BitVecCountOnes

Documentation

API Reference

BitVecCountOnes

Description

Count number of bits set to 1 in bitvector.

Parameters

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

Usage example (from documentation)

  u64 ones = BitVecCountOnes(&flags);

Success

Returns the number of bits set to 1. The bitvector is not modified. Returns 0 for an empty bitvector.

Failure

Function cannot fail.

Usage example (Cross-references)

Usage examples (Cross-references)

In BitVec.c:541:

    }
    
    u64 BitVecCountOnes(const BitVec *bitvec) {
        ValidateBitVec(bitvec);
        if (!bitvec->data)

In BitVec.c:568:

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

In BitVec.c:784:

        ValidateBitVec(bv2);
    
        u64 weight1 = BitVecCountOnes(bv1);
        u64 weight2 = BitVecCountOnes(bv2);

In BitVec.c:785:

    
        u64 weight1 = BitVecCountOnes(bv1);
        u64 weight2 = BitVecCountOnes(bv2);
    
        if (weight1 < weight2) {

In BitVec.c:1510:

    
        u64 dot_product = BitVecDotProduct(bv1, bv2);
        u64 ones1       = BitVecCountOnes(bv1);
        u64 ones2       = BitVecCountOnes(bv2);

In BitVec.c:1511:

        u64 dot_product = BitVecDotProduct(bv1, bv2);
        u64 ones1       = BitVecCountOnes(bv1);
        u64 ones2       = BitVecCountOnes(bv2);
    
        if (ones1 == 0 || ones2 == 0) {

In BitVec.c:1652:

            return 0.0;
    
        u64 ones  = BitVecCountOnes(bv);
        u64 zeros = bv->length - ones;

In Memory.c:647:

        // mutant it aborts.
        bool result = (BitVecGet(&bv, 399) == (399 % 3 == 0));
        result      = result && (BitVecCountOnes(&bv) == BitVecCountOnes(&bv));
    
        BitVecDeinit(&bv);

In Access.Deadend.c:185:

    
        // Test NULL bitvec pointer - should abort
        BitVecCountOnes(NULL);
    
        return false;

In BitWise.Simple.c:1082:

        BitVecShiftRight(&bv, 2);
    
        bool result = (BitVecCountOnes(&bv) == 2);
        result      = result && (BitVecGet(&bv, 0) == true);
        result      = result && (BitVecGet(&bv, 1) == true);

In Convert.c:901:

        Str    s      = StrInitFromZstr("111000111", &alloc);
        BitVec bv     = bitvec_from_str_str(&s, ALLOCATOR_OF(&alloc));
        bool   result = (BitVecLen(&bv) == 9) && (BitVecCountOnes(&bv) == 6);
        for (int i = 0; i < 9; i++) {
            result = result && (BitVecGet(&bv, i) == ((i / 3) % 2 == 0));

In Access.Simple.c:153:

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

In Access.Simple.c:239:

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

In Access.Simple.c:244:

        // Test single bit
        BitVecPush(&bv, true);
        result = result && (BitVecCountOnes(&bv) == 1);
        result = result && (BitVecCountZeros(&bv) == 0);

In Access.Simple.c:252:

            BitVecPush(&bv, true);
        }
        result = result && (BitVecCountOnes(&bv) == 100);
        result = result && (BitVecCountZeros(&bv) == 0);

In Access.Simple.c:285:

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

In Access.Simple.c:292:

        BitVecFlip(&bv, 3); // F -> T
    
        result = result && (BitVecCountOnes(&bv) == 5);
        result = result && (BitVecCountZeros(&bv) == 0);

In Access.Simple.c:321:

    
        // Verify counts
        result = result && (BitVecCountOnes(&bv) == 500);
        result = result && (BitVecCountZeros(&bv) == 500);

In Access.Simple.c:330:

        BitVecFlip(&bv, 999); // F -> T
    
        result = result && (BitVecCountOnes(&bv) == 500);
        result = result && (BitVecCountZeros(&bv) == 500);

In Access.Simple.c:363:

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

In Access.Simple.c:402:

        }
    
        result = result && (BitVecCountOnes(&bv) == expected_true_count);
        result = result && (BitVecCountZeros(&bv) == (size - expected_true_count));

In Access.Simple.c:438:

        }
        result = result && (BitVecCountZeros(&bv) == 64);
        result = result && (BitVecCountOnes(&bv) == 0);
    
        // Test all ones

In Access.Simple.c:445:

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

In Access.Simple.c:453:

            BitVecPush(&bv, i % 2 == 0);
        }
        result = result && (BitVecCountOnes(&bv) == 32);
        result = result && (BitVecCountZeros(&bv) == 32);

In Access.Simple.c:461:

            BitVecPush(&bv, i % 8 == 0);
        }
        result = result && (BitVecCountOnes(&bv) == 8);
        result = result && (BitVecCountZeros(&bv) == 56);

Last updated on July 1, 2026