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:513:

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

In BitVec.c:528:

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

In BitVec.c:729:

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

In BitVec.c:730:

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

In BitVec.c:1455:

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

In BitVec.c:1456:

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

In BitVec.c:1597:

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

In BitVec.Access.Deadend.c:185:

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

In BitVec.Access.Simple.c:153:

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

In BitVec.Access.Simple.c:239:

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

In BitVec.Access.Simple.c:244:

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

In BitVec.Access.Simple.c:252:

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

In BitVec.Access.Simple.c:285:

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

In BitVec.Access.Simple.c:292:

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

In BitVec.Access.Simple.c:321:

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

In BitVec.Access.Simple.c:330:

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

In BitVec.Access.Simple.c:363:

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

In BitVec.Access.Simple.c:402:

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

In BitVec.Access.Simple.c:438:

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

In BitVec.Access.Simple.c:445:

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

In BitVec.Access.Simple.c:453:

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

In BitVec.Access.Simple.c:461:

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

In BitVec.Access.c:190:

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

In BitVec.Access.c:199:

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

In BitVec.Access.c:290:

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

In BitVec.Access.c:295:

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

In BitVec.Access.c:300:

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

In BitVec.Access.c:308:

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

In BitVec.Access.c:480:

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

In BitVec.Access.c:493:

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

In BitVec.Access.c:502:

        }
    
        result = result && (BitVecCountOnes(&bv) == 50);
        result = result && (BitVecCountZeros(&bv) == 50);

In BitVec.Access.c:664:

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

Last updated on June 4, 2026

BitVecContainsAt BitVecCountPattern