Variable.h

Go to the documentation of this file.

//
//  Variable.h -- the abstract external variable (plug or port) class
//  See the copyright notice and acknowledgment of authors in the file COPYRIGHT
//

#ifndef CSL_Variable_H
#define CSL_Variable_H

#include "CSL_Core.h"

//#define USE_RANDOMS           // broken at present (can't link for libnewran.a)

#ifdef USE_RANDOMS
#include "newran/newran.h"      // random variables from Robert Davies
#endif

namespace csl {


class CVariable {       // abstract class

protected:
    float mValue;               
    
public:                         
    CVariable() { };
    CVariable(float tvalue) : mValue(tvalue) { };
    float value() { return(mValue); };
    void setValue(float x) { mValue = x; };
    void setValue(int x) { mValue = (float) x; };
    void setValue(double x) { mValue = (float) x; };
};


class StaticVariable : public CVariable, public UnitGenerator {

public:                     
    StaticVariable(float x) : CVariable(x), UnitGenerator() { }; 
    StaticVariable(int x) : CVariable((float) x), UnitGenerator() { }; 
    StaticVariable(double x) : CVariable((float) x), UnitGenerator() { }; 
    
    bool isFixed() { return true; };
    void nextBuffer(Buffer & outputBuffer, unsigned outBufNum) throw (CException);
    
    float value() { return(CVariable::value()); };
    void setValue(float x) { CVariable::setValue(x); };
    void setValue(int x) { CVariable::setValue(x); };
    void setValue(double x) { CVariable::setValue(x); };
};

// An enumeration for the possible arithmetic operations

#ifdef CSL_ENUMS
typedef enum {
    kOpPlus,
    kOpTimes,
    kOpMinus,
    kOpDivided,
    kOpNegated
} VOperator;
#else
    #define kOpPlus 1
    #define kOpTimes 2
    #define kOpMinus 3
    #define kOpDivided 4
    #define kOpNegated 5
    typedef int VOperator;
#endif


class DynamicVariable : public CVariable, public Effect {

protected:
    VOperator mMode;        
    
public:             
    DynamicVariable(UnitGenerator & vox, float val) : CVariable(val), Effect(vox), mMode(kOpTimes) { };
    DynamicVariable(UnitGenerator & vox, double val) : CVariable((float) val), Effect(vox), mMode(kOpTimes) { };
    DynamicVariable(float val, UnitGenerator & vox) : CVariable(val), Effect(vox), mMode(kOpTimes) { };
    DynamicVariable(float val, UnitGenerator & vox, VOperator m) :  CVariable(val), Effect(vox), mMode(m) { };
    DynamicVariable(UnitGenerator & vox, float val, VOperator m) :  CVariable(val), Effect(vox), mMode(m) { };

    DynamicVariable(int val, UnitGenerator & vox) : CVariable((float) val), Effect(vox), mMode(kOpTimes) { };
    DynamicVariable(UnitGenerator & vox, int val) : CVariable((float) val), Effect(vox), mMode(kOpTimes) { };
    DynamicVariable(int val, UnitGenerator & vox, VOperator m) :  CVariable((float) val), Effect(vox), mMode(m) { };
    DynamicVariable(UnitGenerator & vox, int val, VOperator m) :  CVariable((float) val), Effect(vox), mMode(m) { };

//  void nextBuffer(Buffer & outputBuffer) throw (CException);
    void nextBuffer(Buffer & outputBuffer, unsigned outBufNum) throw (CException);
    
    void setValue(float x) { CVariable::setValue(x); };
    void setValue(int x) { CVariable::setValue(x); };
    void setValue(double x) { CVariable::setValue(x); };
};

#ifdef USE_RANDOMS

#ifdef CSL_ENUMS


typedef enum {
    kUniform,
    kExponential,
    kCauchy,
    kNormal,
    kChiSq,
    kGamma,
    kPareto,
    kPoisson,
    kBinomial,
    kNegativeBinomial
} Distribution;

#endif


class RandomVariable : public CVariable, public UnitGenerator {
    
private:                // Newran stuff
    const static bool copySeedFromDisk = false; 
    MotherOfAll urng;                           
                        // Local stuff
    Random * mVar;              
    Distribution mDist;         
    float mMean;                
    float mVariance;            
    
public:                 
    RandomVariable(Distribution d, float mean, float variance, float v1, float v2);
    ~RandomVariable();
    void nextBuffer(Buffer & outputBuffer, unsigned outBufNum) throw (CException);
};

#endif // USE_RANDOMS

}

#endif