utils.c

#include "utils.h"

void* safeMalloc(size_t size, char *msg) 
{
    void* ptr = malloc(size);
    if (!ptr) 
    {
        perror(msg);
        exit(1);
    }
    return ptr;
}

void* safeCalloc(size_t nmemb, size_t size, char *msg) 
{
    void* ptr = calloc(nmemb, size);
    if (!ptr) 
    {
        perror(msg);
        exit(1);
    }
    return ptr;
}

void* safeRealloc(void *p, size_t size, char *msg) 
{
    void* ptr = realloc(p, size);
    if (!ptr) 
    {
        perror(msg);
        exit(1);
    }
    return ptr;
}

void daIsNullCheck(DynamicArray *da)
{
    if (!da)
    {
        fprintf(stderr, "Error: NULL dynamic array\n");
        exit(1);
    }
    
}

bool daNeedsResize(size_t size, size_t capacity)
{
    return size == capacity;
}

bool daIndexInBounds(size_t size, size_t idx)
{
    return idx < size;
}

size_t tensorComputeSize(size_t ndim, const size_t *shape)
{
    size_t size = 1;
    for (size_t i = 0; i < ndim; i++)
        size *= shape[i];
    return size;
}

void tensorComputeStrides(size_t ndim, const size_t *shape, size_t *strides)
{
    strides[ndim - 1] = 1;
    for (size_t i = ndim - 1; i-- > 0; )
        strides[i] = strides[i + 1] * shape[i + 1];
}

void tensorIsNullCheck(Tensor *t)
{
    if (!t)
    {
        fprintf(stderr, "Error: NULL tensor\n");
        exit(1);
    }
    
}

void linearToIndices(size_t linear, const size_t *shape, const size_t *strides, size_t ndim, size_t *out)
{
    for (size_t i = 0; i < ndim; i++)
    {
        out[i] = linear / strides[i];
        linear %= strides[i];
    }
}

size_t indicesToLinear(const size_t *indices, const size_t *strides, size_t ndim)
{
    size_t linear = 0;

    for (size_t i = 0; i < ndim; i++)
        linear += indices[i] * strides[i];

    return linear;
}