final_cpp_project.cpp

#include <iostream>
#include <stdint.h>
using namespace std;

// Vector memory layout (byte offsets):
// [0..3]    size        (int)   -> number of active elements
// [4..7]    capacity    (int)   -> reserved element capacity
// [8..11]   is_free     (int)   -> 0 = allocated , 1 = free
// [12..15]  next_free   (int)   -> offset of next free block (-1 if none)
// [16..]    data        (int[] or double[])
// Define the simulated 1MB heap and management variables
uint8_t HEAP[1024 * 1024];      // 1 MB simulated heap memory
int heap_top = 0;               // Bump pointer (top of allocated heap)
int free_list_head = -1;        // Head of free-block linked list
int free_list_head_double = -1; // Head of free-block linked list for double vectors

// Breaks a 4-byte int into 4 individual bytes and stores them in HEAP.
// In this system, int is 4 bytes, so we iterate 4 times.
void heap_write_int(int idx, int value)
{
    for (int i = 0; i < 4; i++)
    {
        // Treat 'value' as an array of 4 bytes instead of a single int.
        HEAP[idx + i] = ((uint8_t *)&value)[i];
    }
}

// Reconstructs a 4-byte int by reading 4 individual bytes from HEAP.
// It assembles the bytes back into a single integer value.
int heap_read_int(int idx)
{
    int value;
    for (int i = 0; i < 4; i++)
    {
        ((uint8_t *)&value)[i] = HEAP[idx + i];
    }
    return value;
}
// copy bytes from src_idx to dest_idx
void my_memcpy(int dest_idx, int src_idx, int count)
{
    for (int i = 0; i < count; i++)
    {
        HEAP[dest_idx + i] = HEAP[src_idx + i];
    }
}
// Integer Vector functions
void vec_int_free(int vec_id);                             // Free a vector block and add it to free list
int vec_int_init(int initial_capacity);                    // Initialize a new vector with given capacity
void vec_int_reserve(int &vec_id, int new_cap);            // Ensure vector can hold at least new_cap elements
void vec_int_push_back(int &vec_id, int value);            // Append a value to the end of the vector
void vec_int_popback(int vec_id);                          // Remove the last element of the vector
int vec_int_at(int vec_id, int index);                     // Access the element at a given index safely
int vec_int_size(int vec_id);                              // Return current number of elements in the vector
int *vec_int_data(int vec_id);                             // Return pointer to start of the data array
bool vec_int_clear(int &vec_id);                           // Clear vector: reset size to 0 or reallocate small block
void vec_int_insert(int &vec_id, int index, int value);    // Insert a value at a given index
void vec_int_erase(int vec_id, int index);                 // Remove element at a given index
void vec_int_shrink_to_fit(int &vec_id);                   // Reduce vector capacity to match current size
int vec_int_copy(int vec_id);                              // Return a new vector copy of the given vector
void vec_int_erase_range(int vec_id, int first, int last); // Remove elements in range [first, last)
void test_int_vector_and_free_list();                      // test function
// Helper for 8-byte data
void heap_write_double(int idx, double value);
double heap_read_double(int idx);

// Double Vector functions
void vec_double_free(int vec_id);                             // Free a double vector block and add it to free list
int vec_double_init(int initial_capacity);                    // Initialize a new double vector with given capacity
void vec_double_reserve(int &vec_id, int new_cap);            // Ensure vector can hold at least new_cap elements
void vec_double_push_back(int &vec_id, double value);         // Append a value to the end of the vector
void vec_double_popback(int vec_id);                          // Remove the last element of the vector
double vec_double_at(int vec_id, int index);                  // Access the element at a given index safely
int vec_double_size(int vec_id);                              // Return current number of elements in the vector
double *vec_double_data(int vec_id);                          // Return pointer to start of the data array
bool vec_double_clear(int &vec_id);                           // Clear vector: reset size to 0 or reuse block
void vec_double_insert(int &vec_id, int index, double value); // Insert value at index
void vec_double_erase(int vec_id, int index);                 // Remove element at index
void vec_double_shrink_to_fit(int &vec_id);                   // Reduce capacity to match size
int vec_double_copy(int vec_id);                              // Deep copy vector
void vec_double_erase_range(int vec_id, int first, int last); // Remove elements in range [first, last]
void test_double_vector_and_free_list();                      // Test function

int main()
{
    cout << "[INT TEST]" << endl;
    test_int_vector_and_free_list();

    cout << endl
         << "------------------------------------" << endl;

    cout << "[DOUBLE TEST]" << endl;
    test_double_vector_and_free_list();
    return 0;
}

/*------------------int function------------------*/
void vec_int_free(int vec_id)
{
    // Check if the block is already marked as free
    int is_free = heap_read_int(vec_id + 8);
    if (is_free)
    {
        return; // already freed
    }

    // mark block as free (0 = occupied, 1 = free)
    heap_write_int(vec_id + 8, 1); // is_free = true

    // link this block to free list using offset 12 for next_free
    heap_write_int(vec_id + 12, free_list_head);

    // update the global head of the free list
    free_list_head = vec_id;
}
/*
Free list traversal note:
Free blocks are stored as a singly linked list:

free_list_head -> block A -> block B -> block C -> NULL

Each free block contains exactly one pointer:
    next_free  (offset +12)

During traversal:
- current_node  : block currently being inspected
- previous_node : block that points to current_node

Keeping both pointers allows safe removal of a block from
the middle of the free list without breaking the chain.
*/
int vec_int_init(int initial_capacity)
{
    // invalid capacity
    if (initial_capacity < 0)
        return -1;

    // total memory needed = metadata (16 bytes) + data
    int needed_bytes = 16 + initial_capacity * sizeof(int);

    // first-fit search in free list
    int previous_node = -1;
    int current_node = free_list_head;

    while (current_node != -1)
    {
        int cap = heap_read_int(current_node + 4);
        int is_free = heap_read_int(current_node + 8);

        // reuse block if it is free and has enough capacity
        if (is_free && cap >= initial_capacity)
        {
            int next = heap_read_int(current_node + 12);

            // unlink from free list
            if (previous_node == -1)
            {
                free_list_head = next;
            }
            else
            {
                heap_write_int(previous_node + 12, next);
            }

            // reinitialize metadata
            heap_write_int(current_node + 0, 0);   // size = 0
            heap_write_int(current_node + 8, 0);   // is_free = false
            heap_write_int(current_node + 12, -1); // next_free = NULL

            return current_node; // reused block
        }

        previous_node = current_node;
        current_node = heap_read_int(current_node + 12);
    }

    // no suitable free block found → allocate from heap_top
    if (heap_top + needed_bytes > 1024 * 1024)
        return -1; // out of heap memory

    int vec_id = heap_top;

    // initialize metadata for a new vector block
    heap_write_int(vec_id + 0, 0);                // size
    heap_write_int(vec_id + 4, initial_capacity); // capacity
    heap_write_int(vec_id + 8, 0);                // is_free = false
    heap_write_int(vec_id + 12, -1);              // next_free = NULL

    // advance heap bump pointer
    heap_top += needed_bytes;

    return vec_id;
}
/*
We define reserve before push_back because push_back depends on it.
Logical Flow: push_back adds an element -> if capacity is full -> it calls reserve to move the vector to a larger space.
*/
void vec_int_reserve(int &vec_id, int new_cap)
{
    int old_size = heap_read_int(vec_id + 0);
    int old_cap = heap_read_int(vec_id + 4);

    // if current capacity is enough, do nothing
    if (new_cap <= old_cap)
    {
        return;
    }

    // allocate new vector (reuse free blocks if possible)
    int new_vec_id = vec_int_init(new_cap);
    if (new_vec_id == -1)
    {
        return; // allocation failed
    }
    // copy old data to the new location
    int old_data_offset = vec_id + 16;
    int new_data_offset = new_vec_id + 16;
    my_memcpy(new_data_offset, old_data_offset, old_size * sizeof(int));

    // set size of the new vector
    heap_write_int(new_vec_id + 0, old_size);

    // free old vector block (adds it to free list)
    vec_int_free(vec_id);

    // update reference to point to the new vector
    vec_id = new_vec_id;
}

void vec_int_push_back(int &vec_id, int value)
{
    int size = heap_read_int(vec_id + 0);
    int cap = heap_read_int(vec_id + 4);

    // check if needed to grow or not
    if (size == cap)
    {
        /* Growth Strategy:
         1. If the vector is empty (cap == 0), we initialize it with 2 to avoid
         immediate re-allocation on the second push.
         2. If it's not empty, we double the capacity (Exponential Growth).
         This balances memory usage and performance by reducing the number of
        expensive 'reserve' operations.
        */
        int new_cap = (cap == 0) ? 2 : cap * 2;
        int old_vec_id = vec_id;
        vec_int_reserve(vec_id, new_cap);

        // re-read capacity after reserve (vec_id may have changed!)
        cap = heap_read_int(vec_id + 4);

        // allocation failed, can't push
        if (vec_id == old_vec_id && cap == size)
        {
            return;
        }
    }
    int data_offset = vec_id + 16 + (size * sizeof(int));
    heap_write_int(data_offset, value);

    // update size
    heap_write_int(vec_id + 0, size + 1);
}

void vec_int_popback(int vec_id)
{
    // read current size
    int size = heap_read_int(vec_id + 0);

    // Can't pop from an empty vector
    if (size <= 0)
    {
        return;
    }
    heap_write_int(vec_id + 0, size - 1);
    // no else needed; silently ignore empty vector
}

int vec_int_at(int vec_id, int index)
{
    // read current size from HEAP
    int size = heap_read_int(vec_id + 0);

    // bounds checking
    if (index < 0 || index >= size)
    {
        return -1;
    }

    // compute the byte offset for the requested element
    int data_offset = vec_id + 16 + index * sizeof(int); // Offset = 16 (metadata) + (index * 4 bytes for each int)

    // read and return the value safely
    return heap_read_int(data_offset);
}

int vec_int_size(int vec_id)
{
    // our metadata layout: [vec_id + 0] is always the 'size'
    return heap_read_int(vec_id + 0);
}

int *vec_int_data(int vec_id)
{
    // skip exactly 16 bytes of metadata.
    // we cast the address to (int*) so it can be used like a normal C-array.
    return (int *)(&HEAP[vec_id + 16]);
}

bool vec_int_clear(int &vec_id)
{
    if (vec_id == -1)
    {
        return false; // invalid vector
    }
    vec_int_free(vec_id); // release old block

    int new_id = vec_int_init(2); // start with capacity = 2 to avoid immediate reallocation on first push_back
    if (new_id == -1)
    {
        vec_id = -1; // allocation failed
        return false;
    }

    vec_id = new_id;
    return true;
}
void vec_int_insert(int &vec_id, int index, int value)
{
    // read size and capacity
    int size = heap_read_int(vec_id + 0);
    int cap = heap_read_int(vec_id + 4);

    // check for valid index
    if (index < 0 || index > size)
    {
        return;
    }
    // grow if needed
    if (size >= cap)
    {
        int new_cap = (cap == 0) ? 2 : cap * 2;
        int old_vec_id = vec_id;
        vec_int_reserve(vec_id, new_cap);

        // allocation failed → cannot insert
        if (vec_id == old_vec_id && heap_read_int(vec_id + 4) == cap)
        {
            return;
        }

        // re-read metadata after possible reallocation
        size = heap_read_int(vec_id + 0);
        cap = heap_read_int(vec_id + 4);
    }

    // shift elements to the right to make room
    for (int i = size - 1; i >= index; i--)
    {
        int val = heap_read_int(vec_id + 16 + i * sizeof(int));
        heap_write_int(vec_id + 16 + (i + 1) * sizeof(int), val);
    }

    // insert the new value
    heap_write_int(vec_id + 16 + index * sizeof(int), value);

    // update size
    heap_write_int(vec_id + 0, size + 1);
}

void vec_int_erase(int vec_id, int index)
{
    int size = heap_read_int(vec_id + 0);

    // check for valid index
    if (index < 0 || index >= size)
    {
        return;
    }
    // shift elements left to overwrite the removed element
    for (int i = index + 1; i < size; i++)
    {
        int val = heap_read_int(vec_id + 16 + i * sizeof(int));
        heap_write_int(vec_id + 16 + (i - 1) * sizeof(int), val);
    }

    // decrement size
    heap_write_int(vec_id + 0, size - 1);
}

void vec_int_shrink_to_fit(int &vec_id)
{
    int size = heap_read_int(vec_id + 0);
    int capacity = heap_read_int(vec_id + 4);

    // only shrink if there is unused capacity
    if (size < capacity)
    {
        // allocate a new vector with size capacity
        int new_vec_id = vec_int_init(size);
        if (new_vec_id == -1)
        {
            return; // allocation failed, do nothing
        }
        // copy existing data from old vector to new vector
        my_memcpy(new_vec_id + 16, vec_id + 16, size * sizeof(int));

        // set the size for the new vector
        heap_write_int(new_vec_id + 0, size);

        // free old vector block
        vec_int_free(vec_id);

        // update vector reference
        vec_id = new_vec_id;
    }
}

int vec_int_copy(int vec_id)
{
    int size = heap_read_int(vec_id + 0);
    int capacity = heap_read_int(vec_id + 4);

    // allocate new vector with the same capacity
    int new_vec_id = vec_int_init(capacity);
    if (new_vec_id == -1)
    {
        return -1; // allocation failed
    }
    // copy all data from old vector to new vector
    my_memcpy(new_vec_id + 16, vec_id + 16, size * sizeof(int));

    // set the size for the new vector
    heap_write_int(new_vec_id + 0, size);

    return new_vec_id;
}

void vec_int_erase_range(int vec_id, int first, int last)
{
    int size = heap_read_int(vec_id + 0);

    // validate range
    if (first < 0 || last > size || first >= last)
    {
        return;
    }
    int num_to_remove = last - first;

    // shift elements left to overwrite removed range
    for (int i = last; i < size; i++)
    {
        int val = heap_read_int(vec_id + 16 + i * sizeof(int));
        heap_write_int(vec_id + 16 + (i - num_to_remove) * sizeof(int), val);
    }

    // update size
    heap_write_int(vec_id + 0, size - num_to_remove);
}

void test_int_vector_and_free_list()
{
    // core vector functionality test
    int vec = vec_int_init(2);
    cout << "Initialized vector, ID=" << vec << ", size=" << vec_int_size(vec) << endl;

    vec_int_push_back(vec, 10);
    vec_int_push_back(vec, 20);
    vec_int_push_back(vec, 30);
    cout << "after push_back 3 elements: ";
    for (int i = 0; i < vec_int_size(vec); i++)
        cout << vec_int_at(vec, i) << " ";
    cout << endl;

    vec_int_insert(vec, 1, 15);
    cout << "after insert 15 at index 1: ";
    for (int i = 0; i < vec_int_size(vec); i++)
        cout << vec_int_at(vec, i) << " ";
    cout << endl;

    vec_int_erase(vec, 2);
    cout << "after erase index 2: ";
    for (int i = 0; i < vec_int_size(vec); i++)
        cout << vec_int_at(vec, i) << " ";
    cout << endl;

    vec_int_erase_range(vec, 0, 2);
    cout << "after erase_range 0-2: ";
    for (int i = 0; i < vec_int_size(vec); i++)
        cout << vec_int_at(vec, i) << " ";
    cout << endl;

    vec_int_push_back(vec, 100);
    vec_int_push_back(vec, 200);
    vec_int_push_back(vec, 300);
    cout << "after pushing 100,200,300: ";
    for (int i = 0; i < vec_int_size(vec); i++)
        cout << vec_int_at(vec, i) << " ";
    cout << endl;

    vec_int_shrink_to_fit(vec);
    cout << "after shrink_to_fit: size=" << vec_int_size(vec) << endl;

    int vec_copy = vec_int_copy(vec);
    cout << "Copied vector, size=" << vec_int_size(vec_copy) << ", elements: ";
    for (int i = 0; i < vec_int_size(vec_copy); i++)
        cout << vec_int_at(vec_copy, i) << " ";
    cout << endl;

    vec_int_clear(vec);
    cout << "after clear: size=" << vec_int_size(vec) << endl;

    vec_int_push_back(vec, 555);
    cout << "after push_back 555 on cleared vector: ";
    for (int i = 0; i < vec_int_size(vec); i++)
        cout << vec_int_at(vec, i) << " ";
    cout << endl;

    // Free list reuse test
    int vec1 = vec_int_init(2);
    vec_int_push_back(vec1, 111);
    vec_int_push_back(vec1, 222);

    vec_int_free(vec1);
    cout << "after vec_int_free(vec1): free_list_head=" << free_list_head << endl;

    cout << "current free list: ";
    int cur = free_list_head;
    while (cur != -1)
    {
        cout << cur << " -> ";
        cur = heap_read_int(cur + 12);
    }
    cout << "NULL" << endl;

    int vec2 = vec_int_init(2);
    cout << "vec2 ID after init: " << vec2 << endl;

    if (vec2 == vec1)
        cout << "vec2 reused the freed vec1 block!" << endl;
    else
        cout << "vec2 did NOT reuse the freed block." << endl;

    vec_int_push_back(vec2, 333);
    cout << "vec2 after push_back 333: ";
    for (int i = 0; i < vec_int_size(vec2); i++)
        cout << vec_int_at(vec2, i) << " ";
    cout << endl;
}

/*
------------------------------------------------------------
Differences between int-vector and double-vector implementations

The overall memory layout, allocator logic, free-list handling,
and vector algorithms are IDENTICAL for int and double vectors.

The ONLY differences are:

1) Element size:
   - int    : sizeof(int)    = 4 bytes
   - double : sizeof(double) = 8 bytes

2) Heap access helpers:
   - int    : heap_read_int / heap_write_int
   - double : heap_read_double / heap_write_double

3) Data offset calculation:
   - int    : data_offset = base + index * 4
   - double : data_offset = base + index * 8

This separation allows the allocator and vector logic to remain
generic while supporting multiple data types safely.
------------------------------------------------------------
*/
// write a double value into HEAP at byte index idx
void heap_write_double(int idx, double value)
{
    // break the 8-byte double into individual bytes
    for (int i = 0; i < 8; i++)
    {
        HEAP[idx + i] = ((uint8_t *)&value)[i];
    }
}
// read a double value from HEAP at byte index idx
double heap_read_double(int idx)
{
    double value;

    // reconstruct the double byte-by-byte
    for (int i = 0; i < 8; i++)
    {
        ((uint8_t *)&value)[i] = HEAP[idx + i];
    }

    return value;
}
void vec_double_free(int vec_id)
{
    // check if block is already free
    int is_free = heap_read_int(vec_id + 8);
    if (is_free)
    {
        return; // already freed
    }

    // mark block as free
    heap_write_int(vec_id + 8, 1); // is_free = true

    // link this block into the free list
    heap_write_int(vec_id + 12, free_list_head_double);

    // update free list head
    free_list_head_double = vec_id;
}

int vec_double_init(int initial_capacity)
{
    if (initial_capacity < 0)
    {
        return -1;
    }

    int needed_bytes = 16 + initial_capacity * sizeof(double);

    int previous_node = -1;
    int current_node = free_list_head_double;

    // search free list
    while (current_node != -1)
    {
        int cap = heap_read_int(current_node + 4);
        int is_free = heap_read_int(current_node + 8);

        if (is_free == 1 && cap >= initial_capacity)
        {
            int next = heap_read_int(current_node + 12);

            // unlink from free list
            if (previous_node == -1)
            {
                free_list_head_double = next;
            }
            else
            {
                heap_write_int(previous_node + 12, next);
            }

            // reset metadata
            heap_write_int(current_node + 0, 0); // size
            // keep the original capacity of the reused block
            // this avoids unnecessary reallocations and matches real allocator behavior
            heap_write_int(current_node + 4, cap);
            heap_write_int(current_node + 8, 0);   // is_free = false
            heap_write_int(current_node + 12, -1); // next_free reset

            return current_node;
        }

        previous_node = current_node;
        current_node = heap_read_int(current_node + 12);
    }

    // fallback: allocate from heap_top
    if (heap_top + needed_bytes > 1024 * 1024)
    {
        return -1;
    }

    int vec_id = heap_top;

    heap_write_int(vec_id + 0, 0);                // size
    heap_write_int(vec_id + 4, initial_capacity); // capacity
    heap_write_int(vec_id + 8, 0);                // is_free
    heap_write_int(vec_id + 12, -1);              // next_free

    heap_top += needed_bytes;
    return vec_id;
}

void vec_double_reserve(int &vec_id, int new_cap)
{
    int old_size = heap_read_int(vec_id + 0);
    int old_cap = heap_read_int(vec_id + 4);

    if (new_cap <= old_cap)
    {
        return;
    }

    int new_vec_id = vec_double_init(new_cap);
    if (new_vec_id == -1)
    {
        return;
    }

    int old_data_offset = vec_id + 16;
    int new_data_offset = new_vec_id + 16;

    my_memcpy(
        new_data_offset,
        old_data_offset,
        old_size * sizeof(double));

    heap_write_int(new_vec_id + 0, old_size);

    vec_double_free(vec_id);

    vec_id = new_vec_id;
}

void vec_double_push_back(int &vec_id, double value)
{
    int size = heap_read_int(vec_id + 0);
    int cap = heap_read_int(vec_id + 4);

    if (size == cap)
    {
        int new_cap = (cap == 0) ? 2 : cap * 2;
        int old_vec_id = vec_id;

        vec_double_reserve(vec_id, new_cap);

        if (vec_id == old_vec_id && heap_read_int(vec_id + 4) == cap)
        {
            return; // allocation failed
        }
    }

    int data_offset = vec_id + 16 + size * sizeof(double);
    heap_write_double(data_offset, value);

    heap_write_int(vec_id + 0, size + 1);
}

void vec_double_popback(int vec_id)
{
    int size = heap_read_int(vec_id + 0);

    if (size <= 0)
        return;

    heap_write_int(vec_id + 0, size - 1);
}

double vec_double_at(int vec_id, int index)
{
    int size = heap_read_int(vec_id + 0);
    if (index < 0 || index >= size)
    {
        // out of bounds, return NaN
        return 0.0 / 0.0; // For double vectors, NaN is used to signal invalid access
    }
    int data_offset = vec_id + 16 + index * sizeof(double);
    return heap_read_double(data_offset);
}

int vec_double_size(int vec_id)
{
    return heap_read_int(vec_id + 0);
}

double *vec_double_data(int vec_id)
{
    // Skip 16 bytes and return the physical address in memory
    return (double *)(&HEAP[vec_id + 16]);
}

bool vec_double_clear(int &vec_id)
{
    if (vec_id < 0)
    {
        return false;
    }

    heap_write_int(vec_id + 0, 0);
    return true;
}
void vec_double_insert(int &vec_id, int index, double value)
{
    int size = heap_read_int(vec_id + 0);
    int cap = heap_read_int(vec_id + 4);

    // invalid index
    if (index < 0 || index > size)
    {
        return;
    }

    // grow if needed
    if (size >= cap)
    {
        int new_cap = (cap == 0) ? 2 : cap * 2;
        int old_vec_id = vec_id;
        vec_double_reserve(vec_id, new_cap);

        // allocation failed
        if (vec_id == old_vec_id && heap_read_int(vec_id + 4) == cap)
        {
            return;
        }

        size = heap_read_int(vec_id + 0);
    }

    // shift elements right
    for (int i = size - 1; i >= index; i--)
    {
        double val = heap_read_double(vec_id + 16 + i * sizeof(double));
        heap_write_double(vec_id + 16 + (i + 1) * sizeof(double), val);
    }

    // insert value
    heap_write_double(vec_id + 16 + index * sizeof(double), value);

    // update size
    heap_write_int(vec_id + 0, size + 1);
}

void vec_double_erase(int vec_id, int index)
{
    int size = heap_read_int(vec_id + 0);

    if (index < 0 || index >= size)
    {
        return;
    }

    // shift left
    for (int i = index + 1; i < size; i++)
    {
        double val = heap_read_double(vec_id + 16 + i * sizeof(double));
        heap_write_double(vec_id + 16 + (i - 1) * sizeof(double), val);
    }

    heap_write_int(vec_id + 0, size - 1);
}

void vec_double_shrink_to_fit(int &vec_id)
{
    int size = heap_read_int(vec_id + 0);
    int cap = heap_read_int(vec_id + 4);

    if (size < cap)
    {
        int new_vec_id = vec_double_init(size);
        if (new_vec_id == -1)
        {
            return;
        }
        my_memcpy(new_vec_id + 16,
                  vec_id + 16,
                  size * sizeof(double));

        heap_write_int(new_vec_id + 0, size);

        vec_double_free(vec_id);
        vec_id = new_vec_id;
    }
}

int vec_double_copy(int vec_id)
{
    int size = heap_read_int(vec_id + 0);
    int cap = heap_read_int(vec_id + 4);

    int new_vec_id = vec_double_init(cap);
    if (new_vec_id == -1)
    {
        return -1;
    }

    my_memcpy(new_vec_id + 16,
              vec_id + 16,
              size * sizeof(double));

    heap_write_int(new_vec_id + 0, size);

    return new_vec_id;
}

void vec_double_erase_range(int vec_id, int first, int last)
{
    int size = heap_read_int(vec_id + 0);

    if (first < 0 || last > size || first >= last)
    {
        return;
    }

    int count = last - first;

    for (int i = last; i < size; i++)
    {
        double val = heap_read_double(vec_id + 16 + i * sizeof(double));
        heap_write_double(vec_id + 16 + (i - count) * sizeof(double), val);
    }

    heap_write_int(vec_id + 0, size - count);
}
void test_double_vector_and_free_list()
{
    // Initialize a vector with a capacity of 2
    int vec = vec_double_init(2);
    cout << "initialized double vector, ID=" << vec << ", size=" << vec_double_size(vec) << endl;

    // test pushing elements (should trigger growth/reserve)
    vec_double_push_back(vec, 10.5);
    vec_double_push_back(vec, 20.5);
    vec_double_push_back(vec, 30.5);

    cout << "after push_back 3 elements: ";
    for (int i = 0; i < vec_double_size(vec); i++)
        cout << vec_double_at(vec, i) << " ";
    cout << endl;

    // test insertion at a specific index
    vec_double_insert(vec, 1, 15.5);
    cout << "after insert 15.5 at index 1: ";
    for (int i = 0; i < vec_double_size(vec); i++)
        cout << vec_double_at(vec, i) << " ";
    cout << endl;

    // test erasing an element (shifts remaining elements)
    vec_double_erase(vec, 2);
    cout << "after erase index 2: ";
    for (int i = 0; i < vec_double_size(vec); i++)
        cout << vec_double_at(vec, i) << " ";
    cout << endl;

    // test erasing a range of elements
    vec_double_erase_range(vec, 0, 2);
    cout << "after erase_range 0-2: ";
    for (int i = 0; i < vec_double_size(vec); i++)
        cout << vec_double_at(vec, i) << " ";
    cout << endl;

    // test more pushes to see if it handles new data correctly
    vec_double_push_back(vec, 100.12);
    vec_double_push_back(vec, 200.34);
    vec_double_push_back(vec, 300.56);
    cout << "after pushing new values: ";
    for (int i = 0; i < vec_double_size(vec); i++)
        cout << vec_double_at(vec, i) << " ";
    cout << endl;

    // reallocate memory to match exact size (removes wasted capacity)
    vec_double_shrink_to_fit(vec);
    cout << "after shrink_to_fit: size=" << vec_double_size(vec) << endl;

    // test deep copy of the vector
    int vec_copy = vec_double_copy(vec);
    cout << "copied double vector, size=" << vec_double_size(vec_copy) << ", elements: ";
    for (int i = 0; i < vec_double_size(vec_copy); i++)
        cout << vec_double_at(vec_copy, i) << " ";
    cout << endl;

    // reset size to 0 but keep the allocated block
    vec_double_clear(vec);
    cout << "after clear: size=" << vec_double_size(vec) << endl;

    // ensure it can still accept new data after clearing
    vec_double_push_back(vec, 555.55);
    cout << "after push_back 555.55 on cleared vector: ";
    for (int i = 0; i < vec_double_size(vec); i++)
        cout << vec_double_at(vec, i) << " ";
    cout << endl;

    // free list reuse test
    int vec1 = vec_double_init(2);
    vec_double_push_back(vec1, 111.1);
    vec_double_push_back(vec1, 222.2);

    // release the vector's memory back to the global free list
    vec_double_free(vec1);
    cout << "after vec_double_free(vec1): free_list_head=" << free_list_head_double << endl;

    // visualize the free list chain
    cout << "Current free list: ";
    int cur = free_list_head_double;
    while (cur != -1)
    {
        cout << cur << " -> ";
        cur = heap_read_int(cur + 12); // Offset 12 is 'next_free' pointer
    }
    cout << "NULL" << endl;

    // test if the next initialization picks up the recently freed block
    int vec2 = vec_double_init(2);
    cout << "vec2 ID after init: " << vec2 << endl;

    if (vec2 == vec1)
        cout << "SUCCESS: vec2 reused the freed double-vec block!" << endl;
    else
        cout << "FAILURE: vec2 did NOT reuse the freed block." << endl;

    vec_double_push_back(vec2, 333.3);
    cout << "vec2 after push_back 333.3: ";
    for (int i = 0; i < vec_double_size(vec2); i++)
        cout << vec_double_at(vec2, i) << " ";
    cout << endl;
}