Add Abs, Min(x, y) & Max(x, y) helper methods to the UnitMath (#859)

Author: lipchev

UnitsNet.Tests/UnitMathTests.cs

@@ -7,6 +7,44 @@ namespace UnitsNet.Tests
 {
     public class UnitMathTests
     {
+        [Fact]
+        public void AbsoluteValueOfZeroReturnsZero()
+        {
+            var quantity = Length.Zero;
+
+            var result = quantity.Abs();
+
+            Assert.StrictEqual(quantity, result);
+        }
+
+        [Fact]
+        public void AbsoluteValueOfPositiveReturnsSameValue()
+        {
+            var quantity = Length.FromCentimeters(1);
+
+            var result = quantity.Abs();
+
+            Assert.StrictEqual(quantity, result);
+        }
+
+        [Fact]
+        public void AbsoluteValueOfNegativeReturnsPositive()
+        {
+            var quantity = Length.FromCentimeters(-1);
+
+            var result = quantity.Abs();
+
+            Assert.StrictEqual(-quantity, result);
+        }
+
+        [Fact]
+        public void AbsoluteValueOfNullReferenceThrowsException()
+        {
+            IQuantity quantity = null;
+
+            Assert.Throws<NullReferenceException>(() => quantity.Abs());
+        }
+
         [Fact]
         public void AverageOfDifferentUnitsThrowsException()
         {
@@ -23,6 +61,14 @@ public void AverageOfEmptySourceThrowsException()
             Assert.Throws<InvalidOperationException>(() => units.Average(LengthUnit.Centimeter));
         }
 
+        [Fact]
+        public void AverageOfLengthsWithNullValueThrowsException()
+        {
+            var units = new IQuantity[] {Length.FromMeters(1), null};
+
+            Assert.Throws<NullReferenceException>(() => units.Average(LengthUnit.Centimeter));
+        }
+
         [Fact]
         public void AverageOfLengthsCalculatesCorrectly()
         {
@@ -61,6 +107,18 @@ public void AverageOfLengthsWithSelectorCalculatesCorrectly()
             Assert.Equal(LengthUnit.Centimeter, average.Unit);
         }
 
+        [Fact]
+        public void MaxOfTwoLengthsReturnsTheLargestValue()
+        {
+            var firstValue = Length.FromMeters(1);
+            var secondValue = Length.FromCentimeters(50);
+
+            Length max = UnitMath.Max(firstValue, secondValue);
+
+            Assert.Equal(1, max.Value);
+            Assert.Equal(LengthUnit.Meter, max.Unit);
+        }
+
         [Fact]
         public void MaxOfDifferentUnitsThrowsException()
         {
@@ -69,6 +127,14 @@ public void MaxOfDifferentUnitsThrowsException()
             Assert.Throws<ArgumentException>(() => units.Max(LengthUnit.Centimeter));
         }
 
+        [Fact]
+        public void MaxOfLengthsWithNullValueThrowsException()
+        {
+            var units = new IQuantity[] {Length.FromMeters(1), null};
+
+            Assert.Throws<NullReferenceException>(() => units.Max(LengthUnit.Centimeter));
+        }
+
         [Fact]
         public void MaxOfEmptySourceThrowsException()
         {
@@ -115,6 +181,18 @@ public void MaxOfLengthsWithSelectorCalculatesCorrectly()
             Assert.Equal(LengthUnit.Centimeter, max.Unit);
         }
 
+        [Fact]
+        public void MinOfTwoLengthsReturnsTheSmallestValue()
+        {
+            var firstValue = Length.FromMeters(1);
+            var secondValue = Length.FromCentimeters(50);
+
+            Length min = UnitMath.Min(firstValue, secondValue);
+
+            Assert.Equal(50, min.Value);
+            Assert.Equal(LengthUnit.Centimeter, min.Unit);
+        }
+
         [Fact]
         public void MinOfDifferentUnitsThrowsException()
         {
@@ -123,6 +201,14 @@ public void MinOfDifferentUnitsThrowsException()
             Assert.Throws<ArgumentException>(() => units.Min(LengthUnit.Centimeter));
         }
 
+        [Fact]
+        public void MinOfLengthsWithNullValueThrowsException()
+        {
+            var units = new IQuantity[] {Length.FromMeters(1), null};
+
+            Assert.Throws<NullReferenceException>(() => units.Min(LengthUnit.Centimeter));
+        }
+
         [Fact]
         public void MinOfEmptySourceThrowsException()
         {
@@ -177,6 +263,14 @@ public void SumOfDifferentUnitsThrowsException()
             Assert.Throws<ArgumentException>(() => units.Sum(LengthUnit.Centimeter));
         }
 
+        [Fact]
+        public void SumOfLengthsWithNullValueThrowsException()
+        {
+            var units = new IQuantity[] {Length.FromMeters(1), null};
+
+            Assert.Throws<NullReferenceException>(() => units.Sum(LengthUnit.Centimeter));
+        }
+
         [Fact]
         public void SumOfEmptySourceReturnsZero()
         {

UnitsNet/UnitMath.cs

@@ -9,6 +9,17 @@ namespace UnitsNet
     /// </summary>
     public static class UnitMath
     {
+        /// <summary>Returns the absolute value of a <typeparamref name="TQuantity" />.</summary>
+        /// <param name="value">
+        ///     A quantity with a value that is greater than or equal to <see cref="F:System.Double.MinValue" />,
+        ///     but less than or equal to <see cref="F:System.Double.MaxValue" />.
+        /// </param>
+        /// <returns>A quantity with a value, such that 0 ≤ value ≤ <see cref="F:System.Double.MaxValue" />.</returns>
+        public static TQuantity Abs<TQuantity>(this TQuantity value) where TQuantity : IQuantity
+        {
+            return value.Value >= 0 ? value : (TQuantity) Quantity.From(-value.Value, value.Unit);
+        }
+
         /// <summary>Computes the sum of a sequence of <typeparamref name="TQuantity" /> values.</summary>
         /// <param name="source">A sequence of <typeparamref name="TQuantity" /> values to calculate the sum of.</param>
         /// <param name="unitType">The desired unit type for the resulting quantity</param>
@@ -47,6 +58,16 @@ public static TQuantity Sum<TSource, TQuantity>(this IEnumerable<TSource> source
             return source.Select(selector).Sum(unitType);
         }
 
+        /// <summary>Returns the smaller of two <typeparamref name="TQuantity" /> values.</summary>
+        /// <typeparam name="TQuantity">The type of quantities to compare.</typeparam>
+        /// <param name="val1">The first of two <typeparamref name="TQuantity" /> values to compare.</param>
+        /// <param name="val2">The second of two <typeparamref name="TQuantity" /> values to compare.</param>
+        /// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is smaller.</returns>
+        public static TQuantity Min<TQuantity>(TQuantity val1, TQuantity val2) where TQuantity : IComparable, IQuantity
+        {
+            return val1.CompareTo(val2) == 1 ? val2 : val1;
+        }
+
         /// <summary>Computes the min of a sequence of <typeparamref name="TQuantity" /> values.</summary>
         /// <param name="source">A sequence of <typeparamref name="TQuantity" /> values to calculate the min of.</param>
         /// <param name="unitType">The desired unit type for the resulting quantity</param>
@@ -87,6 +108,16 @@ public static TQuantity Min<TSource, TQuantity>(this IEnumerable<TSource> source
             return source.Select(selector).Min(unitType);
         }
 
+        /// <summary>Returns the larger of two <typeparamref name="TQuantity" /> values.</summary>
+        /// <typeparam name="TQuantity">The type of quantities to compare.</typeparam>
+        /// <param name="val1">The first of two <typeparamref name="TQuantity" /> values to compare.</param>
+        /// <param name="val2">The second of two <typeparamref name="TQuantity" /> values to compare.</param>
+        /// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is larger.</returns>
+        public static TQuantity Max<TQuantity>(TQuantity val1, TQuantity val2) where TQuantity : IComparable, IQuantity
+        {
+            return val1.CompareTo(val2) == -1 ? val2 : val1;
+        }
+
         /// <summary>Computes the max of a sequence of <typeparamref name="TQuantity" /> values.</summary>
         /// <param name="source">A sequence of <typeparamref name="TQuantity" /> values to calculate the max of.</param>
         /// <param name="unitType">The desired unit type for the resulting quantity</param>