unit.h

Go to the documentation of this file.

 
#ifndef NEUR_UNIT_H
#define NEUR_UNIT_H
 
 
#include <fstream>
#include <stdio.h>
#include <iomanip>
#include <math.h>
#include <sys/types.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>
 

enum Neur_Types
{ 
  ENTREE, 
  CACHE, 
  SORTIE 
};
 
 
//      NEURONES

template <class T> class unit
{
  public:


  unit( const char *nom="", int typ=ENTREE, int xx=0, int yy=0, int zz=0, 
       T bia=0, T sor=0 )
  {     set(nom,typ,xx,yy,zz,bia,sor);       }

  ~unit()  { }


  unit<T> & operator = (const unit<T> & u);
  unit<T> & operator +(const unit<T> & u);
  unit<T> & operator -(const unit<T> & u);
  unit<T> & operator *(const unit<T> & u);
  unit<T> & operator /(const unit<T> & u);
  unit<T> & operator ^(const unit<T> & u);
  unit<T> & operator ++();
  unit<T> & operator +=(const unit<T> & u);
  unit<T> & operator -=(const unit<T> & u);
  unit<T> & operator *=(const unit<T> & u);
  unit<T> & operator /=(const unit<T> & u);
  inline int operator ==(const unit<T> & u) const;
  inline int operator !=(const unit<T> & u) const;
  inline int operator <(const unit<T> & u) const;
  inline int operator >(const unit<T> & u) const;
  inline int operator <=(const unit<T> & u) const;
  inline int operator >=(const unit<T> & u) const;


  const char *nm() const      { return(_nm);       }
  T     bi() const    { return(_bi);       }
  int   t() const      { return(_t); }
  T     o() const      { return(_o); }
  int   x() const      { return(_x); }
  int   y() const      { return(_y); }
  int   z() const      { return(_z); }


  void set( const char *nom, int typ, int xx, int yy, int zz, 
                   T bia, T sor);
  void set_nm(const char *nom);
  void set_t(int typ);
  void set_coord(int xx, int yy, int zz);
  void set_bi(T bia)      { _bi=bia;   }
  void set_o(T sor)        { _o=sor;     }


  void  aff() const;
 
 
  protected:

  void errtyp() const;

  char  _nm[12];             /* nom du neurone */
  T             _bi;         /* biais */
  int           _t;           /* type */
  T             _o;           /* etat de sortie */
  int           _x;
  int           _y;
  int           _z;           /* coordonnees du neurone */
};
 
 
// inline functions
 
template<class T> inline int unit<T>::operator == ( const unit<T> & u ) const
{
  return( (_t==u._t) && (_bi==u._bi) && (_x==u._x) && (_y==u._y) && (_z==u._z) 
          && !(strcmp(_nm, u._nm)) );
}
 
 
template<class T> inline int unit<T>::operator != ( const unit<T> & u ) const
{
  return( (_t!=u._t) || (_bi!=u._bi) || (_x!=u._x) || (_y!=u._y) || (_z!=u._z) 
          || strcmp(_nm, u._nm) );
}
 
 
template<class T> inline int unit<T>::operator < ( const unit<T> & u ) const
{
  return( _t < u._t );
}
 
 
template<class T> inline int unit<T>::operator > ( const unit<T> & u ) const
{
  return( _t > u._t );
}
 
 
template<class T> inline int unit<T>::operator <= ( const unit<T> & u ) const
{
  return( _t <= u._t );
}
 
 
template<class T> inline int unit<T>::operator >= ( const unit<T> & u ) const
{
  return( _t >= u._t );
}
 
 
 
 
#endif