monomials_tp.hpp

Go to the documentation of this file.

// --------------------------------------------------------------------------
//
// Copyright (C) 2025-present by Pablo Antolin
//
// This file is part of the QUGaR library.
//
// SPDX-License-Identifier:    MIT
//
// --------------------------------------------------------------------------
 
#ifndef QUGAR_IMPL_MONOMIALS_TP_HPP
#define QUGAR_IMPL_MONOMIALS_TP_HPP
 
 
#include <qugar/bbox.hpp>
#include <qugar/domain_function.hpp>
#include <qugar/polynomial_tp.hpp>
#include <qugar/tensor_index_tp.hpp>
#include <qugar/types.hpp>
 
#include <algoim/xarray.hpp>
 
#include <memory>
#include <vector>
 
namespace qugar::impl {
 
template<int dim, int range> class BezierTP;
 
template<int dim, int range = 1> class MonomialsTP : public PolynomialTP<dim, range>
{
public:
  using Parent = PolynomialTP<dim, range>;
 
  using CoefsType = typename Parent::CoefsType;
 
  template<typename T> using Value = typename Parent::template Value<T>;
 
  template<typename T> using Gradient = typename Parent::template Gradient<T>;
 
  template<typename T> using Hessian = typename Parent::template Hessian<T>;
 
  template<int N> using Interval = ::algoim::Interval<N>;
 
  explicit MonomialsTP(const TensorSizeTP<dim> &order);
 
  MonomialsTP(const TensorSizeTP<dim> &order, const std::vector<CoefsType> &coefs);
 
  MonomialsTP(const MonomialsTP<dim, range> &monomials);
 
  [[nodiscard]] std::shared_ptr<MonomialsTP<dim, range>> create_derivative(const int dir) const;
 
  using DomainFunc<dim, range>::operator();
 
  using DomainFunc<dim, range>::grad;
 
  [[nodiscard]] virtual Value<real> operator()(const Point<dim> &point) const final;
 
  [[nodiscard]] virtual Value<Interval<dim>> operator()(const Point<dim, Interval<dim>> &point) const final;
 
  [[nodiscard]] virtual Gradient<real> grad(const Point<dim> &point) const final;
 
  [[nodiscard]] virtual Gradient<Interval<dim>> grad(const Point<dim, Interval<dim>> &point) const final;
 
  [[nodiscard]] Hessian<real> virtual hessian(const Point<dim> &point) const final;
 
private:
  template<typename T> [[nodiscard]] Value<T> eval_(const Point<dim, T> &point) const;
 
  template<typename T> [[nodiscard]] Gradient<T> grad_(const Point<dim, T> &point) const;
 
  template<typename T> [[nodiscard]] Hessian<T> hessian_(const Point<dim, T> &point) const;
 
public:
  template<int dim_aux = dim>
    requires(dim == dim_aux && dim > 1)
  [[nodiscard]] std::shared_ptr<MonomialsTP<dim - 1, range>> extract_facet(const int local_facet_id) const;
 
  template<typename T>
  static Value<T> horner(const Point<dim, T> &point,
    typename std::vector<CoefsType>::const_iterator &coefs,
    const Vector<int, dim> &order);
 
  template<typename T>
  static Vector<Value<T>, dim + 1> horner_der(const Point<dim, T> &point,
    typename std::vector<CoefsType>::const_iterator &coefs,
    const Vector<int, dim> &order);
 
  static void transform_coefs_to_Bezier(const MonomialsTP<dim, range> &monomials, std::vector<CoefsType> &bzr_coefs);
};
 
 
}// namespace qugar::impl
 
#endif// QUGAR_IMPL_MONOMIALS_TP_HPP