---

matrix_int.h

Go to the documentation of this file.

// matrix.h

//  This matrix class is a C++ wrapper for the GNU Scientific Library
//  Copyright (C) 2001 Ramin Nakisa

//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.

//  This program 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 General Public License for more details.

//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

#if !defined( _matrix_int_h )
#define _matrix_int_h

#include <iostream.h>
#include <fstream.h>
#include <iomanip.h>
#include <math.h>
#include <stdlib.h>

#include <gsl/gsl_math.h>
#include <gsl/gsl_matrix_int.h>
#include <gsl/gsl_linalg.h>
#include <gslwrap/permutation.h>
#include <gslwrap/vector_int.h>

#define type_is_int
#ifdef  type_is
#define type_is_double
#endif

namespace gsl
{

class matrix_int
{
#ifdef type_is_double
        friend class matrix_float;
        friend class matrix_int;
#endif
public:
        matrix_int();
        matrix_int( size_t new_rows, size_t new_cols, bool clear = true );

        void copy(const matrix_int &other)
        {
                set_dimensions(other.size1(),other.size2());
                gsl_matrix_int_memcpy( m, other.m );
        }
        template<class oclass>
        void copy(const oclass &other)
        {
                set_dimensions( other.get_rows(), other.get_cols() );
                for ( size_t i = 0; i < get_rows(); i++ ) 
                {
                        for ( size_t j = 0; j < get_cols(); j++ ) 
                        {
                                gsl_matrix_int_set( m, i, j, (int)other(i,j));
                        }
                }
        }
        matrix_int( const matrix_int &other ):m(NULL) {copy(other);}
        template<class oclass>
        matrix_int( const oclass &other ):m(NULL) {copy(other);}

        ~matrix_int();
//      matrix_int( const char *Filename );
        size_t get_rows() const {return m->size1;}
        size_t get_cols() const {return m->size2;}
        size_t size1() const {return m->size1;}
        size_t size2() const {return m->size2;}
   

        void dimensions( size_t *num_rows, size_t *num_cols ) const;
int        get_element ( size_t row, size_t col ) const {return  gsl_matrix_int_get( m, row, col ) ;}
        const int &operator()( size_t row, size_t col ) const {return *gsl_matrix_int_ptr( m, row, col ) ;}
int       &operator()( size_t row, size_t col )       {return *gsl_matrix_int_ptr( m, row, col ) ;}
        void set_element( size_t row, size_t col, const int &v ){ gsl_matrix_int_set( m, row, col, v );}
        void set_elements( const int & new_value );
        void set_all ( const int & new_value ) {gsl_matrix_int_set_all ( m, new_value );}
        void set_zero() {gsl_matrix_int_set_zero( m );}
        void set_dimensions( size_t new_rows, size_t new_cols );
        void load( const char *filename );
        void save( const char *filename ) const;
        friend ostream& operator<< ( ostream& os, const matrix_int& m );
        //This function writes the elements of the matrix m to the stream stream in binary format. The return value is 0 for success and GSL_EFAILED if there was a problem writing to the file. Since the data is written in the native binary format it may not be portable between different architectures.
        int fwrite (FILE * stream) const {return gsl_matrix_int_fwrite (stream, m);}

//This function reads into the matrix m from the open stream stream in binary format. The matrix m must be preallocated with the correct dimensions since the function uses the size of m to determine how many bytes to read. The return value is 0 for success and GSL_EFAILED if there was a problem reading from the file. The data is assumed to have been written in the native binary format on the same architecture. 
        int fread (FILE * stream) {return gsl_matrix_int_fread (stream, m);}

        void load_binary( const char *filename );
        void save_binary( const char *filename ) const;
        bool operator==( const matrix_int &other ) const;
        bool operator!=( const matrix_int &other ) const {return !((*this)==other);}

        matrix_int &operator=( const matrix_int &other ){copy(other);return *this;}
        template<class omatrix>
        matrix_int &operator=( const omatrix &other ){copy(other);return *this;}
        matrix_int operator+( const matrix_int &other ) const;
        matrix_int operator+( const int &f ) const;
        friend matrix_int operator+( const int &f, const matrix_int &other );
        matrix_int &operator+=( const int &f );
        matrix_int &operator+=( const matrix_int &other );
        matrix_int operator-( const matrix_int &other ) const;
        matrix_int operator-( const int &f ) const;
        friend matrix_int operator-( const int &f, const matrix_int &other );
        matrix_int &operator-=( const int &f );
        matrix_int &operator-=( const matrix_int &other );
        matrix_int operator*( const matrix_int &other ) const;
        matrix_int operator*( const int &f ) const;
        friend matrix_int operator*( const int &f, const matrix_int &other );
        matrix_int &operator*=( const int &f );
        matrix_int &operator*=( const matrix_int &other );
        matrix_int operator/( const int &) const;
        matrix_int &operator/=( const int &);
        matrix_int transpose() const;
        matrix_int LU_decomp(gsl::permutation *perm=NULL,int *psign=NULL) const;
        matrix_int LU_invert() const;
private:
        void LU_decomp( gsl_matrix_int **a,
                                        gsl_permutation **permutation,
                                        int *sign ) const;
public:
    int sum() const;
        double LU_lndet() const;


        vector_int_view       row( size_t rowindex );
        const vector_int_view row( size_t rowindex ) const ;
        vector_int_view       column( size_t colindex );
        const vector_int_view column( size_t colindex ) const;

        matrix_int get_row( size_t rowindex ) const;
        matrix_int get_col( size_t colindex ) const;
        matrix_int row_sum() const;
        matrix_int column_sum() const;
        double trace() const;
        int cholesky_decomp( matrix_int &a ) const;
//      /** returns index of nearest row in matrix to vector argument. */
//      int nearest_row_index( const matrix_int &v ) const;
        matrix_int covariance() const;
        bool is_square() const;
        void set_diagonal( int f );
        void identity( size_t k );
        double norm( double n ) const;

        gsl_matrix_int       *gslobj()       {if (!m){cout << "matrix_int::gslobj ERROR, data not initialized!! " << endl; exit(-1);}return m;}
        const gsl_matrix_int *gslobj() const {if (!m){cout << "matrix_int::gslobj ERROR, data not initialized!! " << endl; exit(-1);}return m;}
 private:
   gsl_matrix_int *m;

};
}
#undef type_is_int
#undef type_is_double

#endif // _matrix_int_h

---