Struct Coords 

pub struct Coords<F: Field, const N: usize, const M: usize = 0>(pub [F; N]);

The canonical model of flat pseudo-Euclidean coordinate space R^(N−M, M).

A fixed-size array of N coordinates over the field R, carrying the algebraic structure of a vector space together with a symmetric bilinear form of signature (N − M, M): N − M positive (spacelike) directions and M negative (timelike) ones. The first M coordinates are the negative-signature directions; the remaining N − M are positive.

This is the space in which local coordinate charts take their values and in which tangent vectors live. With the default M = 0 it is ordinary flat Euclidean space R^N — positive-definite, hence carrying a genuine norm and Metric. With M > 0 the form is indefinite: it is a Bilinear scalar product only, with no norm and no metric (a timelike vector has negative norm_squared, and null vectors give distinct points at zero separation). Minkowski spacetime is Coords<R, 4, 1>.

M is expected in 0..=N; values M > N are safe but redundant, behaving identically to M = N (fully negative-definite), since the scalar product only ranges over the N present coordinates.

Trait scoping

The definite (M = 0) case implements InnerProduct, Metric, and Euclidean; the general case implements Sesquilinear and, in cases where the fixed field is itself, Bilinear

Tuple Fields

0: [F; N]

Methods from Deref<Target = [F; N]>

pub fn as_slice(&self) -> &[T]

Returns a slice containing the entire array. Equivalent to &s[..].

pub fn as_mut_slice(&mut self) -> &mut [T]

Returns a mutable slice containing the entire array. Equivalent to &mut s[..].

pub fn each_ref(&self) -> [&T; N]

Borrows each element and returns an array of references with the same size as self.

Example

let floats = [3.1, 2.7, -1.0];
let float_refs: [&f64; 3] = floats.each_ref();
assert_eq!(float_refs, [&3.1, &2.7, &-1.0]);

This method is particularly useful if combined with other methods, like map. This way, you can avoid moving the original array if its elements are not Copy.

let strings = ["Ferris".to_string(), "♥".to_string(), "Rust".to_string()];
let is_ascii = strings.each_ref().map(|s| s.is_ascii());
assert_eq!(is_ascii, [true, false, true]);

// We can still access the original array: it has not been moved.
assert_eq!(strings.len(), 3);

pub fn each_mut(&mut self) -> [&mut T; N]

Borrows each element mutably and returns an array of mutable references with the same size as self.

Example

let mut floats = [3.1, 2.7, -1.0];
let float_refs: [&mut f64; 3] = floats.each_mut();
*float_refs[0] = 0.0;
assert_eq!(float_refs, [&mut 0.0, &mut 2.7, &mut -1.0]);
assert_eq!(floats, [0.0, 2.7, -1.0]);

pub fn split_array_ref<const M: usize>(&self) -> (&[T; M], &[T])

🔬This is a nightly-only experimental API. (split_array)

Divides one array reference into two at an index.

The first will contain all indices from [0, M) (excluding the index M itself) and the second will contain all indices from [M, N) (excluding the index N itself).

Panics

Panics if M > N.

Examples

#![feature(split_array)]

let v = [1, 2, 3, 4, 5, 6];

{
   let (left, right) = v.split_array_ref::<0>();
   assert_eq!(left, &[]);
   assert_eq!(right, &[1, 2, 3, 4, 5, 6]);
}

{
    let (left, right) = v.split_array_ref::<2>();
    assert_eq!(left, &[1, 2]);
    assert_eq!(right, &[3, 4, 5, 6]);
}

{
    let (left, right) = v.split_array_ref::<6>();
    assert_eq!(left, &[1, 2, 3, 4, 5, 6]);
    assert_eq!(right, &[]);
}

pub fn split_array_mut<const M: usize>(&mut self) -> (&mut [T; M], &mut [T])

🔬This is a nightly-only experimental API. (split_array)

Divides one mutable array reference into two at an index.

The first will contain all indices from [0, M) (excluding the index M itself) and the second will contain all indices from [M, N) (excluding the index N itself).

Panics

Panics if M > N.

Examples

#![feature(split_array)]

let mut v = [1, 0, 3, 0, 5, 6];
let (left, right) = v.split_array_mut::<2>();
assert_eq!(left, &mut [1, 0][..]);
assert_eq!(right, &mut [3, 0, 5, 6]);
left[1] = 2;
right[1] = 4;
assert_eq!(v, [1, 2, 3, 4, 5, 6]);

pub fn rsplit_array_ref<const M: usize>(&self) -> (&[T], &[T; M])

🔬This is a nightly-only experimental API. (split_array)

Divides one array reference into two at an index from the end.

The first will contain all indices from [0, N - M) (excluding the index N - M itself) and the second will contain all indices from [N - M, N) (excluding the index N itself).

Panics

Panics if M > N.

Examples

#![feature(split_array)]

let v = [1, 2, 3, 4, 5, 6];

{
   let (left, right) = v.rsplit_array_ref::<0>();
   assert_eq!(left, &[1, 2, 3, 4, 5, 6]);
   assert_eq!(right, &[]);
}

{
    let (left, right) = v.rsplit_array_ref::<2>();
    assert_eq!(left, &[1, 2, 3, 4]);
    assert_eq!(right, &[5, 6]);
}

{
    let (left, right) = v.rsplit_array_ref::<6>();
    assert_eq!(left, &[]);
    assert_eq!(right, &[1, 2, 3, 4, 5, 6]);
}

pub fn rsplit_array_mut<const M: usize>(&mut self) -> (&mut [T], &mut [T; M])

🔬This is a nightly-only experimental API. (split_array)

Divides one mutable array reference into two at an index from the end.

The first will contain all indices from [0, N - M) (excluding the index N - M itself) and the second will contain all indices from [N - M, N) (excluding the index N itself).

Panics

Panics if M > N.

Examples

#![feature(split_array)]

let mut v = [1, 0, 3, 0, 5, 6];
let (left, right) = v.rsplit_array_mut::<4>();
assert_eq!(left, &mut [1, 0]);
assert_eq!(right, &mut [3, 0, 5, 6][..]);
left[1] = 2;
right[1] = 4;
assert_eq!(v, [1, 2, 3, 4, 5, 6]);

Trait Implementations

impl<F: Field, const N: usize, const M: usize> Add for Coords<F, N, M>

type Output = Coords<F, N, M>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<F: Field, const N: usize, const M: usize> AsMut<[F; N]> for Coords<F, N, M>

fn as_mut(&mut self) -> &mut [F; N]

Converts this type into a mutable reference of the (usually inferred) input type.

impl<F: Field, const N: usize, const M: usize> AsRef<[F; N]> for Coords<F, N, M>

fn as_ref(&self) -> &[F; N]

Converts this type into a shared reference of the (usually inferred) input type.

impl Bounded<So3<Coords<R64, 3>>, So3<Coords<R64, 3>>, Coords<R64, 3>> for So3Cover

Radius of the geodesic-ball domains of So3Cover.

The 60 nodes are the icosahedral rotation group I ≅ A₅ ⊂ SO(3) — the image of the 120 icosian unit quaternions (the vertices of the 600-cell) under the double cover S³ → SO(3). In the bi-invariant metric d = |identity_log| (half the rotation angle; diameter π/2), the pairwise distances realised between nodes are exactly

  π/5 ≈ 0.628,   π/3 ≈ 1.047,   2π/5 ≈ 1.257,   π/2 ≈ 1.571

and the covering radius of the node set is ≈ 0.3857 (the circumradius of a cell of the 600-cell). The radius ρ = 0.42 is chosen so that:

• covering: ρ > 0.3857, so the 60 open balls cover SO(3);
• goodness: ρ < π/4, the convexity radius of SO(3) ≅ RP³, so every ball is geodesically convex and all intersections of balls are convex, hence contractible or empty — an open good cover;
• faithful 1-skeleton: two equal balls overlap iff their centres are closer than 2ρ = 0.84, which separates π/5 from π/3 with a wide margin on both sides — the nerve’s edges are exactly the 600-cell’s edges (mod ±1), and the computation is robust to floating-point error;
• faithful 2-skeleton: every triangle of the overlap graph is an equilateral triangle of side π/5 with spherical circumradius ≈ 0.365 < ρ, so all three balls genuinely share a point — mutual pairwise overlap coincides with triple intersection, and the triangles of the nerve are exactly the 600-cell’s 2-faces (mod ±1).

The nerve of this cover is therefore the hemi-600-cell: the classical vertex-transitive 60-vertex triangulation of RP³ with f-vector (60, 360, 600, 300), obtained from the boundary complex of the 600-cell by identifying antipodes. By the nerve theorem the nerve is homotopy equivalent to SO(3), and π₁ computed from its 2-skeleton is ⟨x | x²⟩ ≅ Z/2Z.

fn sdf(&self, v: &Coords<R64, 3>) -> R64

impl Bounded<UnitComplex<Coords<R64, 1>>, UnitComplex<Coords<R64, 1>>, Coords<R64, 1>> for S1Cover

fn sdf(&self, v: &Coords<R64, 1>) -> R64

impl Chart<So3<Coords<R64, 3>>, Coords<R64, 3>> for So3Cover

type Global = So3<Coords<R64, 3>>

The result of mapping local coordinates back onto the manifold.

fn to_local(&self, point: &So3<Coords<R64, 3>>) -> Option<Coords<R64, 3>>

fn to_global(&self, coord: Coords<R64, 3>) -> So3<Coords<R64, 3>>

fn chart_at(p: &So3<Coords<R64, 3>>) -> Self

fn local_distance(&self, other: &P) -> Option<<V::F as Field>::Fixed>

where V: Euclidean,

Calculates the distance between self and other in local coordinates, based at &self.

fn check_local_inverse(p: &P) -> bool

where P: PartialEq,

impl Chart<UnitComplex<Coords<R64, 1>>, Coords<R64, 1>> for S1Cover

type Global = <UnitComplex<Coords<R64, 1>> as Chart<UnitComplex<Coords<R64, 1>>, Coords<R64, 1>>>::Global

The result of mapping local coordinates back onto the manifold.

fn to_local(&self, p: &UnitComplex<Coords<R64, 1>>) -> Option<Coords<R64, 1>>

fn to_global(&self, c: Coords<R64, 1>) -> Self::Global

fn chart_at(p: &UnitComplex<Coords<R64, 1>>) -> Self

fn local_distance(&self, other: &P) -> Option<<V::F as Field>::Fixed>

where V: Euclidean,

Calculates the distance between self and other in local coordinates, based at &self.

fn check_local_inverse(p: &P) -> bool

where P: PartialEq,

impl<F: Clone + Field, const N: usize, const M: usize> Clone for Coords<F, N, M>

fn clone(&self) -> Coords<F, N, M>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<F: Field + ConstZero, const N: usize, const M: usize> ConstZero for Coords<F, N, M>

const ZERO: Self

The additive identity element of Self, 0.

impl<F: Copy + Field, const N: usize, const M: usize> Copy for Coords<F, N, M>

impl<F: Debug + Field, const N: usize, const M: usize> Debug for Coords<F, N, M>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<F: Field, const N: usize, const M: usize> Deref for Coords<F, N, M>

type Target = [F; N]

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<F: Field, const N: usize, const M: usize> DerefMut for Coords<F, N, M>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<R: Real, const N: usize> Euclidean for Coords<R, N, 0>

fn check_pythagorean(a: &Self, b: &Self) -> bool

impl ExpMap<So3<Coords<R64, 3>>, Coords<R64, 3>> for So3Cover

fn base_point(&self) -> P

fn check_base_point_is_origin(&self) -> bool

where V: Form,

fn check_preservation_of_origin(&self) -> bool

where V: Form,

fn check_chart_at_base_point(&self) -> bool

where V: Form,

If a chart centred at p exists, chart_at(p) returns it. Formally: chart_at(p).base_point() == p whenever p is the base point of some valid chart in this atlas.

impl ExpMap<UnitComplex<Coords<R64, 1>>, Coords<R64, 1>> for S1Cover

fn base_point(&self) -> UnitComplex<Coords<R64, 1>>

fn check_base_point_is_origin(&self) -> bool

where V: Form,

fn check_preservation_of_origin(&self) -> bool

where V: Form,

fn check_chart_at_base_point(&self) -> bool

where V: Form,

If a chart centred at p exists, chart_at(p) returns it. Formally: chart_at(p).base_point() == p whenever p is the base point of some valid chart in this atlas.

impl<R: Field, const N: usize, const M: usize> Form for Coords<R, N, M>

fn flat(&self) -> Dual<Self>

fn dot(&self, b: &Self) -> Self::F

fn self_dot(&self) -> Self::F

fn check_dot_agrees_with_pairing(a: &Self, b: &Self) -> bool

fn check_translation_invariance(a: &Self, b: &Self, c: &Self) -> bool

impl<R: Field, const N: usize, const M: usize> FormLift for Coords<R, N, M>

fn jet_flat_array<𝒞: Cat, S: Field, const K: usize>( value: &<Self as Tensor>::Array<Jet<𝒞, S, K>>, ) -> <Dual<Self> as Tensor>::Array<Jet<𝒞, S, K>>

where Jet<𝒞, S, K>: Field,

Applies the lifted lowering map to raw coordinate arrays.

fn jet_flat<𝒞: Cat, S: Field, const N: usize>( value: &JetVector<𝒞, Self, N, S>, ) -> Dual<JetVector<𝒞, Self, N, S>>

where Jet<𝒞, S, N>: Field, JetVector<𝒞, Self, N, S>: Tensor<F = Jet<𝒞, S, N>>,

Applies the lifted lowering map to a JetVector.

impl<F: CField<Characteristic = NatZero>, const N: usize, const D: usize> From<Coords<F, D>> for SlAlgebra<F, N, D>

fn from(value: Coords<F, D>) -> Self

Converts to this type from the input type.

impl<F: Field, const N: usize, const M: usize> From<Coords<F, N, M>> for [F; N]

fn from(c: Coords<F, N, M>) -> Self

Converts to this type from the input type.

impl<R: Real> From<Coords<R, 2>> for Complex<R>

fn from(value: Coords<R, 2, 0>) -> Self

Converts to this type from the input type.

impl<R: Real> From<Coords<R, 4>> for Quaternion<R>

fn from(value: Coords<R, 4, 0>) -> Self

Converts to this type from the input type.

impl<F: Field> From<F> for Coords<F, 1>

fn from(value: F) -> Self

Converts to this type from the input type.

impl<F: Field, const N: usize, const M: usize> From<[F; N]> for Coords<F, N, M>

fn from(arr: [F; N]) -> Self

Converts to this type from the input type.

impl<const R: usize, F: Field, const N: usize, const M: usize> Index<[usize; R]> for Coords<F, N, M>

where Coords<F, N, M>: Tensor,

type Output = <Coords<F, N, M> as Tensor>::F

The returned type after indexing.

fn index(&self, index: [usize; R]) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<F: Field, const N: usize, const M: usize> Index<usize> for Coords<F, N, M>

type Output = <Coords<F, N, M> as Tensor>::F

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<const R: usize, F: Field, const N: usize, const M: usize> IndexMut<[usize; R]> for Coords<F, N, M>

where Coords<F, N, M>: Tensor,

fn index_mut(&mut self, index: [usize; R]) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<F: Field, const N: usize, const M: usize> IndexMut<usize> for Coords<F, N, M>

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<R: Real, F: Field<Fixed = R>, const N: usize, const M: usize> Interval for Coords<F, N, M>

type R = R

The ordered field the interval is valued in — the real field where magnitudes, distances, and convergence live. Distinct from a scalar field’s involution Fixed: analysis happens here regardless of the algebraic involution.

fn interval_squared(&self, other: &Self) -> R

The signed squared interval s²(a, b) — the primitive from which interval (its signed square root) and distance both derive.

fn interval(&self, other: &Self) -> Complex<Self::R>

Interval between self and other. Real or imaginary carries causal character.

fn check_interval_symmetry(a: Self, b: Self) -> bool

fn check_self_interval_zero(a: Self) -> bool

fn check_interval_squared_agrees_with_interval(a: &Self, b: &Self) -> bool

impl<R: Real> LieGroup<Coords<R, 2>> for Complex<R>

fn identity_exp(v: Coords<R, 2>) -> Self

fn identity_log(p: &Self) -> Option<Coords<R, 2>>

impl<R: Real> LieGroup<Coords<R, 2>> for NonZero<Complex<R>>

fn identity_exp(v: Coords<R, 2>) -> Self

fn identity_log(p: &Self) -> Option<Coords<R, 2>>

impl<R: Real> LieGroup<Coords<R, 4>> for Quaternion<R>

fn identity_exp(v: Coords<R, 4>) -> Self

fn identity_log(p: &Self) -> Option<Coords<R, 4>>

impl<R: Field + Real, const N: usize> Metric for Coords<R, N, 0>

fn distance(&self, other: &Self) -> R

fn check_non_negative(a: Self, b: Self) -> bool

fn check_distance_agrees_with_interval(a: Self, b: Self) -> bool

impl<F: Field, const N: usize, const M: usize> Mul<<Coords<F, N, M> as Tensor>::F> for Coords<F, N, M>

where Coords<F, N, M>: Tensor<Action: ActionExists>,

type Output = Coords<F, N, M>

The resulting type after applying the * operator.

fn mul(self, scalar: <Coords<F, N, M> as Tensor>::F) -> Self::Output

Performs the * operation.

impl<F: Field, const N: usize, const M: usize> Neg for Coords<F, N, M>

type Output = Coords<F, N, M>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl NerveComplexParameters<So3<Coords<R64, 3>>, Coords<R64, 3>, So3<Coords<R64, 3>>, So3Cover> for So3Cover

fn overestimation_bound() -> Option<(V::F, V::F)>

The one irreducible assumption: graph distance on the 1-skeleton overestimates true geodesic distance by at most a factor 1 + e.

fn max_candidate_paths() -> usize

Hard cap on how many candidate edge-paths are straightened. Raising it strengthens the guarantee; lowering it trades certification for speed.

fn max_frontier() -> usize

Cap on heap entries. Prefixes vastly outnumber completions, and this is the quantity that threatens memory. Independent of the above: no ratio between prefixes-in-flight and completions exists.

fn max_rescues() -> usize

Cap on local insertions before declaring the charts unusable. when flowing a polyline, sometimes a point might go out of the injectivity radius of its neighbors, in that case, we insert a point between them to try to rescue the polyline.

fn max_straightening_iterations(n: usize) -> usize

Iteration cap for the flow, as a function of vertex count.

fn max_samples() -> usize

Cap on samples per same_basin comparison. Exceeding it means the polyline is longer than max_samples · δ_s, and no comparison at that spacing could prove two prefixes share a basin — so the prune is declined rather than performed on insufficient evidence.

fn max_canonical_generators() -> usize

Generator count above which fundamental_group returns a correct but non-canonical presentation.

fn prefix_smoothing_sweeps() -> usize

Sweeps of the discrete geodesic flow applied to a prefix before it is compared for basin membership.

fn max_basins_per_class() -> usize

fn get_neighbors(i: usize) -> impl Iterator<Item = usize>

Returns the indices of nodes whose bounded domains overlap the bounded domain of this node — the 1-skeleton of the nerve.

impl NerveComplexParameters<UnitComplex<Coords<R64, 1>>, Coords<R64, 1>, UnitComplex<Coords<R64, 1>>, S1Cover> for S1Cover

fn overestimation_bound() -> Option<(V::F, V::F)>

The one irreducible assumption: graph distance on the 1-skeleton overestimates true geodesic distance by at most a factor 1 + e.

fn max_candidate_paths() -> usize

Hard cap on how many candidate edge-paths are straightened. Raising it strengthens the guarantee; lowering it trades certification for speed.

fn max_frontier() -> usize

Cap on heap entries. Prefixes vastly outnumber completions, and this is the quantity that threatens memory. Independent of the above: no ratio between prefixes-in-flight and completions exists.

fn max_rescues() -> usize

Cap on local insertions before declaring the charts unusable. when flowing a polyline, sometimes a point might go out of the injectivity radius of its neighbors, in that case, we insert a point between them to try to rescue the polyline.

fn max_straightening_iterations(n: usize) -> usize

Iteration cap for the flow, as a function of vertex count.

fn max_samples() -> usize

Cap on samples per same_basin comparison. Exceeding it means the polyline is longer than max_samples · δ_s, and no comparison at that spacing could prove two prefixes share a basin — so the prune is declined rather than performed on insufficient evidence.

fn max_canonical_generators() -> usize

Generator count above which fundamental_group returns a correct but non-canonical presentation.

fn prefix_smoothing_sweeps() -> usize

Sweeps of the discrete geodesic flow applied to a prefix before it is compared for basin membership.

fn max_basins_per_class() -> usize

fn get_neighbors(i: usize) -> impl Iterator<Item = usize>

Returns the indices of nodes whose bounded domains overlap the bounded domain of this node — the 1-skeleton of the nerve.

impl<R: Field, const N: usize, const M: usize> Nondegenerate for Coords<R, N, M>

fn sharp(v: Dual<Self>) -> Self

fn check_isomorphism(a: &Self) -> bool

where Self: PartialEq<Self>,

impl<R: Field, const N: usize, const M: usize> NondegenerateLift for Coords<R, N, M>

fn jet_sharp_array<𝒞: Cat, S: Field, const K: usize>( value: &<Dual<Self> as Tensor>::Array<Jet<𝒞, S, K>>, ) -> <Self as Tensor>::Array<Jet<𝒞, S, K>>

where Jet<𝒞, S, K>: Field,

Applies the lifted raising map to raw coordinate arrays.

fn jet_sharp<𝒞: Cat, S: Field, const N: usize>( value: Dual<JetVector<𝒞, Self, N, S>>, ) -> JetVector<𝒞, Self, N, S>

where Jet<𝒞, S, N>: Field, JetVector<𝒞, Self, N, S>: Tensor<F = Jet<𝒞, S, N>>,

Applies the lifted raising map to a jet-valued covector.

impl<F: Field, const N: usize, const M: usize> PartialEq for Coords<F, N, M>

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<F: Field, const N: usize, const M: usize> Sesquilinear for Coords<F, N, M>

fn norm_squared(&self) -> <Self::F as Field>::Fixed

fn check_hermitian_symmetry(a: Self, b: Self) -> bool

fn check_additivity(a: Self, b: Self, c: Self) -> bool

fn check_scalar_linearity(a: Self, c: Self, k: Self::F) -> bool

impl<F: Field, const N: usize, const M: usize> Sub for Coords<F, N, M>

type Output = Coords<F, N, M>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl TangentBundle<So3<Coords<R64, 3>>, Coords<R64, 3>> for So3Cover

fn check_universal_centring(p: P) -> bool

where V: Form,

impl TangentBundle<UnitComplex<Coords<R64, 1>>, Coords<R64, 1>> for S1Cover

fn check_universal_centring(p: P) -> bool

where V: Form,

impl<F: Field, const N: usize, const M: usize> Tensor for Coords<F, N, M>

type F = F

The scalar field the coordinates live in.

type Hand = Right

The side on which F acts. Dual<Self> elects the opposite hand, and Dual<Dual<Self>> therefore restores this one.

type Action = BothSided

Whether Self has a one-sided or both-sided action.

type Normalization = Atomic

Selects how this constructor participates in tensor normalization. Ordinary tensor spaces use Atomic; expression constructors provide their corresponding structural normalizer.

type Array<T: Point> = [T; N]

The underlying storage of this tensor; generic over any point.

fn from_fn(f: impl FnMut(usize) -> Self::F) -> Self

Builds a vector from a function of coordinate index. The canonical constructor — most other constructors reduce to this.

const N: usize = <Self::Array<Self::F>>::N

The dimension of the space — the number of coordinates.

fn iter(&self) -> <Self::Array<Self::F> as Array<Self::F>>::Iter<'_>

Iterates the N coordinates in order.

fn map(&self, f: impl FnMut(Self::F) -> Self::F) -> Self

Applies f to each coordinate of V

fn pairing(&self, rhs: &Dual<Self>) -> Self::F

The canonical evaluation pairing (V, V*) -> F, ⟨v, ω⟩ = ω(v).

fn from_iter(iter: impl IntoIterator<Item = Self::F>) -> Self

Constructs a tensor from its coordinates in canonical flat-index order.

fn flatten_index<const R: usize>(index: [usize; R]) -> usize

fn check_global_chart(p: &Self, q: &Self) -> bool

fn check_global_geodesic_scaling( p: &Self, v: Self, t: <Self::F as Field>::Fixed, ) -> bool

where Self: Vector + PartialEq,

impl<F: Field, const N: usize, const M: usize> Zero for Coords<F, N, M>

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<F: Field, const N: usize, const M: usize> ι for Coords<F, N, M>

type C = ReflectedContext<𝒞, Coords<F, N, M>>