BitVecSet

Documentation

API Reference

BitVecSet

Description

Set the value of bit at given index in bitvector.

Parameters

Name	Direction	Description
`bv`	in,out	Bitvector to set bit in.
`idx`	in	Index of bit to set (0-based), in [0, length).
`value`	in	Value to set (true/false).

Usage example (from documentation)

  BitVecSet(&flags, 5, true);
  BitVecSet(&flags, 10, false);

Success

Returns to the caller. The bit at idx is now value. Length and capacity are unchanged; all other bits are unchanged.

Failure

Function cannot fail. An out-of-range idx is a caller bug and aborts via LOG_FATAL.

Usage example (Cross-references)

Usage examples (Cross-references)

In BitVec.c:295:

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

In BitVec.c:333:

            return false;
        }
        BitVecSet(bitvec, bitvec->length - 1, value);
        return true;
    }

In BitVec.c:358:

        for (u64 i = bitvec->length - 1; i > idx; i--) {
            bool bit = BitVecGet(bitvec, i - 1);
            BitVecSet(bitvec, i, bit);
        }

In BitVec.c:361:

        }
    
        BitVecSet(bitvec, idx, value);
        return true;
    }

In BitVec.c:382:

            i--;
            bool bit = BitVecGet(bv, i);
            BitVecSet(bv, i + count, bit);
        }

In BitVec.c:386:

    
        for (u64 i = 0; i < count; i++) {
            BitVecSet(bv, idx + i, value);
        }

In BitVec.c:410:

            i--;
            bool bit = BitVecGet(bv, i);
            BitVecSet(bv, i + other->length, bit);
        }

In BitVec.c:415:

        for (u64 i = 0; i < other->length; i++) {
            bool bit = BitVecGet(other, i);
            BitVecSet(bv, idx + i, bit);
        }

In BitVec.c:438:

            i--;
            bool bit = BitVecGet(bv, i);
            BitVecSet(bv, i + pattern_bits, bit);
        }

In BitVec.c:445:

        for (u64 i = 0; i < pattern_bits; i++) {
            bool bit = (pattern & (1u << i)) != 0;
            BitVecSet(bv, idx + i, bit);
        }

In BitVec.c:461:

        for (u64 i = idx; i < bv->length - 1; i++) {
            bool bit = BitVecGet(bv, i + 1);
            BitVecSet(bv, i, bit);
        }

In BitVec.c:486:

        for (u64 i = idx + count; i < bv->length; i++) {
            bool bit = BitVecGet(bv, i);
            BitVecSet(bv, i - count, bit);
        }

In BitVec.c:528:

            if (bit != value) {
                if (write_idx != read_idx) {
                    BitVecSet(bv, write_idx, bit);
                }
                write_idx++;

In BitVec.c:1047:

            u64  bit_offset = i % 8;
            bool bit        = (bytes[byte_idx] & (1u << bit_offset)) != 0;
            BitVecSet(out, i, bit);
        }

In BitVec.c:1103:

        for (u64 i = 0; i < bits; i++) {
            bool bit = (value & (1ULL << i)) != 0;
            BitVecSet(out, i, bit);
        }

In BitVec.c:1134:

        for (u64 i = bv->length - 1; i >= positions; i--) {
            bool bit = BitVecGet(bv, i - positions);
            BitVecSet(bv, i, bit);
        }

In BitVec.c:1138:

    
        for (u64 i = 0; i < positions; i++) {
            BitVecSet(bv, i, false);
        }
    }

In BitVec.c:1155:

        for (u64 i = 0; i < bv->length - positions; i++) {
            bool bit = BitVecGet(bv, i + positions);
            BitVecSet(bv, i, bit);
        }

In BitVec.c:1159:

    
        for (u64 i = bv->length - positions; i < bv->length; i++) {
            BitVecSet(bv, i, false);
        }
    }

In BitVec.c:1183:

            u64  src_idx = (i + positions) % bv->length;
            bool bit     = BitVecGet(&temp, src_idx);
            BitVecSet(bv, i, bit);
        }

In BitVec.c:1209:

            u64  src_idx = (i + bv->length - positions) % bv->length;
            bool bit     = BitVecGet(&temp, src_idx);
            BitVecSet(bv, i, bit);
        }

In BitVec.c:1225:

            bool bit_i = BitVecGet(bv, i);
            bool bit_j = BitVecGet(bv, j);
            BitVecSet(bv, i, bit_j);
            BitVecSet(bv, j, bit_i);
        }

In BitVec.c:1226:

            bool bit_j = BitVecGet(bv, j);
            BitVecSet(bv, i, bit_j);
            BitVecSet(bv, j, bit_i);
        }
    }

In Memory.c:229:

    
        // Modify clone to verify independence
        BitVecSet(&clone, 0, false);
    
        // Original should remain unchanged at index 0

In Memory.c:428:

    
        // Test independence - modify original
        BitVecSet(&bv, 0, !BitVecGet(&bv, 0));
        result = result && (BitVecGet(&clone3, 0) != BitVecGet(&bv, 0));

In Access.Deadend.c:68:

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

In Access.Deadend.c:105:

    
        // Test set on empty bitvec - should abort
        BitVecSet(&bv, 0, true);
    
        BitVecDeinit(&bv);

In Access.Deadend.c:156:

    
        // Test with index way beyond length (2) - should abort
        BitVecSet(&bv, 500, true);
    
        BitVecDeinit(&bv);

In Compare.c:278:

    
        // Test non-subset case
        BitVecSet(&superset, 2, false); // Change superset to 1101
        // Now subset (1010) is not a subset of superset (1101) because subset has 1 at position 2
        result = result && !BitVecIsSubset(&subset, &superset);

In Compare.c:372:

    
        // Test non-superset case
        BitVecSet(&superset, 2, false); // Change to 1101
        // Now superset (1101) is not a superset of subset (1010)
        result = result && !BitVecIsSuperset(&superset, &subset);

In Compare.c:466:

    
        // Create intersecting bitvectors
        BitVecSet(&bv2, 0, true); // Change bv2 to 1101
    
        // Should not be disjoint and should intersect

In Access.Simple.c:59:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecSet\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In Access.Simple.c:65:

        // Reserve space and set bits
        BitVecResize(&bv, 4);
        BitVecSet(&bv, 0, true);
        BitVecSet(&bv, 1, false);
        BitVecSet(&bv, 2, true);

In Access.Simple.c:66:

        BitVecResize(&bv, 4);
        BitVecSet(&bv, 0, true);
        BitVecSet(&bv, 1, false);
        BitVecSet(&bv, 2, true);
        BitVecSet(&bv, 3, false);

In Access.Simple.c:67:

        BitVecSet(&bv, 0, true);
        BitVecSet(&bv, 1, false);
        BitVecSet(&bv, 2, true);
        BitVecSet(&bv, 3, false);

In Access.Simple.c:68:

        BitVecSet(&bv, 1, false);
        BitVecSet(&bv, 2, true);
        BitVecSet(&bv, 3, false);
    
        // Test getting the set bits

In Access.Simple.c:189:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecSet edge cases\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In Access.Simple.c:195:

        // Set first bit
        BitVecResize(&bv, 1);
        BitVecSet(&bv, 0, true);
        bool result = (BitVecGet(&bv, 0) == true);

In Access.Simple.c:199:

    
        // Set same bit to false
        BitVecSet(&bv, 0, false);
        result = result && (BitVecGet(&bv, 0) == false);

In Access.Simple.c:272:

        BitVecPush(&bv, true);
        BitVecResize(&bv, 5);
        BitVecSet(&bv, 1, false);
        BitVecSet(&bv, 2, true);
        BitVecSet(&bv, 3, false);

In Access.Simple.c:273:

        BitVecResize(&bv, 5);
        BitVecSet(&bv, 1, false);
        BitVecSet(&bv, 2, true);
        BitVecSet(&bv, 3, false);
        BitVecSet(&bv, 4, true);

In Access.Simple.c:274:

        BitVecSet(&bv, 1, false);
        BitVecSet(&bv, 2, true);
        BitVecSet(&bv, 3, false);
        BitVecSet(&bv, 4, true);

In Access.Simple.c:275:

        BitVecSet(&bv, 2, true);
        BitVecSet(&bv, 3, false);
        BitVecSet(&bv, 4, true);
    
        // Verify pattern: T F T F T

In Access.Simple.c:356:

    
        // Test some bit operations
        BitVecSet(&bv, 0, false);
        BitVecSet(&bv, 1, true);

In Access.Simple.c:357:

        // Test some bit operations
        BitVecSet(&bv, 0, false);
        BitVecSet(&bv, 1, true);
    
        result = result && (BitVecGet(&bv, 0) == false);

In Access.Simple.c:387:

        for (int i = 0; i < size; i++) {
            BitVecResize(&bv, i + 1);
            BitVecSet(&bv, i, i % 3 == 0); // Every third bit is true
        }

In Access.Simple.c:676:

    
        // Change one bit to false
        BitVecSet(&bv, 500, false);
        result = result && !BitVecAll(&bv, true);
        result = result && BitVecAny(&bv, true);

In Access.Simple.c:713:

    
        // Test with one interruption in the middle
        BitVecSet(&bv, 5000, false);
        result = result && (BitVecLongestRun(&bv, true) == 5000);
        result = result && (BitVecLongestRun(&bv, false) == 1);

Last updated on July 1, 2026

BitVecRuns BitVecShiftLeft