---

valuegen.h

Go to the documentation of this file.

#ifndef __VALUEGEN_H__
#define __VALUEGEN_H__

#ifndef NO_VALGEN_STRINGS
/* Optional: support for reading expressions from strings
   and showing state as a string */
#include "stringutils.h"
#include "msg.h"
#endif

#include "vgen.h"
#include "allocatingpointer.h"
#include "shuffledrand.h"
#include "mathconstants.h"

/******************************************************************************/
/* General-purpose random-value generators for various distributions          */
/******************************************************************************/


namespace Distributions {

struct uniform {
  double operator() ( double mean=0.5, double radius=0.5)
    {  return mean + 2.0*radius*(shuffled_rand() - 0.5); }
};



struct normal {
  double operator() ( double mean=0.0, double radius=1.0)
    {  return mean + radius*(sqrt((-2.0) * log(shuffled_rand())) * cos(2*(Math::pi) * shuffled_rand()));  }
};

}


/******************************************************************************/
/* ValueGenerator objects                                                     */
/******************************************************************************/
template<class T=double>
class ValueGenerator : public ValueGen {
  typedef ValueGenerator<T> self;
  AllocatingPointer<T> v;
  
public:
  ValueGenerator(T  value=T()) : v(value)  { }

  ValueGenerator(T* value)     : v(value) { }
  
#ifndef NO_VALGEN_STRINGS
  ValueGenerator(StringArgs& args) {  args.next(T(),v.valueptrref());  }

  virtual string stringrep() const
    {  return String::stringrep(value());  }
#endif

  virtual ~ValueGenerator() { }

  T operator*() const {  return *v;  }

  T value() const { return *v; }

  T* valueptr() const {  return v.valueptr();  }

  virtual void relink(T* ptr) {  v.relink(ptr);  }
  
  virtual bool next()  { return true; }
  virtual void reset() { }

  virtual ValueGenerator<T>* clone() const { return new self(*this); };
};


typedef ValueGenerator<double> DGen;



template<class T=double, class RandomGen=Distributions::uniform>
class ValueGenerator_Random : public ValueGenerator<T> {
  typedef ValueGenerator_Random<T,RandomGen> self;
  T v; 
  AllocatingPointer<T> m,r;

public:
  ValueGenerator_Random(T mean, T radius=0)
    : ValueGenerator<T>(&v), v(mean),   m(mean),  r(radius) { }

  ValueGenerator_Random(T* mean, T* radius)
    : ValueGenerator<T>(&v), v(*mean), m(mean), r(radius) { }

#ifndef NO_VALGEN_STRINGS
  ValueGenerator_Random(StringArgs& args) : ValueGenerator<T>(&v) {
    args.next(T(),m.valueptrref()); v = *m;
    args.next(T(),r.valueptrref());
  }

  virtual string stringrep() const
    {  return "Random " + String::stringrep(*m) + " " + String::stringrep(*r);  }
#endif

  ValueGenerator_Random(const self& other)
    : ValueGenerator<T>(&v), v(other.v), m(other.m), r(other.r)  { }

  virtual bool next()
    {  v = RandomGen()( *m, *r ); return true; }

  virtual void reset() { v=*m; } // Resets to mean value
  
  virtual ValueGenerator<T>* clone() const { return new ValueGenerator_Random(*this); };
};



template<class T=double, class RandomGen=Distributions::uniform, bool crop=true>
class ValueGenerator_Correlate : public ValueGenerator<T> {
  typedef ValueGenerator_Correlate<T,RandomGen,crop> self;
  T v; 
  AllocatingPointer<T> lb,ub,m,uncorr;

public:
  ValueGenerator_Correlate(T* master_value_ptr, T* uncorrelation_ptr,
                           T lower_bound, T upper_bound)
    : ValueGenerator<T>(&v), v(*master_value_ptr),
    lb(lower_bound), ub(upper_bound),
    m(master_value_ptr), uncorr(uncorrelation_ptr) { }

#ifndef NO_VALGEN_STRINGS

  ValueGenerator_Correlate(StringArgs& args, T* ref=0)
    : ValueGenerator<T>(&v) {
    if (ref) m=ref;
    else     args.next(v,m.valueptrref());
    args.next(v,uncorr.valueptrref());
    args.next(T(),lb.valueptrref());
    args.next(T(),ub.valueptrref());
    
    v = *m;  
  }
  
  virtual string stringrep() const {
    return "Correlate " +
      String::stringrep(*m) + " " +
      String::stringrep(*uncorr) + " " +
      String::stringrep(*lb) + " " +
      String::stringrep(*ub);
  }
#endif
  
  ValueGenerator_Correlate(const self& other)
    : ValueGenerator<T>(&v), v(other.v), lb(other.lb), ub(other.ub),
      m(other.m), uncorr( other.uncorr)  { } 
  virtual bool next() {
    const T uncorr_radius = (*ub-*lb)*(*uncorr);

    /* This conditional will presumably be optimized away */
    if (crop) {
      const T low    = std::max(*lb,*m-uncorr_radius);
      const T high   = std::min(*ub,*m+uncorr_radius);
      const T radius = (high-low)/2;
      const T mean   = low+radius;
      v = RandomGen()(mean, radius);
    }
    else
      v = RandomGen()(*m, uncorr_radius);
    return true;
  }

  virtual void reset() { v=*m; } // Resets to master value

  virtual ValueGenerator<T>* clone() const { return new self(*this); }
};



template<class T=double>
class ValueGenerator_Opposite : public ValueGenerator<T> {
  typedef ValueGenerator_Opposite<T> self;
  T v; 
  T f;
  AllocatingPointer<T> m;

public:
  ValueGenerator_Opposite(T* master_value_ptr, T factor=1)
    : ValueGenerator<T>(&v), v(1-*master_value_ptr), f(factor), m(master_value_ptr) { }

#ifndef NO_VALGEN_STRINGS

  ValueGenerator_Opposite(StringArgs& args, T* ref=0)
    : ValueGenerator<T>(&v) {
    if (ref) m=ref;
    else     args.next(v,m.valueptrref());
    f=args.next(T(1));
    
    reset();  
  }
  
  virtual string stringrep() const {
    return "Opposite " +
      String::stringrep(f) + "-" +
      String::stringrep(*m);
  }
#endif
  
  ValueGenerator_Opposite(const self& other)
    : ValueGenerator<T>(&v), v(other.v), f(other.f), m(other.m) { } 
  virtual bool next() {  reset();  return true;  }
  virtual void reset() { v = f-*m; }
  virtual ValueGenerator<T>* clone() const { return new self(*this); }
};



template<class T=double>
class ValueGenerator_Increment : public ValueGenerator<T> {
  typedef ValueGenerator_Increment<T> self;
  T v; 
  AllocatingPointer<T> s,inc;

public:
  ValueGenerator_Increment(T  init_value, T  increment=1)
    : ValueGenerator<T>(&v), v(init_value), s(init_value), inc(increment) { }

  ValueGenerator_Increment(T* init_value, T* increment)
    : ValueGenerator<T>(&v), v(*init_value), s(init_value), inc(increment) { }

#ifndef NO_VALGEN_STRINGS

  ValueGenerator_Increment(StringArgs& args)
    : ValueGenerator<T>(&v), inc(1) {
    s   = args.next(T());
    v   = *s;
    inc = args.next(T(1));
  }

  virtual string stringrep() const
    { return "Increment " + String::stringrep(*s) + " " + String::stringrep(*inc);  }
#endif
  
  ValueGenerator_Increment(const self& other)
    : ValueGenerator<T>(&v), v(other.v), s(other.s), inc(other.inc) { } 
  virtual bool next()  { v += *inc; return true; }
  virtual void reset() { v  = *s; } // Resets to starting value

  virtual ValueGenerator<T>* clone() const { return new self(*this); };
};



#ifndef NO_VALGEN_STRINGS

template<class T=double>
class ValueGenerator_Expression : public ValueGenerator<T> {
  typedef ValueGenerator_Expression<T> self;
  const StringParser* p;
  T v; 
  string expr;
  
public:
  ValueGenerator_Expression(string expression, const StringParser& parser)
    : ValueGenerator<T>(&v), p(parser.clone()), v(p->parse(expression,v)), expr(expression) { }
  
  ValueGenerator_Expression(StringArgs& args)
    : ValueGenerator<T>(&v), p(args.p.clone()), v(0), expr("") {
      expr = args.next(string(""));
      p->parse(expr,v);
    }
  
  virtual string stringrep() const
    { return "Expression " + expr;  }

  ValueGenerator_Expression(const self& other)
    : ValueGenerator<T>(&v), p(other.p->clone()), v(other.v), expr(other.expr) { } 
  ~ValueGenerator_Expression() {  delete p;  }
  
  virtual bool next() {  p->parse(expr,v); return true; }
  
  virtual void reset() { next(); } // Resets to current value of expr

  virtual ValueGenerator<T>* clone() const { return new self(*this); };
};
#endif




/******************************************************************************/
/* ValueGeneratorFactory                                                      */
/******************************************************************************/

#ifndef NO_VALGEN_STRINGS


template<class T=double>
class VGenFactory {
public:
  VGenFactory()          { };
  virtual ~VGenFactory() { }

  virtual ValueGenerator<T>* create(StringArgs args) const =0;

  virtual ValueGenerator<T>* create(StringArgs args, T* ref) const =0;
  
protected:
  virtual void error(const string&) const {  }
  virtual void warning(const string&) const {  }
};



template<class T=double,
         class urf=Distributions::uniform,
         class nrf=Distributions::normal>
class ValueGeneratorFactory : public VGenFactory<T> {
public:
  ValueGeneratorFactory(Msg::LevelHandler<>** mhp_i=&(Msg::LevelHandler<>::default_instance()))
    : VGenFactory<T>() {  mhp = mhp_i;  };
  
  virtual ~ValueGeneratorFactory() { }
  
  virtual ValueGenerator<T>* create(StringArgs args) const {
    
    /* Empty string is invalid */
    if (args.empty()) {
      warning("ValueGenerator: empty expression");
      return new ValueGenerator<T>;
    }
    
    /* Convenient shorthand: A single item specifies a numeric constant */
    else if (args.oneremaining())
      return new ValueGenerator<T>(args);
    
    /* Anything else should be the name of the ValueGenerator followed by its arguments */
    else {
      const string& vgclass  = args.next(string(""));

      if      (vgclass=="Random")     {  return new ValueGenerator_Random<T,urf>(          args);  }
      else if (vgclass=="Normal")     {  return new ValueGenerator_Random<T,nrf>(          args);  }
      else if (vgclass=="Increment")  {  return new ValueGenerator_Increment<T>(           args);  }
      else if (vgclass=="Expression") {  return new ValueGenerator_Expression<T>(          args);  }
      else if (vgclass=="Correlate")  {  return new ValueGenerator_Correlate<T,urf,true> ( args);  }
      else {
        error("ValueGenerator: Don't know about type `" + vgclass + "'");
        return new ValueGenerator<T>;
      }
    }
  }


  virtual ValueGenerator<T>* create(StringArgs args, T* ref) const {
    if (args.nextis(string("Uncorrelate"))) {
      if (ref) return new ValueGenerator_Correlate<T,urf,true>(args,ref);
      else {
        /* Swallow unneeded args */
        T dummyf;
        ValueGenerator_Correlate<T,urf,true> dummy(args,&dummyf);
      }
    }
    else if (args.nextis(string("Opposite"))) {
      if (ref) return new ValueGenerator_Opposite<T>(args,ref);
      else {
        /* Swallow unneeded args */
        T dummyf;
        ValueGenerator_Opposite<T> dummy(args,&dummyf);
      }
    }
    if (ref) return new ValueGenerator<T>(ref);
    
    /* Otherwise just construct and return a normal ValueGenerator */
    return create(args);
  }
protected:
  void error   (const string& s) const {  message(Msg::Error,s);    }
  void warning (const string& s) const {  message(Msg::Warning,s);  }

private:
  static Msg::LevelHandler<>** mhp;  
  static void message(Msg::MessageLevel m, const string& s)
    {  if (mhp && *mhp) (**mhp)(m,s);  }
};
#endif


/* Static variables */
template<class T, class urf, class nrf> Msg::LevelHandler<>**
ValueGeneratorFactory<T,urf,nrf>::mhp=&(Msg::LevelHandler<>::default_instance());

#endif

---