Added Force unit and unit tests.

Author: MrMatthewLayton

OnixLabs.Units.UnitTests/ForceTests.cs

@@ -0,0 +1,42 @@
+// Copyright 2020-2025 ONIXLabs
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace OnixLabs.Units;
+
+// ReSharper disable MemberCanBePrivate.Global
+public readonly partial struct Force<T>
+{
+    /// <summary>
+    /// Computes the sum of the specified <see cref="Force{T}"/> values.
+    /// </summary>
+    /// <param name="left">The left-hand value to add to.</param>
+    /// <param name="right">The right-hand value to add.</param>
+    /// <returns>Returns the sum of the specified <see cref="Force{T}"/> values.</returns>
+    public static Force<T> Add(Force<T> left, Force<T> right) => new(left.YoctoNewtons + right.YoctoNewtons);
+
+    /// <summary>
+    /// Computes the sum of the specified <see cref="Force{T}"/> values.
+    /// </summary>
+    /// <param name="left">The left-hand value to add to.</param>
+    /// <param name="right">The right-hand value to add.</param>
+    /// <returns>Returns the sum of the specified <see cref="Force{T}"/> values.</returns>
+    public static Force<T> operator +(Force<T> left, Force<T> right) => Add(left, right);
+
+    /// <summary>
+    /// Computes the sum of the current <see cref="Force{T}"/> value and the specified other <see cref="Force{T}"/> value.
+    /// </summary>
+    /// <param name="other">The value to add to the current <see cref="Force{T}"/> value.</param>
+    /// <returns>Returns the sum of the current <see cref="Force{T}"/> value and the specified other <see cref="Force{T}"/> value.</returns>
+    public Force<T> Add(Force<T> other) => Add(this, other);
+}

OnixLabs.Units/Force.Arithmetic.Addition.cs

@@ -0,0 +1,42 @@
+// Copyright 2020-2025 ONIXLabs
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace OnixLabs.Units;
+
+// ReSharper disable MemberCanBePrivate.Global
+public readonly partial struct Force<T>
+{
+    /// <summary>
+    /// Computes the quotient of the specified <see cref="Force{T}"/> values.
+    /// </summary>
+    /// <param name="left">The left-hand value to divide.</param>
+    /// <param name="right">The right-hand value to divide by.</param>
+    /// <returns>Returns the quotient of the specified <see cref="Force{T}"/> values.</returns>
+    public static Force<T> Divide(Force<T> left, Force<T> right) => new(left.YoctoNewtons / right.YoctoNewtons);
+
+    /// <summary>
+    /// Computes the quotient of the specified <see cref="Force{T}"/> values.
+    /// </summary>
+    /// <param name="left">The left-hand value to divide.</param>
+    /// <param name="right">The right-hand value to divide by.</param>
+    /// <returns>Returns the quotient of the specified <see cref="Force{T}"/> values.</returns>
+    public static Force<T> operator /(Force<T> left, Force<T> right) => Divide(left, right);
+
+    /// <summary>
+    /// Computes the quotient of the current <see cref="Force{T}"/> value, divided by the specified other <see cref="Force{T}"/> value.
+    /// </summary>
+    /// <param name="other">The value to divide the current <see cref="Force{T}"/> value by.</param>
+    /// <returns>Returns the quotient of the current <see cref="Force{T}"/> value, divided by the specified other <see cref="Force{T}"/> value.</returns>
+    public Force<T> Divide(Force<T> other) => Divide(this, other);
+}

OnixLabs.Units/Force.Arithmetic.Division.cs

@@ -0,0 +1,42 @@
+// Copyright 2020-2025 ONIXLabs
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace OnixLabs.Units;
+
+// ReSharper disable MemberCanBePrivate.Global
+public readonly partial struct Force<T>
+{
+    /// <summary>
+    /// Computes the product of the specified <see cref="Force{T}"/> values.
+    /// </summary>
+    /// <param name="left">The left-hand value to multiply.</param>
+    /// <param name="right">The right-hand value to multiply by.</param>
+    /// <returns>Returns the product of the specified <see cref="Force{T}"/> values.</returns>
+    public static Force<T> Multiply(Force<T> left, Force<T> right) => new(left.YoctoNewtons * right.YoctoNewtons);
+
+    /// <summary>
+    /// Computes the product of the specified <see cref="Force{T}"/> values.
+    /// </summary>
+    /// <param name="left">The left-hand value to multiply.</param>
+    /// <param name="right">The right-hand value to multiply by.</param>
+    /// <returns>Returns the product of the specified <see cref="Force{T}"/> values.</returns>
+    public static Force<T> operator *(Force<T> left, Force<T> right) => Multiply(left, right);
+
+    /// <summary>
+    /// Computes the product of the current <see cref="Force{T}"/> value, multiplied by the specified other <see cref="Force{T}"/> value.
+    /// </summary>
+    /// <param name="other">The value to multiply the current <see cref="Force{T}"/> value by.</param>
+    /// <returns>Returns the product of the current <see cref="Force{T}"/> value, multiplied by the specified other <see cref="Force{T}"/> value.</returns>
+    public Force<T> Multiply(Force<T> other) => Multiply(this, other);
+}

OnixLabs.Units/Force.Arithmetic.Multiplication.cs

@@ -0,0 +1,42 @@
+// Copyright 2020-2025 ONIXLabs
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace OnixLabs.Units;
+
+// ReSharper disable MemberCanBePrivate.Global
+public readonly partial struct Force<T>
+{
+    /// <summary>
+    /// Computes the difference of the specified <see cref="Force{T}"/> values.
+    /// </summary>
+    /// <param name="left">The left-hand value to subtract from.</param>
+    /// <param name="right">The right-hand value to subtract.</param>
+    /// <returns>Returns the difference of the specified <see cref="Force{T}"/> values.</returns>
+    public static Force<T> Subtract(Force<T> left, Force<T> right) => new(left.YoctoNewtons - right.YoctoNewtons);
+
+    /// <summary>
+    /// Computes the difference of the specified <see cref="Force{T}"/> values.
+    /// </summary>
+    /// <param name="left">The left-hand value to subtract from.</param>
+    /// <param name="right">The right-hand value to subtract.</param>
+    /// <returns>Returns the difference of the specified <see cref="Force{T}"/> values.</returns>
+    public static Force<T> operator -(Force<T> left, Force<T> right) => Subtract(left, right);
+
+    /// <summary>
+    /// Computes the difference of the specified other <see cref="Force{T}"/> value, subtracted from the current <see cref="Force{T}"/> value.
+    /// </summary>
+    /// <param name="other">The value to subtract from the current <see cref="Force{T}"/> value.</param>
+    /// <returns>Returns the difference of the specified other <see cref="Force{T}"/> value, subtracted from the current <see cref="Force{T}"/> value.</returns>
+    public Force<T> Subtract(Force<T> other) => Subtract(this, other);
+}

OnixLabs.Units/Force.Arithmetic.Subtraction.cs

@@ -0,0 +1,80 @@
+// Copyright 2020-2025 ONIXLabs
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using OnixLabs.Core;
+
+namespace OnixLabs.Units;
+
+public readonly partial struct Force<T>
+{
+    /// <summary>
+    /// Compares two <see cref="Force{T}"/> values and returns an integer that indicates
+    /// whether the left-hand value is less than, equal to, or greater than the right-hand value.
+    /// </summary>
+    /// <param name="left">The left-hand value to compare.</param>
+    /// <param name="right">The right-hand value to compare.</param>
+    /// <returns>Returns a value that indicates the relative order of the objects being compared.</returns>
+    public static int Compare(Force<T> left, Force<T> right) => left.YoctoNewtons.CompareTo(right.YoctoNewtons);
+
+    /// <summary>
+    /// Compares the current instance with another object of the same type and returns an integer that indicates
+    /// whether the current instance precedes, follows, or occurs in the same position in the sort order as the
+    /// other object.
+    /// </summary>
+    /// <param name="other">An object to compare with this instance.</param>
+    /// <returns>Returns a value that indicates the relative order of the objects being compared.</returns>
+    public int CompareTo(Force<T> other) => Compare(this, other);
+
+    /// <summary>
+    /// Compares the current instance with another object of the same type and returns an integer that indicates
+    /// whether the current instance precedes, follows, or occurs in the same position in the sort order as the
+    /// other object.
+    /// </summary>
+    /// <param name="obj">An object to compare with this instance.</param>
+    /// <returns>Returns a value that indicates the relative order of the objects being compared.</returns>
+    // ReSharper disable once HeapView.BoxingAllocation
+    public int CompareTo(object? obj) => this.CompareToObject(obj);
+
+    /// <summary>
+    /// Determines whether the left-hand value is greater than the right-hand value.
+    /// </summary>
+    /// <param name="left">The left-hand value to compare.</param>
+    /// <param name="right">The right-hand value to compare.</param>
+    /// <returns>Returns <see langword="true"/> if the left-hand operand is greater than right-hand operand; otherwise, <see langword="false"/>.</returns>
+    public static bool operator >(Force<T> left, Force<T> right) => Compare(left, right) is 1;
+
+    /// <summary>
+    /// Determines whether the left-hand value is greater than or equal to the right-hand value.
+    /// </summary>
+    /// <param name="left">The left-hand value to compare.</param>
+    /// <param name="right">The right-hand value to compare.</param>
+    /// <returns>Returns <see langword="true"/> if the left-hand operand is greater than or equal to the right-hand operand; otherwise, <see langword="false"/>.</returns>
+    public static bool operator >=(Force<T> left, Force<T> right) => Compare(left, right) is 1 or 0;
+
+    /// <summary>
+    /// Determines whether the left-hand value is less than right-hand value.
+    /// </summary>
+    /// <param name="left">The left-hand value to compare.</param>
+    /// <param name="right">The right-hand value to compare.</param>
+    /// <returns>Returns <see langword="true"/> if the left-hand operand is less than the right-hand operand; otherwise, <see langword="false"/>.</returns>
+    public static bool operator <(Force<T> left, Force<T> right) => Compare(left, right) is -1;
+
+    /// <summary>
+    /// Determines whether the left-hand value is less than or equal to the right-hand value.
+    /// </summary>
+    /// <param name="left">The left-hand value to compare.</param>
+    /// <param name="right">The right-hand value to compare.</param>
+    /// <returns>Returns <see langword="true"/> if the left-hand operand is less than or equal to the right-hand operand; otherwise, <see langword="false"/>.</returns>
+    public static bool operator <=(Force<T> left, Force<T> right) => Compare(left, right) is -1 or 0;
+}

OnixLabs.Units/Force.Comparable.cs

@@ -0,0 +1,50 @@
+// Copyright 2020-2025 ONIXLabs
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace OnixLabs.Units;
+
+public readonly partial struct Force<T>
+{
+    /// <summary>
+    /// Gets a zero <see cref="Force{T}"/> value, equal to zero yoctonewtons.
+    /// </summary>
+    public static readonly Force<T> Zero = new(T.Zero);
+
+    private const string YoctoNewtonsSpecifier = "yN";
+    private const string ZeptoNewtonsSpecifier = "zN";
+    private const string AttoNewtonsSpecifier = "aN";
+    private const string FemtoNewtonsSpecifier = "fN";
+    private const string PicoNewtonsSpecifier = "pN";
+    private const string NanoNewtonsSpecifier = "nN";
+    private const string MicroNewtonsSpecifier = "uN";
+    private const string MilliNewtonsSpecifier = "mN";
+    private const string NewtonsSpecifier = "N";
+    private const string KiloNewtonsSpecifier = "kN";
+    private const string MegaNewtonsSpecifier = "MN";
+    private const string GigaNewtonsSpecifier = "GN";
+    private const string TeraNewtonsSpecifier = "TN";
+    private const string PetaNewtonsSpecifier = "PN";
+    private const string ExaNewtonsSpecifier = "EN";
+    private const string ZettaNewtonsSpecifier = "ZN";
+    private const string YottaNewtonsSpecifier = "YN";
+    private const string DynesSpecifier = "dyn";
+    private const string KilogramForceSpecifier = "kgf";
+    private const string GramForceSpecifier = "gf";
+    private const string TonneForceSpecifier = "tf";
+    private const string PoundForceSpecifier = "lbf";
+    private const string OunceForceSpecifier = "ozf";
+    private const string PoundalsSpecifier = "pdl";
+    private const string ShortTonForceSpecifier = "tonf";
+    private const string LongTonForceSpecifier = "ltf";
+}

OnixLabs.Units/Force.Constants.cs

@@ -0,0 +1,64 @@
+// Copyright 2020-2025 ONIXLabs
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System.Diagnostics.CodeAnalysis;
+
+namespace OnixLabs.Units;
+
+public readonly partial struct Force<T>
+{
+    /// <summary>
+    /// Compares two instances of <see cref="Force{T}"/> to determine whether their values are equal.
+    /// </summary>
+    /// <param name="left">The left-hand value to compare.</param>
+    /// <param name="right">The right-hand value to compare.</param>
+    /// <returns>Returns <see langword="true"/> if the two specified instances are equal; otherwise, <see langword="false"/>.</returns>
+    public static bool Equals(Force<T> left, Force<T> right) => Equals(left.YoctoNewtons, right.YoctoNewtons);
+
+    /// <summary>
+    /// Compares the current instance of <see cref="Force{T}"/> with the specified other instance of <see cref="Force{T}"/>.
+    /// </summary>
+    /// <param name="other">The other instance of <see cref="Force{T}"/> to compare with the current instance.</param>
+    /// <returns>Returns <see langword="true"/> if the current instance is equal to the specified other instance; otherwise, <see langword="false"/>.</returns>
+    public bool Equals(Force<T> other) => Equals(this, other);
+
+    /// <summary>
+    /// Checks for equality between this instance and another object.
+    /// </summary>
+    /// <param name="obj">The object to check for equality.</param>
+    /// <returns>Returns <see langword="true"/> if the object is equal to this instance; otherwise, <see langword="false"/>.</returns>
+    public override bool Equals([NotNullWhen(true)] object? obj) => obj is Force<T> other && Equals(other);
+
+    /// <summary>
+    /// Serves as a hash code function for this instance.
+    /// </summary>
+    /// <returns>Returns a hash code for this instance.</returns>
+    public override int GetHashCode() => YoctoNewtons.GetHashCode();
+
+    /// <summary>
+    /// Compares two instances of <see cref="Force{T}"/> to determine whether their values are equal.
+    /// </summary>
+    /// <param name="left">The left-hand value to compare.</param>
+    /// <param name="right">The right-hand value to compare.</param>
+    /// <returns>Returns <see langword="true"/> if the two specified instances are equal; otherwise, <see langword="false"/>.</returns>
+    public static bool operator ==(Force<T> left, Force<T> right) => Equals(left, right);
+
+    /// <summary>
+    /// Compares two instances of <see cref="Force{T}"/> to determine whether their values are not equal.
+    /// </summary>
+    /// <param name="left">The left-hand value to compare.</param>
+    /// <param name="right">The right-hand value to compare.</param>
+    /// <returns>Returns <see langword="true"/> if the two specified instances are not equal; otherwise, <see langword="false"/>.</returns>
+    public static bool operator !=(Force<T> left, Force<T> right) => !Equals(left, right);
+}