From f3ab53215df0ab1cf2a0d5ec6e0eae2b853b18ec Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Anta=CC=83o=20Almada?= <antao.almada@farfetch.com>
Date: Tue, 27 Feb 2024 21:57:03 +0000
Subject: [PATCH] Make operators public

---
 .../NetFabric.Numerics.Tensors.csproj         |  1 +
 .../Operations/LessThanOrEqual.cs             |  2 +-
 .../Operators/AbsOperator.cs                  |  4 +-
 .../Operators/AddMultiplyOperator.cs          |  4 +-
 .../Operators/AdditionOperators.cs            |  6 +-
 .../Operators/BitwiseOperators.cs             | 12 ++--
 .../Operators/ComparisonOperators.cs          | 58 +++++++++----------
 .../Operators/DecrementOperators.cs           |  6 +-
 .../Operators/DivisionOperators.cs            |  6 +-
 .../Operators/EqualityOperators.cs            |  6 +-
 .../Operators/ExponentialOperators.cs         | 16 ++---
 .../FloatingPointIeee754Operators.cs          | 22 +++----
 .../Operators/FloatingPointOperators.cs       | 24 ++++----
 .../Operators/HyperbolicOperators.cs          | 14 ++---
 .../Operators/IdentityOperator.cs             |  4 +-
 .../Operators/IncrementOperators.cs           |  6 +-
 .../Operators/LogarithmicOperators.cs         | 16 ++---
 .../Operators/MaxOperator.cs                  | 10 ++--
 .../Operators/MinOperator.cs                  | 10 ++--
 .../Operators/ModulusOperators.cs             |  4 +-
 .../Operators/MultiplyAddOperator.cs          |  4 +-
 .../Operators/MultiplyDivideOperator.cs       |  4 +-
 .../Operators/MultiplyOperators.cs            |  8 +--
 .../Operators/PowerFunctionsOperators.cs      |  8 +--
 .../Operators/ProductOperator.cs              |  4 +-
 .../Operators/RootFunctionsOperators.cs       | 10 ++--
 .../Operators/ShiftLeftOperator.cs            | 24 ++++----
 .../Operators/ShiftRightAritmeticOperator.cs  | 14 ++---
 .../Operators/ShiftRightLogicalOperator.cs    | 24 ++++----
 .../Operators/SubtractionOperators.cs         |  6 +-
 .../Operators/SumOperator.cs                  |  4 +-
 .../Operators/TrigonometricOperators.cs       | 30 +++++-----
 .../Operators/UnaryNegationOperator.cs        |  6 +-
 33 files changed, 189 insertions(+), 188 deletions(-)

diff --git a/src/NetFabric.Numerics.Tensors/NetFabric.Numerics.Tensors.csproj b/src/NetFabric.Numerics.Tensors/NetFabric.Numerics.Tensors.csproj
index 45ef114..f584120 100644
--- a/src/NetFabric.Numerics.Tensors/NetFabric.Numerics.Tensors.csproj
+++ b/src/NetFabric.Numerics.Tensors/NetFabric.Numerics.Tensors.csproj
@@ -43,6 +43,7 @@
     <Using Include="System.Numerics" />
     <Using Include="System.Runtime.CompilerServices" />
     <Using Include="System.Runtime.InteropServices" />
+    <Using Include="NetFabric.Numerics.Tensors.Operators" />
   </ItemGroup>
 
   <PropertyGroup>
diff --git a/src/NetFabric.Numerics.Tensors/Operations/LessThanOrEqual.cs b/src/NetFabric.Numerics.Tensors/Operations/LessThanOrEqual.cs
index d4f0412..b8895d8 100644
--- a/src/NetFabric.Numerics.Tensors/Operations/LessThanOrEqual.cs
+++ b/src/NetFabric.Numerics.Tensors/Operations/LessThanOrEqual.cs
@@ -33,7 +33,7 @@ public static void LessThanOrEqual(ReadOnlySpan<int> x, ValueTuple<int, int> y,
     public static void LessThanOrEqual(ReadOnlySpan<int> x, ValueTuple<int, int, int> y, Span<int> destination)
         => Tensor.Apply<int, LessThanOrEqualInt32Operator>(x, y, destination);
 
-   public static void LessThanOrEqual(ReadOnlySpan<int> x, ReadOnlySpan<int> y, Span<int> destination)
+    public static void LessThanOrEqual(ReadOnlySpan<int> x, ReadOnlySpan<int> y, Span<int> destination)
         => Tensor.Apply<int, LessThanOrEqualInt32Operator>(x, y, destination);
 
     // long
diff --git a/src/NetFabric.Numerics.Tensors/Operators/AbsOperator.cs b/src/NetFabric.Numerics.Tensors/Operators/AbsOperator.cs
index 8177f1a..65e2633 100644
--- a/src/NetFabric.Numerics.Tensors/Operators/AbsOperator.cs
+++ b/src/NetFabric.Numerics.Tensors/Operators/AbsOperator.cs
@@ -1,6 +1,6 @@
-namespace NetFabric.Numerics.Tensors;
+namespace NetFabric.Numerics.Tensors.Operators;
 
-readonly struct AbsOperator<T>
+public readonly struct AbsOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, INumberBase<T>
 {
diff --git a/src/NetFabric.Numerics.Tensors/Operators/AddMultiplyOperator.cs b/src/NetFabric.Numerics.Tensors/Operators/AddMultiplyOperator.cs
index bbafd6c..b411010 100644
--- a/src/NetFabric.Numerics.Tensors/Operators/AddMultiplyOperator.cs
+++ b/src/NetFabric.Numerics.Tensors/Operators/AddMultiplyOperator.cs
@@ -1,6 +1,6 @@
-namespace NetFabric.Numerics.Tensors;
+namespace NetFabric.Numerics.Tensors.Operators;
 
-readonly struct AddMultiplyOperator<T>
+public readonly struct AddMultiplyOperator<T>
     : ITernaryOperator<T, T, T, T>
     where T : struct, IAdditionOperators<T, T, T>, IMultiplyOperators<T, T, T>
 {
diff --git a/src/NetFabric.Numerics.Tensors/Operators/AdditionOperators.cs b/src/NetFabric.Numerics.Tensors/Operators/AdditionOperators.cs
index be7f77c..f7b6501 100644
--- a/src/NetFabric.Numerics.Tensors/Operators/AdditionOperators.cs
+++ b/src/NetFabric.Numerics.Tensors/Operators/AdditionOperators.cs
@@ -1,6 +1,6 @@
-namespace NetFabric.Numerics.Tensors;
+namespace NetFabric.Numerics.Tensors.Operators;
 
-readonly struct AddOperator<T>
+public readonly struct AddOperator<T>
     : IBinaryOperator<T, T, T>
     where T : struct, IAdditionOperators<T, T, T>
 {
@@ -13,7 +13,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x, ref readonly Vector<T>
         => x + y;
 }
 
-readonly struct CheckedAddOperator<T>
+public readonly struct CheckedAddOperator<T>
     : IBinaryOperator<T, T, T>
     where T : struct, IAdditionOperators<T, T, T>
 {
diff --git a/src/NetFabric.Numerics.Tensors/Operators/BitwiseOperators.cs b/src/NetFabric.Numerics.Tensors/Operators/BitwiseOperators.cs
index f2f828b..c18e742 100644
--- a/src/NetFabric.Numerics.Tensors/Operators/BitwiseOperators.cs
+++ b/src/NetFabric.Numerics.Tensors/Operators/BitwiseOperators.cs
@@ -1,6 +1,6 @@
-namespace NetFabric.Numerics.Tensors;
+namespace NetFabric.Numerics.Tensors.Operators;
 
-readonly struct BitwiseAndOperator<T>
+public readonly struct BitwiseAndOperator<T>
     : IBinaryOperator<T, T, T>
     where T : struct, IBitwiseOperators<T, T, T>
 {
@@ -13,7 +13,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x, ref readonly Vector<T>
         => x & y;
 }
 
-readonly struct BitwiseAndNotOperator<T>
+public readonly struct BitwiseAndNotOperator<T>
     : IBinaryOperator<T, T, T>
     where T : struct, IBitwiseOperators<T, T, T>
 {
@@ -26,7 +26,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x, ref readonly Vector<T>
         => Vector.AndNot(x, y);
 }
 
-readonly struct BitwiseOrOperator<T>
+public readonly struct BitwiseOrOperator<T>
     : IBinaryOperator<T, T, T>
     where T : struct, IBitwiseOperators<T, T, T>
 {
@@ -39,7 +39,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x, ref readonly Vector<T>
         => x | y;
 }
 
-readonly struct XorOperator<T>
+public readonly struct XorOperator<T>
     : IBinaryOperator<T, T, T>
     where T : struct, IBitwiseOperators<T, T, T>
 {
@@ -53,7 +53,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x, ref readonly Vector<T>
 }
 
 
-readonly struct OnesComplementOperator<T>
+public readonly struct OnesComplementOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, IBitwiseOperators<T, T, T>
 {
diff --git a/src/NetFabric.Numerics.Tensors/Operators/ComparisonOperators.cs b/src/NetFabric.Numerics.Tensors/Operators/ComparisonOperators.cs
index 79294f4..f546dc3 100644
--- a/src/NetFabric.Numerics.Tensors/Operators/ComparisonOperators.cs
+++ b/src/NetFabric.Numerics.Tensors/Operators/ComparisonOperators.cs
@@ -1,6 +1,6 @@
-namespace NetFabric.Numerics.Tensors;
+namespace NetFabric.Numerics.Tensors.Operators;
 
-readonly struct GreaterThanOperator<T>
+public readonly struct GreaterThanOperator<T>
     : IBinaryOperator<T, T, T>
     where T : struct, IComparisonOperators<T, T, bool>, IMultiplicativeIdentity<T, T>
 {
@@ -17,7 +17,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x, ref readonly Vector<T>
         => Vector.GreaterThan(x, y);
 }
 
-readonly struct GreaterThanInt32Operator
+public readonly struct GreaterThanInt32Operator
     : IBinaryOperator<int, int, int>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -29,7 +29,7 @@ public static Vector<int> Invoke(ref readonly Vector<int> x, ref readonly Vector
         => Vector.GreaterThan(x, y);
 }
 
-readonly struct GreaterThanInt64Operator
+public readonly struct GreaterThanInt64Operator
     : IBinaryOperator<long, long, long>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -41,7 +41,7 @@ public static Vector<long> Invoke(ref readonly Vector<long> x, ref readonly Vect
         => Vector.GreaterThan(x, y);
 }
 
-readonly struct GreaterThanSingleOperator
+public readonly struct GreaterThanSingleOperator
     : IBinaryOperator<float, float, int>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -53,7 +53,7 @@ public static Vector<int> Invoke(ref readonly Vector<float> x, ref readonly Vect
         => Vector.GreaterThan(x, y);
 }
 
-readonly struct GreaterThanDoubleOperator
+public readonly struct GreaterThanDoubleOperator
     : IBinaryOperator<double, double, long>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -65,7 +65,7 @@ public static Vector<long> Invoke(ref readonly Vector<double> x, ref readonly Ve
         => Vector.GreaterThan(x, y);
 }
 
-readonly struct GreaterThanAllOperator<T>
+public readonly struct GreaterThanAllOperator<T>
     : IBinaryToScalarOperator<T, T, bool>
     where T : struct, IComparisonOperators<T, T, bool>
 {
@@ -78,7 +78,7 @@ public static bool Invoke(ref readonly Vector<T> x, ref readonly Vector<T> y)
         => Vector.GreaterThanAll(x, y);
 }
 
-readonly struct GreaterThanAnyOperator<T>
+public readonly struct GreaterThanAnyOperator<T>
     : IBinaryToScalarOperator<T, T, bool>
     where T : struct, IComparisonOperators<T, T, bool>
 {
@@ -91,7 +91,7 @@ public static bool Invoke(ref readonly Vector<T> x, ref readonly Vector<T> y)
         => Vector.GreaterThanAny(x, y);
 }
 
-readonly struct GreaterThanOrEqualOperator<T>
+public readonly struct GreaterThanOrEqualOperator<T>
     : IBinaryOperator<T, T, T>
     where T : struct, IComparisonOperators<T, T, bool>, IMultiplicativeIdentity<T, T>
 {
@@ -108,7 +108,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x, ref readonly Vector<T>
         => Vector.GreaterThanOrEqual(x, y);
 }
 
-readonly struct GreaterThanOrEqualInt32Operator
+public readonly struct GreaterThanOrEqualInt32Operator
     : IBinaryOperator<int, int, int>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -120,7 +120,7 @@ public static Vector<int> Invoke(ref readonly Vector<int> x, ref readonly Vector
         => Vector.GreaterThanOrEqual(x, y);
 }
 
-readonly struct GreaterThanOrEqualInt64Operator
+public readonly struct GreaterThanOrEqualInt64Operator
     : IBinaryOperator<long, long, long>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -132,7 +132,7 @@ public static Vector<long> Invoke(ref readonly Vector<long> x, ref readonly Vect
         => Vector.GreaterThanOrEqual(x, y);
 }
 
-readonly struct GreaterThanOrEqualSingleOperator
+public readonly struct GreaterThanOrEqualSingleOperator
     : IBinaryOperator<float, float, int>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -144,7 +144,7 @@ public static Vector<int> Invoke(ref readonly Vector<float> x, ref readonly Vect
         => Vector.GreaterThanOrEqual(x, y);
 }
 
-readonly struct GreaterThanOrEqualDoubleOperator
+public readonly struct GreaterThanOrEqualDoubleOperator
     : IBinaryOperator<double, double, long>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -156,7 +156,7 @@ public static Vector<long> Invoke(ref readonly Vector<double> x, ref readonly Ve
         => Vector.GreaterThanOrEqual(x, y);
 }
 
-readonly struct GreaterThanOrEqualAllOperator<T>
+public readonly struct GreaterThanOrEqualAllOperator<T>
     : IBinaryToScalarOperator<T, T, bool>
     where T : struct, IComparisonOperators<T, T, bool>
 {
@@ -169,7 +169,7 @@ public static bool Invoke(ref readonly Vector<T> x, ref readonly Vector<T> y)
         => Vector.GreaterThanOrEqualAll(x, y);
 }
 
-readonly struct GreaterThanOrEqualAnyOperator<T>
+public readonly struct GreaterThanOrEqualAnyOperator<T>
     : IBinaryToScalarOperator<T, T, bool>
     where T : struct, IComparisonOperators<T, T, bool>
 {
@@ -182,7 +182,7 @@ public static bool Invoke(ref readonly Vector<T> x, ref readonly Vector<T> y)
         => Vector.GreaterThanOrEqualAny(x, y);
 }
 
-readonly struct LessThanOperator<T>
+public readonly struct LessThanOperator<T>
     : IBinaryOperator<T, T, T>
     where T : struct, IComparisonOperators<T, T, bool>, IMultiplicativeIdentity<T, T>
 {
@@ -199,7 +199,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x, ref readonly Vector<T>
         => Vector.LessThan(x, y);
 }
 
-readonly struct LessThanInt32Operator
+public readonly struct LessThanInt32Operator
     : IBinaryOperator<int, int, int>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -211,7 +211,7 @@ public static Vector<int> Invoke(ref readonly Vector<int> x, ref readonly Vector
         => Vector.LessThan(x, y);
 }
 
-readonly struct LessThanInt64Operator
+public readonly struct LessThanInt64Operator
     : IBinaryOperator<long, long, long>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -223,7 +223,7 @@ public static Vector<long> Invoke(ref readonly Vector<long> x, ref readonly Vect
         => Vector.LessThan(x, y);
 }
 
-readonly struct LessThanSingleOperator
+public readonly struct LessThanSingleOperator
     : IBinaryOperator<float, float, int>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -235,7 +235,7 @@ public static Vector<int> Invoke(ref readonly Vector<float> x, ref readonly Vect
         => Vector.LessThan(x, y);
 }
 
-readonly struct LessThanDoubleOperator
+public readonly struct LessThanDoubleOperator
     : IBinaryOperator<double, double, long>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -247,7 +247,7 @@ public static Vector<long> Invoke(ref readonly Vector<double> x, ref readonly Ve
         => Vector.LessThan(x, y);
 }
 
-readonly struct LessThanOrEqualOperator<T>
+public readonly struct LessThanOrEqualOperator<T>
     : IBinaryOperator<T, T, T>
     where T : struct, IComparisonOperators<T, T, bool>, IMultiplicativeIdentity<T, T>
 {
@@ -264,7 +264,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x, ref readonly Vector<T>
         => Vector.LessThanOrEqual(x, y);
 }
 
-readonly struct LessThanAllOperator<T>
+public readonly struct LessThanAllOperator<T>
     : IBinaryToScalarOperator<T, T, bool>
     where T : struct, IComparisonOperators<T, T, bool>
 {
@@ -277,7 +277,7 @@ public static bool Invoke(ref readonly Vector<T> x, ref readonly Vector<T> y)
         => Vector.LessThanAll(x, y);
 }
 
-readonly struct LessThanAnyOperator<T>
+public readonly struct LessThanAnyOperator<T>
     : IBinaryToScalarOperator<T, T, bool>
     where T : struct, IComparisonOperators<T, T, bool>
 {
@@ -290,7 +290,7 @@ public static bool Invoke(ref readonly Vector<T> x, ref readonly Vector<T> y)
         => Vector.LessThanAny(x, y);
 }
 
-readonly struct LessThanOrEqualInt32Operator
+public readonly struct LessThanOrEqualInt32Operator
     : IBinaryOperator<int, int, int>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -302,7 +302,7 @@ public static Vector<int> Invoke(ref readonly Vector<int> x, ref readonly Vector
         => Vector.LessThanOrEqual(x, y);
 }
 
-readonly struct LessThanOrEqualInt64Operator
+public readonly struct LessThanOrEqualInt64Operator
     : IBinaryOperator<long, long, long>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -314,7 +314,7 @@ public static Vector<long> Invoke(ref readonly Vector<long> x, ref readonly Vect
         => Vector.LessThanOrEqual(x, y);
 }
 
-readonly struct LessThanOrEqualSingleOperator
+public readonly struct LessThanOrEqualSingleOperator
     : IBinaryOperator<float, float, int>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -326,7 +326,7 @@ public static Vector<int> Invoke(ref readonly Vector<float> x, ref readonly Vect
         => Vector.LessThanOrEqual(x, y);
 }
 
-readonly struct LessThanOrEqualDoubleOperator
+public readonly struct LessThanOrEqualDoubleOperator
     : IBinaryOperator<double, double, long>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -339,7 +339,7 @@ public static Vector<long> Invoke(ref readonly Vector<double> x, ref readonly Ve
 }
 
 
-readonly struct LessThanOrEqualAllOperator<T>
+public readonly struct LessThanOrEqualAllOperator<T>
     : IBinaryToScalarOperator<T, T, bool>
     where T : struct, IComparisonOperators<T, T, bool>
 {
@@ -352,7 +352,7 @@ public static bool Invoke(ref readonly Vector<T> x, ref readonly Vector<T> y)
         => Vector.LessThanOrEqualAll(x, y);
 }
 
-readonly struct LessThanOrEqualAnyOperator<T>
+public readonly struct LessThanOrEqualAnyOperator<T>
     : IBinaryToScalarOperator<T, T, bool>
     where T : struct, IComparisonOperators<T, T, bool>
 {
diff --git a/src/NetFabric.Numerics.Tensors/Operators/DecrementOperators.cs b/src/NetFabric.Numerics.Tensors/Operators/DecrementOperators.cs
index c23f037..d87830a 100644
--- a/src/NetFabric.Numerics.Tensors/Operators/DecrementOperators.cs
+++ b/src/NetFabric.Numerics.Tensors/Operators/DecrementOperators.cs
@@ -1,6 +1,6 @@
-namespace NetFabric.Numerics.Tensors;
+namespace NetFabric.Numerics.Tensors.Operators;
 
-readonly struct DecrementOperator<T>
+public readonly struct DecrementOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, IDecrementOperators<T>
 {
@@ -15,7 +15,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct CheckedDecrementOperator<T>
+public readonly struct CheckedDecrementOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, IDecrementOperators<T>
 {
diff --git a/src/NetFabric.Numerics.Tensors/Operators/DivisionOperators.cs b/src/NetFabric.Numerics.Tensors/Operators/DivisionOperators.cs
index f5265cd..cae6049 100644
--- a/src/NetFabric.Numerics.Tensors/Operators/DivisionOperators.cs
+++ b/src/NetFabric.Numerics.Tensors/Operators/DivisionOperators.cs
@@ -1,6 +1,6 @@
-namespace NetFabric.Numerics.Tensors;
+namespace NetFabric.Numerics.Tensors.Operators;
 
-readonly struct DivideOperator<T>
+public readonly struct DivideOperator<T>
     : IBinaryOperator<T, T, T>
     where T : struct, IDivisionOperators<T, T, T>
 {
@@ -13,7 +13,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x, ref readonly Vector<T>
         => x / y;
 }
 
-readonly struct CheckedDivideOperator<T>
+public readonly struct CheckedDivideOperator<T>
     : IBinaryOperator<T, T, T>
     where T : struct, IDivisionOperators<T, T, T>
 {
diff --git a/src/NetFabric.Numerics.Tensors/Operators/EqualityOperators.cs b/src/NetFabric.Numerics.Tensors/Operators/EqualityOperators.cs
index 83e7a22..e5e27d3 100644
--- a/src/NetFabric.Numerics.Tensors/Operators/EqualityOperators.cs
+++ b/src/NetFabric.Numerics.Tensors/Operators/EqualityOperators.cs
@@ -1,6 +1,6 @@
-namespace NetFabric.Numerics.Tensors;
+namespace NetFabric.Numerics.Tensors.Operators;
 
-readonly struct EqualsAllOperator<T>
+public readonly struct EqualsAllOperator<T>
     : IBinaryToScalarOperator<T, T, bool>
     where T : struct, IEqualityOperators<T, T, bool>
 {
@@ -13,7 +13,7 @@ public static bool Invoke(ref readonly Vector<T> x, ref readonly Vector<T> y)
         => Vector.EqualsAll(x, y);
 }
 
-readonly struct EqualsAnyOperator<T>
+public readonly struct EqualsAnyOperator<T>
     : IBinaryToScalarOperator<T, T, bool>
     where T : struct, IEqualityOperators<T, T, bool>
 {
diff --git a/src/NetFabric.Numerics.Tensors/Operators/ExponentialOperators.cs b/src/NetFabric.Numerics.Tensors/Operators/ExponentialOperators.cs
index edb6f6a..0d15166 100644
--- a/src/NetFabric.Numerics.Tensors/Operators/ExponentialOperators.cs
+++ b/src/NetFabric.Numerics.Tensors/Operators/ExponentialOperators.cs
@@ -1,6 +1,6 @@
-namespace NetFabric.Numerics.Tensors;
+namespace NetFabric.Numerics.Tensors.Operators;
 
-readonly struct ExpOperator<T>
+public readonly struct ExpOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, IExponentialFunctions<T>
 {
@@ -17,7 +17,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct ExpM1Operator<T>
+public readonly struct ExpM1Operator<T>
     : IUnaryOperator<T, T>
     where T : struct, IExponentialFunctions<T>
 {
@@ -34,7 +34,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct Exp2Operator<T>
+public readonly struct Exp2Operator<T>
     : IUnaryOperator<T, T>
     where T : struct, IExponentialFunctions<T>
 {
@@ -51,7 +51,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct Exp2M1Operator<T>
+public readonly struct Exp2M1Operator<T>
     : IUnaryOperator<T, T>
     where T : struct, IExponentialFunctions<T>
 {
@@ -68,7 +68,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct Exp10Operator<T>
+public readonly struct Exp10Operator<T>
     : IUnaryOperator<T, T>
     where T : struct, IExponentialFunctions<T>
 {
@@ -85,7 +85,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct Exp10M1Operator<T>
+public readonly struct Exp10M1Operator<T>
     : IUnaryOperator<T, T>
     where T : struct, IExponentialFunctions<T>
 {
@@ -102,7 +102,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct SigmoidOperator<T>
+public readonly struct SigmoidOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, IExponentialFunctions<T>
 {
diff --git a/src/NetFabric.Numerics.Tensors/Operators/FloatingPointIeee754Operators.cs b/src/NetFabric.Numerics.Tensors/Operators/FloatingPointIeee754Operators.cs
index 0e4583d..416b223 100644
--- a/src/NetFabric.Numerics.Tensors/Operators/FloatingPointIeee754Operators.cs
+++ b/src/NetFabric.Numerics.Tensors/Operators/FloatingPointIeee754Operators.cs
@@ -1,6 +1,6 @@
-namespace NetFabric.Numerics.Tensors;
+namespace NetFabric.Numerics.Tensors.Operators;
 
-readonly struct Atan2Operator<T>
+public readonly struct Atan2Operator<T>
     : IBinaryOperator<T, T, T>
     where T : struct, IFloatingPointIeee754<T>
 {
@@ -17,7 +17,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x, ref readonly Vector<T>
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct Atan2PiOperator<T>
+public readonly struct Atan2PiOperator<T>
     : IBinaryOperator<T, T, T>
     where T : struct, IFloatingPointIeee754<T>
 {
@@ -34,7 +34,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x, ref readonly Vector<T>
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct BitDecrementOperator<T>
+public readonly struct BitDecrementOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, IFloatingPointIeee754<T>
 {
@@ -51,7 +51,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct BitIncrementOperator<T>
+public readonly struct BitIncrementOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, IFloatingPointIeee754<T>
 {
@@ -68,7 +68,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct FusedMultiplyAddOperator<T>
+public readonly struct FusedMultiplyAddOperator<T>
     : ITernaryOperator<T, T, T, T>
     where T : struct, IFloatingPointIeee754<T>
 {
@@ -81,7 +81,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x, ref readonly Vector<T>
         => (x * y) + z;
 }
 
-readonly struct Ieee754RemainderOperator<T>
+public readonly struct Ieee754RemainderOperator<T>
     : IBinaryOperator<T, T, T>
     where T : struct, IFloatingPointIeee754<T>
 {
@@ -98,7 +98,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x, ref readonly Vector<T>
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct ILogBOperator<T>
+public readonly struct ILogBOperator<T>
     : IUnaryOperator<T, int>
     where T : struct, IFloatingPointIeee754<T>
 {
@@ -115,7 +115,7 @@ public static Vector<int> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<int>>();
 }
 
-readonly struct LerpOperator<T>
+public readonly struct LerpOperator<T>
     : ITernaryOperator<T, T, T, T>
     where T : struct, IFloatingPointIeee754<T>
 {
@@ -132,7 +132,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x, ref readonly Vector<T>
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct ReciprocalEstimateOperator<T>
+public readonly struct ReciprocalEstimateOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, IFloatingPointIeee754<T>
 {
@@ -149,7 +149,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct ReciprocalSqrtEstimateOperator<T>
+public readonly struct ReciprocalSqrtEstimateOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, IFloatingPointIeee754<T>
 {
diff --git a/src/NetFabric.Numerics.Tensors/Operators/FloatingPointOperators.cs b/src/NetFabric.Numerics.Tensors/Operators/FloatingPointOperators.cs
index a1e7c12..ae449f6 100644
--- a/src/NetFabric.Numerics.Tensors/Operators/FloatingPointOperators.cs
+++ b/src/NetFabric.Numerics.Tensors/Operators/FloatingPointOperators.cs
@@ -1,6 +1,6 @@
-namespace NetFabric.Numerics.Tensors;
+namespace NetFabric.Numerics.Tensors.Operators;
 
-readonly struct FloorOperator<T>
+public readonly struct FloorOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, IFloatingPoint<T>
 {
@@ -17,7 +17,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct FloorSingleOperator
+public readonly struct FloorSingleOperator
     : IUnaryOperator<float, float>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -29,7 +29,7 @@ public static Vector<float> Invoke(ref readonly Vector<float> x)
         => Vector.Floor(x);
 }
 
-readonly struct FloorDoubleOperator
+public readonly struct FloorDoubleOperator
     : IUnaryOperator<double, double>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -41,7 +41,7 @@ public static Vector<double> Invoke(ref readonly Vector<double> x)
         => Vector.Floor(x);
 }
 
-readonly struct CeilingOperator<T>
+public readonly struct CeilingOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, IFloatingPoint<T>
 {
@@ -58,7 +58,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct CeilingSingleOperator
+public readonly struct CeilingSingleOperator
     : IUnaryOperator<float, float>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -70,7 +70,7 @@ public static Vector<float> Invoke(ref readonly Vector<float> x)
         => Vector.Ceiling(x);
 }
 
-readonly struct CeilingDoubleOperator
+public readonly struct CeilingDoubleOperator
     : IUnaryOperator<double, double>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -82,7 +82,7 @@ public static Vector<double> Invoke(ref readonly Vector<double> x)
         => Vector.Ceiling(x);
 }
 
-readonly struct RoundOperator<T>
+public readonly struct RoundOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, IFloatingPoint<T>
 {
@@ -99,7 +99,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct RoundDigitsOperator<T>
+public readonly struct RoundDigitsOperator<T>
     : IBinaryScalarOperator<T, int, T>
     where T : struct, IFloatingPoint<T>
 {
@@ -116,7 +116,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x, int digits)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct RoundModeOperator<T>
+public readonly struct RoundModeOperator<T>
     : IBinaryScalarOperator<T, MidpointRounding, T>
     where T : struct, IFloatingPoint<T>
 {
@@ -133,7 +133,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x, MidpointRounding mode)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct RoundDigitModeOperator<T>
+public readonly struct RoundDigitModeOperator<T>
     : IBinaryScalarOperator<T, (int digits, MidpointRounding mode), T>
     where T : struct, IFloatingPoint<T>
 {
@@ -150,7 +150,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x, (int digits, MidpointRo
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct TruncateOperator<T>
+public readonly struct TruncateOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, IFloatingPoint<T>
 {
diff --git a/src/NetFabric.Numerics.Tensors/Operators/HyperbolicOperators.cs b/src/NetFabric.Numerics.Tensors/Operators/HyperbolicOperators.cs
index 692492e..29a315f 100644
--- a/src/NetFabric.Numerics.Tensors/Operators/HyperbolicOperators.cs
+++ b/src/NetFabric.Numerics.Tensors/Operators/HyperbolicOperators.cs
@@ -1,6 +1,6 @@
-namespace NetFabric.Numerics.Tensors;
+namespace NetFabric.Numerics.Tensors.Operators;
 
-readonly struct AcoshOperator<T>
+public readonly struct AcoshOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, IHyperbolicFunctions<T>
 {
@@ -17,7 +17,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct AsinhOperator<T>
+public readonly struct AsinhOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, IHyperbolicFunctions<T>
 {
@@ -34,7 +34,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct AtanhOperator<T>
+public readonly struct AtanhOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, IHyperbolicFunctions<T>
 {
@@ -51,7 +51,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct CoshOperator<T>
+public readonly struct CoshOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, IHyperbolicFunctions<T>
 {
@@ -68,7 +68,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct SinhOperator<T>
+public readonly struct SinhOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, IHyperbolicFunctions<T>
 {
@@ -85,7 +85,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct TanhOperator<T>
+public readonly struct TanhOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, IHyperbolicFunctions<T>
 {
diff --git a/src/NetFabric.Numerics.Tensors/Operators/IdentityOperator.cs b/src/NetFabric.Numerics.Tensors/Operators/IdentityOperator.cs
index 261e238..674a351 100644
--- a/src/NetFabric.Numerics.Tensors/Operators/IdentityOperator.cs
+++ b/src/NetFabric.Numerics.Tensors/Operators/IdentityOperator.cs
@@ -1,6 +1,6 @@
-namespace NetFabric.Numerics.Tensors;
+namespace NetFabric.Numerics.Tensors.Operators;
 
-readonly struct IdentityOperator<T>
+public readonly struct IdentityOperator<T>
     : IUnaryOperator<T, T>
     where T : struct
 {
diff --git a/src/NetFabric.Numerics.Tensors/Operators/IncrementOperators.cs b/src/NetFabric.Numerics.Tensors/Operators/IncrementOperators.cs
index 5268378..f9db904 100644
--- a/src/NetFabric.Numerics.Tensors/Operators/IncrementOperators.cs
+++ b/src/NetFabric.Numerics.Tensors/Operators/IncrementOperators.cs
@@ -1,6 +1,6 @@
-namespace NetFabric.Numerics.Tensors;
+namespace NetFabric.Numerics.Tensors.Operators;
 
-readonly struct IncrementOperator<T>
+public readonly struct IncrementOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, IIncrementOperators<T>
 {
@@ -15,7 +15,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct CheckedIncrementOperator<T>
+public readonly struct CheckedIncrementOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, IIncrementOperators<T>
 {
diff --git a/src/NetFabric.Numerics.Tensors/Operators/LogarithmicOperators.cs b/src/NetFabric.Numerics.Tensors/Operators/LogarithmicOperators.cs
index 744fece..32ddfb0 100644
--- a/src/NetFabric.Numerics.Tensors/Operators/LogarithmicOperators.cs
+++ b/src/NetFabric.Numerics.Tensors/Operators/LogarithmicOperators.cs
@@ -1,6 +1,6 @@
-namespace NetFabric.Numerics.Tensors;
+namespace NetFabric.Numerics.Tensors.Operators;
 
-readonly struct LogOperator<T>
+public readonly struct LogOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, ILogarithmicFunctions<T>
 {
@@ -17,7 +17,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct LogBaseOperator<T>
+public readonly struct LogBaseOperator<T>
     : IBinaryScalarOperator<T, T, T>
     where T : struct, ILogarithmicFunctions<T>
 {
@@ -34,7 +34,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x, T newBase)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct LogP1Operator<T>
+public readonly struct LogP1Operator<T>
     : IUnaryOperator<T, T>
     where T : struct, ILogarithmicFunctions<T>
 {
@@ -51,7 +51,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct Log2Operator<T>
+public readonly struct Log2Operator<T>
     : IUnaryOperator<T, T>
     where T : struct, ILogarithmicFunctions<T>
 {
@@ -68,7 +68,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct Log2P1Operator<T>
+public readonly struct Log2P1Operator<T>
     : IUnaryOperator<T, T>
     where T : struct, ILogarithmicFunctions<T>
 {
@@ -85,7 +85,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct Log10Operator<T>
+public readonly struct Log10Operator<T>
     : IUnaryOperator<T, T>
     where T : struct, ILogarithmicFunctions<T>
 {
@@ -102,7 +102,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct Log10P1Operator<T>
+public readonly struct Log10P1Operator<T>
     : IUnaryOperator<T, T>
     where T : struct, ILogarithmicFunctions<T>
 {
diff --git a/src/NetFabric.Numerics.Tensors/Operators/MaxOperator.cs b/src/NetFabric.Numerics.Tensors/Operators/MaxOperator.cs
index 297e876..e5dc081 100644
--- a/src/NetFabric.Numerics.Tensors/Operators/MaxOperator.cs
+++ b/src/NetFabric.Numerics.Tensors/Operators/MaxOperator.cs
@@ -1,6 +1,6 @@
-namespace NetFabric.Numerics.Tensors;
+namespace NetFabric.Numerics.Tensors.Operators;
 
-readonly struct MaxAggregationOperator<T>
+public readonly struct MaxAggregationOperator<T>
     : IAggregationOperator<T, T>
     where T : struct, INumber<T>, IMinMaxValue<T>
 {
@@ -16,7 +16,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x, ref readonly Vector<T>
         => Vector.Max(x, y);
 }
 
-readonly struct MaxPropagateNaNOperator<T>
+public readonly struct MaxPropagateNaNOperator<T>
     : IBinaryOperator<T, T, T>
     where T : struct, INumber<T>
 {
@@ -37,7 +37,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x, ref readonly Vector<T>
             : Vector.Max(x, y); 
 }
 
-readonly struct MaxMagnitudeAggregationOperator<T>
+public readonly struct MaxMagnitudeAggregationOperator<T>
     : IAggregationOperator<T, T>
     where T : struct, INumberBase<T>, IMinMaxValue<T>
 {
@@ -60,7 +60,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x, ref readonly Vector<T>
     }
 }
 
-readonly struct MaxMagnitudePropagateNaNOperator<T>
+public readonly struct MaxMagnitudePropagateNaNOperator<T>
     : IBinaryOperator<T, T, T>
     where T : struct, INumberBase<T>
 {
diff --git a/src/NetFabric.Numerics.Tensors/Operators/MinOperator.cs b/src/NetFabric.Numerics.Tensors/Operators/MinOperator.cs
index 1b3c8f8..8d55d4c 100644
--- a/src/NetFabric.Numerics.Tensors/Operators/MinOperator.cs
+++ b/src/NetFabric.Numerics.Tensors/Operators/MinOperator.cs
@@ -1,6 +1,6 @@
-namespace NetFabric.Numerics.Tensors;
+namespace NetFabric.Numerics.Tensors.Operators;
 
-readonly struct MinAggregationOperator<T>
+public readonly struct MinAggregationOperator<T>
     : IAggregationOperator<T, T>
     where T : struct, INumber<T>, IMinMaxValue<T>
 {
@@ -16,7 +16,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x, ref readonly Vector<T>
         => Vector.Min(x, y);
 }
 
-readonly struct MinPropagateNaNOperator<T>
+public readonly struct MinPropagateNaNOperator<T>
     : IBinaryOperator<T, T, T>
     where T : struct, INumber<T>
 {
@@ -37,7 +37,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x, ref readonly Vector<T>
             : Vector.Min(x, y);
 }
 
-readonly struct MinMagnitudeAggregationOperator<T>
+public readonly struct MinMagnitudeAggregationOperator<T>
     : IAggregationOperator<T, T>
     where T : struct, INumberBase<T>, IMinMaxValue<T>
 {
@@ -60,7 +60,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x, ref readonly Vector<T>
     }
 }
 
-readonly struct MinMagnitudePropagateNaNOperator<T>
+public readonly struct MinMagnitudePropagateNaNOperator<T>
     : IBinaryOperator<T, T, T>
     where T : struct, INumberBase<T>
 {
diff --git a/src/NetFabric.Numerics.Tensors/Operators/ModulusOperators.cs b/src/NetFabric.Numerics.Tensors/Operators/ModulusOperators.cs
index 1c0c233..0102cce 100644
--- a/src/NetFabric.Numerics.Tensors/Operators/ModulusOperators.cs
+++ b/src/NetFabric.Numerics.Tensors/Operators/ModulusOperators.cs
@@ -1,6 +1,6 @@
-namespace NetFabric.Numerics.Tensors;
+namespace NetFabric.Numerics.Tensors.Operators;
 
-readonly struct ModulusOperator<T>
+public readonly struct ModulusOperator<T>
     : IBinaryOperator<T, T, T>
     where T : struct, IModulusOperators<T, T, T>
 {
diff --git a/src/NetFabric.Numerics.Tensors/Operators/MultiplyAddOperator.cs b/src/NetFabric.Numerics.Tensors/Operators/MultiplyAddOperator.cs
index b9a5227..4b57a16 100644
--- a/src/NetFabric.Numerics.Tensors/Operators/MultiplyAddOperator.cs
+++ b/src/NetFabric.Numerics.Tensors/Operators/MultiplyAddOperator.cs
@@ -1,6 +1,6 @@
-namespace NetFabric.Numerics.Tensors;
+namespace NetFabric.Numerics.Tensors.Operators;
 
-readonly struct MultiplyAddOperator<T>
+public readonly struct MultiplyAddOperator<T>
     : ITernaryOperator<T, T, T, T>
     where T : struct, IAdditionOperators<T, T, T>, IMultiplyOperators<T, T, T>
 {
diff --git a/src/NetFabric.Numerics.Tensors/Operators/MultiplyDivideOperator.cs b/src/NetFabric.Numerics.Tensors/Operators/MultiplyDivideOperator.cs
index 2a5f16f..73009cb 100644
--- a/src/NetFabric.Numerics.Tensors/Operators/MultiplyDivideOperator.cs
+++ b/src/NetFabric.Numerics.Tensors/Operators/MultiplyDivideOperator.cs
@@ -1,6 +1,6 @@
-namespace NetFabric.Numerics.Tensors;
+namespace NetFabric.Numerics.Tensors.Operators;
 
-readonly struct MultiplyDivideOperator<T>
+public readonly struct MultiplyDivideOperator<T>
     : ITernaryOperator<T, T, T, T>
     where T : struct, IMultiplyOperators<T, T, T>, IDivisionOperators<T, T, T>
 {
diff --git a/src/NetFabric.Numerics.Tensors/Operators/MultiplyOperators.cs b/src/NetFabric.Numerics.Tensors/Operators/MultiplyOperators.cs
index b144b03..68be658 100644
--- a/src/NetFabric.Numerics.Tensors/Operators/MultiplyOperators.cs
+++ b/src/NetFabric.Numerics.Tensors/Operators/MultiplyOperators.cs
@@ -1,6 +1,6 @@
-namespace NetFabric.Numerics.Tensors;
+namespace NetFabric.Numerics.Tensors.Operators;
 
-readonly struct MultiplyOperator<T>
+public readonly struct MultiplyOperator<T>
     : IBinaryOperator<T, T, T>
     where T : struct, IMultiplyOperators<T, T, T>
 {
@@ -13,7 +13,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x, ref readonly Vector<T>
         => x * y;
 }
 
-readonly struct CheckedMultiplyOperator<T>
+public readonly struct CheckedMultiplyOperator<T>
     : IBinaryOperator<T, T, T>
     where T : struct, IMultiplyOperators<T, T, T>
 {
@@ -30,7 +30,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x, ref readonly Vector<T>
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct MultiplyScalarOperator<T>
+public readonly struct MultiplyScalarOperator<T>
     : IBinaryScalarOperator<T, T, T>
     where T : struct, IMultiplyOperators<T, T, T>
 {
diff --git a/src/NetFabric.Numerics.Tensors/Operators/PowerFunctionsOperators.cs b/src/NetFabric.Numerics.Tensors/Operators/PowerFunctionsOperators.cs
index b00376b..1c80219 100644
--- a/src/NetFabric.Numerics.Tensors/Operators/PowerFunctionsOperators.cs
+++ b/src/NetFabric.Numerics.Tensors/Operators/PowerFunctionsOperators.cs
@@ -1,6 +1,6 @@
-namespace NetFabric.Numerics.Tensors;
+namespace NetFabric.Numerics.Tensors.Operators;
 
-readonly struct SquareOperator<T>
+public readonly struct SquareOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, IMultiplyOperators<T, T, T>
 {
@@ -13,7 +13,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => x * x;
 }
 
-readonly struct CubeOperator<T>
+public readonly struct CubeOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, IMultiplyOperators<T, T, T>
 {
@@ -26,7 +26,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => x * x * x;
 }
 
-readonly struct PowOperator<T>
+public readonly struct PowOperator<T>
     : IBinaryScalarOperator<T, T, T>
     where T : struct, IPowerFunctions<T>
 {
diff --git a/src/NetFabric.Numerics.Tensors/Operators/ProductOperator.cs b/src/NetFabric.Numerics.Tensors/Operators/ProductOperator.cs
index 5d35dfb..fb0829d 100644
--- a/src/NetFabric.Numerics.Tensors/Operators/ProductOperator.cs
+++ b/src/NetFabric.Numerics.Tensors/Operators/ProductOperator.cs
@@ -1,6 +1,6 @@
-namespace NetFabric.Numerics.Tensors;
+namespace NetFabric.Numerics.Tensors.Operators;
 
-readonly struct ProductOperator<T>
+public readonly struct ProductOperator<T>
     : IAggregationOperator<T, T>
     where T : struct, IMultiplicativeIdentity<T, T>, IMultiplyOperators<T, T, T>
 {
diff --git a/src/NetFabric.Numerics.Tensors/Operators/RootFunctionsOperators.cs b/src/NetFabric.Numerics.Tensors/Operators/RootFunctionsOperators.cs
index 8923825..d41922e 100644
--- a/src/NetFabric.Numerics.Tensors/Operators/RootFunctionsOperators.cs
+++ b/src/NetFabric.Numerics.Tensors/Operators/RootFunctionsOperators.cs
@@ -1,6 +1,6 @@
-namespace NetFabric.Numerics.Tensors;
+namespace NetFabric.Numerics.Tensors.Operators;
 
-readonly struct CbrtOperator<T>
+public readonly struct CbrtOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, IRootFunctions<T>
 {
@@ -17,7 +17,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct HypotOperator<T>
+public readonly struct HypotOperator<T>
     : IBinaryOperator<T, T, T>
     where T : struct, IRootFunctions<T>
 {
@@ -34,7 +34,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x, ref readonly Vector<T>
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct RootNOperator<T>
+public readonly struct RootNOperator<T>
     : IBinaryScalarOperator<T, int, T>
     where T : struct, IRootFunctions<T>
 {
@@ -51,7 +51,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x, int y)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct SqrtOperator<T>
+public readonly struct SqrtOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, IRootFunctions<T>
 {
diff --git a/src/NetFabric.Numerics.Tensors/Operators/ShiftLeftOperator.cs b/src/NetFabric.Numerics.Tensors/Operators/ShiftLeftOperator.cs
index e1f86ed..8fdcb9f 100644
--- a/src/NetFabric.Numerics.Tensors/Operators/ShiftLeftOperator.cs
+++ b/src/NetFabric.Numerics.Tensors/Operators/ShiftLeftOperator.cs
@@ -1,6 +1,6 @@
-namespace NetFabric.Numerics.Tensors;
+namespace NetFabric.Numerics.Tensors.Operators;
 
-readonly struct ShiftLeftOperator<T, TResult>
+public readonly struct ShiftLeftOperator<T, TResult>
     : IBinaryScalarOperator<T, int, TResult>
     where T : struct, IShiftOperators<T, int, TResult>
     where TResult : struct
@@ -16,7 +16,7 @@ public static Vector<TResult> Invoke(ref readonly Vector<T> value, int count)
         => Throw.NotSupportedException<Vector<TResult>>();
 }
 
-readonly struct ShiftLeftSByteOperator
+public readonly struct ShiftLeftSByteOperator
     : IBinaryScalarOperator<sbyte, int, sbyte>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -28,7 +28,7 @@ public static Vector<sbyte> Invoke(ref readonly Vector<sbyte> value, int count)
         => Vector.ShiftLeft(value, count);
 }
 
-readonly struct ShiftLeftUInt16Operator
+public readonly struct ShiftLeftUInt16Operator
     : IBinaryScalarOperator<ushort, int, ushort>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -40,7 +40,7 @@ public static Vector<ushort> Invoke(ref readonly Vector<ushort> value, int count
         => Vector.ShiftLeft(value, count);
 }
 
-readonly struct ShiftLeftUInt32Operator
+public readonly struct ShiftLeftUInt32Operator
     : IBinaryScalarOperator<uint, int, uint>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -52,7 +52,7 @@ public static Vector<uint> Invoke(ref readonly Vector<uint> value, int count)
         => Vector.ShiftLeft(value, count);
 }
 
-readonly struct ShiftLeftUInt64Operator
+public readonly struct ShiftLeftUInt64Operator
     : IBinaryScalarOperator<ulong, int, ulong>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -64,7 +64,7 @@ public static Vector<ulong> Invoke(ref readonly Vector<ulong> value, int count)
         => Vector.ShiftLeft(value, count);
 }
 
-readonly struct ShiftLeftUIntPtrOperator
+public readonly struct ShiftLeftUIntPtrOperator
     : IBinaryScalarOperator<UIntPtr, int, UIntPtr>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -76,7 +76,7 @@ public static Vector<UIntPtr> Invoke(ref readonly Vector<UIntPtr> value, int cou
         => Vector.ShiftLeft(value, count);
 }
 
-readonly struct ShiftLeftByteOperator
+public readonly struct ShiftLeftByteOperator
     : IBinaryScalarOperator<byte, int, byte>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -88,7 +88,7 @@ public static Vector<byte> Invoke(ref readonly Vector<byte> value, int count)
         => Vector.ShiftLeft(value, count);
 }
 
-readonly struct ShiftLeftInt16Operator
+public readonly struct ShiftLeftInt16Operator
     : IBinaryScalarOperator<short, int, short>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -100,7 +100,7 @@ public static Vector<short> Invoke(ref readonly Vector<short> value, int count)
         => Vector.ShiftLeft(value, count);
 }
 
-readonly struct ShiftLeftInt32Operator
+public readonly struct ShiftLeftInt32Operator
     : IBinaryScalarOperator<int, int, int>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -112,7 +112,7 @@ public static Vector<int> Invoke(ref readonly Vector<int> value, int count)
         => Vector.ShiftLeft(value, count);
 }
 
-readonly struct ShiftLeftInt64Operator
+public readonly struct ShiftLeftInt64Operator
     : IBinaryScalarOperator<long, int, long>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -124,7 +124,7 @@ public static Vector<long> Invoke(ref readonly Vector<long> value, int count)
         => Vector.ShiftLeft(value, count);
 }
 
-readonly struct ShiftLeftIntPtrOperator
+public readonly struct ShiftLeftIntPtrOperator
     : IBinaryScalarOperator<IntPtr, int, IntPtr>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
diff --git a/src/NetFabric.Numerics.Tensors/Operators/ShiftRightAritmeticOperator.cs b/src/NetFabric.Numerics.Tensors/Operators/ShiftRightAritmeticOperator.cs
index 0fa2642..f4fec8e 100644
--- a/src/NetFabric.Numerics.Tensors/Operators/ShiftRightAritmeticOperator.cs
+++ b/src/NetFabric.Numerics.Tensors/Operators/ShiftRightAritmeticOperator.cs
@@ -1,6 +1,6 @@
-namespace NetFabric.Numerics.Tensors;
+namespace NetFabric.Numerics.Tensors.Operators;
 
-readonly struct ShiftRightArithmeticOperator<T, TResult>
+public readonly struct ShiftRightArithmeticOperator<T, TResult>
     : IBinaryScalarOperator<T, int, TResult>
     where T : struct, IShiftOperators<T, int, TResult>
     where TResult : struct
@@ -16,7 +16,7 @@ public static Vector<TResult> Invoke(ref readonly Vector<T> value, int count)
         => Throw.NotSupportedException<Vector<TResult>>();
 }
 
-readonly struct ShiftRightArithmeticSByteOperator
+public readonly struct ShiftRightArithmeticSByteOperator
     : IBinaryScalarOperator<sbyte, int, sbyte>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -28,7 +28,7 @@ public static Vector<sbyte> Invoke(ref readonly Vector<sbyte> value, int count)
         => Vector.ShiftRightArithmetic(value, count);
 }
 
-readonly struct ShiftRightArithmeticInt16Operator
+public readonly struct ShiftRightArithmeticInt16Operator
     : IBinaryScalarOperator<short, int, short>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -40,7 +40,7 @@ public static Vector<short> Invoke(ref readonly Vector<short> value, int count)
         => Vector.ShiftRightArithmetic(value, count);
 }
 
-readonly struct ShiftRightArithmeticInt32Operator
+public readonly struct ShiftRightArithmeticInt32Operator
     : IBinaryScalarOperator<int, int, int>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -52,7 +52,7 @@ public static Vector<int> Invoke(ref readonly Vector<int> value, int count)
         => Vector.ShiftRightArithmetic(value, count);
 }
 
-readonly struct ShiftRightArithmeticInt64Operator
+public readonly struct ShiftRightArithmeticInt64Operator
     : IBinaryScalarOperator<long, int, long>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -64,7 +64,7 @@ public static Vector<long> Invoke(ref readonly Vector<long> value, int count)
         => Vector.ShiftRightArithmetic(value, count);
 }
 
-readonly struct ShiftRightArithmeticIntPtrOperator
+public readonly struct ShiftRightArithmeticIntPtrOperator
     : IBinaryScalarOperator<IntPtr, int, IntPtr>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
diff --git a/src/NetFabric.Numerics.Tensors/Operators/ShiftRightLogicalOperator.cs b/src/NetFabric.Numerics.Tensors/Operators/ShiftRightLogicalOperator.cs
index c4489b8..8e219e9 100644
--- a/src/NetFabric.Numerics.Tensors/Operators/ShiftRightLogicalOperator.cs
+++ b/src/NetFabric.Numerics.Tensors/Operators/ShiftRightLogicalOperator.cs
@@ -1,6 +1,6 @@
-namespace NetFabric.Numerics.Tensors;
+namespace NetFabric.Numerics.Tensors.Operators;
 
-readonly struct ShiftRightLogicalOperator<T, TResult>
+public readonly struct ShiftRightLogicalOperator<T, TResult>
     : IBinaryScalarOperator<T, int, TResult>
     where T : struct, IShiftOperators<T, int, TResult>
     where TResult : struct
@@ -16,7 +16,7 @@ public static Vector<TResult> Invoke(ref readonly Vector<T> value, int count)
         => Throw.NotSupportedException<Vector<TResult>>();
 }
 
-readonly struct ShiftRightLogicalByteOperator
+public readonly struct ShiftRightLogicalByteOperator
     : IBinaryScalarOperator<byte, int, byte>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -28,7 +28,7 @@ public static Vector<byte> Invoke(ref readonly Vector<byte> value, int count)
         => Vector.ShiftRightLogical(value, count);
 }
 
-readonly struct ShiftRightLogicalUInt16Operator
+public readonly struct ShiftRightLogicalUInt16Operator
     : IBinaryScalarOperator<ushort, int, ushort>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -40,7 +40,7 @@ public static Vector<ushort> Invoke(ref readonly Vector<ushort> value, int count
         => Vector.ShiftRightLogical(value, count);
 }
 
-readonly struct ShiftRightLogicalUInt32Operator
+public readonly struct ShiftRightLogicalUInt32Operator
     : IBinaryScalarOperator<uint, int, uint>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -52,7 +52,7 @@ public static Vector<uint> Invoke(ref readonly Vector<uint> value, int count)
         => Vector.ShiftRightLogical(value, count);
 }
 
-readonly struct ShiftRightLogicalUInt64Operator
+public readonly struct ShiftRightLogicalUInt64Operator
     : IBinaryScalarOperator<ulong, int, ulong>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -64,7 +64,7 @@ public static Vector<ulong> Invoke(ref readonly Vector<ulong> value, int count)
         => Vector.ShiftRightLogical(value, count);
 }
 
-readonly struct ShiftRightLogicalUIntPtrOperator
+public readonly struct ShiftRightLogicalUIntPtrOperator
     : IBinaryScalarOperator<UIntPtr, int, UIntPtr>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -76,7 +76,7 @@ public static Vector<UIntPtr> Invoke(ref readonly Vector<UIntPtr> value, int cou
         => Vector.ShiftRightLogical(value, count);
 }
 
-readonly struct ShiftRightLogicalSByteOperator
+public readonly struct ShiftRightLogicalSByteOperator
     : IBinaryScalarOperator<sbyte, int, sbyte>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -88,7 +88,7 @@ public static Vector<sbyte> Invoke(ref readonly Vector<sbyte> value, int count)
         => Vector.ShiftRightLogical(value, count);
 }
 
-readonly struct ShiftRightLogicalInt16Operator
+public readonly struct ShiftRightLogicalInt16Operator
     : IBinaryScalarOperator<short, int, short>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -100,7 +100,7 @@ public static Vector<short> Invoke(ref readonly Vector<short> value, int count)
         => Vector.ShiftRightLogical(value, count);
 }
 
-readonly struct ShiftRightLogicalInt32Operator
+public readonly struct ShiftRightLogicalInt32Operator
     : IBinaryScalarOperator<int, int, int>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -112,7 +112,7 @@ public static Vector<int> Invoke(ref readonly Vector<int> value, int count)
         => Vector.ShiftRightLogical(value, count);
 }
 
-readonly struct ShiftRightLogicalInt64Operator
+public readonly struct ShiftRightLogicalInt64Operator
     : IBinaryScalarOperator<long, int, long>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -124,7 +124,7 @@ public static Vector<long> Invoke(ref readonly Vector<long> value, int count)
         => Vector.ShiftRightLogical(value, count);
 }
 
-readonly struct ShiftRightLogicalIntPtrOperator
+public readonly struct ShiftRightLogicalIntPtrOperator
     : IBinaryScalarOperator<IntPtr, int, IntPtr>
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
diff --git a/src/NetFabric.Numerics.Tensors/Operators/SubtractionOperators.cs b/src/NetFabric.Numerics.Tensors/Operators/SubtractionOperators.cs
index 72cab2d..fbad986 100644
--- a/src/NetFabric.Numerics.Tensors/Operators/SubtractionOperators.cs
+++ b/src/NetFabric.Numerics.Tensors/Operators/SubtractionOperators.cs
@@ -1,6 +1,6 @@
-namespace NetFabric.Numerics.Tensors;
+namespace NetFabric.Numerics.Tensors.Operators;
 
-readonly struct SubtractOperator<T>
+public readonly struct SubtractOperator<T>
     : IBinaryOperator<T, T, T>
     where T : struct, ISubtractionOperators<T, T, T>
 {
@@ -13,7 +13,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x, ref readonly Vector<T>
         => x - y;
 }
 
-readonly struct CheckedSubtractOperator<T>
+public readonly struct CheckedSubtractOperator<T>
     : IBinaryOperator<T, T, T>
     where T : struct, ISubtractionOperators<T, T, T>
 {
diff --git a/src/NetFabric.Numerics.Tensors/Operators/SumOperator.cs b/src/NetFabric.Numerics.Tensors/Operators/SumOperator.cs
index 4c8ca03..24f8ccc 100644
--- a/src/NetFabric.Numerics.Tensors/Operators/SumOperator.cs
+++ b/src/NetFabric.Numerics.Tensors/Operators/SumOperator.cs
@@ -1,6 +1,6 @@
-namespace NetFabric.Numerics.Tensors;
+namespace NetFabric.Numerics.Tensors.Operators;
 
-readonly struct SumOperator<T>
+public readonly struct SumOperator<T>
     : IAggregationOperator<T, T>
     where T : struct, IAdditiveIdentity<T, T>, IAdditionOperators<T, T, T>
 {
diff --git a/src/NetFabric.Numerics.Tensors/Operators/TrigonometricOperators.cs b/src/NetFabric.Numerics.Tensors/Operators/TrigonometricOperators.cs
index d96427d..131e29a 100644
--- a/src/NetFabric.Numerics.Tensors/Operators/TrigonometricOperators.cs
+++ b/src/NetFabric.Numerics.Tensors/Operators/TrigonometricOperators.cs
@@ -1,6 +1,6 @@
-namespace NetFabric.Numerics.Tensors;
+namespace NetFabric.Numerics.Tensors.Operators;
 
-readonly struct AcosOperator<T>
+public readonly struct AcosOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, ITrigonometricFunctions<T>
 {
@@ -17,7 +17,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct AcosPiOperator<T>
+public readonly struct AcosPiOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, ITrigonometricFunctions<T>
 {
@@ -34,7 +34,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct AsinOperator<T>
+public readonly struct AsinOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, ITrigonometricFunctions<T>
 {
@@ -51,7 +51,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct AsinPiOperator<T>
+public readonly struct AsinPiOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, ITrigonometricFunctions<T>
 {
@@ -68,7 +68,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct AtanOperator<T>
+public readonly struct AtanOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, ITrigonometricFunctions<T>
 {
@@ -85,7 +85,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct AtanPiOperator<T>
+public readonly struct AtanPiOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, ITrigonometricFunctions<T>
 {
@@ -102,7 +102,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct CosOperator<T>
+public readonly struct CosOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, ITrigonometricFunctions<T>
 {
@@ -119,7 +119,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct CosPiOperator<T>
+public readonly struct CosPiOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, ITrigonometricFunctions<T>
 {
@@ -136,7 +136,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct SinOperator<T>
+public readonly struct SinOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, ITrigonometricFunctions<T>
 {
@@ -153,7 +153,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct SinPiOperator<T>
+public readonly struct SinPiOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, ITrigonometricFunctions<T>
 {
@@ -170,7 +170,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct TanOperator<T>
+public readonly struct TanOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, ITrigonometricFunctions<T>
 {
@@ -187,7 +187,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct TanPiOperator<T>
+public readonly struct TanPiOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, ITrigonometricFunctions<T>
 {
@@ -204,7 +204,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> x)
         => Throw.InvalidOperationException<Vector<T>>();
 }
 
-readonly struct SinCosOperator<T>
+public readonly struct SinCosOperator<T>
     : IUnaryOperator<T, (T Sin, T Cos)>
     where T : struct, ITrigonometricFunctions<T>
 {
@@ -221,7 +221,7 @@ public static (T Sin, T Cos) Invoke(T x)
         => Throw.InvalidOperationException<Vector<(T Sin, T Cos)>>();
 }
 
-readonly struct SinCosPiOperator<T>
+public readonly struct SinCosPiOperator<T>
     : IUnaryOperator<T, (T SinPi, T CosPi)>
     where T : struct, ITrigonometricFunctions<T>
 {
diff --git a/src/NetFabric.Numerics.Tensors/Operators/UnaryNegationOperator.cs b/src/NetFabric.Numerics.Tensors/Operators/UnaryNegationOperator.cs
index 8f78435..ff41a08 100644
--- a/src/NetFabric.Numerics.Tensors/Operators/UnaryNegationOperator.cs
+++ b/src/NetFabric.Numerics.Tensors/Operators/UnaryNegationOperator.cs
@@ -1,6 +1,6 @@
-namespace NetFabric.Numerics.Tensors;
+namespace NetFabric.Numerics.Tensors.Operators;
 
-readonly struct NegateOperator<T>
+public readonly struct NegateOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, IUnaryNegationOperators<T, T>
 {
@@ -13,7 +13,7 @@ public static Vector<T> Invoke(ref readonly Vector<T> value)
         => -value;
 }
 
-readonly struct CheckedNegateOperator<T>
+public readonly struct CheckedNegateOperator<T>
     : IUnaryOperator<T, T>
     where T : struct, IUnaryNegationOperators<T, T>
 {