cartan 0.4.0

Riemannian geometry, manifold optimization, and geodesic computation in 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

//! # cartan
//!
//! Riemannian geometry, manifold optimization, and geodesic computation in Rust.
//!
//! This is the top-level facade crate. It re-exports the most commonly used
//! items from the sub-crates so that downstream users only need one dependency:
//! `cartan = "0.1"`.
//!
//! ## Crate structure
//!
//! - `cartan-core` -- abstract trait system (Manifold, Retraction, etc.)
//! - `cartan-manifolds` -- concrete manifolds (Sphere, SO(N), SE(N), ...)
//! - `cartan-optim` -- optimization algorithms (RGD, RCG, trust region)
//! - `cartan-geo` -- geodesic and curvature tools
//! - `cartan-dec` -- discrete exterior calculus: simplicial complexes, Hodge
//!   operators, and covariant differential operators for PDE solvers (requires std)
//!
//! ## no_std / embedded usage
//!
//! The default `full` feature includes `cartan-dec`, which requires std.
//! For embedded and no_std targets, disable default features and select a tier:
//!
//! ```toml
//! # no_std with allocator (recommended for most embedded targets)
//! cartan = { version = "0.1", default-features = false, features = ["alloc"] }
//!
//! # std without cartan-dec (no mesh/PDE layer)
//! cartan = { version = "0.1", default-features = false, features = ["std"] }
//! ```
//!
//! See the [README](https://github.com/alejandro-soto-franco/cartan#embedded-and-nostd-targets)
//! for the full feature tier table.
//!
//! ## Prelude
//!
//! Import `use cartan::prelude::*;` to bring all traits into scope.
//! This lets you call `.exp()`, `.log()`, `.inner()` etc. on any manifold
//! without individually importing each trait.

// Re-export sub-crates under descriptive aliases.
//
// NOTE: The core traits crate is aliased as `traits`, NOT `core`.
// Aliasing as `core` would shadow `std::core` and break macro hygiene
// in downstream crates that use standard library macros.
pub use cartan_core as traits;
#[cfg(feature = "full")]
pub use cartan_dec as dec;
pub use cartan_geo as geo;
pub use cartan_manifolds as manifolds;
pub use cartan_optim as optim;

/// Prelude module: import with `use cartan::prelude::*` to bring all traits into scope.
///
/// This is the recommended way to use cartan. It brings all the abstract
/// geometry traits into scope so you can call their methods on any manifold
/// without needing to name each trait individually.
pub mod prelude {
    // The foundational Manifold trait: exp, log, inner, project, validate, random.
    pub use cartan_core::Manifold;

    // Optional capability traits, in order of computational cost.
    // Retraction: cheaper approximation to exp (e.g., QR on Stiefel).
    pub use cartan_core::Retraction;
    // ParallelTransport: exact parallel transport along geodesics.
    pub use cartan_core::ParallelTransport;
    // VectorTransport: approximation to parallel transport (blanket impl from PT).
    pub use cartan_core::VectorTransport;
    // Connection: Riemannian Hessian-vector products for second-order methods.
    pub use cartan_core::Connection;
    // Curvature: Riemann tensor, sectional curvature, Ricci, scalar curvature.
    pub use cartan_core::Curvature;
    // GeodesicInterpolation: geodesic curve sampling gamma(p, q, t).
    pub use cartan_core::GeodesicInterpolation;

    // The unified error type for all cartan operations.
    pub use cartan_core::CartanError;

    // The Real type alias (f64) used throughout cartan.
    pub use cartan_core::Real;
}