Chebyshev.h

Go to the documentation of this file.

// $Id$
//==============================================================================
//==============================================================================
 
#ifndef _CHEBYSHEV_H
#define _CHEBYSHEV_H
 
#include "Function.h"
#include "TensorFunction.h"
 
#include <array>
#include <functional>
#include <memory>
 
 
namespace Chebyshev
{
  Real evalPol1(int polnum, Real xi);
  Real evalPol2(int polnum, Real xi);
 
  Real evalDer1(int polnum, Real xi);
  Real evalDer2(int polnum, Real xi);
 
  Real eval2Der1(int polnum, Real xi);
}
 
 
class ChebyshevFunc : public RealFunc
{
  std::vector<Real> coefs; 
  std::array<int,3> n;     
  std::array<std::array<double,2>,3> domain; 
 
public:
  ChebyshevFunc(const std::string& input, bool file);
 
  bool isZero() const override { return coefs.empty(); }
 
  const std::vector<Real>& getCoefs() const { return coefs; }
  const std::array<int,3>& getSize() const { return n; }
 
  Real deriv(const Vec3& X, int c) const override;
 
  Real dderiv(const Vec3& X, int c, int c2) const override;
 
protected:
  Real evaluate(const Vec3& X) const override;
 
private:
  struct Func
  {
    std::function<Real(int, Real)> f; 
    double w; 
  };
 
  Real evaluateTP (const Vec3& X, const std::array<Func,3>& funcs) const;
 
  void read(std::istream& in);
};
 
 
class ChebyshevVecFunc : public VecFunc
{
  std::array<std::unique_ptr<ChebyshevFunc>,3> f; 
 
public:
  ChebyshevVecFunc(const std::vector<std::string>& input, bool file);
 
  bool isZero() const override { return !f[0] || f[0]->isZero(); }
 
protected:
  Vec3 evaluate(const Vec3& X) const override;
  std::vector<Real> evalGradient(const Vec3&) const override;
  std::vector<Real> evalHessian(const Vec3& X) const override;
};
 
 
class ChebyshevTensorFunc : public TensorFunc
{
  std::vector<std::unique_ptr<ChebyshevFunc>> f; 
 
public:
  ChebyshevTensorFunc(const std::vector<std::string>& input, bool file);
 
  bool isZero() const override { return f.empty(); }
 
protected:
  Tensor evaluate(const Vec3& X) const override;
  std::vector<Real> evalGradient(const Vec3&) const override;
  std::vector<Real> evalHessian(const Vec3&) const override;
};
 
#endif