BitVecFlip

Documentation

API Reference

BitVecFlip

Description

Flip the value of bit at given index in bitvector. Changes 0 to 1 and 1 to 0.

Parameters

Name	Direction	Description
`bv`	in	Bitvector to flip bit in
`idx`	in	Index of bit to flip (0-based)

Usage example (from documentation)

  BitVecFlip(&flags, 5);

Usage example (Cross-references)

Usage examples (Cross-references)

In BitVec.c:212:

    }
    
    void BitVecFlip(BitVec *bitvec, u64 idx) {
        ValidateBitVec(bitvec);
        if (idx >= bitvec->length) {

In BitVec.Access.Simple.c:75:

    // Test BitVecFlip function
    bool test_bitvec_flip(void) {
        WriteFmt("Testing BitVecFlip\n");
    
        BitVec bv = BitVecInit();

In BitVec.Access.Simple.c:86:

    
        // Flip some bits
        BitVecFlip(&bv, 0);
        BitVecFlip(&bv, 1);

In BitVec.Access.Simple.c:87:

        // Flip some bits
        BitVecFlip(&bv, 0);
        BitVecFlip(&bv, 1);
    
        // Test the flipped bits

In BitVec.Access.Simple.c:188:

    // Edge case tests for BitVecFlip
    bool test_bitvec_flip_edge_cases(void) {
        WriteFmt("Testing BitVecFlip edge cases\n");
    
        BitVec bv = BitVecInit();

In BitVec.Access.Simple.c:194:

        // Test flipping single bit
        BitVecPush(&bv, false);
        BitVecFlip(&bv, 0);
        bool result = (BitVecGet(&bv, 0) == true);

In BitVec.Access.Simple.c:198:

    
        // Flip it again
        BitVecFlip(&bv, 0);
        result = result && (BitVecGet(&bv, 0) == false);

In BitVec.Access.Simple.c:260:

    
        // Flip some bits and verify
        BitVecFlip(&bv, 1); // F -> T
        BitVecFlip(&bv, 3); // F -> T

In BitVec.Access.Simple.c:261:

        // Flip some bits and verify
        BitVecFlip(&bv, 1); // F -> T
        BitVecFlip(&bv, 3); // F -> T
    
        result = result && (BitVecCountOnes(&bv) == 5);

In BitVec.Access.Simple.c:293:

    
        // Flip some bits and verify
        BitVecFlip(&bv, 0);   // T -> F
        BitVecFlip(&bv, 1);   // F -> T
        BitVecFlip(&bv, 500); // T -> F

In BitVec.Access.Simple.c:294:

        // Flip some bits and verify
        BitVecFlip(&bv, 0);   // T -> F
        BitVecFlip(&bv, 1);   // F -> T
        BitVecFlip(&bv, 500); // T -> F
        BitVecFlip(&bv, 999); // F -> T

In BitVec.Access.Simple.c:295:

        BitVecFlip(&bv, 0);   // T -> F
        BitVecFlip(&bv, 1);   // F -> T
        BitVecFlip(&bv, 500); // T -> F
        BitVecFlip(&bv, 999); // F -> T

In BitVec.Access.Simple.c:296:

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

In BitVec.Access.Simple.c:369:

        // Flip every 7th bit
        for (int i = 0; i < size; i += 7) {
            BitVecFlip(&bv, i);
        }

In BitVec.Access.Deadend.c:77:

    
        // Test NULL bitvec pointer - should abort
        BitVecFlip(NULL, 0);
    
        return false;

In BitVec.Access.Deadend.c:112:

    
        // Test flip on empty bitvec - should abort
        BitVecFlip(&bv, 0);
    
        BitVecDeinit(&bv);

In BitVec.Access.Deadend.c:157:

    
        // Test with index exactly at length (invalid) - should abort
        BitVecFlip(&bv, 10);
    
        BitVecDeinit(&bv);

In BitVec.Access.c:90:

    // Test BitVecFlip function
    bool test_bitvec_flip(void) {
        WriteFmt("Testing BitVecFlip\n");
    
        BitVec bv = BitVecInit();

In BitVec.Access.c:100:

    
        // Flip each bit
        BitVecFlip(&bv, 0); // 1 -> 0
        BitVecFlip(&bv, 1); // 0 -> 1
        BitVecFlip(&bv, 2); // 1 -> 0

In BitVec.Access.c:101:

        // Flip each bit
        BitVecFlip(&bv, 0); // 1 -> 0
        BitVecFlip(&bv, 1); // 0 -> 1
        BitVecFlip(&bv, 2); // 1 -> 0

In BitVec.Access.c:102:

        BitVecFlip(&bv, 0); // 1 -> 0
        BitVecFlip(&bv, 1); // 0 -> 1
        BitVecFlip(&bv, 2); // 1 -> 0
    
        // Verify flipped values: should now be 010

In BitVec.Access.c:110:

    
        // Flip back
        BitVecFlip(&bv, 0); // 0 -> 1
        BitVecFlip(&bv, 1); // 1 -> 0
        BitVecFlip(&bv, 2); // 0 -> 1

In BitVec.Access.c:111:

        // Flip back
        BitVecFlip(&bv, 0); // 0 -> 1
        BitVecFlip(&bv, 1); // 1 -> 0
        BitVecFlip(&bv, 2); // 0 -> 1

In BitVec.Access.c:112:

        BitVecFlip(&bv, 0); // 0 -> 1
        BitVecFlip(&bv, 1); // 1 -> 0
        BitVecFlip(&bv, 2); // 0 -> 1
    
        // Should be back to original: 101

In BitVec.Access.c:235:

    
    bool test_bitvec_flip_edge_cases(void) {
        WriteFmt("Testing BitVecFlip edge cases\n");
    
        BitVec bv     = BitVecInit();

In BitVec.Access.c:242:

        // Test normal flipping
        BitVecPush(&bv, true);
        BitVecFlip(&bv, 0);
        result = result && (BitVecGet(&bv, 0) == false);

In BitVec.Access.c:245:

        result = result && (BitVecGet(&bv, 0) == false);
    
        BitVecFlip(&bv, 0);
        result = result && (BitVecGet(&bv, 0) == true);

In BitVec.Access.c:411:

            if (boundaries[i] < size) {
                bool original = BitVecGet(&bv, boundaries[i]);
                BitVecFlip(&bv, boundaries[i]);
                result = result && (BitVecGet(&bv, boundaries[i]) == !original);
                BitVecFlip(&bv, boundaries[i]); // Flip back

In BitVec.Access.c:413:

                BitVecFlip(&bv, boundaries[i]);
                result = result && (BitVecGet(&bv, boundaries[i]) == !original);
                BitVecFlip(&bv, boundaries[i]); // Flip back
                result = result && (BitVecGet(&bv, boundaries[i]) == original);
            }

In BitVec.Access.c:509:

    
        // Test NULL bitvec pointer - should abort
        BitVecFlip(NULL, 0);
    
        return false;

In BitVec.Access.c:544:

    
        // Test flip on empty bitvec - should abort
        BitVecFlip(&bv, 0);
    
        BitVecDeinit(&bv);

In BitVec.Access.c:589:

    
        // Test with index exactly at length (invalid) - should abort
        BitVecFlip(&bv, 10);
    
        BitVecDeinit(&bv);

Last updated on April 20, 2026

BitVecFindPattern BitVecFuzzyMatch