Return to bits.3 CVS log

Up to [Research Unix] / researchv10dc / man / man3

Annotation of researchv10dc/man/man3/bits.3, revision 1.1

1.1     ! root        1: .TH BITS 3+
        !             2: .CT 2 datatype
        !             3: .SH NAME
        !             4: bits \- variable length bit strings
        !             5: .SH SYNOPSIS
        !             6: .nf
        !             7: .B "#include <Bits.h>"
        !             8: .PP
        !             9: .B "typedef unsigned long Bits_chunk;"
        !            10: .PP
        !            11: .B "struct Bits {"
        !            12: .B "   Bits() { }"
        !            13: .B "   Bits(Bits_chunk, unsigned = 1);"
        !            14: .B "   Bits(const Bits&)"
        !            15: .B "   ~Bits();
        !            16: .BR "  Bits& operator= (const Bits&);  // " also " = &= |= ^=
        !            17: .BR "  Bits& operator<<= (int);                // " also " >>=
        !            18: .B "   int operator[] (unsigned);"
        !            19: .B "   operator Bits_chunk();"
        !            20: .B "   unsigned size();"
        !            21: .B "   unsigned size(unsigned);"
        !            22: .B "   Bits& compl();"
        !            23: .B "   Bits& concat(const Bits&);"
        !            24: .B "   Bits& set(unsigned, unsigned long = 1);"
        !            25: .B "   Bits& reset(unsigned);"
        !            26: .B "   Bits& compl(unsigned);"
        !            27: .B "   unsigned count();"
        !            28: .B "   unsigned signif();"
        !            29: .B "   unsigned trim();"
        !            30: .B "};"
        !            31: .PP
        !            32: .B "Bits operator~ (const Bits&);
        !            33: .BR "Bits operator& (const Bits&, const Bits&); // " also " | ^
        !            34: .BR "Bits operator<< (const Bits&, int);                // " also " >>
        !            35: .BR "int operator< (const Bits&, const Bits&);  // " also " > <= >= == !=
        !            36: .fi
        !            37: .SH DESCRIPTION
        !            38: A
        !            39: .B Bits
        !            40: object contains a variable-length bit string.
        !            41: The bits of a
        !            42: .B Bits
        !            43: object
        !            44: .I b
        !            45: are numbered from 0 through
        !            46: .IB b .size()\fR\-1,\fP
        !            47: with the rightmost bit numbered 0.
        !            48: .PP
        !            49: .B Bits_chunk
        !            50: is the largest unsigned integral type
        !            51: acceptable for conversion to and from
        !            52: .BR Bits ,
        !            53: .BR "unsigned long" 
        !            54: in this implementation.
        !            55: .SS Constructors
        !            56: .TP \w'\fIa\fL.concat(\fIb\fL)\ 'u
        !            57: .B Bits()
        !            58: An empty bit string.
        !            59: .TP
        !            60: .BI Bits( n )
        !            61: The bits are copied from the binary representation of
        !            62: .I n
        !            63: with the ones-digit of
        !            64: .I n
        !            65: becoming bit 0.
        !            66: Leading zero-bits are removed,
        !            67: except that
        !            68: .B Bits(0)
        !            69: is a one-bit string.
        !            70: .TP
        !            71: .BI Bits( n , m )
        !            72: The same, but padded with leading zeros to size
        !            73: .I m
        !            74: if necessary.
        !            75: .SS Operators
        !            76: Bit strings have
        !            77: value semantics;
        !            78: assigning a
        !            79: .B Bits
        !            80: object or passing it to or returning it from a function
        !            81: creates a copy of its value.
        !            82: The meanings of operators are mostly predictable from C.
        !            83: .PP
        !            84: Under binary and comparison operators,
        !            85: the shorter operand
        !            86: is considered to be padded on the left with zeros to the
        !            87: length of the longer.
        !            88: If, after padding, two strings of different length compare equal,
        !            89: the shorter is deemed the smaller.
        !            90: .PP
        !            91: Negative shift amounts
        !            92: reverse the sense of shift operators.
        !            93: .PP
        !            94: Under conversion (or assignment) to a
        !            95: .BR Bits_chunk ,
        !            96: a
        !            97: .B Bits
        !            98: is interpreted as an unsigned integer.
        !            99: If it has a value small enough to fit,
        !           100: that value is assigned.
        !           101: Otherwise, a non-zero value is
        !           102: assigned.
        !           103: Thus a
        !           104: .B Bits
        !           105: is considered `true' in an
        !           106: .B if
        !           107: test if it contains any one-bit, `false' otherwise.
        !           108: .TP \w'\fIa\fL.concat(\fIb\fL)\ 'u
        !           109: .IB a [ s ]
        !           110: Bit number
        !           111: .I s
        !           112: of
        !           113: .IR a ;
        !           114: 0 if
        !           115: .I s
        !           116: is out of bounds.
        !           117: .SS Other functions
        !           118: .TP \w'\fIa\fL.concat(\fIb\fL)\ 'u
        !           119: .IB a .size( s )
        !           120: Set the size of
        !           121: .I a
        !           122: to
        !           123: .I s
        !           124: by truncating or padding with zeros on the left as necessary.
        !           125: Return the new size.
        !           126: .TP
        !           127: .IB a .compl()
        !           128: Complement the bits of
        !           129: .I a.
        !           130: Return
        !           131: .I a.
        !           132: .TP
        !           133: .IB a .set( s )
        !           134: .PD 0
        !           135: .TP
        !           136: .IB a .reset( s )
        !           137: .TP
        !           138: .IB a .compl ( s )
        !           139: Set, reset, or complement bit
        !           140: .I s
        !           141: of
        !           142: .I a.
        !           143: No effect if
        !           144: .IB a .size()<= s.
        !           145: Return
        !           146: .I a.
        !           147: .PD
        !           148: .TP
        !           149: .IB a .set( s , n )
        !           150: If
        !           151: .I n
        !           152: is 0, reset bit
        !           153: .I s
        !           154: of
        !           155: .I a,
        !           156: otherwise set bit
        !           157: .I s.
        !           158: Equivalent to
        !           159: .BR "n? a.set(s): a.reset(s)" .
        !           160: .TP
        !           161: .IB a .count()
        !           162: Return the number of one-bits in
        !           163: .I a.
        !           164: .TP
        !           165: .IB a .signif()
        !           166: Return the number of significant bits in
        !           167: .BR a :
        !           168: one more than the
        !           169: number of the leftmost one-bit, or
        !           170: zero if there is no one-bit.
        !           171: .TP
        !           172: .IB a .trim()
        !           173: Discard high-order zero-bits.
        !           174: Equivalent to
        !           175: .BR a.size(a.signif()) .
        !           176: .TP
        !           177: .IB a .concat( b )
        !           178: Concatenate the value of
        !           179: .I b
        !           180: to the right (low-order) end of
        !           181: .I a.
        !           182: Return
        !           183: .I a.
        !           184: .TP
        !           185: .BI concat( a , b )
        !           186: Return a newly created concatenated object.
        !           187: .SH DIAGNOSTICS
        !           188: An operation that runs out of memory sets
        !           189: the length of the affected
        !           190: .B Bits
        !           191: to zero.
        !           192: .SH BUGS
        !           193: Too bad C++ can't support
        !           194: .BR "a[s] = n" .
        !           195: .br
        !           196: Things would be more consistent if
        !           197: .B Bits(0).size()
        !           198: were zero.

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.