man > Bit::Vector

🏷️ NAME

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

🚀 Quick Reference

Use Case	Command	Description
📦 Create a new bit vector	Bit::Vector->new($bits)	Create a new bit vector with $bits bits, all cleared.
🔢 Create from hex string	Bit::Vector->new_Hex($bits, $hex)	Create and initialize from hexadecimal string.
🔘 Set a single bit	$vec->Bit_On($index)	Set bit at $index to 1.
🔘 Clear a single bit	$vec->Bit_Off($index)	Set bit at $index to 0.
🔍 Test a bit	$vec->bit_test($index)	Return 1 if bit is set, 0 otherwise.
🔗 Bitwise OR (Union)	$vec3->Or($vec1, $vec2)	Compute bitwise OR of two vectors.
🔗 Bitwise AND (Intersection)	$vec3->And($vec1, $vec2)	Compute bitwise AND of two vectors.
🔗 Bitwise NOT (Complement)	$vec2->Not($vec1)	Compute bitwise complement (flip all bits).
➕ Arithmetic addition	$vec3->add($vec1, $vec2, $carry)	Add two numbers with carry, store result.
➖ Arithmetic subtraction	$vec3->subtract($vec1, $vec2, $carry)	Subtract two numbers with borrow.
✖️ Multiplication	$vec3->Multiply($vec1, $vec2)	Multiply two signed numbers.
🔢 Convert to hex string	$vec->to_Hex()	Return hexadecimal representation.
🔢 Convert from hex string	$vec->from_Hex($hex)	Load vector from hexadecimal string.
📏 Get size	$vec->Size()	Return number of bits in vector.
📐 Resize	$vec->Resize($bits)	Change size, preserving as many bits as possible.

📋 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(); — Bits in a machine word (unsigned int).
• $bits = Bit::Vector->Long_Bits(); — Bits in an unsigned long.
• $vector = Bit::Vector->new($bits); — Bit vector constructor.
• @veclist = Bit::Vector->new($bits, $count); — Create multiple vectors.
• $vector = Bit::Vector->new_Hex($bits, $string); — Constructor with hex init.
• $vector = Bit::Vector->new_Bin($bits, $string); — Constructor with binary init.
• $vector = Bit::Vector->new_Dec($bits, $string); — Constructor with decimal init.
• $vector = Bit::Vector->new_Enum($bits, $string); — Constructor with enumeration init.
• $vector = Bit::Vector->Concat_List(@vectors); — Concatenate multiple vectors.

🧰 OBJECT METHODS

• $vec2 = $vec1->new($bits); — Alternative constructor call.
• @veclist = $vec->new($bits, $count); — Alternative multiple constructor.
• $vec2 = $vec1->Shadow(); — New vector, same size, empty.
• $vec2 = $vec1->Clone(); — Exact duplicate.
• $vector = $vec1->Concat($vec2); — Concatenate two vectors.
• $vector = $vec1->Concat_List($vec2, $vec3, ...); — Concatenate multiple.
• $bits = $vector->Size(); — Number of bits.
• $vector->Resize($bits); — Change size.
• $vec2->Copy($vec1); — Copy contents.
• $vector->Empty(); — Clear all bits.
• $vector->Fill(); — Set all bits.
• $vector->Flip(); — Complement all bits.
• $vector->Primes(); — Sieve of Eratosthenes: set bits at prime indices.
• $vec2->Reverse($vec1); — Reverse order of bits.
• $vector->Interval_Empty($min, $max); — Clear bit range.
• $vector->Interval_Fill($min, $max); — Set bit range.
• $vector->Interval_Flip($min, $max); — Complement bit range.
• $vector->Interval_Reverse($min, $max); — Reverse bit range.
• ($min, $max) = $vector->Interval_Scan_inc($start); — Find next block of set bits (ascending).
• ($min, $max) = $vector->Interval_Scan_dec($start); — Find next block of set bits (descending).
• $vec2->Interval_Copy($vec1, $offset2, $offset1, $length); — Copy bit range.
• $vec2->Interval_Substitute($vec1, $off2, $len2, $off1, $len1); — Splice-like operation.
• if ($vector->is_empty()) — Test if all bits cleared.
• if ($vector->is_full()) — Test if all bits set.
• if ($vec1->equal($vec2)) — Equality test.
• $cmp = $vec1->Lexicompare($vec2); — Unsigned comparison.
• $cmp = $vec1->Compare($vec2); — Signed comparison.
• $string = $vector->to_Hex(); — Convert to hex string.
• $vector->from_Hex($string); — Load from hex string.
• $string = $vector->to_Bin(); — Convert to binary string.
• $vector->from_Bin($string); — Load from binary string.
• $string = $vector->to_Dec(); — Convert to decimal string.
• $vector->from_Dec($string); — Load from decimal string.
• $string = $vector->to_Enum(); — Convert to enumeration string (e.g., "2,3,5-7").
• $vector->from_Enum($string); — Load from enumeration string.
• $vector->Bit_Off($index); — Clear single bit.
• $vector->Bit_On($index); — Set single bit.
• $bit = $vector->bit_flip($index); — Flip single bit, return new state.
• $bit = $vector->bit_test($index); — Test single bit.
• $vector->Bit_Copy($index, $bit); — Set single bit to 0 or 1.
• $vector->LSB($bit); — Set least significant bit.
• $vector->MSB($bit); — Set most significant bit.
• $bit = $vector->lsb(); — Get least significant bit.
• $bit = $vector->msb(); — Get most significant bit.
• $carry = $vector->rotate_left(); — Rotate left through carry.
• $carry = $vector->rotate_right(); — Rotate right through carry.
• $carry = $vector->shift_left($carry_in); — Shift left with carry.
• $carry = $vector->shift_right($carry_in); — Shift right with carry.
• $vector->Move_Left($bits); — Shift left by N positions.
• $vector->Move_Right($bits); — Shift right by N positions.
• $vector->Insert($offset, $bits); — Insert bits at offset (size unchanged).
• $vector->Delete($offset, $bits); — Delete bits at offset (size unchanged).
• $carry = $vector->increment(); — Increment (unsigned).
• $carry = $vector->decrement(); — Decrement (unsigned).
• $overflow = $vec2->inc($vec1); — Increment and copy.
• $overflow = $vec2->dec($vec1); — Decrement and copy.
• $carry = $vec3->add($vec1, $vec2, $carry); — Addition with carry.
• ($carry, $overflow) = $vec3->add($vec1, $vec2, $carry); — Addition with carry and overflow.
• $carry = $vec3->subtract($vec1, $vec2, $carry); — Subtraction with borrow.
• ($carry, $overflow) = $vec3->subtract($vec1, $vec2, $carry); — Subtraction with borrow and overflow.
• $vec2->Neg($vec1); — Two's complement (negate).
• $vec2->Negate($vec1); — Alias for Neg.
• $vec2->Abs($vec1); — Absolute value.
• $vec2->Absolute($vec1); — Alias for Abs.
• $sign = $vector->Sign(); — Return 0, 1, or -1.
• $vec3->Multiply($vec1, $vec2); — Multiplication (signed).
• $quot->Divide($vec1, $vec2, $rest); — Division and remainder.
• $vecgcd->GCD($veca, $vecb); — Greatest Common Divisor.
• $vecgcd->GCD($vecx, $vecy, $veca, $vecb); — Extended GCD (linear combination).
• $vec3->Power($vec1, $vec2); — Exponentiation.
• $vector->Block_Store($buffer); — Load from binary string (low byte first).
• $buffer = $vector->Block_Read(); — Export to binary string.
• $size = $vector->Word_Size(); — Number of machine words.
• $vector->Word_Store($offset, $word); — Store a machine word.
• $word = $vector->Word_Read($offset); — Read a machine word.
• $vector->Word_List_Store(@words); — Store list of words.
• @words = $vector->Word_List_Read(); — Read all words.
• $vector->Word_Insert($offset, $count); — Insert machine words.
• $vector->Word_Delete($offset, $count); — Delete machine words.
• $vector->Chunk_Store($chunksize, $offset, $chunk); — Store a chunk of bits.
• $chunk = $vector->Chunk_Read($chunksize, $offset); — Read a chunk of bits.
• $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); — Clear bits at indices.
• $vector->Index_List_Store(@indices); — Set bits at indices.
• @indices = $vector->Index_List_Read(); — Get list of set bit indices.
• $vec3->Or($vec1, $vec2); — Bitwise OR (Union).
• $set3->Union($set1, $set2); — Alias.
• $vec3->And($vec1, $vec2); — Bitwise AND (Intersection).
• $set3->Intersection($set1, $set2); — Alias.
• $vec3->AndNot($vec1, $vec2); — Bitwise AND NOT (Difference).
• $set3->Difference($set1, $set2); — Alias.
• $vec3->Xor($vec1, $vec2); — Bitwise XOR (Symmetric difference).
• $set3->ExclusiveOr($set1, $set2); — Alias.
• $vec2->Not($vec1); — Bitwise NOT (Complement).
• $set2->Complement($set1); — Alias.
• if ($set1->subset($set2)) — Subset test.
• $norm = $set->Norm(); — Count set bits (fast).
• $norm = $set->Norm2(); — Count set bits (alternative).
• $norm = $set->Norm3(); — Count set bits (sparse).
• $min = $set->Min(); — Minimum index of set bit.
• $max = $set->Max(); — Maximum index of set bit.
• $m3->Multiplication($r3, $c3, $m1, $r1, $c1, $m2, $r2, $c2); — Boolean matrix multiplication (XOR addition).
• $m3->Product($r3, $c3, $m1, $r1, $c1, $m2, $r2, $c2); — Boolean matrix multiplication (OR addition).
• $matrix->Closure($rows, $cols); — Reflexive transitive closure (Kleene).
• $matrix2->Transpose($rows2, $cols2, $matrix1, $rows1, $cols1); — Matrix transpose.

⚠️ IMPORTANT NOTES

• 🔹 Method naming conventions: Names in all lowercase indicate boolean return value. (Except new().)
• 🔹 Boolean values: Always numeric 0 (false) and 1 (true).
• 🔹 Negative numbers: All numeric input parameters are treated as unsigned. Negative numbers become large positive due to two's complement.
• 🔹 Bit order: Bits stored least order bit and word first. Block_Read()/Block_Store() use "least order byte first" for portability. In hex/binary strings, rightmost bit is least significant.
• 🔹 Word-related methods: Word_* are machine-dependent! Use Chunk_* with chunk size ≤ 32 bits for portability.
• 🔹 Chunk sizes: Legal range 1 to Bit::Vector->Long_Bits(). For portability, use ≤ 32.
• 🔹 Matching sizes: Most methods require all vector arguments to have identical size. Exceptions: Concat(), Concat_List(), Copy(), Interval_Copy(), Interval_Substitute(). Multiply() allows result vector to be larger. Power() result must be same size or larger than 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 the current version number of this module.
• 🔹 $bits = Bit::Vector->Word_Bits(); — Returns the number of bits of an unsigned int (machine word) on your machine.
• 🔹 $bits = Bit::Vector->Long_Bits(); — Returns the number of bits of an unsigned long on your machine.
• 🔹 $vector = Bit::Vector->new($bits); — Bit vector constructor. Creates a new vector with $bits bits, all cleared. $bits = 0 is permitted. An exception is raised if memory allocation fails.
• 🔹 @veclist = Bit::Vector->new($bits, $count); — Creates a list of $count bit vectors, all with $bits bits and cleared. Returns empty list if $count = 0.
• 🔹 $vector = Bit::Vector->new_Hex($bits, $string); — Alternative constructor: creates vector and initializes from hex string. More efficient than separate new() + from_Hex(). Raises exception on memory or syntax error.
• 🔹 $vector = Bit::Vector->new_Bin($bits, $string); — Constructor with binary string initialization.
• 🔹 $vector = Bit::Vector->new_Dec($bits, $string); — Constructor with decimal string initialization.
• 🔹 $vector = Bit::Vector->new_Enum($bits, $string); — Constructor with enumeration string initialization (e.g., "2,3,5-7").
• 🔹 $vector = Bit::Vector->Concat_List(@vectors); — Creates a new vector by concatenating all given vectors. Rightmost vector becomes least significant part. Empty list returns zero-length vector.

🧰 OBJECT METHODS

• 🔹 $vec2 = $vec1->new($bits); — Alternative way to call constructor, using an existing vector as anchor.
• 🔹 @veclist = $vec->new($bits, $count); — Same for multiple vectors.
• 🔹 $vec2 = $vec1->Shadow(); — Creates a new vector of the same size but empty.
• 🔹 $vec2 = $vec1->Clone(); — Creates an exact duplicate.
• 🔹 $vector = $vec1->Concat($vec2); — Concatenates $vec1 (most significant) and $vec2 (least significant).
• 🔹 $vector = $vec1->Concat_List($vec2, $vec3, ...); — Concatenates all arguments.
• 🔹 $bits = $vector->Size(); — Returns the size (number of bits).
• 🔹 $vector->Resize($bits); — Changes size, preserving as many bits as will fit. May reuse memory if same number of words. Raises exception on memory failure.
• 🔹 $vec2->Copy($vec1); — Copies $vec1 into $vec2 (both must exist). Handles sign extension if source larger or smaller.
• 🔹 $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 (LSB ↔ MSB). In-place supported.
• 🔹 $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); — Complements bits in range.
• 🔹 $vector->Interval_Reverse($min, $max); — Reverses order of bits in range.
• 🔹 ($min, $max) = $vector->Interval_Scan_inc($start); — Finds next contiguous block of set bits starting from $start (ascending). Returns empty list if none.
• 🔹 ($min, $max) = $vector->Interval_Scan_dec($start); — Same, descending.
• 🔹 $vec2->Interval_Copy($vec1, $offset2, $offset1, $length); — Copies a stretch of bits from $vec1 to $vec2. Length is automatically adjusted if out of bounds.
• 🔹 $vec2->Interval_Substitute($vec1, $off2, $len2, $off1, $len1); — Splice-like operation: replaces a stretch in $vec2 with a stretch from $vec1, automatically resizing $vec2. If $len1=0, deletes; if $len2=0, inserts.
• 🔹 if ($vector->is_empty()) — Returns true if all bits are cleared (zero). Also true for zero-length vector.
• 🔹 if ($vector->is_full()) — Returns true if all bits are set (-1). False for zero-length.
• 🔹 if ($vec1->equal($vec2)) — Returns true if vectors are identical.
• 🔹 $cmp = $vec1->Lexicompare($vec2); — Compares unsigned numbers: -1, 0, 1.
• 🔹 $cmp = $vec1->Compare($vec2); — Compares signed numbers: -1, 0, 1.
• 🔹 $string = $vector->to_Hex(); — Returns hex string (LSB at right).
• 🔹 $vector->from_Hex($string); — Loads from hex string; extra digits ignored, missing digits zero-filled.
• 🔹 $string = $vector->to_Bin(); — Returns binary string (LSB at right).
• 🔹 $vector->from_Bin($string); — Loads from binary string.
• 🔹 $string = $vector->to_Dec(); — Returns decimal string (signed). May be slow for large numbers.
• 🔹 $vector->from_Dec($string); — Loads from decimal string (signed). Raises overflow if number too large.
• 🔹 $string = $vector->to_Enum(); — Returns enumeration string like "2,3,5-7".
• 🔹 $vector->from_Enum($string); — Loads from enumeration string (indices and ranges).
• 🔹 $vector->Bit_Off($index); — Clears single bit.
• 🔹 $vector->Bit_On($index); — Sets single bit.
• 🔹 $bit = $vector->bit_flip($index); — Flips single bit, returns new state.
• 🔹 $bit = $vector->bit_test($index); — Returns state of bit (0 or 1).
• 🔹 $vector->Bit_Copy($index, $bit); — Sets bit to 0 or 1.
• 🔹 $vector->LSB($bit); — Sets least significant bit.
• 🔹 $vector->MSB($bit); — Sets most significant bit.
• 🔹 $bit = $vector->lsb(); — Returns least significant bit.
• 🔹 $bit = $vector->msb(); — Returns most significant bit.
• 🔹 $carry = $vector->rotate_left(); — Rotates left through carry (MSB moves to LSB via carry).
• 🔹 $carry = $vector->rotate_right(); — Rotates right through carry.
• 🔹 $carry = $vector->shift_left($carry_in); — Shifts left, LSB filled with $carry_in, MSB becomes new carry.
• 🔹 $carry = $vector->shift_right($carry_in); — Shifts right, MSB filled with $carry_in, LSB becomes new carry.
• 🔹 $vector->Move_Left($bits); — Shifts left by $bits positions, inserts zeros at LSB, discards MSB bits.
• 🔹 $vector->Move_Right($bits); — Shifts right by $bits positions, inserts zeros at MSB, discards LSB bits.
• 🔹 $vector->Insert($offset, $bits); — Inserts $bits empty bits at offset, shifting higher bits up, losing top bits. Does not change size.
• 🔹 $vector->Delete($offset, $bits); — Removes $bits at offset, shifting higher bits down, clearing top bits. Does not change size.
• 🔹 $carry = $vector->increment(); — Increments (unsigned). Returns carry if overflow.
• 🔹 $carry = $vector->decrement(); — Decrements (unsigned). Returns carry if underflow.
• 🔹 $overflow = $vec2->inc($vec1); — Copies $vec1 to $vec2, increments copy, returns overflow flag.
• 🔹 $overflow = $vec2->dec($vec1); — Copies $vec1 to $vec2, decrements copy, returns overflow flag.
• 🔹 $carry = $vec3->add($vec1, $vec2, $carry); — Addition with carry. In list context returns (carry, overflow).
• 🔹 $carry = $vec3->subtract($vec1, $vec2, $carry); — Subtraction with borrow. In list context returns (carry, overflow).
• 🔹 $vec2->Neg($vec1); — Two's complement (negate).
• 🔹 $vec2->Negate($vec1); — Alias.
• 🔹 $vec2->Abs($vec1); — Absolute value.
• 🔹 $vec2->Absolute($vec1); — Alias.
• 🔹 $sign = $vector->Sign(); — Returns 0 if zero, -1 if negative, 1 if positive.
• 🔹 $vec3->Multiply($vec1, $vec2); — Multiplication (signed). Result vector may be larger than factors.
• 🔹 $quot->Divide($vec1, $vec2, $rest); — Division and remainder (signed). $quot and $rest must be distinct.
• 🔹 $vecgcd->GCD($veca, $vecb); — Greatest Common Divisor (Euclid's algorithm).
• 🔹 $vecgcd->GCD($vecx, $vecy, $veca, $vecb); — Extended GCD, returns coefficients x, y such that GCD = x*a + y*b.
• 🔹 $vec3->Power($vec1, $vec2); — Exponentiation (base^exponent). Result must be same size or larger than base. Exponent must be positive.
• 🔹 $vector->Block_Store($buffer); — Loads bit vector from binary string (little-endian byte order).
• 🔹 $buffer = $vector->Block_Read(); — Exports bit vector to binary string (little-endian).
• 🔹 $size = $vector->Word_Size(); — Number of machine words (machine-dependent).
• 🔹 $vector->Word_Store($offset, $word); — Stores a machine word at offset.
• 🔹 $word = $vector->Word_Read($offset); — Reads a machine word at offset.
• 🔹 $vector->Word_List_Store(@words); — Stores list of words (LSB first).
• 🔹 @words = $vector->Word_List_Read(); — Reads all words (LSB first).
• 🔹 $vector->Word_Insert($offset, $count); — Inserts $count empty words, losing top words.
• 🔹 $vector->Word_Delete($offset, $count); — Deletes $count words, clearing top words.
• 🔹 $vector->Chunk_Store($chunksize, $offset, $chunk); — Stores a chunk of bits (up to Long_Bits).
• 🔹 $chunk = $vector->Chunk_Read($chunksize, $offset); — Reads a chunk of bits.
• 🔹 $vector->Chunk_List_Store($chunksize, @chunks); — Stores list of chunks (LSB first).
• 🔹 @chunks = $vector->Chunk_List_Read($chunksize); — Reads list of chunks.
• 🔹 $vector->Index_List_Remove(@indices); — Clears bits at given indices.
• 🔹 $vector->Index_List_Store(@indices); — Sets bits at given indices.
• 🔹 @indices = $vector->Index_List_Read(); — Returns list of indices of set bits (ascending).
• 🔹 $vec3->Or($vec1, $vec2); — Bitwise OR (union).
• 🔹 $set3->Union($set1, $set2); — Alias.
• 🔹 $vec3->And($vec1, $vec2); — Bitwise AND (intersection).
• 🔹 $set3->Intersection($set1, $set2); — Alias.
• 🔹 $vec3->AndNot($vec1, $vec2); — Bitwise AND NOT (difference).
• 🔹 $set3->Difference($set1, $set2); — Alias.
• 🔹 $vec3->Xor($vec1, $vec2); — Bitwise XOR (symmetric difference).
• 🔹 $set3->ExclusiveOr($set1, $set2); — Alias.
• 🔹 $vec2->Not($vec1); — Bitwise NOT (complement).
• 🔹 $set2->Complement($set1); — Alias.
• 🔹 if ($set1->subset($set2)) — Returns true if $set1 is subset of $set2.
• 🔹 $norm = $set->Norm(); — Counts set bits (fast byte lookup).
• 🔹 $norm = $set->Norm2(); — Counts set bits (alternative algorithm, good for sparse).
• 🔹 $norm = $set->Norm3(); — Counts set bits (original algorithm).
• 🔹 $min = $set->Min(); — Returns minimum index of set bit, or MAX_LONG if empty.
• 🔹 $max = $set->Max(); — Returns maximum index of set bit, or MIN_LONG if empty.
• 🔹 $m3->Multiplication($r3, $c3, $m1, $r1, $c1, $m2, $r2, $c2); — Boolean matrix multiplication (XOR addition).
• 🔹 $m3->Product($r3, $c3, $m1, $r1, $c1, $m2, $r2, $c2); — Boolean matrix multiplication (OR addition).
• 🔹 $matrix->Closure($rows, $cols); — Reflexive transitive closure (Kleene's algorithm). Matrix is modified in place.
• 🔹 $matrix2->Transpose($rows2, $cols2, $matrix1, $rows1, $cols1); — Matrix transpose. In-place allowed 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 man page documents Bit::Vector version 7.4.

👤 AUTHOR

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

©️ COPYRIGHT

Copyright (c) 1995 - 2013 by Steffen Beyer. All rights reserved.

📄 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".

Please refer to the files "Artistic.txt", "GNU_GPL.txt" and "GNU_LGPL.txt" in this distribution for details!

⚠️ 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. See the "GNU General Public License" for more details.