param_func.hpp

Go to the documentation of this file.

/***************************************************************************
 *   Software License Agreement (BSD License)                              *
 *   Copyright (C) 2016 by Horatiu George Todoran <todorangrg@gmail.com>   *
 *                                                                         *
 *   Redistribution and use in source and binary forms, with or without    *
 *   modification, are permitted provided that the following conditions    *
 *   are met:                                                              *
 *                                                                         *
 *   1. Redistributions of source code must retain the above copyright     *
 *      notice, this list of conditions and the following disclaimer.      *
 *   2. Redistributions in binary form must reproduce the above copyright  *
 *      notice, this list of conditions and the following disclaimer in    *
 *      the documentation and/or other materials provided with the         *
 *      distribution.                                                      *
 *   3. Neither the name of the copyright holder nor the names of its      *
 *      contributors may be used to endorse or promote products derived    *
 *      from this software without specific prior written permission.      *
 *                                                                         *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS   *
 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT     *
 *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS     *
 *   FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE        *
 *   COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,  *
 *   INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,  *
 *   BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;      *
 *   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER      *
 *   CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT    *
 *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY *
 *   WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE           *
 *   POSSIBILITY OF SUCH DAMAGE.                                           *
 ***************************************************************************/

#ifndef PARAM_FUNC_HPP
#define PARAM_FUNC_HPP

#include <memory>
#include <vector>
#include <map>
#include <tuw_control/utils.h>

namespace tuw
{
// enums
enum class FuncEvalMode
{
  DIFF1,  
  DIFF2,  
  INT1,   
  INT2,   
  FUNC,   
  ENUM_SIZE
};
enum class CtrlPtDim
{
  VAL,  
  ARC   
};
enum class EvalArcGuarantee
{
  NONE,
  NEAR_LAST,  
  AT_BEGIN,   
  AT_END      
};

static constexpr const std::size_t nrModesMax_ = asInt(FuncEvalMode::ENUM_SIZE) - 1;
using FuncEvalModesFlags = std::array<bool, nrModesMax_>;

// structs
struct ParamFuncsStructure
{
  ParamFuncsStructure() : ctrlPtsSize(0), ctrlPtsArcRefIdx(0), evalReq()
  {
    evalReq.fill(false);
  }
  std::size_t ctrlPtsSize;  
  std::size_t ctrlPtsArcRefIdx;  
  FuncEvalModesFlags evalReq;  
};
template <typename TNumType>
struct FuncCtrlPt
{
  FuncCtrlPt(const TNumType& _val, TNumType& _arc) : val(_val), arc(_arc)
  {
  }
  TNumType val;   
  TNumType& arc;  
};

namespace
{
template <class TDerived>
struct ParamFuncsBaseCRTPTraits;
}

template <typename TDerived>
class ParamFuncsBaseCRTP
{
protected:
  using eAG = EvalArcGuarantee;

protected:
  using NumType = typename ParamFuncsBaseCRTPTraits<TDerived>::NumType;

protected:
  using FuncCtrlPtType = FuncCtrlPt<NumType>;

  // special class member functions
public:
  ParamFuncsBaseCRTP() = default;

public:
  ~ParamFuncsBaseCRTP() = default;

public:
  ParamFuncsBaseCRTP(const ParamFuncsBaseCRTP&) = default;

public:
  ParamFuncsBaseCRTP& operator=(const ParamFuncsBaseCRTP&) = default;

public:
  ParamFuncsBaseCRTP(ParamFuncsBaseCRTP&&) = default;

public:
  ParamFuncsBaseCRTP& operator=(ParamFuncsBaseCRTP&&) = default;

public:
  template <typename TParamFucsStructVecArr>
  void init(const TParamFucsStructVecArr& _paramFuncsStructure)
  {
    thisDerived().initImplCRTP(_paramFuncsStructure);
  }
public:
  std::size_t funcsSize() const
  {
    return thisDerived().funcsSizeImplCRTP();
  }
public:
  std::size_t funcsArcSize() const
  {
    return thisDerived().funcsArcSizeImplCRTP();
  }
public:
  std::size_t funcsArcSize(const std::size_t& _i) const
  {
    return thisDerived().funcsArcSizeImplCRTP(_i);
  }
public:
  std::size_t funcCtrlPtSize(const std::size_t& _i) const
  {
    return thisDerived().funcCtrlPtSizeImplCRTP(_i);
  }
public:
  NumType& funcsArcBegin()
  {
    return thisDerived().funcsArcBeginImplCRTP();
  }
public:
  const NumType& funcsArcBegin() const
  {
    return thisDerived().funcsArcBeginImplCRTP();
  }
public:
  NumType& funcsArcEnd()
  {
    return thisDerived().funcsArcEndImplCRTP();
  }
public:
  const NumType& funcsArcEnd() const
  {
    return thisDerived().funcsArcEndImplCRTP();
  }
public:
  const NumType& funcsArcEval() const
  {
    return thisDerived().funcsArcEvalImplCRTP();
  }
public:
  NumType& funcsArc(const std::size_t& _i, const std::size_t& _j)
  {
    return thisDerived().funcsArcImplCRTP(_i, _j);
  }
public:
  const NumType& funcsArc(const std::size_t& _i, const std::size_t& _j) const
  {
    return thisDerived().funcsArcImplCRTP(_i, _j);
  }
public:
  FuncCtrlPtType& ctrlPt(const std::size_t& _funcIdx, const std::size_t& _funcCtrlPtIdx)
  {
    return thisDerived().ctrlPtImplCRTP(_funcIdx, _funcCtrlPtIdx);
  }
public:
  const FuncCtrlPtType& ctrlPt(const std::size_t& _funcIdx, const std::size_t& _funcCtrlPtIdx) const
  {
    return thisDerived().ctrlPtImplCRTP(_funcIdx, _funcCtrlPtIdx);
  }
public:
  NumType& ctrlPtVal(const std::size_t& _funcIdx, const std::size_t& _funcCtrlPtIdx,
                     const CtrlPtDim& _ctrlPtDim = CtrlPtDim::VAL)
  {
    return thisDerived().ctrlPtValImplCRTP(_funcIdx, _funcCtrlPtIdx, _ctrlPtDim);
  }
public:
  const NumType& ctrlPtVal(const std::size_t& _funcIdx, const std::size_t& _funcCtrlPtIdx,
                           const CtrlPtDim& _ctrlPtDim = CtrlPtDim::VAL) const
  {
    return thisDerived().ctrlPtValImplCRTP(_funcIdx, _funcCtrlPtIdx, _ctrlPtDim);
  }

public:
  void shiftStartCtrlPt(const NumType& _dt)
  {
    thisDerived().shiftStartCtrlPtImplCRTP(_dt);
  }

public:
  void precompute()
  {
    thisDerived().precomputeImplCRTP();
  }
public:
  void setEvalArc(const NumType& _arcEval, const eAG& _eAG = eAG::NONE)
  {
    thisDerived().setEvalArcImplCRTP(_arcEval, _eAG);
  }
public:
  NumType computeFuncVal(const std::size_t& _funcIdx) const
  {
    return thisDerived().computeFuncValImplCRTP(_funcIdx);
  }
public:
  NumType computeFuncDiff1(const std::size_t& _funcIdx) const
  {
    return thisDerived().computeFuncDiff1ImplCRTP(_funcIdx);
  }
public:
  NumType computeFuncDiff2(const std::size_t& _funcIdx) const
  {
    return thisDerived().computeFuncDiff2ImplCRTP(_funcIdx);
  }
public:
  NumType computeFuncInt1(const std::size_t& _funcIdx) const
  {
    return thisDerived().computeFuncInt1ImplCRTP(_funcIdx);
  }
public:
  NumType computeFuncInt2(const std::size_t& _funcIdx) const
  {
    return thisDerived().computeFuncInt2ImplCRTP(_funcIdx);
  }

private:
  TDerived& thisDerived()
  {
    return static_cast<TDerived&>(*this);
  }

private:
  const TDerived& thisDerived() const
  {
    return static_cast<const TDerived&>(*this);
  }
};
template <typename TNumType>
class ParamFuncsBaseVirt
{
protected:
  using eAG = EvalArcGuarantee;

protected:
  using FuncCtrlPtType = FuncCtrlPt<TNumType>;

  // special class member functions
public:
  ParamFuncsBaseVirt() = default;

public:
  virtual ~ParamFuncsBaseVirt() = default;

public:
  ParamFuncsBaseVirt(const ParamFuncsBaseVirt&) = default;

public:
  ParamFuncsBaseVirt& operator=(const ParamFuncsBaseVirt&) = default;

public:
  ParamFuncsBaseVirt(ParamFuncsBaseVirt&&) = default;

public:
  ParamFuncsBaseVirt& operator=(ParamFuncsBaseVirt&&) = default;

public:
  void init(const std::vector<ParamFuncsStructure>& _paramFuncsStructure)
  {
    initImplVirt(_paramFuncsStructure);
  }
public:
  std::size_t funcsSize() const
  {
    return funcsSizeImplVirt();
  }
public:
  std::size_t funcsArcSize() const
  {
    return funcsArcSizeImplVirt();
  }
public:
  std::size_t funcsArcSize(const std::size_t& _i) const
  {
    return funcsArcSizeImplVirt(_i);
  }
public:
  std::size_t funcCtrlPtSize(const std::size_t& _i) const
  {
    return funcCtrlPtSizeImplVirt(_i);
  }
public:
  TNumType& funcsArcBegin()
  {
    return funcsArcBeginImplVirt();
  }
public:
  const TNumType& funcsArcBegin() const
  {
    return funcsArcBeginImplVirt();
  }
public:
  TNumType& funcsArcEnd()
  {
    return funcsArcEndImplVirt();
  }
public:
  const TNumType& funcsArcEnd() const
  {
    return funcsArcEndImplVirt();
  }
public:
  const TNumType& funcsArcEval() const
  {
    return funcsArcEvalImplVirt();
  }
public:
  TNumType& funcsArc(const std::size_t& _i, const std::size_t& _j)
  {
    return funcsArcImplVirt(_i, _j);
  }
public:
  const TNumType& funcsArc(const std::size_t& _i, const std::size_t& _j) const
  {
    return funcsArcImplVirt(_i, _j);
  }
public:
  FuncCtrlPtType& ctrlPt(const std::size_t& _funcIdx, const std::size_t& _funcCtrlPtIdx)
  {
    return ctrlPtImplVirt(_funcIdx, _funcCtrlPtIdx);
  }
public:
  const FuncCtrlPtType& ctrlPt(const std::size_t& _funcIdx, const std::size_t& _funcCtrlPtIdx) const
  {
    return ctrlPtImplVirt(_funcIdx, _funcCtrlPtIdx);
  }
public:
  TNumType& ctrlPtVal(const std::size_t& _funcIdx, const std::size_t& _funcCtrlPtIdx,
                      const CtrlPtDim& _ctrlPtDim = CtrlPtDim::VAL)
  {
    return ctrlPtValImplVirt(_funcIdx, _funcCtrlPtIdx, _ctrlPtDim);
  }
public:
  const TNumType& ctrlPtVal(const std::size_t& _funcIdx, const std::size_t& _funcCtrlPtIdx,
                            const CtrlPtDim& _ctrlPtDim = CtrlPtDim::VAL) const
  {
    return ctrlPtValImplVirt(_funcIdx, _funcCtrlPtIdx, _ctrlPtDim);
  }

public:
  void shiftStartCtrlPt(const TNumType& _dt)
  {
    shiftStartCtrlPtImplVirt(_dt);
  }

public:
  void precompute()
  {
    precomputeImplVirt();
  }
public:
  void setEvalArc(const TNumType& _arcEval, const eAG& _eAG = eAG::NONE)
  {
    setEvalArcImplVirt(_arcEval, _eAG);
  }
public:
  TNumType computeFuncVal(const std::size_t& _funcIdx) const
  {
    return computeFuncValImplVirt(_funcIdx);
  }
public:
  TNumType computeFuncDiff1(const std::size_t& _funcIdx) const
  {
    return computeFuncDiff1ImplVirt(_funcIdx);
  }
public:
  TNumType computeFuncDiff2(const std::size_t& _funcIdx) const
  {
    return computeFuncDiff2ImplVirt(_funcIdx);
  }
public:
  TNumType computeFuncInt1(const std::size_t& _funcIdx) const
  {
    return computeFuncInt1ImplVirt(_funcIdx);
  }
public:
  TNumType computeFuncInt2(const std::size_t& _funcIdx) const
  {
    return computeFuncInt2ImplVirt(_funcIdx);
  }

  // pure virtual functions
private:
  virtual void initImplVirt(const std::vector<ParamFuncsStructure>& _paramFuncsStructure) = 0;

private:
  virtual std::size_t funcsSizeImplVirt() const = 0;

private:
  virtual std::size_t funcsArcSizeImplVirt() const = 0;

private:
  virtual std::size_t funcsArcSizeImplVirt(const std::size_t& _i) const = 0;

private:
  virtual std::size_t funcCtrlPtSizeImplVirt(const std::size_t& _i) const = 0;

private:
  virtual TNumType& funcsArcBeginImplVirt() = 0;

private:
  virtual const TNumType& funcsArcBeginImplVirt() const = 0;

private:
  virtual TNumType& funcsArcEndImplVirt() = 0;

private:
  virtual const TNumType& funcsArcEndImplVirt() const = 0;

private:
  virtual const TNumType& funcsArcEvalImplVirt() const = 0;

private:
  virtual TNumType& funcsArcImplVirt(const std::size_t& _i, const std::size_t& _j) = 0;

private:
  virtual const TNumType& funcsArcImplVirt(const std::size_t& _i, const std::size_t& _j) const = 0;

private:
  virtual FuncCtrlPtType& ctrlPtImplVirt(const std::size_t& _funcIdx, const std::size_t& _funcCtrlPtIdx) = 0;

private:
  virtual const FuncCtrlPtType& ctrlPtImplVirt(const std::size_t& _funcIdx,
                                               const std::size_t& _funcCtrlPtIdx) const = 0;

private:
  virtual TNumType& ctrlPtValImplVirt(const std::size_t& _funcIdx, const std::size_t& _funcCtrlPtIdx,
                                      const CtrlPtDim& _ctrlPtDim) = 0;

private:
  virtual const TNumType& ctrlPtValImplVirt(const std::size_t& _funcIdx, const std::size_t& _funcCtrlPtIdx,
                                            const CtrlPtDim& _ctrlPtDim) const = 0;

private:
  virtual void shiftStartCtrlPtImplVirt(const TNumType& _dt) = 0;

private:
  virtual void precomputeImplVirt() = 0;

private:
  virtual void setEvalArcImplVirt(const TNumType& _arcEval, const eAG& _eAG) = 0;

private:
  virtual TNumType computeFuncValImplVirt(const std::size_t& _funcIdx) const = 0;

private:
  virtual TNumType computeFuncDiff1ImplVirt(const std::size_t& _funcIdx) const = 0;

private:
  virtual TNumType computeFuncDiff2ImplVirt(const std::size_t& _funcIdx) const = 0;

private:
  virtual TNumType computeFuncInt1ImplVirt(const std::size_t& _funcIdx) const = 0;

private:
  virtual TNumType computeFuncInt2ImplVirt(const std::size_t& _funcIdx) const = 0;
};

template <typename TNumType>
struct ParamFuncsBaseArcVarsDyn
{
protected:
  std::vector<std::vector<TNumType>> funcCtrlPtArc_;
};
template <typename TNumType, size_t TArcLatticeSize>
struct ParamFuncsBaseArcVarsStatic
{
protected:
  std::array<std::vector<TNumType>, TArcLatticeSize> funcCtrlPtArc_;
};

template <typename TNumType>
struct ParamFuncsBaseFuncVarsDyn
{
protected:
  std::vector<FuncEvalModesFlags> funcEvalReq_;
protected:
  std::vector<std::vector<FuncCtrlPt<TNumType>>> funcCtrlPt_;
protected:
  std::vector<ParamFuncsStructure> paramFuncsStructure_;
protected:
  std::vector<std::size_t> func2Arc_;
};
template <typename TNumType, size_t TFuncSize>
struct ParamFuncsBaseFuncVarsStatic
{
protected:
  std::array<FuncEvalModesFlags, TFuncSize> funcEvalReq_;
protected:
  std::array<std::vector<FuncCtrlPt<TNumType>>, TFuncSize> funcCtrlPt_;
protected:
  std::array<ParamFuncsStructure, TFuncSize> paramFuncsStructure_;
protected:
  std::array<std::size_t, TFuncSize> func2Arc_;
};

template <typename TDerived, typename TNumType, int TFuncSize, int TArcLatticeSize>
class ParamFuncsBase : public ParamFuncsBaseCRTP<ParamFuncsBase<TDerived, TNumType, TFuncSize, TArcLatticeSize>>,
                       public ParamFuncsBaseVirt<TNumType>,
                       public std::conditional<TFuncSize == -1, ParamFuncsBaseFuncVarsDyn<TNumType>,
                                               ParamFuncsBaseFuncVarsStatic<TNumType, TFuncSize>>::type,
                       public std::conditional<TArcLatticeSize == -1, ParamFuncsBaseArcVarsDyn<TNumType>,
                                               ParamFuncsBaseArcVarsStatic<TNumType, TArcLatticeSize>>::type
{
public:
  using NumType = TNumType;

public:
  using ParamFuncsBaseType = ParamFuncsBase<TDerived, TNumType, TFuncSize, TArcLatticeSize>;

public:
  static constexpr const int FuncSize = TFuncSize;

private:
  static constexpr const bool IsFuncDyn = TFuncSize == -1;

private:
  static constexpr const bool IsArcDyn = TArcLatticeSize == -1;

protected:
  using FuncCtrlPtType = FuncCtrlPt<TNumType>;

  // special class member functions
public:
  ParamFuncsBase() : funcsArcEval_(-1)
  {
  }

public:
  virtual ~ParamFuncsBase() = default;

public:
  ParamFuncsBase(const ParamFuncsBase& _other)
  {
    using PfCpD = CtrlPtDim;
    initBase(_other.paramFuncsStructure_);
    for (size_t i = 0; i < funcsArcSize(); ++i)
    {
      for (size_t j = 0; j < funcsArcSize(i); ++j)
      {
        funcsArc(i, j) = _other.funcsArc(i, j);
      }
    }
    for (size_t i = 0; i < funcsSize(); ++i)
    {
      for (size_t j = 0; j < funcCtrlPtSize(i); ++j)
      {
        ctrlPtVal(i, j, PfCpD::VAL) = _other.ctrlPtVal(i, j, PfCpD::VAL);
      }
    }
  }

public:
  ParamFuncsBase& operator=(const ParamFuncsBase& _other)
  {
    if (this == &_other)
    {
      return *this;
    }

    using PfCpD = CtrlPtDim;
    init(_other.paramFuncsStructure_);
    for (size_t i = 0; i < funcsArcSize(); ++i)
    {
      for (size_t j = 0; j < funcsArcSize(i); ++j)
      {
        funcsArc(i, j) = _other.funcsArc(i, j);
      }
    }
    for (size_t i = 0; i < funcsSize(); ++i)
    {
      for (size_t j = 0; j < funcCtrlPtSize(i); ++j)
      {
        ctrlPtVal(i, j, PfCpD::VAL) = _other.ctrlPtVal(i, j, PfCpD::VAL);
      }
    }
    return *this;
  }

public:
  ParamFuncsBase(ParamFuncsBase&&) = default;

public:
  ParamFuncsBase& operator=(ParamFuncsBase&&) = default;

  using ParamFuncsBaseCRTP<ParamFuncsBaseType>::init;
  using ParamFuncsBaseCRTP<ParamFuncsBaseType>::funcsSize;
  using ParamFuncsBaseCRTP<ParamFuncsBaseType>::funcsArcSize;
  using ParamFuncsBaseCRTP<ParamFuncsBaseType>::funcCtrlPtSize;
  using ParamFuncsBaseCRTP<ParamFuncsBaseType>::funcsArcBegin;
  using ParamFuncsBaseCRTP<ParamFuncsBaseType>::funcsArcEnd;
  using ParamFuncsBaseCRTP<ParamFuncsBaseType>::funcsArcEval;
  using ParamFuncsBaseCRTP<ParamFuncsBaseType>::funcsArc;
  using ParamFuncsBaseCRTP<ParamFuncsBaseType>::ctrlPt;
  using ParamFuncsBaseCRTP<ParamFuncsBaseType>::ctrlPtVal;
  using ParamFuncsBaseCRTP<ParamFuncsBaseType>::shiftStartCtrlPt;
  using ParamFuncsBaseCRTP<ParamFuncsBaseType>::precompute;
  using ParamFuncsBaseCRTP<ParamFuncsBaseType>::setEvalArc;
  using ParamFuncsBaseCRTP<ParamFuncsBaseType>::computeFuncVal;
  using ParamFuncsBaseCRTP<ParamFuncsBaseType>::computeFuncDiff1;
  using ParamFuncsBaseCRTP<ParamFuncsBaseType>::computeFuncDiff2;
  using ParamFuncsBaseCRTP<ParamFuncsBaseType>::computeFuncInt1;
  using ParamFuncsBaseCRTP<ParamFuncsBaseType>::computeFuncInt2;
protected:
  void initImpl()
  {
    thisDerived().initImplImpl();
  }

private:
  void precomputeImplVirt() override final
  {
    thisDerived().precomputeImpl();
  }

private:
  void setEvalArcImplVirt(const TNumType& _arcEval,
                          const typename ParamFuncsBaseCRTP<ParamFuncsBaseType>::eAG& _eAG) override final
  {
    thisDerived().setEvalArcImpl(_arcEval, _eAG);
  }

private:
  TNumType computeFuncValImplVirt(const std::size_t& _funcIdx) const override final
  {
    return thisDerived().computeFuncValImpl(_funcIdx);
  }

private:
  TNumType computeFuncDiff1ImplVirt(const std::size_t& _funcIdx) const override final
  {
    return thisDerived().computeFuncDiff1Impl(_funcIdx);
  }

private:
  TNumType computeFuncDiff2ImplVirt(const std::size_t& _funcIdx) const override final
  {
    return thisDerived().computeFuncDiff2Impl(_funcIdx);
  }

private:
  TNumType computeFuncInt1ImplVirt(const std::size_t& _funcIdx) const override final
  {
    return thisDerived().computeFuncInt1Impl(_funcIdx);
  }

private:
  TNumType computeFuncInt2ImplVirt(const std::size_t& _funcIdx) const override final
  {
    return thisDerived().computeFuncInt2Impl(_funcIdx);
  }

private:
  void precomputeImplCRTP()
  {
    thisDerived().precomputeImpl();
  }

private:
  void setEvalArcImplCRTP(const TNumType& _arcEval, const typename ParamFuncsBaseCRTP<ParamFuncsBaseType>::eAG& _eAG)
  {
    thisDerived().setEvalArcImpl(_arcEval, _eAG);
  }

private:
  TNumType computeFuncValImplCRTP(const std::size_t& _funcIdx) const
  {
    return thisDerived().computeFuncValImpl(_funcIdx);
  }

private:
  TNumType computeFuncDiff1ImplCRTP(const std::size_t& _funcIdx) const
  {
    return thisDerived().computeFuncDiff1Impl(_funcIdx);
  }

private:
  TNumType computeFuncDiff2ImplCRTP(const std::size_t& _funcIdx) const
  {
    return thisDerived().computeFuncDiff2Impl(_funcIdx);
  }

private:
  TNumType computeFuncInt1ImplCRTP(const std::size_t& _funcIdx) const
  {
    return thisDerived().computeFuncInt1Impl(_funcIdx);
  }

private:
  TNumType computeFuncInt2ImplCRTP(const std::size_t& _funcIdx) const
  {
    return thisDerived().computeFuncInt2Impl(_funcIdx);
  }

private:
  template <bool FuncDyn = IsFuncDyn, typename std::enable_if<FuncDyn>::type* = nullptr>
  void initImplVirtDispatch(const std::vector<ParamFuncsStructure>& _paramFuncsStructure)
  {
    initImplCRTP(_paramFuncsStructure);
  }

private:
  template <bool FuncDyn = IsFuncDyn, typename std::enable_if<!FuncDyn>::type* = nullptr>
  void initImplVirtDispatch(const std::vector<ParamFuncsStructure>& _paramFuncsStructure)
  {
    if (_paramFuncsStructure.size() != TFuncSize)
    {
      throw std::runtime_error("Error in ParamFuncs::init: number of functions in init structure does not match "
                               "(static) number of param funcs");
    }
    std::array<ParamFuncsStructure, TFuncSize> pfsStatic;
    for (size_t i = 0; i < pfsStatic.size(); ++i)
    {
      pfsStatic[i] = _paramFuncsStructure[i];
    }
    initImplCRTP(pfsStatic);
  }

private:
  void initImplVirt(const std::vector<ParamFuncsStructure>& _paramFuncsStructure) override final
  {
    initImplVirtDispatch(_paramFuncsStructure);
  }

private:
  std::size_t funcsSizeImplVirt() const override final
  {
    return funcsSizeImplCRTP();
  }

private:
  std::size_t funcsArcSizeImplVirt() const override final
  {
    return funcsArcSizeImplCRTP();
  }

private:
  std::size_t funcsArcSizeImplVirt(const std::size_t& _i) const override final
  {
    return funcsArcSizeImplCRTP(_i);
  }

private:
  std::size_t funcCtrlPtSizeImplVirt(const std::size_t& _i) const override final
  {
    return funcCtrlPtSizeImplCRTP(_i);
  }

private:
  TNumType& funcsArcBeginImplVirt() override final
  {
    return funcsArcBeginImplCRTP();
  }

private:
  const TNumType& funcsArcBeginImplVirt() const override final
  {
    return funcsArcBeginImplCRTP();
  }

private:
  TNumType& funcsArcEndImplVirt() override final
  {
    return funcsArcEndImplCRTP();
  }

private:
  const TNumType& funcsArcEndImplVirt() const override final
  {
    return funcsArcEndImplCRTP();
  }

private:
  const TNumType& funcsArcEvalImplVirt() const override final
  {
    return funcsArcEvalImplCRTP();
  }

private:
  TNumType& funcsArcImplVirt(const std::size_t& _i, const std::size_t& _j) override final
  {
    return funcsArcImplCRTP(_i, _j);
  }

private:
  const TNumType& funcsArcImplVirt(const std::size_t& _i, const std::size_t& _j) const override final
  {
    return funcsArcImplCRTP(_i, _j);
  }

private:
  FuncCtrlPtType& ctrlPtImplVirt(const std::size_t& _funcIdx, const std::size_t& _funcCtrlPtIdx) override final
  {
    return ctrlPtImplCRTP(_funcIdx, _funcCtrlPtIdx);
  }

private:
  const FuncCtrlPtType& ctrlPtImplVirt(const std::size_t& _funcIdx,
                                       const std::size_t& _funcCtrlPtIdx) const override final
  {
    return ctrlPtImplCRTP(_funcIdx, _funcCtrlPtIdx);
  }

private:
  TNumType& ctrlPtValImplVirt(const std::size_t& _funcIdx, const std::size_t& _funcCtrlPtIdx,
                              const CtrlPtDim& _ctrlPtDim) override final
  {
    return ctrlPtValImplCRTP(_funcIdx, _funcCtrlPtIdx, _ctrlPtDim);
  }

private:
  const TNumType& ctrlPtValImplVirt(const std::size_t& _funcIdx, const std::size_t& _funcCtrlPtIdx,
                                    const CtrlPtDim& _ctrlPtDim) const override final
  {
    return ctrlPtValImplCRTP(_funcIdx, _funcCtrlPtIdx, _ctrlPtDim);
  }

private:
  void shiftStartCtrlPtImplVirt(const TNumType& _dt) override final
  {
    shiftStartCtrlPtImplCRTP(_dt);
  }

private:
  template <bool FuncDyn = (IsFuncDyn), bool ArcDyn = IsArcDyn,
            typename std::enable_if<(FuncDyn) && (ArcDyn)>::type* = nullptr>
  void initBase(const std::vector<ParamFuncsStructure>& _paramFuncsStructure)
  {
    this->paramFuncsStructure_ = _paramFuncsStructure;
    const size_t funcsSize = _paramFuncsStructure.size();
    if (funcsSize < 1)
    {
      throw std::runtime_error("Error in ParamFuncs::checkParamFuncsStructure: initialization with 0 number of "
                               "functions!");
    }
    this->funcCtrlPt_.resize(funcsSize);
    for (auto& funcCtrlPtrI : this->funcCtrlPt_)
    {
      funcCtrlPtrI.clear();
    }
    this->func2Arc_.resize(funcsSize);
    this->funcEvalReq_.resize(funcsSize);
    this->funcCtrlPtArc_.clear();
    std::vector<size_t> funcSameArcCtrlPtSize;
    for (size_t i = 0; i < funcsSize; ++i)
    {
      const auto& paramFuncsStructureI = _paramFuncsStructure[i];
      const size_t& funcCtrlPtsSize = paramFuncsStructureI.ctrlPtsSize;
      if (funcCtrlPtsSize < 2)
      {
        throw std::runtime_error("Error in ParamFuncs::checkParamFuncsStructure: function has less than 2 control "
                                 "points!");
      }
      auto& func2ArcI = this->func2Arc_[i];
      func2ArcI = paramFuncsStructureI.ctrlPtsArcRefIdx;
      if (func2ArcI >= this->funcCtrlPtArc_.size())
      {
        if (func2ArcI == this->funcCtrlPtArc_.size())
        {
          this->funcCtrlPtArc_.emplace_back(std::vector<TNumType>(funcCtrlPtsSize - 2, 0));
          funcSameArcCtrlPtSize.emplace_back(funcCtrlPtsSize);
        }
        else
        {
          throw std::runtime_error("Error in ParamFuncs::init: a ctrlPtsArcRefIdx is not consistent (new Idx not unit "
                                   "incremental)");
        }
      }
      if (funcCtrlPtsSize != funcSameArcCtrlPtSize[func2ArcI])
      {
        throw "Error in ParamFuncs::init: inconsistent number of control points for functions with same arc "
              "parametrization reference";
      }
      auto& funcCtrlPtI = this->funcCtrlPt_[i];
      funcCtrlPtI.reserve(funcCtrlPtsSize);
      funcCtrlPtI.emplace_back(FuncCtrlPtType(0, funcsArcBegin_));
      for (size_t j = 1; j < funcCtrlPtsSize - 1; ++j)
      {
        funcCtrlPtI.emplace_back(FuncCtrlPtType(0, this->funcCtrlPtArc_[func2ArcI][j - 1]));
      }
      funcCtrlPtI.emplace_back(FuncCtrlPtType(0, funcsArcEnd_));

      this->funcEvalReq_[i] = paramFuncsStructureI.evalReq;
    }
  }

private:
  template <bool FuncDyn = (IsFuncDyn), bool ArcDyn = IsArcDyn,
            typename std::enable_if<(!FuncDyn) && (ArcDyn)>::type* = nullptr>
  void initBase(const std::array<ParamFuncsStructure, TFuncSize>& _paramFuncsStructure)
  {
    this->paramFuncsStructure_ = _paramFuncsStructure;
    for (auto& funcCtrlPtrI : this->funcCtrlPt_)
    {
      funcCtrlPtrI.clear();
    }
    this->funcCtrlPtArc_.clear();
    std::vector<size_t> funcSameArcCtrlPtSize;
    for (size_t i = 0; i < (size_t)TFuncSize; ++i)
    {
      const auto& paramFuncsStructureI = _paramFuncsStructure[i];
      const size_t& funcCtrlPtsSize = paramFuncsStructureI.ctrlPtsSize;
      if (funcCtrlPtsSize < 2)
      {
        throw std::runtime_error("Error in ParamFuncs::checkParamFuncsStructure: function has less than 2 control "
                                 "points!");
      }
      auto& func2ArcI = this->func2Arc_[i];
      func2ArcI = paramFuncsStructureI.ctrlPtsArcRefIdx;
      if (func2ArcI >= this->funcCtrlPtArc_.size())
      {
        if (func2ArcI == this->funcCtrlPtArc_.size())
        {
          this->funcCtrlPtArc_.emplace_back(std::vector<TNumType>(funcCtrlPtsSize - 2, 0));
          funcSameArcCtrlPtSize.emplace_back(funcCtrlPtsSize);
        }
        else
        {
          throw std::runtime_error("Error in ParamFuncs::init: a ctrlPtsArcRefIdx is not consistent (new Idx not unit "
                                   "incremental)");
        }
      }
      if (funcCtrlPtsSize != funcSameArcCtrlPtSize[func2ArcI])
      {
        throw "Error in ParamFuncs::init: inconsistent number of control points for functions with same arc "
              "parametrization reference";
      }
      auto& funcCtrlPtI = this->funcCtrlPt_[i];
      funcCtrlPtI.reserve(funcCtrlPtsSize);
      funcCtrlPtI.emplace_back(FuncCtrlPtType(0, funcsArcBegin_));
      for (size_t j = 1; j < funcCtrlPtsSize - 1; ++j)
      {
        funcCtrlPtI.emplace_back(FuncCtrlPtType(0, this->funcCtrlPtArc_[func2ArcI][j - 1]));
      }
      funcCtrlPtI.emplace_back(FuncCtrlPtType(0, funcsArcEnd_));

      this->funcEvalReq_[i] = paramFuncsStructureI.evalReq;
    }
  }

private:
  template <bool FuncDyn = (IsFuncDyn), bool ArcDyn = IsArcDyn,
            typename std::enable_if<(FuncDyn) && (!ArcDyn)>::type* = nullptr>
  void initBase(const std::vector<ParamFuncsStructure>& _paramFuncsStructure)
  {
    this->paramFuncsStructure_ = _paramFuncsStructure;
    const size_t funcsSize = _paramFuncsStructure.size();
    if (funcsSize < 1)
    {
      throw std::runtime_error("Error in ParamFuncs::checkParamFuncsStructure: initialization with 0 number of "
                               "functions!");
    }
    this->funcCtrlPt_.resize(funcsSize);
    for (auto& funcCtrlPtrI : this->funcCtrlPt_)
    {
      funcCtrlPtrI.clear();
    }
    this->func2Arc_.resize(funcsSize);
    this->funcEvalReq_.resize(funcsSize);
    std::array<size_t, TFuncSize> funcSameArcCtrlPtSize;
    std::vector<bool> initFuncCtrlPtArc(this->funcCtrlPtArc_.size(), false);
    for (size_t i = 0; i < funcsSize; ++i)
    {
      const auto& paramFuncsStructureI = _paramFuncsStructure[i];
      const size_t& funcCtrlPtsSize = paramFuncsStructureI.ctrlPtsSize;
      if (funcCtrlPtsSize < 2)
      {
        throw std::runtime_error("Error in ParamFuncs::checkParamFuncsStructure: function has less than 2 control "
                                 "points!");
      }
      auto& func2ArcI = this->func2Arc_[i];
      func2ArcI = paramFuncsStructureI.ctrlPtsArcRefIdx;
      if (func2ArcI < this->funcCtrlPtArc_.size())
      {
        if (initFuncCtrlPtArc[func2ArcI] == false)
        {
          this->funcCtrlPtArc_[func2ArcI] = std::vector<TNumType>(funcCtrlPtsSize - 2, 0);
          initFuncCtrlPtArc[func2ArcI] = true;
        }
        funcSameArcCtrlPtSize[func2ArcI] = funcCtrlPtsSize;
      }
      else
      {
        throw std::runtime_error("Error in ParamFuncs::init: a ctrlPtsArcRefIdx is not consistent (>= than the static "
                                 "arc lattice size)");
      }
      if (funcCtrlPtsSize != funcSameArcCtrlPtSize[func2ArcI])
      {
        throw "Error in ParamFuncs::init: inconsistent number of control points for functions with same arc "
              "parametrization reference";
      }
      auto& funcCtrlPtI = this->funcCtrlPt_[i];
      funcCtrlPtI.reserve(funcCtrlPtsSize);
      funcCtrlPtI.emplace_back(FuncCtrlPtType(0, funcsArcBegin_));
      for (size_t j = 1; j < funcCtrlPtsSize - 1; ++j)
      {
        funcCtrlPtI.emplace_back(FuncCtrlPtType(0, this->funcCtrlPtArc_[func2ArcI][j - 1]));
      }
      funcCtrlPtI.emplace_back(FuncCtrlPtType(0, funcsArcEnd_));

      this->funcEvalReq_[i] = paramFuncsStructureI.evalReq;
    }
  }

private:
  template <bool FuncDyn = (IsFuncDyn), bool ArcDyn = IsArcDyn,
            typename std::enable_if<(!FuncDyn) && (!ArcDyn)>::type* = nullptr>
  void initBase(const std::array<ParamFuncsStructure, TFuncSize>& _paramFuncsStructure)
  {
    this->paramFuncsStructure_ = _paramFuncsStructure;
    for (auto& funcCtrlPtrI : this->funcCtrlPt_)
    {
      funcCtrlPtrI.clear();
    }
    std::array<size_t, TFuncSize> funcSameArcCtrlPtSize;
    std::vector<bool> initFuncCtrlPtArc(this->funcCtrlPtArc_.size(), false);
    for (size_t i = 0; i < (size_t)TFuncSize; ++i)
    {
      const auto& paramFuncsStructureI = _paramFuncsStructure[i];
      const size_t& funcCtrlPtsSize = paramFuncsStructureI.ctrlPtsSize;
      if (funcCtrlPtsSize < 2)
      {
        throw std::runtime_error("Error in ParamFuncs::checkParamFuncsStructure: function has less than 2 control "
                                 "points!");
      }
      auto& func2ArcI = this->func2Arc_[i];
      func2ArcI = paramFuncsStructureI.ctrlPtsArcRefIdx;
      if (func2ArcI < this->funcCtrlPtArc_.size())
      {
        if (initFuncCtrlPtArc[func2ArcI] == false)
        {
          this->funcCtrlPtArc_[func2ArcI] = std::vector<TNumType>(funcCtrlPtsSize - 2, 0);
          initFuncCtrlPtArc[func2ArcI] = true;
        }
        funcSameArcCtrlPtSize[func2ArcI] = funcCtrlPtsSize;
      }
      else
      {
        throw std::runtime_error("Error in ParamFuncs::init: a ctrlPtsArcRefIdx is not consistent (>= than the static "
                                 "arc lattice size)");
      }
      if (funcCtrlPtsSize != funcSameArcCtrlPtSize[func2ArcI])
      {
        throw std::runtime_error("Error in ParamFuncs::init: inconsistent number of control points for functions with "
                                 "same arc parametrization reference");
      }
      auto& funcCtrlPtI = this->funcCtrlPt_[i];
      funcCtrlPtI.reserve(funcCtrlPtsSize);
      funcCtrlPtI.emplace_back(FuncCtrlPtType(0, funcsArcBegin_));
      for (size_t j = 1; j < funcCtrlPtsSize - 1; ++j)
      {
        funcCtrlPtI.emplace_back(FuncCtrlPtType(0, this->funcCtrlPtArc_[func2ArcI][j - 1]));
      }
      funcCtrlPtI.emplace_back(FuncCtrlPtType(0, funcsArcEnd_));

      this->funcEvalReq_[i] = paramFuncsStructureI.evalReq;
    }
  }

private:
  template <typename TParamFucsStructVecArr>
  void initImplCRTP(const TParamFucsStructVecArr& _paramFuncsStructure)
  {
    initBase(_paramFuncsStructure);
    initImpl();
  }

private:
  std::size_t funcsSizeImplCRTP() const
  {
    return this->funcCtrlPt_.size();
  }

private:
  std::size_t funcsArcSizeImplCRTP() const
  {
    return this->funcCtrlPtArc_.size();
  }

private:
  std::size_t funcsArcSizeImplCRTP(const std::size_t& _i) const
  {
    return this->funcCtrlPtArc_[_i].size() + 2;
  }

private:
  std::size_t funcCtrlPtSizeImplCRTP(const std::size_t& _i) const
  {
    return this->funcCtrlPt_[_i].size();
  }

private:
  TNumType& funcsArcBeginImplCRTP()
  {
    return funcsArcBegin_;
  }

private:
  const TNumType& funcsArcBeginImplCRTP() const
  {
    return funcsArcBegin_;
  }

private:
  TNumType& funcsArcEndImplCRTP()
  {
    return funcsArcEnd_;
  }

private:
  const TNumType& funcsArcEndImplCRTP() const
  {
    return funcsArcEnd_;
  }

private:
  const TNumType& funcsArcEvalImplCRTP() const
  {
    return funcsArcEval_;
  }

private:
  TNumType& funcsArcImplCRTP(const std::size_t& _i, const std::size_t& _j)
  {
    if (_j == 0)
    {
      return funcsArcBegin_;
    }
    if (_j > this->funcCtrlPtArc_[_i].size())
    {
      return funcsArcEnd_;
    }
    return this->funcCtrlPtArc_[_i][_j - 1];
  }

private:
  const TNumType& funcsArcImplCRTP(const std::size_t& _i, const std::size_t& _j) const
  {
    if (_j == 0)
    {
      return funcsArcBegin_;
    }
    if (_j > this->funcCtrlPtArc_[_i].size())
    {
      return funcsArcEnd_;
    }
    return this->funcCtrlPtArc_[_i][_j - 1];
  }

private:
  FuncCtrlPtType& ctrlPtImplCRTP(const std::size_t& _funcIdx, const std::size_t& _funcCtrlPtIdx)
  {
    return this->funcCtrlPt_[_funcIdx][_funcCtrlPtIdx];
  }

private:
  const FuncCtrlPtType& ctrlPtImplCRTP(const std::size_t& _funcIdx, const std::size_t& _funcCtrlPtIdx) const
  {
    return this->funcCtrlPt_[_funcIdx][_funcCtrlPtIdx];
  }

private:
  TNumType& ctrlPtValImplCRTP(const std::size_t& _funcIdx, const std::size_t& _funcCtrlPtIdx,
                              const CtrlPtDim& _ctrlPtDim)
  {
    switch (_ctrlPtDim)
    {
      case CtrlPtDim::VAL:
        return this->funcCtrlPt_[_funcIdx][_funcCtrlPtIdx].val;
        break;
      case CtrlPtDim::ARC:
        return this->funcCtrlPt_[_funcIdx][_funcCtrlPtIdx].arc;
        break;
      default:
        throw "CtrlPtDim unrecognised in function ParamFuncs::ctrlPtVal !";
        break;
    }
  }

private:
  const TNumType& ctrlPtValImplCRTP(const std::size_t& _funcIdx, const std::size_t& _funcCtrlPtIdx,
                                    const CtrlPtDim& _ctrlPtDim) const
  {
    switch (_ctrlPtDim)
    {
      case CtrlPtDim::VAL:
        return this->funcCtrlPt_[_funcIdx][_funcCtrlPtIdx].val;
        break;
      case CtrlPtDim::ARC:
        return this->funcCtrlPt_[_funcIdx][_funcCtrlPtIdx].arc;
        break;
      default:
        throw "CtrlPtDim unrecognised in function ParamFuncs::ctrlPtVal !";
        break;
    }
  }

private:
  void shiftStartCtrlPtImplCRTP(const TNumType& _dt)
  {
    std::vector<TNumType> ctrlPtValPref(funcsSize(), 0);
    const TNumType dtBound = fmin(fmax(funcsArcBegin_, _dt), funcsArcEnd_ - funcsArcBegin_);
    const TNumType evalArc = funcsArcBegin_ + dtBound;
    setEvalArc(evalArc);
    for (size_t i = 0; i < funcsSize(); ++i)
    {
      ctrlPtValPref[i] = computeFuncVal(i);
    }
    for (size_t i = 0; i < funcsSize(); ++i)
    {
      for (size_t j = 0; j < funcCtrlPtSize(i); ++j)
      {
        if (ctrlPtVal(i, j, CtrlPtDim::ARC) < evalArc)
        {
          ctrlPtVal(i, j, CtrlPtDim::VAL) = ctrlPtValPref[i];
        }
        else
        {
          break;
        }
      }
    }
    for (size_t k = 0; k < funcsArcSize(); ++k)
    {
      for (size_t j = 0; j < this->funcCtrlPtArc_[k].size(); ++j)
      {
        this->funcCtrlPtArc_[k][j] = fmax(funcsArcBegin_, this->funcCtrlPtArc_[k][j] - dtBound);
      }
    }
    funcsArcEnd_ -= dtBound;
    precompute();
    setEvalArc(funcsArcBegin_);
  }

private:
  TDerived& thisDerived()
  {
    return static_cast<TDerived&>(*this);
  }

private:
  const TDerived& thisDerived() const
  {
    return static_cast<const TDerived&>(*this);
  }

protected:
  TNumType funcsArcBegin_;
protected:
  TNumType funcsArcEnd_;
protected:
  TNumType funcsArcEval_;

  template <typename TDerived2>
  friend class ParamFuncsBaseCRTP;
  template <typename TNum2>
  friend class ParamFuncsBaseVirt;
};
template <typename TDerived, typename TNumType, int TFuncSize, int TArcLatticeSize>
constexpr const int ParamFuncsBase<TDerived, TNumType, TFuncSize, TArcLatticeSize>::FuncSize;

namespace
{
template <typename TDerived, typename TNumType, int TFuncSize, int TArcLatticeSize>
struct ParamFuncsBaseCRTPTraits<ParamFuncsBase<TDerived, TNumType, TFuncSize, TArcLatticeSize>>
{
  using NumType = TNumType;
};

}  // namespace <anonymous>
}

#endif  // PARAM_FUNC_HPP