mat.h

Go to the documentation of this file.

/* -*- mode: C; c-basic-offset: 4 -*- */
/* ex: set shiftwidth=4 tabstop=4 expandtab: */
/*
 * Copyright (c) 2018-2019, Colorado School of Mines
 * All rights reserved.
 *
 * Author(s): Neil T. Dantam <ndantam@miens.edu>
 * Georgia Tech Humanoid Robotics Lab
 * Under Direction of Prof. Mike Stilman <mstilman@cc.gatech.edu>
 *
 *
 * This file is provided under the following "BSD-style" License:
 *
 *
 *   Redistribution and use in source and binary forms, with or
 *   without modification, are permitted provided that the following
 *   conditions are met:
 *
 *   * Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *
 *   * Redistributions in binary form must reproduce the above
 *     copyright notice, this list of conditions and the following
 *     disclaimer in the documentation and/or other materials provided
 *     with the distribution.
 *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
 *   CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
 *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 *   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 *   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
 *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 *   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 *   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *   POSSIBILITY OF SUCH DAMAGE.
 *
 */
 
#ifndef AMINO_MAT_H
#define AMINO_MAT_H
 
#include <cblas.h>
 
typedef size_t aa_la_size;
 
struct aa_dvec {
    aa_la_size len;   
    double *data; 
    aa_la_size inc;   
};
 
struct aa_dmat {
    aa_la_size rows;    
    aa_la_size cols;    
    double *data;   
    aa_la_size ld;      
};
 
 
#define AA_DVEC_REF(v,i) ((v)->data[(i) * (v)->inc])
 
#define AA_DMAT_REF(M,i,j) (((M)->data)[(M)->ld*(j) + (i)])
 
 
typedef void
(aa_la_err_fun)( const char *message );
 
AA_API void
aa_la_err( const char *message );
 
AA_API void
aa_la_set_err( aa_la_err_fun *fun );
 
 
#define AA_VEC_ARGS(X) (X->data), ((int)(X->inc))
 
#define AA_MAT_ARGS(X) (X->data), ((int)(X->ld))
 
/* Construction */
 
static inline struct aa_dvec
AA_DVEC_INIT( aa_la_size len, double *data, aa_la_size inc )
{
    struct aa_dvec vec = {len, data, inc};
    return vec;
}
 
static inline void
AA_DVEC_VIEW(struct aa_dvec *vec, aa_la_size len, double *data, aa_la_size inc)
{
    *vec = AA_DVEC_INIT(len,data,inc);
}
 
AA_API void
aa_dvec_view( struct aa_dvec *vec, aa_la_size len, double *data, aa_la_size inc );
 
 
AA_API void
aa_dmat_view( struct aa_dmat *mat, aa_la_size rows, aa_la_size cols, double *data, aa_la_size ld );
 
AA_API void
aa_dmat_view_block( struct aa_dmat *dst,
                    const struct aa_dmat *src,
                    aa_la_size row_start, aa_la_size col_start,
                    aa_la_size rows, aa_la_size cols );
 
AA_API void
aa_dvec_slice( const struct aa_dvec *src,
               aa_la_size start,
               aa_la_size stop,
               aa_la_size step,
               struct aa_dvec *dst );
 
 
AA_API void
aa_dmat_block( const struct aa_dmat *src,
               aa_la_size row_start, aa_la_size col_start,
               aa_la_size row_end, aa_la_size col_end,
               struct aa_dmat *dst );
 
AA_API void
aa_dmat_row_vec( const struct aa_dmat *src, aa_la_size row, struct aa_dvec *dst );
 
AA_API void
aa_dmat_col_vec( const struct aa_dmat *src, aa_la_size col, struct aa_dvec *dst );
 
AA_API void
aa_dmat_diag_vec( const struct aa_dmat *src, struct aa_dvec *dst );
 
 
static inline struct aa_dmat
AA_DMAT_INIT( aa_la_size rows, aa_la_size cols, double *data, aa_la_size ld )
{
    struct aa_dmat mat;
    mat.rows = rows;
    mat.cols = cols;
    mat.data = data;
    mat.ld = ld;
    return mat;
}
 
static inline void
AA_DMAT_VIEW(struct aa_dmat *mat, aa_la_size rows, aa_la_size cols, double *data, aa_la_size ld)
{
    *mat = AA_DMAT_INIT(rows,cols,data,ld);
}
 
#define AA_MAT_DIAG(VEC,MAT)                                    \
    aa_dvec_view((VEC), (MAT)->cols, (MAT)->data, 1+(MAT)->ld);
 
AA_API struct aa_dvec *
aa_dvec_alloc( struct aa_mem_region *reg, aa_la_size len );
 
 
AA_API struct aa_dvec *
aa_dvec_dup( struct aa_mem_region *reg, const struct aa_dvec *src);
 
AA_API struct aa_dvec *
aa_dvec_mdup(const struct aa_dvec *src);
 
AA_API struct aa_dmat *
aa_dmat_dup( struct aa_mem_region *reg, const struct aa_dmat *src);
 
AA_API struct aa_dmat *
aa_dmat_mdup(const struct aa_dmat *src);
 
AA_API struct aa_dmat *
aa_dmat_alloc( struct aa_mem_region *reg, aa_la_size rows, aa_la_size cols );
 
AA_API struct aa_dvec *
aa_dvec_malloc( aa_la_size len );
 
AA_API struct aa_dmat *
aa_dmat_malloc( aa_la_size rows, aa_la_size cols );
 
AA_API void
aa_dvec_zero( struct aa_dvec *vec );
 
AA_API void
aa_dvec_set( struct aa_dvec *vec, double alpha );
 
AA_API void
aa_dmat_set( struct aa_dmat *A, double alpha, double beta );
 
AA_API void
aa_dmat_zero( struct aa_dmat *mat );
 
/* Level 1 BLAS */
 
AA_API void
aa_dvec_swap( struct aa_dvec *x, struct aa_dvec *y );
 
AA_API void
aa_dvec_scal( double alpha, struct aa_dvec *x );
 
AA_API void
aa_dvec_inc( double alpha, struct aa_dvec *x );
 
AA_API void
aa_dvec_copy( const struct aa_dvec *x, struct aa_dvec *y );
 
 
AA_API void
aa_dvec_axpy( double a, const struct aa_dvec *x, struct aa_dvec *y );
 
AA_API double
aa_dvec_dot( const struct aa_dvec *x, struct aa_dvec *y );
 
AA_API double
aa_dvec_nrm2( const struct aa_dvec *x );
 
/* Level 2 BLAS */
 
AA_API void
aa_dmat_gemv( AA_CBLAS_TRANSPOSE trans,
              double alpha, const struct aa_dmat *A,
              const struct aa_dvec *x,
              double beta, struct aa_dvec *y );
 
 
 
/* Level 3 BLAS */
 
AA_API void
aa_dmat_gemm( AA_CBLAS_TRANSPOSE transA, AA_CBLAS_TRANSPOSE transB,
              double alpha, const struct aa_dmat *A,
              const struct aa_dmat *B,
              double beta, struct aa_dmat *C );
 
 
 
 
/* LAPACK */
 
AA_API void
aa_dmat_lacpy( const char uplo[1],
               const struct aa_dmat *A,
               struct aa_dmat *B );
 
 
 
/* Matrix/Vector Functions */
 
AA_API double
aa_dvec_ssd( const struct aa_dvec *x, const struct aa_dvec *y);
 
 
AA_API void
aa_dmat_axpy( double alpha, const struct aa_dmat *X, struct aa_dmat *Y);
 
AA_API double
aa_dmat_ssd( const struct aa_dmat *x, const struct aa_dmat *y);
 
AA_API void
aa_dmat_scal( struct aa_dmat *A, double alpha );
 
AA_API void
aa_dmat_inc( struct aa_dmat *A, double alpha );
 
AA_API double
aa_dmat_nrm2( const struct aa_dmat *x );
 
 
AA_API void
aa_dmat_trans( const struct aa_dmat *A, struct aa_dmat *At);
 
 
AA_API int
aa_dmat_inv( struct aa_dmat *A);
 
 
AA_API int
aa_dmat_pinv( const struct aa_dmat *A, double tol, struct aa_dmat *As);
 
AA_API int
aa_dmat_dpinv( const struct aa_dmat *A, double k, struct aa_dmat *As);
 
AA_API int
aa_dmat_dzdpinv(  const struct aa_dmat *A, double s_min, struct aa_dmat *As);
 
AA_API void
aa_dmat_copy(  const struct aa_dmat *A, struct aa_dmat *B);
 
 
#endif /* AMINO_MAT_H */