Added DataSize implementation (#31)

Author: MrMatthewLayton

OnixLabs.Core.UnitTests/Units/DataSizeTests.cs

@@ -0,0 +1,43 @@
+// Copyright © 2020 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.Numerics;
+
+namespace OnixLabs.Core.Numerics;
+
+/// <summary>
+/// Provides generic mathematical functions.
+/// </summary>
+internal static class GenericMath
+{
+    /// <summary>
+    /// Calculates the power of the specified value, raised by the specified exponent.
+    /// </summary>
+    /// <param name="value">The value to raise to the power of the specified exponent.</param>
+    /// <param name="exponent">The specified exponent to raise the value by.</param>
+    /// <typeparam name="T">The underlying <see cref="INumber{TSelf}"/> type.</typeparam>
+    /// <returns>Returns the power of the specified value, raised by the specified exponent.</returns>
+    public static T Pow<T>(T value, int exponent) where T : INumber<T>
+    {
+        if (exponent == 0) return T.One;
+        if (exponent == 1 || value == T.One) return value;
+
+        T result = value;
+        int count = int.Abs(exponent);
+
+        while (--count > 0) result *= value;
+
+        return exponent > 1 ? result : T.One / result;
+    }
+}

OnixLabs.Core/Numerics/GenericMath.cs

@@ -51,4 +51,5 @@
     </ItemGroup>
 
 
+
 </Project>

OnixLabs.Core/OnixLabs.Core.csproj

@@ -0,0 +1,106 @@
+// Copyright © 2020 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.Core.Units;
+
+public readonly partial struct DataSize<T>
+{
+    /// <summary>
+    /// Computes the sum of the specified <see cref="DataSize{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="DataSize{T}"/> values.</returns>
+    public static DataSize<T> Add(DataSize<T> left, DataSize<T> right)
+    {
+        return new DataSize<T>(left.Bits + right.Bits);
+    }
+
+    /// <summary>
+    /// Computes the difference between the specified <see cref="DataSize{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 between the specified <see cref="DataSize{T}"/> values.</returns>
+    public static DataSize<T> Subtract(DataSize<T> left, DataSize<T> right)
+    {
+        return new DataSize<T>(left.Bits - right.Bits);
+    }
+
+    /// <summary>
+    /// Computes the product of the specified <see cref="DataSize{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="DataSize{T}"/> values.</returns>
+    public static DataSize<T> Multiply(DataSize<T> left, DataSize<T> right)
+    {
+        return new DataSize<T>(left.Bits * right.Bits);
+    }
+
+    /// <summary>
+    /// Computes the quotient of the specified <see cref="DataSize{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="DataSize{T}"/> values.</returns>
+    public static DataSize<T> Divide(DataSize<T> left, DataSize<T> right)
+    {
+        return new DataSize<T>(left.Bits / right.Bits);
+    }
+
+    /// <summary>
+    /// Computes the sum of the specified <see cref="DataSize{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="DataSize{T}"/> values.</returns>
+    public static DataSize<T> operator +(DataSize<T> left, DataSize<T> right)
+    {
+        return Add(left, right);
+    }
+
+    /// <summary>
+    /// Computes the difference between the specified <see cref="DataSize{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 between the specified <see cref="DataSize{T}"/> values.</returns>
+    public static DataSize<T> operator -(DataSize<T> left, DataSize<T> right)
+    {
+        return Subtract(left, right);
+    }
+
+    /// <summary>
+    /// Computes the product of the specified <see cref="DataSize{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="DataSize{T}"/> values.</returns>
+    public static DataSize<T> operator *(DataSize<T> left, DataSize<T> right)
+    {
+        return Multiply(left, right);
+    }
+
+    /// <summary>
+    /// Computes the quotient of the specified <see cref="DataSize{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="DataSize{T}"/> values.</returns>
+    public static DataSize<T> operator /(DataSize<T> left, DataSize<T> right)
+    {
+        return Divide(left, right);
+    }
+}

OnixLabs.Core/Units/DataSize.Arithmetic.cs

@@ -0,0 +1,100 @@
+// Copyright © 2020 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;
+
+namespace OnixLabs.Core.Units;
+
+public readonly partial struct DataSize<T> : IComparable<DataSize<T>>, IComparable
+{
+    /// <summary>
+    /// Compares two <see cref="DataSize{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(DataSize<T> left, DataSize<T> right)
+    {
+        return left.Bits.CompareTo(right.Bits);
+    }
+
+    /// <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(DataSize<T> other)
+    {
+        return 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>
+    public int CompareTo(object? obj)
+    {
+        return this.CompareObject(obj);
+    }
+
+    /// <summary>
+    /// Performs a greater than comparison check between two <see cref="DataSize{T}"/> values.
+    /// </summary>
+    /// <param name="left">The left-hand value to compare.</param>
+    /// <param name="right">The right-hand value to compare.</param>
+    /// <returns>Returns true if the left-hand operand is greater than right-hand operand; otherwise, false.</returns>
+    public static bool operator >(DataSize<T> left, DataSize<T> right)
+    {
+        return Compare(left, right) is 1;
+    }
+
+    /// <summary>
+    /// Performs a greater than or equal comparison check between two <see cref="DataSize{T}"/> values.
+    /// </summary>
+    /// <param name="left">The left-hand value to compare.</param>
+    /// <param name="right">The right-hand value to compare.</param>
+    /// <returns>Returns true if the left-hand operand is greater than or equal to right-hand operand; otherwise, false.</returns>
+    public static bool operator >=(DataSize<T> left, DataSize<T> right)
+    {
+        return Compare(left, right) is 1 or 0;
+    }
+
+    /// <summary>
+    /// Performs a less than comparison check between two <see cref="DataSize{T}"/> values.
+    /// </summary>
+    /// <param name="left">The left-hand value to compare.</param>
+    /// <param name="right">The right-hand value to compare.</param>
+    /// <returns>Returns true if the left-hand operand is less than right-hand operand; otherwise, false.</returns>
+    public static bool operator <(DataSize<T> left, DataSize<T> right)
+    {
+        return Compare(left, right) is -1;
+    }
+
+    /// <summary>
+    /// Performs a less than or equal comparison check between two <see cref="DataSize{T}"/> values.
+    /// </summary>
+    /// <param name="left">The left-hand value to compare.</param>
+    /// <param name="right">The right-hand value to compare.</param>
+    /// <returns>Returns true if the left-hand operand is less than or equal to right-hand operand; otherwise, false.</returns>
+    public static bool operator <=(DataSize<T> left, DataSize<T> right)
+    {
+        return Compare(left, right) is -1 or 0;
+    }
+}

OnixLabs.Core/Units/DataSize.Comparable.cs

@@ -0,0 +1,63 @@
+// Copyright © 2020 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.Core.Units;
+
+public readonly partial struct DataSize<T>
+{
+    /// <summary>
+    /// Represents a zero-bit <see cref="DataSize{T}"/> value.
+    /// </summary>
+    public static DataSize<T> Zero => default;
+
+    /// <summary>
+    /// Gets the number of bits per nibble.
+    /// </summary>
+    private static T BitsPerNibble => T.CreateChecked(4);
+
+    /// <summary>
+    /// Gets the number of bits per byte.
+    /// </summary>
+    private static T BitsPerByte => T.CreateChecked(8);
+
+    /// <summary>
+    /// Gets the number of bits per word.
+    /// </summary>
+    private static T BitsPerWord => T.CreateChecked(16);
+
+    /// <summary>
+    /// Gets the number of bits per double-word.
+    /// </summary>
+    private static T BitsPerDoubleWord => T.CreateChecked(32);
+
+    /// <summary>
+    /// Gets the number of bits per quad-word.
+    /// </summary>
+    private static T BitsPerQuadWord => T.CreateChecked(64);
+
+    /// <summary>
+    /// Gets the value of a binary thousand.
+    /// </summary>
+    private static T BinaryThousand => T.CreateChecked(1024);
+
+    /// <summary>
+    /// Gets the value of a decimal thousand.
+    /// </summary>
+    private static T DecimalThousand => T.CreateChecked(1000);
+    
+    /// <summary>
+    /// Gets the default format.
+    /// </summary>
+    private const string DefaultFormat = "b";
+}