t_matrix.hpp

Go to the documentation of this file.

/*
 *    This file is part of ACADO Toolkit.
 *
 *    ACADO Toolkit -- A Toolkit for Automatic Control and Dynamic Optimization.
 *    Copyright (C) 2008-2014 by Boris Houska, Hans Joachim Ferreau,
 *    Milan Vukov, Rien Quirynen, KU Leuven.
 *    Developed within the Optimization in Engineering Center (OPTEC)
 *    under supervision of Moritz Diehl. All rights reserved.
 *
 *    ACADO Toolkit 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 3 of the License, or (at your option) any later version.
 *
 *    ACADO Toolkit 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 ACADO Toolkit; if not, write to the Free Software
 *    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */


#ifndef ACADO_TOOLKIT_T_MATRIX_HPP
#define ACADO_TOOLKIT_T_MATRIX_HPP


BEGIN_NAMESPACE_ACADO

template <typename T>
class Tmatrix
{
  template <typename U> friend class Tmatrix;
  template <typename U> friend std::ostream& operator<<
    ( std::ostream&, const Tmatrix<U>& );
  template <typename U> friend Tmatrix<U> operator+
    ( const Tmatrix<U>& );
  template <typename U, typename V> friend Tmatrix<U> operator+
    ( const Tmatrix<U>&, const V& );
  template <typename U, typename V> friend Tmatrix<U> operator+
    ( const V&, const Tmatrix<U>& );
  template <typename U, typename V> friend Tmatrix<U> operator+
    ( const Tmatrix<U>&, const Tmatrix<V>& );
  template <typename U> friend Tmatrix<U> operator-
    ( const Tmatrix<U>& );
  template <typename U, typename V> friend Tmatrix<U> operator-
    ( const Tmatrix<U>&, const V& );
  template <typename U, typename V> friend Tmatrix<U> operator-
    ( const U&, const Tmatrix<V>& );
  template <typename U, typename V> friend Tmatrix<U> operator-
    ( const Tmatrix<U>&, const Tmatrix<V>& );
  template <typename U, typename V> friend Tmatrix<U> operator*
    ( const Tmatrix<U>&, const V& );
  template <typename U, typename V> friend Tmatrix<U> operator*
    ( const V&, const Tmatrix<U>& );
  template <typename U, typename V> friend Tmatrix<U> operator*
    ( const Tmatrix<U>&, const Tmatrix<V>& );
  template <typename U, typename V> friend Tmatrix<U> operator/
    ( const Tmatrix<U>&, const V& );

public:


  Tmatrix():
    _nr(0), _nc(0), _sub(false), _pcol(0), _prow(0), _pblock(0)
    {}
  Tmatrix
    ( const unsigned int nr, const unsigned int nc=1, const bool alloc=true ):
    _nr(nr), _nc(nc), _sub(!alloc), _pcol(0), _prow(0), _pblock(0)
    {
      unsigned int ne = nr*nc;
      for( unsigned int ie=0; ie<ne; ie++ ){
        T*pvall = ( alloc? new T: 0 );
        _data.push_back( pvall );
      }
    }
  template <typename U> Tmatrix
    ( const unsigned int nr, const unsigned int nc, const U&v,
      const bool alloc=true ):
    _nr(nr), _nc(nc), _sub(!alloc), _pcol(0), _prow(0), _pblock(0)
    {
      unsigned int ne = nr*nc;
      for( unsigned int ie=0; ie<ne; ie++ ){
        T*pvall = ( alloc? new T(v): 0 );
        _data.push_back( pvall );
      }
    }
  Tmatrix
    ( const Tmatrix<T>&M ):
    _nr(M._nr), _nc(M._nc), _sub(false), _pcol(0), _prow(0), _pblock(0)
    {
      typename std::vector<T*>::const_iterator it = M._data.begin();
      for( ; it!=M._data.end(); it++ ){
        T*pvall = new T(**it);
        _data.push_back( pvall );
      }
    }
  template <typename U> Tmatrix
    ( const Tmatrix<U>&M ):
    _nr(M._nr), _nc(M._nc), _sub(false), _pcol(0), _prow(0), _pblock(0)
    {
      typename std::vector<U*>::const_iterator it = M._data.begin();
      for( ; it!=M._data.end(); it++ ){
        T*pvall = new T(**it);
        _data.push_back( pvall );
      }
    }
  ~Tmatrix()
    {
      delete _pcol;
      delete _prow;
      delete _pblock;
      if( !_sub ) _reset();
    }

  void resize
    ( const unsigned int nr, const unsigned int nc=1, const bool alloc=true )
    {
      delete _pcol;
      delete _prow;
      delete _pblock;
      if( !_sub ) _reset();
      _nr = nr; _nc = nc; _sub = !alloc;
      _pcol = _prow = _pblock = 0;
      unsigned int ne = nr*nc;
      for( unsigned int ie=0; ie<ne; ie++ ){
        T*pvall = ( alloc? new T: 0 );
        _data.push_back( pvall );
      }
    }
  Tmatrix<T>& col
    ( const unsigned int ic );
  Tmatrix<T>& row
    ( const unsigned int ir );
  T*& pval
    ( const unsigned int ir, const unsigned int ic );
  unsigned int col() const
    { return _nc; };
  unsigned int row() const
    { return _nr; };
  T* array() const;
  void array
    ( const T*pM );

        unsigned int getDim() const{ return _nc*_nr; }
        unsigned int getNumRows() const{ return _nr; }
        unsigned int getNumCols() const{ return _nc; }
        
        
  Tmatrix<unsigned int> sort();
  T& operator()
    ( const unsigned int ir, const unsigned int ic );
  const T& operator()
    ( const unsigned int ir, const unsigned int ic ) const;
  T& operator()
    ( const unsigned int ie );
  const T& operator()
    ( const unsigned int ie ) const;
  Tmatrix<T>& operator=
  ( const Tmatrix<T>&M );
  Tmatrix<T>& operator=
  ( const T&m );
  template <typename U> Tmatrix<T>& operator+=
  ( const Tmatrix<U>&M );
  template <typename U> Tmatrix<T>& operator+=
  ( const U&m );
  template <typename U> Tmatrix<T>& operator-=
  ( const Tmatrix<U>&M );
  template <typename U> Tmatrix<T>& operator-=
  ( const U&m );
  template <typename U> Tmatrix<T>& operator*=
  ( const Tmatrix<U>&M );
  template <typename U> Tmatrix<T>& operator*=
  ( const U&m );
  template <typename U> Tmatrix<T>& operator/=
  ( const U&m );

private:

  unsigned int _nr;
  unsigned int _nc;
  std::vector<T*> _data;
  bool _sub;
  Tmatrix<T>* _pcol;
  Tmatrix<T>* _prow;
  Tmatrix<T>* _pblock;

  T& _val
    ( const unsigned int ir, const unsigned int ic );
  const T& _val
    ( const unsigned int ir, const unsigned int ic ) const;
  T& _val
    ( const unsigned int ie );
  const T& _val
    ( const unsigned int ie ) const;
  T*& _pval
    ( const unsigned int ie );
  void _reset();
  static unsigned int _digits
    ( unsigned int n );
};


template <typename T> inline T&
Tmatrix<T>::operator()
( const unsigned int ir, const unsigned int ic )
{
  return _val(ic*_nr+ir);
}

template <typename T> inline const T&
Tmatrix<T>::operator()
( const unsigned int ir, const unsigned int ic ) const
{
  return _val(ic*_nr+ir);
}

template <typename T> inline T&
Tmatrix<T>::operator()
( const unsigned int ie )
{
  return _val(ie);
}

template <typename T> inline const T&
Tmatrix<T>::operator()
( const unsigned int ie ) const
{
  return _val(ie);
}

template <typename T> inline T&
Tmatrix<T>::_val
( const unsigned int ir, const unsigned int ic )
{
  return _val(ic*_nr+ir);
}

template <typename T> inline const T&
Tmatrix<T>::_val
( const unsigned int ir, const unsigned int ic ) const
{
  return _val(ic*_nr+ir);
}

template <typename T> inline T&
Tmatrix<T>::_val
( const unsigned int ie )
{
  ASSERT( ie<_nr*_nc && ie>=0 );
  return *(_data[ie]);
}

template <typename T> inline const T&
Tmatrix<T>::_val
( const unsigned int ie ) const
{
  ASSERT( ie<_nr*_nc && ie>=0 );
  return *(_data[ie]);
}

template <typename T> inline T*&
Tmatrix<T>::pval
( const unsigned int ir, const unsigned int ic )
{
  return _pval(ic*_nr+ir);
}

template <typename T> inline T*&
Tmatrix<T>::_pval
( const unsigned int ie )
{
  ASSERT( ie<_nr*_nc && ie>=0 );
  return _data[ie];
}

template <typename T> inline void
Tmatrix<T>::_reset()
{
  typename std::vector<T*>::iterator it = _data.begin();
  for( ; it!=_data.end(); it++ ) delete *it;
}

template <typename T> inline Tmatrix<T>&
Tmatrix<T>::col
( const unsigned int ic )
{
  ASSERT( ic<_nc && ic>=0 );
  if( !_pcol ) _pcol = new Tmatrix<T>( _nr, 1, false );
  for( unsigned int ir=0; ir<_nr; ir++ ){
    _pcol->pval(ir,0) = pval(ir,ic);
#ifdef DEBUG__MATRIX_COL
    std::cout << ir << " , 0 : " << pval(ir,ic) << " "
              << _pcol->pval(ir,0) << std::endl;
#endif
  }
#ifdef DEBUG__MATRIX_COL
  std::cout << std::endl;
#endif
  return *_pcol;
}

template <typename T> inline Tmatrix<T>&
Tmatrix<T>::row
( const unsigned int ir )
{
  ASSERT( ir<_nr && ir>=0 );
  if( !_prow ) _prow = new Tmatrix<T>( 1, _nc, false );
  for( unsigned int ic=0; ic<_nc; ic++ ){
    _prow->pval(0,ic) = pval(ir,ic);
#ifdef DEBUG__MATRIX_ROW
    std::cout << "0 , " << ic << " : " << pval(ir,ic) << " "
              << _prow->pval(0,ic) << std::endl;
#endif
  }
#ifdef DEBUG__MATRIX_ROW
  std::cout << std::endl;
#endif
  return *_prow;
}

template <typename T> inline Tmatrix<T>&
Tmatrix<T>::operator=
( const Tmatrix<T>&M )
{
  if( M._nr!=_nr || M._nc!=_nc )
    resize( M._nr, M._nc );
  for( unsigned int ie=0; ie!=_nr*_nc; ie++ ){
    _val(ie) = M._val(ie);
  }
  return *this;
}

template <typename T> inline Tmatrix<T>&
Tmatrix<T>::operator=
( const T&m )
{
  for( unsigned int ie=0; ie!=_nr*_nc; ie++ ){
    _val(ie) = m;
  }
  return *this;
}

template <typename T> template <typename U> inline Tmatrix<T>&
Tmatrix<T>::operator+=
( const Tmatrix<U>&M )
{
  ASSERT( M._nr==_nr && M._nc==_nc );
  for( unsigned int ie=0; ie!=_nr*_nc; ie++ )
    _val(ie) += M._val(ie);
  return *this;
}

template <typename T> template <typename U> inline Tmatrix<T>&
Tmatrix<T>::operator+=
( const U&m )
{
  for( unsigned int ie=0; ie!=_nr*_nc; ie++ )
    _val(ie) += m;
  return *this;
}

template <typename T> template <typename U> inline Tmatrix<T>&
Tmatrix<T>::operator-=
( const Tmatrix<U>&M )
{
  ASSERT( M._nr==_nr && M._nc==_nc );
  for( unsigned int ie=0; ie!=_nr*_nc; ie++ )
    _val(ie) -= M._val(ie);
  return *this;
}

template <typename T> template <typename U> inline Tmatrix<T>&
Tmatrix<T>::operator-=
( const U&m )
{
  for( unsigned int ie=0; ie!=_nr*_nc; ie++ )
    _val(ie) -= m;
  return *this;
}

template <typename T> template <typename U> inline Tmatrix<T>&
Tmatrix<T>::operator*=
( const Tmatrix<U>&M )
{
  ASSERT( M._nr==M._nc && M._nr==_nc );
  for( unsigned int ir=0; ir<_nr; ir++ ){
    Tmatrix<T> irow = row(ir);
    for( unsigned int ic=0; ic<_nc; ic++ ){
      _val(ir,ic) = irow(0)*M(0,ic);
      for( unsigned int k=1; k<_nc; k++ ){
        _val(ir,ic) += irow(k)*M(k,ic);
      }
    }
  }
  return *this;
}

template <typename T> template <typename U> inline Tmatrix<T>&
Tmatrix<T>::operator*=
( const U&m )
{
  for( unsigned int ie=0; ie!=_nr*_nc; ie++ )
    _val(ie) *= m;
  return *this;
}

template <typename T> template <typename U> inline Tmatrix<T>&
Tmatrix<T>::operator/=
( const U&m )
{
  for( unsigned int ie=0; ie!=_nr*_nc; ie++ )
    _val(ie) /= m;
  return *this;
}

template <typename T> inline Tmatrix<T>
operator+
( const Tmatrix<T>&M )
{
  return M;
}

template <typename T, typename U> inline Tmatrix<T>
operator+
( const Tmatrix<T>&M, const Tmatrix<U>&N )
{
  Tmatrix<T> P( M );   
  P += N;
  return P;
}

template <typename T, typename U> inline Tmatrix<T>
operator+
( const Tmatrix<T>&M, const U&n )
{
  Tmatrix<T> P( M );
  P += n;
  return P;
}

template <typename T, typename U> inline Tmatrix<T>
operator+
( const U&m, const Tmatrix<T>&N )
{
  return N+m;
}

template <typename T> inline Tmatrix<T>
operator-
( const Tmatrix<T>&M )
{
  return -M;
}

template <typename T, typename U> inline Tmatrix<T>
operator-
( const Tmatrix<T>&M, const Tmatrix<U>&N )
{
  Tmatrix<T> P( M );
  P -= N;
  return P;
}

template <typename T, typename U> inline Tmatrix<T>
operator-
( const Tmatrix<T>&M, const U&n )
{
  Tmatrix<T> P( M );
  P -= n;
  return P;
}

template <typename T, typename U> inline Tmatrix<T>
operator-
( const T&m, const Tmatrix<U>&N )
{
  Tmatrix<T> P( -N );
  P += m;
  return P;
}

template <typename T, typename U> inline Tmatrix<T>
operator*
( const Tmatrix<T>&M, const Tmatrix<U>&N )
{
  ASSERT( M._nc==N._nr );
  Tmatrix<T> P( M._nr, N._nc );
  for( unsigned int ir=0; ir<M._nr; ir++ ){
    for( unsigned int ic=0; ic<N._nc; ic++ ){
      P(ir,ic) = M(ir,0)*N(0,ic);
      for( unsigned int k=1; k<M._nc; k++ ){
        P(ir,ic) += M(ir,k)*N(k,ic);
      }
    }
  }
  return P;
}

template <typename T, typename U> inline Tmatrix<T>
operator*
( const Tmatrix<T>&M, const U&n )
{
  Tmatrix<T> P( M );
  P *= n;
  return P;
}

template <typename T, typename U> inline Tmatrix<T>
operator*
( const U&m, const Tmatrix<T>&N )
{
  return N*m;
}

template <typename T, typename U> inline Tmatrix<T>
operator/
( const Tmatrix<T>&M, const U&n )
{
  Tmatrix<T> P( M );
  P /= n;
  return P;
}

template <typename T> inline std::ostream&
operator<<
( std::ostream& os, const Tmatrix<T>&M )
{
  for( unsigned int ir=0; ir<M._nr; ir++ )
    for( unsigned int ic=0; ic<M._nc; ic++ )
      os << ir << " , " << ic << " : " << M(ir,ic) << std::endl;
  return os;
}

template <typename T> inline T*
Tmatrix<T>::array() const
{
  T*pM = new T[_nr*_nc];
  for( unsigned int ic=0, ie=0; ic<_nc; ic++ )
    for( unsigned int ir=0; ir<_nr; ir++, ie++ )
      pM[ie] = _val (ir,ic);
  return pM;
}

template <typename T> inline void
Tmatrix<T>::array
( const T*pM )
{
  for( unsigned int ic=0, ie=0; ic<_nc; ic++ )
    for( unsigned int ir=0; ir<_nr; ir++, ie++ )
      _val(ir,ic) = pM[ie];
}


template <typename T> inline unsigned int
Tmatrix<T>::_digits
( unsigned int n )
{
  if( n == 0 ) return 1;
  int l = 0;
  while( n > 0 ){
    ++l;
    n /= 10;
  }
  return l;
}



CLOSE_NAMESPACE_ACADO


#endif  // ACADO_TOOLKIT_T_MATRIX_HPP

/*
 *      end of file
 */