dynamics.hpp

卡尔曼滤波类

// dynamics.hpp	     definition of a virtual class for 1-D dynamical systems
//		     manages the basic stuff, the actual calculations are done
//		     in a derived class

//                      (c) Copyright 1995, Everett F. Carter Jr.
//                      Permission is granted by the author to use
//			this software for any application provided this
//			copyright notice is preserved.

// rcsid: @(#)dynamics.hpp	1.4 12:37:49 6/3/96   EFC

#ifndef DYNAMICS_HPP_
#define DYNAMICS_HPP_ 1.4

#include <iostream.h>

#include <status.hpp>
#include <barray.hpp>
#include <vector.hpp>


class Dynamics : public virtual ErrorStatus
{
	private:
	   static int instances;

	protected:
           static char *name;          // name of the method
           static int namelen;

           ostream *es_os;             // where to send logging output (if used)

	   int n;
	   float t,dt;
	   Vector u;

	   void set_name(const char* newname);

	   virtual void input_data(const BasicArray& a);
	   virtual void input_data(const float* a);
	   virtual void input_data(const double* a);

	   virtual void output_data(BasicArray& a);
	   virtual void output_data(float* a);
	   virtual void output_data(double* a);

	   virtual void attach(ostream& os);

	public:
	   Dynamics(const int n_in,const float ndt,const char* nam = NULL);

	   Dynamics();
	   Dynamics(const Dynamics&);
           
	   virtual ~Dynamics();

	   Dynamics& operator=(const Dynamics&);

	  void init(const int n_in,const float ndt, const char* nam = NULL);


	  // these functions set the relevant parameter and return the OLD value
	  virtual float time(const float tt);
	  virtual int dimension(const int d);     // query/set system dimension
	  virtual float delta_t(const float h);   // query/set delta-t

	  // parameter query only functions
	  const char* method() const      { return name; }
	  float time()         const   	  { return t;    }
      	  virtual int dimension();
	  virtual float delta_t();

	  
	  virtual void step(const int) = 0;
	  virtual void reset()  { t = 0.0; u = 0.0; }

	  virtual ostream& parameter_settings(ostream& os);

	  void width(const int w)     { u.width( w ); }

	  // moving data into and out of the model
	  friend Dynamics& operator<<(Dynamics&,const BasicArray&);
  // friend Dynamics& operator<<(Dynamics&,const Vector&);
	  friend Dynamics& operator<<(Dynamics&,const float*);
	  friend Dynamics& operator<<(Dynamics&,const double*);

	  friend BasicArray& operator<<(BasicArray&, Dynamics&);
  // friend Vector& operator<<(Vector&, Dynamics&);	

	  friend float* operator<<(float*, Dynamics&);	
	  friend double* operator<<(double*, Dynamics&);	

	  // output model data directly
	  friend ostream& operator<<(ostream&, const Dynamics&);

	  Dynamics& operator++()            { step(1); return *this; }
	  Dynamics& operator+=(const int s) { step(s); return *this; }


          Dynamics& operator<<(ostream& os)	// attach logging output
			{ attach( os );   return *this; }

	// manipulators
	friend Dynamics& restart(Dynamics& s) { s.reset(); return s; }

	typedef Dynamics&(*DynManip)(Dynamics&);

	// applicator for the zero parameter manipulators
	friend Dynamics& operator<<(Dynamics& sb, DynManip f)
						 { f(sb); return sb; }


};


inline Dynamics& operator<<(Dynamics& d, const BasicArray& a)
	{ d.input_data( a );	return d; }

// inline Dynamics& operator<<(Dynamics& d, const Vector& a)
//	{ d.input_data( (BasicArray& )a );	return d; }

inline Dynamics& operator<<(Dynamics& d, const float* a)
	{ d.input_data( a );	return d; }


inline Dynamics& operator<<(Dynamics& d, const double* a)
	{ d.input_data( a );	return d; }



inline BasicArray& operator<<(BasicArray& v, Dynamics& d)
	{ d.output_data( v );	return v; }

//inline Vector& operator<<(Vector& v, Dynamics& d)
//	{ d.output_data( (BasicArray&)v );	return v; }

inline float* operator<<(float* v, Dynamics& d)
	{ d.output_data( v );	return v; }


inline double* operator<<(double* v, Dynamics& d)
	{ d.output_data( v );	return v; }

#endif