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( size_t len, double *data, size_t inc )
{
    struct aa_dvec vec;
    vec.len = len;
    vec.data = data;
    vec.inc = inc;
    return vec;
}

AA_API void
aa_dvec_view( struct aa_dvec *vec, size_t len, double *data, size_t inc );

AA_API void
aa_dmat_view( struct aa_dmat *mat, size_t rows, size_t cols, double *data, size_t ld );

AA_API void
aa_dmat_view_block( struct aa_dmat *dst,
                    const struct aa_dmat *src,
                    size_t row_start, size_t col_start,
                    size_t rows, size_t cols );

AA_API void
aa_dvec_slice( const struct aa_dvec *src,
               size_t start,
               size_t stop,
               size_t step,
               struct aa_dvec *dst );


AA_API void
aa_dmat_block( const struct aa_dmat *src,
               size_t row_start, size_t col_start,
               size_t row_end, size_t col_end,
               struct aa_dmat *dst );

AA_API void
aa_dmat_row_vec( const struct aa_dmat *src, size_t row, struct aa_dvec *dst );

AA_API void
aa_dmat_col_vec( const struct aa_dmat *src, size_t 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( size_t rows, size_t cols, double *data, size_t ld )
{
    struct aa_dmat mat;
    mat.rows = rows;
    mat.cols = cols;
    mat.data = data;
    mat.ld = ld;
    return mat;
}


#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, size_t len );


AA_API struct aa_dvec *
aa_dvec_dup( struct aa_mem_region *reg, 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_alloc( struct aa_mem_region *reg, size_t rows, size_t cols );

AA_API struct aa_dvec *
aa_dvec_malloc( size_t len );

AA_API struct aa_dmat *
aa_dmat_malloc( size_t rows, size_t 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( 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( CBLAS_TRANSPOSE transA, 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 */