interval.hpp

Go to the documentation of this file.

/*****************************************************************************
    NumeRe: Framework fuer Numerische Rechnungen
    Copyright (C) 2021  Erik Haenel et al.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
 
 
#ifndef INTERVAL_HPP
#define INTERVAL_HPP
 
#include <vector>
#include <string>
 
#include "ParserLib/muParserDef.h"
 
class Interval
{
    private:
        std::string m_sDefinition;
        std::vector<double> m_vInterval;
 
        void assign(const Interval& ivl);
        double getSample(size_t n, size_t nSamples) const;
 
    public:
        std::string name;
 
        Interval() : m_sDefinition(), m_vInterval({NAN,NAN}), name() {}
        Interval(const std::string& sDef);
        Interval(mu::value_type dFront, mu::value_type dBack);
        Interval(const Interval& ivl);
 
        Interval& operator=(const Interval& ivl);
        mu::value_type operator()(size_t n, size_t nSamples = 100) const;
        mu::value_type log(size_t n, size_t nSamples = 100) const;
 
        mu::value_type front() const;
        mu::value_type back() const;
 
        mu::value_type cmin() const;
        mu::value_type cmax() const;
 
        double min() const;
        double max() const;
        double range() const;
        double middle() const;
 
        bool isInside(mu::value_type val) const;
        bool contains(const std::string& sVarName) const;
        size_t getSamples() const;
 
        void refresh();
        void reset(const std::string& sDef);
        void reset(mu::value_type dFront, mu::value_type dBack);
 
        void expand(double perc, double dMin = -INFINITY);
        Interval combine(const Interval& _ivl) const;
};
 
 
struct IntervalSet
{
    std::vector<Interval> intervals;
 
    IntervalSet(const std::string& sIntervalString);
    IntervalSet(const IntervalSet& ivSet);
    IntervalSet() = default;
 
    IntervalSet& operator=(const IntervalSet& ivSet);
    Interval& operator[](size_t n);
    const Interval& operator[](size_t n) const;
 
    bool hasDependentIntervals() const;
    size_t size() const;
    std::vector<mu::value_type> convert();
    void setNames(const std::vector<std::string>& vNames);
};
 
 
struct Line
{
    std::string sDesc;
    std::string sStyle;
    double dPos;
 
    Line() : sDesc(""), sStyle("k;2"), dPos(0.0) {}
};
 
 
struct Axis
{
    std::string sLabel;
    std::string sStyle;
    Interval ivl;
};
 
 
struct TimeAxis
{
    std::string sTimeFormat;
    bool use;
 
    TimeAxis() : sTimeFormat(""), use(false) {}
 
    void activate(const std::string& sFormat = "")
    {
        use = true;
        sTimeFormat = sFormat;
 
        if (!sTimeFormat.length())
            return;
 
        if (sTimeFormat.find("YYYY") != std::string::npos)
            sTimeFormat.replace(sTimeFormat.find("YYYY"), 4, "%Y");
 
        if (sTimeFormat.find("YY") != std::string::npos)
            sTimeFormat.replace(sTimeFormat.find("YY"), 2, "%y");
 
        if (sTimeFormat.find("MM") != std::string::npos)
            sTimeFormat.replace(sTimeFormat.find("MM"), 2, "%m");
 
        if (sTimeFormat.find("DD") != std::string::npos)
            sTimeFormat.replace(sTimeFormat.find("DD"), 2, "%d");
 
        if (sTimeFormat.find("HH") != std::string::npos)
            sTimeFormat.replace(sTimeFormat.find("HH"), 2, "%H");
 
        if (sTimeFormat.find("hh") != std::string::npos)
            sTimeFormat.replace(sTimeFormat.find("hh"), 2, "%H");
 
        if (sTimeFormat.find("mm") != std::string::npos)
            sTimeFormat.replace(sTimeFormat.find("mm"), 2, "%M");
 
        if (sTimeFormat.find("ss") != std::string::npos)
            sTimeFormat.replace(sTimeFormat.find("ss"), 2, "%S");
    }
 
    void deactivate()
    {
        use = false;
        sTimeFormat.clear();
    }
};
 
 
 
#endif // INTERVAL_HPP