BitVecClear

Documentation

API Reference

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)

Usage examples (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.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.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.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.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.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.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);

In BitVec.Init.c:104:

    // Test BitVecClear function
    bool test_bitvec_clear(void) {
        WriteFmt("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) {
        WriteFmt("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.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.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.Convert.c:256:

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

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.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.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.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.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 Init.h:56:

    static inline void IntClear(Int *value) {
        ValidateInt(value);
        BitVecClear(&value->bits);
    }

Last updated on April 20, 2026

BitVecCapacity BitVecClone