Matrices.hpp

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-2011 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_HPP
#define QPOASES_MATRICES_HPP


#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__ */


extern "C"
{
        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 * );
}


BEGIN_NAMESPACE_QPOASES


class Matrix
{
        public:
                Matrix( ) { doNotFreeMemory(); };

                virtual ~Matrix( ) { };

                virtual void free( ) = 0;

                virtual Matrix* duplicate( ) const = 0;

                virtual real_t diag(    int i                   
                                                                ) const = 0;

                virtual BooleanType isDiag( ) const = 0;

                virtual returnValue getRow(
                                int rNum,                                               
                                const Indexlist* const icols,   
                                real_t alpha,                                   
                                real_t *row                                             
                                ) const = 0;

                virtual returnValue getCol(
                                int cNum,                                               
                                const Indexlist* const irows,   
                                real_t alpha,                                   
                                real_t *col                                             
                                ) const = 0;

                virtual returnValue times (     int xN,                                 
                                                                        real_t alpha,                   
                                                                        const real_t *x,                
                                                                        int xLD,                                
                                                                        real_t beta,                    
                                                                        real_t *y,                              
                                                                        int yLD                                 
                                                                        ) const = 0;

                virtual returnValue transTimes (        int xN,                         
                                                                                        real_t alpha,           
                                                                                        const real_t *x,        
                                                                                        int xLD,                        
                                                                                        real_t beta,            
                                                                                        real_t *y,                      
                                                                                        int yLD                         
                                                                                        ) const = 0;

                virtual returnValue times (     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 = BT_TRUE    
                                                                        ) const = 0;

                virtual returnValue transTimes (        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                                                 
                                                                                        ) const = 0;

                virtual returnValue addToDiag(  real_t alpha            
                                                                                ) = 0;
                                                                                

                virtual returnValue print( ) const = 0;


                BooleanType needToFreeMemory( ) const { return freeMemory; };

                void doFreeMemory( ) { freeMemory = BT_TRUE; };
                
                void doNotFreeMemory( ) { freeMemory = BT_FALSE; };


        protected:
                        BooleanType freeMemory;                         
};


class SymmetricMatrix : public virtual Matrix
{
        public:

                virtual returnValue bilinear(
                                const Indexlist* const icols,   
                                int xN,                                                 
                                const real_t *x,                                
                                int xLD,                                                
                                real_t *y,                                              
                                int yLD                                                 
                                ) const = 0;

};


class DenseMatrix : public virtual Matrix
{
        public:
                DenseMatrix( ) : nRows(0), nCols(0), leaDim(0), val(0) {};

                DenseMatrix(    int m,                  
                                                int n,                  
                                                int lD,                 
                                                real_t *v               
                                                ) : nRows(m), nCols(n), leaDim(lD), val(v) {}


                virtual ~DenseMatrix();

                virtual void free( );

                virtual Matrix *duplicate( ) const;

                virtual real_t diag(    int i                   
                                                                ) const;

                virtual BooleanType isDiag( ) const;

                virtual returnValue getRow(
                                int rNum,                                               
                                const Indexlist* const icols,   
                                real_t alpha,                                   
                                real_t *row                                             
                                ) const;

                virtual returnValue getCol(
                                int cNum,                                               
                                const Indexlist* const irows,   
                                real_t alpha,                                   
                                real_t *col                                             
                                ) const;

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

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

                virtual returnValue times (     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 = BT_TRUE    
                                                                        ) const;

                virtual returnValue transTimes (        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                                                 
                                                                                        ) const;

                virtual returnValue addToDiag(  real_t alpha            
                                                                                );

                virtual returnValue print( ) const;


        protected:
                int nRows;                      
                int nCols;                      
                int leaDim;                     
                real_t *val;            
};


class SymDenseMat : public DenseMatrix, public SymmetricMatrix
{
        public:
                SymDenseMat() : DenseMatrix() {}

                SymDenseMat(    int m,                  
                                                int n,                  
                                                int lD,                 
                                                real_t *v               
                                                ) : DenseMatrix(m, n, lD, v) {}
                                                
                virtual Matrix *duplicate( ) const;

                virtual returnValue bilinear(
                                const Indexlist* const icols,   
                                int xN,                                                 
                                const real_t *x,                                
                                int xLD,                                                
                                real_t *y,                                              
                                int yLD                                                 
                                ) const;
};


class SparseMatrix : public virtual Matrix
{
        public:
                SparseMatrix();

                SparseMatrix(
                                long nr,                
                                long nc,                
                                long *r,                
                                long *c,                
                                real_t *v,              
                                long *d = 0             
                                );

                SparseMatrix(
                                int nr,                                 
                                int nc,                                 
                                int ld,                                 
                                const real_t * const v  
                                );

                virtual ~SparseMatrix();

                virtual void free( );

                virtual Matrix *duplicate( ) const;

                virtual real_t diag(    int i                   
                                                                ) const;

                virtual BooleanType isDiag( ) const;

                virtual returnValue getRow (
                                int rNum,                                               
                                const Indexlist* const icols,   
                                real_t alpha,                                   
                                real_t *row                                             
                                ) const;

                virtual returnValue getCol (
                                int cNum,                                               
                                const Indexlist* const irows,   
                                real_t alpha,                                   
                                real_t *col                                             
                                ) const;

                virtual returnValue times (     int xN,                                 
                                                                        real_t alpha,                   
                                                                        const real_t *x,                
                                                                        int xLD,                                
                                                                        real_t beta,                    
                                                                        real_t *y,                              
                                                                        int yLD                                 
                                                                        ) const;

                virtual returnValue transTimes (        int xN,                         
                                                                                        real_t alpha,           
                                                                                        const real_t *x,        
                                                                                        int xLD,                        
                                                                                        real_t beta,            
                                                                                        real_t *y,                      
                                                                                        int yLD                         
                                                                                        ) const;

                virtual returnValue times (     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 = BT_TRUE    
                                                                        ) const;

                virtual returnValue transTimes (        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                                                 
                                                                                        ) const;

                virtual returnValue addToDiag(  real_t alpha            
                                                                                );

                long *createDiagInfo();

                real_t *full() const;

                virtual returnValue print( ) const;


        protected:
                long nRows;                     
                long nCols;                     
                long *ir;                       
                long *jc;                       
                long *jd;                       
                real_t *val;            
};


class SymSparseMat : public SymmetricMatrix, public SparseMatrix
{
        public:
                SymSparseMat() : SparseMatrix() {}

                SymSparseMat(
                                long nr,                
                                long nc,                
                                long *r,                
                                long *c,                
                                real_t *v,              
                                long *d = 0             
                                ) : SparseMatrix(nr, nc, r, c, v, d) {}

                SymSparseMat(
                                int nr,                                 
                                int nc,                                 
                                int ld,                                 
                                const real_t * const v  
                                ) : SparseMatrix(nr, nc, ld, v) {}

                virtual Matrix *duplicate( ) const;


                virtual returnValue bilinear(
                                const Indexlist* const icols,   
                                int xN,                                                 
                                const real_t *x,                                
                                int xLD,                                                
                                real_t *y,                                              
                                int yLD                                                 
                                ) const;
};


END_NAMESPACE_QPOASES


#endif  /* QPOASES_MATRICES_HPP */