plFloatMatrix.h

/*=============================================================================
 * Product        : OpenPL 
 * File           : plFloatMatrix.h
 * Author         : Christophe Coue
 * Creation       : Mar 12 2001
 *
 *=============================================================================
 *     (c) Copyright 2000, Centre National de la Recherche Scientifique,
 *                              all rights reserved
 *=============================================================================
 *
 *------------------------- Description ---------------------------------------
 *    for kalman filter
 *   
 *-----------------------------------------------------------------------------
*/
#ifndef __FLOAT_MATRIX_H
#define __FLOAT_MATRIX_H


#include <plObject.h>
#include <plMath.h>
#include <plFloatVector.h>
#include <plError.h>


#define Error_Number 15


/*****************************************************************************
 *                           Classes Definitions
 *****************************************************************************/


class plFloatMatrix :public plObject
{

protected:
  void Output(ostream &out) const;

  void init(unsigned int r, unsigned int c, bool init_to_zero);

 protected:  
  plFloat **m;

  unsigned int rz;
  unsigned int cz;


  plFloat elem_check(unsigned int r, unsigned int c) const;
  plFloat& elem_check(unsigned int r, unsigned int c);

 public:

  plFloatMatrix();
  
  plFloatMatrix( unsigned int r, unsigned int c, bool init_to_zero = false);

  plFloatMatrix( unsigned int d, bool init_to_zero = false);

  plFloatMatrix( unsigned int d, const float * float_vector);
   
  plFloatMatrix( unsigned int d, const double * double_vector);

  plFloatMatrix( unsigned int d, const long double * long_double_vector);

  
  explicit plFloatMatrix(const vector <float> &float_vector);
   
  explicit plFloatMatrix(const vector <double> &double_vector);

  explicit plFloatMatrix(const vector <long double> &long_double_vector);
  
  
  explicit plFloatMatrix(const vector <vector <float> > &stl_matrix);
   
  explicit plFloatMatrix(const vector <vector <double> > &stl_matrix);

  explicit plFloatMatrix(const vector <vector <long double> > &stl_matrix);

  plFloatMatrix( const plFloatMatrix &);

  explicit plFloatMatrix( const plFloatVector &diag_vector);

  void resize(unsigned int nr, unsigned int nc, bool init_to_zero = false);
  
  void resize(unsigned int nr, bool init_to_zero = false);

  virtual ~plFloatMatrix();

  unsigned int rows() const {return rz;};

  unsigned int cols() const {return cz;};

  plFloat operator()(unsigned int r, unsigned int c) const { return elem_check(r,c); };

  plFloat& operator()(unsigned int r, unsigned int c) { return elem_check(r,c); };

#ifndef RAVI_INTERFACE

  plFloat* operator[](unsigned int i) const { return m[i];};
  
  plFloat* operator[](unsigned int i) { return m[i];};
#endif

  plFloatVector row(unsigned int i) const;

  plFloatVector column(unsigned int j) const;  // construit un plFloatVector a partir de la colonne j 

  /* operateurs */

  plFloatMatrix& operator=(const plFloatMatrix &);

  plFloatMatrix operator+(const plFloatMatrix&) const; 
  
  
  plFloatMatrix &operator+=(const plFloatMatrix&);

  plFloatMatrix operator-(const plFloatMatrix&) const;
  
  plFloatMatrix &operator-=(const plFloatMatrix&);

  plFloatMatrix operator*(const plFloatMatrix&) const;

  friend plFloatMatrix operator*(const long double&,const plFloatMatrix&);

  friend plFloatMatrix operator*(const double&,const plFloatMatrix&);

  friend plFloatMatrix operator*(const float&,const plFloatMatrix&);
  
  friend plFloatMatrix operator*(const int&,const plFloatMatrix&);

  friend plFloatMatrix operator*(const unsigned int&,const plFloatMatrix&);


  
  plFloatVector operator*(const plFloatVector&) const;

  bool operator==(const plFloatMatrix&) const;

  plFloatMatrix transpose() const;

  void transpose(plFloatMatrix & result) const;

  plFloat trace() const;

  plFloat inverse(plFloatMatrix& inverse,plFloat threshold=PL_ONE) const;

  void diagonalize( plFloatMatrix& Eigen_Matrix , plFloatVector& Eigen_Vector) const;
  
  void reset();
  
  void reset(float val);
  
  void reset(double val);
  
  void reset(long double val);

};


#endif

---