Return decimal for decimal-based quantities

CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs

@@ -262,11 +262,11 @@ private void GenerateProperties()
         public {_valueType} Value => _value;
 ");
 
-            // Need to provide explicit interface implementation for decimal quantities like Information
-            if (_quantity.ValueType != "double")
-                Writer.WL(@"
-        double IQuantity.Value => (double) _value;
+            Writer.WL(@"
+        /// <inheritdoc />
+        QuantityValue IQuantity.Value => _value;
 ");
+            // Need to provide explicit interface implementation for decimal quantities like Information
             if (_quantity.ValueType == "decimal")
                 Writer.WL(@"
         /// <inheritdoc cref=""IDecimalQuantity.Value""/>
@@ -306,11 +306,11 @@ private void GenerateConversionProperties()
 
                 Writer.WL($@"
         /// <summary>
-        ///     Gets a <see cref=""double""/> value of this quantity converted into <see cref=""{_unitEnumName}.{unit.SingularName}""/>
+        ///     Gets a <see cref=""{_quantity.ValueType}""/> value of this quantity converted into <see cref=""{_unitEnumName}.{unit.SingularName}""/>
         /// </summary>");
                 Writer.WLIfText(2, GetObsoleteAttributeOrNull(unit));
                 Writer.WL($@"
-        public double {unit.PluralName} => As({_unitEnumName}.{unit.SingularName});
+        public {_quantity.ValueType} {unit.PluralName} => As({_unitEnumName}.{unit.SingularName});
 ");
             }
 
@@ -651,7 +651,7 @@ private void GenerateArithmeticOperators()
         }}
 
         /// <summary>Get ratio value from dividing <see cref=""{_quantity.Name}""/> by <see cref=""{_quantity.Name}""/>.</summary>
-        public static double operator /({_quantity.Name} left, {_quantity.Name} right)
+        public static {_quantity.ValueType} operator /({_quantity.Name} left, {_quantity.Name} right)
         {{
             return left.{_baseUnit.PluralName} / right.{_baseUnit.PluralName};
         }}
@@ -806,13 +806,13 @@ public int CompareTo({_quantity.Name} other)
         /// <param name=""tolerance"">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
         /// <param name=""comparisonType"">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
-        public bool Equals({_quantity.Name} other, double tolerance, ComparisonType comparisonType)
+        public bool Equals({_quantity.Name} other, {_quantity.ValueType} tolerance, ComparisonType comparisonType)
         {{
             if (tolerance < 0)
                 throw new ArgumentOutOfRangeException(""tolerance"", ""Tolerance must be greater than or equal to 0."");
 
-            double thisValue = (double)this.Value;
-            double otherValueInThisUnits = other.As(this.Unit);
+            {_quantity.ValueType} thisValue = this.Value;
+            {_quantity.ValueType} otherValueInThisUnits = other.As(this.Unit);
 
             return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
         }}
@@ -839,17 +839,30 @@ private void GenerateConversionMethods()
         ///     Convert to the unit representation <paramref name=""unit"" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public double As({_unitEnumName} unit)
+        public {_quantity.ValueType} As({_unitEnumName} unit)
         {{
             if (Unit == unit)
-                return Convert.ToDouble(Value);
+                return Value;
+
+            return GetValueAs(unit);
+        }}
+");
 
-            var converted = GetValueAs(unit);
-            return Convert.ToDouble(converted);
+            if (_quantity.ValueType == "decimal")
+            {
+                Writer.WL($@"
+
+        double IQuantity<{_unitEnumName}>.As({_unitEnumName} unit)
+        {{
+            return (double)As(unit);
         }}
+");
+            }
+
+            Writer.WL($@"
 
         /// <inheritdoc cref=""IQuantity.As(UnitSystem)""/>
-        public double As(UnitSystem unitSystem)
+        public {_quantity.ValueType} As(UnitSystem unitSystem)
         {{
             if (unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -862,14 +875,27 @@ public double As(UnitSystem unitSystem)
 
             return As(firstUnitInfo.Value);
         }}
+");
+
+            if (_quantity.ValueType == "decimal")
+            {
+                Writer.WL($@"
+         /// <inheritdoc cref=""IQuantity.As(UnitSystem)""/>
+        double IQuantity.As(UnitSystem unitSystem)
+        {{
+            return (double)As(unitSystem);
+        }}
+");
+            }
 
+            Writer.WL($@"
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
         {{
-            if (!(unit is {_unitEnumName} unitAs{_unitEnumName}))
+            if (!(unit is {_unitEnumName} typedUnit))
                 throw new ArgumentException($""The given unit is of type {{unit.GetType()}}. Only {{typeof({_unitEnumName})}} is supported."", nameof(unit));
 
-            return As(unitAs{_unitEnumName});
+            return (double)As(typedUnit);
         }}
 
         /// <summary>
@@ -916,10 +942,10 @@ double IQuantity.As(Enum unit)
         /// <inheritdoc />
         IQuantity IQuantity.ToUnit(Enum unit)
         {{
-            if (!(unit is {_unitEnumName} unitAs{_unitEnumName}))
+            if (!(unit is {_unitEnumName} typedUnit))
                 throw new ArgumentException($""The given unit is of type {{unit.GetType()}}. Only {{typeof({_unitEnumName})}} is supported."", nameof(unit));
 
-            return ToUnit(unitAs{_unitEnumName}, DefaultConversionFunctions);
+            return ToUnit(typedUnit, DefaultConversionFunctions);
         }}
 
         /// <inheritdoc cref=""IQuantity.ToUnit(UnitSystem)""/>

CodeGen/Generators/UnitsNetGen/UnitTestBaseClassGenerator.cs

@@ -102,7 +102,7 @@ public abstract partial class {_quantity.Name}TestsBase : QuantityTestsBase
                     continue;
 
                 Writer.WL($@"
-        protected abstract double {unit.PluralName}InOne{_baseUnit.SingularName} {{ get; }}");
+        protected abstract {_quantity.ValueType} {unit.PluralName}InOne{_baseUnit.SingularName} {{ get; }}");
             }
 
             Writer.WL("");
@@ -114,12 +114,12 @@ public abstract partial class {_quantity.Name}TestsBase : QuantityTestsBase
                     continue;
 
                 Writer.WL($@"
-        protected virtual double {unit.PluralName}Tolerance {{ get {{ return 1e-5; }} }}");
+        protected virtual {_quantity.ValueType} {unit.PluralName}Tolerance {{ get {{ return { (_quantity.ValueType == "decimal" ? "1e-9m" : "1e-5") }; }} }}");
             }
         Writer.WL($@"
 // ReSharper restore VirtualMemberNeverOverriden.Global
 
-        protected (double UnitsInBaseUnit, double Tolerence) GetConversionFactor({_unitEnumName} unit)
+        protected ({_quantity.ValueType} UnitsInBaseUnit, {_quantity.ValueType} Tolerence) GetConversionFactor({_unitEnumName} unit)
         {{
             return unit switch
             {{");
@@ -355,7 +355,7 @@ public void ToUnit({_unitEnumName} unit)
             var converted = inBaseUnits.ToUnit(unit);
 
             var conversionFactor = GetConversionFactor(unit);
-            AssertEx.EqualTolerance(conversionFactor.UnitsInBaseUnit, (double)converted.Value, conversionFactor.Tolerence);
+            AssertEx.EqualTolerance(conversionFactor.UnitsInBaseUnit, converted.Value, conversionFactor.Tolerence);
             Assert.Equal(unit, converted.Unit);
         }}
 

Common/UnitDefinitions/Power.json

@@ -85,8 +85,8 @@
     {
       "SingularName": "BritishThermalUnitPerHour",
       "PluralName": "BritishThermalUnitsPerHour",
-      "FromUnitToBaseFunc": "{x} * 0.293071m",
-      "FromBaseToUnitFunc": "{x} / 0.293071m",
+      "FromUnitToBaseFunc": "{x} * 0.29307107017m",
+      "FromBaseToUnitFunc": "{x} / 0.29307107017m",
       "Prefixes": [ "Kilo", "Mega" ],
       "Localization": [
         {

UnitsNet.Serialization.JsonNet.Tests/UnitsNetBaseJsonConverterTest.cs

@@ -54,7 +54,7 @@ public void UnitsNetBaseJsonConverter_ConvertValueUnit_works_as_expected()
 
             Assert.NotNull(result);
             Assert.IsType<Power>(result);
-            Assert.True(Power.FromWatts(10.2365m).Equals((Power)result, 1E-5, ComparisonType.Absolute));
+            Assert.True(Power.FromWatts(10.2365m).Equals((Power)result, 1E-5m, ComparisonType.Absolute));
 
         }
 

UnitsNet.Serialization.JsonNet.Tests/UnitsNetIComparableJsonConverterTest.cs

@@ -117,7 +117,7 @@ public void UnitsNetIComparableJsonConverter_ReadJson_works_as_expected()
 
             Assert.NotNull(result);
             Assert.IsType<Power>(result);
-            Assert.Equal(120D, ((Power)result).Watts);
+            Assert.Equal(120M, ((Power)result).Watts);
         }
     }
 }

UnitsNet.Serialization.JsonNet.Tests/UnitsNetIQuantityJsonConverterTest.cs

@@ -135,7 +135,7 @@ public void UnitsNetIQuantityJsonConverter_ReadJson_works_as_expected()
 
             Assert.NotNull(result);
             Assert.IsType<Power>(result);
-            Assert.Equal(10.3654D, ((Power)result).Watts);
+            Assert.Equal(10.3654M, ((Power)result).Watts);
         }
     }
 }

UnitsNet.Serialization.JsonNet/AbbreviatedUnitsConverter.cs

@@ -85,7 +85,7 @@ public override void WriteJson(JsonWriter writer, IQuantity? quantity, JsonSeria
             }
             else
             {
-                writer.WriteValue(quantity.Value);
+                writer.WriteValue((double)quantity.Value);
             }
 
             //  write the 'Unit' abbreviation

UnitsNet.Serialization.JsonNet/UnitsNetBaseJsonConverter.cs

@@ -186,13 +186,14 @@ protected ValueUnit ConvertIQuantity(IQuantity quantity)
                 return new ExtendedValueUnit
                 {
                     Unit = $"{quantity.QuantityInfo.UnitType.Name}.{quantity.Unit}",
-                    Value = quantity.Value,
+                    // The type of "Value" is still double
+                    Value = (double)quantity.Value,
                     ValueString = d.Value.ToString(CultureInfo.InvariantCulture),
                     ValueType = "decimal"
                 };
             }
 
-            return new ValueUnit {Value = quantity.Value, Unit = $"{quantity.QuantityInfo.UnitType.Name}.{quantity.Unit}"};
+            return new ValueUnit {Value = (double)quantity.Value, Unit = $"{quantity.QuantityInfo.UnitType.Name}.{quantity.Unit}"};
         }
 
         /// <summary>

UnitsNet.Tests/AssertEx.cs

@@ -25,5 +25,23 @@ public static void EqualTolerance(double expected, double actual, double toleran
                 Assert.True( areEqual, $"Values are not equal within absolute tolerance: {tolerance}\nExpected: {expected}\nActual: {actual}\nDiff: {actual - expected:e}" );
             }
         }
+
+        public static void EqualTolerance(decimal expected, decimal actual, decimal tolerance, ComparisonType comparisonType = ComparisonType.Relative)
+        {
+            if (comparisonType == ComparisonType.Relative)
+            {
+                bool areEqual = Comparison.EqualsRelative(expected, actual, tolerance);
+
+                decimal difference = Math.Abs(expected - actual);
+                decimal relativeDifference = difference / expected;
+
+                Assert.True(areEqual, $"Values are not equal within relative tolerance: {tolerance:P4}\nExpected: {expected}\nActual: {actual}\nDiff: {relativeDifference:P4}");
+            }
+            else if (comparisonType == ComparisonType.Absolute)
+            {
+                bool areEqual = Comparison.EqualsAbsolute(expected, actual, tolerance);
+                Assert.True(areEqual, $"Values are not equal within absolute tolerance: {tolerance}\nExpected: {expected}\nActual: {actual}\nDiff: {actual - expected:e}");
+            }
+        }
     }
 }

UnitsNet.Tests/CustomCode/BitRateTests.cs

@@ -29,37 +29,37 @@ public class BitRateTests : BitRateTestsBase
     {
         protected override bool SupportsSIUnitSystem => false;
 
-        protected override double BitsPerSecondInOneBitPerSecond => 1d;
-        protected override double BytesPerSecondInOneBitPerSecond => 1.25E-1d;
+        protected override decimal BitsPerSecondInOneBitPerSecond => 1m;
+        protected override decimal BytesPerSecondInOneBitPerSecond => 1.25E-1m;
 
-        protected override double KilobitsPerSecondInOneBitPerSecond => 1E-3d;
-        protected override double KilobytesPerSecondInOneBitPerSecond => 1.25E-4d;
-        protected override double KibibitsPerSecondInOneBitPerSecond => 0.0009765625d;
-        protected override double KibibytesPerSecondInOneBitPerSecond => 0.0001220703125d;
+        protected override decimal KilobitsPerSecondInOneBitPerSecond => 1E-3m;
+        protected override decimal KilobytesPerSecondInOneBitPerSecond => 1.25E-4m;
+        protected override decimal KibibitsPerSecondInOneBitPerSecond => 0.0009765625m;
+        protected override decimal KibibytesPerSecondInOneBitPerSecond => 0.0001220703125m;
 
-        protected override double MegabitsPerSecondInOneBitPerSecond => 1E-6d;
-        protected override double MegabytesPerSecondInOneBitPerSecond => 1.25E-07d;
-        protected override double MebibitsPerSecondInOneBitPerSecond => 9.5367431640625E-07d;
-        protected override double MebibytesPerSecondInOneBitPerSecond => 1.19209289550781E-07d;
+        protected override decimal MegabitsPerSecondInOneBitPerSecond => 1E-6m;
+        protected override decimal MegabytesPerSecondInOneBitPerSecond => 1.25E-07m;
+        protected override decimal MebibitsPerSecondInOneBitPerSecond => 9.5367431640625E-07m;
+        protected override decimal MebibytesPerSecondInOneBitPerSecond => 1.19209289550781E-07m;
 
-        protected override double GigabitsPerSecondInOneBitPerSecond => 1E-9d;
-        protected override double GigabytesPerSecondInOneBitPerSecond => 1.25E-10d;
-        protected override double GibibitsPerSecondInOneBitPerSecond => 9.31322574615479E-10d;
-        protected override double GibibytesPerSecondInOneBitPerSecond => 1.16415321826935E-10d;
+        protected override decimal GigabitsPerSecondInOneBitPerSecond => 1E-9m;
+        protected override decimal GigabytesPerSecondInOneBitPerSecond => 1.25E-10m;
+        protected override decimal GibibitsPerSecondInOneBitPerSecond => 9.31322574615479E-10m;
+        protected override decimal GibibytesPerSecondInOneBitPerSecond => 1.16415321826935E-10m;
 
-        protected override double TerabitsPerSecondInOneBitPerSecond => 1E-12d;
-        protected override double TerabytesPerSecondInOneBitPerSecond => 1.25E-13d;
-        protected override double TebibitsPerSecondInOneBitPerSecond => 9.09494701772928E-13d;
-        protected override double TebibytesPerSecondInOneBitPerSecond => 1.13686837721616E-13d;
+        protected override decimal TerabitsPerSecondInOneBitPerSecond => 1E-12m;
+        protected override decimal TerabytesPerSecondInOneBitPerSecond => 1.25E-13m;
+        protected override decimal TebibitsPerSecondInOneBitPerSecond => 9.09494701772928E-13m;
+        protected override decimal TebibytesPerSecondInOneBitPerSecond => 1.13686837721616E-13m;
 
-        protected override double PetabitsPerSecondInOneBitPerSecond => 1E-15d;
-        protected override double PetabytesPerSecondInOneBitPerSecond => 1.25E-16d;
-        protected override double PebibitsPerSecondInOneBitPerSecond => 8.88178419700125E-16d;
-        protected override double PebibytesPerSecondInOneBitPerSecond => 1.11022302462516E-16d;
+        protected override decimal PetabitsPerSecondInOneBitPerSecond => 1E-15m;
+        protected override decimal PetabytesPerSecondInOneBitPerSecond => 1.25E-16m;
+        protected override decimal PebibitsPerSecondInOneBitPerSecond => 8.88178419700125E-16m;
+        protected override decimal PebibytesPerSecondInOneBitPerSecond => 1.11022302462516E-16m;
 
-        protected override double ExabitsPerSecondInOneBitPerSecond => 1E-18d;
-        protected override double ExabytesPerSecondInOneBitPerSecond => 1.25E-19d;
-        protected override double ExbibitsPerSecondInOneBitPerSecond => 8.67361738E-19d;
-        protected override double ExbibytesPerSecondInOneBitPerSecond => 1.0842021724855E-19d;
+        protected override decimal ExabitsPerSecondInOneBitPerSecond => 1E-18m;
+        protected override decimal ExabytesPerSecondInOneBitPerSecond => 1.25E-19m;
+        protected override decimal ExbibitsPerSecondInOneBitPerSecond => 8.67361738E-19m;
+        protected override decimal ExbibytesPerSecondInOneBitPerSecond => 1.0842021724855E-19m;
     }
 }