BitVecClear

Function
August 22, 2025

Table of Contents

`BitVecClear`

Description

Clear all bits in bitvector without deallocating memory. Sets length to 0 but keeps allocated capacity.

Parameters

Name	Direction	Description
`bv`	in	Pointer to bitvector to clear

Usage example (from documentation)

  BitVecClear(&flags);

Usage example (Cross-references)

In BitVec.c:49:

    }
    
    void BitVecClear(BitVec *bitvec) {
    ValidateBitVec(bitvec);
    bitvec->length = 0;

In BitVec.c:873:

    if (positions >= bv->length) {
    // Shift everything out
    BitVecClear(bv);
    return;
    }

In BitVec.c:897:

    if (positions >= bv->length) {
    // Shift everything out
    BitVecClear(bv);
    return;
    }

In BitVec.Foreach.c:255:

    
    // Test foreach on large data
    BitVecClear(&bv);
    for (int i = 0; i < 1000; i++) {
    BitVecPush(&bv, i % 2 == 0);

In BitVec.Foreach.c:294:

    
    // Test foreach idx ordering
    BitVecClear(&bv);
    for (int i = 0; i < 10; i++) {
    BitVecPush(&bv, i % 2 == 0);

In BitVec.Foreach.c:332:

    
    // Test reverse ordering
    BitVecClear(&bv);
    BitVecPush(&bv, true);                          // idx 0
    BitVecPush(&bv, false);                         // idx 1

In BitVec.Foreach.c:603:

    
    // Test with complex random-like pattern
    BitVecClear(&large_bv);
    
    // Pattern: 1111000011100010000111 (variable length runs)

In BitVec.Init.c:104:

    // Test BitVecClear function
    bool test_bitvec_clear(void) {
    printf("Testing BitVecClear\n");
    
    BitVec bv = BitVecInit();

In BitVec.Init.c:119:

    
    // Clear the bitvector
    BitVecClear(&bv);
    
    // Check that length is 0 but capacity and memory allocation remain

In BitVec.Init.c:263:

    
    bool test_bitvec_clear_edge_cases(void) {
    printf("Testing BitVecClear edge cases\n");
    
    BitVec bv     = BitVecInit();

In BitVec.Init.c:269:

    
    // Test clear on empty bitvec
    BitVecClear(&bv);
    result = result && (bv.length == 0);

In BitVec.Init.c:274:

    // Test clear after single bit
    BitVecPush(&bv, true);
    BitVecClear(&bv);
    result = result && (bv.length == 0);

In BitVec.Init.c:278:

    
    // Test multiple clears
    BitVecClear(&bv);
    BitVecClear(&bv);
    result = result && (bv.length == 0);

In BitVec.Init.c:279:

    // Test multiple clears
    BitVecClear(&bv);
    BitVecClear(&bv);
    result = result && (bv.length == 0);

In BitVec.Init.c:286:

    BitVecPush(&bv, i % 2);
    }
    BitVecClear(&bv);
    result = result && (bv.length == 0);

In BitVec.Memory.c:211:

    // Test shrink after reserve and clear
    BitVecReserve(&bv, 1000);
    BitVecClear(&bv);
    BitVecShrinkToFit(&bv);
    result = result && (bv.length == 0);

In BitVec.Memory.c:231:

    // Test set capacity to 0
    // BitVecReserve doesn't support shrinking to 0, use BitVecClear instead
    BitVecClear(&bv);
    result = result && (bv.length == 0);

In BitVec.Memory.c:278:

    
    // Test swap with large data
    BitVecClear(&bv1);
    for (int i = 0; i < 1000; i++) {
    BitVecPush(&bv1, i % 3 == 0);

In BitVec.Memory.c:316:

    
    // Test clone large data
    BitVecClear(&bv);
    for (int i = 0; i < 1000; i++) {
    BitVecPush(&bv, i % 2 == 0);

In BitVec.Access.Simple.c:222:

    
    // Test all same bits
    BitVecClear(&bv);
    for (int i = 0; i < 100; i++) {
    BitVecPush(&bv, true);

In BitVec.Access.Simple.c:400:

    
    // Test all ones
    BitVecClear(&bv);
    for (int i = 0; i < 64; i++) {
    BitVecPush(&bv, true);

In BitVec.Access.Simple.c:408:

    
    // Test checkerboard pattern
    BitVecClear(&bv);
    for (int i = 0; i < 64; i++) {
    BitVecPush(&bv, i % 2 == 0);

In BitVec.Access.Simple.c:416:

    
    // Test sparse pattern (every 8th bit)
    BitVecClear(&bv);
    for (int i = 0; i < 64; i++) {
    BitVecPush(&bv, i % 8 == 0);

In BitVec.Access.Simple.c:424:

    
    // Test random-like pattern (using simple algorithm)
    BitVecClear(&bv);
    for (int i = 0; i < 100; i++) {
    BitVecPush(&bv, (i * 17 + 3) % 7 < 3); // Pseudo-random pattern

In BitVec.Access.Simple.c:460:

    
    // Test with all same values
    BitVecClear(&bv);
    for (int i = 0; i < 5; i++) {
    BitVecPush(&bv, true);

In BitVec.Access.Simple.c:492:

    
    // Test with all false
    BitVecClear(&bv);
    for (int i = 0; i < 5; i++) {
    BitVecPush(&bv, false);

In BitVec.Access.Simple.c:504:

    
    // Test with mixed values
    BitVecClear(&bv);
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);

In BitVec.Access.Simple.c:538:

    
    // Test with all same values
    BitVecClear(&bv);
    for (int i = 0; i < 10; i++) {
    BitVecPush(&bv, true);

In BitVec.Access.Simple.c:546:

    
    // Test alternating pattern
    BitVecClear(&bv);
    for (int i = 0; i < 10; i++) {
    BitVecPush(&bv, i % 2 == 0);

In BitVec.Access.Simple.c:578:

    
    // Test with large bitvector
    BitVecClear(&bv);
    for (int i = 0; i < 1000; i++) {
    BitVecPush(&bv, i == 500 || i == 999); // Only indices 500 and 999 are true

In BitVec.Access.Simple.c:612:

    
    // Test large bitvector with specific patterns
    BitVecClear(&bv);
    for (int i = 0; i < 1000; i++) {
    BitVecPush(&bv, true); // All true

In BitVec.Access.Simple.c:646:

    
    // Test large runs
    BitVecClear(&bv);
    for (int i = 0; i < 10000; i++) {
    BitVecPush(&bv, true);

In BitVec.Insert.c:211:

    
    // Test large range insertion
    BitVecClear(&bv);
    BitVecInsertRange(&bv, 0, 1000, true);
    result = result && (bv.length == 1000);

In BitVec.Insert.c:239:

    
    // Test inserting large bitvec
    BitVecClear(&source);
    for (int i = 0; i < 500; i++) {
    BitVecPush(&source, false);

In BitVec.Insert.c:269:

    
    // Test inserting 8-bit pattern
    BitVecClear(&bv);
    BitVecInsertPattern(&bv, 0, 0xAA, 8);            // 10101010 pattern
    result = result && (bv.length == 8);

In BitVec.Remove.c:300:

    
    // Test remove entire bitvec
    BitVecClear(&bv);
    for (int i = 0; i < 10; i++) {
    BitVecPush(&bv, i % 2 == 0);

In BitVec.Remove.c:338:

    
    // Test remove single occurrence
    BitVecClear(&bv);
    BitVecPush(&bv, false);
    found  = BitVecRemoveFirst(&bv, false);

In BitVec.Remove.c:371:

    
    // Test remove all of uniform data
    BitVecClear(&bv);
    for (int i = 0; i < 100; i++) {
    BitVecPush(&bv, true);

In BitVec.BitWise.c:360:

    
    // Test large data shift
    BitVecClear(&bv);
    for (int i = 0; i < 1000; i++) {
    BitVecPush(&bv, i % 2 == 0);

In BitVec.BitWise.c:423:

    
    // Test NOT on various sizes
    BitVecClear(&bv1);
    BitVecNot(&result_bv, &bv1);
    result = result && (result_bv.length == 0);

In BitVec.BitWise.c:455:

    
    // Test reverse even length
    BitVecClear(&bv);
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);

In BitVec.BitWise.c:503:

    
    // Test with single bit operands
    BitVecClear(&bv1);
    BitVecClear(&bv2);
    BitVecPush(&bv1, true);

In BitVec.BitWise.c:504:

    // Test with single bit operands
    BitVecClear(&bv1);
    BitVecClear(&bv2);
    BitVecPush(&bv1, true);
    BitVecPush(&bv2, false);

In BitVec.BitWise.c:516:

    
    // Test NOT on large bitvector
    BitVecClear(&bv1);
    for (int i = 0; i < 100; i++) {
    BitVecPush(&bv1, i % 3 == 0);

In BitVec.BitWise.c:569:

    
    // Test shifting by exactly length (should clear everything)
    BitVecClear(&bv);
    for (int i = 0; i < 8; i++) {
    BitVecPush(&bv, true);

In BitVec.BitWise.c:578:

    
    // Test shifting by more than length
    BitVecClear(&bv);
    for (int i = 0; i < 5; i++) {
    BitVecPush(&bv, true);

In BitVec.BitWise.c:587:

    
    // Test boundary conditions - shift by length-1
    BitVecClear(&bv);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);

In BitVec.BitWise.c:645:

    
    // Test rotate with odd length
    BitVecClear(&bv);
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);

In BitVec.BitWise.c:722:

    
    // Test A AND 0 = 0
    BitVecClear(&bv2);
    for (int i = 0; i < 16; i++) {
    BitVecPush(&bv2, false);

In BitVec.BitWise.c:738:

    
    // Test A OR 1 = 1
    BitVecClear(&bv2);
    for (int i = 0; i < 16; i++) {
    BitVecPush(&bv2, true);

In BitVec.BitWise.c:863:

    
    // Test shift on large data
    BitVecClear(&result);
    for (int i = 0; i < 1000; i++) {
    BitVecPush(&result, i % 2 == 0);

In BitVec.BitWise.Simple.c:360:

    
    // Test large data shift
    BitVecClear(&bv);
    for (int i = 0; i < 1000; i++) {
    BitVecPush(&bv, i % 2 == 0);

In BitVec.BitWise.Simple.c:423:

    
    // Test NOT on various sizes
    BitVecClear(&bv1);
    BitVecNot(&result_bv, &bv1);
    result = result && (result_bv.length == 0);

In BitVec.BitWise.Simple.c:455:

    
    // Test reverse even length
    BitVecClear(&bv);
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);

In BitVec.BitWise.Simple.c:503:

    
    // Test with single bit operands
    BitVecClear(&bv1);
    BitVecClear(&bv2);
    BitVecPush(&bv1, true);

In BitVec.BitWise.Simple.c:504:

    // Test with single bit operands
    BitVecClear(&bv1);
    BitVecClear(&bv2);
    BitVecPush(&bv1, true);
    BitVecPush(&bv2, false);

In BitVec.BitWise.Simple.c:516:

    
    // Test NOT on large bitvector
    BitVecClear(&bv1);
    for (int i = 0; i < 100; i++) {
    BitVecPush(&bv1, i % 3 == 0);

In BitVec.BitWise.Simple.c:569:

    
    // Test shifting by exactly length (should clear everything)
    BitVecClear(&bv);
    for (int i = 0; i < 8; i++) {
    BitVecPush(&bv, true);

In BitVec.BitWise.Simple.c:578:

    
    // Test shifting by more than length
    BitVecClear(&bv);
    for (int i = 0; i < 5; i++) {
    BitVecPush(&bv, true);

In BitVec.BitWise.Simple.c:587:

    
    // Test boundary conditions - shift by length-1
    BitVecClear(&bv);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);

In BitVec.BitWise.Simple.c:645:

    
    // Test rotate with odd length
    BitVecClear(&bv);
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);

In BitVec.BitWise.Simple.c:722:

    
    // Test A AND 0 = 0
    BitVecClear(&bv2);
    for (int i = 0; i < 16; i++) {
    BitVecPush(&bv2, false);

In BitVec.BitWise.Simple.c:738:

    
    // Test A OR 1 = 1
    BitVecClear(&bv2);
    for (int i = 0; i < 16; i++) {
    BitVecPush(&bv2, true);

In BitVec.BitWise.Simple.c:863:

    
    // Test shift on large data
    BitVecClear(&result);
    for (int i = 0; i < 1000; i++) {
    BitVecPush(&result, i % 2 == 0);

In BitVec.Convert.c:256:

    
    // Test large conversions
    BitVecClear(&bv);
    for (int i = 0; i < 1000; i++) {
    BitVecPush(&bv, i % 2 == 0);

In BitVec.Foreach.Simple.c:255:

    
    // Test foreach on large data
    BitVecClear(&bv);
    for (int i = 0; i < 1000; i++) {
    BitVecPush(&bv, i % 2 == 0);

In BitVec.Foreach.Simple.c:294:

    
    // Test foreach idx ordering
    BitVecClear(&bv);
    for (int i = 0; i < 10; i++) {
    BitVecPush(&bv, i % 2 == 0);

In BitVec.Foreach.Simple.c:332:

    
    // Test reverse ordering
    BitVecClear(&bv);
    BitVecPush(&bv, true);                          // idx 0
    BitVecPush(&bv, false);                         // idx 1

In BitVec.Foreach.Simple.c:603:

    
    // Test with complex random-like pattern
    BitVecClear(&large_bv);
    
    // Pattern: 1111000011100010000111 (variable length runs)

In BitVec.Pattern.Simple.c:114:

    
    // Pattern 2: Single bit pattern
    BitVecClear(&pattern);
    BitVecPush(&pattern, true);
    index  = BitVecFindPattern(&source, &pattern);

In BitVec.Pattern.Simple.c:120:

    
    // Pattern 3: Non-existent pattern
    BitVecClear(&pattern);
    BitVecPush(&pattern, false);
    BitVecPush(&pattern, false);

In BitVec.Pattern.Simple.c:128:

    
    // Pattern 4: Pattern at the end
    BitVecClear(&pattern);
    BitVecPush(&pattern, true);
    BitVecPush(&pattern, false);

In BitVec.Pattern.Simple.c:159:

    
    // Test with pattern that occurs only once
    BitVecClear(&source);
    BitVecClear(&pattern);

In BitVec.Pattern.Simple.c:160:

    // Test with pattern that occurs only once
    BitVecClear(&source);
    BitVecClear(&pattern);
    
    // Source: 110011

In BitVec.Pattern.Simple.c:219:

    
    // Test with non-overlapping pattern
    BitVecClear(&source);
    BitVecClear(&pattern);

In BitVec.Pattern.Simple.c:220:

    // Test with non-overlapping pattern
    BitVecClear(&source);
    BitVecClear(&pattern);
    
    // Source: 110110110

In BitVec.Pattern.Simple.c:256:

    
    // Test pattern longer than source
    BitVecClear(&pattern);
    for (int i = 0; i < 5; i++) {
    BitVecPush(&pattern, true);

In BitVec.Pattern.Simple.c:264:

    
    // Test empty source
    BitVecClear(&source);
    BitVecClear(&pattern);
    BitVecPush(&pattern, true);

In BitVec.Pattern.Simple.c:265:

    // Test empty source
    BitVecClear(&source);
    BitVecClear(&pattern);
    BitVecPush(&pattern, true);
    index  = BitVecFindPattern(&source, &pattern);

In BitVec.Pattern.Simple.c:271:

    
    // Test exact match (pattern same as source)
    BitVecClear(&source);
    BitVecClear(&pattern);
    BitVecPush(&source, true);

In BitVec.Pattern.Simple.c:272:

    // Test exact match (pattern same as source)
    BitVecClear(&source);
    BitVecClear(&pattern);
    BitVecPush(&source, true);
    BitVecPush(&source, false);

In BitVec.Pattern.Simple.c:283:

    
    // Test single bit source and pattern
    BitVecClear(&source);
    BitVecClear(&pattern);
    BitVecPush(&source, true);

In BitVec.Pattern.Simple.c:284:

    // Test single bit source and pattern
    BitVecClear(&source);
    BitVecClear(&pattern);
    BitVecPush(&source, true);
    BitVecPush(&pattern, true);

In BitVec.Pattern.Simple.c:296:

    // Test BitVecFindAllPattern edge cases
    size results[1];
    BitVecClear(&source);
    BitVecClear(&pattern);
    BitVecPush(&source, true);

In BitVec.Pattern.Simple.c:297:

    size results[1];
    BitVecClear(&source);
    BitVecClear(&pattern);
    BitVecPush(&source, true);
    BitVecPush(&pattern, true);

In BitVec.Pattern.Simple.c:377:

    
    // Test non-matching prefix: 101
    BitVecClear(&prefix);
    BitVecPush(&prefix, true);
    BitVecPush(&prefix, false);

In BitVec.Pattern.Simple.c:401:

    
    // Test prefix longer than source
    BitVecClear(&source);
    BitVecPush(&prefix, true);
    BitVecPush(&prefix, false);

In BitVec.Pattern.Simple.c:407:

    
    // Test equal length
    BitVecClear(&source);
    BitVecClear(&prefix);
    BitVecPush(&source, true);

In BitVec.Pattern.Simple.c:408:

    // Test equal length
    BitVecClear(&source);
    BitVecClear(&prefix);
    BitVecPush(&source, true);
    BitVecPush(&source, false);

In BitVec.Pattern.Simple.c:444:

    
    // Test non-matching suffix: 110
    BitVecClear(&suffix);
    BitVecPush(&suffix, true);
    BitVecPush(&suffix, true);

In BitVec.Pattern.Simple.c:468:

    
    // Test suffix longer than source
    BitVecClear(&source);
    BitVecPush(&suffix, true);
    BitVecPush(&suffix, false);

In BitVec.Pattern.Simple.c:503:

    
    // Test non-existing pattern: 000
    BitVecClear(&pattern);
    BitVecPush(&pattern, false);
    BitVecPush(&pattern, false);

In BitVec.Pattern.Simple.c:591:

    
    // Test pattern: 010 (should find 3 occurrences at 1, 3, 5)
    BitVecClear(&pattern);
    BitVecPush(&pattern, false);
    BitVecPush(&pattern, true);

In BitVec.Math.c:71:

    
    // Test completely different bitvectors
    BitVecClear(&bv2);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);

In BitVec.Math.c:80:

    
    // Test partially different bitvectors
    BitVecClear(&bv2);
    BitVecPush(&bv2, true); // Same
    BitVecPush(&bv2, true); // Different

In BitVec.Math.c:114:

    
    // Test one empty, one non-empty
    BitVecClear(&bv2);
    distance = BitVecHammingDistance(&bv1, &bv2);
    result   = result && (distance == 2); // Length of bv1

In BitVec.Math.c:143:

    
    // Test no overlap
    BitVecClear(&bv1);
    BitVecClear(&bv2);
    BitVecPush(&bv1, true);

In BitVec.Math.c:144:

    // Test no overlap
    BitVecClear(&bv1);
    BitVecClear(&bv2);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);

In BitVec.Math.c:154:

    
    // Test partial overlap
    BitVecClear(&bv1);
    BitVecClear(&bv2);
    BitVecPush(&bv1, true);

In BitVec.Math.c:155:

    // Test partial overlap
    BitVecClear(&bv1);
    BitVecClear(&bv2);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, true);

In BitVec.Math.c:218:

    
    // Test orthogonal vectors
    BitVecClear(&bv1);
    BitVecClear(&bv2);
    BitVecPush(&bv1, true);

In BitVec.Math.c:219:

    // Test orthogonal vectors
    BitVecClear(&bv1);
    BitVecClear(&bv2);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);

In BitVec.Math.c:251:

    
    // Test one zero vector
    BitVecClear(&bv2);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);

In BitVec.Math.c:285:

    
    // Test no overlap
    BitVecClear(&bv1);
    BitVecClear(&bv2);
    BitVecPush(&bv1, true);

In BitVec.Math.c:286:

    // Test no overlap
    BitVecClear(&bv1);
    BitVecClear(&bv2);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);

In BitVec.Math.c:347:

    
    // Test single substitution
    BitVecClear(&bv2);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true); // Changed from false

In BitVec.Math.c:356:

    
    // Test insertion
    BitVecClear(&bv2);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);

In BitVec.Math.c:420:

    
    // Test perfect anti-correlation
    BitVecClear(&bv2);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);

In BitVec.Math.c:479:

    
    // Test minimum entropy (all same)
    BitVecClear(&bv);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);

In BitVec.Math.c:531:

    
    // Test perfect mismatch
    BitVecClear(&bv2);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);

In BitVec.Pattern.c:114:

    
    // Pattern 2: Single bit pattern
    BitVecClear(&pattern);
    BitVecPush(&pattern, true);
    index  = BitVecFindPattern(&source, &pattern);

In BitVec.Pattern.c:120:

    
    // Pattern 3: Non-existent pattern
    BitVecClear(&pattern);
    BitVecPush(&pattern, false);
    BitVecPush(&pattern, false);

In BitVec.Pattern.c:128:

    
    // Pattern 4: Pattern at the end
    BitVecClear(&pattern);
    BitVecPush(&pattern, true);
    BitVecPush(&pattern, false);

In BitVec.Pattern.c:159:

    
    // Test with pattern that occurs only once
    BitVecClear(&source);
    BitVecClear(&pattern);

In BitVec.Pattern.c:160:

    // Test with pattern that occurs only once
    BitVecClear(&source);
    BitVecClear(&pattern);
    
    // Source: 110011

In BitVec.Pattern.c:219:

    
    // Test with non-overlapping pattern
    BitVecClear(&source);
    BitVecClear(&pattern);

In BitVec.Pattern.c:220:

    // Test with non-overlapping pattern
    BitVecClear(&source);
    BitVecClear(&pattern);
    
    // Source: 110110110

In BitVec.Pattern.c:256:

    
    // Test pattern longer than source
    BitVecClear(&pattern);
    for (int i = 0; i < 5; i++) {
    BitVecPush(&pattern, true);

In BitVec.Pattern.c:264:

    
    // Test empty source
    BitVecClear(&source);
    BitVecClear(&pattern);
    BitVecPush(&pattern, true);

In BitVec.Pattern.c:265:

    // Test empty source
    BitVecClear(&source);
    BitVecClear(&pattern);
    BitVecPush(&pattern, true);
    index  = BitVecFindPattern(&source, &pattern);

In BitVec.Pattern.c:271:

    
    // Test exact match (pattern same as source)
    BitVecClear(&source);
    BitVecClear(&pattern);
    BitVecPush(&source, true);

In BitVec.Pattern.c:272:

    // Test exact match (pattern same as source)
    BitVecClear(&source);
    BitVecClear(&pattern);
    BitVecPush(&source, true);
    BitVecPush(&source, false);

In BitVec.Pattern.c:283:

    
    // Test single bit source and pattern
    BitVecClear(&source);
    BitVecClear(&pattern);
    BitVecPush(&source, true);

In BitVec.Pattern.c:284:

    // Test single bit source and pattern
    BitVecClear(&source);
    BitVecClear(&pattern);
    BitVecPush(&source, true);
    BitVecPush(&pattern, true);

In BitVec.Pattern.c:296:

    // Test BitVecFindAllPattern edge cases
    size results[1];
    BitVecClear(&source);
    BitVecClear(&pattern);
    BitVecPush(&source, true);

In BitVec.Pattern.c:297:

    size results[1];
    BitVecClear(&source);
    BitVecClear(&pattern);
    BitVecPush(&source, true);
    BitVecPush(&pattern, true);

In BitVec.Pattern.c:493:

    
    // Test non-matching prefix: 101
    BitVecClear(&prefix);
    BitVecPush(&prefix, true);
    BitVecPush(&prefix, false);

In BitVec.Pattern.c:517:

    
    // Test prefix longer than source
    BitVecClear(&source);
    BitVecPush(&prefix, true);
    BitVecPush(&prefix, false);

In BitVec.Pattern.c:523:

    
    // Test equal length
    BitVecClear(&source);
    BitVecClear(&prefix);
    BitVecPush(&source, true);

In BitVec.Pattern.c:524:

    // Test equal length
    BitVecClear(&source);
    BitVecClear(&prefix);
    BitVecPush(&source, true);
    BitVecPush(&source, false);

In BitVec.Pattern.c:560:

    
    // Test non-matching suffix: 110
    BitVecClear(&suffix);
    BitVecPush(&suffix, true);
    BitVecPush(&suffix, true);

In BitVec.Pattern.c:584:

    
    // Test suffix longer than source
    BitVecClear(&source);
    BitVecPush(&suffix, true);
    BitVecPush(&suffix, false);

In BitVec.Pattern.c:619:

    
    // Test non-existing pattern: 000
    BitVecClear(&pattern);
    BitVecPush(&pattern, false);
    BitVecPush(&pattern, false);

In BitVec.Pattern.c:707:

    
    // Test pattern: 010 (should find 3 occurrences at 1, 3, 5)
    BitVecClear(&pattern);
    BitVecPush(&pattern, false);
    BitVecPush(&pattern, true);

In BitVec.Access.c:146:

    
    // Clear and check empty
    BitVecClear(&bv);
    result = result && BitVecEmpty(&bv);
    result = result && (BitVecLen(&bv) == 0);

In BitVec.Access.c:176:

    
    // Test with all ones
    BitVecClear(&bv);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);

In BitVec.Access.c:202:

    
    // Test with large data set
    BitVecClear(&bv);
    for (int i = 0; i < 1000; i++) {
    BitVecPush(&bv, i % 3 == 0);

In BitVec.Access.c:267:

    result = result && (BitVecCountZeros(&bv) == 0);
    
    BitVecClear(&bv);
    BitVecPush(&bv, false);
    result = result && (BitVecCountOnes(&bv) == 0);

In BitVec.Access.c:273:

    
    // Test count with large uniform data
    BitVecClear(&bv);
    for (int i = 0; i < 1000; i++) {
    BitVecPush(&bv, true);

In BitVec.Access.c:370:

    
    // Test with exactly power-of-2 sizes
    BitVecClear(&bv);
    for (int i = 0; i < 64; i++) { // Exactly 64 bits
    BitVecPush(&bv, true);

In BitVec.Access.c:451:

    
    // Test checkerboard pattern
    BitVecClear(&bv);
    for (int i = 0; i < 100; i++) {
    BitVecPush(&bv, i % 2 == 0);

In BitVec.Access.c:466:

    
    // Test Fibonacci-like pattern (each bit is XOR of previous two)
    BitVecClear(&bv);
    BitVecPush(&bv, true); // F(0) = 1
    BitVecPush(&bv, true); // F(1) = 1

In BitVec.Access.c:647:

    
    // Test with all same values
    BitVecClear(&bv);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);

In BitVec.Access.c:681:

    
    // Test with all false bits
    BitVecClear(&bv);
    BitVecPush(&bv, false);
    BitVecPush(&bv, false);

In BitVec.Access.c:694:

    
    // Test with mixed bits
    BitVecClear(&bv);
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);

In BitVec.Access.c:740:

    
    // Test with all same values
    BitVecClear(&bv);
    for (int i = 0; i < 10; i++) {
    BitVecPush(&bv, true);

In BitVec.Access.c:748:

    
    // Test alternating pattern
    BitVecClear(&bv);
    for (int i = 0; i < 10; i++) {
    BitVecPush(&bv, i % 2 == 0);

In BitVec.Access.c:780:

    
    // Test with large bitvector
    BitVecClear(&bv);
    for (int i = 0; i < 1000; i++) {
    BitVecPush(&bv, i == 500 || i == 999); // Only indices 500 and 999 are true

In BitVec.Access.c:814:

    
    // Test large bitvector with specific patterns
    BitVecClear(&bv);
    for (int i = 0; i < 1000; i++) {
    BitVecPush(&bv, true); // All true

In BitVec.Access.c:848:

    
    // Test large runs
    BitVecClear(&bv);
    for (int i = 0; i < 10000; i++) {
    BitVecPush(&bv, true);

In BitVec.Compare.c:94:

    
    // Test first greater than second
    BitVecClear(&bv1);
    BitVecClear(&bv2);

In BitVec.Compare.c:95:

    // Test first greater than second
    BitVecClear(&bv1);
    BitVecClear(&bv2);
    
    BitVecPush(&bv1, true);

In BitVec.Compare.c:133:

    
    // Test equal bitvectors
    BitVecClear(&bv2);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);

In BitVec.Compare.c:169:

    
    // Test equal values
    BitVecClear(&bv2);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);

In BitVec.Compare.c:205:

    
    // Test equal weights
    BitVecClear(&bv2);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true);

In BitVec.Compare.c:247:

    
    // Test equal sets (should be subset)
    BitVecClear(&superset);
    BitVecPush(&superset, true);
    BitVecPush(&superset, false);

In BitVec.Compare.c:284:

    
    // Test two positives
    BitVecClear(&bv2);
    // bv2: 001 (positive 1)
    BitVecPush(&bv2, true);

In BitVec.Compare.c:333:

    
    // Test equal sets (should be superset)
    BitVecClear(&superset);
    BitVecPush(&superset, true);
    BitVecPush(&superset, false);

In BitVec.Compare.c:372:

    
    // Test non-overlapping bitvectors
    BitVecClear(&bv2);
    // bv2: 0101 (complement of bv1)
    BitVecPush(&bv2, false);

In BitVec.Compare.c:421:

    
    // Test with empty bitvectors
    BitVecClear(&bv1);
    BitVecClear(&bv2);
    result = result && BitVecDisjoint(&bv1, &bv2);

In BitVec.Compare.c:422:

    // Test with empty bitvectors
    BitVecClear(&bv1);
    BitVecClear(&bv2);
    result = result && BitVecDisjoint(&bv1, &bv2);
    result = result && !BitVecOverlaps(&bv1, &bv2);

In BitVec.Compare.c:587:

    
    // Test all zeros
    BitVecClear(&bv);
    for (int i = 0; i < 5; i++) {
    BitVecPush(&bv, false);

In BitVec.Compare.c:594:

    
    // Test all ones
    BitVecClear(&bv);
    for (int i = 0; i < 5; i++) {
    BitVecPush(&bv, true);

In BitVec.Compare.c:624:

    
    // Test large identical bitvecs
    BitVecClear(&bv1);
    BitVecClear(&bv2);
    for (int i = 0; i < 1000; i++) {

In BitVec.Compare.c:625:

    // Test large identical bitvecs
    BitVecClear(&bv1);
    BitVecClear(&bv2);
    for (int i = 0; i < 1000; i++) {
    bool bit = i % 3 == 0;

In BitVec.Compare.c:634:

    
    // Test subset operations on empty sets
    BitVecClear(&bv1);
    BitVecClear(&bv2);
    result = result && BitVecIsSubset(&bv1, &bv2); // Empty is subset of empty

In BitVec.Compare.c:635:

    // Test subset operations on empty sets
    BitVecClear(&bv1);
    BitVecClear(&bv2);
    result = result && BitVecIsSubset(&bv1, &bv2); // Empty is subset of empty

In BitVec.Compare.c:660:

    
    // Test large sets
    BitVecClear(&bv1);
    BitVecClear(&bv2);
    for (int i = 0; i < 1000; i++) {

In BitVec.Compare.c:661:

    // Test large sets
    BitVecClear(&bv1);
    BitVecClear(&bv2);
    for (int i = 0; i < 1000; i++) {
    BitVecPush(&bv1, i % 2 == 0);

BitVecClear

`BitVecClear`

Description

Parameters

Usage example (from documentation)

Usage example (Cross-references)

Tags :

Share :

Related Posts

BitVecReplaceAll

BitVecMatches

BitVecDeinit