# Euclidean space

The Euclidean space $ℝ^n$ is a simple model space, since it has curvature constantly zero everywhere; hence, nearly all operations simplify. The easiest way to generate an Euclidean space is to use a field, i.e. `AbstractNumbers`

, e.g. to create the $ℝ^n$ or $ℝ^{n\times n}$ you can simply type `M = ℝ^n`

or `ℝ^(n,n)`

, respectively.

`Manifolds.Euclidean`

— Type`Euclidean{T<:Tuple,𝔽} <: AbstractManifold{𝔽}`

Euclidean vector space.

**Constructor**

`Euclidean(n)`

Generate the $n$-dimensional vector space $ℝ^n$.

```
Euclidean(n₁,n₂,...,nᵢ; field=ℝ)
𝔽^(n₁,n₂,...,nᵢ) = Euclidean(n₁,n₂,...,nᵢ; field=𝔽)
```

Generate the vector space of $k = n_1 \cdot n_2 \cdot … \cdot n_i$ values, i.e. the manifold $𝔽^{n_1, n_2, …, n_i}$, $𝔽\in\{ℝ,ℂ\}$, whose elements are interpreted as $n_1 × n_2 × … × n_i$ arrays. For $i=2$ we obtain a matrix space. The default `field=ℝ`

can also be set to `field=ℂ`

. The dimension of this space is $k \dim_ℝ 𝔽$, where $\dim_ℝ 𝔽$ is the `real_dimension`

of the field $𝔽$.

`Euclidean(; field=ℝ)`

Generate the 1D Euclidean manifold for an `ℝ`

-, `ℂ`

-valued real- or complex-valued immutable values (in contrast to 1-element arrays from the constructor above).

`Base.exp`

— Method`exp(M::Euclidean, p, X)`

Compute the exponential map on the `Euclidean`

manifold `M`

from `p`

in direction `X`

, which in this case is just

\[\exp_p X = p + X.\]

`Base.log`

— Method`log(M::Euclidean, p, q)`

Compute the logarithmic map on the `Euclidean`

`M`

from `p`

to `q`

, which in this case is just

\[\log_p q = q-p.\]

`LinearAlgebra.norm`

— Method`norm(M::Euclidean, p, X)`

Compute the norm of a tangent vector `X`

at `p`

on the `Euclidean`

`M`

, i.e. since every tangent space can be identified with `M`

itself in this case, just the (Frobenius) norm of `X`

.

`ManifoldsBase.distance`

— Method`distance(M::Euclidean, p, q)`

Compute the Euclidean distance between two points on the `Euclidean`

manifold `M`

, i.e. for vectors it's just the norm of the difference, for matrices and higher order arrays, the matrix and ternsor Frobenius norm, respectively.

`ManifoldsBase.embed`

— Method`embed(M::Euclidean, p, X)`

Embed the tangent vector `X`

at point `p`

in `M`

. Equivalent to an identity map.

`ManifoldsBase.embed`

— Method`embed(M::Euclidean, p)`

Embed the point `p`

in `M`

. Equivalent to an identity map.

`ManifoldsBase.injectivity_radius`

— Method`injectivity_radius(M::Euclidean)`

Return the injectivity radius on the `Euclidean`

`M`

, which is $∞$.

`ManifoldsBase.inner`

— Method`inner(M::Euclidean, p, X, Y)`

Compute the inner product on the `Euclidean`

`M`

, which is just the inner product on the real-valued or complex valued vector space of arrays (or tensors) of size $n_1 × n_2 × … × n_i$, i.e.

\[g_p(X,Y) = \sum_{k ∈ I} \overline{X}_{k} Y_{k},\]

where $I$ is the set of vectors $k ∈ ℕ^i$, such that for all

$i ≤ j ≤ i$ it holds $1 ≤ k_j ≤ n_j$ and $\overline{\cdot}$ denotes the complex conjugate.

For the special case of $i ≤ 2$, i.e. matrices and vectors, this simplifies to

\[g_p(X,Y) = X^{\mathrm{H}}Y,\]

where $\cdot^{\mathrm{H}}$ denotes the Hermitian, i.e. complex conjugate transposed.

`ManifoldsBase.is_flat`

— Method`is_flat(::Euclidean)`

Return true. `Euclidean`

is a flat manifold.

`ManifoldsBase.manifold_dimension`

— Method`manifold_dimension(M::Euclidean)`

Return the manifold dimension of the `Euclidean`

`M`

, i.e. the product of all array dimensions and the `real_dimension`

of the underlying number system.

`ManifoldsBase.parallel_transport_along`

— Method`parallel_transport_along(M::Euclidean, p, X, c)`

the parallel transport on `Euclidean`

is the identiy, i.e. returns `X`

.

`ManifoldsBase.parallel_transport_direction`

— Method`parallel_transport_direction(M::Euclidean, p, X, d)`

the parallel transport on `Euclidean`

is the identiy, i.e. returns `X`

.

`ManifoldsBase.parallel_transport_to`

— Method`parallel_transport_to(M::Euclidean, p, X, q)`

the parallel transport on `Euclidean`

is the identiy, i.e. returns `X`

.

`ManifoldsBase.project`

— Method`project(M::Euclidean, p, X)`

Project an arbitrary vector `X`

into the tangent space of a point `p`

on the `Euclidean`

`M`

, which is just the identity, since any tangent space of `M`

can be identified with all of `M`

.

`ManifoldsBase.project`

— Method`project(M::Euclidean, p)`

Project an arbitrary point `p`

onto the `Euclidean`

manifold `M`

, which is of course just the identity map.

`ManifoldsBase.representation_size`

— Method`representation_size(M::Euclidean)`

Return the array dimensions required to represent an element on the `Euclidean`

`M`

, i.e. the vector of all array dimensions.

`ManifoldsBase.riemann_tensor`

— Method`riemann_tensor(M::Euclidean, p, X, Y, Z)`

Compute the Riemann tensor $R(X,Y)Z$ at point `p`

on `Euclidean`

manifold `M`

. Its value is always the zero tangent vector. ````

`ManifoldsBase.vector_transport_to`

— Method`vector_transport_to(M::Euclidean, p, X, q, ::AbstractVectorTransportMethod)`

Transport the vector `X`

from the tangent space at `p`

to the tangent space at `q`

on the `Euclidean`

`M`

, which simplifies to the identity.

`ManifoldsBase.zero_vector`

— Method`zero_vector(M::Euclidean, x)`

Return the zero vector in the tangent space of `x`

on the `Euclidean`

`M`

, which here is just a zero filled array the same size as `x`

.