QuantityValue implemented as a fractional number 🐲

Build/build-functions.psm1

@@ -63,7 +63,8 @@ function Start-Tests {
   $projectPaths = @(
     "UnitsNet.Tests\UnitsNet.Tests.csproj",
     "UnitsNet.NumberExtensions.Tests\UnitsNet.NumberExtensions.Tests.csproj",
-    "UnitsNet.Serialization.JsonNet.Tests\UnitsNet.Serialization.JsonNet.Tests.csproj"
+    "UnitsNet.Serialization.JsonNet.Tests\UnitsNet.Serialization.JsonNet.Tests.csproj",
+    "UnitsNet.Serialization.SystemTextJson.Tests\UnitsNet.Serialization.SystemTextJson.csproj"
     )
 
   # Parent dir must exist before xunit tries to write files to it
@@ -102,6 +103,7 @@ function Start-PackNugets([boolean] $IncludeNanoFramework = $false) {
   $projectPaths = @(
     "UnitsNet\UnitsNet.csproj",
     "UnitsNet.Serialization.JsonNet\UnitsNet.Serialization.JsonNet.csproj",
+    "UnitsNet.Serialization.SystemTextJson\UnitsNet.Serialization.SystemTextJson.csproj",
     "UnitsNet.NumberExtensions\UnitsNet.NumberExtensions.csproj"
     )
 

CodeGen/CodeGen.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
@@ -10,6 +10,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="Fractions" />
     <PackageReference Include="Newtonsoft.Json" />
     <PackageReference Include="NuGet.Protocol" />
     <PackageReference Include="Serilog" />

CodeGen/Generators/NanoFrameworkGen/NuspecGenerator.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using CodeGen.JsonTypes;
 
 namespace CodeGen.Generators.NanoFrameworkGen

CodeGen/Generators/UnitsNetGen/NumberExtensionsGenerator.cs

@@ -40,7 +40,7 @@ public static class NumberTo{_quantityName}Extensions
                     continue;
 
                 Writer.WL(2, $@"
-/// <inheritdoc cref=""{_quantityName}.From{unit.PluralName}(double)"" />");
+/// <inheritdoc cref=""{_quantityName}.From{unit.PluralName}(QuantityValue)"" />");
 
                 // Include obsolete text from the quantity per extension method, to make it visible when the class is not explicitly referenced in code.
                 Writer.WLIfText(2, GetObsoleteAttributeOrNull(unit.ObsoleteText ?? _quantity.ObsoleteText));
@@ -49,10 +49,10 @@ public static class NumberTo{_quantityName}Extensions
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => {_quantityName}.From{unit.PluralName}(double.CreateChecked(value));
+            => {_quantityName}.From{unit.PluralName}(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => {_quantityName}.From{unit.PluralName}(value.ToDouble(null));
+            => {_quantityName}.From{unit.PluralName}(value.ToQuantityValue());
 #endif
 ");
             }

CodeGen/Generators/UnitsNetGen/StaticQuantityGenerator.cs

@@ -1,4 +1,6 @@
-using CodeGen.JsonTypes;
+using System.Collections.Generic;
+using System.Linq;
+using CodeGen.JsonTypes;
 
 namespace CodeGen.Generators.UnitsNetGen
 {
@@ -33,27 +35,46 @@ internal static class DefaultProvider
         /// <summary>
         ///     All QuantityInfo instances that are present in UnitsNet by default.
         /// </summary>
-        internal static IReadOnlyList<QuantityInfo> Quantities { get; } =
-        [");
+        internal static IReadOnlyList<QuantityInfo> Quantities => new QuantityInfo[]
+        {");
             foreach (var quantity in _quantities)
                 Writer.WL($@"
             {quantity.Name}.Info,");
             Writer.WL(@"
-        ];
+        };
 
-        internal static void RegisterUnitConversions(UnitConverter unitConverter)
+        /// <summary>
+        ///     All implicit quantity conversions that exist by default.
+        /// </summary>
+        internal static readonly IReadOnlyList<QuantityConversionMapping> Conversions = new QuantityConversionMapping[]
         {");
-            foreach (Quantity quantity in _quantities)
-            {
+            foreach (var quantityRelation in _quantities.SelectMany(quantity => quantity.Relations.Where(x => x.Operator == "inverse")).Distinct(new CumulativeRelationshipEqualityComparer()).OrderBy(relation => relation.LeftQuantity.Name))
                 Writer.WL($@"
-            {quantity.Name}.RegisterDefaultConversions(unitConverter);");
-            }
-
+            new (typeof({quantityRelation.LeftQuantity.Name}), typeof({quantityRelation.RightQuantity.Name})),");
             Writer.WL(@"
-        }
+        };
     }
 }");
             return Writer.ToString();
         }
     }
+
+    internal class CumulativeRelationshipEqualityComparer: IEqualityComparer<QuantityRelation>{
+        public bool Equals(QuantityRelation? x, QuantityRelation? y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+            if (x is null) return false;
+            if (y is null) return false;
+            if (x.GetType() != y.GetType()) return false;
+            return
+                x.ResultQuantity == y.ResultQuantity && (
+                    (x.LeftQuantity.Equals(y.LeftQuantity) && x.RightQuantity.Equals(y.RightQuantity))
+                    || (x.LeftQuantity.Equals(y.RightQuantity) && x.RightQuantity.Equals(y.LeftQuantity)));
+        }
+
+        public int GetHashCode(QuantityRelation obj)
+        {
+            return obj.LeftQuantity.GetHashCode() ^ obj.RightQuantity.GetHashCode();
+        }
+    }
 }

CodeGen/Generators/UnitsNetGen/UnitTestBaseClassGenerator.cs

@@ -59,7 +59,7 @@ internal class UnitTestBaseClassGenerator : GeneratorBase
         /// A dimensionless quantity has all base dimensions (L, M, T, I, Θ, N, J) equal to zero.
         /// </remarks>
         private readonly bool _isDimensionless;
-
+        
         /// <summary>
         ///     Stores a mapping of culture names to their corresponding unique unit abbreviations.
         ///     Each culture maps to a dictionary where the key is the unit abbreviation and the value is the corresponding
@@ -101,7 +101,7 @@ internal class UnitTestBaseClassGenerator : GeneratorBase
         ///     is not available for the defined unit localizations.
         /// </remarks>
         private const string FallbackCultureName = "en-US";
-
+        
         public UnitTestBaseClassGenerator(Quantity quantity)
         {
             _quantity = quantity;
@@ -263,6 +263,7 @@ public abstract partial class {_quantity.Name}TestsBase : QuantityTestsBase
                 Writer.WL($@"
             new object[] {{ {GetUnitFullName(unit)} }},");
             }
+
             Writer.WL($@"
         }};
 
@@ -339,6 +340,20 @@ public void Ctor_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
             Assert.Equal(quantityInfo, ((IQuantity<{_unitEnumName}>)quantity).QuantityInfo);
         }}
 
+        [Fact]
+        public void {_quantity.Name}Info_CreateWithCustomUnitInfos()
+        {{
+            {_unitEnumName}[] expectedUnits = [{_baseUnitFullName}];
+
+            {_quantity.Name}.{_quantity.Name}Info quantityInfo = {_quantity.Name}.{_quantity.Name}Info.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal(""{_quantity.Name}"", quantityInfo.Name);
+            Assert.Equal({_quantity.Name}.Zero, quantityInfo.Zero);
+            Assert.Equal({_quantity.Name}.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }}
+
         [Fact]
         public void {_baseUnit.SingularName}To{_quantity.Name}Units()
         {{
@@ -584,7 +599,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
             }
 
             Writer.WL($@"
-        public void Parse(string culture, string quantityString, {_unitEnumName} expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, {_unitEnumName} expectedUnit, decimal expectedValue)
         {{
             using var _ = new CultureScope(culture);
             var parsed = {_quantity.Name}.Parse(quantityString);
@@ -629,7 +644,7 @@ public void ParseWithAmbiguousAbbreviation(string culture, string quantityString
             }
 
             Writer.WL($@"
-        public void TryParse(string culture, string quantityString, {_unitEnumName} expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, {_unitEnumName} expectedUnit, decimal expectedValue)
         {{
             using var _ = new CultureScope(culture);
             Assert.True({_quantity.Name}.TryParse(quantityString, out {_quantity.Name} parsed));
@@ -887,7 +902,7 @@ public void GetAbbreviationWithDefaultCulture()
             }});
         }}
 ");
-
+            
             Writer.WL($@"
         [Theory]
         [MemberData(nameof(UnitTypes))]
@@ -919,6 +934,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit({_unitEnumName}
                 var quantity = {_quantity.Name}.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             }});
         }}
 
@@ -942,20 +958,22 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity({_unitEnumName} uni
                 IQuantity<{_unitEnumName}> quantityToConvert = quantity;
                 IQuantity<{_unitEnumName}> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }}, () =>
             {{
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }});
         }}
 
         [Fact]
         public void ConversionRoundTrip()
         {{
-            {_quantity.Name} {baseUnitVariableName} = {_quantity.Name}.From{_baseUnit.PluralName}(1);");
+            {_quantity.Name} {baseUnitVariableName} = {_quantity.Name}.From{_baseUnit.PluralName}(3);");
             foreach (var unit in _quantity.Units) Writer.WL($@"
-            AssertEx.EqualTolerance(1, {_quantity.Name}.From{unit.PluralName}({baseUnitVariableName}.{unit.PluralName}).{_baseUnit.PluralName}, {unit.PluralName}Tolerance);");
+            Assert.Equal(3, {_quantity.Name}.From{unit.PluralName}({baseUnitVariableName}.{unit.PluralName}).{_baseUnit.PluralName});");
             Writer.WL($@"
         }}
 ");
@@ -967,13 +985,13 @@ public void ConversionRoundTrip()
         public void LogarithmicArithmeticOperators()
         {{
             {_quantity.Name} v = {_quantity.Name}.From{_baseUnit.PluralName}(40);
-            AssertEx.EqualTolerance(-40, -v.{_baseUnit.PluralName}, {unit.PluralName}Tolerance);
+            Assert.Equal(-40, -v.{_baseUnit.PluralName});
             AssertLogarithmicAddition();
             AssertLogarithmicSubtraction();
-            AssertEx.EqualTolerance(50, (v*10).{_baseUnit.PluralName}, {unit.PluralName}Tolerance);
-            AssertEx.EqualTolerance(50, (10*v).{_baseUnit.PluralName}, {unit.PluralName}Tolerance);
-            AssertEx.EqualTolerance(35, (v/5).{_baseUnit.PluralName}, {unit.PluralName}Tolerance);
-            AssertEx.EqualTolerance(35, v/{_quantity.Name}.From{_baseUnit.PluralName}(5), {unit.PluralName}Tolerance);
+            Assert.Equal(50, (v * 10).{_baseUnit.PluralName});
+            Assert.Equal(50, (10 * v).{_baseUnit.PluralName});
+            Assert.Equal(35, (v / 5).{_baseUnit.PluralName});
+            Assert.Equal(35, v / {_quantity.Name}.From{_baseUnit.PluralName}(5));
         }}
 
         protected abstract void AssertLogarithmicAddition();
@@ -988,13 +1006,13 @@ public void LogarithmicArithmeticOperators()
         public void ArithmeticOperators()
         {{
             {_quantity.Name} v = {_quantity.Name}.From{_baseUnit.PluralName}(1);
-            AssertEx.EqualTolerance(-1, -v.{_baseUnit.PluralName}, {_baseUnit.PluralName}Tolerance);
-            AssertEx.EqualTolerance(2, ({_quantity.Name}.From{_baseUnit.PluralName}(3)-v).{_baseUnit.PluralName}, {_baseUnit.PluralName}Tolerance);
-            AssertEx.EqualTolerance(2, (v + v).{_baseUnit.PluralName}, {_baseUnit.PluralName}Tolerance);
-            AssertEx.EqualTolerance(10, (v*10).{_baseUnit.PluralName}, {_baseUnit.PluralName}Tolerance);
-            AssertEx.EqualTolerance(10, (10*v).{_baseUnit.PluralName}, {_baseUnit.PluralName}Tolerance);
-            AssertEx.EqualTolerance(2, ({_quantity.Name}.From{_baseUnit.PluralName}(10)/5).{_baseUnit.PluralName}, {_baseUnit.PluralName}Tolerance);
-            AssertEx.EqualTolerance(2, {_quantity.Name}.From{_baseUnit.PluralName}(10)/{_quantity.Name}.From{_baseUnit.PluralName}(5), {_baseUnit.PluralName}Tolerance);
+            Assert.Equal(-1, -v.{_baseUnit.PluralName});
+            Assert.Equal(2, ({_quantity.Name}.From{_baseUnit.PluralName}(3) - v).{_baseUnit.PluralName});
+            Assert.Equal(2, (v + v).{_baseUnit.PluralName});
+            Assert.Equal(10, (v * 10).{_baseUnit.PluralName});
+            Assert.Equal(10, (10 * v).{_baseUnit.PluralName});
+            Assert.Equal(2, ({_quantity.Name}.From{_baseUnit.PluralName}(10) / 5).{_baseUnit.PluralName});
+            Assert.Equal(2, {_quantity.Name}.From{_baseUnit.PluralName}(10) / {_quantity.Name}.From{_baseUnit.PluralName}(5));
         }}
 ");
             }
@@ -1047,13 +1065,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, {_baseUnitFullName}, 1, {_baseUnitFullName}, true)]  // Same value and unit.
         [InlineData(1, {_baseUnitFullName}, 2, {_baseUnitFullName}, false)] // Different value.
-        [InlineData(2, {_baseUnitFullName}, 1, {_otherOrBaseUnitFullName}, false)] // Different value and unit.");
-            if (_baseUnit != _otherOrBaseUnit)
-            {
-                Writer.WL($@"
-        [InlineData(1, {_baseUnitFullName}, 1, {_otherOrBaseUnitFullName}, false)] // Different unit.");
-            }
-            Writer.WL($@"
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, {_unitEnumName} unitA, double valueB, {_unitEnumName} unitB, bool expectEqual)
         {{
             var a = new {_quantity.Name}(valueA, unitA);
@@ -1118,8 +1129,8 @@ public void Equals_Logarithmic_WithTolerance(double firstValue, double secondVal
             var quantity = {_quantity.Name}.From{_baseUnit.PluralName}(firstValue);
             var otherQuantity = {_quantity.Name}.From{_baseUnit.PluralName}(secondValue);
             {differenceResultType} maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, {differenceResultType}.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, largerTolerance));
@@ -1151,8 +1162,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = {_quantity.Name}.From{_baseUnit.PluralName}(firstValue);
             var otherQuantity = {_quantity.Name}.From{_baseUnit.PluralName}(secondValue);
             {differenceResultType} maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, {differenceResultType}.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -1193,7 +1204,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {{
-            var units = Enum.GetValues<{_unitEnumName}>();
+            var units = EnumHelper.GetValues<{_unitEnumName}>();
             foreach (var unit in units)
             {{
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -1206,6 +1217,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False({_quantity.Name}.BaseDimensions is null);
         }}
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {{
+            Assert.Equal({_quantity.Name}.Info.Units, {_quantity.Name}.Units);
+        }}
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {{
+            Assert.Equal(UnitConverter.Default, {_quantity.Name}.DefaultConversionFunctions);
+        }}
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {{
@@ -1278,7 +1301,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {{
             var quantity = {_quantity.Name}.From{_baseUnit.PluralName}(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof({_quantity.Name}), quantity.As({_quantity.Name}.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }}
 ");
 

CodeGen/Generators/UnitsNetGenerator.cs

@@ -153,9 +153,6 @@ private static void GenerateResourceFiles(Quantity[] quantities, string resource
                         $"{resourcesDirectory}/{quantity.Name}.restext" :
                         $"{resourcesDirectory}/{quantity.Name}.{culture}.restext";
 
-                    // Ensure parent folder exists
-                    Directory.CreateDirectory(resourcesDirectory);
-
                     using var writer = File.CreateText(fileName);
 
                     foreach(Unit unit in quantity.Units)

CodeGen/Helpers/ExpressionAnalyzer/ExpressionEvaluationTerm.cs

@@ -0,0 +1,14 @@
+using Fractions;
+
+namespace CodeGen.Helpers.ExpressionAnalyzer;
+
+/// <summary>
+///     A term of the form "P^n" where P is a term that hasn't been parsed, raised to the given power.
+/// </summary>
+/// <param name="Expression">The actual expression to parse</param>
+/// <param name="Exponent">The exponent to use on the parsed expression (default is 1)</param>
+/// <remarks>
+///     Since we're tokenizing the expressions from top to bottom, the first step is parsing the exponent of the
+///     expression: e.g. Math.Pow(P, 2)
+/// </remarks>
+public record ExpressionEvaluationTerm(string Expression, Fraction Exponent);