diff --git a/src/Mathematics.NET/AutoDiff/Dual.cs b/src/Mathematics.NET/AutoDiff/Dual.cs
index 7d532f74..c7595994 100644
--- a/src/Mathematics.NET/AutoDiff/Dual.cs
+++ b/src/Mathematics.NET/AutoDiff/Dual.cs
@@ -27,6 +27,9 @@
 
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.InteropServices;
+using Mathematics.NET.DifferentialGeometry;
+using Mathematics.NET.DifferentialGeometry.Abstractions;
+using Mathematics.NET.LinearAlgebra;
 
 namespace Mathematics.NET.AutoDiff;
 
@@ -248,4 +251,32 @@ public static Dual<T> Tan(Dual<T> x)
     /// <returns>A dual number.</returns>
     public static Dual<T> CustomOperation(Dual<T> x, Dual<T> y, Func<T, T, T> f, Func<T, T, T> dfx, Func<T, T, T> dfy)
         => new(f(x._d0, y._d0), dfy(x._d0, y._d0) * x._d1 + dfx(x._d0, y._d1) * y._d1);
+
+    //
+    // DifGeo
+    //
+
+    public static AutoDiffTensor2<Dual<T>, T, U> CreateAutoDiffTensor<U>(in Vector2<T> x, in Vector2<T> seed)
+        where U : IIndex
+        => new(CreateVariable(x.X1, seed.X1), CreateVariable(x.X2, seed.X2));
+
+    public static AutoDiffTensor2<Dual<T>, T, U> CreateAutoDiffTensor<U>(in T x0, in T x1, in T seed0, in T seed1)
+        where U : IIndex
+        => new(CreateVariable(x0, seed0), CreateVariable(x1, seed1));
+
+    public static AutoDiffTensor3<Dual<T>, T, U> CreateAutoDiffTensor<U>(in Vector3<T> x, in Vector3<T> seed)
+        where U : IIndex
+        => new(CreateVariable(x.X1, seed.X1), CreateVariable(x.X2, seed.X2), CreateVariable(x.X3, seed.X3));
+
+    public static AutoDiffTensor3<Dual<T>, T, U> CreateAutoDiffTensor<U>(in T x0, in T x1, in T x2, in T seed0, in T seed1, in T seed2)
+        where U : IIndex
+        => new(CreateVariable(x0, seed0), CreateVariable(x1, seed1), CreateVariable(x2, seed2));
+
+    public static AutoDiffTensor4<Dual<T>, T, U> CreateAutoDiffTensor<U>(in Vector4<T> x, in Vector4<T> seed)
+        where U : IIndex
+        => new(CreateVariable(x.X1, seed.X1), CreateVariable(x.X2, seed.X2), CreateVariable(x.X3, seed.X3), CreateVariable(x.X4, seed.X4));
+
+    public static AutoDiffTensor4<Dual<T>, T, U> CreateAutoDiffTensor<U>(in T x0, in T x1, in T x2, in T x3, in T seed0, in T seed1, in T seed2, in T seed3)
+        where U : IIndex
+        => new(CreateVariable(x0, seed0), CreateVariable(x1, seed1), CreateVariable(x2, seed2), CreateVariable(x3, seed3));
 }
diff --git a/src/Mathematics.NET/AutoDiff/GradientTape.cs b/src/Mathematics.NET/AutoDiff/GradientTape.cs
index 020a4286..99692d87 100644
--- a/src/Mathematics.NET/AutoDiff/GradientTape.cs
+++ b/src/Mathematics.NET/AutoDiff/GradientTape.cs
@@ -62,6 +62,9 @@
 
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using Mathematics.NET.DifferentialGeometry;
+using Mathematics.NET.DifferentialGeometry.Abstractions;
+using Mathematics.NET.LinearAlgebra;
 using Microsoft.Extensions.Logging;
 
 namespace Mathematics.NET.AutoDiff;
@@ -102,10 +105,10 @@ public GradientTape(int n, bool isTracking = true)
     // Methods
     //
 
-    public Variable<T> CreateVariable(T seed)
+    public Variable<T> CreateVariable(T value)
     {
         _nodes.Add(new(_variableCount));
-        Variable<T> variable = new(_variableCount++, seed);
+        Variable<T> variable = new(_variableCount++, value);
         return variable;
     }
 
@@ -665,4 +668,32 @@ public Variable<T> CustomOperation(Variable<T> x, Variable<T> y, Func<T, T, T> f
         }
         return new(_nodes.Count, f(x.Value, y.Value));
     }
+
+    //
+    // DifGeo
+    //
+
+    public AutoDiffTensor2<T, U> CreateAutoDiffTensor<U>(in Vector2<T> x)
+        where U : IIndex
+        => new(CreateVariable(x.X1), CreateVariable(x.X2));
+
+    public AutoDiffTensor2<T, U> CreateAutoDiffTensor<U>(in T x0, in T x1)
+        where U : IIndex
+        => new(CreateVariable(x0), CreateVariable(x1));
+
+    public AutoDiffTensor3<T, U> CreateAutoDiffTensor<U>(in Vector3<T> x)
+        where U : IIndex
+        => new(CreateVariable(x.X1), CreateVariable(x.X2), CreateVariable(x.X3));
+
+    public AutoDiffTensor3<T, U> CreateAutoDiffTensor<U>(in T x0, in T x1, in T x2)
+        where U : IIndex
+        => new(CreateVariable(x0), CreateVariable(x1), CreateVariable(x2));
+
+    public AutoDiffTensor4<T, U> CreateAutoDiffTensor<U>(in Vector4<T> x)
+        where U : IIndex
+        => new(CreateVariable(x.X1), CreateVariable(x.X2), CreateVariable(x.X3), CreateVariable(x.X4));
+
+    public AutoDiffTensor4<T, U> CreateAutoDiffTensor<U>(in T x0, in T x1, in T x2, in T x3)
+        where U : IIndex
+        => new(CreateVariable(x0), CreateVariable(x1), CreateVariable(x2), CreateVariable(x3));
 }
diff --git a/src/Mathematics.NET/AutoDiff/HessianTape.cs b/src/Mathematics.NET/AutoDiff/HessianTape.cs
index 9c3a6f09..478b7d67 100644
--- a/src/Mathematics.NET/AutoDiff/HessianTape.cs
+++ b/src/Mathematics.NET/AutoDiff/HessianTape.cs
@@ -29,6 +29,9 @@
 
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using Mathematics.NET.DifferentialGeometry;
+using Mathematics.NET.DifferentialGeometry.Abstractions;
+using Mathematics.NET.LinearAlgebra;
 using Microsoft.Extensions.Logging;
 
 namespace Mathematics.NET.AutoDiff;
@@ -69,10 +72,10 @@ public HessianTape(int n, bool isTracking = true)
     // Methods
     //
 
-    public Variable<T> CreateVariable(T seed)
+    public Variable<T> CreateVariable(T value)
     {
         _nodes.Add(new(_variableCount));
-        Variable<T> variable = new(_variableCount++, seed);
+        Variable<T> variable = new(_variableCount++, value);
         return variable;
     }
 
@@ -846,4 +849,32 @@ public Variable<T> CustomOperation(
         }
         return new(_nodes.Count, f(x.Value, y.Value));
     }
+
+    //
+    // DifGeo
+    //
+
+    public AutoDiffTensor2<T, U> CreateAutoDiffTensor<U>(in Vector2<T> x)
+        where U : IIndex
+        => new(CreateVariable(x.X1), CreateVariable(x.X2));
+
+    public AutoDiffTensor2<T, U> CreateAutoDiffTensor<U>(in T x0, in T x1)
+        where U : IIndex
+        => new(CreateVariable(x0), CreateVariable(x1));
+
+    public AutoDiffTensor3<T, U> CreateAutoDiffTensor<U>(in Vector3<T> x)
+        where U : IIndex
+        => new(CreateVariable(x.X1), CreateVariable(x.X2), CreateVariable(x.X3));
+
+    public AutoDiffTensor3<T, U> CreateAutoDiffTensor<U>(in T x0, in T x1, in T x2)
+        where U : IIndex
+        => new(CreateVariable(x0), CreateVariable(x1), CreateVariable(x2));
+
+    public AutoDiffTensor4<T, U> CreateAutoDiffTensor<U>(in Vector4<T> x)
+        where U : IIndex
+        => new(CreateVariable(x.X1), CreateVariable(x.X2), CreateVariable(x.X3), CreateVariable(x.X4));
+
+    public AutoDiffTensor4<T, U> CreateAutoDiffTensor<U>(in T x0, in T x1, in T x2, in T x3)
+        where U : IIndex
+        => new(CreateVariable(x0), CreateVariable(x1), CreateVariable(x2), CreateVariable(x3));
 }
diff --git a/src/Mathematics.NET/AutoDiff/HyperDual.cs b/src/Mathematics.NET/AutoDiff/HyperDual.cs
index 6530a6ef..b0b887a5 100644
--- a/src/Mathematics.NET/AutoDiff/HyperDual.cs
+++ b/src/Mathematics.NET/AutoDiff/HyperDual.cs
@@ -27,6 +27,9 @@
 
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.InteropServices;
+using Mathematics.NET.DifferentialGeometry;
+using Mathematics.NET.DifferentialGeometry.Abstractions;
+using Mathematics.NET.LinearAlgebra;
 
 namespace Mathematics.NET.AutoDiff;
 
@@ -275,4 +278,32 @@ public static HyperDual<T> CustomOperation(
         Func<Dual<T>, Dual<T>, Dual<T>> dfx,
         Func<Dual<T>, Dual<T>, Dual<T>> dfy)
         => new(f(x._d0, y._d0), dfy(x._d0, y._d0) * x._d1 + dfx(x._d0, y._d1) * y._d1);
+
+    //
+    // DifGeo
+    //
+
+    public static AutoDiffTensor2<HyperDual<T>, T, U> CreateAutoDiffTensor<U>(in Vector2<T> x, in Vector2<T> seed)
+        where U : IIndex
+        => new(CreateVariable(x.X1, seed.X1), CreateVariable(x.X2, seed.X2));
+
+    public static AutoDiffTensor2<HyperDual<T>, T, U> CreateAutoDiffTensor<U>(in T x0, in T x1, in T seed0, in T seed1)
+        where U : IIndex
+        => new(CreateVariable(x0, seed0), CreateVariable(x1, seed1));
+
+    public static AutoDiffTensor3<HyperDual<T>, T, U> CreateAutoDiffTensor<U>(in Vector3<T> x, in Vector3<T> seed)
+        where U : IIndex
+        => new(CreateVariable(x.X1, seed.X1), CreateVariable(x.X2, seed.X2), CreateVariable(x.X3, seed.X3));
+
+    public static AutoDiffTensor3<HyperDual<T>, T, U> CreateAutoDiffTensor<U>(in T x0, in T x1, in T x2, in T seed0, in T seed1, in T seed2)
+        where U : IIndex
+        => new(CreateVariable(x0, seed0), CreateVariable(x1, seed1), CreateVariable(x2, seed2));
+
+    public static AutoDiffTensor4<HyperDual<T>, T, U> CreateAutoDiffTensor<U>(in Vector4<T> x, in Vector4<T> seed)
+        where U : IIndex
+        => new(CreateVariable(x.X1, seed.X1), CreateVariable(x.X2, seed.X2), CreateVariable(x.X3, seed.X3), CreateVariable(x.X4, seed.X4));
+
+    public static AutoDiffTensor4<HyperDual<T>, T, U> CreateAutoDiffTensor<U>(in T x0, in T x1, in T x2, in T x3, in T seed0, in T seed1, in T seed2, in T seed3)
+        where U : IIndex
+        => new(CreateVariable(x0, seed0), CreateVariable(x1, seed1), CreateVariable(x2, seed2), CreateVariable(x3, seed3));
 }
diff --git a/src/Mathematics.NET/AutoDiff/IDual.cs b/src/Mathematics.NET/AutoDiff/IDual.cs
index d93151cb..b6605f5a 100644
--- a/src/Mathematics.NET/AutoDiff/IDual.cs
+++ b/src/Mathematics.NET/AutoDiff/IDual.cs
@@ -27,51 +27,118 @@
 
 using Mathematics.NET.Core.Operations;
 using Mathematics.NET.Core.Relations;
+using Mathematics.NET.DifferentialGeometry;
+using Mathematics.NET.DifferentialGeometry.Abstractions;
+using Mathematics.NET.LinearAlgebra;
 
 namespace Mathematics.NET.AutoDiff;
 
 /// <summary>Defines support for dual numbers.</summary>
-/// <typeparam name="T">The type that implements the interface.</typeparam>
-/// <typeparam name="U">A type that implements <see cref="IComplex{T}"/> and <see cref="IDifferentiableFunctions{T}"/>.</typeparam>
-public interface IDual<T, U>
-    : IAdditionOperation<T, T>,
-      IDivisionOperation<T, T>,
-      IMultiplicationOperation<T, T>,
-      IUnaryMinusOperation<T, T>,
-      IUnaryPlusOperation<T, T>,
-      ISubtractionOperation<T, T>,
+/// <typeparam name="TDN">The type that implements the interface.</typeparam>
+/// <typeparam name="TN">A type that implements <see cref="IComplex{T}"/> and <see cref="IDifferentiableFunctions{T}"/>.</typeparam>
+public interface IDual<TDN, TN>
+    : IAdditionOperation<TDN, TDN>,
+      IDivisionOperation<TDN, TDN>,
+      IMultiplicationOperation<TDN, TDN>,
+      IUnaryMinusOperation<TDN, TDN>,
+      IUnaryPlusOperation<TDN, TDN>,
+      ISubtractionOperation<TDN, TDN>,
       IFormattable,
-      IEqualityRelation<T, bool>,
-      IEquatable<T>,
-      IDifferentiableFunctions<T>
-    where T : IDual<T, U>
-    where U : IComplex<U>, IDifferentiableFunctions<U>
+      IEqualityRelation<TDN, bool>,
+      IEquatable<TDN>,
+      IDifferentiableFunctions<TDN>
+    where TDN : IDual<TDN, TN>
+    where TN : IComplex<TN>, IDifferentiableFunctions<TN>
 {
     /// <summary>Represents the primal part of the dual number.</summary>
-    U D0 { get; }
+    TN D0 { get; }
 
     /// <summary>Represents the tangent part of the dual number.</summary>
-    U D1 { get; }
+    TN D1 { get; }
 
     /// <summary>Create an instance of the type with a specified value.</summary>
     /// <param name="value">A value.</param>
     /// <returns>An instance of the type.</returns>
-    static abstract T CreateVariable(U value);
+    static abstract TDN CreateVariable(TN value);
 
     /// <summary>Create an instance of the type with a specified value and seed.</summary>
     /// <param name="value">A value.</param>
     /// <param name="seed">A seed.</param>
     /// <returns>An instance of the type.</returns>
-    static abstract T CreateVariable(U value, U seed);
+    static abstract TDN CreateVariable(TN value, TN seed);
 
     /// <inheritdoc cref="IDifferentiableFunctions{T}.Pow(T, T)"/>
-    static abstract T Pow(T x, U y);
+    static abstract TDN Pow(TDN x, TN y);
 
     /// <inheritdoc cref="IDifferentiableFunctions{T}.Pow(T, T)"/>
-    static abstract T Pow(U x, T y);
+    static abstract TDN Pow(TN x, TDN y);
 
     /// <summary>Create a seeded instance of this type.</summary>
     /// <param name="seed">The seed value.</param>
     /// <returns>A seeded value.</returns>
-    T WithSeed(U seed);
+    TDN WithSeed(TN seed);
+
+    //
+    // DifGeo
+    //
+
+    /// <summary>Create an autodiff, rank-one tensor from vectors of initial and seed values.</summary>
+    /// <typeparam name="TI">An index.</typeparam>
+    /// <param name="x">A vector of initial values.</param>
+    /// <param name="seed">A vector of seed values.</param>
+    /// <returns>A rank-one tensor of two initial and seed values.</returns>
+    static abstract AutoDiffTensor2<TDN, TN, TI> CreateAutoDiffTensor<TI>(in Vector2<TN> x, in Vector2<TN> seed)
+        where TI : IIndex;
+
+    /// <summary>Create an autodiff, rank-one tensor from intial and seed values.</summary>
+    /// <typeparam name="TI">An index.</typeparam>
+    /// <param name="x0">The zeroth value.</param>
+    /// <param name="x1">The first value.</param>
+    /// <param name="seed0">The zeroth seed value.</param>
+    /// <param name="seed1">The first seed value.</param>
+    /// <returns>A rank-one tensor of two initial and seed values.</returns>
+    static abstract AutoDiffTensor2<TDN, TN, TI> CreateAutoDiffTensor<TI>(in TN x0, in TN x1, in TN seed0, in TN seed1)
+        where TI : IIndex;
+
+    /// <summary>Create an autodiff, rank-one tensor from vectors of initial and seed values.</summary>
+    /// <typeparam name="TI">An index.</typeparam>
+    /// <param name="x">A vector of initial values.</param>
+    /// <param name="seed">A vector of seed values.</param>
+    /// <returns>A rank-one tensor of three initial and seed values.</returns>
+    static abstract AutoDiffTensor3<TDN, TN, TI> CreateAutoDiffTensor<TI>(in Vector3<TN> x, in Vector3<TN> seed)
+        where TI : IIndex;
+
+    /// <summary>Create an autodiff, rank-one tensor from intial and seed values.</summary>
+    /// <typeparam name="TI">An index.</typeparam>
+    /// <param name="x0">The zeroth value.</param>
+    /// <param name="x1">The first value.</param>
+    /// <param name="x2">The second value.</param>
+    /// <param name="seed0">The zeroth seed value.</param>
+    /// <param name="seed1">The first seed value.</param>
+    /// <param name="seed2">The second seed value.</param>
+    /// <returns>A rank-one tensor of three initial and seed values.</returns>
+    static abstract AutoDiffTensor3<TDN, TN, TI> CreateAutoDiffTensor<TI>(in TN x0, in TN x1, in TN x2, in TN seed0, in TN seed1, in TN seed2)
+        where TI : IIndex;
+
+    /// <summary>Create an autodiff, rank-one tensor from vectors of initial and seed values.</summary>
+    /// <typeparam name="TI">An index.</typeparam>
+    /// <param name="x">A vector of initial values.</param>
+    /// <param name="seed">A vector of seed values.</param>
+    /// <returns>A rank-one tensor of four initial and seed values.</returns>
+    static abstract AutoDiffTensor4<TDN, TN, TI> CreateAutoDiffTensor<TI>(in Vector4<TN> x, in Vector4<TN> seed)
+        where TI : IIndex;
+
+    /// <summary>Create an autodiff, rank-one tensor from intial and seed values.</summary>
+    /// <typeparam name="TI">An index.</typeparam>
+    /// <param name="x0">The zeroth value.</param>
+    /// <param name="x1">The first value.</param>
+    /// <param name="x2">The second value.</param>
+    /// <param name="x3">The third value.</param>
+    /// <param name="seed0">The zeroth seed value.</param>
+    /// <param name="seed1">The first seed value.</param>
+    /// <param name="seed2">The second seed value.</param>
+    /// <param name="seed3">The third seed value.</param>
+    /// <returns>A rank-one tensor of four initial and seed values.</returns>
+    static abstract AutoDiffTensor4<TDN, TN, TI> CreateAutoDiffTensor<TI>(in TN x0, in TN x1, in TN x2, in TN x3, in TN seed0, in TN seed1, in TN seed2, in TN seed3)
+        where TI : IIndex;
 }
diff --git a/src/Mathematics.NET/AutoDiff/ITape.cs b/src/Mathematics.NET/AutoDiff/ITape.cs
index 995037f5..3330c1d1 100644
--- a/src/Mathematics.NET/AutoDiff/ITape.cs
+++ b/src/Mathematics.NET/AutoDiff/ITape.cs
@@ -25,6 +25,9 @@
 // SOFTWARE.
 // </copyright>
 
+using Mathematics.NET.DifferentialGeometry;
+using Mathematics.NET.DifferentialGeometry.Abstractions;
+using Mathematics.NET.LinearAlgebra;
 using Microsoft.Extensions.Logging;
 
 namespace Mathematics.NET.AutoDiff;
@@ -35,35 +38,35 @@ public interface ITape<T>
     where T : IComplex<T>, IDifferentiableFunctions<T>
 {
     /// <summary>This property indicates whether or not the tape is currently tracking nodes.</summary>
-    public bool IsTracking { get; set; }
+    bool IsTracking { get; set; }
 
     /// <summary>Get the number of nodes on the gradient tape.</summary>
-    public int NodeCount { get; }
+    int NodeCount { get; }
 
     /// <summary>Get the number of variables that are being tracked.</summary>
-    public int VariableCount { get; }
+    int VariableCount { get; }
 
     /// <summary>Create a variable for the gradient tape to track.</summary>
-    /// <param name="seed">A seed value.</param>
+    /// <param name="value">An initial value.</param>
     /// <returns>A variable.</returns>
-    public Variable<T> CreateVariable(T seed);
+    Variable<T> CreateVariable(T value);
 
     /// <summary>Log nodes tracked by the tape.</summary>
     /// <param name="logger">A logger.</param>
     /// <param name="cancellationToken">A cancellation token.</param>
     /// <param name="limit">The total number of nodes to log.</param>
-    public void LogNodes(ILogger<ITape<T>> logger, CancellationToken cancellationToken, int limit = 100);
+    void LogNodes(ILogger<ITape<T>> logger, CancellationToken cancellationToken, int limit = 100);
 
     /// <summary>Perform reverse accumulation on the gradient or Hessian tape and output the resulting gradient.</summary>
     /// <param name="gradient">The gradient.</param>
     /// <exception cref="Exception">The gradient tape does not have any tracked variables.</exception>
-    public void ReverseAccumulate(out ReadOnlySpan<T> gradient);
+    void ReverseAccumulate(out ReadOnlySpan<T> gradient);
 
     /// <summary>Perform reverse accumulation on the gradient or Hessian tape and output the resulting gradient.</summary>
     /// <param name="gradient">The gradient.</param>
     /// <param name="seed">A seed value.</param>
     /// <exception cref="Exception">The gradient tape does not have any tracked variables.</exception>
-    public void ReverseAccumulate(out ReadOnlySpan<T> gradient, T seed);
+    void ReverseAccumulate(out ReadOnlySpan<T> gradient, T seed);
 
     //
     // Basic operations
@@ -73,91 +76,91 @@ public interface ITape<T>
     /// <param name="x">The first variable.</param>
     /// <param name="y">The second variable.</param>
     /// <returns>A variable.</returns>
-    public Variable<T> Add(Variable<T> x, Variable<T> y);
+    Variable<T> Add(Variable<T> x, Variable<T> y);
 
     /// <summary>Add a constant value and a variable.</summary>
     /// <param name="c">A constant value.</param>
     /// <param name="x">A variable.</param>
     /// <returns>A variable.</returns>
-    public Variable<T> Add(T c, Variable<T> x);
+    Variable<T> Add(T c, Variable<T> x);
 
     /// <summary>Add a variable and a constant value.</summary>
     /// <param name="x">A variable.</param>
     /// <param name="c">A constant value.</param>
     /// <returns>A variable.</returns>
-    public Variable<T> Add(Variable<T> x, T c);
+    Variable<T> Add(Variable<T> x, T c);
 
     /// <summary>Divide two variables.</summary>
     /// <param name="x">A dividend.</param>
     /// <param name="y">A divisor.</param>
     /// <returns>A variable.</returns>
-    public Variable<T> Divide(Variable<T> x, Variable<T> y);
+    Variable<T> Divide(Variable<T> x, Variable<T> y);
 
     /// <summary>Divide a constant value by a variable.</summary>
     /// <param name="c">A constant dividend.</param>
     /// <param name="x">A variable divisor.</param>
     /// <returns>A variable.</returns>
-    public Variable<T> Divide(T c, Variable<T> x);
+    Variable<T> Divide(T c, Variable<T> x);
 
     /// <summary>Divide a variable by a constant value.</summary>
     /// <param name="x">A variable dividend.</param>
     /// <param name="c">A constant divisor.</param>
     /// <returns>A variabl.</returns>
-    public Variable<T> Divide(Variable<T> x, T c);
+    Variable<T> Divide(Variable<T> x, T c);
 
     /// <summary>Compute the modulo of a variable given a divisor.</summary>
     /// <param name="x">A dividend.</param>
     /// <param name="y">A divisor.</param>
     /// <returns><paramref name="x"/> mod <paramref name="y"/>.</returns>
-    public Variable<Real> Modulo(in Variable<Real> x, in Variable<Real> y);
+    Variable<Real> Modulo(in Variable<Real> x, in Variable<Real> y);
 
     /// <summary>Compute the modulo of a real value given a divisor.</summary>
     /// <param name="c">A real dividend.</param>
     /// <param name="x">A variable divisor.</param>
     /// <returns><paramref name="c"/> mod <paramref name="x"/>.</returns>
-    public Variable<Real> Modulo(Real c, in Variable<Real> x);
+    Variable<Real> Modulo(Real c, in Variable<Real> x);
 
     /// <summary>Compute the modulo of a variable given a divisor.</summary>
     /// <param name="x">A variable dividend.</param>
     /// <param name="c">A real divisor.</param>
     /// <returns><paramref name="x"/> mod <paramref name="c"/>.</returns>
-    public Variable<Real> Modulo(in Variable<Real> x, Real c);
+    Variable<Real> Modulo(in Variable<Real> x, Real c);
 
     /// <summary>Multiply two variables.</summary>
     /// <param name="x">The first variable.</param>
     /// <param name="y">The second variable.</param>
     /// <returns>A variable.</returns>
-    public Variable<T> Multiply(Variable<T> x, Variable<T> y);
+    Variable<T> Multiply(Variable<T> x, Variable<T> y);
 
     /// <summary>Multiply a constant value by a variable.</summary>
     /// <param name="c">A constant value.</param>
     /// <param name="x">A variable.</param>
     /// <returns>A variable.</returns>
-    public Variable<T> Multiply(T c, Variable<T> x);
+    Variable<T> Multiply(T c, Variable<T> x);
 
     /// <summary>Multiply a variable by a constant value.</summary>
     /// <param name="x">A variable.</param>
     /// <param name="c">A constant value.</param>
     /// <returns>A variable.</returns>
-    public Variable<T> Multiply(Variable<T> x, T c);
+    Variable<T> Multiply(Variable<T> x, T c);
 
     /// <summary>Subract two variables.</summary>
     /// <param name="x">The first variable.</param>
     /// <param name="y">The second variable.</param>
     /// <returns>A variable.</returns>
-    public Variable<T> Subtract(Variable<T> x, Variable<T> y);
+    Variable<T> Subtract(Variable<T> x, Variable<T> y);
 
     /// <summary>Subtract a variable from a constant value.</summary>
     /// <param name="c">A constant value.</param>
     /// <param name="x">A variable.</param>
     /// <returns>A variable.</returns>
-    public Variable<T> Subtract(T c, Variable<T> x);
+    Variable<T> Subtract(T c, Variable<T> x);
 
     /// <summary>Subtract a constant value from a variable.</summary>
     /// <param name="x">A variable.</param>
     /// <param name="c">A constant value.</param>
     /// <returns>A variable.</returns>
-    public Variable<T> Subtract(Variable<T> x, T c);
+    Variable<T> Subtract(Variable<T> x, T c);
 
     //
     // Other operations
@@ -166,95 +169,147 @@ public interface ITape<T>
     /// <summary>Negate a variable.</summary>
     /// <param name="x">A variable.</param>
     /// <returns>Minus one times the variable.</returns>
-    public Variable<T> Negate(Variable<T> x);
+    Variable<T> Negate(Variable<T> x);
 
     // Exponential functions
 
     /// <inheritdoc cref="IDifferentiableFunctions{T}.Exp(T)"/>
-    public Variable<T> Exp(Variable<T> x);
+    Variable<T> Exp(Variable<T> x);
 
     /// <inheritdoc cref="IDifferentiableFunctions{T}.Exp2(T)"/>
-    public Variable<T> Exp2(Variable<T> x);
+    Variable<T> Exp2(Variable<T> x);
 
     /// <inheritdoc cref="IDifferentiableFunctions{T}.Exp10(T)"/>
-    public Variable<T> Exp10(Variable<T> x);
+    Variable<T> Exp10(Variable<T> x);
 
     // Hyperbolic functions
 
     /// <inheritdoc cref="IDifferentiableFunctions{T}.Acosh(T)"/>
-    public Variable<T> Acosh(Variable<T> x);
+    Variable<T> Acosh(Variable<T> x);
 
     /// <inheritdoc cref="IDifferentiableFunctions{T}.Asinh(T)"/>
-    public Variable<T> Asinh(Variable<T> x);
+    Variable<T> Asinh(Variable<T> x);
 
     /// <inheritdoc cref="IDifferentiableFunctions{T}.Atanh(T)"/>
-    public Variable<T> Atanh(Variable<T> x);
+    Variable<T> Atanh(Variable<T> x);
 
     /// <inheritdoc cref="IDifferentiableFunctions{T}.Cosh(T)"/>
-    public Variable<T> Cosh(Variable<T> x);
+    Variable<T> Cosh(Variable<T> x);
 
     /// <inheritdoc cref="IDifferentiableFunctions{T}.Sinh(T)"/>
-    public Variable<T> Sinh(Variable<T> x);
+    Variable<T> Sinh(Variable<T> x);
 
     /// <inheritdoc cref="IDifferentiableFunctions{T}.Tanh(T)"/>
-    public Variable<T> Tanh(Variable<T> x);
+    Variable<T> Tanh(Variable<T> x);
 
     // Logarithmic functions
 
     /// <inheritdoc cref="IDifferentiableFunctions{T}.Ln(T)"/>
-    public Variable<T> Ln(Variable<T> x);
+    Variable<T> Ln(Variable<T> x);
 
     /// <inheritdoc cref="IDifferentiableFunctions{T}.Log(T, T)"/>
-    public Variable<T> Log(Variable<T> x, Variable<T> b);
+    Variable<T> Log(Variable<T> x, Variable<T> b);
 
     /// <inheritdoc cref="IDifferentiableFunctions{T}.Log2(T)"/>
-    public Variable<T> Log2(Variable<T> x);
+    Variable<T> Log2(Variable<T> x);
 
     /// <inheritdoc cref="IDifferentiableFunctions{T}.Log10(T)"/>
-    public Variable<T> Log10(Variable<T> x);
+    Variable<T> Log10(Variable<T> x);
 
     // Power functions
 
     /// <inheritdoc cref="IDifferentiableFunctions{T}.Pow(T, T)"/>
-    public Variable<T> Pow(Variable<T> x, Variable<T> y);
+    Variable<T> Pow(Variable<T> x, Variable<T> y);
 
     /// <inheritdoc cref="IDifferentiableFunctions{T}.Pow(T, T)"/>
-    public Variable<T> Pow(Variable<T> x, T y);
+    Variable<T> Pow(Variable<T> x, T y);
 
     /// <inheritdoc cref="IDifferentiableFunctions{T}.Pow(T, T)"/>
-    public Variable<T> Pow(T x, Variable<T> y);
+    Variable<T> Pow(T x, Variable<T> y);
 
     // Root functions
 
     /// <inheritdoc cref="IDifferentiableFunctions{T}.Cbrt(T)"/>
-    public Variable<T> Cbrt(Variable<T> x);
+    Variable<T> Cbrt(Variable<T> x);
 
     /// <inheritdoc cref="IDifferentiableFunctions{T}.Root(T, T)"/>
-    public Variable<T> Root(Variable<T> x, Variable<T> n);
+    Variable<T> Root(Variable<T> x, Variable<T> n);
 
     /// <inheritdoc cref="IDifferentiableFunctions{T}.Sqrt(T)"/>
-    public Variable<T> Sqrt(Variable<T> x);
+    Variable<T> Sqrt(Variable<T> x);
 
     // Trigonometric function
 
     /// <inheritdoc cref="IDifferentiableFunctions{T}.Acos(T)"/>
-    public Variable<T> Acos(Variable<T> x);
+    Variable<T> Acos(Variable<T> x);
 
     /// <inheritdoc cref="IDifferentiableFunctions{T}.Asin(T)"/>
-    public Variable<T> Asin(Variable<T> x);
+    Variable<T> Asin(Variable<T> x);
 
     /// <inheritdoc cref="IDifferentiableFunctions{T}.Atan(T)"/>
-    public Variable<T> Atan(Variable<T> x);
+    Variable<T> Atan(Variable<T> x);
 
     /// <inheritdoc cref="IReal{T}.Atan2(T, T)"/>
-    public Variable<Real> Atan2(in Variable<Real> y, in Variable<Real> x);
+    Variable<Real> Atan2(in Variable<Real> y, in Variable<Real> x);
 
     /// <inheritdoc cref="IDifferentiableFunctions{T}.Cos(T)"/>
-    public Variable<T> Cos(Variable<T> x);
+    Variable<T> Cos(Variable<T> x);
 
     /// <inheritdoc cref="IDifferentiableFunctions{T}.Sin(T)"/>
-    public Variable<T> Sin(Variable<T> x);
+    Variable<T> Sin(Variable<T> x);
 
     /// <inheritdoc cref="IDifferentiableFunctions{T}.Tan(T)"/>
-    public Variable<T> Tan(Variable<T> x);
+    Variable<T> Tan(Variable<T> x);
+
+    //
+    // DifGeo
+    //
+
+    /// <summary>Create an autodiff, rank-one tensor from a vector of initial values.</summary>
+    /// <typeparam name="U">An index.</typeparam>
+    /// <param name="x">A vector of initial values.</param>
+    /// <returns>A rank-one tensor of two variables.</returns>
+    AutoDiffTensor2<T, U> CreateAutoDiffTensor<U>(in Vector2<T> x)
+        where U : IIndex;
+
+    /// <summary>Create an autodiff, rank-one tensor from initial values.</summary>
+    /// <typeparam name="U">An index.</typeparam>
+    /// <param name="x0">The zeroth value.</param>
+    /// <param name="x1">The first value.</param>
+    /// <returns>A rank-one tensor of two variables.</returns>
+    AutoDiffTensor2<T, U> CreateAutoDiffTensor<U>(in T x0, in T x1)
+        where U : IIndex;
+
+    /// <summary>Create an autodiff, rank-one tensor from a vector of initial values.</summary>
+    /// <typeparam name="U">An index.</typeparam>
+    /// <param name="x">A vector of initial values.</param>
+    /// <returns>A rank-one tensor of three variables.</returns>
+    AutoDiffTensor3<T, U> CreateAutoDiffTensor<U>(in Vector3<T> x)
+        where U : IIndex;
+
+    /// <summary>Create an autodiff, rank-one tensor from initial values.</summary>
+    /// <typeparam name="U">An index.</typeparam>
+    /// <param name="x0">The zeroth value.</param>
+    /// <param name="x1">The first value.</param>
+    /// <param name="x2">The second value.</param>
+    /// <returns>A rank-one tensor of three variables.</returns>
+    AutoDiffTensor3<T, U> CreateAutoDiffTensor<U>(in T x0, in T x1, in T x2)
+        where U : IIndex;
+
+    /// <summary>Create an autodiff, rank-one tensor from a vector of initial values.</summary>
+    /// <typeparam name="U">An index.</typeparam>
+    /// <param name="x">A vector of initial values.</param>
+    /// <returns>A rank-one tensor of four variables.</returns>
+    AutoDiffTensor4<T, U> CreateAutoDiffTensor<U>(in Vector4<T> x)
+        where U : IIndex;
+
+    /// <summary>Create an autodiff, rank-one tensor from initial values.</summary>
+    /// <typeparam name="U">An index.</typeparam>
+    /// <param name="x0">The zeroth value.</param>
+    /// <param name="x1">The first value.</param>
+    /// <param name="x2">The second value.</param>
+    /// <param name="x3">The third value.</param>
+    /// <returns>A rank-one tensor of four variables.</returns>
+    AutoDiffTensor4<T, U> CreateAutoDiffTensor<U>(in T x0, in T x1, in T x2, in T x3)
+        where U : IIndex;
 }
diff --git a/src/Mathematics.NET/Core/Buffers/FMTensor4Buffer4.cs b/src/Mathematics.NET/Core/Buffers/FMTensor4Buffer4.cs
new file mode 100644
index 00000000..ef453315
--- /dev/null
+++ b/src/Mathematics.NET/Core/Buffers/FMTensor4Buffer4.cs
@@ -0,0 +1,44 @@
+// <copyright file="FMTensor4Buffer4.cs" company="Mathematics.NET">
+// Mathematics.NET
+// https://github.com/HamletTanyavong/Mathematics.NET
+//
+// MIT License
+//
+// Copyright (c) 2023-present Hamlet Tanyavong
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+// </copyright>
+
+#pragma warning disable IDE0051
+
+using System.Runtime.CompilerServices;
+using Mathematics.NET.AutoDiff;
+using Mathematics.NET.DifferentialGeometry;
+using Mathematics.NET.DifferentialGeometry.Abstractions;
+
+namespace Mathematics.NET.Core.Buffers;
+
+[InlineArray(4)]
+internal struct FMTensor4Buffer4<TDN, TN, TPI>
+    where TDN : IDual<TDN, TN>
+    where TN : IComplex<TN>, IDifferentiableFunctions<TN>
+    where TPI : IIndex
+{
+    private Func<AutoDiffTensor4<TDN, TN, TPI>, TDN> _element0;
+}
diff --git a/src/Mathematics.NET/Core/Buffers/AutoDiffTensor2Buffer2.cs b/src/Mathematics.NET/Core/Buffers/RMTensor2Buffer2.cs
similarity index 94%
rename from src/Mathematics.NET/Core/Buffers/AutoDiffTensor2Buffer2.cs
rename to src/Mathematics.NET/Core/Buffers/RMTensor2Buffer2.cs
index fc723d85..a35aced6 100644
--- a/src/Mathematics.NET/Core/Buffers/AutoDiffTensor2Buffer2.cs
+++ b/src/Mathematics.NET/Core/Buffers/RMTensor2Buffer2.cs
@@ -1,4 +1,4 @@
-// <copyright file="AutoDiffTensor2Buffer2.cs" company="Mathematics.NET">
+// <copyright file="RMTensor2Buffer2.cs" company="Mathematics.NET">
 // Mathematics.NET
 // https://github.com/HamletTanyavong/Mathematics.NET
 //
@@ -39,7 +39,7 @@ namespace Mathematics.NET.Core.Buffers;
 /// <typeparam name="TN">A type that implements <see cref="IComplex{T}"/> and <see cref="IDifferentiableFunctions{T}"/>.</typeparam>
 /// <typeparam name="TPI">The index of the point on the manifold.</typeparam>
 [InlineArray(2)]
-internal struct AutoDiffTensor2Buffer2<TT, TN, TPI>
+internal struct RMTensor2Buffer2<TT, TN, TPI>
     where TT : ITape<TN>
     where TN : IComplex<TN>, IDifferentiableFunctions<TN>
     where TPI : IIndex
diff --git a/src/Mathematics.NET/Core/Buffers/AutoDiffTensor2Buffer2x2.cs b/src/Mathematics.NET/Core/Buffers/RMTensor2Buffer2x2.cs
similarity index 87%
rename from src/Mathematics.NET/Core/Buffers/AutoDiffTensor2Buffer2x2.cs
rename to src/Mathematics.NET/Core/Buffers/RMTensor2Buffer2x2.cs
index c0992090..ac4b578e 100644
--- a/src/Mathematics.NET/Core/Buffers/AutoDiffTensor2Buffer2x2.cs
+++ b/src/Mathematics.NET/Core/Buffers/RMTensor2Buffer2x2.cs
@@ -1,4 +1,4 @@
-// <copyright file="AutoDiffTensor2Buffer2x2.cs" company="Mathematics.NET">
+// <copyright file="RMTensor2Buffer2x2.cs" company="Mathematics.NET">
 // Mathematics.NET
 // https://github.com/HamletTanyavong/Mathematics.NET
 //
@@ -33,15 +33,15 @@
 
 namespace Mathematics.NET.Core.Buffers;
 
-/// <summary>Represents a buffer of 2 AutoDiffTensor2Buffer2 buffers.</summary>
+/// <summary>Represents a buffer of 2 RMTensor2Buffer2 buffers.</summary>
 /// <typeparam name="TT">A type that implements <see cref="ITape{T}"/>.</typeparam>
 /// <typeparam name="TN">A type that implements <see cref="IComplex{T}"/> and <see cref="IDifferentiableFunctions{T}"/>.</typeparam>
 /// <typeparam name="TPI">The index of the point on the manifold.</typeparam>
 [InlineArray(2)]
-internal struct AutoDiffTensor2Buffer2x2<TT, TN, TPI>
+internal struct RMTensor2Buffer2x2<TT, TN, TPI>
     where TT : ITape<TN>
     where TN : IComplex<TN>, IDifferentiableFunctions<TN>
     where TPI : IIndex
 {
-    private AutoDiffTensor2Buffer2<TT, TN, TPI> _element0;
+    private RMTensor2Buffer2<TT, TN, TPI> _element0;
 }
diff --git a/src/Mathematics.NET/Core/Buffers/AutoDiffTensor3Buffer3.cs b/src/Mathematics.NET/Core/Buffers/RMTensor3Buffer3.cs
similarity index 94%
rename from src/Mathematics.NET/Core/Buffers/AutoDiffTensor3Buffer3.cs
rename to src/Mathematics.NET/Core/Buffers/RMTensor3Buffer3.cs
index ecad4276..7c044d13 100644
--- a/src/Mathematics.NET/Core/Buffers/AutoDiffTensor3Buffer3.cs
+++ b/src/Mathematics.NET/Core/Buffers/RMTensor3Buffer3.cs
@@ -1,4 +1,4 @@
-// <copyright file="AutoDiffTensor3Buffer3.cs" company="Mathematics.NET">
+// <copyright file="RMTensor3Buffer3.cs" company="Mathematics.NET">
 // Mathematics.NET
 // https://github.com/HamletTanyavong/Mathematics.NET
 //
@@ -39,7 +39,7 @@ namespace Mathematics.NET.Core.Buffers;
 /// <typeparam name="TN">A type that implements <see cref="IComplex{T}"/> and <see cref="IDifferentiableFunctions{T}"/>.</typeparam>
 /// <typeparam name="TPI">The index of the point on the manifold.</typeparam>
 [InlineArray(3)]
-internal struct AutoDiffTensor3Buffer3<TT, TN, TPI>
+internal struct RMTensor3Buffer3<TT, TN, TPI>
     where TT : ITape<TN>
     where TN : IComplex<TN>, IDifferentiableFunctions<TN>
     where TPI : IIndex
diff --git a/src/Mathematics.NET/Core/Buffers/AutoDiffTensor3Buffer3x3.cs b/src/Mathematics.NET/Core/Buffers/RMTensor3Buffer3x3.cs
similarity index 87%
rename from src/Mathematics.NET/Core/Buffers/AutoDiffTensor3Buffer3x3.cs
rename to src/Mathematics.NET/Core/Buffers/RMTensor3Buffer3x3.cs
index 018032fa..05d05b60 100644
--- a/src/Mathematics.NET/Core/Buffers/AutoDiffTensor3Buffer3x3.cs
+++ b/src/Mathematics.NET/Core/Buffers/RMTensor3Buffer3x3.cs
@@ -1,4 +1,4 @@
-// <copyright file="AutoDiffTensor3Buffer3x3.cs" company="Mathematics.NET">
+// <copyright file="RMTensor3Buffer3x3.cs" company="Mathematics.NET">
 // Mathematics.NET
 // https://github.com/HamletTanyavong/Mathematics.NET
 //
@@ -33,15 +33,15 @@
 
 namespace Mathematics.NET.Core.Buffers;
 
-/// <summary>Represents a buffer of 3 AutoDiffTensor3Buffer3 buffers.</summary>
+/// <summary>Represents a buffer of 3 RMTensor3Buffer3 buffers.</summary>
 /// <typeparam name="TT">A type that implements <see cref="ITape{T}"/>.</typeparam>
 /// <typeparam name="TN">A type that implements <see cref="IComplex{T}"/> and <see cref="IDifferentiableFunctions{T}"/>.</typeparam>
 /// <typeparam name="TPI">The index of the point on the manifold.</typeparam>
 [InlineArray(3)]
-internal struct AutoDiffTensor3Buffer3x3<TT, TN, TPI>
+internal struct RMTensor3Buffer3x3<TT, TN, TPI>
     where TT : ITape<TN>
     where TN : IComplex<TN>, IDifferentiableFunctions<TN>
     where TPI : IIndex
 {
-    private AutoDiffTensor3Buffer3<TT, TN, TPI> _element0;
+    private RMTensor3Buffer3<TT, TN, TPI> _element0;
 }
diff --git a/src/Mathematics.NET/Core/Buffers/AutoDiffTensor4Buffer4.cs b/src/Mathematics.NET/Core/Buffers/RMTensor4Buffer4.cs
similarity index 94%
rename from src/Mathematics.NET/Core/Buffers/AutoDiffTensor4Buffer4.cs
rename to src/Mathematics.NET/Core/Buffers/RMTensor4Buffer4.cs
index c4145966..77218a6a 100644
--- a/src/Mathematics.NET/Core/Buffers/AutoDiffTensor4Buffer4.cs
+++ b/src/Mathematics.NET/Core/Buffers/RMTensor4Buffer4.cs
@@ -1,4 +1,4 @@
-// <copyright file="AutoDiffTensor4Buffer4.cs" company="Mathematics.NET">
+// <copyright file="RMTensor4Buffer4.cs" company="Mathematics.NET">
 // Mathematics.NET
 // https://github.com/HamletTanyavong/Mathematics.NET
 //
@@ -39,7 +39,7 @@ namespace Mathematics.NET.Core.Buffers;
 /// <typeparam name="TN">A type that implements <see cref="IComplex{T}"/> and <see cref="IDifferentiableFunctions{T}"/>.</typeparam>
 /// <typeparam name="TPI">The index of the point on the manifold.</typeparam>
 [InlineArray(4)]
-internal struct AutoDiffTensor4Buffer4<TT, TN, TPI>
+internal struct RMTensor4Buffer4<TT, TN, TPI>
     where TT : ITape<TN>
     where TN : IComplex<TN>, IDifferentiableFunctions<TN>
     where TPI : IIndex
diff --git a/src/Mathematics.NET/Core/Buffers/AutoDiffTensor4Buffer4x4.cs b/src/Mathematics.NET/Core/Buffers/RMTensor4Buffer4x4.cs
similarity index 87%
rename from src/Mathematics.NET/Core/Buffers/AutoDiffTensor4Buffer4x4.cs
rename to src/Mathematics.NET/Core/Buffers/RMTensor4Buffer4x4.cs
index f37c4696..d059be09 100644
--- a/src/Mathematics.NET/Core/Buffers/AutoDiffTensor4Buffer4x4.cs
+++ b/src/Mathematics.NET/Core/Buffers/RMTensor4Buffer4x4.cs
@@ -1,4 +1,4 @@
-// <copyright file="AutoDiffTensor4Buffer4x4.cs" company="Mathematics.NET">
+// <copyright file="RMTensor4Buffer4x4.cs" company="Mathematics.NET">
 // Mathematics.NET
 // https://github.com/HamletTanyavong/Mathematics.NET
 //
@@ -33,15 +33,15 @@
 
 namespace Mathematics.NET.Core.Buffers;
 
-/// <summary>Represents a buffer of 4 AutoDiffTensor4Buffer4 buffers.</summary>
+/// <summary>Represents a buffer of 4 RMTensor4Buffer4 buffers.</summary>
 /// <typeparam name="TT">A type that implements <see cref="ITape{T}"/>.</typeparam>
 /// <typeparam name="TN">A type that implements <see cref="IComplex{T}"/> and <see cref="IDifferentiableFunctions{T}"/>.</typeparam>
 /// <typeparam name="TPI">The index of the point on the manifold.</typeparam>
 [InlineArray(4)]
-internal struct AutoDiffTensor4Buffer4x4<TT, TN, TPI>
+internal struct RMTensor4Buffer4x4<TT, TN, TPI>
     where TT : ITape<TN>
     where TN : IComplex<TN>, IDifferentiableFunctions<TN>
     where TPI : IIndex
 {
-    private AutoDiffTensor4Buffer4<TT, TN, TPI> _element0;
+    private RMTensor4Buffer4<TT, TN, TPI> _element0;
 }
diff --git a/src/Mathematics.NET/DifferentialGeometry/DifGeo.cs b/src/Mathematics.NET/DifferentialGeometry/DifGeo.cs
index 495e1736..d35b4047 100644
--- a/src/Mathematics.NET/DifferentialGeometry/DifGeo.cs
+++ b/src/Mathematics.NET/DifferentialGeometry/DifGeo.cs
@@ -208,7 +208,7 @@ public static void Derivative<TT, TN, TPIN, TI1N, TI2N, TI3N>(
     /// <param name="dTensor">A rank-three tensor.</param>
     public static void Derivative<TT, TN, TPIN, TI2P, TI3P, TI1N, TI2N, TI3N>(
         TT tape,
-        TensorField2x2<TT, TN, TI2P, TI3P, Index<Upper, TPIN>> tensor,
+        RMTensorField2x2<TT, TN, TI2P, TI3P, Index<Upper, TPIN>> tensor,
         AutoDiffTensor2<TN, Index<Upper, TPIN>> point,
         out Tensor<Array2x2x2<TN>, TN, Index<Lower, TI1N>, Index<TI2P, TI2N>, Index<TI3P, TI3N>> dTensor)
         where TT : ITape<TN>
@@ -230,17 +230,19 @@ public static void Derivative<TT, TN, TPIN, TI2P, TI3P, TI1N, TI2N, TI3N>(
                     _ = function(tape, point);
                     tape.ReverseAccumulate(out var gradient);
 
-                    dTensor[0, i, j] = gradient[0];
-                    dTensor[1, i, j] = gradient[1];
+                    for (int k = 0; k < 2; k++)
+                    {
+                        dTensor[k, i, j] = gradient[k];
+                    }
                 }
             }
         }
     }
 
-    /// <inheritdoc cref="Derivative{TT, TN, TPIN, TI2P, TI3P, TI1N, TI2N, TI3N}(TT, TensorField2x2{TT, TN, TI2P, TI3P, Index{Upper, TPIN}}, AutoDiffTensor2{TN, Index{Upper, TPIN}}, out Tensor{Array2x2x2{TN}, TN, Index{Lower, TI1N}, Index{TI2P, TI2N}, Index{TI3P, TI3N}})"/>
+    /// <inheritdoc cref="Derivative{TT, TN, TPIN, TI2P, TI3P, TI1N, TI2N, TI3N}(TT, RMTensorField2x2{TT, TN, TI2P, TI3P, Index{Upper, TPIN}}, AutoDiffTensor2{TN, Index{Upper, TPIN}}, out Tensor{Array2x2x2{TN}, TN, Index{Lower, TI1N}, Index{TI2P, TI2N}, Index{TI3P, TI3N}})"/>
     public static void Derivative<TT, TN, TPIN, TI2P, TI3P, TI1N, TI2N, TI3N>(
         TT tape,
-        TensorField3x3<TT, TN, TI2P, TI3P, Index<Upper, TPIN>> tensor,
+        RMTensorField3x3<TT, TN, TI2P, TI3P, Index<Upper, TPIN>> tensor,
         AutoDiffTensor3<TN, Index<Upper, TPIN>> point,
         out Tensor<Array3x3x3<TN>, TN, Index<Lower, TI1N>, Index<TI2P, TI2N>, Index<TI3P, TI3N>> dTensor)
         where TT : ITape<TN>
@@ -262,18 +264,19 @@ public static void Derivative<TT, TN, TPIN, TI2P, TI3P, TI1N, TI2N, TI3N>(
                     _ = function(tape, point);
                     tape.ReverseAccumulate(out var gradient);
 
-                    dTensor[0, i, j] = gradient[0];
-                    dTensor[1, i, j] = gradient[1];
-                    dTensor[2, i, j] = gradient[2];
+                    for (int k = 0; k < 3; k++)
+                    {
+                        dTensor[k, i, j] = gradient[k];
+                    }
                 }
             }
         }
     }
 
-    /// <inheritdoc cref="Derivative{TT, TN, TPIN, TI2P, TI3P, TI1N, TI2N, TI3N}(TT, TensorField2x2{TT, TN, TI2P, TI3P, Index{Upper, TPIN}}, AutoDiffTensor2{TN, Index{Upper, TPIN}}, out Tensor{Array2x2x2{TN}, TN, Index{Lower, TI1N}, Index{TI2P, TI2N}, Index{TI3P, TI3N}})"/>
+    /// <inheritdoc cref="Derivative{TT, TN, TPIN, TI2P, TI3P, TI1N, TI2N, TI3N}(TT, RMTensorField2x2{TT, TN, TI2P, TI3P, Index{Upper, TPIN}}, AutoDiffTensor2{TN, Index{Upper, TPIN}}, out Tensor{Array2x2x2{TN}, TN, Index{Lower, TI1N}, Index{TI2P, TI2N}, Index{TI3P, TI3N}})"/>
     public static void Derivative<TT, TN, TPIN, TI2P, TI3P, TI1N, TI2N, TI3N>(
         TT tape,
-        TensorField4x4<TT, TN, TI2P, TI3P, Index<Upper, TPIN>> tensor,
+        RMTensorField4x4<TT, TN, TI2P, TI3P, Index<Upper, TPIN>> tensor,
         AutoDiffTensor4<TN, Index<Upper, TPIN>> point,
         out Tensor<Array4x4x4<TN>, TN, Index<Lower, TI1N>, Index<TI2P, TI2N>, Index<TI3P, TI3N>> dTensor)
         where TT : ITape<TN>
@@ -295,19 +298,19 @@ public static void Derivative<TT, TN, TPIN, TI2P, TI3P, TI1N, TI2N, TI3N>(
                     _ = function(tape, point);
                     tape.ReverseAccumulate(out var gradient);
 
-                    dTensor[0, i, j] = gradient[0];
-                    dTensor[1, i, j] = gradient[1];
-                    dTensor[2, i, j] = gradient[2];
-                    dTensor[3, i, j] = gradient[3];
+                    for (int k = 0; k < 4; k++)
+                    {
+                        dTensor[k, i, j] = gradient[k];
+                    }
                 }
             }
         }
     }
 
-    /// <inheritdoc cref="Derivative{TT, TN, TPIN, TI2P, TI3P, TI1N, TI2N, TI3N}(TT, TensorField2x2{TT, TN, TI2P, TI3P, Index{Upper, TPIN}}, AutoDiffTensor2{TN, Index{Upper, TPIN}}, out Tensor{Array2x2x2{TN}, TN, Index{Lower, TI1N}, Index{TI2P, TI2N}, Index{TI3P, TI3N}})"/>
+    /// <inheritdoc cref="Derivative{TT, TN, TPIN, TI2P, TI3P, TI1N, TI2N, TI3N}(TT, RMTensorField2x2{TT, TN, TI2P, TI3P, Index{Upper, TPIN}}, AutoDiffTensor2{TN, Index{Upper, TPIN}}, out Tensor{Array2x2x2{TN}, TN, Index{Lower, TI1N}, Index{TI2P, TI2N}, Index{TI3P, TI3N}})"/>
     public static void Derivative<TT, TN, TPIN, TI2P, TI3P, TI1N, TI2N, TI3N>(
         TT tape,
-        TensorField2x2<TT, TN, TI2P, TI3P, Index<Lower, TPIN>> tensor,
+        RMTensorField2x2<TT, TN, TI2P, TI3P, Index<Lower, TPIN>> tensor,
         AutoDiffTensor2<TN, Index<Lower, TPIN>> point,
         out Tensor<Array2x2x2<TN>, TN, Index<Upper, TI1N>, Index<TI2P, TI2N>, Index<TI3P, TI3N>> dTensor)
         where TT : ITape<TN>
@@ -329,17 +332,19 @@ public static void Derivative<TT, TN, TPIN, TI2P, TI3P, TI1N, TI2N, TI3N>(
                     _ = function(tape, point);
                     tape.ReverseAccumulate(out var gradient);
 
-                    dTensor[0, i, j] = gradient[0];
-                    dTensor[1, i, j] = gradient[1];
+                    for (int k = 0; k < 2; k++)
+                    {
+                        dTensor[k, i, j] = gradient[k];
+                    }
                 }
             }
         }
     }
 
-    /// <inheritdoc cref="Derivative{TT, TN, TPIN, TI2P, TI3P, TI1N, TI2N, TI3N}(TT, TensorField2x2{TT, TN, TI2P, TI3P, Index{Upper, TPIN}}, AutoDiffTensor2{TN, Index{Upper, TPIN}}, out Tensor{Array2x2x2{TN}, TN, Index{Lower, TI1N}, Index{TI2P, TI2N}, Index{TI3P, TI3N}})"/>
+    /// <inheritdoc cref="Derivative{TT, TN, TPIN, TI2P, TI3P, TI1N, TI2N, TI3N}(TT, RMTensorField2x2{TT, TN, TI2P, TI3P, Index{Upper, TPIN}}, AutoDiffTensor2{TN, Index{Upper, TPIN}}, out Tensor{Array2x2x2{TN}, TN, Index{Lower, TI1N}, Index{TI2P, TI2N}, Index{TI3P, TI3N}})"/>
     public static void Derivative<TT, TN, TPIN, TI2P, TI3P, TI1N, TI2N, TI3N>(
         TT tape,
-        TensorField3x3<TT, TN, TI2P, TI3P, Index<Lower, TPIN>> tensor,
+        RMTensorField3x3<TT, TN, TI2P, TI3P, Index<Lower, TPIN>> tensor,
         AutoDiffTensor3<TN, Index<Lower, TPIN>> point,
         out Tensor<Array3x3x3<TN>, TN, Index<Upper, TI1N>, Index<TI2P, TI2N>, Index<TI3P, TI3N>> dTensor)
         where TT : ITape<TN>
@@ -361,18 +366,19 @@ public static void Derivative<TT, TN, TPIN, TI2P, TI3P, TI1N, TI2N, TI3N>(
                     _ = function(tape, point);
                     tape.ReverseAccumulate(out var gradient);
 
-                    dTensor[0, i, j] = gradient[0];
-                    dTensor[1, i, j] = gradient[1];
-                    dTensor[2, i, j] = gradient[2];
+                    for (int k = 0; k < 3; k++)
+                    {
+                        dTensor[k, i, j] = gradient[k];
+                    }
                 }
             }
         }
     }
 
-    /// <inheritdoc cref="Derivative{TT, TN, TPIN, TI2P, TI3P, TI1N, TI2N, TI3N}(TT, TensorField2x2{TT, TN, TI2P, TI3P, Index{Upper, TPIN}}, AutoDiffTensor2{TN, Index{Upper, TPIN}}, out Tensor{Array2x2x2{TN}, TN, Index{Lower, TI1N}, Index{TI2P, TI2N}, Index{TI3P, TI3N}})"/>
+    /// <inheritdoc cref="Derivative{TT, TN, TPIN, TI2P, TI3P, TI1N, TI2N, TI3N}(TT, RMTensorField2x2{TT, TN, TI2P, TI3P, Index{Upper, TPIN}}, AutoDiffTensor2{TN, Index{Upper, TPIN}}, out Tensor{Array2x2x2{TN}, TN, Index{Lower, TI1N}, Index{TI2P, TI2N}, Index{TI3P, TI3N}})"/>
     public static void Derivative<TT, TN, TPIN, TI2P, TI3P, TI1N, TI2N, TI3N>(
         TT tape,
-        TensorField4x4<TT, TN, TI2P, TI3P, Index<Lower, TPIN>> tensor,
+        RMTensorField4x4<TT, TN, TI2P, TI3P, Index<Lower, TPIN>> tensor,
         AutoDiffTensor4<TN, Index<Lower, TPIN>> point,
         out Tensor<Array4x4x4<TN>, TN, Index<Upper, TI1N>, Index<TI2P, TI2N>, Index<TI3P, TI3N>> dTensor)
         where TT : ITape<TN>
@@ -394,10 +400,10 @@ public static void Derivative<TT, TN, TPIN, TI2P, TI3P, TI1N, TI2N, TI3N>(
                     _ = function(tape, point);
                     tape.ReverseAccumulate(out var gradient);
 
-                    dTensor[0, i, j] = gradient[0];
-                    dTensor[1, i, j] = gradient[1];
-                    dTensor[2, i, j] = gradient[2];
-                    dTensor[3, i, j] = gradient[3];
+                    for (int k = 0; k < 4; k++)
+                    {
+                        dTensor[k, i, j] = gradient[k];
+                    }
                 }
             }
         }
@@ -419,7 +425,7 @@ public static void Derivative<TT, TN, TPIN, TI2P, TI3P, TI1N, TI2N, TI3N>(
     /// <param name="d2Tensor">A rank-four tensor.</param>
     public static void SecondDerivative<TN, TPIN, TI3P, TI4P, TI1N, TI2N, TI3N, TI4N>(
         HessianTape<TN> tape,
-        TensorField2x2<HessianTape<TN>, TN, TI3P, TI4P, Index<Upper, TPIN>> tensor,
+        RMTensorField2x2<HessianTape<TN>, TN, TI3P, TI4P, Index<Upper, TPIN>> tensor,
         AutoDiffTensor2<TN, Index<Upper, TPIN>> point,
         out Tensor<Array2x2x2x2<TN>, TN, Index<Lower, TI1N>, Index<Lower, TI2N>, Index<TI3P, TI3N>, Index<TI4P, TI4N>> d2Tensor)
         where TN : IComplex<TN>, IDifferentiableFunctions<TN>
@@ -441,20 +447,22 @@ public static void SecondDerivative<TN, TPIN, TI3P, TI4P, TI1N, TI2N, TI3N, TI4N
                     _ = function(tape, point);
                     tape.ReverseAccumulate(out ReadOnlySpan2D<TN> hessian);
 
-                    d2Tensor[0, 0, i, j] = hessian[0, 0];
-                    d2Tensor[0, 1, i, j] = hessian[0, 1];
-
-                    d2Tensor[1, 0, i, j] = hessian[1, 0];
-                    d2Tensor[1, 1, i, j] = hessian[1, 1];
+                    for (int k = 0; k < 2; k++)
+                    {
+                        for (int l = 0; l < 2; l++)
+                        {
+                            d2Tensor[k, l, i, j] = hessian[k, l];
+                        }
+                    }
                 }
             }
         }
     }
 
-    /// <inheritdoc cref="SecondDerivative{TN, TPIN, TI3P, TI4P, TI1N, TI2N, TI3N, TI4N}(HessianTape{TN}, TensorField2x2{HessianTape{TN}, TN, TI3P, TI4P, Index{Upper, TPIN}}, AutoDiffTensor2{TN, Index{Upper, TPIN}}, out Tensor{Array2x2x2x2{TN}, TN, Index{Lower, TI1N}, Index{Lower, TI2N}, Index{TI3P, TI3N}, Index{TI4P, TI4N}})"/>
+    /// <inheritdoc cref="SecondDerivative{TN, TPIN, TI3P, TI4P, TI1N, TI2N, TI3N, TI4N}(HessianTape{TN}, RMTensorField2x2{HessianTape{TN}, TN, TI3P, TI4P, Index{Upper, TPIN}}, AutoDiffTensor2{TN, Index{Upper, TPIN}}, out Tensor{Array2x2x2x2{TN}, TN, Index{Lower, TI1N}, Index{Lower, TI2N}, Index{TI3P, TI3N}, Index{TI4P, TI4N}})"/>
     public static void SecondDerivative<TN, TPIN, TI3P, TI4P, TI1N, TI2N, TI3N, TI4N>(
         HessianTape<TN> tape,
-        TensorField3x3<HessianTape<TN>, TN, TI3P, TI4P, Index<Upper, TPIN>> tensor,
+        RMTensorField3x3<HessianTape<TN>, TN, TI3P, TI4P, Index<Upper, TPIN>> tensor,
         AutoDiffTensor3<TN, Index<Upper, TPIN>> point,
         out Tensor<Array3x3x3x3<TN>, TN, Index<Lower, TI1N>, Index<Lower, TI2N>, Index<TI3P, TI3N>, Index<TI4P, TI4N>> d2Tensor)
         where TN : IComplex<TN>, IDifferentiableFunctions<TN>
@@ -476,26 +484,22 @@ public static void SecondDerivative<TN, TPIN, TI3P, TI4P, TI1N, TI2N, TI3N, TI4N
                     _ = function(tape, point);
                     tape.ReverseAccumulate(out ReadOnlySpan2D<TN> hessian);
 
-                    d2Tensor[0, 0, i, j] = hessian[0, 0];
-                    d2Tensor[0, 1, i, j] = hessian[0, 1];
-                    d2Tensor[0, 2, i, j] = hessian[0, 2];
-
-                    d2Tensor[1, 0, i, j] = hessian[1, 0];
-                    d2Tensor[1, 1, i, j] = hessian[1, 1];
-                    d2Tensor[1, 2, i, j] = hessian[1, 2];
-
-                    d2Tensor[2, 0, i, j] = hessian[2, 0];
-                    d2Tensor[2, 1, i, j] = hessian[2, 1];
-                    d2Tensor[2, 2, i, j] = hessian[2, 2];
+                    for (int k = 0; k < 3; k++)
+                    {
+                        for (int l = 0; l < 3; l++)
+                        {
+                            d2Tensor[k, l, i, j] = hessian[k, l];
+                        }
+                    }
                 }
             }
         }
     }
 
-    /// <inheritdoc cref="SecondDerivative{TN, TPIN, TI3P, TI4P, TI1N, TI2N, TI3N, TI4N}(HessianTape{TN}, TensorField2x2{HessianTape{TN}, TN, TI3P, TI4P, Index{Upper, TPIN}}, AutoDiffTensor2{TN, Index{Upper, TPIN}}, out Tensor{Array2x2x2x2{TN}, TN, Index{Lower, TI1N}, Index{Lower, TI2N}, Index{TI3P, TI3N}, Index{TI4P, TI4N}})"/>
+    /// <inheritdoc cref="SecondDerivative{TN, TPIN, TI3P, TI4P, TI1N, TI2N, TI3N, TI4N}(HessianTape{TN}, RMTensorField2x2{HessianTape{TN}, TN, TI3P, TI4P, Index{Upper, TPIN}}, AutoDiffTensor2{TN, Index{Upper, TPIN}}, out Tensor{Array2x2x2x2{TN}, TN, Index{Lower, TI1N}, Index{Lower, TI2N}, Index{TI3P, TI3N}, Index{TI4P, TI4N}})"/>
     public static void SecondDerivative<TN, TPIN, TI3P, TI4P, TI1N, TI2N, TI3N, TI4N>(
         HessianTape<TN> tape,
-        TensorField4x4<HessianTape<TN>, TN, TI3P, TI4P, Index<Upper, TPIN>> tensor,
+        RMTensorField4x4<HessianTape<TN>, TN, TI3P, TI4P, Index<Upper, TPIN>> tensor,
         AutoDiffTensor4<TN, Index<Upper, TPIN>> point,
         out Tensor<Array4x4x4x4<TN>, TN, Index<Lower, TI1N>, Index<Lower, TI2N>, Index<TI3P, TI3N>, Index<TI4P, TI4N>> d2Tensor)
         where TN : IComplex<TN>, IDifferentiableFunctions<TN>
@@ -517,34 +521,22 @@ public static void SecondDerivative<TN, TPIN, TI3P, TI4P, TI1N, TI2N, TI3N, TI4N
                     _ = function(tape, point);
                     tape.ReverseAccumulate(out ReadOnlySpan2D<TN> hessian);
 
-                    d2Tensor[0, 0, i, j] = hessian[0, 0];
-                    d2Tensor[0, 1, i, j] = hessian[0, 1];
-                    d2Tensor[0, 2, i, j] = hessian[0, 2];
-                    d2Tensor[0, 3, i, j] = hessian[0, 3];
-
-                    d2Tensor[1, 0, i, j] = hessian[1, 0];
-                    d2Tensor[1, 1, i, j] = hessian[1, 1];
-                    d2Tensor[1, 2, i, j] = hessian[1, 2];
-                    d2Tensor[1, 3, i, j] = hessian[1, 3];
-
-                    d2Tensor[2, 0, i, j] = hessian[2, 0];
-                    d2Tensor[2, 1, i, j] = hessian[2, 1];
-                    d2Tensor[2, 2, i, j] = hessian[2, 2];
-                    d2Tensor[2, 3, i, j] = hessian[2, 3];
-
-                    d2Tensor[3, 0, i, j] = hessian[3, 0];
-                    d2Tensor[3, 1, i, j] = hessian[3, 1];
-                    d2Tensor[3, 2, i, j] = hessian[3, 2];
-                    d2Tensor[3, 3, i, j] = hessian[3, 3];
+                    for (int k = 0; k < 4; k++)
+                    {
+                        for (int l = 0; l < 4; l++)
+                        {
+                            d2Tensor[k, l, i, j] = hessian[k, l];
+                        }
+                    }
                 }
             }
         }
     }
 
-    /// <inheritdoc cref="SecondDerivative{TN, TPIN, TI3P, TI4P, TI1N, TI2N, TI3N, TI4N}(HessianTape{TN}, TensorField2x2{HessianTape{TN}, TN, TI3P, TI4P, Index{Upper, TPIN}}, AutoDiffTensor2{TN, Index{Upper, TPIN}}, out Tensor{Array2x2x2x2{TN}, TN, Index{Lower, TI1N}, Index{Lower, TI2N}, Index{TI3P, TI3N}, Index{TI4P, TI4N}})"/>
+    /// <inheritdoc cref="SecondDerivative{TN, TPIN, TI3P, TI4P, TI1N, TI2N, TI3N, TI4N}(HessianTape{TN}, RMTensorField2x2{HessianTape{TN}, TN, TI3P, TI4P, Index{Upper, TPIN}}, AutoDiffTensor2{TN, Index{Upper, TPIN}}, out Tensor{Array2x2x2x2{TN}, TN, Index{Lower, TI1N}, Index{Lower, TI2N}, Index{TI3P, TI3N}, Index{TI4P, TI4N}})"/>
     public static void SecondDerivative<TN, TPIN, TI3P, TI4P, TI1N, TI2N, TI3N, TI4N>(
         HessianTape<TN> tape,
-        TensorField2x2<HessianTape<TN>, TN, TI3P, TI4P, Index<Lower, TPIN>> tensor,
+        RMTensorField2x2<HessianTape<TN>, TN, TI3P, TI4P, Index<Lower, TPIN>> tensor,
         AutoDiffTensor2<TN, Index<Lower, TPIN>> point,
         out Tensor<Array2x2x2x2<TN>, TN, Index<Upper, TI1N>, Index<Upper, TI2N>, Index<TI3P, TI3N>, Index<TI4P, TI4N>> d2Tensor)
         where TN : IComplex<TN>, IDifferentiableFunctions<TN>
@@ -566,20 +558,22 @@ public static void SecondDerivative<TN, TPIN, TI3P, TI4P, TI1N, TI2N, TI3N, TI4N
                     _ = function(tape, point);
                     tape.ReverseAccumulate(out ReadOnlySpan2D<TN> hessian);
 
-                    d2Tensor[0, 0, i, j] = hessian[0, 0];
-                    d2Tensor[0, 1, i, j] = hessian[0, 1];
-
-                    d2Tensor[1, 0, i, j] = hessian[1, 0];
-                    d2Tensor[1, 1, i, j] = hessian[1, 1];
+                    for (int k = 0; k < 2; k++)
+                    {
+                        for (int l = 0; l < 2; l++)
+                        {
+                            d2Tensor[k, l, i, j] = hessian[k, l];
+                        }
+                    }
                 }
             }
         }
     }
 
-    /// <inheritdoc cref="SecondDerivative{TN, TPIN, TI3P, TI4P, TI1N, TI2N, TI3N, TI4N}(HessianTape{TN}, TensorField2x2{HessianTape{TN}, TN, TI3P, TI4P, Index{Upper, TPIN}}, AutoDiffTensor2{TN, Index{Upper, TPIN}}, out Tensor{Array2x2x2x2{TN}, TN, Index{Lower, TI1N}, Index{Lower, TI2N}, Index{TI3P, TI3N}, Index{TI4P, TI4N}})"/>
+    /// <inheritdoc cref="SecondDerivative{TN, TPIN, TI3P, TI4P, TI1N, TI2N, TI3N, TI4N}(HessianTape{TN}, RMTensorField2x2{HessianTape{TN}, TN, TI3P, TI4P, Index{Upper, TPIN}}, AutoDiffTensor2{TN, Index{Upper, TPIN}}, out Tensor{Array2x2x2x2{TN}, TN, Index{Lower, TI1N}, Index{Lower, TI2N}, Index{TI3P, TI3N}, Index{TI4P, TI4N}})"/>
     public static void SecondDerivative<TN, TPIN, TI3P, TI4P, TI1N, TI2N, TI3N, TI4N>(
         HessianTape<TN> tape,
-        TensorField3x3<HessianTape<TN>, TN, TI3P, TI4P, Index<Lower, TPIN>> tensor,
+        RMTensorField3x3<HessianTape<TN>, TN, TI3P, TI4P, Index<Lower, TPIN>> tensor,
         AutoDiffTensor3<TN, Index<Lower, TPIN>> point,
         out Tensor<Array3x3x3x3<TN>, TN, Index<Upper, TI1N>, Index<Upper, TI2N>, Index<TI3P, TI3N>, Index<TI4P, TI4N>> d2Tensor)
         where TN : IComplex<TN>, IDifferentiableFunctions<TN>
@@ -601,26 +595,22 @@ public static void SecondDerivative<TN, TPIN, TI3P, TI4P, TI1N, TI2N, TI3N, TI4N
                     _ = function(tape, point);
                     tape.ReverseAccumulate(out ReadOnlySpan2D<TN> hessian);
 
-                    d2Tensor[0, 0, i, j] = hessian[0, 0];
-                    d2Tensor[0, 1, i, j] = hessian[0, 1];
-                    d2Tensor[0, 2, i, j] = hessian[0, 2];
-
-                    d2Tensor[1, 0, i, j] = hessian[1, 0];
-                    d2Tensor[1, 1, i, j] = hessian[1, 1];
-                    d2Tensor[1, 2, i, j] = hessian[1, 2];
-
-                    d2Tensor[2, 0, i, j] = hessian[2, 0];
-                    d2Tensor[2, 1, i, j] = hessian[2, 1];
-                    d2Tensor[2, 2, i, j] = hessian[2, 2];
+                    for (int k = 0; k < 3; k++)
+                    {
+                        for (int l = 0; l < 3; l++)
+                        {
+                            d2Tensor[k, l, i, j] = hessian[k, l];
+                        }
+                    }
                 }
             }
         }
     }
 
-    /// <inheritdoc cref="SecondDerivative{TN, TPIN, TI3P, TI4P, TI1N, TI2N, TI3N, TI4N}(HessianTape{TN}, TensorField2x2{HessianTape{TN}, TN, TI3P, TI4P, Index{Upper, TPIN}}, AutoDiffTensor2{TN, Index{Upper, TPIN}}, out Tensor{Array2x2x2x2{TN}, TN, Index{Lower, TI1N}, Index{Lower, TI2N}, Index{TI3P, TI3N}, Index{TI4P, TI4N}})"/>
+    /// <inheritdoc cref="SecondDerivative{TN, TPIN, TI3P, TI4P, TI1N, TI2N, TI3N, TI4N}(HessianTape{TN}, RMTensorField2x2{HessianTape{TN}, TN, TI3P, TI4P, Index{Upper, TPIN}}, AutoDiffTensor2{TN, Index{Upper, TPIN}}, out Tensor{Array2x2x2x2{TN}, TN, Index{Lower, TI1N}, Index{Lower, TI2N}, Index{TI3P, TI3N}, Index{TI4P, TI4N}})"/>
     public static void SecondDerivative<TN, TPIN, TI3P, TI4P, TI1N, TI2N, TI3N, TI4N>(
         HessianTape<TN> tape,
-        TensorField4x4<HessianTape<TN>, TN, TI3P, TI4P, Index<Lower, TPIN>> tensor,
+        RMTensorField4x4<HessianTape<TN>, TN, TI3P, TI4P, Index<Lower, TPIN>> tensor,
         AutoDiffTensor4<TN, Index<Lower, TPIN>> point,
         out Tensor<Array4x4x4x4<TN>, TN, Index<Upper, TI1N>, Index<Upper, TI2N>, Index<TI3P, TI3N>, Index<TI4P, TI4N>> d2Tensor)
         where TN : IComplex<TN>, IDifferentiableFunctions<TN>
@@ -642,25 +632,13 @@ public static void SecondDerivative<TN, TPIN, TI3P, TI4P, TI1N, TI2N, TI3N, TI4N
                     _ = function(tape, point);
                     tape.ReverseAccumulate(out ReadOnlySpan2D<TN> hessian);
 
-                    d2Tensor[0, 0, i, j] = hessian[0, 0];
-                    d2Tensor[0, 1, i, j] = hessian[0, 1];
-                    d2Tensor[0, 2, i, j] = hessian[0, 2];
-                    d2Tensor[0, 3, i, j] = hessian[0, 3];
-
-                    d2Tensor[1, 0, i, j] = hessian[1, 0];
-                    d2Tensor[1, 1, i, j] = hessian[1, 1];
-                    d2Tensor[1, 2, i, j] = hessian[1, 2];
-                    d2Tensor[1, 3, i, j] = hessian[1, 3];
-
-                    d2Tensor[2, 0, i, j] = hessian[2, 0];
-                    d2Tensor[2, 1, i, j] = hessian[2, 1];
-                    d2Tensor[2, 2, i, j] = hessian[2, 2];
-                    d2Tensor[2, 3, i, j] = hessian[2, 3];
-
-                    d2Tensor[3, 0, i, j] = hessian[3, 0];
-                    d2Tensor[3, 1, i, j] = hessian[3, 1];
-                    d2Tensor[3, 2, i, j] = hessian[3, 2];
-                    d2Tensor[3, 3, i, j] = hessian[3, 3];
+                    for (int k = 0; k < 4; k++)
+                    {
+                        for (int l = 0; l < 4; l++)
+                        {
+                            d2Tensor[k, l, i, j] = hessian[k, l];
+                        }
+                    }
                 }
             }
         }
@@ -1113,8 +1091,7 @@ public static void Riemann<TN, TPIN, TI1N, TI2N, TI3N, TI4N>(
                 {
                     for (int n = 0; n < 2; n++)
                     {
-                        riemann[r, s, m, n] =
-                            dChristoffel[m, r, s, n] - dChristoffel[n, r, s, m] + cChristoffels[r, m, s, n] - cChristoffels[r, n, s, m];
+                        riemann[r, s, m, n] = dChristoffel[m, r, s, n] - dChristoffel[n, r, s, m] + cChristoffels[r, m, s, n] - cChristoffels[r, n, s, m];
                     }
                 }
             }
@@ -1147,8 +1124,7 @@ public static void Riemann<TN, TPIN, TI1N, TI2N, TI3N, TI4N>(
                 {
                     for (int n = 0; n < 3; n++)
                     {
-                        riemann[r, s, m, n] =
-                            dChristoffel[m, r, s, n] - dChristoffel[n, r, s, m] + cChristoffels[r, m, s, n] - cChristoffels[r, n, s, m];
+                        riemann[r, s, m, n] = dChristoffel[m, r, s, n] - dChristoffel[n, r, s, m] + cChristoffels[r, m, s, n] - cChristoffels[r, n, s, m];
                     }
                 }
             }
@@ -1181,8 +1157,7 @@ public static void Riemann<TN, TPIN, TI1N, TI2N, TI3N, TI4N>(
                 {
                     for (int n = 0; n < 4; n++)
                     {
-                        riemann[r, s, m, n] =
-                            dChristoffel[m, r, s, n] - dChristoffel[n, r, s, m] + cChristoffels[r, m, s, n] - cChristoffels[r, n, s, m];
+                        riemann[r, s, m, n] = dChristoffel[m, r, s, n] - dChristoffel[n, r, s, m] + cChristoffels[r, m, s, n] - cChristoffels[r, n, s, m];
                     }
                 }
             }
diff --git a/src/Mathematics.NET/DifferentialGeometry/DifGeoExtensions.cs b/src/Mathematics.NET/DifferentialGeometry/DifGeoExtensions.cs
index 8e501aac..8357649c 100644
--- a/src/Mathematics.NET/DifferentialGeometry/DifGeoExtensions.cs
+++ b/src/Mathematics.NET/DifferentialGeometry/DifGeoExtensions.cs
@@ -26,9 +26,6 @@
 // </copyright>
 
 using System.Runtime.CompilerServices;
-using Mathematics.NET.AutoDiff;
-using Mathematics.NET.DifferentialGeometry.Abstractions;
-using Mathematics.NET.LinearAlgebra;
 using Mathematics.NET.LinearAlgebra.Abstractions;
 
 namespace Mathematics.NET.DifferentialGeometry;
@@ -36,130 +33,6 @@ namespace Mathematics.NET.DifferentialGeometry;
 /// <summary>A class containing difgeo extension methods.</summary>
 public static class DifGeoExtensions
 {
-    //
-    // AutoDiff
-    //
-
-    /// <summary>Create an autodiff, rank-one tensor from a real vector.</summary>
-    /// <typeparam name="T">An index.</typeparam>
-    /// <param name="tape">A type that implements <see cref="ITape{T}"/>.</param>
-    /// <param name="x">A vector of seed values.</param>
-    /// <returns>A rank-one tensor of four variables.</returns>
-    public static AutoDiffTensor2<Real, T> CreateAutoDiffTensor<T>(this ITape<Real> tape, Vector2<Real> x)
-        where T : IIndex
-        => new(tape.CreateVariable(x.X1), tape.CreateVariable(x.X2));
-
-    /// <summary>Create an autodiff, rank-one tensor from a complex vector.</summary>
-    /// <typeparam name="T">An index.</typeparam>
-    /// <param name="tape">A type that implements <see cref="ITape{T}"/>.</param>
-    /// <param name="x">A vector of seed values.</param>
-    /// <returns>A rank-one tensor of four variables.</returns>
-    public static AutoDiffTensor2<Complex, T> CreateAutoDiffTensor<T>(this ITape<Complex> tape, Vector2<Complex> x)
-        where T : IIndex
-        => new(tape.CreateVariable(x.X1), tape.CreateVariable(x.X2));
-
-    /// <summary>Create an autodiff, rank-one tensor from real seed values.</summary>
-    /// <typeparam name="T">An index.</typeparam>
-    /// <param name="tape">A type that implements <see cref="ITape{T}"/>.</param>
-    /// <param name="x0Seed">The zeroth seed value.</param>
-    /// <param name="x1Seed">The first seed value.</param>
-    /// <returns>A rank-one tensor of four variables.</returns>
-    public static AutoDiffTensor2<Real, T> CreateAutoDiffTensor<T>(this ITape<Real> tape, Real x0Seed, Real x1Seed)
-        where T : IIndex
-        => new(tape.CreateVariable(x0Seed), tape.CreateVariable(x1Seed));
-
-    /// <summary>Create an autodiff, rank-one tensor from complex seed values.</summary>
-    /// <typeparam name="T">An index.</typeparam>
-    /// <param name="tape">A type that implements <see cref="ITape{T}"/>.</param>
-    /// <param name="x0Seed">The zeroth seed value.</param>
-    /// <param name="x1Seed">The first seed value.</param>
-    /// <returns>A rank-one tensor of four variables.</returns>
-    public static AutoDiffTensor2<Complex, T> CreateAutoDiffTensor<T>(this ITape<Complex> tape, in Complex x0Seed, in Complex x1Seed)
-        where T : IIndex
-        => new(tape.CreateVariable(x0Seed), tape.CreateVariable(x1Seed));
-
-    /// <summary>Create an autodiff, rank-one tensor from a real vector.</summary>
-    /// <typeparam name="T">An index.</typeparam>
-    /// <param name="tape">A type that implements <see cref="ITape{T}"/>.</param>
-    /// <param name="x">A vector of seed values.</param>
-    /// <returns>A rank-one tensor of four variables.</returns>
-    public static AutoDiffTensor3<Real, T> CreateAutoDiffTensor<T>(this ITape<Real> tape, Vector3<Real> x)
-        where T : IIndex
-        => new(tape.CreateVariable(x.X1), tape.CreateVariable(x.X2), tape.CreateVariable(x.X3));
-
-    /// <summary>Create an autodiff, rank-one tensor from a complex vector.</summary>
-    /// <typeparam name="T">An index.</typeparam>
-    /// <param name="tape">A type that implements <see cref="ITape{T}"/>.</param>
-    /// <param name="x">A vector of seed values.</param>
-    /// <returns>A rank-one tensor of four variables.</returns>
-    public static AutoDiffTensor3<Complex, T> CreateAutoDiffTensor<T>(this ITape<Complex> tape, Vector3<Complex> x)
-        where T : IIndex
-        => new(tape.CreateVariable(x.X1), tape.CreateVariable(x.X2), tape.CreateVariable(x.X3));
-
-    /// <summary>Create an autodiff, rank-one tensor from real seed values.</summary>
-    /// <typeparam name="T">An index.</typeparam>
-    /// <param name="tape">A type that implements <see cref="ITape{T}"/>.</param>
-    /// <param name="x0Seed">The zeroth seed value.</param>
-    /// <param name="x1Seed">The first seed value.</param>
-    /// <param name="x2Seed">The second seed value.</param>
-    /// <returns>A rank-one tensor of four variables.</returns>
-    public static AutoDiffTensor3<Real, T> CreateAutoDiffTensor<T>(this ITape<Real> tape, Real x0Seed, Real x1Seed, Real x2Seed)
-        where T : IIndex
-        => new(tape.CreateVariable(x0Seed), tape.CreateVariable(x1Seed), tape.CreateVariable(x2Seed));
-
-    /// <summary>Create an autodiff, rank-one tensor from complex seed values.</summary>
-    /// <typeparam name="T">An index.</typeparam>
-    /// <param name="tape">A type that implements <see cref="ITape{T}"/>.</param>
-    /// <param name="x0Seed">The zeroth seed value.</param>
-    /// <param name="x1Seed">The first seed value.</param>
-    /// <param name="x2Seed">The second seed value.</param>
-    /// <returns>A rank-one tensor of four variables.</returns>
-    public static AutoDiffTensor3<Complex, T> CreateAutoDiffTensor<T>(this ITape<Complex> tape, in Complex x0Seed, in Complex x1Seed, in Complex x2Seed)
-        where T : IIndex
-        => new(tape.CreateVariable(x0Seed), tape.CreateVariable(x1Seed), tape.CreateVariable(x2Seed));
-
-    /// <summary>Create an autodiff, rank-one tensor from a real vector.</summary>
-    /// <typeparam name="T">An index.</typeparam>
-    /// <param name="tape">A type that implements <see cref="ITape{T}"/>.</param>
-    /// <param name="x">A vector of seed values.</param>
-    /// <returns>A rank-one tensor of four variables.</returns>
-    public static AutoDiffTensor4<Real, T> CreateAutoDiffTensor<T>(this ITape<Real> tape, Vector4<Real> x)
-        where T : IIndex
-        => new(tape.CreateVariable(x.X1), tape.CreateVariable(x.X2), tape.CreateVariable(x.X3), tape.CreateVariable(x.X4));
-
-    /// <summary>Create an autodiff, rank-one tensor from a complex vector.</summary>
-    /// <typeparam name="T">An index.</typeparam>
-    /// <param name="tape">A type that implements <see cref="ITape{T}"/>.</param>
-    /// <param name="x">A vector of seed values.</param>
-    /// <returns>A rank-one tensor of four variables.</returns>
-    public static AutoDiffTensor4<Complex, T> CreateAutoDiffTensor<T>(this ITape<Complex> tape, Vector4<Complex> x)
-        where T : IIndex
-        => new(tape.CreateVariable(x.X1), tape.CreateVariable(x.X2), tape.CreateVariable(x.X3), tape.CreateVariable(x.X4));
-
-    /// <summary>Create an autodiff, rank-one tensor from real seed values.</summary>
-    /// <typeparam name="T">An index.</typeparam>
-    /// <param name="tape">A type that implements <see cref="ITape{T}"/>.</param>
-    /// <param name="x0Seed">The zeroth seed value.</param>
-    /// <param name="x1Seed">The first seed value.</param>
-    /// <param name="x2Seed">The second seed value.</param>
-    /// <param name="x3Seed">The third seed value.</param>
-    /// <returns>A rank-one tensor of four variables.</returns>
-    public static AutoDiffTensor4<Real, T> CreateAutoDiffTensor<T>(this ITape<Real> tape, Real x0Seed, Real x1Seed, Real x2Seed, Real x3Seed)
-        where T : IIndex
-        => new(tape.CreateVariable(x0Seed), tape.CreateVariable(x1Seed), tape.CreateVariable(x2Seed), tape.CreateVariable(x3Seed));
-
-    /// <summary>Create an autodiff, rank-one tensor from complex seed values.</summary>
-    /// <typeparam name="T">An index.</typeparam>
-    /// <param name="tape">A type that implements <see cref="ITape{T}"/>.</param>
-    /// <param name="x0Seed">The zeroth seed value.</param>
-    /// <param name="x1Seed">The first seed value.</param>
-    /// <param name="x2Seed">The second seed value.</param>
-    /// <param name="x3Seed">The third seed value.</param>
-    /// <returns>A rank-one tensor of four variables.</returns>
-    public static AutoDiffTensor4<Complex, T> CreateAutoDiffTensor<T>(this ITape<Complex> tape, in Complex x0Seed, in Complex x1Seed, in Complex x2Seed, in Complex x3Seed)
-        where T : IIndex
-        => new(tape.CreateVariable(x0Seed), tape.CreateVariable(x1Seed), tape.CreateVariable(x2Seed), tape.CreateVariable(x3Seed));
-
     //
     // Calculus
     //
diff --git a/src/Mathematics.NET/DifferentialGeometry/MetricTensorField2x2.cs b/src/Mathematics.NET/DifferentialGeometry/MetricTensorField2x2.cs
index 5ebf1e51..be06bb0a 100644
--- a/src/Mathematics.NET/DifferentialGeometry/MetricTensorField2x2.cs
+++ b/src/Mathematics.NET/DifferentialGeometry/MetricTensorField2x2.cs
@@ -35,7 +35,7 @@ namespace Mathematics.NET.DifferentialGeometry;
 /// <typeparam name="TT">A type that implements <see cref="ITape{T}"/>.</typeparam>
 /// <typeparam name="TN">A type that implements <see cref="IComplex{T}"/> and <see cref="IDifferentiableFunctions{T}"/>.</typeparam>
 /// <typeparam name="TPI">The index of the point on the manifold.</typeparam>
-public abstract class MetricTensorField2x2<TT, TN, TPI> : TensorField2x2<TT, TN, Lower, Lower, TPI>
+public abstract class MetricTensorField2x2<TT, TN, TPI> : RMTensorField2x2<TT, TN, Lower, Lower, TPI>
     where TT : ITape<TN>
     where TN : IComplex<TN>, IDifferentiableFunctions<TN>
     where TPI : IIndex
diff --git a/src/Mathematics.NET/DifferentialGeometry/MetricTensorField3x3.cs b/src/Mathematics.NET/DifferentialGeometry/MetricTensorField3x3.cs
index 83a1d255..158e2e8a 100644
--- a/src/Mathematics.NET/DifferentialGeometry/MetricTensorField3x3.cs
+++ b/src/Mathematics.NET/DifferentialGeometry/MetricTensorField3x3.cs
@@ -35,7 +35,7 @@ namespace Mathematics.NET.DifferentialGeometry;
 /// <typeparam name="TT">A type that implements <see cref="ITape{T}"/>.</typeparam>
 /// <typeparam name="TN">A type that implements <see cref="IComplex{T}"/> and <see cref="IDifferentiableFunctions{T}"/>.</typeparam>
 /// <typeparam name="TPI">The index of the point on the manifold.</typeparam>
-public abstract class MetricTensorField3x3<TT, TN, TPI> : TensorField3x3<TT, TN, Lower, Lower, TPI>
+public abstract class MetricTensorField3x3<TT, TN, TPI> : RMTensorField3x3<TT, TN, Lower, Lower, TPI>
     where TT : ITape<TN>
     where TN : IComplex<TN>, IDifferentiableFunctions<TN>
     where TPI : IIndex
diff --git a/src/Mathematics.NET/DifferentialGeometry/MetricTensorField4x4.cs b/src/Mathematics.NET/DifferentialGeometry/MetricTensorField4x4.cs
index 09cbbdc0..e3679da3 100644
--- a/src/Mathematics.NET/DifferentialGeometry/MetricTensorField4x4.cs
+++ b/src/Mathematics.NET/DifferentialGeometry/MetricTensorField4x4.cs
@@ -35,7 +35,7 @@ namespace Mathematics.NET.DifferentialGeometry;
 /// <typeparam name="TT">A type that implements <see cref="ITape{T}"/>.</typeparam>
 /// <typeparam name="TN">A type that implements <see cref="IComplex{T}"/> and <see cref="IDifferentiableFunctions{T}"/>.</typeparam>
 /// <typeparam name="TPI">The index of the point on the manifold.</typeparam>
-public abstract class MetricTensorField4x4<TT, TN, TPI> : TensorField4x4<TT, TN, Lower, Lower, TPI>
+public abstract class MetricTensorField4x4<TT, TN, TPI> : RMTensorField4x4<TT, TN, Lower, Lower, TPI>
     where TT : ITape<TN>
     where TN : IComplex<TN>, IDifferentiableFunctions<TN>
     where TPI : IIndex
diff --git a/src/Mathematics.NET/DifferentialGeometry/TensorField2.cs b/src/Mathematics.NET/DifferentialGeometry/RMTensorField2.cs
similarity index 91%
rename from src/Mathematics.NET/DifferentialGeometry/TensorField2.cs
rename to src/Mathematics.NET/DifferentialGeometry/RMTensorField2.cs
index e7d3c6af..dfb2e361 100644
--- a/src/Mathematics.NET/DifferentialGeometry/TensorField2.cs
+++ b/src/Mathematics.NET/DifferentialGeometry/RMTensorField2.cs
@@ -1,4 +1,4 @@
-// <copyright file="TensorField2.cs" company="Mathematics.NET">
+// <copyright file="RMTensorField2.cs" company="Mathematics.NET">
 // Mathematics.NET
 // https://github.com/HamletTanyavong/Mathematics.NET
 //
@@ -37,15 +37,15 @@ namespace Mathematics.NET.DifferentialGeometry;
 /// <typeparam name="TN">A type that implements <see cref="IComplex{T}"/> and <see cref="IDifferentiableFunctions{T}"/>.</typeparam>
 /// <typeparam name="TIP">An index position.</typeparam>
 /// <typeparam name="TPI">An index.</typeparam>
-public class TensorField2<TT, TN, TIP, TPI> : TensorField<TN, TPI>
+public class RMTensorField2<TT, TN, TIP, TPI> : TensorField<TN, TPI>
     where TT : ITape<TN>
     where TN : IComplex<TN>, IDifferentiableFunctions<TN>
     where TIP : IIndexPosition
     where TPI : IIndex
 {
-    private AutoDiffTensor2Buffer2<TT, TN, TPI> _buffer;
+    private RMTensor2Buffer2<TT, TN, TPI> _buffer;
 
-    public TensorField2() { }
+    public RMTensorField2() { }
 
     public Func<TT, AutoDiffTensor2<TN, TPI>, Variable<TN>> this[int index]
     {
diff --git a/src/Mathematics.NET/DifferentialGeometry/TensorField2x2.cs b/src/Mathematics.NET/DifferentialGeometry/RMTensorField2x2.cs
similarity index 93%
rename from src/Mathematics.NET/DifferentialGeometry/TensorField2x2.cs
rename to src/Mathematics.NET/DifferentialGeometry/RMTensorField2x2.cs
index 6c18f16f..f949e790 100644
--- a/src/Mathematics.NET/DifferentialGeometry/TensorField2x2.cs
+++ b/src/Mathematics.NET/DifferentialGeometry/RMTensorField2x2.cs
@@ -1,4 +1,4 @@
-// <copyright file="TensorField2x2.cs" company="Mathematics.NET">
+// <copyright file="RMTensorField2x2.cs" company="Mathematics.NET">
 // Mathematics.NET
 // https://github.com/HamletTanyavong/Mathematics.NET
 //
@@ -39,16 +39,16 @@ namespace Mathematics.NET.DifferentialGeometry;
 /// <typeparam name="TI1P">The position of the first index of the tensor.</typeparam>
 /// <typeparam name="TI2P">The position of the second index of the tensor.</typeparam>
 /// <typeparam name="TPI">The index of the point on the manifold.</typeparam>
-public class TensorField2x2<TT, TN, TI1P, TI2P, TPI> : TensorField<TN, TPI>
+public class RMTensorField2x2<TT, TN, TI1P, TI2P, TPI> : TensorField<TN, TPI>
     where TT : ITape<TN>
     where TN : IComplex<TN>, IDifferentiableFunctions<TN>
     where TI1P : IIndexPosition
     where TI2P : IIndexPosition
     where TPI : IIndex
 {
-    private protected AutoDiffTensor2Buffer2x2<TT, TN, TPI> _buffer;
+    private protected RMTensor2Buffer2x2<TT, TN, TPI> _buffer;
 
-    public TensorField2x2() { }
+    public RMTensorField2x2() { }
 
     public Func<TT, AutoDiffTensor2<TN, TPI>, Variable<TN>> this[int row, int column]
     {
diff --git a/src/Mathematics.NET/DifferentialGeometry/TensorField3.cs b/src/Mathematics.NET/DifferentialGeometry/RMTensorField3.cs
similarity index 91%
rename from src/Mathematics.NET/DifferentialGeometry/TensorField3.cs
rename to src/Mathematics.NET/DifferentialGeometry/RMTensorField3.cs
index 5e6fe0fe..995d5031 100644
--- a/src/Mathematics.NET/DifferentialGeometry/TensorField3.cs
+++ b/src/Mathematics.NET/DifferentialGeometry/RMTensorField3.cs
@@ -1,4 +1,4 @@
-// <copyright file="TensorField3.cs" company="Mathematics.NET">
+// <copyright file="RMTensorField3.cs" company="Mathematics.NET">
 // Mathematics.NET
 // https://github.com/HamletTanyavong/Mathematics.NET
 //
@@ -37,15 +37,15 @@ namespace Mathematics.NET.DifferentialGeometry;
 /// <typeparam name="TN">A type that implements <see cref="IComplex{T}"/> and <see cref="IDifferentiableFunctions{T}"/>.</typeparam>
 /// <typeparam name="TIP">An index position.</typeparam>
 /// <typeparam name="TPI">An index.</typeparam>
-public class TensorField3<TT, TN, TIP, TPI> : TensorField<TN, TPI>
+public class RMTensorField3<TT, TN, TIP, TPI> : TensorField<TN, TPI>
     where TT : ITape<TN>
     where TN : IComplex<TN>, IDifferentiableFunctions<TN>
     where TIP : IIndexPosition
     where TPI : IIndex
 {
-    private AutoDiffTensor3Buffer3<TT, TN, TPI> _buffer;
+    private RMTensor3Buffer3<TT, TN, TPI> _buffer;
 
-    public TensorField3() { }
+    public RMTensorField3() { }
 
     public Func<TT, AutoDiffTensor3<TN, TPI>, Variable<TN>> this[int index]
     {
diff --git a/src/Mathematics.NET/DifferentialGeometry/TensorField3x3.cs b/src/Mathematics.NET/DifferentialGeometry/RMTensorField3x3.cs
similarity index 89%
rename from src/Mathematics.NET/DifferentialGeometry/TensorField3x3.cs
rename to src/Mathematics.NET/DifferentialGeometry/RMTensorField3x3.cs
index d9130372..94b385d1 100644
--- a/src/Mathematics.NET/DifferentialGeometry/TensorField3x3.cs
+++ b/src/Mathematics.NET/DifferentialGeometry/RMTensorField3x3.cs
@@ -1,4 +1,4 @@
-// <copyright file="TensorField3x3.cs" company="Mathematics.NET">
+// <copyright file="RMTensorField3x3.cs" company="Mathematics.NET">
 // Mathematics.NET
 // https://github.com/HamletTanyavong/Mathematics.NET
 //
@@ -39,16 +39,16 @@ namespace Mathematics.NET.DifferentialGeometry;
 /// <typeparam name="TI1P">The position of the first index of the tensor.</typeparam>
 /// <typeparam name="TI2P">The position of the second index of the tensor.</typeparam>
 /// <typeparam name="TPI">The index of the point on the manifold.</typeparam>
-public class TensorField3x3<TT, TN, TI1P, TI2P, TPI> : TensorField<TN, TPI>
+public class RMTensorField3x3<TT, TN, TI1P, TI2P, TPI> : TensorField<TN, TPI>
     where TT : ITape<TN>
     where TN : IComplex<TN>, IDifferentiableFunctions<TN>
     where TI1P : IIndexPosition
     where TI2P : IIndexPosition
     where TPI : IIndex
 {
-    private protected AutoDiffTensor3Buffer3x3<TT, TN, TPI> _buffer;
+    private protected RMTensor3Buffer3x3<TT, TN, TPI> _buffer;
 
-    public TensorField3x3() { }
+    public RMTensorField3x3() { }
 
     public Func<TT, AutoDiffTensor3<TN, TPI>, Variable<TN>> this[int row, int column]
     {
@@ -59,7 +59,7 @@ public TensorField3x3() { }
         set => _buffer[row][column] = value;
     }
 
-    /// <inheritdoc cref="TensorField2x2{TT, TN, TI1P, TI2P, TPI}.Compute{TI1N, TI2N}(TT, AutoDiffTensor2{TN, TPI})"/>
+    /// <inheritdoc cref="RMTensorField2x2{TT, TN, TI1P, TI2P, TPI}.Compute{TI1N, TI2N}(TT, AutoDiffTensor2{TN, TPI})"/>
     public Tensor<Matrix3x3<TN>, TN, Index<TI1P, TI1N>, Index<TI2P, TI2N>> Compute<TI1N, TI2N>(TT tape, AutoDiffTensor3<TN, TPI> x)
         where TI1N : IIndexName
         where TI2N : IIndexName
diff --git a/src/Mathematics.NET/DifferentialGeometry/TensorField4.cs b/src/Mathematics.NET/DifferentialGeometry/RMTensorField4.cs
similarity index 91%
rename from src/Mathematics.NET/DifferentialGeometry/TensorField4.cs
rename to src/Mathematics.NET/DifferentialGeometry/RMTensorField4.cs
index 9261cd12..be3d4e92 100644
--- a/src/Mathematics.NET/DifferentialGeometry/TensorField4.cs
+++ b/src/Mathematics.NET/DifferentialGeometry/RMTensorField4.cs
@@ -1,4 +1,4 @@
-// <copyright file="TensorField4.cs" company="Mathematics.NET">
+// <copyright file="RMTensorField4.cs" company="Mathematics.NET">
 // Mathematics.NET
 // https://github.com/HamletTanyavong/Mathematics.NET
 //
@@ -37,15 +37,15 @@ namespace Mathematics.NET.DifferentialGeometry;
 /// <typeparam name="TN">A type that implements <see cref="IComplex{T}"/> and <see cref="IDifferentiableFunctions{T}"/>.</typeparam>
 /// <typeparam name="TIP">An index position.</typeparam>
 /// <typeparam name="TPI">An index.</typeparam>
-public class TensorField4<TT, TN, TIP, TPI> : TensorField<TN, TPI>
+public class RMTensorField4<TT, TN, TIP, TPI> : TensorField<TN, TPI>
     where TT : ITape<TN>
     where TN : IComplex<TN>, IDifferentiableFunctions<TN>
     where TIP : IIndexPosition
     where TPI : IIndex
 {
-    private AutoDiffTensor4Buffer4<TT, TN, TPI> _buffer;
+    private RMTensor4Buffer4<TT, TN, TPI> _buffer;
 
-    public TensorField4() { }
+    public RMTensorField4() { }
 
     public Func<TT, AutoDiffTensor4<TN, TPI>, Variable<TN>> this[int index]
     {
diff --git a/src/Mathematics.NET/DifferentialGeometry/TensorField4x4.cs b/src/Mathematics.NET/DifferentialGeometry/RMTensorField4x4.cs
similarity index 89%
rename from src/Mathematics.NET/DifferentialGeometry/TensorField4x4.cs
rename to src/Mathematics.NET/DifferentialGeometry/RMTensorField4x4.cs
index 4bba0b8c..c184a3ea 100644
--- a/src/Mathematics.NET/DifferentialGeometry/TensorField4x4.cs
+++ b/src/Mathematics.NET/DifferentialGeometry/RMTensorField4x4.cs
@@ -1,4 +1,4 @@
-// <copyright file="TensorField4x4.cs" company="Mathematics.NET">
+// <copyright file="RMTensorField4x4.cs" company="Mathematics.NET">
 // Mathematics.NET
 // https://github.com/HamletTanyavong/Mathematics.NET
 //
@@ -39,16 +39,16 @@ namespace Mathematics.NET.DifferentialGeometry;
 /// <typeparam name="TI1P">The position of the first index of the tensor.</typeparam>
 /// <typeparam name="TI2P">The position of the second index of the tensor.</typeparam>
 /// <typeparam name="TPI">The index of the point on the manifold.</typeparam>
-public class TensorField4x4<TT, TN, TI1P, TI2P, TPI> : TensorField<TN, TPI>
+public class RMTensorField4x4<TT, TN, TI1P, TI2P, TPI> : TensorField<TN, TPI>
     where TT : ITape<TN>
     where TN : IComplex<TN>, IDifferentiableFunctions<TN>
     where TI1P : IIndexPosition
     where TI2P : IIndexPosition
     where TPI : IIndex
 {
-    private protected AutoDiffTensor4Buffer4x4<TT, TN, TPI> _buffer;
+    private protected RMTensor4Buffer4x4<TT, TN, TPI> _buffer;
 
-    public TensorField4x4() { }
+    public RMTensorField4x4() { }
 
     public Func<TT, AutoDiffTensor4<TN, TPI>, Variable<TN>> this[int row, int column]
     {
@@ -59,7 +59,7 @@ public TensorField4x4() { }
         set => _buffer[row][column] = value;
     }
 
-    /// <inheritdoc cref="TensorField2x2{TT, TN, TI1P, TI2P, TPI}.Compute{TI1N, TI2N}(TT, AutoDiffTensor2{TN, TPI})"/>
+    /// <inheritdoc cref="RMTensorField2x2{TT, TN, TI1P, TI2P, TPI}.Compute{TI1N, TI2N}(TT, AutoDiffTensor2{TN, TPI})"/>
     public Tensor<Matrix4x4<TN>, TN, Index<TI1P, TI1N>, Index<TI2P, TI2N>> Compute<TI1N, TI2N>(TT tape, AutoDiffTensor4<TN, TPI> point)
         where TI1N : IIndexName
         where TI2N : IIndexName
diff --git a/tests/Mathematics.NET.Benchmarks.Implementations/AutoDiff/GradientTapeWithLinkedList.cs b/tests/Mathematics.NET.Benchmarks.Implementations/AutoDiff/GradientTapeWithLinkedList.cs
index a2229f17..20c4f01b 100644
--- a/tests/Mathematics.NET.Benchmarks.Implementations/AutoDiff/GradientTapeWithLinkedList.cs
+++ b/tests/Mathematics.NET.Benchmarks.Implementations/AutoDiff/GradientTapeWithLinkedList.cs
@@ -27,6 +27,9 @@
 
 using System.Runtime.CompilerServices;
 using Mathematics.NET.AutoDiff;
+using Mathematics.NET.DifferentialGeometry;
+using Mathematics.NET.DifferentialGeometry.Abstractions;
+using Mathematics.NET.LinearAlgebra;
 using Microsoft.Extensions.Logging;
 
 namespace Mathematics.NET.Benchmarks.Implementations.AutoDiff;
@@ -570,4 +573,15 @@ public Variable<T> CustomOperation(Variable<T> x, Variable<T> y, Func<T, T, T> f
         _nodes.AddLast(new GradientNode<T>(dfx(x.Value, y.Value), dfy(x.Value, y.Value), x._index, y._index));
         return new(_nodes.Count - 1, f(x.Value, y.Value));
     }
+
+    //
+    // DifGeo
+    //
+
+    public AutoDiffTensor2<T, U> CreateAutoDiffTensor<U>(in Vector2<T> x) where U : IIndex => throw new NotImplementedException();
+    public AutoDiffTensor2<T, U> CreateAutoDiffTensor<U>(in T x0, in T x1) where U : IIndex => throw new NotImplementedException();
+    public AutoDiffTensor3<T, U> CreateAutoDiffTensor<U>(in Vector3<T> x) where U : IIndex => throw new NotImplementedException();
+    public AutoDiffTensor3<T, U> CreateAutoDiffTensor<U>(in T x0, in T x1, in T x2) where U : IIndex => throw new NotImplementedException();
+    public AutoDiffTensor4<T, U> CreateAutoDiffTensor<U>(in Vector4<T> x) where U : IIndex => throw new NotImplementedException();
+    public AutoDiffTensor4<T, U> CreateAutoDiffTensor<U>(in T x0, in T x1, in T x2, in T x3) where U : IIndex => throw new NotImplementedException();
 }