Parameter.h

Go to the documentation of this file.

/*  YAP - Yet another PWA toolkit
    Copyright 2015, Technische Universitaet Muenchen,
    Authors: Daniel Greenwald, Johannes Rauch

    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 yap_Parameter_h
#define yap_Parameter_h

#include "fwd/Parameter.h"

#include "Exceptions.h"
#include "VariableStatus.h"

#include <algorithm>
#include <complex>
#include <memory>
#include <numeric>

namespace yap {

class ParameterBase
{
protected:

    ParameterBase() : VariableStatus_(VariableStatus::changed) {}

public:

    VariableStatus& variableStatus()
    { return VariableStatus_; }

    const VariableStatus variableStatus() const
    { return VariableStatus_; }

    virtual const size_t size() const = 0;

    virtual void setValue(const std::vector<double>& V) = 0;

private:

    VariableStatus VariableStatus_;

};

template <typename IterType>
constexpr VariableStatus variable_status(IterType first, IterType last)
{
    return std::any_of(first, last,
                       [](const std::shared_ptr<ParameterBase>& p)
                       {return p->variableStatus() == VariableStatus::changed;})
        ? VariableStatus::changed : VariableStatus::unchanged;
}

template <typename T>
class Parameter : public ParameterBase
{
public:

    Parameter() = default;

    explicit Parameter(T t) : ParameterBase(), ParameterValue_(t)
    {}

    ~Parameter() = default;

    Parameter(const Parameter&) = default;

    Parameter(Parameter&&) = default;

    Parameter& operator=(const Parameter&) = default;

    Parameter& operator=(Parameter&&) = default;

    virtual typename std::conditional<std::is_fundamental<T>::value, const T, const T&>::type
    value() const
    { return ParameterValue_; }

    using ParameterBase::setValue;

    virtual void setValue(typename std::conditional<std::is_fundamental<T>::value, const T, const T&>::type val)
    {
        if (variableStatus() == VariableStatus::fixed)
            throw exceptions::ParameterIsFixed("", "Parameter::setValue");
        if (ParameterValue_ == val)
            return;
        ParameterValue_ = val;
        variableStatus() = VariableStatus::changed;
    }

    Parameter& operator=(typename std::conditional<std::is_fundamental<T>::value, const T, const T&>::type t)
    { setValue(t); return *this; }


private:

    T ParameterValue_;

};

template <typename T>
inline std::string to_string(const Parameter<T>& P)
{ using std::to_string; return to_string(P.value()) + " (" + to_string(P.variableStatus()) + ")"; }

class RealParameter : public Parameter<double>
{
public:

    RealParameter(double t = 0) : Parameter(t) {}

    const size_t size() const {return 1;}

    using Parameter::setValue;

    void setValue(const std::vector<double>& V)
    { setValue(V[0]); }

    using Parameter::operator=;
};

class ComplexParameter : public Parameter<std::complex<double> >
{
public:

    ComplexParameter(const std::complex<double>& t = 0) : Parameter(t) {}

    const size_t size() const {return 2;}

    using Parameter::setValue;

    void setValue(const std::vector<double>& V)
    { setValue(std::complex<double>(V[0], V[1])); }

    using Parameter::operator=;
};


class ComplexComponentParameter : public RealParameter
{
public:
    ComplexComponentParameter(std::shared_ptr<ComplexParameter> par);

    const double value() const override
    { return component(Parent_->value()); }

    using RealParameter::setValue;

    void setValue(double val) override;

    std::shared_ptr<ComplexParameter> parent()
    { return Parent_; }

    using RealParameter::operator=;

protected:

    virtual double component(const std::complex<double>& c) const = 0;

    virtual std::complex<double> setComponent(const std::complex<double>& c, double v) const = 0;

private:

    std::shared_ptr<ComplexParameter> Parent_;

};

class RealComponentParameter : public ComplexComponentParameter
{
public:

    RealComponentParameter(std::shared_ptr<ComplexParameter> par)
        : ComplexComponentParameter(par) {}

    using ComplexComponentParameter::operator=;

protected:

    double component(const std::complex<double>& c) const override
    { return real(c); }

    virtual std::complex<double> setComponent(const std::complex<double>& c, double v) const override
    { return std::complex<double>(v, imag(c)); }

};

class ImaginaryComponentParameter : public ComplexComponentParameter
{
public:

    ImaginaryComponentParameter(std::shared_ptr<ComplexParameter> par)
        : ComplexComponentParameter(par) {}

    using ComplexComponentParameter::operator=;

protected:

    double component(const std::complex<double>& c) const override
    { return imag(c); }

    virtual std::complex<double> setComponent(const std::complex<double>& c, double v) const override
    { return std::complex<double>(real(c), v); }

};

inline const size_t size(const ParameterVector& V)
{ return std::accumulate(V.begin(), V.end(), size_t(0), [](size_t& s, const ParameterVector::value_type & p) {return s += p->size();}); }

template <class InputIt>
std::vector<double>::const_iterator set_value(ParameterBase& P, InputIt first)
{ std::vector<double> V(first, first + P.size()); P.setValue(V); return first += (P.size() - 1); }

template <class InputIt>
void set_values(ParameterVector::iterator first_par, ParameterVector::iterator last_par, InputIt first_val, InputIt last_val)
{
    while (first_par != last_par and first_val != last_val) {
        first_val = set_value(**first_par, first_val);
        ++first_par;
        ++first_val;
    }
    if (first_par != last_par)
        throw exceptions::Exception("insufficient number of values provided", "set_values");
}

inline void set_values(ParameterVector& pars, const std::vector<double>& vals)
{ set_values(pars.begin(), pars.end(), vals.begin(), vals.end()); }

}

#endif