AnimaL

Tutorial

Documentation

---

Documentation

• Overview
• Modules
• Namespace List
• Class Hierarchy
• Alphabetical List
• Compound List
• File List
• Namespace Members
• Compound Members
• File Members
• Examples

---

matrix.h

Go to the documentation of this file.

#ifndef ANIMAL_MATRIX_H
#define ANIMAL_MATRIX_H

#include <iostream>
#include <vector>
#include <animal/linear.h>


namespace animal{

template<class T> struct Matrix;

template<class T>
struct matrix_traits<Matrix<T> >
{
    typedef T value_type;         
    static T ZERO() { return 0; } 
    static T ONE() { return 1; }  
};



template<class T>
struct Matrix
{

    Matrix( int nrow=0, int ncol=0 )
        : nr( nrow )
        , nc( ncol )
    {
        assert( nr >=0 ); assert( nc>=0 );
        value.resize(nr*nc);
    }
    
    void resize( int r, int c ){
        nr = r;
        nc = c;
        value.resize(nr*nc);
    }
    
    void fill( const T& v ){
        typename std::vector<T>::iterator i=value.begin(), iend=value.end();
        while( i!=iend ) 
            *i++ = v;
    }
    
    void setIdentity() {
        assert( nrows() == ncols() );
        fill( matrix_traits<Matrix<T> >::ZERO() );
        for( int i=0; i<nr; ++i )
            (*this)[i][i] = matrix_traits<Matrix<T> >::ONE();
    }
        
    T* operator[] (int r)
    {
        assert( r>=0 ); assert( r<nr );
        return &(value[nc*r]);
    }

    const T* operator[] (int r) const
    {
        assert( r>=0 ); assert( r<nr );
        return &(value[nc*r]);
    }
    
    int nrows() const { return nr; }

    int ncols() const { return nc; }
    
    template<class U> inline friend
    ::std::ostream& operator << (::std::ostream& out, const Matrix<U>& m){
        for( std::size_t i=0; i<animal::nrows(m); ++i ){
            for( std::size_t j=0; j<animal::ncols(m); ++j )
                out << m[i][j] << " ";
            out << "\n";
        }
        return out;
    }

    template<class U> inline friend
    ::std::istream& operator >> (::std::istream& in, animal::Matrix<U>& m )
    {
        for( std::size_t i=0; i<animal::nrows(m); ++i )
            for( std::size_t j=0; j<animal::ncols(m); ++j )
                in >> m[i][j]; 
        return in;
    }


private:
    std::vector<T> value;        
    int nr;          
    int nc;          
    
};
// compatibility with animal:

template<class T> inline
std::size_t nrows( const Matrix<T>& m ){ return m.nrows(); }

template<class T> inline
std::size_t  ncols( const Matrix<T>& m ){ return m.ncols(); }

template<class T> inline
const Matrix<T>& m_output(const Matrix<T>& m){ return m; }

template<class T> inline
Matrix<T>& m_input(Matrix<T>& m){ return m; }




}//animal



#endif

---