Merge 269d0c338e into 4823426d55

.github/workflows/build-macos.yml

@@ -1,6 +1,6 @@
 name: Build macOS
 
-on: [push]
+on: [push, workflow_dispatch]
 
 jobs:
   build:

.gitignore

@@ -25,9 +25,10 @@ lib/*Lexer.cpp
 lib/*Parser.cpp
 lib/*Parser.hpp
 
-# Eigen headers
-lib/Eigen/*
+# Eigen headers and archives
+lib/Eigen
 lib/eigen_files.mk
+eigen-*.tar.bz2
 
 # CI builds
 ci-scripts/local/*

bootstrap.sh

@@ -2,5 +2,5 @@
 
 rm -rf .buildutils
 mkdir -p .buildutils/m4
-./update_eigen.sh eigen-3.3.8.tar.bz2
+./update_eigen.sh eigen-3.4.0.tar.bz2
 autoreconf -fvi

build.sh

@@ -1,24 +0,0 @@
-#!/bin/bash
-
-set -e
-
-PREFIX=`cat Makefile | grep '^prefix =' | awk '{print $3}'`
-case $1 in
-    '')
-        echo '-- building...'
-        make -j8
-        echo '-- installing...'
-        make uninstall 1>/dev/null
-        make install 1>/dev/null;;
-#        if [[ `basename \`pwd\`` == "lib" ]]
-#        then
-#            echo '-- creating debug symbols...'
-#            dsymutil .libs/libLatAnalyze.0.dylib -o ${PREFIX}/lib/libLatAnalyze.0.dylib.dSYM
-#        fi;;
-    'clean')
-        echo '-- cleaning...'
-        make -j8 clean;;
-    *)
-        echo 'error: unknown action' 1>&2
-        exit 1;;
-esac

examples/exRand.cpp

@@ -7,7 +7,7 @@
 using namespace std;
 using namespace Latan;
 
-constexpr Index  size          = 8;
+constexpr Index  n             = 8;
 constexpr Index  nDraw         = 20000;
 constexpr Index  nSample       = 2000;
 const     string stateFileName = "exRand.seed";
@@ -40,14 +40,14 @@ int main(void)
     p << PlotFunction(compile("return exp(-x_0^2/2)/sqrt(2*pi);", 1), -5., 5.);
     p.display();
 
-    DMat       var(size, size);
-    DVec       mean(size);
-    DMatSample sample(nSample, size, 1);
+    DMat       var(n, n);
+    DVec       mean(n);
+    DMatSample sample(nSample, n, 1);
 
     cout << "-- generating " << nSample << " Gaussian random vectors..." << endl;
-    var   = DMat::Random(size, size);
+    var   = DMat::Random(n, n);
     var  *= var.adjoint();
-    mean  = DVec::Random(size); 
+    mean  = DVec::Random(n); 
     RandomNormal mgauss(mean, var, rd());
     sample[central] = mgauss();
     FOR_STAT_ARRAY(sample, s)

lib/Core/Math.cpp

@@ -18,6 +18,7 @@
  */
 
 #include <LatAnalyze/Core/Math.hpp>
+#include <LatAnalyze/Numerical/GslFFT.hpp>
 #include <LatAnalyze/includes.hpp>
 #include <gsl/gsl_cdf.h>
 
@@ -48,16 +49,42 @@ DMat MATH_NAMESPACE::corrToVar(const DMat &corr, const DVec &varDiag)
     return res;
 }
 
-double MATH_NAMESPACE::svdDynamicRange(const DMat &mat)
+double MATH_NAMESPACE::conditionNumber(const DMat &mat)
 {
     DVec s = mat.singularValues();
 
     return s.maxCoeff()/s.minCoeff();
 }
 
-double MATH_NAMESPACE::svdDynamicRangeDb(const DMat &mat)
+double MATH_NAMESPACE::cdr(const DMat &mat)
 {
-    return 10.*log10(svdDynamicRange(mat));
+    return 10.*log10(conditionNumber(mat));
+}
+
+template <typename FFT>
+double nsdr(const DMat &m)
+{
+    Index  n = m.rows();
+    FFT    fft(n);
+    CMat   buf(n, 1);
+
+    FOR_VEC(buf, i)
+    {
+        buf(i) = 0.;
+        for (Index j = 0; j < n; ++j)
+        {
+            buf(i) += m(j, (i+j) % n);
+        }
+        buf(i) /= n;
+    }
+    fft(buf, FFT::Forward);
+
+    return 10.*log10(buf.real().maxCoeff()/buf.real().minCoeff());
+}
+
+double MATH_NAMESPACE::nsdr(const DMat &mat)
+{
+    return ::nsdr<GslFFT>(mat);
 }
 
 /******************************************************************************

lib/Core/Math.hpp

@@ -73,8 +73,9 @@ namespace MATH_NAMESPACE
     DMat corrToVar(const DMat &corr, const DVec &varDiag);
 
     // matrix SVD dynamic range
-    double svdDynamicRange(const DMat &mat);
-    double svdDynamicRangeDb(const DMat &mat);
+    double conditionNumber(const DMat &mat);
+    double cdr(const DMat &mat);
+    double nsdr(const DMat &mat);
     
     // Constants
     constexpr double pi  = 3.1415926535897932384626433832795028841970;

lib/Core/MathInterpreter.cpp

@@ -217,146 +217,25 @@ void RunContext::reset(void)
 #define CODE_WIDTH 6
 #define CODE_MOD   setw(CODE_WIDTH) << left
 
-// Instruction operator ////////////////////////////////////////////////////////
-ostream &Latan::operator<<(ostream& out, const Instruction& ins)
+auto readConstant(Program::const_iterator ip)
+    -> std::tuple<double, Program::const_iterator>
 {
-    ins.print(out);
-    
-    return out;
+    double value = 0.0;
+    std::copy(ip, ip + sizeof(double), reinterpret_cast<std::uint8_t*>(&value));
+
+    return std::make_tuple(value, ip + sizeof(double));
 }
 
-// Push constructors ///////////////////////////////////////////////////////////
-Push::Push(const double val)
-: type_(ArgType::Constant)
-, val_(val)
-, address_(0)
-, name_("")
-{}
-
-Push::Push(const unsigned int address, const string &name)
-: type_(ArgType::Variable)
-, val_(0.0)
-, address_(address)
-, name_(name)
-{}
-
-// Push execution //////////////////////////////////////////////////////////////
-void Push::operator()(RunContext &context) const
+auto readAddress(Program::const_iterator ip)
+    -> std::tuple<unsigned int, Program::const_iterator>
 {
-    if (type_ == ArgType::Constant)
-    {
-        context.stack().push(val_);
-    }
-    else
-    {
-        context.stack().push(context.getVariable(address_));
-    }
-    context.incrementInsIndex();
+    unsigned int address = 0.0;
+    const auto end = ip + sizeof(unsigned int);
+    std::copy(ip, end, reinterpret_cast<std::uint8_t*>(&address));
+
+    return std::make_tuple(address, end);
 }
 
-// Push print //////////////////////////////////////////////////////////////////
-void Push::print(ostream &out) const
-{
-    out << CODE_MOD << "push";
-    if (type_ == ArgType::Constant)
-    {
-        out << CODE_MOD << val_;
-    }
-    else
-    {
-        out << CODE_MOD << name_ << " @v" << address_;
-    }
-}
-
-// Pop constructor /////////////////////////////////////////////////////////////
-Pop::Pop(const unsigned int address, const string &name)
-: address_(address)
-, name_(name)
-{}
-
-// Pop execution ///////////////////////////////////////////////////////////////
-void Pop::operator()(RunContext &context) const
-{
-    if (!name_.empty())
-    {
-        context.setVariable(address_, context.stack().top());
-    }
-    context.stack().pop();
-    context.incrementInsIndex();
-}
-
-// Pop print ///////////////////////////////////////////////////////////////////
-void Pop::print(ostream &out) const
-{
-    out << CODE_MOD << "pop" << CODE_MOD << name_ << " @v" << address_;
-}
-
-// Store constructor ///////////////////////////////////////////////////////////
-Store::Store(const unsigned int address, const string &name)
-: address_(address)
-, name_(name)
-{}
-
-// Store execution /////////////////////////////////////////////////////////////
-void Store::operator()(RunContext &context) const
-{
-    if (!name_.empty())
-    {
-        context.setVariable(address_, context.stack().top());
-    }
-    context.incrementInsIndex();
-}
-
-// Store print /////////////////////////////////////////////////////////////////
-void Store::print(ostream &out) const
-{
-    out << CODE_MOD << "store" << CODE_MOD << name_ << " @v" << address_;
-}
-
-// Call constructor ////////////////////////////////////////////////////////////
-Call::Call(const unsigned int address, const string &name)
-: address_(address)
-, name_(name)
-{}
-
-// Call execution //////////////////////////////////////////////////////////////
-void Call::operator()(RunContext &context) const
-{
-    context.stack().push((*context.getFunction(address_))(context.stack()));
-    context.incrementInsIndex();
-}
-
-// Call print //////////////////////////////////////////////////////////////////
-void Call::print(ostream &out) const
-{
-    out << CODE_MOD << "call" << CODE_MOD << name_ << " @f" << address_;
-}
-
-// Math operations /////////////////////////////////////////////////////////////
-#define DEF_OP(name, nArg, exp, insName)\
-void name::operator()(RunContext &context) const\
-{\
-    double x[nArg];\
-    for (int i = 0; i < nArg; ++i)\
-    {\
-        x[nArg-1-i] = context.stack().top();\
-        context.stack().pop();\
-    }\
-    context.stack().push(exp);\
-    context.incrementInsIndex();\
-}\
-void name::print(ostream &out) const\
-{\
-    out << CODE_MOD << insName;\
-}
-
-DEF_OP(Neg, 1, -x[0],          "neg")
-DEF_OP(Add, 2, x[0] + x[1],    "add")
-DEF_OP(Sub, 2, x[0] - x[1],    "sub")
-DEF_OP(Mul, 2, x[0]*x[1],      "mul")
-DEF_OP(Div, 2, x[0]/x[1],      "div")
-DEF_OP(Pow, 2, pow(x[0],x[1]), "pow")
-
 /******************************************************************************
  *                        ExprNode implementation                             *
  ******************************************************************************/
@@ -442,29 +321,35 @@ ostream &Latan::operator<<(ostream &out, const ExprNode &n)
     return out;
 }
 
-#define PUSH_INS(program, type, ...)\
-program.push_back(unique_ptr<type>(new type(__VA_ARGS__)))
-#define GET_ADDRESS(address, table, name)\
-try\
-{\
-    address = (table).at(name);\
-}\
-catch (out_of_range)\
-{\
-    address         = (table).size();\
-    (table)[(name)] = address;\
-}\
+// Bytecode helper functions ///////////////////////////////////////////////////
+void pushInstruction(Program &program, const Instruction instruction) {
+    program.push_back(static_cast<std::uint8_t>(instruction));
+}
+
+void pushAddress(Program &program, const unsigned int address) {
+    const auto address_ptr = reinterpret_cast<const std::uint8_t*>(&address);
+    const auto size = sizeof(unsigned int);
+    program.insert(program.end(), address_ptr, address_ptr + size);
+}
+
+void pushConstant(Program &program, const double value) {
+    const auto value_ptr = reinterpret_cast<const std::uint8_t*>(&value);
+    const auto size = sizeof(double);
+    program.insert(program.end(), value_ptr, value_ptr + size);
+}
 
 // VarNode compile /////////////////////////////////////////////////////////////
 void VarNode::compile(Program &program, RunContext &context) const
 {
-    PUSH_INS(program, Push, context.getVariableAddress(getName()), getName());
+    pushInstruction(program, Instruction::LOAD);
+    pushAddress(program, context.getVariableAddress(getName()));
 }
 
 // CstNode compile /////////////////////////////////////////////////////////////
 void CstNode::compile(Program &program, RunContext &context __dumb) const
 {
-    PUSH_INS(program, Push, strTo<double>(getName()));
+    pushInstruction(program, Instruction::CONST);
+    pushConstant(program, strTo<double>(getName()));
 }
 
 // SemicolonNode compile ///////////////////////////////////////////////////////
@@ -482,6 +367,10 @@ void SemicolonNode::compile(Program &program, RunContext &context) const
         {
             n[i].compile(program, context);
         }
+        // Where a variable has just been assigned, pop it off the stack.
+        if (isAssign) {
+            pushInstruction(program, Instruction::POP);
+        }
     }
 }
 
@@ -492,19 +381,10 @@ void AssignNode::compile(Program &program, RunContext &context) const
     
     if (isDerivedFrom<VarNode>(&n[0]))
     {
-        bool hasSemicolonParent = isDerivedFrom<SemicolonNode>(getParent());
-        unsigned int address;
-        
         n[1].compile(program, context);
-        address = context.addVariable(n[0].getName());
-        if (hasSemicolonParent)
-        {
-            PUSH_INS(program, Pop, address, n[0].getName());
-        }
-        else
-        {
-            PUSH_INS(program, Store, address, n[0].getName());
-        }
+        const unsigned int address = context.addVariable(n[0].getName());
+        pushInstruction(program, Instruction::STORE);
+        pushAddress(program, address);
     }
     else
     {
@@ -519,19 +399,37 @@ void AssignNode::compile(Program &program, RunContext &context) const
 
 void MathOpNode::compile(Program &program, RunContext &context) const
 {
+#define PUSH_BINARY_OP(op, instruction) \
+    case op: \
+        pushInstruction(program, Instruction::instruction); \
+        break;
+
     auto &n = *this;
     
     for (Index i = 0; i < n.getNArg(); ++i)
     {
         n[i].compile(program, context);
     }
-    IFNODE("-", 1)   PUSH_INS(program, Neg,);
-    ELIFNODE("+", 2) PUSH_INS(program, Add,);
-    ELIFNODE("-", 2) PUSH_INS(program, Sub,);
-    ELIFNODE("*", 2) PUSH_INS(program, Mul,);
-    ELIFNODE("/", 2) PUSH_INS(program, Div,);
-    ELIFNODE("^", 2) PUSH_INS(program, Pow,);
-    ELSE LATAN_ERROR(Compilation, "unknown operator '" + getName() + "'");
+    if (n.getName() == "-" and n.getNArg() == 1) {
+        pushInstruction(program, Instruction::NEG);
+        return;
+    }
+
+    if (getNArg() != 2) {
+        LATAN_ERROR(Compilation, "unknown operator '" + getName() + "'");
+    }
+
+    switch (getName()[0]) {
+    PUSH_BINARY_OP('+', ADD)
+    PUSH_BINARY_OP('-', SUB)
+    PUSH_BINARY_OP('*', MUL)
+    PUSH_BINARY_OP('/', DIV)
+    PUSH_BINARY_OP('^', POW)
+    default:
+        LATAN_ERROR(Compilation, "unknown operator '" + getName() + "'");
+    }
+
+#undef PUSH_BINARY_OP
 }
 
 // FuncNode compile ////////////////////////////////////////////////////////////
@@ -543,7 +441,8 @@ void FuncNode::compile(Program &program, RunContext &context) const
     {
         n[i].compile(program, context);
     }
-    PUSH_INS(program, Call, context.getFunctionAddress(getName()), getName());
+    pushInstruction(program, Instruction::CALL);
+    pushAddress(program, context.getFunctionAddress(getName()));
 }
 
 // ReturnNode compile ////////////////////////////////////////////////////////////
@@ -552,7 +451,7 @@ void ReturnNode::compile(Program &program, RunContext &context) const
     auto &n = *this;
     
     n[0].compile(program, context);
-    program.push_back(nullptr);
+    pushInstruction(program, Instruction::RET);
 }
 
 /******************************************************************************
@@ -582,7 +481,7 @@ MathInterpreter::MathInterpreter(const std::string &code)
 // access //////////////////////////////////////////////////////////////////////
 const Instruction * MathInterpreter::operator[](const Index i) const
 {
-    return program_[i].get();
+    return reinterpret_cast<const Instruction*>(&program_[i]);
 }
 
 const ExprNode * MathInterpreter::getAST(void) const
@@ -592,7 +491,7 @@ const ExprNode * MathInterpreter::getAST(void) const
 
 void MathInterpreter::push(const Instruction *i)
 {
-    program_.push_back(unique_ptr<const Instruction>(i));
+    pushInstruction(program_, *i);
 }
 
 // initialization //////////////////////////////////////////////////////////////
@@ -695,7 +594,7 @@ void MathInterpreter::compile(RunContext &context)
             root_->compile(program_, context);
             for (unsigned int i = 0; i < program_.size(); ++i)
             {
-                if (!program_[i])
+                if (static_cast<Instruction>(program_[i]) == Instruction::RET)
                 {
                     gotReturn = true;
                     program_.resize(i);
@@ -726,20 +625,145 @@ void MathInterpreter::operator()(RunContext &context)
 
 void MathInterpreter::execute(RunContext &context) const
 {
-    context.setInsIndex(0);
-    while (context.getInsIndex() != program_.size())
-    {
-        (*(program_[context.getInsIndex()]))(context);
+#define BINARY_OP_CASE(instruction, expr) \
+        case Instruction::instruction: { \
+            const auto second = context.stack().top(); \
+            context.stack().pop(); \
+            const auto first = context.stack().top(); \
+            context.stack().pop(); \
+            context.stack().push(expr); \
+            break; \
+        }
+    auto ip = program_.begin();
+
+    while (ip != program_.end()) {
+        const auto instruction = static_cast<Instruction>(*ip);
+        ip++;
+
+        switch (instruction) {
+        BINARY_OP_CASE(ADD, first + second)
+        BINARY_OP_CASE(SUB, first - second)
+        BINARY_OP_CASE(MUL, first * second)
+        BINARY_OP_CASE(DIV, first / second)
+        BINARY_OP_CASE(POW, std::pow(first, second))
+        case Instruction::NEG: {
+            const auto operand = context.stack().top();
+            context.stack().pop();
+            context.stack().push(-operand);
+            break;
+        }
+        case Instruction::CONST: {
+            double value = 0.0;
+            std::tie(value, ip) = readConstant(ip);
+            context.stack().push(value);
+            break;
+        }
+        case Instruction::POP:
+            context.stack().pop();
+            break;
+        case Instruction::LOAD: {
+            unsigned int address = 0;
+            std::tie(address, ip) = readAddress(ip);
+            context.stack().push(context.getVariable(address));
+            break;
+        }
+        case Instruction::STORE: {
+            unsigned int address = 0;
+            std::tie(address, ip) = readAddress(ip);
+            context.setVariable(address, context.stack().top());
+            break;
+        }
+        case Instruction::CALL: {
+            unsigned int address = 0;
+            std::tie(address, ip) = readAddress(ip);
+            auto& stack = context.stack();
+            stack.push((*context.getFunction(address))(stack));
+            break;
+        }
+        case Instruction::RET:
+            break;
+        }
     }
+
+#undef BINARY_OP_CASE
+}
+
+Program::const_iterator instructionToStream(
+    ostream &out, Program::const_iterator ip)
+{
+    const auto instruction = static_cast<Instruction>(*ip);
+    ip++;
+
+    switch (instruction) {
+    case Instruction::ADD:
+        out << "ADD";
+        break;
+    case Instruction::SUB:
+        out << "SUB";
+        break;
+    case Instruction::MUL:
+        out << "MUL";
+        break;
+    case Instruction::DIV:
+        out << "DIV";
+        break;
+    case Instruction::POW:
+        out << "POW";
+        break;
+    case Instruction::NEG:
+        out << "NEG";
+        break;
+    case Instruction::CONST: {
+        double value = 0.0;
+        std::tie(value, ip) = readConstant(ip);
+        out << CODE_MOD << setfill(' ') << "CONST" << value;
+        break;
+    }
+    case Instruction::POP:
+        out << "POP";
+        break;
+    case Instruction::LOAD: {
+        unsigned int address = 0;
+        std::tie(address, ip) = readAddress(ip);
+        out << CODE_MOD << setfill(' ') << "LOAD" << address;
+        break;
+    }
+    case Instruction::STORE: {
+        unsigned int address = 0;
+        std::tie(address, ip) = readAddress(ip);
+        out << CODE_MOD << setfill(' ') << "STORE" << address;
+        break;
+    }
+    case Instruction::CALL: {
+        unsigned int address = 0;
+        std::tie(address, ip) = readAddress(ip);
+        out << CODE_MOD << setfill(' ') << "CALL" << address;
+        break;
+    }
+    case Instruction::RET:
+        out << "RET";
+        break;
+    }
+
+    return ip;
+}
+
+ostream &programToStream(ostream &out, const Program &program)
+{
+    auto ip = program.begin();
+
+    while (ip != program.end()) {
+        const auto i = std::distance(program.begin(), ip);
+        cout << setw(4) << setfill('0') << right << i << "  ";
+        ip = instructionToStream(out, ip);
+        out << '\n';
+    }
+
+    return out;
 }
 
 // IO //////////////////////////////////////////////////////////////////////////
 ostream &Latan::operator<<(ostream &out, const MathInterpreter &program)
 {
-    for (unsigned int i = 0; i < program.program_.size(); ++i)
-    {
-        out << *(program.program_[i]) << endl;
-    }
-    
-    return out;
+    return programToStream(out, program.program_);
 }

lib/Core/MathInterpreter.hpp

@@ -20,6 +20,8 @@
 #ifndef Latan_MathInterpreter_hpp_
 #define	Latan_MathInterpreter_hpp_
 
+#include <cstdint>
+
 #include <LatAnalyze/Functional/Function.hpp>
 #include <LatAnalyze/Global.hpp>
 #include <LatAnalyze/Core/ParserState.hpp>
@@ -79,108 +81,26 @@ private:
  *                         Instruction classes                                *
  ******************************************************************************/
 // Abstract base
-class Instruction
-{
-public:
-    // destructor
-    virtual ~Instruction(void) = default;
-    // instruction execution
-    virtual void operator()(RunContext &context) const = 0;
-    friend std::ostream & operator<<(std::ostream &out, const Instruction &ins);
-private:
-    virtual void print(std::ostream &out) const = 0;
+
+enum class Instruction : std::uint8_t {
+    ADD,
+    SUB,
+    MUL,
+    DIV,
+    POW,
+    NEG,
+    CONST,
+    POP,
+    LOAD,
+    STORE,
+    CALL,
+    RET,
 };
 
 std::ostream & operator<<(std::ostream &out, const Instruction &ins);
 
 // Instruction container
-typedef std::vector<std::unique_ptr<const Instruction>> Program;
-
-// Push
-class Push: public Instruction
-{
-private:
-    enum class ArgType
-    {
-        Constant = 0,
-        Variable = 1
-    };
-public:
-    //constructors
-    explicit Push(const double val);
-    explicit Push(const unsigned int address, const std::string &name);
-    // instruction execution
-    virtual void operator()(RunContext &context) const;
-private:
-    virtual void print(std::ostream& out) const;
-private:
-    ArgType      type_;
-    double       val_;
-    unsigned int address_;
-    std::string  name_;
-};
-
-// Pop
-class Pop: public Instruction
-{
-public:
-    //constructor
-    explicit Pop(const unsigned int address, const std::string &name);
-    // instruction execution
-    virtual void operator()(RunContext &context) const;
-private:
-    virtual void print(std::ostream& out) const;
-private:
-    unsigned int address_;
-    std::string name_;
-};
-
-// Store
-class Store: public Instruction
-{
-public:
-    //constructor
-    explicit Store(const unsigned int address, const std::string &name);
-    // instruction execution
-    virtual void operator()(RunContext &context) const;
-private:
-    virtual void print(std::ostream& out) const;
-private:
-    unsigned int address_;
-    std::string name_;
-};
-
-// Call function
-class Call: public Instruction
-{
-public:
-    //constructor
-    explicit Call(const unsigned int address, const std::string &name);
-    // instruction execution
-    virtual void operator()(RunContext &context) const;
-private:
-    virtual void print(std::ostream& out) const;
-private:
-    unsigned int address_;
-    std::string name_;
-};
-
-// Floating point operations
-#define DECL_OP(name)\
-class name: public Instruction\
-{\
-public:\
-    virtual void operator()(RunContext &context) const;\
-private:\
-    virtual void print(std::ostream &out) const;\
-}
-
-DECL_OP(Neg);
-DECL_OP(Add);
-DECL_OP(Sub);
-DECL_OP(Mul);
-DECL_OP(Div);
-DECL_OP(Pow);
+typedef std::vector<std::uint8_t> Program;
 
 /******************************************************************************
  *                            Expression node classes                         *

lib/Core/Plot.cpp

@@ -515,14 +515,16 @@ void Dash::operator()(PlotOptions &option) const
 }
 
 // LogScale constructor ////////////////////////////////////////////////////////
-LogScale::LogScale(const Axis axis)
+LogScale::LogScale(const Axis axis, const double basis)
 : axis_(axis)
+, basis_(basis)
 {}
 
 // Logscale modifier ///////////////////////////////////////////////////////////
 void LogScale::operator()(PlotOptions &option) const
 {
-    option.scaleMode[static_cast<int>(axis_)] |= Plot::Scale::log;
+    option.scaleMode[static_cast<int>(axis_)]     |= Plot::Scale::log;
+    option.logScaleBasis[static_cast<int>(axis_)]  = basis_;
 }
 
 // PlotRange constructors //////////////////////////////////////////////////////
@@ -915,11 +917,11 @@ ostream & Latan::operator<<(ostream &out, const Plot &plot)
     out << "unset log" << endl;
     if (plot.options_.scaleMode[x] & Plot::Scale::log)
     {
-        out << "set log x" << endl;
+        out << "set log x " << plot.options_.logScaleBasis[x] << endl;;
     }
     if (plot.options_.scaleMode[y] & Plot::Scale::log)
     {
-        out << "set log y" << endl;
+        out << "set log y " << plot.options_.logScaleBasis[y] << endl;
     }
     if (!plot.options_.label[x].empty())
     {

lib/Core/Plot.hpp

@@ -227,6 +227,7 @@ struct PlotOptions
     std::string              caption;
     std::string              title;
     unsigned int             scaleMode[2];
+    double                   logScaleBasis[2];
     Range                    scale[2];
     std::string              label[2];
     std::string              lineColor;
@@ -314,13 +315,14 @@ class LogScale: public PlotModifier
 {
 public:
     // constructor
-    explicit LogScale(const Axis axis);
+    explicit LogScale(const Axis axis, const double basis = 10);
     // destructor
     virtual ~LogScale(void) = default;
     // modifier
     virtual void operator()(PlotOptions &option) const;
 private:
     const Axis axis_;
+    const double basis_;
 };
 
 class PlotRange: public PlotModifier

lib/Core/Utilities.hpp

@@ -108,23 +108,6 @@ inline std::string strFrom(const T x)
 }
 
 // specialization for vectors
-template<>
-inline std::vector<Index> strTo<std::vector<Index>>(const std::string &str)
-{
-    std::vector<Index>  res;
-    std::vector<double> vbuf;
-    double              buf;
-    std::istringstream  stream(str);
-    
-    while (!stream.eof())
-    {
-        stream >> buf;
-        res.push_back(buf);
-    }
-    
-    return res;
-}
-
 template<>
 inline DVec strTo<DVec>(const std::string &str)
 {

lib/Makefile.am

@@ -58,6 +58,7 @@ libLatAnalyze_la_SOURCES =           \
     Numerical/RootFinder.cpp         \
     Numerical/Solver.cpp             \
     Physics/CorrelatorFitter.cpp     \
+    Physics/DataFilter.cpp           \
     Physics/EffectiveMass.cpp        \
     Statistics/FitInterface.cpp      \
     Statistics/Histogram.cpp         \
@@ -106,6 +107,7 @@ HPPFILES =                           \
     Numerical/RootFinder.hpp         \
     Numerical/Solver.hpp             \
     Physics/CorrelatorFitter.hpp     \
+    Physics/DataFilter.hpp           \
     Physics/EffectiveMass.hpp        \
     Statistics/Dataset.hpp           \
     Statistics/FitInterface.hpp      \

lib/Numerical/DWT.cpp

@@ -32,46 +32,91 @@ DWT::DWT(const DWTFilter &filter)
 {}
 
 // convolution primitive ///////////////////////////////////////////////////////
-void DWT::filterConvolution(DVec &out, const DVec &data, 
-                            const std::vector<double> &filter, const Index offset)
+template <typename MatType>
+void filterConvolution(MatType &out, const MatType &data, 
+                       const std::vector<double> &filter, const Index offset)
 {
-    Index n = data.size(), nf = n*filter.size();
+    Index n = data.rows(), nf = n*filter.size();
 
-    out.resize(n);
+    out.resizeLike(data);
     out.fill(0.);
     for (unsigned int i = 0; i < filter.size(); ++i)
     {
-        FOR_VEC(out, j)
+        FOR_MAT(out, j, k)
         {
-            out(j) += filter[i]*data((j + i + nf - offset) % n);
+            out(j, k) += filter[i]*data((j + i + nf - offset) % n, k);
         }
     }
 }
 
+void DWT::filterConvolution(DVec &out, const DVec &data, 
+                            const std::vector<double> &filter, const Index offset)
+{
+    ::filterConvolution(out, data, filter, offset);
+}
+
+void DWT::filterConvolution(DMat &out, const DMat &data, 
+                            const std::vector<double> &filter, const Index offset)
+{
+    ::filterConvolution(out, data, filter, offset);
+}
+
 // downsampling/upsampling primitives //////////////////////////////////////////
+template <typename MatType>
+void downsample(MatType &out, const MatType &in)
+{
+    if (out.rows() < in.rows()/2)
+    {
+        LATAN_ERROR(Size, "output rows smaller than half the input vector rows");
+    }
+    if (out.cols() != in.cols())
+    {
+        LATAN_ERROR(Size, "output and input number of columns mismatch");
+    }
+    for (Index j = 0; j < in.cols(); j++)
+    for (Index i = 0; i < in.rows(); i += 2)
+    {
+        out(i/2, j) = in(i, j);
+    }
+}
+
 void DWT::downsample(DVec &out, const DVec &in)
 {
-    if (out.size() < in.size()/2)
+    ::downsample(out, in);
+}
+
+void DWT::downsample(DMat &out, const DMat &in)
+{
+    ::downsample(out, in);
+}
+
+template <typename MatType>
+void upsample(MatType &out, const MatType &in)
+{
+    if (out.size() < 2*in.size())
     {
-        LATAN_ERROR(Size, "output vector smaller than half the input vector size");
+        LATAN_ERROR(Size, "output rows smaller than twice the input rows");
     }
-    for (Index i = 0; i < in.size(); i += 2)
+    if (out.cols() != in.cols())
     {
-        out(i/2) = in(i);
+        LATAN_ERROR(Size, "output and input number of columns mismatch");
+    }
+    out.block(0, 0, 2*in.size(), out.cols()).fill(0.);
+    for (Index j = 0; j < in.cols(); j++)
+    for (Index i = 0; i < in.size(); i ++)
+    {
+        out(2*i, j) = in(i, j);
     }
 }
 
 void DWT::upsample(DVec &out, const DVec &in)
 {
-    if (out.size() < 2*in.size())
-    {
-        LATAN_ERROR(Size, "output vector smaller than twice the input vector size");
-    }
-    out.segment(0, 2*in.size()).fill(0.);
-    for (Index i = 0; i < in.size(); i ++)
-    {
-        out(2*i) = in(i);
-    }
+    ::upsample(out, in);
+}
+
+void DWT::upsample(DMat &out, const DMat &in)
+{
+    ::upsample(out, in);
 }
 
 // DWT /////////////////////////////////////////////////////////////////////////
@@ -135,3 +180,26 @@ DVec DWT::backward(const std::vector<DWTLevel>& dwt) const
 
     return res;
 }
+
+// concatenate levels //////////////////////////////////////////////////////////
+DVec DWT::concat(const std::vector<DWTLevel> &dwt, const int maxLevel, const bool dropLow)
+{
+    unsigned int level = ((maxLevel >= 0) ? (maxLevel + 1) : dwt.size());
+    Index nlast = dwt[level - 1].first.size();
+    Index n = 2*dwt.front().first.size() - ((dropLow) ? nlast : 0);
+    Index pt = n, nl;
+    DVec  res(n);
+
+    for (unsigned int l = 0; l < level; ++l)
+    {
+        nl  = dwt[l].second.size();
+        pt -= nl;
+        res.segment(pt, nl) = dwt[l].second;
+    }
+    if (!dropLow)
+    {
+        res.segment(0, nl) = dwt[level-1].first;
+    }
+
+    return res;
+}

lib/Numerical/DWT.hpp

@@ -22,6 +22,7 @@
 
 #include <LatAnalyze/Global.hpp>
 #include <LatAnalyze/Numerical/DWTFilters.hpp>
+#include <LatAnalyze/Core/Mat.hpp>
 
 BEGIN_LATAN_NAMESPACE
 
@@ -40,12 +41,18 @@ public:
     // convolution primitive
     static void filterConvolution(DVec &out, const DVec &data, 
                                   const std::vector<double> &filter, const Index offset);
+    static void filterConvolution(DMat &out, const DMat &data, 
+                                  const std::vector<double> &filter, const Index offset);
     // downsampling/upsampling primitives
     static void downsample(DVec &out, const DVec &in);
+    static void downsample(DMat &out, const DMat &in);
     static void upsample(DVec &out, const DVec &in);
+    static void upsample(DMat &out, const DMat &in);
     // DWT
     std::vector<DWTLevel> forward(const DVec &data, const unsigned int level) const;
     DVec                  backward(const std::vector<DWTLevel>& dwt) const;
+    // concatenate levels
+    static DVec concat(const std::vector<DWTLevel>& dwt, const int maxLevel = -1, const bool dropLow = false);
 private:
     DWTFilter filter_;
 };

lib/Physics/CorrelatorFitter.cpp

@@ -253,39 +253,16 @@ DMatSample CorrelatorUtils::shift(const DMatSample &c, const Index ts)
     }
 }
 
-DMatSample CorrelatorUtils::fold(const DMatSample &c, const CorrelatorModels::ModelPar &par)
+DMatSample CorrelatorUtils::fold(const DMatSample &c)
 {
     const Index nt  = c[central].rows();
     DMatSample  buf = c;
-    int         sign;
-    bool        fold = false;
-    
-    switch (par.type)
-    {
-        case CorrelatorType::cosh:
-        case CorrelatorType::cst:
-            sign = 1;
-            fold = true;
-            break;
-        case CorrelatorType::sinh:
-            sign = -1;
-            fold = true;
-            break;
-        case CorrelatorType::linear:
-            cout << "Linear model is asymmetric: will not fold." << endl;
-            break;
-        default:
-            break;
-    }
 
-    if (fold)
+    FOR_STAT_ARRAY(buf, s)
     {
-        FOR_STAT_ARRAY(buf, s)
+        for (Index t = 0; t < nt; ++t)
         {
-            for (Index t = 0; t < nt; ++t)
-            {
-                buf[s](t) = 0.5*(c[s](t) + sign*c[s]((nt - t) % nt));
-            }
+            buf[s](t) = 0.5*(c[s](t) + c[s]((nt - t) % nt));
         }
     }
 

lib/Physics/CorrelatorFitter.hpp

@@ -56,7 +56,7 @@ namespace CorrelatorModels
 namespace CorrelatorUtils
 {
     DMatSample shift(const DMatSample &c, const Index ts);
-    DMatSample fold(const DMatSample &c, const CorrelatorModels::ModelPar &par);
+    DMatSample fold(const DMatSample &c);
     DMatSample fourierTransform(const DMatSample &c, FFT &fft, 
                                 const unsigned int dir = FFT::Forward);
 };

lib/Physics/DataFilter.cpp

@@ -0,0 +1,83 @@
+/*
+ * DataFilter.cpp, part of LatAnalyze 3
+ *
+ * Copyright (C) 2013 - 2020 Antonin Portelli
+ *
+ * LatAnalyze 3 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.
+ *
+ * LatAnalyze 3 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 LatAnalyze 3.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <LatAnalyze/Physics/DataFilter.hpp>
+#include <LatAnalyze/includes.hpp>
+#include <LatAnalyze/Numerical/DWT.hpp>
+
+using namespace std;
+using namespace Latan;
+
+/******************************************************************************
+ *                        DataFilter implementation                           *
+ ******************************************************************************/
+// constructor ////////////////////////////////////////////////////////////////
+DataFilter::DataFilter(const vector<double> &filter, const bool downsample)
+: filter_(filter), downsample_(downsample)
+{}
+
+// filtering //////////////////////////////////////////////////////////////////
+template <typename MatType>
+void filter(MatType &out, const MatType &in, const vector<double> &filter, 
+            const bool downsample, MatType &buf)
+{
+    if (!downsample)
+    {
+        out.resizeLike(in);
+        DWT::filterConvolution(out, in, filter, filter.size()/2);
+    }
+    else
+    {
+        out.resize(in.rows()/2, in.cols());
+        buf.resizeLike(in);
+        DWT::filterConvolution(buf, in, filter, filter.size()/2);
+        DWT::downsample(out, buf);
+    }
+}
+
+void DataFilter::operator()(DVec &out, const DVec &in)
+{
+    filter(out, in, filter_, downsample_, vBuf_);
+}
+
+void DataFilter::operator()(DMat &out, const DMat &in)
+{
+    filter(out, in, filter_, downsample_, mBuf_);
+}
+
+/******************************************************************************
+ *                     LaplaceDataFilter implementation                       *
+ ******************************************************************************/
+// constructor ////////////////////////////////////////////////////////////////
+LaplaceDataFilter::LaplaceDataFilter(const bool downsample)
+: DataFilter({1., -2. , 1.}, downsample)
+{}
+
+// filtering //////////////////////////////////////////////////////////////////
+void LaplaceDataFilter::operator()(DVec &out, const DVec &in, const double lambda)
+{
+    filter_[1] = -2. - lambda;
+    DataFilter::operator()(out, in);
+}
+
+void LaplaceDataFilter::operator()(DMat &out, const DMat &in, const double lambda)
+{
+    filter_[1] = -2. - lambda;
+    DataFilter::operator()(out, in);
+}

lib/Physics/DataFilter.hpp

@@ -0,0 +1,139 @@
+/*
+ * DataFilter.hpp, part of LatAnalyze 3
+ *
+ * Copyright (C) 2013 - 2020 Antonin Portelli
+ *
+ * LatAnalyze 3 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.
+ *
+ * LatAnalyze 3 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 LatAnalyze 3.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef Latan_DataFilter_hpp_
+#define Latan_DataFilter_hpp_
+
+#include <LatAnalyze/Global.hpp>
+#include <LatAnalyze/Core/Math.hpp>
+#include <LatAnalyze/Statistics/StatArray.hpp>
+#include <LatAnalyze/Statistics/MatSample.hpp>
+#include <LatAnalyze/Numerical/Minimizer.hpp>
+
+BEGIN_LATAN_NAMESPACE
+
+/******************************************************************************
+ *                    Generic convolution filter class                        *
+ ******************************************************************************/
+class DataFilter
+{
+public:
+    // constructor
+    DataFilter(const std::vector<double> &filter, const bool downsample = false);
+    // filtering
+    void operator()(DVec &out, const DVec &in);
+    void operator()(DMat &out, const DMat &in);
+    template <typename MatType, Index o>
+    void operator()(StatArray<MatType, o> &out, const StatArray<MatType, o> &in);
+protected:
+    std::vector<double> filter_;
+private:
+    bool                downsample_;
+    DVec                vBuf_;
+    DMat                mBuf_;
+};
+
+/******************************************************************************
+ *                         Laplacian filter class                             *
+ ******************************************************************************/
+class LaplaceDataFilter: public DataFilter
+{
+public:
+    // constructor
+    LaplaceDataFilter(const bool downsample = false);
+    // filtering
+    void operator()(DVec &out, const DVec &in, const double lambda = 0.);
+    void operator()(DMat &out, const DMat &in, const double lambda = 0.);
+    template <typename MatType, Index o>
+    void operator()(StatArray<MatType, o> &out, const StatArray<MatType, o> &in, 
+                    const double lambda = 0.);
+    // correlation optimisation
+    template <typename MatType, Index o>
+    double optimiseCdr(const StatArray<MatType, o> &data, Minimizer &min,
+                       const unsigned int nPass = 3);
+};
+
+/******************************************************************************
+ *                 DataFilter class template implementation                   *
+ ******************************************************************************/
+// filtering //////////////////////////////////////////////////////////////////
+template <typename MatType, Index o>
+void DataFilter::operator()(StatArray<MatType, o> &out, const StatArray<MatType, o> &in)
+{
+    FOR_STAT_ARRAY(in, s)
+    {
+        (*this)(out[s], in[s]);
+    }
+}
+
+/******************************************************************************
+ *            LaplaceDataFilter class template implementation                 *
+ ******************************************************************************/
+// filtering //////////////////////////////////////////////////////////////////
+template <typename MatType, Index o>
+void LaplaceDataFilter::operator()(StatArray<MatType, o> &out, 
+                                   const StatArray<MatType, o> &in, const double lambda)
+{
+    FOR_STAT_ARRAY(in, s)
+    {
+        (*this)(out[s], in[s], lambda);
+    }
+}
+
+// correlation optimisation ///////////////////////////////////////////////////
+template <typename MatType, Index o>
+double LaplaceDataFilter::optimiseCdr(const StatArray<MatType, o> &data, 
+                                      Minimizer &min, const unsigned int nPass)
+{
+    StatArray<MatType, o> fdata(data.size());
+    DVec init(1);
+    double reg, prec;
+    DoubleFunction cdr([&data, &fdata, this](const double *x)
+    {
+        double res;
+        (*this)(fdata, data, x[0]);
+        res = Math::cdr(fdata.correlationMatrix());
+        
+        return res;
+    }, 1);
+
+    min.setLowLimit(0., -0.1);
+    min.setHighLimit(0., 100000.);
+    init(0) = 0.1;
+    min.setInit(init);
+    prec = 0.1;
+    min.setPrecision(prec);
+    reg = min(cdr)(0);
+    for (unsigned int pass = 0; pass < nPass; pass++)
+    {
+        min.setLowLimit(0., (1.-10.*prec)*reg);
+        min.setHighLimit(0., (1.+10.*prec)*reg);
+        init(0) = reg;
+        min.setInit(init);
+        prec *= 0.1;
+        min.setPrecision(prec);
+        reg = min(cdr)(0);
+    }
+
+    return reg;
+}
+
+END_LATAN_NAMESPACE
+
+#endif // Latan_DataFilter_hpp_

lib/Statistics/Histogram.cpp

@@ -146,16 +146,6 @@ double Histogram::getX(const Index i) const
     return x_(i);
 }
 
-double Histogram::getXMin(void) const
-{
-    return xMin_;
-}
-
-double Histogram::getXMax(void) const
-{
-    return xMax_;
-}
-
 double Histogram::operator[](const Index i) const
 {
     return bin_(i)*(isNormalized() ? norm_ : 1.);

lib/Statistics/Histogram.hpp

@@ -52,8 +52,6 @@ public:
     const StatArray<double> & getData(void) const;
     const StatArray<double> & getWeight(void) const;
     double                    getX(const Index i) const;
-    double                    getXMin(void) const;
-    double                    getXMax(void) const;
     double                    operator[](const Index i) const;
     double                    operator()(const double x) const;
     // percentiles & confidence interval

lib/Statistics/MatSample.hpp

@@ -103,10 +103,6 @@ public:
                      const Index nCol);
     // resize all matrices
     void resizeMat(const Index nRow, const Index nCol);
-    // covariance matrix
-    Mat<T> covarianceMatrix(const MatSample<T> &sample) const;
-    Mat<T> varianceMatrix(void) const;
-    Mat<T> correlationMatrix(void) const;
 };
 
 // non-member operators
@@ -383,79 +379,6 @@ void MatSample<T>::resizeMat(const Index nRow, const Index nCol)
     }
 }
 
-// covariance matrix ///////////////////////////////////////////////////////////
-template <typename T>
-Mat<T> MatSample<T>::covarianceMatrix(const MatSample<T> &sample) const
-{
-    if (((*this)[central].cols() != 1) or (sample[central].cols() != 1))
-    {
-        LATAN_ERROR(Size, "samples have more than one column");
-    }
-
-    Index  n1 = (*this)[central].rows(), n2 = sample[central].rows();
-    Index  nSample = this->size();
-    Mat<T> tmp1(n1, nSample), tmp2(n2, nSample), res(n1, n2);
-    Mat<T> s1(n1, 1), s2(n2, 1), one(nSample, 1);
-
-    one.fill(1.);
-    s1.fill(0.);
-    s2.fill(0.);
-    for (unsigned int s = 0; s < nSample; ++s)
-    {
-        s1          += (*this)[s];
-        tmp1.col(s)  = (*this)[s];
-    }
-    tmp1 -= s1*one.transpose()/static_cast<double>(nSample);
-    for (unsigned int s = 0; s < nSample; ++s)
-    {
-        s2          += sample[s];
-        tmp2.col(s)  = sample[s];
-    }
-    tmp2 -= s2*one.transpose()/static_cast<double>(nSample);
-    res   = tmp1*tmp2.transpose()/static_cast<double>(nSample - 1);
-
-    return res;
-}
-
-template <typename T>
-Mat<T> MatSample<T>::varianceMatrix(void) const
-{
-    if ((*this)[central].cols() != 1)
-    {
-        LATAN_ERROR(Size, "samples have more than one column");
-    }
-
-    Index  n1 = (*this)[central].rows();
-    Index  nSample = this->size();
-    Mat<T> tmp1(n1, nSample), res(n1, n1);
-    Mat<T> s1(n1, 1), one(nSample, 1);
-
-    one.fill(1.);
-    s1.fill(0.);
-    for (unsigned int s = 0; s < nSample; ++s)
-    {
-        s1          += (*this)[s];
-        tmp1.col(s)  = (*this)[s];
-    }
-    tmp1 -= s1*one.transpose()/static_cast<double>(nSample);
-    res   = tmp1*tmp1.transpose()/static_cast<double>(nSample - 1);
-
-    return res;
-}
-
-template <typename T>
-Mat<T> MatSample<T>::correlationMatrix(void) const
-{
-    Mat<T> res = varianceMatrix();
-    Mat<T> invDiag(res.rows(), 1);
-
-    invDiag = res.diagonal();
-    invDiag = invDiag.cwiseInverse().cwiseSqrt();
-    res     = (invDiag*invDiag.transpose()).cwiseProduct(res);
-
-    return res;
-}
-
 END_LATAN_NAMESPACE
 
 #endif // Latan_MatSample_hpp_

lib/Statistics/StatArray.hpp

@@ -52,10 +52,13 @@ public:
     // statistics
     void bin(Index binSize);
     T    sum(const Index pos = 0, const Index n = -1) const;
-    T    meanOld(const Index pos = 0, const Index n = -1) const;
     T    mean(const Index pos = 0, const Index n = -1) const;
     T    covariance(const StatArray<T, os> &array) const;
     T    variance(void) const;
+    T    covarianceMatrix(const StatArray<T, os> &data) const;
+    T    varianceMatrix(void) const;
+    T    correlationMatrix(void) const;
+
     // IO type
     virtual IoType getType(void) const;
 public:
@@ -192,6 +195,79 @@ T StatArray<T, os>::variance(void) const
     return covariance(*this);
 }
 
+template <typename MatType, Index os>
+MatType StatArray<MatType, os>::covarianceMatrix(
+    const StatArray<MatType, os> &data) const
+{
+    if (((*this)[central].cols() != 1) or (data[central].cols() != 1))
+    {
+        LATAN_ERROR(Size, "samples have more than one column");
+    }
+
+    Index   n1 = (*this)[central].rows(), n2 = data[central].rows();
+    Index   nSample = this->size();
+    MatType tmp1(n1, nSample), tmp2(n2, nSample), res(n1, n2);
+    MatType s1(n1, 1), s2(n2, 1), one(nSample, 1);
+
+    one.fill(1.);
+    s1.fill(0.);
+    s2.fill(0.);
+    for (unsigned int s = 0; s < nSample; ++s)
+    {
+        s1          += (*this)[s];
+        tmp1.col(s)  = (*this)[s];
+    }
+    tmp1 -= s1*one.transpose()/static_cast<double>(nSample);
+    for (unsigned int s = 0; s < nSample; ++s)
+    {
+        s2          += data[s];
+        tmp2.col(s)  = data[s];
+    }
+    tmp2 -= s2*one.transpose()/static_cast<double>(nSample);
+    res   = tmp1*tmp2.transpose()/static_cast<double>(nSample - 1);
+
+    return res;
+}
+
+template <typename MatType, Index os>
+MatType StatArray<MatType, os>::varianceMatrix(void) const
+{
+    if ((*this)[0].cols() != 1)
+    {
+        LATAN_ERROR(Size, "samples have more than one column");
+    }
+
+    Index   n1 = (*this)[0].rows();
+    Index   nSample = this->size();
+    MatType tmp1(n1, nSample), res(n1, n1);
+    MatType s1(n1, 1), one(nSample, 1);
+
+    one.fill(1.);
+    s1.fill(0.);
+    for (unsigned int s = 0; s < nSample; ++s)
+    {
+        s1          += (*this)[s];
+        tmp1.col(s)  = (*this)[s];
+    }
+    tmp1 -= s1*one.transpose()/static_cast<double>(nSample);
+    res   = tmp1*tmp1.transpose()/static_cast<double>(nSample - 1);
+
+    return res;
+}
+
+template <typename MatType, Index os>
+MatType StatArray<MatType, os>::correlationMatrix(void) const
+{
+    MatType res = varianceMatrix();
+    MatType invDiag(res.rows(), 1);
+
+    invDiag = res.diagonal();
+    invDiag = invDiag.cwiseInverse().cwiseSqrt();
+    res     = (invDiag*invDiag.transpose()).cwiseProduct(res);
+
+    return res;
+}
+
 // reduction operations ////////////////////////////////////////////////////////
 namespace StatOp
 {

lib/Statistics/XYSampleData.cpp

@@ -300,67 +300,6 @@ const XYStatData & XYSampleData::getData(void)
 }
 
 // fit /////////////////////////////////////////////////////////////////////////
-
-void XYSampleData::fitSample(std::vector<Minimizer *> &minimizer,
-                             const std::vector<const DoubleModel *> &v,
-                             SampleFitResult &result,
-                             DVec &init,
-                             Index s)
-{
-    result.resize(nSample_);
-    result.chi2_.resize(nSample_);
-    result.model_.resize(v.size());
-    FitResult sampleResult;
-    setDataToSample(s);
-    if (s == central)
-    {
-        sampleResult        = data_.fit(minimizer, init, v);
-        init                = sampleResult.segment(0, init.size());
-        result.nPar_        = sampleResult.getNPar();
-        result.nDof_        = sampleResult.nDof_;
-        result.parName_     = sampleResult.parName_;
-        result.corrRangeDb_ = Math::svdDynamicRangeDb(getFitCorrMat());
-    }
-    else
-    {
-        sampleResult = data_.fit(*(minimizer.back()), init, v);
-    }
-    result[s]       = sampleResult;
-    result.chi2_[s] = sampleResult.getChi2();
-    for (unsigned int j = 0; j < v.size(); ++j)
-    {
-        result.model_[j].resize(nSample_);
-        result.model_[j][s] = sampleResult.getModel(j);
-    }
-
-    
-}
-
-SampleFitResult XYSampleData::fit(std::vector<Minimizer *> &minimizer,
-                                  const DVec &init,
-                                  const std::vector<const DoubleModel *> &v,
-                                  Index s)
-{
-    computeVarMat();
-    
-    SampleFitResult result;
-    DVec      initCopy = init;
-
-    fitSample(minimizer, v, result, initCopy, s);
-    
-    return result;
-}
-
-SampleFitResult XYSampleData::fit(Minimizer &minimizer,
-                                  const DVec &init,
-                                  const std::vector<const DoubleModel *> &v,
-                                  Index s)
-{
-    vector<Minimizer *> mv{&minimizer};
-    
-    return fit(mv, init, v, s);
-}
-
 SampleFitResult XYSampleData::fit(std::vector<Minimizer *> &minimizer,
                                   const DVec &init,
                                   const std::vector<const DoubleModel *> &v)
@@ -368,14 +307,43 @@ SampleFitResult XYSampleData::fit(std::vector<Minimizer *> &minimizer,
     computeVarMat();
     
     SampleFitResult      result;
+    FitResult            sampleResult;
     DVec                 initCopy = init;
     Minimizer::Verbosity verbCopy = minimizer.back()->getVerbosity();
     
+    result.resize(nSample_);
+    result.chi2_.resize(nSample_);
+    result.model_.resize(v.size());
     FOR_STAT_ARRAY(result, s)
     {
-        fitSample(minimizer, v, result, initCopy, s);
+        setDataToSample(s);
+        if (s == central)
+        {
+            sampleResult = data_.fit(minimizer, initCopy, v);
+            initCopy     = sampleResult.segment(0, initCopy.size());
+            if (verbCopy != Minimizer::Verbosity::Debug)
+            {
+                minimizer.back()->setVerbosity(Minimizer::Verbosity::Silent);
+            }
+        }
+        else
+        {
+            
+            sampleResult = data_.fit(*(minimizer.back()), initCopy, v);
+        }
+        result[s]       = sampleResult;
+        result.chi2_[s] = sampleResult.getChi2();
+        for (unsigned int j = 0; j < v.size(); ++j)
+        {
+            result.model_[j].resize(nSample_);
+            result.model_[j][s] = sampleResult.getModel(j);
+        }
     }
     minimizer.back()->setVerbosity(verbCopy);
+    result.nPar_       = sampleResult.getNPar();
+    result.nDof_       = sampleResult.nDof_;
+    result.parName_    = sampleResult.parName_;
+    result.corrRangeDb_ = Math::cdr(getFitCorrMat());
     
     return result;
 }

lib/Statistics/XYSampleData.hpp

@@ -103,16 +103,9 @@ public:
     // get internal XYStatData
     const XYStatData & getData(void);
     // fit
-    void            fitSample(std::vector<Minimizer *> &minimizer, 
-                              const std::vector<const DoubleModel *> &v, 
-                              SampleFitResult &sampleResult, DVec &init, Index s);
-    SampleFitResult fit(std::vector<Minimizer *> &minimizer, const DVec &init, 
-                        const std::vector<const DoubleModel *> &v, Index s);
-    SampleFitResult fit(Minimizer &minimizer, const DVec &init, 
-                        const std::vector<const DoubleModel *> &v, Index s);
-    SampleFitResult fit(std::vector<Minimizer *> &minimizer, const DVec &init, 
+    SampleFitResult fit(std::vector<Minimizer *> &minimizer, const DVec &init,
                         const std::vector<const DoubleModel *> &v);
-    SampleFitResult fit(Minimizer &minimizer, const DVec &init, 
+    SampleFitResult fit(Minimizer &minimizer, const DVec &init,
                         const std::vector<const DoubleModel *> &v);
     template <typename... Ts>
     SampleFitResult fit(std::vector<Minimizer *> &minimizer, const DVec &init,

lib/Statistics/XYStatData.cpp

@@ -358,7 +358,7 @@ FitResult XYStatData::fit(vector<Minimizer *> &minimizer, const DVec &init,
         result    = (*m)(chi2);
         totalInit = result;
     }
-    result.corrRangeDb_ = Math::svdDynamicRangeDb(getFitCorrMat());
+    result.corrRangeDb_ = Math::cdr(getFitCorrMat());
     result.chi2_       = chi2(result);
     result.nPar_       = nPar;
     result.nDof_       = layout.totalYSize - nPar;

physics/2pt-fit.cpp

@@ -24,7 +24,7 @@ int main(int argc, char *argv[])
 {
     // parse arguments /////////////////////////////////////////////////////////
     OptParser            opt;
-    bool                 parsed, doLaplace, doPlot, doHeatmap, doCorr, fold, doScan;
+    bool                 parsed, doLaplace, doPlot, doHeatmap, doCorr, fold, doScan, noGuess;
     string               corrFileName, model, outFileName, outFmt, savePlot;
     Index                ti, tf, shift, nPar, thinning;
     double               svdTol;
@@ -59,6 +59,8 @@ int main(int argc, char *argv[])
                   "show the fit plot");
     opt.addOption("h", "heatmap"  , OptParser::OptType::trigger, true,
                   "show the fit correlation heatmap");
+    opt.addOption("", "no-guess"  , OptParser::OptType::trigger, true,
+                  "do not try to guess fit parameters");
     opt.addOption("", "save-plot", OptParser::OptType::value, true,
                     "saves the source and .pdf", "");
     opt.addOption("", "scan", OptParser::OptType::trigger, true,
@@ -87,6 +89,7 @@ int main(int argc, char *argv[])
     fold         = opt.gotOption("fold");
     doPlot       = opt.gotOption("p");
     doHeatmap    = opt.gotOption("h");
+    noGuess      = opt.gotOption("no-guess");
     savePlot     = opt.optionValue("save-plot");
     doScan       = opt.gotOption("scan");
     switch (opt.optionValue<unsigned int>("v"))
@@ -114,7 +117,6 @@ int main(int argc, char *argv[])
     nt      = corr[central].rows();
     corr    = corr.block(0, 0, nt, 1);
     corr    = CorrelatorUtils::shift(corr, shift);
-
     if (doLaplace)
     {
         vector<double> filter = {1., -2., 1.};
@@ -156,11 +158,6 @@ int main(int argc, char *argv[])
         }
     }
     
-    if (fold)
-    {
-        corr = CorrelatorUtils::fold(corr,modelPar);
-    }
-
     // fit /////////////////////////////////////////////////////////////////////
     DVec                init(nPar);
     NloptMinimizer      globMin(NloptMinimizer::Algorithm::GN_CRS2_LM);
@@ -173,13 +170,14 @@ int main(int argc, char *argv[])
     fitter.setThinning(thinning);
 
     // set initial values ******************************************************
-    if (modelPar.type != CorrelatorType::undefined)
+    if ((modelPar.type != CorrelatorType::undefined) and !noGuess)
     {
         init = CorrelatorModels::parameterGuess(corr, modelPar);
     }
     else
     {
-        init.fill(0.1);
+        init.fill(1.);
+        init(0) = 0.2;
     }
 
     // set limits for minimisers ***********************************************

utils/sample-dwt.cpp

@@ -17,6 +17,7 @@
  * along with LatAnalyze 3.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <LatAnalyze/Core/Math.hpp>
 #include <LatAnalyze/Core/OptParser.hpp>
 #include <LatAnalyze/Core/Plot.hpp>
 #include <LatAnalyze/Io/Io.hpp>
@@ -53,7 +54,13 @@ int main(int argc, char *argv[])
         cerr << "usage: " << argv[0];
         cerr << " <options> <input file>" << endl;
         cerr << endl << "Possible options:" << endl << opt << endl;
-        
+        cerr << "Available DWT filters:" << endl;
+        for (auto &fv: DWTFilters::fromName)
+        {
+            cerr << fv.first << " ";
+        }
+        cerr << endl << endl;
+
         return EXIT_FAILURE;
     }
     inFilename  = opt.getArgs()[0];
@@ -68,22 +75,45 @@ int main(int argc, char *argv[])
     DMatSample            in = Io::load<DMatSample>(inFilename), res;
     Index                 nSample = in.size(), n = in[central].rows();
     vector<DMatSample>    out(ss ? 1 : level, DMatSample(nSample)), 
-                          outh(ss ? 0 : level, DMatSample(nSample));
+                          outh(ss ? 0 : level, DMatSample(nSample)),
+                          concath(ss ? 0 : level, DMatSample(nSample));
+    DMatSample            concat(nSample, n, 1);
     DWT                   dwt(*DWTFilters::fromName.at(filterName));
     vector<DWT::DWTLevel> dataDWT(level);
 
+    FOR_STAT_ARRAY(in, s)
+    {
+        in[s].conservativeResize(n, 1);
+    }
     if (!ss)
     {
+        DMatSample buf(nSample);
+
         cout << "-- compute discrete wavelet transform" << endl;
         cout << "filter '" << filterName << "' / " << level << " level(s)" << endl;
         FOR_STAT_ARRAY(in, s)
         {
-            dataDWT = dwt.forward(in[s].col(0), level);
+            dataDWT = dwt.forward(in[s], level);
             for (unsigned int l = 0; l < level; ++l)
             {
-                out[l][s]  = dataDWT[l].first;
-                outh[l][s] = dataDWT[l].second;
+                out[l][s]     = dataDWT[l].first;
+                outh[l][s]    = dataDWT[l].second;
+                concath[l][s] = DWT::concat(dataDWT, l, true);
             }
+            concat[s] = DWT::concat(dataDWT);
+        }
+        cout << "Data CDR " << Math::cdr(in.correlationMatrix()) << " dB" << endl;
+        cout << "DWT CDR " << Math::cdr(concat.correlationMatrix()) << " dB" << endl;
+        for (unsigned int l = 0; l < level; ++l)
+        {
+            cout << "DWT level " << l << " CDR: L= ";
+            cout << Math::cdr(out[l].correlationMatrix()) << " dB / H= ";
+            cout << Math::cdr(outh[l].correlationMatrix()) << " dB" << endl;
+        }
+        for (unsigned int l = 0; l < level; ++l)
+        {
+            cout << "DWT detail level " << l << " CDR: ";
+            cout << Math::cdr(concath[l].correlationMatrix()) << " dB" << endl;
         }
     }
     else
@@ -102,7 +132,7 @@ int main(int argc, char *argv[])
         }
         FOR_STAT_ARRAY(in, s)
         {
-            dataDWT.back().first = in[s].col(0);
+            dataDWT.back().first = in[s];
             out[0][s] = dwt.backward(dataDWT);
         }
     }
@@ -115,7 +145,9 @@ int main(int argc, char *argv[])
             {
                 Io::save<DMatSample>(out[l], outFilename + "/L" + strFrom(l) + ".h5");
                 Io::save<DMatSample>(outh[l], outFilename + "/H" + strFrom(l) + ".h5");
+                Io::save<DMatSample>(concath[l], outFilename + "/concatH" + strFrom(l) + ".h5");
             }
+            Io::save<DMatSample>(concat, outFilename + "/concat.h5");
         }
         else
         {

utils/sample-fake.cpp

@@ -18,42 +18,30 @@
  */
 
 #include <LatAnalyze/Io/Io.hpp>
-#include <LatAnalyze/Core/OptParser.hpp>
-
 
 using namespace std;
 using namespace Latan;
 
 int main(int argc, char *argv[])
 {
-    OptParser            opt;
     Index  nSample;
     double val, err;
     string outFileName;
 
-    opt.addOption("r", "seed"      , OptParser::OptType::value,   true,
-                    "random generator seed (default: random)"); 
-    opt.addOption("", "help"      , OptParser::OptType::trigger, true,
-                  "show this help message and exit");
-
-    bool parsed = opt.parse(argc, argv);
-    if (!parsed or (opt.getArgs().size() != 4) or opt.gotOption("help"))
+    if (argc != 5)
     {
         cerr << "usage: " << argv[0];
         cerr << " <central value> <error> <nSample> <output file>" << endl;
-        cerr << endl << "Possible options:" << endl << opt << endl;
 
         return EXIT_FAILURE;
     }
-
     val         = strTo<double>(argv[1]);
     err         = strTo<double>(argv[2]);
     nSample     = strTo<Index>(argv[3]);
     outFileName = argv[4];
 
     random_device         rd;
-    SeedType              seed = (opt.gotOption("r")) ? opt.optionValue<SeedType>("r") : rd();
-    mt19937               gen(seed);
+    mt19937               gen(rd());
     normal_distribution<> dis(val, err);
     DSample               res(nSample);
 
@@ -71,4 +59,4 @@ int main(int argc, char *argv[])
     Io::save<DSample>(res, outFileName);
 
     return EXIT_SUCCESS;
-}
+}

utils/sample-plot-corr.cpp

@@ -68,7 +68,7 @@ int main(int argc, char *argv[])
     var    = sample.varianceMatrix();
     corr   = sample.correlationMatrix();
 
-    cout << "dynamic range " << Math::svdDynamicRangeDb(corr) << " dB" << endl;
+    cout << "dynamic range " << Math::cdr(corr) << " dB" << endl;
     p << PlotCorrMatrix(corr);
     p.display();
     if (!outVarName.empty())

utils/sample-read.cpp

@@ -38,23 +38,9 @@ int main(int argc, char *argv[])
     {
         DMatSample s    = Io::load<DMatSample>(fileName);
         string     name = Io::getFirstName(fileName);
-        Index nRows     = s[central].rows();
-        Index nCols     = s[central].cols();
         cout << scientific;
-        cout << "central value +/-  standard deviation\n" << endl;
-        cout << "Re:" << endl;
-        for(Index i = 0; i < nRows; i++)
-        {
-            cout << s[central](i,0) << " +/- " << s.variance().cwiseSqrt()(i,0) << endl;
-        }
-        if(nCols == 2)
-        {
-            cout << "\nIm:" << endl;
-            for(Index i = 0; i < nRows; i++)
-            {
-                cout << s[central](i,1) << " +/- " << s.variance().cwiseSqrt()(i,1) << endl;
-            }   
-        }
+        cout << "central value:\n"      << s[central]               << endl;
+        cout << "standard deviation:\n" << s.variance().cwiseSqrt() << endl;
         if (!copy.empty())
         {
             Io::save(s, copy, File::Mode::write, name);
@@ -65,8 +51,8 @@ int main(int argc, char *argv[])
         DSample s    = Io::load<DSample>(fileName);
         string  name = Io::getFirstName(fileName);
         cout << scientific;
-        cout << "central value +/-  standard deviation\n" << endl;
-        cout << s[central] << " +/- " << sqrt(s.variance()) << endl;
+        cout << "central value:\n"      << s[central]         << endl;
+        cout << "standard deviation:\n" << sqrt(s.variance()) << endl;
         if (!copy.empty())
         {
             Io::save(s, copy, File::Mode::write, name);