matrices.h

Go to the documentation of this file.

/*
 * Copyright (c) 2019-2020 Kevin Townsend (KTOWN)
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_ZSL_MATRICES_H_
#define ZEPHYR_INCLUDE_ZSL_MATRICES_H_
 
#include <zsl/zsl.h>
#include <zsl/vectors.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define EEIGENSIZE   (100)
 
#define ECOMPLEXVAL  (101)
 
struct zsl_mtx {
    size_t sz_rows;
    size_t sz_cols;
    zsl_real_t *data;
};
 
#define ZSL_MATRIX_DEF(name, m, n); \
    zsl_real_t name ## _mtx[m * n]; \
    struct zsl_mtx name = {     \
        .sz_rows = m,       \
        .sz_cols = n,       \
        .data = name ## _mtx    \
    }
 /* End of MTX_STRUCTS group */
 
typedef enum zsl_mtx_unary_op {
    ZSL_MTX_UNARY_OP_INCREMENT,             
    ZSL_MTX_UNARY_OP_DECREMENT,             
    ZSL_MTX_UNARY_OP_NEGATIVE,
    ZSL_MTX_UNARY_OP_ROUND,
    ZSL_MTX_UNARY_OP_ABS,
    ZSL_MTX_UNARY_OP_FLOOR,
    ZSL_MTX_UNARY_OP_CEIL,
    ZSL_MTX_UNARY_OP_EXP,
    ZSL_MTX_UNARY_OP_LOG,
    ZSL_MTX_UNARY_OP_LOG10,
    ZSL_MTX_UNARY_OP_SQRT,
    ZSL_MTX_UNARY_OP_SIN,
    ZSL_MTX_UNARY_OP_COS,
    ZSL_MTX_UNARY_OP_TAN,
    ZSL_MTX_UNARY_OP_ASIN,
    ZSL_MTX_UNARY_OP_ACOS,
    ZSL_MTX_UNARY_OP_ATAN,
    ZSL_MTX_UNARY_OP_SINH,
    ZSL_MTX_UNARY_OP_COSH,
    ZSL_MTX_UNARY_OP_TANH,
} zsl_mtx_unary_op_t;
 
typedef enum zsl_mtx_binary_op {
    ZSL_MTX_BINARY_OP_ADD,                  
    ZSL_MTX_BINARY_OP_SUB,                  
    ZSL_MTX_BINARY_OP_MULT,                 
    ZSL_MTX_BINARY_OP_DIV,                  
    ZSL_MTX_BINARY_OP_MEAN,                 
    ZSL_MTX_BINARY_OP_EXPON,                
    ZSL_MTX_BINARY_OP_MIN,                  
    ZSL_MTX_BINARY_OP_MAX,                  
    ZSL_MTX_BINARY_OP_EQUAL,                
    ZSL_MTX_BINARY_OP_NEQUAL,               
    ZSL_MTX_BINARY_OP_LESS,                 
    ZSL_MTX_BINARY_OP_GREAT,                
    ZSL_MTX_BINARY_OP_LEQ,                  
    ZSL_MTX_BINARY_OP_GEQ,                  
} zsl_mtx_binary_op_t;
 /* End of MTX_OPERANDS group */
 
typedef int (*zsl_mtx_unary_fn_t)(struct zsl_mtx *m, size_t i, size_t j);
 
typedef int (*zsl_mtx_binary_fn_t)(struct zsl_mtx *ma, struct zsl_mtx *mb,
                   struct zsl_mtx *mc, size_t i, size_t j);
 
typedef int (*zsl_mtx_init_entry_fn_t)(struct zsl_mtx *m, size_t i, size_t j);
 
int zsl_mtx_entry_fn_empty(struct zsl_mtx *m, size_t i, size_t j);
 
int zsl_mtx_entry_fn_identity(struct zsl_mtx *m, size_t i, size_t j);
 
int zsl_mtx_entry_fn_random(struct zsl_mtx *m, size_t i, size_t j);
 
int zsl_mtx_init(struct zsl_mtx *m, zsl_mtx_init_entry_fn_t entry_fn);
 
int zsl_mtx_from_arr(struct zsl_mtx *m, zsl_real_t *a);
 
int zsl_mtx_copy(struct zsl_mtx *mdest, struct zsl_mtx *msrc);
 /* End of MTX_INIT group */
 
int zsl_mtx_get(struct zsl_mtx *m, size_t i, size_t j, zsl_real_t *x);
 
int zsl_mtx_set(struct zsl_mtx *m, size_t i, size_t j, zsl_real_t x);
 
int zsl_mtx_get_row(struct zsl_mtx *m, size_t i, zsl_real_t *v);
 
int zsl_mtx_set_row(struct zsl_mtx *m, size_t i, zsl_real_t *v);
 
int zsl_mtx_get_col(struct zsl_mtx *m, size_t j, zsl_real_t *v);
 
int zsl_mtx_set_col(struct zsl_mtx *m, size_t j, zsl_real_t *v);
 /* End of MTX_DATAACCESS group */
 
int zsl_mtx_unary_op(struct zsl_mtx *m, zsl_mtx_unary_op_t op);
 
int zsl_mtx_unary_func(struct zsl_mtx *m, zsl_mtx_unary_fn_t fn);
 
int zsl_mtx_binary_op(struct zsl_mtx *ma, struct zsl_mtx *mb,
              struct zsl_mtx *mc, zsl_mtx_binary_op_t op);
 
int zsl_mtx_binary_func(struct zsl_mtx *ma, struct zsl_mtx *mb,
            struct zsl_mtx *mc, zsl_mtx_binary_fn_t fn);
 /* End of MTX_OPERANDS group */
 
int zsl_mtx_add(struct zsl_mtx *ma, struct zsl_mtx *mb, struct zsl_mtx *mc);
 
int zsl_mtx_add_d(struct zsl_mtx *ma, struct zsl_mtx *mb);
 
int zsl_mtx_sum_rows_d(struct zsl_mtx *m, size_t i, size_t j);
 
int zsl_mtx_sum_rows_scaled_d(struct zsl_mtx *m, size_t i, size_t j,
                  zsl_real_t s);
 
int zsl_mtx_sub(struct zsl_mtx *ma, struct zsl_mtx *mb, struct zsl_mtx *mc);
 
int zsl_mtx_sub_d(struct zsl_mtx *ma, struct zsl_mtx *mb);
 
int zsl_mtx_mult(struct zsl_mtx *ma, struct zsl_mtx *mb, struct zsl_mtx *mc);
 
int zsl_mtx_mult_d(struct zsl_mtx *ma, struct zsl_mtx *mb);
 
int zsl_mtx_scalar_mult_d(struct zsl_mtx *m, zsl_real_t s);
 
int zsl_mtx_scalar_mult_row_d(struct zsl_mtx *m, size_t i, zsl_real_t s);
 /* End of MTX_BASICMATH group */
 
int zsl_mtx_trans(struct zsl_mtx *ma, struct zsl_mtx *mb);
 
int zsl_mtx_adjoint_3x3(struct zsl_mtx *m, struct zsl_mtx *ma);
 
int zsl_mtx_adjoint(struct zsl_mtx *m, struct zsl_mtx *ma);
 
#ifndef CONFIG_ZSL_SINGLE_PRECISION
 
int zsl_mtx_vec_wedge(struct zsl_mtx *m, struct zsl_vec *v);
#endif
 
int zsl_mtx_reduce(struct zsl_mtx *m, struct zsl_mtx *mr, size_t i, size_t j);
 
/* NOTE: This is used for household method/QR. Should it be in the main lib? */
int zsl_mtx_reduce_iter(struct zsl_mtx *m, struct zsl_mtx *mred);
 
/* NOTE: This is used for household method/QR. Should it be in the main lib? */
int zsl_mtx_augm_diag(struct zsl_mtx *m, struct zsl_mtx *maug);
 
int zsl_mtx_deter_3x3(struct zsl_mtx *m, zsl_real_t *d);
 
int zsl_mtx_deter(struct zsl_mtx *m, zsl_real_t *d);
 
int zsl_mtx_gauss_elim(struct zsl_mtx *m, struct zsl_mtx *mg,
               struct zsl_mtx *mi, size_t i, size_t j);
 
int zsl_mtx_gauss_elim_d(struct zsl_mtx *m, struct zsl_mtx *mi,
             size_t i, size_t j);
 
int zsl_mtx_gauss_reduc(struct zsl_mtx *m, struct zsl_mtx *mi,
            struct zsl_mtx *mg);
 
int zsl_mtx_cols_norm(struct zsl_mtx *m, struct zsl_mtx *mnorm);
 
int zsl_mtx_gram_schmidt(struct zsl_mtx *m, struct zsl_mtx *mort);
 
int zsl_mtx_norm_elem(struct zsl_mtx *m, struct zsl_mtx *mn, struct zsl_mtx *mi,
              size_t i, size_t j);
 
int zsl_mtx_norm_elem_d(struct zsl_mtx *m, struct zsl_mtx *mi,
            size_t i, size_t j);
 
int zsl_mtx_inv_3x3(struct zsl_mtx *m, struct zsl_mtx *mi);
 
int zsl_mtx_inv(struct zsl_mtx *m, struct zsl_mtx *mi);
 
int zsl_mtx_cholesky(struct zsl_mtx *m, struct zsl_mtx *l);
 
int zsl_mtx_balance(struct zsl_mtx *m, struct zsl_mtx *mout);
 
int zsl_mtx_householder(struct zsl_mtx *m, struct zsl_mtx *h, bool hessenberg);
 
int zsl_mtx_qrd(struct zsl_mtx *m, struct zsl_mtx *q, struct zsl_mtx *r,
        bool hessenberg);
 
#ifndef CONFIG_ZSL_SINGLE_PRECISION
 
int zsl_mtx_qrd_iter(struct zsl_mtx *m, struct zsl_mtx *mout, size_t iter);
#endif
 
#ifndef CONFIG_ZSL_SINGLE_PRECISION
 
int zsl_mtx_eigenvalues(struct zsl_mtx *m, struct zsl_vec *v, size_t iter);
#endif
 
#ifndef CONFIG_ZSL_SINGLE_PRECISION
 
int zsl_mtx_eigenvectors(struct zsl_mtx *m, struct zsl_mtx *mev, size_t iter,
             bool orthonormal);
#endif
 
#ifndef CONFIG_ZSL_SINGLE_PRECISION
 
int zsl_mtx_svd(struct zsl_mtx *m, struct zsl_mtx *u, struct zsl_mtx *e,
        struct zsl_mtx *v, size_t iter);
#endif
 
#ifndef CONFIG_ZSL_SINGLE_PRECISION
 
int zsl_mtx_pinv(struct zsl_mtx *m, struct zsl_mtx *pinv, size_t iter);
#endif
 /* End of MTX_TRANSFORMATIONS group */
 
int zsl_mtx_min(struct zsl_mtx *m, zsl_real_t *x);
 
int zsl_mtx_max(struct zsl_mtx *m, zsl_real_t *x);
 
int zsl_mtx_min_idx(struct zsl_mtx *m, size_t *i, size_t *j);
 
int zsl_mtx_max_idx(struct zsl_mtx *m, size_t *i, size_t *j);
 /* End of MTX_LIMITS group */
 
bool zsl_mtx_is_equal(struct zsl_mtx *ma, struct zsl_mtx *mb);
 
bool zsl_mtx_is_notneg(struct zsl_mtx *m);
 
bool zsl_mtx_is_sym(struct zsl_mtx *m);
 /* End of MTX_COMPARISON group */
 
int zsl_mtx_print(struct zsl_mtx *m);
 
// int      zsl_mtx_fprint(FILE *stream, zsl_mtx *m);
 /* End of MTX_DISPLAY group */
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_ZSL_MATRICES_H_ */
 /* End of matrices group */