dense_storage.c

浏览该文件的文档.

 
#include <string.h>
#include "memory_bridge.h"
#include "internal.h"
#include "lmmc/config.h"
#include "lmmc/dense.h"
#include "lmmc/linear_algebra.h"
 
 
lmmc_status_t lmmc_mat_create(size_t rows, size_t cols, lmmc_mat_t* out_mat) {
    size_t n_elem = 0;
    size_t n_bytes = 0;
    lmmc_real_t* data = NULL;
 
    if (out_mat == NULL || rows == 0 || cols == 0) {
        return LMMC_STATUS_INVALID_ARGUMENT;
    }
    if (!lmmc_safe_mul_size(rows, cols, &n_elem) ||
        !lmmc_safe_mul_size(n_elem, sizeof(lmmc_real_t), &n_bytes)) {
        return LMMC_STATUS_INVALID_ARGUMENT;
    }
 
    data = (lmmc_real_t*)lmmc_memory_alloc(n_bytes);
    if (data == NULL) {
        return LMMC_STATUS_ALLOCATION_FAILED;
    }
    memset(data, 0, n_bytes);
 
    for (size_t i = 0; i < rows * cols; ++i) {
        LMMC_REAL_INIT(&data[i]);
    }
 
    out_mat->rows = rows;
    out_mat->cols = cols;
    out_mat->stride = cols;
    out_mat->data = data;
    out_mat->owns_data = 1;
    return LMMC_STATUS_OK;
}
 
lmmc_status_t lmmc_mat_wrap(size_t rows, size_t cols, size_t stride, lmmc_real_t* data, lmmc_mat_t* out_mat) {
    lmmc_mat_t candidate;
    if (out_mat == NULL) {
        return LMMC_STATUS_INVALID_ARGUMENT;
    }
    candidate.rows = rows;
    candidate.cols = cols;
    candidate.stride = stride;
    candidate.data = data;
    candidate.owns_data = 0;
    if (!lmmc_mat_descriptor_is_valid(&candidate)) {
        return LMMC_STATUS_INVALID_ARGUMENT;
    }
    *out_mat = candidate;
    return LMMC_STATUS_OK;
}
 
void lmmc_mat_destroy(lmmc_mat_t* mat) {
    if (mat == NULL) {
        return;
    }
    if (mat->owns_data && mat->data != NULL) {
        for (size_t i = 0; i < mat->rows * mat->cols; ++i) {
            LMMC_REAL_CLEAR(&mat->data[i]);
        }
        lmmc_memory_free(mat->data);
    }
    mat->rows = 0;
    mat->cols = 0;
    mat->stride = 0;
    mat->data = NULL;
    mat->owns_data = 0;
}
 
lmmc_status_t lmmc_mat_fill(lmmc_mat_t* mat, lmmc_real_t value) {
    size_t i = 0;
    size_t j = 0;
    if (!lmmc_mat_descriptor_is_valid(mat)) {
        return LMMC_STATUS_INVALID_ARGUMENT;
    }
    for (i = 0; i < mat->rows; ++i) {
        for (j = 0; j < mat->cols; ++j) {
            LMMC_REAL_SET(&mat->data[i * mat->stride + j], &value);
        }
    }
    return LMMC_STATUS_OK;
}
 
lmmc_status_t lmmc_mat_copy(const lmmc_mat_t* src, lmmc_mat_t* dst) {
    size_t i = 0;
    size_t j = 0;
    if (!lmmc_mat_descriptor_is_valid(src) ||
        !lmmc_mat_descriptor_is_valid(dst)) {
        return LMMC_STATUS_INVALID_ARGUMENT;
    }
    if (src->rows != dst->rows || src->cols != dst->cols) {
        return LMMC_STATUS_DIMENSION_MISMATCH;
    }
    for (i = 0; i < src->rows; ++i) {
        for (j = 0; j < src->cols; ++j) {
            LMMC_REAL_SET(&dst->data[i * dst->stride + j], &src->data[i * src->stride + j]);
        }
    }
    return LMMC_STATUS_OK;
}
 
lmmc_status_t lmmc_mat_transpose_to(const lmmc_mat_t* src, lmmc_mat_t* dst) {
    size_t i = 0;
    size_t j = 0;
    if (!lmmc_mat_descriptor_is_valid(src) ||
        !lmmc_mat_descriptor_is_valid(dst)) {
        return LMMC_STATUS_INVALID_ARGUMENT;
    }
    if (dst->rows != src->cols || dst->cols != src->rows) {
        return LMMC_STATUS_DIMENSION_MISMATCH;
    }
    {
        lmmc_storage_envelope_t src_envelope;
        lmmc_storage_envelope_t dst_envelope;
        if (!lmmc_storage_envelope_checked(src->data, src->rows, src->cols,
                                           src->stride, sizeof(lmmc_real_t),
                                           &src_envelope) ||
            !lmmc_storage_envelope_checked(dst->data, dst->rows, dst->cols,
                                           dst->stride, sizeof(lmmc_real_t),
                                           &dst_envelope)) {
            return LMMC_STATUS_INVALID_ARGUMENT;
        }
        if (lmmc_storage_envelopes_overlap(&src_envelope, &dst_envelope)) {
            return LMMC_STATUS_INVALID_ARGUMENT;
        }
    }
    for (i = 0; i < src->rows; ++i) {
        for (j = 0; j < src->cols; ++j) {
            LMMC_REAL_SET(&dst->data[j * dst->stride + i], &src->data[i * src->stride + j]);
        }
    }
    return LMMC_STATUS_OK;
}
 
lmmc_status_t lmmc_vec_create(size_t size, lmmc_vec_t* out_vec) {
    size_t n_bytes = 0;
    lmmc_real_t* data = NULL;
    if (out_vec == NULL || size == 0) {
        return LMMC_STATUS_INVALID_ARGUMENT;
    }
    if (!lmmc_safe_mul_size(size, sizeof(lmmc_real_t), &n_bytes)) {
        return LMMC_STATUS_INVALID_ARGUMENT;
    }
    data = (lmmc_real_t*)lmmc_memory_alloc(n_bytes);
    if (data == NULL) {
        return LMMC_STATUS_ALLOCATION_FAILED;
    }
    memset(data, 0, n_bytes);
 
    for (size_t i = 0; i < size; ++i) {
        LMMC_REAL_INIT(&data[i]);
    }
 
    out_vec->size = size;
    out_vec->data = data;
    out_vec->owns_data = 1;
    return LMMC_STATUS_OK;
}
 
lmmc_status_t lmmc_vec_wrap(size_t size, lmmc_real_t* data, lmmc_vec_t* out_vec) {
    lmmc_vec_t candidate;
    if (out_vec == NULL) {
        return LMMC_STATUS_INVALID_ARGUMENT;
    }
    candidate.size = size;
    candidate.data = data;
    candidate.owns_data = 0;
    if (!lmmc_vec_descriptor_is_valid(&candidate)) {
        return LMMC_STATUS_INVALID_ARGUMENT;
    }
    *out_vec = candidate;
    return LMMC_STATUS_OK;
}
 
void lmmc_vec_destroy(lmmc_vec_t* vec) {
    if (vec == NULL) {
        return;
    }
    if (vec->owns_data && vec->data != NULL) {
        for (size_t i = 0; i < vec->size; ++i) {
            LMMC_REAL_CLEAR(&vec->data[i]);
        }
        lmmc_memory_free(vec->data);
    }
    vec->size = 0;
    vec->data = NULL;
    vec->owns_data = 0;
}
 
lmmc_status_t lmmc_vec_fill(lmmc_vec_t* vec, lmmc_real_t value) {
    size_t i = 0;
    if (!lmmc_vec_descriptor_is_valid(vec)) {
        return LMMC_STATUS_INVALID_ARGUMENT;
    }
    for (i = 0; i < vec->size; ++i) {
        LMMC_REAL_SET(&vec->data[i], &value);
    }
    return LMMC_STATUS_OK;
}
 
lmmc_status_t lmmc_vec_copy(const lmmc_vec_t* src, lmmc_vec_t* dst) {
    if (!lmmc_vec_descriptor_is_valid(src) ||
        !lmmc_vec_descriptor_is_valid(dst)) {
        return LMMC_STATUS_INVALID_ARGUMENT;
    }
    if (src->size != dst->size) {
        return LMMC_STATUS_DIMENSION_MISMATCH;
    }
 
    for (size_t i = 0; i < src->size; ++i) {
        LMMC_REAL_SET(&dst->data[i], &src->data[i]);
    }
    return LMMC_STATUS_OK;
}
 
lmmc_status_t lmmc_vec_swap(lmmc_vec_t* x, lmmc_vec_t* y) {
    if (!lmmc_vec_descriptor_is_valid(x) ||
        !lmmc_vec_descriptor_is_valid(y)) {
        return LMMC_STATUS_INVALID_ARGUMENT;
    }
    if (x->size != y->size) {
        return LMMC_STATUS_DIMENSION_MISMATCH;
    }
 
    for (size_t i = 0; i < x->size; ++i) {
        lmmc_swap(&x->data[i], &y->data[i]);
    }
    return LMMC_STATUS_OK;
}