plFloatVector.h

/*=============================================================================
 * Product        : OpenPL 
 * File           : plFloatVector.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_VECTOR_H
#define __FLOAT_VECTOR_H


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



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


#define Error_Number 15



class plFloatVector : public plObject
{
 protected:
  void Output(ostream &out) const;
  
 protected:
  void init(unsigned int r, bool init_to_zero);

 protected:  
  plFloat *v;       //le vecteur
  
  plFloat elem_check(unsigned int i) const;

  plFloat& elem_check(unsigned int i);

   unsigned int _size;
   
 public:
 
  unsigned int size()const{return _size;}
 
  // Constructeurs

  plFloatVector();

  plFloatVector(unsigned int r, float val);
  
  plFloatVector(unsigned int r, double val);
  
  plFloatVector(unsigned int r, long double val);
  
  plFloatVector(unsigned int r, bool init_to_zero = false);

  plFloatVector(unsigned int r, const float *float_vector);

  plFloatVector(unsigned int r, const double *double_vector);

  plFloatVector(unsigned int r, const long double *long_double_vector);

  explicit plFloatVector(const vector <float> &float_vector);

  explicit plFloatVector(const vector <double> &double_vector);

  explicit plFloatVector(const vector <long double> &long_double_vector);

  plFloatVector( const plFloatVector &v2);

  virtual ~plFloatVector();

  void resize(unsigned int r);

  // operators

  plFloatVector& operator=(const plFloatVector &);

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

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

  plFloatVector operator*(plFloat) const;
  
  friend plFloatVector operator*(plFloat ,const plFloatVector&);

  plFloat operator[](unsigned int i) const {return v[i];};

  plFloat& operator[](unsigned int i) {return v[i];};

  plFloat operator()(unsigned int i) const { return elem_check(i); };
  
  plFloat& operator()(unsigned int i) {return elem_check(i); }; 

  bool operator==(const plFloatVector&) const;  

  plFloat dot_product(const plFloatVector &a) const ; // pdt scalaire
  
  plFloatVector cross_product(const plFloatVector &a) const;

  plFloat normalize(plFloatVector &result) const;

  plFloat product() const;

  // friend class
  friend class plFloatMatrix;
  
  void reset(float val);
  
  void reset(double val);
  
  void reset(long double val);
  
  void reset();
};


#endif

---