cheby 0.3.0

Unit-safe Chebyshev approximation and spectral numerics for Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

// SPDX-License-Identifier: AGPL-3.0-or-later
// Copyright (C) 2026 Vallés Puig, Ramon

#![forbid(unsafe_code)]
#![warn(missing_docs)]
#![cfg_attr(not(feature = "std"), no_std)]
#![doc = include_str!("../README.md")]

#[cfg(feature = "alloc")]
extern crate alloc;

pub mod core;

#[cfg(feature = "approx")]
pub mod approx;
#[cfg(feature = "calculus")]
pub mod calculus;
#[cfg(any(feature = "serde", feature = "binary"))]
pub mod io;
#[cfg(feature = "piecewise")]
pub mod piecewise;
#[cfg(feature = "quadrature")]
pub mod quadrature;
#[cfg(feature = "spectral")]
pub mod spectral;

pub use core::{
    basis, evaluate, evaluate_both, ChebyError, ChebyScalar, ChebySeries, ChebySeriesOn, ChebyTime,
    Domain, NodeKind,
};

#[cfg(feature = "alloc")]
pub use core::ChebySeriesDyn;

#[cfg(feature = "approx")]
pub use approx::fit::fit_coeffs;

#[cfg(feature = "piecewise")]
pub use piecewise::{ChebySegment, ChebySegmentTable};

/// Backward-compatible normalized derivative evaluation.
///
/// This returns `df/dtau`, where `tau` is the normalized coordinate in
/// `[-1, 1]`. Domain-aware derivatives with physical units are available on
/// [`ChebySeriesOn`] and [`piecewise::ChebySegment`].
#[inline]
pub fn evaluate_derivative<T: ChebyScalar>(coeffs: &[T], tau: f64) -> T {
    core::eval::evaluate_derivative(coeffs, tau)
}

/// Backward-compatible root helper for roots of `T_N` on `[-1, 1]`.
#[inline]
pub fn chebyshev_roots<const N: usize>() -> [f64; N] {
    core::nodes::nodes(NodeKind::Roots)
}

/// Backward-compatible root-node helper.
#[inline]
pub fn nodes<const N: usize>() -> [f64; N] {
    core::nodes::nodes(NodeKind::Roots)
}

/// Backward-compatible mapped root-node helper.
#[inline]
pub fn nodes_mapped<const N: usize>(start: f64, end: f64) -> [f64; N] {
    let domain = Domain::new(start, end);
    core::nodes::nodes_mapped(domain, NodeKind::Roots)
}

/// Backward-compatible mapped roots helper.
#[inline]
pub fn nodes_mapped_interval<const N: usize>(start: f64, end: f64) -> [f64; N] {
    let domain = Domain::new(start, end);
    core::nodes::nodes_mapped(domain, NodeKind::Roots)
}

/// Backward-compatible typed mapped roots helper.
#[inline]
pub fn nodes_mapped_t<Tt: ChebyTime, const N: usize>(start: Tt, end: Tt) -> [Tt; N] {
    let domain = Domain::new(start, end);
    core::nodes::nodes_mapped(domain, NodeKind::Roots)
}

/// Backward-compatible root-node name.
#[inline]
pub fn nodes_roots<const N: usize>() -> [f64; N] {
    core::nodes::nodes(NodeKind::Roots)
}

/// Backward-compatible fitting helper returning raw coefficients.
#[cfg(feature = "approx")]
#[inline]
pub fn fit_from_fn<T: ChebyScalar, const N: usize>(
    f: impl Fn(f64) -> T,
    start: f64,
    end: f64,
) -> [T; N] {
    approx::fit::fit_from_fn_on(Domain::new(start, end), f).into_coeffs()
}

/// Backward-compatible typed fitting helper returning raw coefficients.
#[cfg(feature = "approx")]
#[inline]
pub fn fit_from_fn_t<T: ChebyScalar, X: ChebyTime, const N: usize>(
    f: impl Fn(X) -> T,
    start: X,
    end: X,
) -> [T; N] {
    approx::fit::fit_from_fn_on(Domain::new(start, end), f).into_coeffs()
}