BitVecCountZeros

Documentation

API Reference

BitVecCountZeros

Description

Count number of bits set to 0 in bitvector.

Parameters

Name	Direction	Description
`bv`	in	Bitvector to count zeros in

Usage example (from documentation)

  u64 zeros = BitVecCountZeros(&flags);

Returns

Number of bits set to 0

Usage example (Cross-references)

Usage examples (Cross-references)

In BitVec.c:449:

    }
    
    u64 BitVecCountZeros(BitVec *bitvec) {
        ValidateBitVec(bitvec);
        return bitvec->length - BitVecCountOnes(bitvec);

In BitVec.Access.Simple.c:139:

    
        // Count true and false bits
        bool result = (BitVecCountOnes(&bv) == 3) && (BitVecCountZeros(&bv) == 2);
    
        BitVecDeinit(&bv);

In BitVec.Access.Simple.c:214:

        // Test empty bitvector
        result = result && (BitVecCountOnes(&bv) == 0);
        result = result && (BitVecCountZeros(&bv) == 0);
    
        // Test single bit

In BitVec.Access.Simple.c:219:

        BitVecPush(&bv, true);
        result = result && (BitVecCountOnes(&bv) == 1);
        result = result && (BitVecCountZeros(&bv) == 0);
    
        // Test all same bits

In BitVec.Access.Simple.c:227:

        }
        result = result && (BitVecCountOnes(&bv) == 100);
        result = result && (BitVecCountZeros(&bv) == 0);
    
        BitVecDeinit(&bv);

In BitVec.Access.Simple.c:257:

        // Count and verify
        result = result && (BitVecCountOnes(&bv) == 3);
        result = result && (BitVecCountZeros(&bv) == 2);
    
        // Flip some bits and verify

In BitVec.Access.Simple.c:264:

    
        result = result && (BitVecCountOnes(&bv) == 5);
        result = result && (BitVecCountZeros(&bv) == 0);
    
        BitVecDeinit(&bv);

In BitVec.Access.Simple.c:290:

        // Verify counts
        result = result && (BitVecCountOnes(&bv) == 500);
        result = result && (BitVecCountZeros(&bv) == 500);
    
        // Flip some bits and verify

In BitVec.Access.Simple.c:299:

    
        result = result && (BitVecCountOnes(&bv) == 500);
        result = result && (BitVecCountZeros(&bv) == 500);
    
        BitVecDeinit(&bv);

In BitVec.Access.Simple.c:329:

        // Test count operations
        result = result && (BitVecCountOnes(&bv) == 1);
        result = result && (BitVecCountZeros(&bv) == 1);
    
        BitVecDeinit(&bv);

In BitVec.Access.Simple.c:365:

    
        result = result && (BitVecCountOnes(&bv) == expected_true_count);
        result = result && (BitVecCountZeros(&bv) == (size - expected_true_count));
    
        // Flip every 7th bit

In BitVec.Access.Simple.c:396:

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

In BitVec.Access.Simple.c:405:

        }
        result = result && (BitVecCountOnes(&bv) == 64);
        result = result && (BitVecCountZeros(&bv) == 0);
    
        // Test checkerboard pattern

In BitVec.Access.Simple.c:413:

        }
        result = result && (BitVecCountOnes(&bv) == 32);
        result = result && (BitVecCountZeros(&bv) == 32);
    
        // Test sparse pattern (every 8th bit)

In BitVec.Access.Simple.c:421:

        }
        result = result && (BitVecCountOnes(&bv) == 8);
        result = result && (BitVecCountZeros(&bv) == 56);
    
        // Test random-like pattern (using simple algorithm)

In BitVec.Access.c:173:

        // Test counting
        bool result = (BitVecCountOnes(&bv) == 3);
        result      = result && (BitVecCountZeros(&bv) == 4);
    
        // Test with all ones

In BitVec.Access.c:182:

    
        result = result && (BitVecCountOnes(&bv) == 3);
        result = result && (BitVecCountZeros(&bv) == 0);
    
        // Clean up

In BitVec.Access.c:260:

        // Test count on empty bitvec
        result = result && (BitVecCountOnes(&bv) == 0);
        result = result && (BitVecCountZeros(&bv) == 0);
    
        // Test count with single bit

In BitVec.Access.c:265:

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

In BitVec.Access.c:270:

        BitVecPush(&bv, false);
        result = result && (BitVecCountOnes(&bv) == 0);
        result = result && (BitVecCountZeros(&bv) == 1);
    
        // Test count with large uniform data

In BitVec.Access.c:278:

        }
        result = result && (BitVecCountOnes(&bv) == 1000);
        result = result && (BitVecCountZeros(&bv) == 0);
    
        BitVecDeinit(&bv);

In BitVec.Access.c:435:

    
        result = result && (BitVecCountOnes(&bv) == 0);
        result = result && (BitVecCountZeros(&bv) == 100);
    
        // Verify all bits are false

In BitVec.Access.c:448:

    
        result = result && (BitVecCountOnes(&bv) == 100);
        result = result && (BitVecCountZeros(&bv) == 0);
    
        // Test checkerboard pattern

In BitVec.Access.c:457:

    
        result = result && (BitVecCountOnes(&bv) == 50);
        result = result && (BitVecCountZeros(&bv) == 50);
    
        // Verify checkerboard pattern

Last updated on April 20, 2026

BitVecCountPattern BitVecDeinit