info > Bit::Vector

Che Dong

📖 NAME

Bit::Vector — Efficient bit vector, set of integers and "big int" math library

🚀 Quick Reference

Use Case	Command	Description
📦 Create a bit vector	`Bit::Vector->new($bits)`	Create a new bit vector of given size, all bits cleared
🔢 Create from hex string	`Bit::Vector->new_Hex($bits,$string)`	Create and initialize from hexadecimal string
🔢 Create from binary string	`Bit::Vector->new_Bin($bits,$string)`	Create and initialize from binary string
🔢 Create from decimal string	`Bit::Vector->new_Dec($bits,$string)`	Create and initialize from decimal string
🔢 Create from enumeration	`Bit::Vector->new_Enum($bits,$string)`	Create and initialize from "2,3,5-7" style string
📏 Get size	`$vector->Size()`	Return number of bits in the vector
✂️ Resize	`$vector->Resize($bits)`	Change size, preserving lower bits
📋 Clone	`$vec2 = $vec1->Clone()`	Create exact duplicate
📋 Shadow	`$vec2 = $vec1->Shadow()`	Create same-size empty vector
📝 Copy	`$vec2->Copy($vec1)`	Copy contents (sign extension if larger)
🧹 Empty	`$vector->Empty()`	Clear all bits
🧹 Fill	`$vector->Fill()`	Set all bits
🔄 Flip	`$vector->Flip()`	Complement all bits
🔍 Test bit	`$vector->bit_test($index)`	Return 0/1 for bit at index
🔍 Contains	`$vector->contains($index)`	Same as bit_test
✏️ Set bit	`$vector->Bit_On($index)`	Set bit at index to 1
✏️ Clear bit	`$vector->Bit_Off($index)`	Set bit at index to 0
✏️ Flip bit	`$vector->bit_flip($index)`	Toggle bit, return new state
✏️ Copy bit	`$vector->Bit_Copy($index,$bit)`	Set bit to given boolean
🔢 Convert to hex	`$string = $vector->to_Hex()`	Return hexadecimal string
🔢 Import from hex	`$vector->from_Hex($string)`	Read from hex string
🔢 Convert to binary	`$string = $vector->to_Bin()`	Return binary string
🔢 Import from binary	`$vector->from_Bin($string)`	Read from binary string
🔢 Convert to decimal	`$string = $vector->to_Dec()`	Return decimal string (signed)
🔢 Import from decimal	`$vector->from_Dec($string)`	Read from decimal string
🔢 Convert to enumeration	`$string = $vector->to_Enum()`	Return "2,3,5-7" style string
🔢 Import from enumeration	`$vector->from_Enum($string)`	Read from enumeration string
➕ Increment	`$carry = $vector->increment()`	Add 1 to vector (unsigned)
➖ Decrement	`$carry = $vector->decrement()`	Subtract 1 (unsigned)
➕ Add	`$vec3->add($vec1,$vec2,$carry)`	Add with carry, returns (carry,overflow)
➖ Subtract	`$vec3->subtract($vec1,$vec2,$carry)`	Subtract with carry
✖️ Multiply	`$vec3->Multiply($vec1,$vec2)`	Multiply (signed), result may be larger
➗ Divide	`$quot->Divide($vec1,$vec2,$rest)`	Divide, get quotient and remainder
🔢 Negate	`$vec2->Neg($vec1)`	Two's complement negation
🔢 Absolute	`$vec2->Abs($vec1)`	Absolute value
🔢 Compare (unsigned)	`$vec1->Lexicompare($vec2)`	Return -1,0,1
🔢 Compare (signed)	`$vec1->Compare($vec2)`	Return -1,0,1
🔢 Equality	`$vec1->equal($vec2)`	Return boolean
🔢 Is empty	`$vector->is_empty()`	True if all bits zero
🔢 Is full	`$vector->is_full()`	True if all bits one
🔢 Rotate left	`$carry = $vector->rotate_left()`	Circular shift left through carry
🔢 Rotate right	`$carry = $vector->rotate_right()`	Circular shift right through carry
🔢 Shift left	`$carry = $vector->shift_left($carry_in)`	Shift left, feed carry
🔢 Shift right	`$carry = $vector->shift_right($carry_in)`	Shift right, feed carry
🔢 Move left (multiple bits)	`$vector->Move_Left($bits)`	Shift left by $bits positions
🔢 Move right	`$vector->Move_Right($bits)`	Shift right by $bits positions
🔢 Insert bits	`$vector->Insert($offset,$bits)`	Insert cleared bits at offset, lose top bits
🔢 Delete bits	`$vector->Delete($offset,$bits)`	Remove bits at offset, zeros at top
🔢 Interval empty	`$vector->Interval_Empty($min,$max)`	Clear range of bits
🔢 Interval fill	`$vector->Interval_Fill($min,$max)`	Set range of bits
🔢 Interval flip	`$vector->Interval_Flip($min,$max)`	Complement range
🔢 Interval reverse	`$vector->Interval_Reverse($min,$max)`	Reverse bit order in range
🔍 Scan intervals (ascending)	`($min,$max) = $vector->Interval_Scan_inc($start)`	Find next block of set bits upward
🔍 Scan intervals (descending)	`($min,$max) = $vector->Interval_Scan_dec($start)`	Find next block of set bits downward
📋 Interval copy	`$vec2->Interval_Copy($vec1,$off2,$off1,$len)`	Copy a stretch of bits between vectors
📋 Interval substitute (splice)	`$vec2->Interval_Substitute($vec1,$off2,$len2,$off1,$len1)`	Replace/insert/delete bits, auto-resize
🔢 Block store (binary)	`$vector->Block_Store($buffer)`	Load vector from binary string (low byte first)
🔢 Block read	`$buffer = $vector->Block_Read()`	Export vector as binary string
🔢 Word store (machine-dependent)	`$vector->Word_Store($offset,$word)`	Store a machine word at given offset
🔢 Word read	`$word = $vector->Word_Read($offset)`	Read a machine word
🔢 Chunk store (portable)	`$vector->Chunk_Store($chunksize,$offset,$chunk)`	Store a chunk of bits (1 to Long_Bits)
🔢 Chunk read	`$chunk = $vector->Chunk_Read($chunksize,$offset)`	Read a chunk of bits
🔢 Prime sieve	`$vector->Primes()`	Set bits at prime indices
🔢 Reverse	`$vec2->Reverse($vec1)`	Reverse the order of all bits
🔢 Set operations (union)	`$vec3->Or($vec1,$vec2)`	Bitwise OR
🔢 Intersection	`$vec3->And($vec1,$vec2)`	Bitwise AND
🔢 Difference	`$vec3->AndNot($vec1,$vec2)`	Bitwise AND NOT
🔢 Symmetric difference	`$vec3->Xor($vec1,$vec2)`	Bitwise XOR
🔢 Complement	`$vec2->Not($vec1)`	Bitwise NOT
🔢 Subset test	`$set1->subset($set2)`	True if all bits of set1 are in set2
🔢 Norm (population count)	`$norm = $set->Norm()`	Number of set bits
🔢 Min/Max	`$min = $set->Min(); $max = $set->Max()`	Smallest/largest index with set bit
🔢 GCD	`$vecgcd->GCD($veca,$vecb)`	Greatest Common Divisor
🔢 Power	`$vec3->Power($vec1,$vec2)`	Exponentiation (base**exp)
🔢 Matrix multiplication (XOR)	`$m3->Multiplication(...)`	Boolean matrix multiplication (XOR sum)
🔢 Matrix product (OR)	`$m3->Product(...)`	Boolean matrix multiplication (OR sum)
🔢 Transitive closure	`$matrix->Closure($rows,$cols)`	Reflexive transitive closure (Kleene)
🔢 Transpose	`$matrix2->Transpose(...)`	Transpose a boolean matrix

📋 SYNOPSIS

🔀 OVERLOADED OPERATORS

See Bit::Vector::Overload(3).

📥 MORE STRING IMPORT/EXPORT

See Bit::Vector::String(3).

🏷️ CLASS METHODS

$version = Bit::Vector->Version(); — Returns version number
$bits = Bit::Vector->Word_Bits(); — Number of bits in a machine word (unsigned int)
$bits = Bit::Vector->Long_Bits(); — Number of bits in an unsigned long
$vector = Bit::Vector->new($bits); — Constructor, creates vector with $bits bits (cleared)
@veclist = Bit::Vector->new($bits,$count); — Create multiple vectors
$vector = Bit::Vector->new_Hex($bits,$string); — Constructor from hex
$vector = Bit::Vector->new_Bin($bits,$string); — Constructor from binary
$vector = Bit::Vector->new_Dec($bits,$string); — Constructor from decimal
$vector = Bit::Vector->new_Enum($bits,$string); — Constructor from enumeration
$vector = Bit::Vector->Concat_List(@vectors); — Concatenate list of vectors

🔧 OBJECT METHODS

$vec2 = $vec1->new($bits); — Alternative constructor call
@veclist = $vec->new($bits,$count); — Multiple vectors via object
$vec2 = $vec1->Shadow(); — Same size, empty vector
$vec2 = $vec1->Clone(); — Exact duplicate
$vector = $vec1->Concat($vec2); — Concatenate two vectors
$vector = $vec1->Concat_List($vec2,$vec3,...); — Concatenate list
$bits = $vector->Size(); — Number of bits
$vector->Resize($bits); — Change size
$vec2->Copy($vec1); — Copy with sign extension
$vector->Empty(); — Clear all bits
$vector->Fill(); — Set all bits
$vector->Flip(); — Complement all bits
$vector->Primes(); — Sieve of Eratosthenes
$vec2->Reverse($vec1); — Reverse bit order
$vector->Interval_Empty($min,$max); — Clear range
$vector->Interval_Fill($min,$max); — Set range
$vector->Interval_Flip($min,$max); — Flip range
$vector->Interval_Reverse($min,$max); — Reverse range
($min,$max) = $vector->Interval_Scan_inc($start) — Next set block upward
($min,$max) = $vector->Interval_Scan_dec($start) — Next set block downward
$vec2->Interval_Copy($vec1,$offset2,$offset1,$length); — Copy interval
$vec2->Interval_Substitute($vec1,$off2,$len2,$off1,$len1); — Splice-like operation
$vector->is_empty() — Boolean: all bits zero
$vector->is_full() — Boolean: all bits one
$vec1->equal($vec2) — Boolean: equality
$vec1->Lexicompare($vec2) — Unsigned comparison (-1,0,1)
$vec1->Compare($vec2) — Signed comparison
$string = $vector->to_Hex() — Export hex
$vector->from_Hex($string) — Import hex
$string = $vector->to_Bin() — Export binary
$vector->from_Bin($string) — Import binary
$string = $vector->to_Dec() — Export decimal (signed)
$vector->from_Dec($string) — Import decimal
$string = $vector->to_Enum() — Export enumeration
$vector->from_Enum($string) — Import enumeration
$vector->Bit_Off($index); — Clear bit
$vector->Bit_On($index); — Set bit
$bit = $vector->bit_flip($index) — Flip bit, return new state
$bit = $vector->bit_test($index) — Test bit
$vector->Bit_Copy($index,$bit); — Copy boolean to bit
$vector->LSB($bit); — Set least significant bit
$vector->MSB($bit); — Set most significant bit
$bit = $vector->lsb(); — Get LSB
$bit = $vector->msb(); — Get MSB
$carry = $vector->rotate_left(); — Left rotate through carry
$carry = $vector->rotate_right(); — Right rotate
$carry = $vector->shift_left($carry_in); — Left shift with carry in
$carry = $vector->shift_right($carry_in); — Right shift
$vector->Move_Left($bits); — Shift left by $bits positions
$vector->Move_Right($bits); — Shift right by $bits positions
$vector->Insert($offset,$bits); — Insert cleared bits, lose top bits
$vector->Delete($offset,$bits); — Delete bits, zeros at top
$carry = $vector->increment(); — Add 1 (unsigned)
$carry = $vector->decrement(); — Subtract 1 (unsigned)
$overflow = $vec2->inc($vec1); — Increment copy
$overflow = $vec2->dec($vec1); — Decrement copy
$carry = $vec3->add($vec1,$vec2,$carry); — Add with carry
$carry = $vec3->subtract($vec1,$vec2,$carry); — Subtract with carry
$vec2->Neg($vec1); — Two's complement negation
$vec2->Abs($vec1); — Absolute value
$sign = $vector->Sign(); — Return -1,0,1
$vec3->Multiply($vec1,$vec2); — Multiplication (signed)
$quot->Divide($vec1,$vec2,$rest); — Division, quotient and remainder
$vecgcd->GCD($veca,$vecb); — Greatest Common Divisor
$vecgcd->GCD($vecx,$vecy,$veca,$vecb); — GCD with linear combination
$vec3->Power($vec1,$vec2); — Exponentiation
$vector->Block_Store($buffer); — Load from binary string
$buffer = $vector->Block_Read(); — Export as binary string
$size = $vector->Word_Size(); — Number of machine words
$vector->Word_Store($offset,$word); — Store a word
$word = $vector->Word_Read($offset); — Read a word
$vector->Word_List_Store(@words); — Store list of words
@words = $vector->Word_List_Read(); — Read list of words
$vector->Word_Insert($offset,$count); — Insert words
$vector->Word_Delete($offset,$count); — Delete words
$vector->Chunk_Store($chunksize,$offset,$chunk); — Store a chunk
$chunk = $vector->Chunk_Read($chunksize,$offset); — Read a chunk
$vector->Chunk_List_Store($chunksize,@chunks); — Store list of chunks
@chunks = $vector->Chunk_List_Read($chunksize); — Read list of chunks
$vector->Index_List_Remove(@indices); — Turn off bits at indices
$vector->Index_List_Store(@indices); — Turn on bits at indices
@indices = $vector->Index_List_Read(); — List of indices with set bits
$vec3->Or($vec1,$vec2); — Union (bitwise OR)
$vec3->And($vec1,$vec2); — Intersection (AND)
$vec3->AndNot($vec1,$vec2); — Difference (AND NOT)
$vec3->Xor($vec1,$vec2); — Symmetric difference (XOR)
$vec2->Not($vec1); — Complement (NOT)
$set1->subset($set2) — Subset test
$norm = $set->Norm(); — Population count (byte lookup)
$norm = $set->Norm2(); — Population count (min-set/cleared)
$norm = $set->Norm3(); — Population count (per set bit)
$min = $set->Min(); — Minimum index with set bit
$max = $set->Max(); — Maximum index with set bit
$m3->Multiplication($r3,$c3,$m1,$r1,$c1,$m2,$r2,$c2); — Boolean matrix multiplication (XOR)
$m3->Product($r3,$c3,$m1,$r1,$c1,$m2,$r2,$c2); — Boolean matrix multiplication (OR)
$matrix->Closure($rows,$cols); — Reflexive transitive closure
$matrix2->Transpose($rows2,$cols2,$matrix1,$rows1,$cols1); — Transpose matrix

⚠️ IMPORTANT NOTES

🔤 Method naming conventions: Methods in all lowercase return boolean values (except new()).
✅ Boolean values: Always numeric 0 (false) or 1 (true).
➖ Negative numbers: All numeric input parameters are treated as UNSIGNED. Passing a negative number will cause "index out of range" errors.
🔢 Bit order: Bit vectors are stored least significant bit first. Machine words are stored least order byte first when using Block_Read()/Block_Store(). Binary/hex strings have LSB at right.
💻 "Word" related methods: Methods starting with Word_ are MACHINE-DEPENDENT. Use Chunk_ methods for portability (chunk size ≤ 32 bits).
📏 Chunk sizes: Legal range 1 to Long_Bits(). For portability, use ≤ 32 bits.
📐 Matching sizes: Most methods require all bit vector arguments to have identical sizes. Exceptions: Concat, Concat_List, Copy, Interval_Copy, Interval_Substitute, Multiply (result may be larger), Power (result ≥ base).
🔢 Index ranges: All indices must be between 0 and $vector->Size()-1.
💾 Object persistence: Since version 6.5, Bit::Vector objects can be serialized with Storable automatically.

📖 DESCRIPTION

🔀 OVERLOADED OPERATORS

See Bit::Vector::Overload(3).

📥 MORE STRING IMPORT/EXPORT

See Bit::Vector::String(3).

🏷️ CLASS METHODS

$version = Bit::Vector->Version(); — Returns version number.
$bits = Bit::Vector->Word_Bits(); — Number of bits in an unsigned int (machine word).
$bits = Bit::Vector->Long_Bits(); — Number of bits in an unsigned long.
$vector = Bit::Vector->new($bits); — Creates a new bit vector of given size, all bits cleared. Zero-length vectors are permitted. Raises exception on memory failure.
@veclist = Bit::Vector->new($bits,$count); — Creates multiple vectors. Returns empty list if $count=0.
$vector = Bit::Vector->new_Hex($bits,$string); — Creates and initializes from hex string. More efficient than separate new() and from_Hex().
$vector = Bit::Vector->new_Bin($bits,$string); — Creates and initializes from binary string.
$vector = Bit::Vector->new_Dec($bits,$string); — Creates and initializes from decimal string.
$vector = Bit::Vector->new_Enum($bits,$string); — Creates and initializes from enumeration string (e.g., "2,3,5-7").
$vector = Bit::Vector->Concat_List(@vectors); — Concatenates all vectors. Rightmost becomes least significant. Empty list returns empty vector.

🔧 OBJECT METHODS

$vec2 = $vec1->new($bits); — Alternative constructor call, $vec1 is unused.
$vec2 = $vec1->Shadow(); — Creates new vector of same size, all zeros.
$vec2 = $vec1->Clone(); — Creates exact duplicate.
$vector = $vec1->Concat($vec2); — Concatenates $vec1 (most significant) and $vec2 (least significant).
$vector = $vec1->Concat_List($vec2,$vec3,...); — Concatenates list.
$bits = $vector->Size(); — Returns number of bits.
$vector->Resize($bits); — Changes size, preserving lower bits. May reuse memory. Zero-length permitted.
$vec2->Copy($vec1); — Copies contents with sign extension if target larger. If source larger, truncates lower bits.
$vector->Empty(); — Clears all bits.
$vector->Fill(); — Sets all bits.
$vector->Flip(); — Complements all bits.
$vector->Primes(); — Sets bits at prime indices using Sieve of Eratosthenes.
$vec2->Reverse($vec1); — Reverses bit order.
$vector->Interval_Empty($min,$max); — Clears bits in range [min,max].
$vector->Interval_Fill($min,$max); — Sets bits in range.
$vector->Interval_Flip($min,$max); — Flips bits in range.
$vector->Interval_Reverse($min,$max); — Reverses bit order in range.
($min,$max) = $vector->Interval_Scan_inc($start) — Returns next contiguous block of set bits starting from $start upward. Returns empty list if none.
($min,$max) = $vector->Interval_Scan_dec($start) — Same but searches downward.
$vec2->Interval_Copy($vec1,$offset2,$offset1,$length); — Copies a stretch of bits from $vec1 to $vec2. Length auto-truncated if out of bounds. Handles overlapping intervals.
$vec2->Interval_Substitute($vec1,$off2,$len2,$off1,$len1); — Splice operation: replaces interval in $vec2 with interval from $vec1. Automatically resizes $vec2. If $len1=0: delete interval. If $len2=0: insert. In-place possible.
$vector->is_empty() — Returns true if all bits are zero (or length zero).
$vector->is_full() — Returns true if all bits are one. For length zero returns false.
$vec1->equal($vec2) — Returns true if vectors are identical.
$vec1->Lexicompare($vec2) — Unsigned comparison: returns -1, 0, or 1.
$vec1->Compare($vec2) — Signed comparison.
$string = $vector->to_Hex() — Returns hexadecimal string (LSB at right).
$vector->from_Hex($string) — Reads from hex string. Too-short string clears remaining bits. Too-long string ignores extra characters. Syntax error on invalid characters.
$string = $vector->to_Bin() — Returns binary string (LSB at right).
$vector->from_Bin($string) — Reads from binary string. Same truncation behavior as from_Hex.
$string = $vector->to_Dec() — Returns decimal string (signed). Uses divide-and-conquer for speed. Beware: large positive numbers may appear negative if MSB set.
$vector->from_Dec($string) — Reads decimal string (signed). Overflow error if number doesn't fit. Use eval to catch errors.
$string = $vector->to_Enum() — Returns enumeration string (e.g., "2,3,5-7").
$vector->from_Enum($string) — Parses enumeration string. Indices and ranges may overlap. Syntax error on invalid characters.
$vector->Bit_Off($index); — Clears bit at index.
$vector->Bit_On($index); — Sets bit.
$bit = $vector->bit_flip($index) — Flips bit, returns new state.
$bit = $vector->bit_test($index) — Returns 0 or 1.
$vector->Bit_Copy($index,$bit); — Sets bit to given boolean.
$vector->LSB($bit); — Sets least significant bit.
$vector->MSB($bit); — Sets most significant bit.
$bit = $vector->lsb(); — Returns LSB.
$bit = $vector->msb(); — Returns MSB.
$carry = $vector->rotate_left(); — Rotates left through carry. LSB moves to MSB? Actually: LSB becomes carry, carry becomes MSB? Wait, diagram shows LSB becomes carry, MSB becomes LSB? The diagram: LSB carry, MSB rotate_right(); — Rotates right.
$carry = $vector->shift_left($carry_in); — Shifts left, LSB gets carry_in, MSB becomes carry_out.
$carry = $vector->shift_right($carry_in); — Shifts right, MSB gets carry_in, LSB becomes carry_out.
$vector->Move_Left($bits); — Shifts left by $bits positions, losing top bits, inserting zeros at bottom. If $bits >= size, vector becomes zero.
$vector->Move_Right($bits); — Shifts right by $bits positions, losing bottom bits, inserting zeros at top.
$vector->Insert($offset,$bits); — Inserts $bits cleared bits at $offset, shifting existing bits up, losing top $bits bits. Does not grow vector.
$vector->Delete($offset,$bits); — Removes $bits bits at $offset, shifting remaining bits down, zeros at top. Does not shrink.
$carry = $vector->increment(); — Increments (unsigned). Returns carry if overflow.
$carry = $vector->decrement(); — Decrements (unsigned). Returns carry if underflow.
$overflow = $vec2->inc($vec1); — Increments a copy, returns overflow flag.
$overflow = $vec2->dec($vec1); — Decrements a copy.
$carry = $vec3->add($vec1,$vec2,$carry); — Addition with carry. In list context returns (carry, overflow). Overflow is true if sign is wrong due to carry.
$carry = $vec3->subtract($vec1,$vec2,$carry); — Subtraction with carry. Returns (carry, overflow) in list context.
$vec2->Neg($vec1); — Two's complement negation. Beware: negating 2^(n-1) yields itself.
$vec2->Abs($vec1); — Absolute value. Same caveat for 2^(n-1).
$sign = $vector->Sign(); — Returns 0 if zero, -1 if negative, 1 if positive.
$vec3->Multiply($vec1,$vec2); — Signed multiplication. Result vector may be larger than factors. Overflow error if result doesn't fit.
$quot->Divide($vec1,$vec2,$rest); — Signed division. $quot and $rest must be distinct. Division by zero error.
$vecgcd->GCD($veca,$vecb); — Greatest Common Divisor (Euclid's algorithm).
$vecgcd->GCD($vecx,$vecy,$veca,$vecb); — Extended GCD: finds x,y such that GCD = x*a + y*b.
$vec3->Power($vec1,$vec2); — Exponentiation: $vec1 ** $vec2. $vec3 must be same size as base or larger. $vec2 must be positive.
$vector->Block_Store($buffer); — Loads vector from binary string (low byte first).
$buffer = $vector->Block_Read(); — Exports vector as binary string.
$size = $vector->Word_Size(); — Number of machine words.
$vector->Word_Store($offset,$word); — Stores a word at offset.
$word = $vector->Word_Read($offset); — Reads a word.
$vector->Word_List_Store(@words); — Stores list of words (first becomes least significant).
@words = $vector->Word_List_Read(); — Reads all words.
$vector->Word_Insert($offset,$count); — Inserts $count cleared words at offset, loses top words.
$vector->Word_Delete($offset,$count); — Deletes words at offset, zeros at top.
$vector->Chunk_Store($chunksize,$offset,$chunk); — Stores a chunk of bits (1..Long_Bits).
$chunk = $vector->Chunk_Read($chunksize,$offset); — Reads a chunk.
$vector->Chunk_List_Store($chunksize,@chunks); — Fills vector with list of chunks.
@chunks = $vector->Chunk_List_Read($chunksize); — Reads vector as list of chunks. Beware of large lists.
$vector->Index_List_Remove(@indices); — Turns off bits at given indices. Does not clear vector first.
$vector->Index_List_Store(@indices); — Turns on bits at indices. Does not clear vector first.
@indices = $vector->Index_List_Read(); — Returns list of indices of set bits (ascending). Beware of large lists.
$vec3->Or($vec1,$vec2); — Union (bitwise OR).
$vec3->And($vec1,$vec2); — Intersection (AND).
$vec3->AndNot($vec1,$vec2); — Difference (AND NOT).
$vec3->Xor($vec1,$vec2); — Symmetric difference (XOR).
$vec2->Not($vec1); — Complement (NOT).
$set1->subset($set2) — Returns true if $set1 is subset of $set2.
$norm = $set->Norm(); — Returns number of set bits (byte lookup table).
$norm = $set->Norm2(); — Population count using min(set, cleared bits).
$norm = $set->Norm3(); — Population count per set bit (slow for dense).
$min = $set->Min(); — Smallest index with set bit, or MAX_LONG if empty.
$max = $set->Max(); — Largest index with set bit, or MIN_LONG if empty.
$m3->Multiplication($r3,$c3,$m1,$r1,$c1,$m2,$r2,$c2); — Boolean matrix multiplication (XOR as addition).
$m3->Product($r3,$c3,$m1,$r1,$c1,$m2,$r2,$c2); — Boolean matrix multiplication (OR as addition).
$matrix->Closure($rows,$cols); — Reflexive transitive closure (Kleene's algorithm). Modifies matrix in place.
$matrix2->Transpose($rows2,$cols2,$matrix1,$rows1,$cols1); — Transpose matrix. In-place only if quadratic.

📚 SEE ALSO

Bit::Vector::Overload(3), Bit::Vector::String(3), Storable(3).

Set::IntRange(3), Math::MatrixBool(3), Math::MatrixReal(3), DFA::Kleene(3), Math::Kleene(3), Graph::Kruskal(3).

📌 VERSION

This document describes Bit::Vector version 7.4.

👤 AUTHOR

Steffen Beyer
STBEY@cpan.org
http://www.engelschall.com/u/sb/download/

©️ COPYRIGHT

📄 LICENSE

This package is free software; you can redistribute it and/or modify it under the same terms as Perl itself, i.e., under the terms of the "Artistic License" or the "GNU General Public License".

The C library at the core of this Perl module can additionally be redistributed and/or modified under the terms of the "GNU Library General Public License".

⚠️ DISCLAIMER

This package is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Generated by phpman v4.9.26-1-g511901d Author: Che Dong Under GNU General Public License
2026-08-09 09:21 @2600:1f28:365:80b0:50b3:453e:ff52:20f7
CrawledBy CCBot/2.0 (https://commoncrawl.org/faq/)

Enhanced by LLM: deepseek-v4-flash / taotoken.net / www.chedong.com - original format