Integrate.hpp File Reference

ODE integration for Metis framework. More...

#include "metis/core/MetisConcepts.hpp"
#include "metis/core/MetisError.hpp"
#include "metis/core/MetisTypes.hpp"
#include "metis/math/Arithmetic.hpp"
#include "metis/math/IntegratorStep.hpp"
#include "metis/math/Linalg.hpp"
#include "metis/math/Quadrature.hpp"
#include "metis/math/Spacing.hpp"
#include <Eigen/Dense>
#include <casadi/casadi.hpp>
#include <functional>
#include <limits>
#include <optional>
#include <string>
#include <vector>

Include dependency graph for Integrate.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	metis::OdeResult< Scalar >
	Result structure for ODE solvers. More...
struct	metis::SecondOrderOdeResult< Scalar >
	Result structure for second-order IVP solvers. More...
struct	metis::SecondOrderIvpOptions
	Options for second-order structure-preserving trajectory integration. More...
struct	metis::MassMatrixIvpOptions
	Options for stiff mass-matrix integration. More...
struct	metis::QuadResult< Scalar >
	Result structure for quadrature (definite integration). More...

Namespaces
namespace	metis
namespace	metis::detail
	Smooth approximation of ReLU function: softplus(x) = (1/beta) * log(1 + exp(beta * x)).

Enumerations
enum class	metis::SecondOrderIntegratorMethod { metis::StormerVerlet , metis::RungeKuttaNystrom4 }
	Stepper selection for second-order systems q'' = a(t, q). More...
enum class	metis::MassMatrixIntegratorMethod { metis::RosenbrockEuler , metis::Bdf1 }
	Stepper selection for mass-matrix systems M(t, y) y' = f(t, y). More...

Functions
NumericVector	metis::detail::to_numeric_vector (std::initializer_list< double > init)
const char *	metis::detail::method_name (SecondOrderIntegratorMethod method)
const char *	metis::detail::method_name (MassMatrixIntegratorMethod method)
void	metis::detail::validate_eval_count (const std::string &context, int n_eval)
void	metis::detail::validate_second_order_options (const SecondOrderIvpOptions &opts, const std::string &context)
void	metis::detail::validate_mass_matrix_options (const MassMatrixIvpOptions &opts, const std::string &context)
void	metis::detail::validate_second_order_initial_state (const NumericVector &q0, const NumericVector &v0)
double	metis::detail::inf_norm (const NumericVector &x)
bool	metis::detail::is_constant_zero (const SymbolicScalar &expr)
template<typename VectorFunc>
NumericMatrix	metis::detail::finite_difference_jacobian (VectorFunc &&func, const NumericVector &x, double epsilon)
template<typename MassFunc>
NumericMatrix	metis::detail::evaluate_mass_matrix (MassFunc &&mass_matrix, double t, const NumericVector &y, const std::string &context)
template<typename RhsFunc, typename MassFunc>
NumericVector	metis::detail::rosenbrock_euler_step (RhsFunc &&rhs, MassFunc &&mass_matrix, const NumericVector &y, double t, double dt, const MassMatrixIvpOptions &opts)
template<typename RhsFunc, typename MassFunc>
NumericVector	metis::detail::bdf1_step (RhsFunc &&rhs, MassFunc &&mass_matrix, const NumericVector &y, double t, double dt, const MassMatrixIvpOptions &opts)
template<typename Func, typename T>
QuadResult< T >	metis::quad (Func &&func, T a, T b, double abstol=1e-8, double reltol=1e-6)
	Compute definite integral using adaptive quadrature (numeric) or CVODES (symbolic).
QuadResult< SymbolicScalar >	metis::quad (const SymbolicScalar &expr, const SymbolicScalar &variable, double a, double b, double abstol=1e-8, double reltol=1e-6)
	Compute definite integral of a symbolic expression using CasADi CVODES.
template<typename Func>
OdeResult< double >	metis::solve_ivp (Func &&fun, std::pair< double, double > t_span, const NumericVector &y0, int n_eval=100, double abstol=1e-8, double reltol=1e-6)
	Solve initial value problem: dy/dt = f(t, y), y(t0) = y0.
template<typename Func>
OdeResult< double >	metis::solve_ivp (Func &&fun, std::pair< double, double > t_span, std::initializer_list< double > y0_init, int n_eval=100, double abstol=1e-8, double reltol=1e-6)
	Convenience overload: solve_ivp with initializer list for y0.
template<typename AccelFunc>
SecondOrderOdeResult< double >	metis::solve_second_order_ivp (AccelFunc &&acceleration, std::pair< double, double > t_span, const NumericVector &q0, const NumericVector &v0, int n_eval=100, const SecondOrderIvpOptions &opts={})
	Solve a second-order IVP q'' = a(t, q), q(t0) = q0, v(t0) = v0.
template<typename AccelFunc>
SecondOrderOdeResult< double >	metis::solve_second_order_ivp (AccelFunc &&acceleration, std::pair< double, double > t_span, std::initializer_list< double > q0_init, std::initializer_list< double > v0_init, int n_eval=100, const SecondOrderIvpOptions &opts={})
	Convenience overload for second-order IVPs using initializer lists.
template<typename RhsFunc, typename MassFunc>
OdeResult< double >	metis::solve_ivp_mass_matrix (RhsFunc &&rhs, MassFunc &&mass_matrix, std::pair< double, double > t_span, const NumericVector &y0, int n_eval=100, const MassMatrixIvpOptions &opts={})
	Solve M(t, y) y' = f(t, y) with a native numeric stiff integrator.
template<typename RhsFunc, typename MassFunc>
OdeResult< double >	metis::solve_ivp_mass_matrix (RhsFunc &&rhs, MassFunc &&mass_matrix, std::pair< double, double > t_span, std::initializer_list< double > y0_init, int n_eval=100, const MassMatrixIvpOptions &opts={})
	Convenience overload for mass-matrix IVPs using initializer lists.
OdeResult< double >	metis::solve_ivp_mass_matrix_expr (const SymbolicScalar &rhs_expr, const SymbolicScalar &mass_expr, const SymbolicScalar &t_var, const SymbolicScalar &y_var, std::pair< double, double > t_span, const NumericVector &y0, int n_eval=100, const MassMatrixIvpOptions &opts={})
	Solve a symbolic mass-matrix IVP using CasADi IDAS.
template<typename Func>
OdeResult< SymbolicScalar >	metis::solve_ivp_symbolic (Func &&fun, std::pair< double, double > t_span, const Eigen::VectorXd &y0, int n_eval=100, double abstol=1e-8, double reltol=1e-6)
	Solve IVP with symbolic ODE function (CasADi CVODES backend).
OdeResult< double >	metis::solve_ivp_expr (const SymbolicScalar &ode_expr, const SymbolicScalar &t_var, const SymbolicScalar &y_var, std::pair< double, double > t_span, const NumericVector &y0, int n_eval=100, double abstol=1e-8, double reltol=1e-6)
	Solve IVP with a symbolic expression directly (expression-based API).

Detailed Description

ODE integration for Metis framework.

Provides quad (definite integration) and solve_ivp (initial value problem) with dual-backend support: numeric fallback and CasADi CVODES for symbolic graphs.

See also IntegratorStep.hpp for single-step integrators (euler_step, rk4_step, etc.)