|| || || || || || || ||

---

Iterable.h

Go to the documentation of this file.

#ifndef Impala_Util_Iterable_h
#define Impala_Util_Iterable_h

#include <math.h>
#include "Util/StringParser.h"

namespace Impala {
namespace Util {


class Iterable
{
public:
    virtual int GetSteps() = 0;
    virtual void SetIteration(int i) = 0;
    virtual void Next() = 0;
    virtual double GetValue() = 0;
    virtual bool Done() = 0;
    virtual std::string GetName() = 0;
    virtual bool HasNotifications() const = 0;
};


class Param : public Iterable
{
public:
    Param(const std::string& name, double value):
        mName(name), mValue(value)
    {
    }
    virtual int GetSteps()           
    {
        return 1;
    }
    virtual void SetIteration(int i)
    {
    }
    virtual void Next()
    {
    }
    virtual double GetValue()
    {
        return mValue;
    }
    virtual bool Done()
    {
        return true;
    }
    std::string GetName()
    {
        return mName;
    }
    virtual bool HasNotifications() const
    {
        return false;
    }

protected:
    std::string mName;
    double mValue;
};

class Range : public Iterable
{
public:
    Range(const std::string& name, double start, double end, int steps, bool notifications):
        mName(name), mValue(start), mStart(start), mSteps(steps)
    {
        mIterator = 0;
        mRange = end - start;
        mHasNotifications = notifications;
    }

    virtual int GetSteps()
    {
        return mSteps;
    }
    virtual void SetIteration(int i) 
    {
        if(i<mSteps)
            mIterator = i;
    }
    virtual void Next()
    {
        mIterator++;
    }
    virtual bool Done()
    {
        return mIterator >= mSteps;
    }
    virtual double GetValue()
    {
        if(mSteps < 2)
            return mStart;
        return mStart+((mRange*mIterator)/(mSteps-1));
    }

    std::string GetName()
    {
        return mName;
    }
    virtual bool HasNotifications() const
    {
        return mHasNotifications;
    }
protected:
    std::string mName;
    double mValue;
    double mStart;
    double mRange;
    int mSteps;
    int mIterator;
    bool mHasNotifications;
};



class LogRange : public Range
{
public:
    LogRange(const std::string& name, double startExp, double endExp, int steps, double logarithmicBase=10.0):
        Range(name, startExp, endExp, steps, false)
    {
        mLogarithmicBase = logarithmicBase;
        mValue = pow(mLogarithmicBase,startExp);
    }

    double GetValue()   
    { 
        return pow(mLogarithmicBase, mStart + (double)mIterator*(mRange/(double)(mSteps-1)));
    }
protected:
    double mLogarithmicBase;
};


//class Set : public Iterable
//{
//public:
//    Set(const std::string& name, std::string& definition):
//        mName(name)
//    {
//        if(mSteps < 2)
//            mSteps = 2;
//        mIterator = 0;
//        mRange = end - start;
//        mHasNotifications = notifications;
//    }
//
//    virtual int GetSteps()
//    {
//        return mSteps;
//    }
//    virtual void SetIteration(int i) 
//    {
//        if(i<mSteps)
//            mIterator = i;
//    }
//    virtual void Next()
//    {
//        mIterator++;
//    }
//    virtual bool Done()
//    {
//        return mIterator >= mSteps;
//    }
//    virtual double GetValue()
//    {
//        return mStart+((mRange*mIterator)/(mSteps-1));
//    }
//
//    virtual bool HasNotifications() const
//    {
//        return mHasNotifications;
//    }
//protected:
//    void ParseDefinition(std::string& definition)
//    {
//        std::istringstream iss(definition);
//    }
//
//    std::string mName;
//    double mValue;
//    double mStart;
//    double mRange;
//    int mSteps;
//    int mIterator;
//    bool mHasNotifications;
//};
Iterable* ParseRangeDefinitionElement(const std::string& name, std::string& definition)
{
    if(definition.find(':') == std::string::npos)
        return 0;
    bool logarithmic = false;
    double logarithmicBase = 10.0;
    if(definition.substr(0,3) == "log")
    {
        logarithmic = true;
        definition = definition.substr(3);
        logarithmicBase = 10.0;
    }
    if(definition.substr(0,4) == "2log")
    {
        logarithmic = true;
        definition = definition.substr(4);
        logarithmicBase = 2.0;
    }
    std::istringstream iss(definition);
    double start, stop;
    int steps;
    char c;
    iss >> start >> c >> stop;
    if(c!=':')
    {
        std::cout << "[ParseRangeDefinitionElement] error " << definition << " is not a valid element\n";
        return 0; //syntax error;
    }
    iss >> c;
    if(!iss.eof())
    {
        iss >> steps;
        if(c != '/')
        {
            std::cout << "[ParseRangeDefinitionElement] error " << definition << " is not a valid element\n";
            return 0; //syntax error;
        }
    }
    else
        steps = fabs(stop - start) + 1;

    if(logarithmic)
        return new LogRange(name, start, stop, steps, logarithmicBase);
    return new Range(name, start, stop, steps, false);
}

Iterable* ParseRangeDefinition(const std::string& name, const std::string& definition)
{
    if(definition[0]!='[' || definition[definition.size()-1]!=']')
    {
        std::cout << "[ParseRangeDefinition] error " << definition << " is not a valid definition\n";
        return 0;
    }
    std::string inside = definition.substr(1,definition.size()-2);
    Iterable *it = ParseRangeDefinitionElement(name, inside);
    return it;
}

bool IsRangeDefinition(std::string s)
{
    if(s[0]!='[' || s[s.size()-1]!=']')
        return false;
    int left = 1;
    int right = s.size()-2;
    if(s.substr(left,3) == "log")
        left += 3;
    if(s.substr(left,4) == "2log")
        left += 4;
    std::istringstream iss(s.substr(left, right-left));
    double start, stop;
    char c1, c2;
    iss >> start >> c1 >> stop >> c2;
    if(c1 != ':')
        return false;
    if(!iss.eof())
        if(c2 != ':')
            return true;
    return true;
}

} // namespace Util
} // namespace Impala

#endif //Impala_Util_Iterable_h

---