Added Speed unit and tests.

Author: MrMatthewLayton

OnixLabs.Units.UnitTests/SpeedTests.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 Speed<T>
+{
+    /// <summary>
+    /// Computes the sum of the specified <see cref="Speed{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="Speed{T}"/> values.</returns>
+    public static Speed<T> Add(Speed<T> left, Speed<T> right) => new(left.QuectoMetersPerSecond + right.QuectoMetersPerSecond);
+
+    /// <summary>
+    /// Computes the sum of the specified <see cref="Speed{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="Speed{T}"/> values.</returns>
+    public static Speed<T> operator +(Speed<T> left, Speed<T> right) => Add(left, right);
+
+    /// <summary>
+    /// Computes the sum of the current <see cref="Speed{T}"/> value and the specified other <see cref="Speed{T}"/> value.
+    /// </summary>
+    /// <param name="other">The value to add to the current <see cref="Speed{T}"/> value.</param>
+    /// <returns>Returns the sum of the current <see cref="Speed{T}"/> value and the specified other <see cref="Speed{T}"/> value.</returns>
+    public Speed<T> Add(Speed<T> other) => Add(this, other);
+}

OnixLabs.Units/Speed.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 Speed<T>
+{
+    /// <summary>
+    /// Computes the quotient of the specified <see cref="Speed{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="Speed{T}"/> values.</returns>
+    public static Speed<T> Divide(Speed<T> left, Speed<T> right) => new(left.QuectoMetersPerSecond / right.QuectoMetersPerSecond);
+
+    /// <summary>
+    /// Computes the quotient of the specified <see cref="Speed{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="Speed{T}"/> values.</returns>
+    public static Speed<T> operator /(Speed<T> left, Speed<T> right) => Divide(left, right);
+
+    /// <summary>
+    /// Computes the quotient of the current <see cref="Speed{T}"/> value divided by the specified other <see cref="Speed{T}"/> value.
+    /// </summary>
+    /// <param name="other">The value to divide the current <see cref="Speed{T}"/> value by.</param>
+    /// <returns>Returns the quotient of the current <see cref="Speed{T}"/> value divided by the specified other <see cref="Speed{T}"/> value.</returns>
+    public Speed<T> Divide(Speed<T> other) => Divide(this, other);
+}

OnixLabs.Units/Speed.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 Speed<T>
+{
+    /// <summary>
+    /// Computes the product of the specified <see cref="Speed{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="Speed{T}"/> values.</returns>
+    public static Speed<T> Multiply(Speed<T> left, Speed<T> right) => new(left.QuectoMetersPerSecond * right.QuectoMetersPerSecond);
+
+    /// <summary>
+    /// Computes the product of the specified <see cref="Speed{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="Speed{T}"/> values.</returns>
+    public static Speed<T> operator *(Speed<T> left, Speed<T> right) => Multiply(left, right);
+
+    /// <summary>
+    /// Computes the product of the current <see cref="Speed{T}"/> value multiplied by the specified other <see cref="Speed{T}"/> value.
+    /// </summary>
+    /// <param name="other">The value to multiply the current <see cref="Speed{T}"/> value by.</param>
+    /// <returns>Returns the product of the current <see cref="Speed{T}"/> value multiplied by the specified other <see cref="Speed{T}"/> value.</returns>
+    public Speed<T> Multiply(Speed<T> other) => Multiply(this, other);
+}

OnixLabs.Units/Speed.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 Speed<T>
+{
+    /// <summary>
+    /// Computes the difference of the specified <see cref="Speed{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="Speed{T}"/> values.</returns>
+    public static Speed<T> Subtract(Speed<T> left, Speed<T> right) => new(left.QuectoMetersPerSecond - right.QuectoMetersPerSecond);
+
+    /// <summary>
+    /// Computes the difference of the specified <see cref="Speed{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="Speed{T}"/> values.</returns>
+    public static Speed<T> operator -(Speed<T> left, Speed<T> right) => Subtract(left, right);
+
+    /// <summary>
+    /// Computes the difference of the current <see cref="Speed{T}"/> value and the specified other <see cref="Speed{T}"/> value.
+    /// </summary>
+    /// <param name="other">The value to subtract from the current <see cref="Speed{T}"/> value.</param>
+    /// <returns>Returns the difference of the current <see cref="Speed{T}"/> value and the specified other <see cref="Speed{T}"/> value.</returns>
+    public Speed<T> Subtract(Speed<T> other) => Subtract(this, other);
+}

OnixLabs.Units/Speed.Arithmetic.Subtraction.cs

@@ -0,0 +1,79 @@
+// 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;
+
+// ReSharper disable MemberCanBePrivate.Global
+public readonly partial struct Speed<T>
+{
+    /// <summary>
+    /// Compares two <see cref="Speed{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(Speed<T> left, Speed<T> right) => left.QuectoMetersPerSecond.CompareTo(right.QuectoMetersPerSecond);
+
+    /// <summary>
+    /// Compares the current instance with another instance of <see cref="Speed{T}"/> 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 instance of <see cref="Speed{T}"/> to compare with this instance.</param>
+    /// <returns>Returns a value that indicates the relative order of the objects being compared.</returns>
+    public int CompareTo(Speed<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 the right-hand operand; otherwise, <see langword="false"/>.</returns>
+    public static bool operator >(Speed<T> left, Speed<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 >=(Speed<T> left, Speed<T> right) => Compare(left, right) is 1 or 0;
+
+    /// <summary>
+    /// Determines whether the left-hand value is less 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 less than the right-hand operand; otherwise, <see langword="false"/>.</returns>
+    public static bool operator <(Speed<T> left, Speed<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 <=(Speed<T> left, Speed<T> right) => Compare(left, right) is -1 or 0;
+}

OnixLabs.Units/Speed.Comparable.cs

@@ -0,0 +1,54 @@
+// 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 Speed<T>
+{
+    /// <summary>
+    /// Gets a zero <see cref="Speed{T}"/> value, equal to zero quectometers per second.
+    /// </summary>
+    public static readonly Speed<T> Zero = new(T.Zero);
+
+    private const string QuectoMetersPerSecondSpecifier = "qmps";
+    private const string RontoMetersPerSecondSpecifier = "rmps";
+    private const string YoctoMetersPerSecondSpecifier = "ymps";
+    private const string ZeptoMetersPerSecondSpecifier = "zmps";
+    private const string AttoMetersPerSecondSpecifier = "amps";
+    private const string FemtoMetersPerSecondSpecifier = "fmps";
+    private const string PicoMetersPerSecondSpecifier = "pmps";
+    private const string NanoMetersPerSecondSpecifier = "nmps";
+    private const string MicroMetersPerSecondSpecifier = "umps";
+    private const string MilliMetersPerSecondSpecifier = "mmps";
+    private const string CentiMetersPerSecondSpecifier = "cmps";
+    private const string DeciMetersPerSecondSpecifier = "dmps";
+    private const string MetersPerSecondSpecifier = "mps";
+    private const string DecaMetersPerSecondSpecifier = "damps";
+    private const string HectoMetersPerSecondSpecifier = "hmps";
+    private const string KiloMetersPerSecondSpecifier = "kmps";
+    private const string MegaMetersPerSecondSpecifier = "Mmps";
+    private const string GigaMetersPerSecondSpecifier = "Gmps";
+    private const string TeraMetersPerSecondSpecifier = "Tmps";
+    private const string PetaMetersPerSecondSpecifier = "Pmps";
+    private const string ExaMetersPerSecondSpecifier = "Emps";
+    private const string ZettaMetersPerSecondSpecifier = "Zmps";
+    private const string YottaMetersPerSecondSpecifier = "Ymps";
+    private const string RonnaMetersPerSecondSpecifier = "Rmps";
+    private const string QuettaMetersPerSecondSpecifier = "Qmps";
+    private const string InchesPerSecondSpecifier = "ips";
+    private const string FeetPerSecondSpecifier = "fps";
+    private const string KilometersPerHourSpecifier = "kmph";
+    private const string MilesPerHourSpecifier = "mph";
+    private const string KnotsSpecifier = "kt";
+}

OnixLabs.Units/Speed.Constants.cs

@@ -0,0 +1,65 @@
+// 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;
+
+// ReSharper disable MemberCanBePrivate.Global
+public readonly partial struct Speed<T>
+{
+    /// <summary>
+    /// Compares two instances of <see cref="Speed{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 <see cref="Speed{T}"/> instances are equal; otherwise, <see langword="false"/>.</returns>
+    public static bool Equals(Speed<T> left, Speed<T> right) => Equals(left.QuectoMetersPerSecond, right.QuectoMetersPerSecond);
+
+    /// <summary>
+    /// Compares the current instance of <see cref="Speed{T}"/> with the specified other instance of <see cref="Speed{T}"/>.
+    /// </summary>
+    /// <param name="other">The other instance of <see cref="Speed{T}"/> to compare with the current instance.</param>
+    /// <returns>Returns <see langword="true"/> if the current instance has the same value as the specified other instance; otherwise, <see langword="false"/>.</returns>
+    public bool Equals(Speed<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 Speed<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() => QuectoMetersPerSecond.GetHashCode();
+
+    /// <summary>
+    /// Compares two instances of <see cref="Speed{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 <see cref="Speed{T}"/> instances are equal; otherwise, <see langword="false"/>.</returns>
+    public static bool operator ==(Speed<T> left, Speed<T> right) => Equals(left, right);
+
+    /// <summary>
+    /// Compares two instances of <see cref="Speed{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 <see cref="Speed{T}"/> instances are not equal; otherwise, <see langword="false"/>.</returns>
+    public static bool operator !=(Speed<T> left, Speed<T> right) => !Equals(left, right);
+}