metis::diff_test Namespace Reference

Namespaces
namespace	detail

Classes
struct	DiffTestOptions
	Options controlling differentiability test behavior. More...
struct	DualModeResult
	Result of a dual-mode (symbolic compilation + value match) check. More...
struct	DiffTestResult
	Result of a full differentiability check (dual-mode + Jacobian). More...

Functions
template<typename Func>
DualModeResult	verify_dual_mode_at_point (Func &&f, const std::vector< double > &point, const DiffTestOptions &opts={})
	Verify that a dual-mode function compiles symbolically and that symbolic evaluation matches numeric evaluation at a single point.
template<typename Func>
DualModeResult	verify_dual_mode (Func &&f, const std::vector< std::vector< double > > &test_points, const DiffTestOptions &opts={})
	Verify dual-mode across multiple test points. Returns on first failure.
template<typename Func>
DiffTestResult	verify_differentiable_at_point (Func &&f, const std::vector< double > &point, const DiffTestOptions &opts={})
	Verify differentiability at a single test point: dual-mode checks + AD Jacobian vs FD Jacobian.
template<typename Func>
DiffTestResult	verify_differentiable (Func &&f, const std::vector< std::vector< double > > &test_points, const DiffTestOptions &opts={})
	Verify differentiability across multiple test points. Returns on first failure.
template<typename Func>
void	expect_dual_mode (Func &&f, const std::vector< std::vector< double > > &test_points, const DiffTestOptions &opts={})
	Assert that a dual-mode function compiles symbolically and that symbolic output matches numeric output at all test points.
template<typename Func>
void	expect_differentiable (Func &&f, const std::vector< std::vector< double > > &test_points, const DiffTestOptions &opts={})
	Assert that a dual-mode function is differentiable: symbolic compilation + value match + AD Jacobian matches FD Jacobian.

Function Documentation

expect_differentiable()

template<typename Func>

void metis::diff_test::expect_differentiable	(	Func &&	f,
		const std::vector< std::vector< double > > &	test_points,
		const DiffTestOptions &	opts = {} )

Assert that a dual-mode function is differentiable: symbolic compilation + value match + AD Jacobian matches FD Jacobian.

TEST(MyTests, SinDifferentiable) {
    metis::diff_test::expect_differentiable(
        [](auto x) { return metis::sin(x); },
        {{0.5}, {1.0}, {2.0}}
    );
}

expect_dual_mode()

template<typename Func>

void metis::diff_test::expect_dual_mode	(	Func &&	f,
		const std::vector< std::vector< double > > &	test_points,
		const DiffTestOptions &	opts = {} )

Assert that a dual-mode function compiles symbolically and that symbolic output matches numeric output at all test points.

TEST(MyTests, FloorDualMode) {
    metis::diff_test::expect_dual_mode(
        [](auto x) { return metis::floor(x); },
        {{0.5}, {1.7}, {-2.3}}
    );
}

verify_differentiable()

template<typename Func>

DiffTestResult metis::diff_test::verify_differentiable	(	Func &&	f,
		const std::vector< std::vector< double > > &	test_points,
		const DiffTestOptions &	opts = {} )

Verify differentiability across multiple test points. Returns on first failure.

For each test point, verifies:

1. Symbolic mode compiles
2. Symbolic output matches numeric output within value_tol
3. AD Jacobian matches FD Jacobian within jac_rtol/jac_atol

Template Parameters

Func	Lambda type: auto f(Scalar x1, ..., Scalar xN) -> Scalar or MetisVector<Scalar>

Parameters

f	The dual-mode function to test
test_points	Vector of test points, each a vector of doubles
opts	Tolerance and step size options

Returns

DiffTestResult with pass/fail and diagnostics

verify_differentiable_at_point()

template<typename Func>

DiffTestResult metis::diff_test::verify_differentiable_at_point	(	Func &&	f,
		const std::vector< double > &	point,
		const DiffTestOptions &	opts = {} )

Verify differentiability at a single test point: dual-mode checks + AD Jacobian vs FD Jacobian.

verify_dual_mode()

template<typename Func>

DualModeResult metis::diff_test::verify_dual_mode	(	Func &&	f,
		const std::vector< std::vector< double > > &	test_points,
		const DiffTestOptions &	opts = {} )

Verify dual-mode across multiple test points. Returns on first failure.

verify_dual_mode_at_point()

template<typename Func>

DualModeResult metis::diff_test::verify_dual_mode_at_point	(	Func &&	f,
		const std::vector< double > &	point,
		const DiffTestOptions &	opts = {} )

Verify that a dual-mode function compiles symbolically and that symbolic evaluation matches numeric evaluation at a single point.