utilities.h

#ifndef UTILITIES_H
#define UTILITIES_H
 
#include <fstream>
#include <iostream>
#include <functional>
#include <vector>
#include <string>
#include <map>
#include <cmath>
 
namespace Utilities 
{
    class RunningStat
    {
    private:
        int n_values;
        float summed_values;
        float max_value;
        float min_value;
        float new_M;
        float old_M;
        float new_S;
        float old_S;
    public:
        RunningStat();
        void push(float value);
        int size();
        float sum();
        float max();
        float min();
        float mean();
        float variance();
        float stddev();
    };
 
    class CSVFile
    {
    public:
        std::ofstream& ofstream;
        std::string name;
        std::vector<std::string> headers;
        std::vector<std::string> buffer;
 
        CSVFile(std::ofstream& new_ofstream, std::string new_name, 
                std::vector<std::string> new_headers);
        virtual ~CSVFile();
        CSVFile clone(std::string new_name);
        template<typename Type>
        void pushCol(Type value);
        void writeRow(bool append = true);
    };
    typedef std::vector<CSVFile> CSVFiles;
 
    class Dynamic
    {
    public:
        virtual ~Dynamic();
    };
 
    template<typename Type>
    class Variable : public Dynamic
    {
    protected:
        Type value;
        Type reset_value;
    public:
        Variable();
        Variable(Type new_reset_value);
        virtual ~Variable();
        Type getValue();
        Type& getReference();
        void setValue(Type new_value);
        void setResetValue(Type new_reset_value);
        void resetValue();
    };
 
    class Variables
    {
    protected:
        std::map<std::string, Dynamic*> variables;
        std::map<std::string, std::function<void()>> resetters;
        template<typename Type>
        Variable<Type>* getVar(std::string name);
    public:
        Variables();
        virtual ~Variables();
        template<typename Type>
        void newVar(std::string new_name);
        template<typename Type>
        void newVar(std::string new_name, Type new_reset_value);
        template<typename Type>
        Type getVal(std::string name);
        template<typename Type>
        Type& getRef(std::string name);
        template<typename Type>
        void setVal(std::string name, Type new_value);
        template<typename Type>
        void resetVal(std::string name);
        void resetVars();
    };
}
 
#include "utilities.icc"
 
#endif