/*******************************************************
*
*  DESCRIPTION: Signal class 
*
*  AUTHOR: Mariana C. D'Abreu
*
*  EMAIL: mdabreu@dc.uba.ar
*
********************************************************/ 

#ifndef _SIGNAL_H
#define _SIGNAL_H

#include <math.h>
#include <string>
#include "except.h"
#include "value.h"

typedef RealValue STime;

#define DEF_OFFSET	0
#define DEF_STRTIME	0

/************************************
 * Clase de Senal abstracta
 ************************************/

class Signal {
  
  public:
    
    static Signal *create( const string &sname );

    virtual ~Signal() {};

    double getOffset() const
   	{ return offset; }

    double getStartTime() const
	{ return startTime; }

    void setOffset( const double offset )
	{ this->offset = offset; }
  
    void setStartTime( const double startTime )
	{ this->startTime = startTime; }
  
    virtual RealValue s  ( const STime t )  const = 0;
    RealValue         der( const STime t )  const;

    virtual bool      isContinuous() const = 0;
    virtual bool      isDerivable()  const = 0;

    virtual int       paramCount() const = 0;
    const string      paramName ( const unsigned int ) const;
    const RealValue   paramValue( const unsigned int ) const;
    Signal            &setParam ( const unsigned int, const RealValue & );

    virtual string    name() const = 0;
    virtual string    info() const;

  protected:
  
    Signal( const double offset = DEF_OFFSET, const double startTime = DEF_STRTIME ) 
	{ this->offset = offset; this->startTime = startTime; }   

    virtual const string      pName ( const unsigned int ) const = 0;
    virtual const RealValue   pValue( const unsigned int ) const = 0;
    virtual Signal            &set  ( const unsigned int, const RealValue & ) = 0;
    virtual RealValue         derivative( STime t ) const = 0;

    double  offset;
    double  startTime;
};  

/************************************
 * Excepcions
 ************************************/
class SignalException : public MException {
  
  public:

    const string type() const
      { return "SignalException"; }
};


class PulseSignalException : public SignalException {
  
  public:

    const string type() const
      { return "PulseSignalException"; }
};


/*************************************
 *
 * Clase para Senales concretas
 *
 *************************************/

/************************************
 * Constant signal
 ************************************/

class ConstantSignal : public Signal {

  public:
    
    ConstantSignal();
    ConstantSignal( const RealValue &, const double offset = DEF_OFFSET, const double strTime = DEF_STRTIME );
    ~ConstantSignal() {};

    virtual RealValue s( const STime t )  const
      { return k; }
    
    virtual bool      isContinuous() const
      { return true; }
  
    virtual bool      isDerivable() const
      { return true; }
    
    virtual int       paramCount() const 
      { return 1; }
    
    virtual string    name() const
      { return "Constant"; }
    
    static  const RealValue DefaultConstant;

  protected:
  
    virtual const string    pName ( const unsigned int index ) const
      { return "constant"; }

    virtual const RealValue pValue( const unsigned int index ) const
      { return k; }
    
    virtual Signal          &set  ( const unsigned int index, const RealValue &value ) 
      { k = value; return *this; }

    virtual RealValue       derivative( const STime t ) const
      { return 0; }
    
  private:

    RealValue k;
};

//--- inline functions ---
inline
ConstantSignal::ConstantSignal()
  :Signal()
{
  k = DefaultConstant;
}

inline
ConstantSignal::ConstantSignal( const RealValue &K, const double offset, const double startTime )
  :Signal( offset, startTime )
{
  k = K;
}

/************************************
 * Step signal
 ************************************/

class StepSignal : public Signal {

  public:
    
    StepSignal();
    StepSignal( const RealValue &, const double offset = DEF_OFFSET, const double strTime = DEF_STRTIME );
    ~StepSignal() {};

    virtual RealValue s( const STime t )  const;
      
    virtual bool      isContinuous() const
      { return false; }
  
    virtual bool      isDerivable() const
      { return false; }
    
    virtual int       paramCount() const 
      { return 1; }
    
    virtual string    name() const
      { return "Step"; }
    
    static const RealValue DefaultHeight;
    
  protected:
  
    virtual const string    pName ( const unsigned int index ) const;
      
    virtual const RealValue pValue( const unsigned int index ) const;
      
    virtual Signal          &set  ( const unsigned int index, const RealValue &value );
      
    virtual RealValue       derivative( const STime t ) const;
      
  private:

    RealValue height;
};

//--- inline functions ---
inline
StepSignal::StepSignal()
  :Signal()
{
  height = DefaultHeight;
}

inline
StepSignal::StepSignal( const RealValue &height, const double offset, const double strTime )
  :Signal( offset, strTime )
{
  this->height = height;
}

inline
RealValue StepSignal::s( const STime t ) const {
  return ( offset + ( t < startTime ? 0 : height ) );
}

/************************************
 * Sine signal
 ************************************/

class SineSignal : public Signal {

  public:
    
    SineSignal();
    SineSignal( const RealValue &, const RealValue &, const RealValue &, const double offset = DEF_OFFSET, const double strTime = DEF_STRTIME );
    ~SineSignal() {};

    virtual RealValue s( const STime t )  const;
    virtual STime     inv( const RealValue v, const STime t ) const; 
      
    virtual bool      isContinuous() const
      { return true; }
  
    virtual bool      isDerivable() const
      { return true; }
    
    virtual int       paramCount() const 
      { return 3; }
    
    virtual string    name() const
      { return "Sine"; }
    
    static const RealValue DefaultAmplitude;
    static const RealValue DefaultPhase;
    static const RealValue DefaultWaveFreq;

  protected:
  
    virtual const string    pName ( const unsigned int index ) const;
      
    virtual const RealValue pValue( const unsigned int index ) const;
      
    virtual Signal          &set  ( const unsigned int index, const RealValue &value );
      
    virtual RealValue       derivative( const STime t ) const;
      
  private:

    RealValue amplitude;
    RealValue phase;
    RealValue wavefreq;
};

/************************************
 * Ramp signal
 ************************************/

class RampSignal : public Signal {

  public:
    
    RampSignal();
    RampSignal( const RealValue &, const RealValue &, const double offset = DEF_OFFSET, const double strTime = DEF_STRTIME );
    ~RampSignal() {};

    virtual RealValue s( const STime t )  const;
      
    virtual bool      isContinuous() const
      { return true; }
  
    virtual bool      isDerivable() const
      { return false; }
    
    virtual int       paramCount() const 
      { return 2; }
    
    virtual string    name() const
      { return "Ramp"; }
    
    static const RealValue DefaultHeight;
    static const RealValue DefaultDuration;
 
  protected:
  
    virtual const string    pName ( const unsigned int index ) const;
      
    virtual const RealValue pValue( const unsigned int index ) const;
      
    virtual Signal          &set  ( const unsigned int index, const RealValue &value );
      
    virtual RealValue       derivative( const STime t ) const;
      
  private:

    RealValue height;
    RealValue duration;
};

/************************************
 * ExpSine signal
 ************************************/

class ExpSineSignal : public Signal {

  public:
    
    ExpSineSignal();
    ExpSineSignal( const RealValue &, const RealValue &, const RealValue &, const RealValue &, const double offset = DEF_OFFSET, const double strTime = DEF_STRTIME );
    ~ExpSineSignal() {};

    virtual RealValue s( const STime t )  const;
      
    virtual bool      isContinuous() const
      { return true; }
  
    virtual bool      isDerivable() const
      { return true; }
    
    virtual int       paramCount() const 
      { return 4; }
    
    virtual string    name() const
      { return "ExpSine"; }
    
    static const RealValue DefaultAmplitude;
    static const RealValue DefaultPhase;
    static const RealValue DefaultWaveFreq;
    static const RealValue DefaultDamping;

  protected:
  
    virtual const string    pName ( const unsigned int index ) const;
      
    virtual const RealValue pValue( const unsigned int index ) const;
      
    virtual Signal          &set  ( const unsigned int index, const RealValue &value );
      
    virtual RealValue       derivative( const STime t ) const;
      
  private:

    RealValue amplitude;
    RealValue phase;
    RealValue wavefreq;            
    RealValue damping;
};

/************************************
 * Exponential signal
 ************************************/

class ExponentialSignal : public Signal {

  public:
    
    ExponentialSignal();
    ExponentialSignal( const RealValue &, const RealValue &, const RealValue &, const RealValue &, const double offset = DEF_OFFSET, const double strTime = DEF_STRTIME );
    ~ExponentialSignal() {};

    virtual RealValue s( const STime t )  const;
      
    virtual bool      isContinuous() const
      { return true; }
  
    virtual bool      isDerivable() const
      { return false; }
    
    virtual int       paramCount() const 
      { return 4; }
    
    virtual string    name() const
      { return "Exponential"; }
    
    static const RealValue DefaultHeight;
    static const RealValue DefaultRiseTime;
    static const RealValue DefaultRiseTimeConst;
    static const RealValue DefaultFallTimeConst;

  protected:
  
    virtual const string    pName ( const unsigned int index ) const;
      
    virtual const RealValue pValue( const unsigned int index ) const;
      
    virtual Signal          &set  ( const unsigned int index, const RealValue &value );
      
    virtual RealValue       derivative( const STime t ) const;
      
  private:

    RealValue height;
    RealValue riseTime;
    RealValue riseTimeConst;
    RealValue fallTimeConst;

};

/************************************
 * Pulse signal
 ************************************/

class PulseSignal : public Signal {

  public:
    
    PulseSignal();
    PulseSignal( const RealValue &, const RealValue &, const RealValue &, const double offset = DEF_OFFSET, const double strTime = DEF_STRTIME );
    ~PulseSignal() {};

    virtual RealValue s( const STime t )  const;
      
    virtual bool      isContinuous() const
      { return false; }
  
    virtual bool      isDerivable() const
      { return false; }
    
    virtual int       paramCount() const 
      { return 3; }
    
    virtual string    name() const
      { return "Pulse"; }
    
    static const RealValue DefaultAmplitude;
    static const RealValue DefaultWidth;
    static const RealValue DefaultPeriod;
 
  protected:
  
    virtual const string    pName ( const unsigned int index ) const;
      
    virtual const RealValue pValue( const unsigned int index ) const;
      
    virtual Signal          &set  ( const unsigned int index, const RealValue &value );
      
    virtual RealValue       derivative( const STime t ) const;
      
    virtual RealValue       periodInit( const STime t ) const;
    
  private:

    RealValue amplitude;
    RealValue width;
    RealValue period;
    RealValue nwidth;
};

#endif