bezier_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_BEZIER_TP_HPP
#define QUGAR_IMPL_BEZIER_TP_HPP
 
 
#include <qugar/bbox.hpp>
#include <qugar/domain_function.hpp>
#include <qugar/monomials_tp.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 MonomialsTP;
 
template<int dim, int range = 1> class BezierTP : 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 BezierTP(const TensorSizeTP<dim> &order);
 
  BezierTP(const TensorSizeTP<dim> &order, const CoefsType &value);
 
  BezierTP(const TensorSizeTP<dim> &order, const std::vector<CoefsType> &coefs);
 
  BezierTP(const BezierTP<dim, range> &bezier);
 
  explicit BezierTP(const MonomialsTP<dim, range> &monomials);
 
  using DomainFunc<dim, range>::operator();
 
  using DomainFunc<dim, range>::grad;
 
 
private:
  ::algoim::xarray<CoefsType, dim> coefs_xarray_;
 
public:
  [[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<typename T>
  static Value<T> casteljau(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> casteljau_der(const Point<dim, T> &point,
    typename std::vector<CoefsType>::const_iterator &coefs,
    const Vector<int, dim> &order);
 
  [[nodiscard]] const ::algoim::xarray<CoefsType, dim> &get_xarray() const;
 
  template<int dim_aux = dim>
    requires(dim == dim_aux && dim > 1)
 
  [[nodiscard]] std::shared_ptr<BezierTP<dim - 1, range>> extract_facet(const int local_facet_id) const;
 
  [[nodiscard]] std::shared_ptr<BezierTP<dim, range>> raise_order(const TensorSizeTP<dim> &new_order) const;
 
  [[nodiscard]] std::shared_ptr<BezierTP<dim, range>> negate() const;
 
  template<int range_aux = range>
    requires(range_aux == range && range == 1)
  void rescale_domain(const BoundBox<dim> &new_domain);
 
  template<int range_aux = range>
    requires(range_aux == range && range == 1)
  [[nodiscard]] FuncSign sign() const;
 
  [[nodiscard]] std::shared_ptr<BezierTP<dim, range>> operator*(const BezierTP<dim, range> &rhs) const;
 
  [[nodiscard]] std::shared_ptr<BezierTP<dim, range>> operator+(const BezierTP<dim, range> &rhs) const;
 
  [[nodiscard]] std::shared_ptr<BezierTP<dim, range>> operator-(const BezierTP<dim, range> &rhs) const;
 
 
  template<int sub_dim>
  [[nodiscard]] std::shared_ptr<BezierTP<sub_dim, range>> compose(const BezierTP<sub_dim, dim> &rhs) const;
};
 
template<int dim, int range> static bool is_bezier(const DomainFunc<dim, range> &func)
{
  const auto *bzr = dynamic_cast<const BezierTP<dim, range> *>(&func);
  return bzr != nullptr;
}
 
}// namespace qugar::impl
 
#endif// QUGAR_IMPL_BEZIER_TP_HPP