fpPeriodicCurve.hpp

Go to the documentation of this file.

/***************************************************************************************************
!                                ____________________  ___   ________ __
!                               / ____/  _/_  __/ __ \/   | / ____/ //_/
!                              / /_   / /  / / / /_/ / /| |/ /   / ,<
!                             / __/ _/ /  / / / ____/ ___ / /___/ /| |
!                            /_/   /___/ /_/ /_/   /_/  |_\____/_/ |_|
!
!                                     A Curve Fitting Package
!
!   fpPeriodicCurve.hpp (class fpPeriodicCurve)
!> @brief Standalone C++ wrapper for fitpack_periodic_curve (no fortran-arrays dependency)
!
!   @author Federico Perini
!   @date   2026-08-27
!
!   References :
!     - C. De Boor, "On calculating with b-splines", J Approx Theory 6 (1972) 50-62
!     - M. G. Cox, "The numerical evaluation of b-splines", J Inst Maths Applics 10 (1972) 134-149
!     - P. Dierckx, "Curve and surface fitting with splines", Monographs on numerical analysis,
!                    Oxford university press, 1993.
!
! **************************************************************************************************/
 
#ifndef FPPERIODICCURVE_HPP_INCLUDED
#define FPPERIODICCURVE_HPP_INCLUDED
 
#include "fitpack_config.h"
 
#if HAVE_FXARRAY
#include "fxArrays.hpp"
#endif
 
#include "fitpack_periodic_curve_c.h"
#include "fpCurve.hpp"
#include <string>
#include <vector>
#include <cstdint>
#include <memory>
#include <stdexcept>
#include <variant>
#include <optional>
 
static_assert(sizeof(fitpack_periodic_curve_c) == sizeof(fitpack_curve_c),
    "C descriptor layout mismatch: fitpack_periodic_curve_c vs fitpack_curve_c");

class fpPeriodicCurve : public fpCurve {
public:
    // ===========================================================================================
    // Constructors and Destructor
    // ===========================================================================================

    fpPeriodicCurve() : fpCurve(NoAlloc{}) {
        fitpack_periodic_curve_c_allocate(as<fitpack_periodic_curve_c>(), nullptr);
    }

    ~fpPeriodicCurve() override {
        fitpack_periodic_curve_c_destroy(as<fitpack_periodic_curve_c>(), nullptr);
    }

    fpPeriodicCurve(const fpPeriodicCurve& other) : fpCurve(NoAlloc{}) {
        *as<fitpack_periodic_curve_c>() = fitpack_periodic_curve_c_null;
        fitpack_periodic_curve_c_copy(as<fitpack_periodic_curve_c>(), other.as<fitpack_periodic_curve_c>(), false, nullptr);
    }

    fpPeriodicCurve& operator=(const fpPeriodicCurve& other) {
        if (this != &other) {
            fitpack_periodic_curve_c_destroy(as<fitpack_periodic_curve_c>(), nullptr);
            fitpack_periodic_curve_c_copy(as<fitpack_periodic_curve_c>(), other.as<fitpack_periodic_curve_c>(), false, nullptr);
        }
        return *this;
    }

    fpPeriodicCurve(fpPeriodicCurve&& other) noexcept : fpCurve(NoAlloc{}) {
        *as<fitpack_periodic_curve_c>() = fitpack_periodic_curve_c_null;
        fitpack_periodic_curve_c_move_alloc(as<fitpack_periodic_curve_c>(), other.as<fitpack_periodic_curve_c>(), nullptr);
    }

    fpPeriodicCurve& operator=(fpPeriodicCurve&& other) noexcept {
        if (this != &other) {
            fitpack_periodic_curve_c_destroy(as<fitpack_periodic_curve_c>(), nullptr);
            fitpack_periodic_curve_c_move_alloc(as<fitpack_periodic_curve_c>(), other.as<fitpack_periodic_curve_c>(), nullptr);
        }
        return *this;
    }

    explicit fpPeriodicCurve(fitpack_periodic_curve_c& c_wrapper, bool move = false) : fpCurve(NoAlloc{}) {
        if (move) {
            fitpack_periodic_curve_c_move_alloc(as<fitpack_periodic_curve_c>(), &c_wrapper, nullptr);
        } else {
            *as<fitpack_periodic_curve_c>() = fitpack_periodic_curve_c_null;
            fitpack_periodic_curve_c_copy(as<fitpack_periodic_curve_c>(), &c_wrapper, false, nullptr);
        }
    }

    explicit fpPeriodicCurve(fitpack_periodic_curve_c& c_wrapper, ViewTag) : fpCurve(NoAlloc{}) {
        *as<fitpack_periodic_curve_c>() = c_wrapper;
        as<fitpack_periodic_curve_c>()->is_pointer = true;
    }
 
    // ===========================================================================================
    // Utility Methods
    // ===========================================================================================

    bool is_allocated() const override {
        return as<fitpack_periodic_curve_c>()->cptr != nullptr;
    }

    bool is_pointer() const override {
        return as<fitpack_periodic_curve_c>()->is_pointer;
    }

    const char* c_type_name() const override {
        return fitpack_periodic_curve_c_c_type_name(*as<fitpack_periodic_curve_c>());
    }

    const char* cpp_type_name() const override {
        return "fpPeriodicCurve";
    }

    fitpack_periodic_curve_c& c_handle() {
        return *as<fitpack_periodic_curve_c>();
    }

    const fitpack_periodic_curve_c& c_handle() const {
        return *as<fitpack_periodic_curve_c>();
    }

    static fpPeriodicCurve make_view() {
        return fpPeriodicCurve(NoAlloc{});
    }

    fpCurve& as_parent() {
        return static_cast<fpCurve&>(*this);
    }
    const fpCurve& as_parent() const {
        return static_cast<const fpCurve&>(*this);
    }
 
    // ===========================================================================================
    // Method Wrappers (standalone — no fxArray dependency)
    // ===========================================================================================

    void new_points(std::vector<double>& x, std::vector<double>& y, double* w = nullptr) override {
        int32_t n = static_cast<int32_t>(x.size());
        fitpack_periodic_curve_c_new_points(as<fitpack_periodic_curve_c>(), n, x.data(), y.data(), w);
    }
 

    int32_t new_fit(std::vector<double>& x, std::vector<double>& y, double* w = nullptr, double* smoothing = nullptr, int32_t* order = nullptr) override {
        int32_t n = static_cast<int32_t>(x.size());
        return fitpack_periodic_curve_c_new_fit(as<fitpack_periodic_curve_c>(), n, x.data(), y.data(), w, smoothing, order);
    }
 
 
    int32_t fit(double* smoothing = nullptr, int32_t* order = nullptr, bool* keep_knots = nullptr) override {
        return fitpack_periodic_curve_c_fit(as<fitpack_periodic_curve_c>(), smoothing, order, keep_knots);
    }
 
    int32_t interpolate(int32_t* order = nullptr, bool* reset_knots = nullptr) override {
        return fitpack_periodic_curve_c_interpolate(as<fitpack_periodic_curve_c>(), order, reset_knots);
    }
 
    int32_t least_squares(double* smoothing = nullptr, bool* reset_knots = nullptr) override {
        return fitpack_periodic_curve_c_least_squares(as<fitpack_periodic_curve_c>(), smoothing, reset_knots);
    }
 
    double eval(double x, int32_t& ierr) override {
        return fitpack_periodic_curve_c_curve_eval_one(as<fitpack_periodic_curve_c>(), x, &ierr);
    }
 
    double eval(double x) const override {
        return fitpack_periodic_curve_c_curve_eval_one_noerr(as<fitpack_periodic_curve_c>(), x);
    }

    std::vector<double> eval(std::vector<double>& x, int32_t& ierr) override {
        int32_t n = static_cast<int32_t>(x.size());
        std::vector<double> result(n);
        int32_t n_result = 0;
        fitpack_periodic_curve_c_curve_eval_many(as<fitpack_periodic_curve_c>(), n, x.data(), &ierr, result.data(), &n_result, n);
        result.resize(n_result);
        return result;
    }
 

    std::vector<double> eval(std::vector<double>& x) override {
        int32_t n = static_cast<int32_t>(x.size());
        std::vector<double> result(n);
        int32_t n_result = 0;
        fitpack_periodic_curve_c_curve_eval_many_pure(as<fitpack_periodic_curve_c>(), n, x.data(), result.data(), &n_result, n);
        result.resize(n_result);
        return result;
    }
 
 
    double integral(double from, double to) override {
        return fitpack_periodic_curve_c_integral(as<fitpack_periodic_curve_c>(), from, to);
    }

    void fourier_coefficients(std::vector<double>& alpha, std::vector<double>& a, std::vector<double>& b, int32_t* ierr = nullptr) override {
        int32_t n = static_cast<int32_t>(alpha.size());
        fitpack_periodic_curve_c_fourier_coefficients(as<fitpack_periodic_curve_c>(), n, alpha.data(), a.data(), b.data(), ierr);
    }
 

    std::vector<double> zeros(int32_t max_size, int32_t* ierr = nullptr) override {
        std::vector<double> result(max_size);
        int32_t n_result = 0;
        fitpack_periodic_curve_c_zeros(as<fitpack_periodic_curve_c>(), ierr, result.data(), &n_result, max_size);
        result.resize(n_result);
        return result;
    }
 
 
    double dfdx(double x, int32_t order, int32_t* ierr = nullptr) override {
        return fitpack_periodic_curve_c_curve_derivative(as<fitpack_periodic_curve_c>(), x, order, ierr);
    }

    std::vector<double> dfdx(std::vector<double>& x, int32_t order, int32_t* ierr = nullptr) override {
        int32_t n = static_cast<int32_t>(x.size());
        std::vector<double> result(n);
        int32_t n_result = 0;
        fitpack_periodic_curve_c_curve_derivatives(as<fitpack_periodic_curve_c>(), n, x.data(), order, ierr, result.data(), &n_result, n);
        result.resize(n_result);
        return result;
    }
 

    std::vector<double> dfdx_all(double x, int32_t& ierr, int32_t n_result) override {
        std::vector<double> result(n_result);
        fitpack_periodic_curve_c_curve_all_derivatives(as<fitpack_periodic_curve_c>(), x, &ierr, result.data(), n_result);
        return result;
    }
 

    std::vector<double> dfdx_all(double x, int32_t n_result) override {
        std::vector<double> result(n_result);
        fitpack_periodic_curve_c_curve_all_derivatives_pure(as<fitpack_periodic_curve_c>(), x, result.data(), n_result);
        return result;
    }
 
 
    void insert_knot(double x, int32_t* ierr = nullptr) override {
        fitpack_periodic_curve_c_curve_insert_knot_one(as<fitpack_periodic_curve_c>(), x, ierr);
    }

    void insert_knot(std::vector<double>& x, int32_t* ierr = nullptr) override {
        int32_t n = static_cast<int32_t>(x.size());
        fitpack_periodic_curve_c_curve_insert_knot_many(as<fitpack_periodic_curve_c>(), n, x.data(), ierr);
    }
 
 
    int32_t comm_size() const override {
        return fitpack_periodic_curve_c_comm_size(as<fitpack_periodic_curve_c>());
    }

    void comm_pack(std::vector<double>& buffer) const override {
        int32_t n = static_cast<int32_t>(buffer.size());
        fitpack_periodic_curve_c_comm_pack(as<fitpack_periodic_curve_c>(), n, buffer.data());
    }
 

    void comm_expand(std::vector<double>& buffer) override {
        int32_t n = static_cast<int32_t>(buffer.size());
        fitpack_periodic_curve_c_comm_expand(as<fitpack_periodic_curve_c>(), n, buffer.data());
    }
 
 
    double mse() const override {
        return fitpack_periodic_curve_c_mse(as<fitpack_periodic_curve_c>());
    }
 
    int32_t core_comm_size() const override {
        return fitpack_periodic_curve_c_core_comm_size(as<fitpack_periodic_curve_c>());
    }

    void core_comm_pack(std::vector<double>& buffer) const override {
        int32_t n = static_cast<int32_t>(buffer.size());
        fitpack_periodic_curve_c_core_comm_pack(as<fitpack_periodic_curve_c>(), n, buffer.data());
    }
 

    void core_comm_expand(std::vector<double>& buffer) override {
        int32_t n = static_cast<int32_t>(buffer.size());
        fitpack_periodic_curve_c_core_comm_expand(as<fitpack_periodic_curve_c>(), n, buffer.data());
    }
 
 
    void destroy_base() override {
        fitpack_periodic_curve_c_destroy_base(as<fitpack_periodic_curve_c>());
    }
 
    // ===========================================================================================
    // extra_methods/fpCurveInherit.hpp (hand-maintained)
    //
    // This class overrides the raw new_fit / fit / interpolate / eval, which hides the
    // ergonomic overloads spliced into fpCurve. Re-expose them; the overrides above still win
    // for their own signatures, and every ergonomic overload dispatches back through them.
    // ===========================================================================================
 
    using fpCurve::new_fit;
    using fpCurve::fit;
    using fpCurve::interpolate;
    using fpCurve::eval;
 
protected:
    explicit fpPeriodicCurve(NoAlloc tag) : fpCurve(tag) {}
 
};
 
#endif /* FPPERIODICCURVE_HPP_INCLUDED */