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

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

In BitVec.c:267:

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

In BitVec.c:305:

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

In BitVec.c:330:

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

In BitVec.c:333:

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

In BitVec.c:354:

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

In BitVec.c:358:

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

In BitVec.c:382:

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

In BitVec.c:387:

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

In BitVec.c:410:

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

In BitVec.c:417:

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

In BitVec.c:433:

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

In BitVec.c:458:

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

In BitVec.c:500:

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

In BitVec.c:544:

            bool bit_a = BitVecGet(a, i);
            bool bit_b = BitVecGet(b, i);
            BitVecSet(result, i, bit_a && bit_b);
        }
    }

In BitVec.c:561:

            bool bit_a = i < a->length ? BitVecGet(a, i) : false;
            bool bit_b = i < b->length ? BitVecGet(b, i) : false;
            BitVecSet(result, i, bit_a || bit_b);
        }
    }

In BitVec.c:578:

            bool bit_a = i < a->length ? BitVecGet(a, i) : false;
            bool bit_b = i < b->length ? BitVecGet(b, i) : false;
            BitVecSet(result, i, bit_a != bit_b);
        }
    }

In BitVec.c:592:

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

In BitVec.c:992:

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

In BitVec.c:1048:

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

In BitVec.c:1079:

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

In BitVec.c:1083:

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

In BitVec.c:1100:

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

In BitVec.c:1104:

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

In BitVec.c:1128:

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

In BitVec.c:1154:

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

In BitVec.c:1170:

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

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

In Int.c:1021:

    
        for (u64 i = bits; i > 0; i--) {
            BitVecSet(INT_BITS(value), i - 1 + positions, BitVecGet(INT_BITS(value), i - 1));
        }

In Int.c:1025:

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

In Int.c:1045:

    
        for (u64 i = 0; i + positions < bits; i++) {
            BitVecSet(INT_BITS(value), i, BitVecGet(INT_BITS(value), i + positions));
        }

In Int.c:1407:

                        goto cleanup;
                    }
                    BitVecSet(INT_BITS(&q), bit, true);
                }

In BitVec.Memory.c:188:

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

In BitVec.Memory.c:387:

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

In BitVec.Access.Deadend.c:68:

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

In BitVec.Access.Deadend.c:105:

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

In BitVec.Access.Deadend.c:156:

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

In BitVec.Access.Simple.c:59:

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

In BitVec.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 BitVec.Access.Simple.c:66:

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

In BitVec.Access.Simple.c:67:

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

In BitVec.Access.Simple.c:68:

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

In BitVec.Access.Simple.c:189:

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

In BitVec.Access.Simple.c:195:

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

In BitVec.Access.Simple.c:199:

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

In BitVec.Access.Simple.c:272:

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

In BitVec.Access.Simple.c:273:

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

In BitVec.Access.Simple.c:274:

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

In BitVec.Access.Simple.c:275:

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

In BitVec.Access.Simple.c:356:

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

In BitVec.Access.Simple.c:357:

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

In BitVec.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 BitVec.Access.Simple.c:676:

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

In BitVec.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);

In BitVec.Compare.c:269:

    
        // 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 BitVec.Compare.c:363:

    
        // 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 BitVec.Compare.c:457:

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

In BitVec.Access.c:66:

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

In BitVec.Access.c:76:

    
        // Set specific bits
        BitVecSet(&bv, 0, true);
        BitVecSet(&bv, 2, true);

In BitVec.Access.c:77:

        // Set specific bits
        BitVecSet(&bv, 0, true);
        BitVecSet(&bv, 2, true);
    
        // Verify changes

In BitVec.Access.c:85:

    
        // Test setting back to false
        BitVecSet(&bv, 0, false);
        result = result && (BitVecGet(&bv, 0) == false);

In BitVec.Access.c:240:

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

In BitVec.Access.c:247:

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

In BitVec.Access.c:251:

    
        // Test setting same value multiple times
        BitVecSet(&bv, 0, true);
        BitVecSet(&bv, 0, true);
        result = result && (BitVecGet(&bv, 0) == true);

In BitVec.Access.c:252:

        // Test setting same value multiple times
        BitVecSet(&bv, 0, true);
        BitVecSet(&bv, 0, true);
        result = result && (BitVecGet(&bv, 0) == true);

In BitVec.Access.c:335:

    
            // Test setting and getting
            BitVecSet(&bv, cycle, cycle % 3 == 0);
            result = result && (BitVecGet(&bv, cycle) == (cycle % 3 == 0));
        }

In BitVec.Access.c:490:

        // Change to all-ones pattern
        for (int i = 0; i < 100; i++) {
            BitVecSet(&bv, i, true);
        }

In BitVec.Access.c:547:

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

In BitVec.Access.c:584:

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

In BitVec.Access.c:635:

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

In BitVec.Access.c:904:

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

In BitVec.Access.c:941:

    
        // 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 June 4, 2026

BitVecRotateRight BitVecShiftLeft