Matrices.h

Go to the documentation of this file.

/*
 *      This file is part of qpOASES.
 *
 *      qpOASES -- An Implementation of the Online Active Set Strategy.
 *      Copyright (C) 2007-2015 by Hans Joachim Ferreau, Andreas Potschka,
 *      Christian Kirches et al. All rights reserved.
 *
 *      qpOASES is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation; either
 *      version 2.1 of the License, or (at your option) any later version.
 *
 *      qpOASES is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *      See the GNU Lesser General Public License for more details.
 *
 *      You should have received a copy of the GNU Lesser General Public
 *      License along with qpOASES; if not, write to the Free Software
 *      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */


#ifndef QPOASES_MATRICES_H
#define QPOASES_MATRICES_H

#ifdef __USE_SINGLE_PRECISION__

        #define GEMM sgemm_

        #define SYR ssyr_

        #define SYR2 ssyr2_

        #define POTRF spotrf_

#else

        #define GEMM dgemm_

        #define SYR  dsyr_

        #define SYR2 dsyr2_

        #define POTRF dpotrf_

#endif /* __USE_SINGLE_PRECISION__ */


        void dgemm_ ( const char*, const char*, const unsigned long*, const unsigned long*, const unsigned long*,
                        const double*, const double*, const unsigned long*, const double*, const unsigned long*,
                        const double*, double*, const unsigned long* );
        void sgemm_ ( const char*, const char*, const unsigned long*, const unsigned long*, const unsigned long*,
                        const float*, const float*, const unsigned long*, const float*, const unsigned long*,
                        const float*, float*, const unsigned long* );

        void dsyr_ ( const char *, const unsigned long *, const double *, const double *,
                                 const unsigned long *, double *, const unsigned long *);
        void ssyr_ ( const char *, const unsigned long *, const float *, const float *,
                                 const unsigned long *, float *, const unsigned long *);

        void dsyr2_ ( const char *, const unsigned long *, const double *, const double *,
                                  const unsigned long *, const double *, const unsigned long *, double *, const unsigned long *);
        void ssyr2_ ( const char *, const unsigned long *, const float *, const float *,
                                  const unsigned long *, const float *, const unsigned long *, float *, const unsigned long *);

        void dpotrf_ ( const char *, const unsigned long *, double *, const unsigned long *, long * );
        void spotrf_ ( const char *, const unsigned long *, float *, const unsigned long *, long * );


#include <qpOASES_e/Indexlist.h>


BEGIN_NAMESPACE_QPOASES


typedef struct
{
        int nRows;                                      
        int nCols;                                      
        int leaDim;                                     
        real_t val[NVCMAX*NVMAX];       
} DenseMatrix;



void DenseMatrixCON(    DenseMatrix* _THIS,
                                                int m,                  
                                                int n,                  
                                                int lD,                 
                                                real_t *v               
                                                );

void DenseMatrixCPY(    DenseMatrix* FROM,
                                                DenseMatrix* TO
                                                );


void DenseMatrix_free( DenseMatrix* _THIS );

returnValue DenseMatrix_init(   DenseMatrix* _THIS,
                                                                int m,                  
                                                                int n,                  
                                                                int lD,                 
                                                                real_t *v               
                                                                );


real_t DenseMatrix_diag(        DenseMatrix* _THIS,
                                                        int i                   
                                                        );

BooleanType DenseMatrix_isDiag( DenseMatrix* _THIS );

real_t DenseMatrix_getNorm( DenseMatrix* _THIS,
                                                        int type                        
                                                        );

real_t DenseMatrix_getRowNorm(  DenseMatrix* _THIS,
                                                                int rNum,                       
                                                                int type                        
                                                                );

returnValue DenseMatrix_getRow( DenseMatrix* _THIS,
                                                                int rNum,                                               
                                                                const Indexlist* const icols,   
                                                                real_t alpha,                                   
                                                                real_t *row                                             
                                                                );

 returnValue DenseMatrix_getCol(        DenseMatrix* _THIS,
                                                                        int cNum,                                               
                                                                        const Indexlist* const irows,   
                                                                        real_t alpha,                                   
                                                                        real_t *col                                             
                                                                        );

returnValue DenseMatrix_times(  DenseMatrix* _THIS,
                                                                int xN,                                 
                                                                real_t alpha,                   
                                                                const real_t *x,                
                                                                int xLD,                                
                                                                real_t beta,                    
                                                                real_t *y,                              
                                                                int yLD                                 
                                                                );

returnValue DenseMatrix_transTimes(     DenseMatrix* _THIS,
                                                                        int xN,                         
                                                                        real_t alpha,           
                                                                        const real_t *x,        
                                                                        int xLD,                        
                                                                        real_t beta,            
                                                                        real_t *y,                      
                                                                        int yLD                         
                                                                        );

 returnValue DenseMatrix_subTimes(      DenseMatrix* _THIS,
                                                                        const Indexlist* const irows,   
                                                                        const Indexlist* const icols,   
                                                                        int xN,                                                 
                                                                        real_t alpha,                                   
                                                                        const real_t *x,                                
                                                                        int xLD,                                                
                                                                        real_t beta,                                    
                                                                        real_t *y,                                              
                                                                        int yLD,                                                
                                                                        BooleanType yCompr                              
                                                                        );

returnValue DenseMatrix_subTransTimes(  DenseMatrix* _THIS,
                                                                                const Indexlist* const irows,   
                                                                                const Indexlist* const icols,   
                                                                                int xN,                                                 
                                                                                real_t alpha,                                   
                                                                                const real_t *x,                                
                                                                                int xLD,                                                
                                                                                real_t beta,                                    
                                                                                real_t *y,                                              
                                                                                int yLD                                                 
                                                                                );

returnValue DenseMatrix_addToDiag(      DenseMatrix* _THIS,
                                                                        real_t alpha            
                                                                        );

returnValue DenseMatrix_print(  DenseMatrix* _THIS
                                                                );

static inline real_t* DenseMatrix_getVal( DenseMatrix* _THIS ) { return _THIS->val; }

returnValue DenseMatrix_bilinear(       DenseMatrix* _THIS,
                                                                        const Indexlist* const icols,   
                                                                        int xN,                                                 
                                                                        const real_t *x,                                
                                                                        int xLD,                                                
                                                                        real_t *y,                                              
                                                                        int yLD                                                 
                                                                        );



END_NAMESPACE_QPOASES


#endif  /* QPOASES_MATRICES_H */