Namespace cip

Classes

Type	Name
class	CubicCellND <typename T, N>
class	CubicCellND< T, 1 > <typename T>
class	CubicInterp <typename T, typename SlopePolicy, N, IM>
class	CubicInterpND <typename T, N, IM>
class	CubicInterpND< T, 1, IM > <typename T, IM>
class	Indexer <typename T, Method>
class	LinearCellND <typename T, N>
class	LinearCellND< T, 1 > <typename T>
class	LinearInterp <typename T, N, IM>
class	LinearInterpND <typename T, N, IM>
class	LinearInterpND< T, 1, IM > <typename T, IM>
struct	SlopePolicy <Method, BC>
class	VectorN <typename T, N>
struct	setNaturalSplineBoundaryCondition <BC, typename T, typename Tx, typename Tf>
struct	setNaturalSplineBoundaryCondition< BoundaryConditionType::Clamped, T, Tx, Tf > <typename T, typename Tx, typename Tf>
struct	setNaturalSplineBoundaryCondition< BoundaryConditionType::Natural, T, Tx, Tf > <typename T, typename Tx, typename Tf>
struct	setNaturalSplineBoundaryCondition< BoundaryConditionType::NotAKnot, T, Tx, Tf > <typename T, typename Tx, typename Tf>
struct	setNaturalSplineBoundaryCondition< BoundaryConditionType::Periodic, T, Tx, Tf > <typename T, typename Tx, typename Tf>

Public Types

Type	Name
enum	BoundaryConditionType
enum	IndexMethod
typedef LinearInterp< T, 1, IM >	LinearInterp1D
typedef LinearInterp< T, 2, IM >	LinearInterp2D
typedef LinearInterp< T, 3, IM >	LinearInterp3D
typedef LinearInterp< T, 4, IM >	LinearInterp4D
typedef CubicInterp< T, SlopePolicy< SlopeMethod::Makima >, 1, IM >	MakimaCubicInterp1D
typedef CubicInterp< T, SlopePolicy< SlopeMethod::Makima >, N, IM >	MakimaCubicInterp2D
typedef CubicInterp< T, SlopePolicy< SlopeMethod::Monotonic >, 1, IM >	MonotonicCubicInterp1D
typedef CubicInterp< T, SlopePolicy< SlopeMethod::Monotonic >, N, IM >	MonotonicCubicInterp2D
typedef CubicInterp< T, SlopePolicy< SlopeMethod::Natural, BC >, 1, IM >	NaturalCubicInterp1D
typedef CubicInterp< T, SlopePolicy< SlopeMethod::Natural, BC >, N, IM >	NaturalCubicInterp2D
typedef CubicInterp< T, SlopePolicy< SlopeMethod::Natural, BC >, N, IM >	NaturalCubicInterp3D
typedef CubicInterp< T, SlopePolicy< SlopeMethod::Natural, BC >, 1, IM >	NaturalPeriodicCubicInterp1D
typedef CubicInterp< T, SlopePolicy< SlopeMethod::Natural, BC >, N, IM >	NaturalPeriodicCubicInterp2D
enum	SlopeMethod

Public Attributes

Type	Name
constexpr std::size_t	SIZE_T_ZERO = `0`

Public Functions

Type	Name
constexpr std::size_t	binomial (std::size_t n, std::size_t k) noexcept
T	binomial_power_coefficient (const T y, const int n, const int k)
constexpr auto	build_coordinate_indices (const Tuple & t)
constexpr auto	build_coordinate_indices_impl (const Tuple & t, Accum acc)
void	call_move_into_submdspan (FType & F, SlopeType && slopes, const CoordTuple & coord, const DerivTuple & deriv)
auto	call_submdspan_1d (FType & F, const CoordTuple & coord, const DerivTuple & deriv)
void	compute_mixed_derivatives (FType & F, XiArray const & xi, CalcSlopesFunctor calcSlopes)
void	compute_mixed_derivatives_impl (FType & F, XiArray const & xi, const DerivTuple & currentDeriv, CalcSlopesFunctor calcSlopes, std::size_t start=0)
void	cyclic_thomas_algorithm (const std::vector< T > & a, const std::vector< T > & b, const std::vector< T > & c, std::vector< T > & d, const std::size_t exclude_rows=0)
constexpr int	factorial (int n)
constexpr void	for_each_dimension (const Tuple & tup, Func && func)
constexpr void	for_each_dimension_impl (const Tuple & tup, Func && func, std::index_sequence< Is... >)
void	iterate_over_indices (Func && func, XiArray const & xi, Indices... indices)
constexpr auto	make_zero_tuple ()
std::vector< T >	makima_slopes (const Tx x, const Tf f)
std::vector< T >	monotonic_slopes (const Tx x, const Tf f)
std::vector< T >	natural_spline_slopes (const Tx x, const Tf f)
constexpr std::size_t	power ()
void	thomas_algorithm (const std::vector< T > & a, const std::vector< T > & b, std::vector< T > & c, std::vector< T > & d)
constexpr auto	update_tuple_element (const Tuple & tup, T new_value)

Public Types Documentation

enum BoundaryConditionType

enum cip::BoundaryConditionType {
    Natural,
    Clamped,
    NotAKnot,
    Periodic
};

enum IndexMethod

enum cip::IndexMethod {
    BinarySearch,
    Uniform
};

typedef LinearInterp1D

using cip::LinearInterp1D = typedef LinearInterp<T, 1, IM>;

typedef LinearInterp2D

using cip::LinearInterp2D = typedef LinearInterp<T, 2, IM>;

typedef LinearInterp3D

using cip::LinearInterp3D = typedef LinearInterp<T, 3, IM>;

typedef LinearInterp4D

using cip::LinearInterp4D = typedef LinearInterp<T, 4, IM>;

typedef MakimaCubicInterp1D

using cip::MakimaCubicInterp1D = typedef CubicInterp<T, SlopePolicy<SlopeMethod::Makima>, 1, IM>;

typedef MakimaCubicInterp2D

using cip::MakimaCubicInterp2D = typedef CubicInterp<T, SlopePolicy<SlopeMethod::Makima>, N, IM>;

typedef MonotonicCubicInterp1D

using cip::MonotonicCubicInterp1D = typedef CubicInterp<T, SlopePolicy<SlopeMethod::Monotonic>, 1, IM>;

typedef MonotonicCubicInterp2D

using cip::MonotonicCubicInterp2D = typedef CubicInterp<T, SlopePolicy<SlopeMethod::Monotonic>, N, IM>;

typedef NaturalCubicInterp1D

using cip::NaturalCubicInterp1D = typedef CubicInterp<T, SlopePolicy<SlopeMethod::Natural, BC>, 1, IM>;

typedef NaturalCubicInterp2D

using cip::NaturalCubicInterp2D = typedef CubicInterp<T, SlopePolicy<SlopeMethod::Natural, BC>, N, IM>;

typedef NaturalCubicInterp3D

using cip::NaturalCubicInterp3D = typedef CubicInterp<T, SlopePolicy<SlopeMethod::Natural, BC>, N, IM>;

typedef NaturalPeriodicCubicInterp1D

using cip::NaturalPeriodicCubicInterp1D = typedef CubicInterp<T, SlopePolicy<SlopeMethod::Natural, BC>, 1, IM>;

typedef NaturalPeriodicCubicInterp2D

using cip::NaturalPeriodicCubicInterp2D = typedef CubicInterp<T, SlopePolicy<SlopeMethod::Natural, BC>, N, IM>;

enum SlopeMethod

enum cip::SlopeMethod {
    Monotonic,
    Makima,
    Natural
};

Public Attributes Documentation

variable SIZE_T_ZERO

constexpr std::size_t cip::SIZE_T_ZERO;

Public Functions Documentation

function binomial

inline constexpr std::size_t cip::binomial (
    std::size_t n,
    std::size_t k
) noexcept

function binomial_power_coefficient

template<typename T>
T cip::binomial_power_coefficient (
    const T y,
    const int n,
    const int k
)

function build_coordinate_indices

template<std::size_t N, std::size_t D, typename Tuple>
constexpr auto cip::build_coordinate_indices (
    const Tuple & t
)

function build_coordinate_indices_impl

template<std::size_t I, std::size_t N, std::size_t D, typename Tuple, typename Accum>
constexpr auto cip::build_coordinate_indices_impl (
    const Tuple & t,
    Accum acc
)

function call_move_into_submdspan

template<typename FType, typename SlopeType, typename CoordTuple, typename DerivTuple>
void cip::call_move_into_submdspan (
    FType & F,
    SlopeType && slopes,
    const CoordTuple & coord,
    const DerivTuple & deriv
)

function call_submdspan_1d

template<typename FType, typename CoordTuple, typename DerivTuple>
auto cip::call_submdspan_1d (
    FType & F,
    const CoordTuple & coord,
    const DerivTuple & deriv
)

function compute_mixed_derivatives

template<std::size_t N, typename FType, typename XiArray, typename CalcSlopesFunctor>
void cip::compute_mixed_derivatives (
    FType & F,
    XiArray const & xi,
    CalcSlopesFunctor calcSlopes
)

function compute_mixed_derivatives_impl

template<std::size_t N, typename FType, typename XiArray, typename DerivTuple, typename CalcSlopesFunctor>
void cip::compute_mixed_derivatives_impl (
    FType & F,
    XiArray const & xi,
    const DerivTuple & currentDeriv,
    CalcSlopesFunctor calcSlopes,
    std::size_t start=0
)

function cyclic_thomas_algorithm

template<typename T>
void cip::cyclic_thomas_algorithm (
    const std::vector< T > & a,
    const std::vector< T > & b,
    const std::vector< T > & c,
    std::vector< T > & d,
    const std::size_t exclude_rows=0
)

function factorial

inline constexpr int cip::factorial (
    int n
)

function for_each_dimension

template<std::size_t N, typename Tuple, typename Func>
constexpr void cip::for_each_dimension (
    const Tuple & tup,
    Func && func
)

function for_each_dimension_impl

template<std::size_t N, typename Tuple, typename Func, std::size_t... Is>
constexpr void cip::for_each_dimension_impl (
    const Tuple & tup,
    Func && func,
    std::index_sequence< Is... >
)

function iterate_over_indices

template<std::size_t N, std::size_t D, std::size_t current, typename Func, typename XiArray, typename... Indices>
void cip::iterate_over_indices (
    Func && func,
    XiArray const & xi,
    Indices... indices
)

function make_zero_tuple

template<std::size_t N>
constexpr auto cip::make_zero_tuple ()

function makima_slopes

template<typename T, typename Tx, typename Tf>
std::vector< T > cip::makima_slopes (
    const Tx x,
    const Tf f
)

function monotonic_slopes

template<typename T, typename Tx, typename Tf>
std::vector< T > cip::monotonic_slopes (
    const Tx x,
    const Tf f
)

function natural_spline_slopes

template<typename T, BoundaryConditionType BC, typename Tx, typename Tf>
std::vector< T > cip::natural_spline_slopes (
    const Tx x,
    const Tf f
)

function power

template<std::size_t Base, std::size_t Exp>
constexpr std::size_t cip::power ()

function thomas_algorithm

template<typename T>
void cip::thomas_algorithm (
    const std::vector< T > & a,
    const std::vector< T > & b,
    std::vector< T > & c,
    std::vector< T > & d
)

function update_tuple_element

template<std::size_t D, typename Tuple, typename T>
constexpr auto cip::update_tuple_element (
    const Tuple & tup,
    T new_value
)

The documentation for this class was generated from the following file include/cubic_interp.hpp