diff --git a/CodeGen/Generators/QuantityRelationsParser.cs b/CodeGen/Generators/QuantityRelationsParser.cs index 401c7e7b10..668704260e 100644 --- a/CodeGen/Generators/QuantityRelationsParser.cs +++ b/CodeGen/Generators/QuantityRelationsParser.cs @@ -32,7 +32,7 @@ internal static class QuantityRelationsParser /// /// /// [ - /// "1 = Length.Meter * ReciprocalLength.InverseMeter" + /// "double = Length.Meter * ReciprocalLength.InverseMeter -- Inverse" /// "Power.Watt = ElectricPotential.Volt * ElectricCurrent.Ampere", /// "Mass.Kilogram = MassConcentration.KilogramPerCubicMeter * Volume.CubicMeter -- NoInferredDivision", /// ] @@ -46,22 +46,23 @@ public static void ParseAndApplyRelations(string rootDir, Quantity[] quantities) // Add double and 1 as pseudo-quantities to validate relations that use them. var pseudoQuantity = new Quantity { Name = null!, Units = [new Unit { SingularName = null! }] }; quantityDictionary["double"] = pseudoQuantity with { Name = "double" }; - quantityDictionary["1"] = pseudoQuantity with { Name = "1" }; var relations = ParseRelations(rootDir, quantityDictionary); // Because multiplication is commutative, we can infer the other operand order. relations.AddRange(relations - .Where(r => r.Operator is "*" or "inverse" && r.LeftQuantity != r.RightQuantity) + .Where(r => r.Operator is "*" && r.LeftQuantity != r.RightQuantity) .Select(r => r with { LeftQuantity = r.RightQuantity, LeftUnit = r.RightUnit, RightQuantity = r.LeftQuantity, RightUnit = r.LeftUnit, + IsDerived = true, + // IsInverse is propagated, to also generate Inverse() method for the right hand quantity. }) .ToList()); - + // We can infer division relations from multiplication relations. relations.AddRange(relations .Where(r => r is { Operator: "*", NoInferredDivision: false }) @@ -72,6 +73,8 @@ public static void ParseAndApplyRelations(string rootDir, Quantity[] quantities) LeftUnit = r.ResultUnit, ResultQuantity = r.LeftQuantity, ResultUnit = r.LeftUnit, + IsDerived = true, + IsInverse = false, // Don't propagate for inferred division relations, Inverse() methods should only be generated the left and right hand quantities in the original definition. }) // Skip division between equal quantities because the ratio is already generated as part of the Arithmetic Operators. .Where(r => r.LeftQuantity != r.RightQuantity) @@ -91,7 +94,7 @@ public static void ParseAndApplyRelations(string rootDir, Quantity[] quantities) var list = string.Join("\n ", duplicates); throw new UnitsNetCodeGenException($"Duplicate inferred relations:\n {list}"); } - + var ambiguous = relations .GroupBy(r => $"{r.LeftQuantity.Name} {r.Operator} {r.RightQuantity.Name}") .Where(g => g.Count() > 1) @@ -170,14 +173,14 @@ private static QuantityRelation ParseRelation(string relationString, IReadOnlyDi var rightUnit = GetUnit(rightQuantity, right.ElementAtOrDefault(1)); var resultUnit = GetUnit(resultQuantity, result.ElementAtOrDefault(1)); - if (resultQuantity.Name == "1") - { - @operator = "inverse"; - } + // Configuration segments are the parts after the "--" in the relation string. + // Example: "double = Length.Meter * ReciprocalLength.InverseMeter -- Inverse" => ["Inverse"] + var configurationSegments = relationString.Split("--").Last().Trim().Split(' ', StringSplitOptions.RemoveEmptyEntries); return new QuantityRelation { - NoInferredDivision = segments.Contains("NoInferredDivision"), + NoInferredDivision = configurationSegments.Contains("NoInferredDivision"), + IsInverse = configurationSegments.Contains("Inverse"), Operator = @operator, LeftQuantity = leftQuantity, LeftUnit = leftUnit, @@ -210,4 +213,4 @@ Unit GetUnit(Quantity quantity, string? unitName) } } } -} \ No newline at end of file +} diff --git a/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs b/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs index eea1a6378a..3d4214dd00 100644 --- a/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs +++ b/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs @@ -788,61 +788,65 @@ private void GenerateRelationalOperators() Writer.WL($@" #region Relational Operators "); - - foreach (QuantityRelation relation in _quantity.Relations) + // Generate an Inverse() method for the original relation definition, if the quantity can be inverted to another quantity. + // E.g. double = Length.Meter * ReciprocalLength.InverseMeter + if (_quantity.Relations.FirstOrDefault(x => x is { IsInverse: true, }) is { } inverseRelation) { - if (relation.Operator == "inverse") - { - Writer.WL($@" + Unit unit = inverseRelation.LeftUnit; + Quantity inverseQuantity = inverseRelation.RightQuantity; + Unit inverseUnit = inverseRelation.RightUnit; + + Writer.WL($@" /// Calculates the inverse of this quantity. - /// The corresponding inverse quantity, . - public {relation.RightQuantity.Name} Inverse() + /// The corresponding inverse quantity, . + public {inverseQuantity.Name} Inverse() {{ - return {relation.RightQuantity.Name}.From{relation.RightUnit.PluralName}(1 / {relation.LeftUnit.PluralName}); + return {inverseQuantity.Name}.From{inverseUnit.PluralName}(1 / {unit.PluralName}); }} "); - } - else - { - var leftParameter = relation.LeftQuantity.Name.ToCamelCase(); - var leftConversionProperty = relation.LeftUnit.PluralName; - var rightParameter = relation.RightQuantity.Name.ToCamelCase(); - var rightConversionProperty = relation.RightUnit.PluralName; + } - if (leftParameter == rightParameter) - { - leftParameter = "left"; - rightParameter = "right"; - } + // Generate arithmetic operator overloads for each relation, including inverse relations. + foreach (QuantityRelation relation in _quantity.Relations) + { + var leftParameter = relation.LeftQuantity.Name.ToCamelCase(); + var leftConversionProperty = relation.LeftUnit.PluralName; + var rightParameter = relation.RightQuantity.Name.ToCamelCase(); + var rightConversionProperty = relation.RightUnit.PluralName; + + if (leftParameter == rightParameter) + { + leftParameter = "left"; + rightParameter = "right"; + } - var leftPart = $"{leftParameter}.{leftConversionProperty}"; - var rightPart = $"{rightParameter}.{rightConversionProperty}"; + var leftPart = $"{leftParameter}.{leftConversionProperty}"; + var rightPart = $"{rightParameter}.{rightConversionProperty}"; - if (leftParameter is "double") - { - leftParameter = leftPart = "value"; - } + if (leftParameter is "double") + { + leftParameter = leftPart = "value"; + } - if (rightParameter is "double") - { - rightParameter = rightPart = "value"; - } + if (rightParameter is "double") + { + rightParameter = rightPart = "value"; + } - var expression = $"{leftPart} {relation.Operator} {rightPart}"; + var expression = $"{leftPart} {relation.Operator} {rightPart}"; - if (relation.ResultQuantity.Name is not "double") - { - expression = $"{relation.ResultQuantity.Name}.From{relation.ResultUnit.PluralName}({expression})"; - } + if (relation.ResultQuantity.Name is not "double") + { + expression = $"{relation.ResultQuantity.Name}.From{relation.ResultUnit.PluralName}({expression})"; + } - Writer.WL($@" + Writer.WL($@" /// Get from {relation.Operator} . public static {relation.ResultQuantity.Name} operator {relation.Operator}({relation.LeftQuantity.Name} {leftParameter}, {relation.RightQuantity.Name} {rightParameter}) {{ return {expression}; }} "); - } } Writer.WL($@" diff --git a/CodeGen/Generators/UnitsNetGen/UnitTestBaseClassGenerator.cs b/CodeGen/Generators/UnitsNetGen/UnitTestBaseClassGenerator.cs index ba43729679..f30040baac 100644 --- a/CodeGen/Generators/UnitsNetGen/UnitTestBaseClassGenerator.cs +++ b/CodeGen/Generators/UnitsNetGen/UnitTestBaseClassGenerator.cs @@ -884,6 +884,62 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, {_quantity.Name}.From{_baseUnit.PluralName}(10)/{_quantity.Name}.From{_baseUnit.PluralName}(5), {_baseUnit.PluralName}Tolerance); }} "); + + if (_quantity.Relations.Length > 0) + { + Writer.WL($@" + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + {{"); + foreach (QuantityRelation relation in _quantity.Relations) + { + var leftQuantity = relation.LeftQuantity; + var leftUnit = relation.LeftUnit; + var rightQuantity = relation.RightQuantity; + var rightUnit = relation.RightUnit; + var expectedValue = relation.Operator switch + { + "+" => 12, + "-" => 8, + "*" => 20, + "/" => 5, + _ => throw new NotSupportedException($"Unsupported operator: {relation.Operator}") + }; + var left = GetQuantityValueText(leftQuantity, leftUnit, 10); + var right = GetQuantityValueText(rightQuantity, rightUnit, 2); + var expected = GetQuantityValueText(relation.ResultQuantity, relation.ResultUnit, expectedValue); + + Writer.WL($@" + Assert.Equal({expected}, {left} {relation.Operator} {right});"); + } + Writer.WL($@" + }} +"); + } + + if (_quantity.Relations.FirstOrDefault(x => x.IsInverse) is { } inverseRelation) + { + var quantityName = _quantity.Name; + Unit unit = inverseRelation.LeftQuantity.Name == quantityName ? inverseRelation.LeftUnit : inverseRelation.RightUnit; + Quantity inverseQuantity = inverseRelation.LeftQuantity.Name == quantityName ? inverseRelation.RightQuantity : inverseRelation.LeftQuantity; + Unit inverseUnit = inverseRelation.LeftQuantity.Name == quantityName ? inverseRelation.RightUnit : inverseRelation.LeftUnit; + + Writer.WL($@" + + [Fact] + public void InverseMethod() + {{ + {quantityName} v = {quantityName}.From{unit.PluralName}(10); + + {inverseQuantity.Name} inverse = v.Inverse(); + + AssertEx.EqualTolerance(0.1, inverse.Value, 1e-5); + Assert.Equal({inverseQuantity.Name}Unit.{inverseUnit.SingularName}, inverse.Unit);"); + Writer.WL($@" + }} +"); + } } else { @@ -1119,6 +1175,20 @@ public void NegationOperator_ReturnsQuantity_WithNegatedValue(double value) return Writer.ToString(); } + /// + /// Returns either the number value as string, such as 5, or the quantity factory method, such as Length.FromMeters(100). + /// + /// + /// + /// + /// + private static string GetQuantityValueText(Quantity quantity, Unit unit, int value) + { + return quantity.Name == "double" + ? value.ToString() + : $"{quantity.Name}.From{unit.PluralName}({value})"; + } + private bool IsAmbiguousAbbreviation(Localization localization, string abbreviation) { return _quantity.Units.Count(u => diff --git a/CodeGen/JsonTypes/Quantity.cs b/CodeGen/JsonTypes/Quantity.cs index f471225ad8..cd45308183 100644 --- a/CodeGen/JsonTypes/Quantity.cs +++ b/CodeGen/JsonTypes/Quantity.cs @@ -3,6 +3,7 @@ using System; using System.Diagnostics; +using System.Linq; namespace CodeGen.JsonTypes { @@ -26,5 +27,7 @@ internal record Quantity // 0649 Field is never assigned to #pragma warning restore 0649 + + public Unit GetBaseUnit() => Units.First(x => x.SingularName == BaseUnit); } } diff --git a/CodeGen/JsonTypes/QuantityRelation.cs b/CodeGen/JsonTypes/QuantityRelation.cs index 35e97a6bc0..d858e1d835 100644 --- a/CodeGen/JsonTypes/QuantityRelation.cs +++ b/CodeGen/JsonTypes/QuantityRelation.cs @@ -8,6 +8,13 @@ namespace CodeGen.JsonTypes internal record QuantityRelation : IComparable { public bool NoInferredDivision = false; + + /// Whether this is a relation between two quantities that are the inverse of each other, such as double = Length.Meter * ReciprocalLength.InverseMeter -- Inverse. + public bool IsInverse = false; + + /// Whether this relation is derived from another relation, such as obtaining division from a multiplication definition. Can be used to treat the original definitions differently. + public bool IsDerived = false; + public string Operator = null!; public Quantity LeftQuantity = null!; @@ -32,4 +39,4 @@ public int CompareTo(QuantityRelation? other) private static string PrependDot(string? s) => s == null ? string.Empty : "." + s; } -} \ No newline at end of file +} diff --git a/Common/UnitRelations.json b/Common/UnitRelations.json index bded89653c..0f8e4e6773 100644 --- a/Common/UnitRelations.json +++ b/Common/UnitRelations.json @@ -1,8 +1,4 @@ [ - "1 = Area.SquareMeter * ReciprocalArea.InverseSquareMeter", - "1 = Density.KilogramPerCubicMeter * SpecificVolume.CubicMeterPerKilogram", - "1 = ElectricResistivity.OhmMeter * ElectricConductivity.SiemensPerMeter", - "1 = Length.Meter * ReciprocalLength.InverseMeter", "Acceleration.MeterPerSecondSquared = Jerk.MeterPerSecondCubed * Duration.Second", "AmountOfSubstance.Mole = MolarFlow.MolePerSecond * Duration.Second", "AmountOfSubstance.Mole = Molarity.MolePerCubicMeter * Volume.CubicMeter", @@ -11,6 +7,9 @@ "Area.SquareMeter = Length.Meter * Length.Meter", "Area.SquareMeter = Volume.CubicMeter * ReciprocalLength.InverseMeter", "AreaMomentOfInertia.MeterToTheFourth = Volume.CubicMeter * Length.Meter", + "double = Density.KilogramPerCubicMeter * SpecificVolume.CubicMeterPerKilogram -- Inverse", + "double = ElectricResistivity.OhmMeter * ElectricConductivity.SiemensPerMeter -- Inverse", + "double = Length.Meter * ReciprocalLength.InverseMeter -- Inverse", "double = SpecificEnergy.JoulePerKilogram * BrakeSpecificFuelConsumption.KilogramPerJoule", "DynamicViscosity.NewtonSecondPerMeterSquared = Density.KilogramPerCubicMeter * KinematicViscosity.SquareMeterPerSecond", "ElectricCharge.AmpereHour = ElectricCurrent.Ampere * Duration.Hour", @@ -64,7 +63,7 @@ "Pressure.Pascal = PressureChangeRate.PascalPerSecond * Duration.Second", "Pressure.Pascal = SpecificWeight.NewtonPerCubicMeter * Length.Meter", "RadiationEquivalentDose.Sievert = RadiationEquivalentDoseRate.SievertPerHour * Duration.Hour", - "Ratio.DecimalFraction = Area.SquareMeter * ReciprocalArea.InverseSquareMeter -- NoInferredDivision", + "Ratio.DecimalFraction = Area.SquareMeter * ReciprocalArea.InverseSquareMeter -- NoInferredDivision Inverse", "Ratio.DecimalFraction = TemperatureDelta.Kelvin * CoefficientOfThermalExpansion.PerKelvin -- NoInferredDivision", "ReciprocalArea.InverseSquareMeter = ReciprocalLength.InverseMeter * ReciprocalLength.InverseMeter", "ReciprocalLength.InverseMeter = Length.Meter * ReciprocalArea.InverseSquareMeter", diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/AccelerationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/AccelerationTestsBase.g.cs index 3e0bdd7cde..0c53ccf99b 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/AccelerationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/AccelerationTestsBase.g.cs @@ -1099,6 +1099,17 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, Acceleration.FromMetersPerSecondSquared(10)/Acceleration.FromMetersPerSecondSquared(5), MetersPerSecondSquaredTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Duration.FromSeconds(5), Acceleration.FromMetersPerSecondSquared(10) / Jerk.FromMetersPerSecondCubed(2)); + Assert.Equal(Force.FromNewtons(20), Acceleration.FromMetersPerSecondSquared(10) * Mass.FromKilograms(2)); + Assert.Equal(Jerk.FromMetersPerSecondCubed(5), Acceleration.FromMetersPerSecondSquared(10) / Duration.FromSeconds(2)); + Assert.Equal(SpecificWeight.FromNewtonsPerCubicMeter(20), Acceleration.FromMetersPerSecondSquared(10) * Density.FromKilogramsPerCubicMeter(2)); + Assert.Equal(Speed.FromMetersPerSecond(20), Acceleration.FromMetersPerSecondSquared(10) * Duration.FromSeconds(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/AmountOfSubstanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/AmountOfSubstanceTestsBase.g.cs index 707a0a4a6c..42f818dbe2 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/AmountOfSubstanceTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/AmountOfSubstanceTestsBase.g.cs @@ -945,6 +945,18 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, AmountOfSubstance.FromMoles(10)/AmountOfSubstance.FromMoles(5), MolesTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Duration.FromSeconds(5), AmountOfSubstance.FromMoles(10) / MolarFlow.FromMolesPerSecond(2)); + Assert.Equal(Energy.FromJoules(20), AmountOfSubstance.FromMoles(10) * MolarEnergy.FromJoulesPerMole(2)); + Assert.Equal(Mass.FromKilograms(20), AmountOfSubstance.FromMoles(10) * MolarMass.FromKilogramsPerMole(2)); + Assert.Equal(MolarFlow.FromMolesPerSecond(5), AmountOfSubstance.FromMoles(10) / Duration.FromSeconds(2)); + Assert.Equal(Molarity.FromMolesPerCubicMeter(5), AmountOfSubstance.FromMoles(10) / Volume.FromCubicMeters(2)); + Assert.Equal(Volume.FromCubicMeters(5), AmountOfSubstance.FromMoles(10) / Molarity.FromMolesPerCubicMeter(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/AngleTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/AngleTestsBase.g.cs index 3c831101e2..2fa2d97801 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/AngleTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/AngleTestsBase.g.cs @@ -1247,6 +1247,15 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, Angle.FromRadians(10)/Angle.FromRadians(5), RadiansTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Duration.FromSeconds(5), Angle.FromRadians(10) / RotationalSpeed.FromRadiansPerSecond(2)); + Assert.Equal(RotationalSpeed.FromRadiansPerSecond(5), Angle.FromRadians(10) / Duration.FromSeconds(2)); + Assert.Equal(Torque.FromNewtonMeters(20), Angle.FromRadians(10) * RotationalStiffness.FromNewtonMetersPerRadian(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/AreaDensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/AreaDensityTestsBase.g.cs index b275a78209..dd4e412346 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/AreaDensityTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/AreaDensityTestsBase.g.cs @@ -530,6 +530,13 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, AreaDensity.FromKilogramsPerSquareMeter(10)/AreaDensity.FromKilogramsPerSquareMeter(5), KilogramsPerSquareMeterTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Mass.FromKilograms(20), AreaDensity.FromKilogramsPerSquareMeter(10) * Area.FromSquareMeters(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/AreaMomentOfInertiaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/AreaMomentOfInertiaTestsBase.g.cs index 23c476062b..bc871c3906 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/AreaMomentOfInertiaTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/AreaMomentOfInertiaTestsBase.g.cs @@ -605,6 +605,14 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, AreaMomentOfInertia.FromMetersToTheFourth(10)/AreaMomentOfInertia.FromMetersToTheFourth(5), MetersToTheFourthTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Length.FromMeters(5), AreaMomentOfInertia.FromMetersToTheFourth(10) / Volume.FromCubicMeters(2)); + Assert.Equal(Volume.FromCubicMeters(5), AreaMomentOfInertia.FromMetersToTheFourth(10) / Length.FromMeters(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/AreaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/AreaTestsBase.g.cs index 95cf522c99..8cde1b4dee 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/AreaTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/AreaTestsBase.g.cs @@ -1314,6 +1314,39 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, Area.FromSquareMeters(10)/Area.FromSquareMeters(5), SquareMetersTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Force.FromNewtons(20), Area.FromSquareMeters(10) * Pressure.FromPascals(2)); + Assert.Equal(ForcePerLength.FromNewtonsPerMeter(20), Area.FromSquareMeters(10) * SpecificWeight.FromNewtonsPerCubicMeter(2)); + Assert.Equal(Length.FromMeters(20), Area.FromSquareMeters(10) * ReciprocalLength.FromInverseMeters(2)); + Assert.Equal(Length.FromMeters(5), Area.FromSquareMeters(10) / Length.FromMeters(2)); + Assert.Equal(LinearDensity.FromKilogramsPerMeter(20), Area.FromSquareMeters(10) * Density.FromKilogramsPerCubicMeter(2)); + Assert.Equal(LuminousFlux.FromLumens(20), Area.FromSquareMeters(10) * Illuminance.FromLux(2)); + Assert.Equal(LuminousIntensity.FromCandela(20), Area.FromSquareMeters(10) * Luminance.FromCandelasPerSquareMeter(2)); + Assert.Equal(Mass.FromKilograms(20), Area.FromSquareMeters(10) * AreaDensity.FromKilogramsPerSquareMeter(2)); + Assert.Equal(MassFlow.FromKilogramsPerSecond(20), Area.FromSquareMeters(10) * MassFlux.FromKilogramsPerSecondPerSquareMeter(2)); + Assert.Equal(Power.FromWatts(20), Area.FromSquareMeters(10) * HeatFlux.FromWattsPerSquareMeter(2)); + Assert.Equal(Ratio.FromDecimalFractions(20), Area.FromSquareMeters(10) * ReciprocalArea.FromInverseSquareMeters(2)); + Assert.Equal(ReciprocalLength.FromInverseMeters(5), Area.FromSquareMeters(10) / Volume.FromCubicMeters(2)); + Assert.Equal(Torque.FromNewtonMeters(20), Area.FromSquareMeters(10) * ForcePerLength.FromNewtonsPerMeter(2)); + Assert.Equal(Volume.FromCubicMeters(20), Area.FromSquareMeters(10) * Length.FromMeters(2)); + Assert.Equal(Volume.FromCubicMeters(5), Area.FromSquareMeters(10) / ReciprocalLength.FromInverseMeters(2)); + Assert.Equal(VolumeFlow.FromCubicMetersPerSecond(20), Area.FromSquareMeters(10) * Speed.FromMetersPerSecond(2)); + } + + [Fact] + public void InverseMethod() + { + Area v = Area.FromSquareMeters(10); + + ReciprocalArea inverse = v.Inverse(); + + AssertEx.EqualTolerance(0.1, inverse.Value, 1e-5); + Assert.Equal(ReciprocalAreaUnit.InverseSquareMeter, inverse.Unit); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/BrakeSpecificFuelConsumptionTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/BrakeSpecificFuelConsumptionTestsBase.g.cs index 149607cfd2..62fdb54427 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/BrakeSpecificFuelConsumptionTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/BrakeSpecificFuelConsumptionTestsBase.g.cs @@ -509,6 +509,15 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, BrakeSpecificFuelConsumption.FromKilogramsPerJoule(10)/BrakeSpecificFuelConsumption.FromKilogramsPerJoule(5), KilogramsPerJouleTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(MassFlow.FromKilogramsPerSecond(20), BrakeSpecificFuelConsumption.FromKilogramsPerJoule(10) * Power.FromWatts(2)); + Assert.Equal(SpecificEnergy.FromJoulesPerKilogram(5), 10 / BrakeSpecificFuelConsumption.FromKilogramsPerJoule(2)); + Assert.Equal(20, BrakeSpecificFuelConsumption.FromKilogramsPerJoule(10) * SpecificEnergy.FromJoulesPerKilogram(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/CoefficientOfThermalExpansionTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/CoefficientOfThermalExpansionTestsBase.g.cs index 065ae984ab..5a7fd01b02 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/CoefficientOfThermalExpansionTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/CoefficientOfThermalExpansionTestsBase.g.cs @@ -605,6 +605,13 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, CoefficientOfThermalExpansion.FromPerKelvin(10)/CoefficientOfThermalExpansion.FromPerKelvin(5), PerKelvinTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Ratio.FromDecimalFractions(20), CoefficientOfThermalExpansion.FromPerKelvin(10) * TemperatureDelta.FromKelvins(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/DensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/DensityTestsBase.g.cs index 45eb200af2..2a429aa355 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/DensityTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/DensityTestsBase.g.cs @@ -2399,6 +2399,32 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, Density.FromKilogramsPerCubicMeter(10)/Density.FromKilogramsPerCubicMeter(5), KilogramsPerCubicMeterTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(DynamicViscosity.FromNewtonSecondsPerMeterSquared(20), Density.FromKilogramsPerCubicMeter(10) * KinematicViscosity.FromSquareMetersPerSecond(2)); + Assert.Equal(LinearDensity.FromKilogramsPerMeter(20), Density.FromKilogramsPerCubicMeter(10) * Area.FromSquareMeters(2)); + Assert.Equal(Mass.FromKilograms(20), Density.FromKilogramsPerCubicMeter(10) * Volume.FromCubicMeters(2)); + Assert.Equal(MassConcentration.FromKilogramsPerCubicMeter(20), Density.FromKilogramsPerCubicMeter(10) * VolumeConcentration.FromDecimalFractions(2)); + Assert.Equal(MassFlow.FromKilogramsPerSecond(20), Density.FromKilogramsPerCubicMeter(10) * VolumeFlow.FromCubicMetersPerSecond(2)); + Assert.Equal(MassFlux.FromKilogramsPerSecondPerSquareMeter(20), Density.FromKilogramsPerCubicMeter(10) * Speed.FromMetersPerSecond(2)); + Assert.Equal(SpecificVolume.FromCubicMetersPerKilogram(5), 10 / Density.FromKilogramsPerCubicMeter(2)); + Assert.Equal(SpecificWeight.FromNewtonsPerCubicMeter(20), Density.FromKilogramsPerCubicMeter(10) * Acceleration.FromMetersPerSecondSquared(2)); + Assert.Equal(20, Density.FromKilogramsPerCubicMeter(10) * SpecificVolume.FromCubicMetersPerKilogram(2)); + } + + [Fact] + public void InverseMethod() + { + Density v = Density.FromKilogramsPerCubicMeter(10); + + SpecificVolume inverse = v.Inverse(); + + AssertEx.EqualTolerance(0.1, inverse.Value, 1e-5); + Assert.Equal(SpecificVolumeUnit.CubicMeterPerKilogram, inverse.Unit); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/DurationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/DurationTestsBase.g.cs index 9dec63ca39..a370d018e3 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/DurationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/DurationTestsBase.g.cs @@ -1912,6 +1912,27 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, Duration.FromSeconds(10)/Duration.FromSeconds(5), SecondsTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Acceleration.FromMetersPerSecondSquared(20), Duration.FromSeconds(10) * Jerk.FromMetersPerSecondCubed(2)); + Assert.Equal(AmountOfSubstance.FromMoles(20), Duration.FromSeconds(10) * MolarFlow.FromMolesPerSecond(2)); + Assert.Equal(Angle.FromRadians(20), Duration.FromSeconds(10) * RotationalSpeed.FromRadiansPerSecond(2)); + Assert.Equal(Area.FromSquareMeters(20), Duration.FromSeconds(10) * KinematicViscosity.FromSquareMetersPerSecond(2)); + Assert.Equal(ElectricCharge.FromAmpereHours(20), Duration.FromHours(10) * ElectricCurrent.FromAmperes(2)); + Assert.Equal(ElectricCurrent.FromAmperes(20), Duration.FromSeconds(10) * ElectricCurrentGradient.FromAmperesPerSecond(2)); + Assert.Equal(Energy.FromJoules(20), Duration.FromSeconds(10) * Power.FromWatts(2)); + Assert.Equal(Force.FromNewtons(20), Duration.FromSeconds(10) * ForceChangeRate.FromNewtonsPerSecond(2)); + Assert.Equal(Length.FromMeters(20), Duration.FromSeconds(10) * Speed.FromMetersPerSecond(2)); + Assert.Equal(Mass.FromKilograms(20), Duration.FromSeconds(10) * MassFlow.FromKilogramsPerSecond(2)); + Assert.Equal(Pressure.FromPascals(20), Duration.FromSeconds(10) * PressureChangeRate.FromPascalsPerSecond(2)); + Assert.Equal(RadiationEquivalentDose.FromSieverts(20), Duration.FromHours(10) * RadiationEquivalentDoseRate.FromSievertsPerHour(2)); + Assert.Equal(Speed.FromMetersPerSecond(20), Duration.FromSeconds(10) * Acceleration.FromMetersPerSecondSquared(2)); + Assert.Equal(TemperatureDelta.FromDegreesCelsius(20), Duration.FromSeconds(10) * TemperatureChangeRate.FromDegreesCelsiusPerSecond(2)); + Assert.Equal(Volume.FromCubicMeters(20), Duration.FromSeconds(10) * VolumeFlow.FromCubicMetersPerSecond(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/DynamicViscosityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/DynamicViscosityTestsBase.g.cs index ca5587a154..9a15d82dfc 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/DynamicViscosityTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/DynamicViscosityTestsBase.g.cs @@ -796,6 +796,14 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, DynamicViscosity.FromNewtonSecondsPerMeterSquared(10)/DynamicViscosity.FromNewtonSecondsPerMeterSquared(5), NewtonSecondsPerMeterSquaredTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Density.FromKilogramsPerCubicMeter(5), DynamicViscosity.FromNewtonSecondsPerMeterSquared(10) / KinematicViscosity.FromSquareMetersPerSecond(2)); + Assert.Equal(KinematicViscosity.FromSquareMetersPerSecond(5), DynamicViscosity.FromNewtonSecondsPerMeterSquared(10) / Density.FromKilogramsPerCubicMeter(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricChargeTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricChargeTestsBase.g.cs index 38196445cf..285963ded5 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricChargeTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricChargeTestsBase.g.cs @@ -813,6 +813,15 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, ElectricCharge.FromCoulombs(10)/ElectricCharge.FromCoulombs(5), CoulombsTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Duration.FromHours(5), ElectricCharge.FromAmpereHours(10) / ElectricCurrent.FromAmperes(2)); + Assert.Equal(ElectricCurrent.FromAmperes(5), ElectricCharge.FromAmpereHours(10) / Duration.FromHours(2)); + Assert.Equal(Energy.FromJoules(20), ElectricCharge.FromCoulombs(10) * ElectricPotential.FromVolts(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricConductivityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricConductivityTestsBase.g.cs index 3f0c9a3225..b51ae464dd 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricConductivityTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricConductivityTestsBase.g.cs @@ -605,6 +605,25 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, ElectricConductivity.FromSiemensPerMeter(10)/ElectricConductivity.FromSiemensPerMeter(5), SiemensPerMeterTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(ElectricResistivity.FromOhmMeters(5), 10 / ElectricConductivity.FromSiemensPerMeter(2)); + Assert.Equal(20, ElectricConductivity.FromSiemensPerMeter(10) * ElectricResistivity.FromOhmMeters(2)); + } + + [Fact] + public void InverseMethod() + { + ElectricConductivity v = ElectricConductivity.FromSiemensPerMeter(10); + + ElectricResistivity inverse = v.Inverse(); + + AssertEx.EqualTolerance(0.1, inverse.Value, 1e-5); + Assert.Equal(ElectricResistivityUnit.OhmMeter, inverse.Unit); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentGradientTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentGradientTestsBase.g.cs index d4c84273a2..7875d249c1 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentGradientTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentGradientTestsBase.g.cs @@ -637,6 +637,13 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, ElectricCurrentGradient.FromAmperesPerSecond(10)/ElectricCurrentGradient.FromAmperesPerSecond(5), AmperesPerSecondTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(ElectricCurrent.FromAmperes(20), ElectricCurrentGradient.FromAmperesPerSecond(10) * Duration.FromSeconds(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentTestsBase.g.cs index a629f4f7ba..1b93693040 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentTestsBase.g.cs @@ -689,6 +689,17 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, ElectricCurrent.FromAmperes(10)/ElectricCurrent.FromAmperes(5), AmperesTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Duration.FromSeconds(5), ElectricCurrent.FromAmperes(10) / ElectricCurrentGradient.FromAmperesPerSecond(2)); + Assert.Equal(ElectricCharge.FromAmpereHours(20), ElectricCurrent.FromAmperes(10) * Duration.FromHours(2)); + Assert.Equal(ElectricCurrentGradient.FromAmperesPerSecond(5), ElectricCurrent.FromAmperes(10) / Duration.FromSeconds(2)); + Assert.Equal(ElectricPotential.FromVolts(20), ElectricCurrent.FromAmperes(10) * ElectricResistance.FromOhms(2)); + Assert.Equal(Power.FromWatts(20), ElectricCurrent.FromAmperes(10) * ElectricPotential.FromVolts(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricPotentialTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricPotentialTestsBase.g.cs index 4c4ccfa1ad..679fb8e139 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricPotentialTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricPotentialTestsBase.g.cs @@ -683,6 +683,16 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, ElectricPotential.FromVolts(10)/ElectricPotential.FromVolts(5), VoltsTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(ElectricCurrent.FromAmperes(5), ElectricPotential.FromVolts(10) / ElectricResistance.FromOhms(2)); + Assert.Equal(ElectricResistance.FromOhms(5), ElectricPotential.FromVolts(10) / ElectricCurrent.FromAmperes(2)); + Assert.Equal(Energy.FromJoules(20), ElectricPotential.FromVolts(10) * ElectricCharge.FromCoulombs(2)); + Assert.Equal(Power.FromWatts(20), ElectricPotential.FromVolts(10) * ElectricCurrent.FromAmperes(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricResistanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricResistanceTestsBase.g.cs index 52aeab3c26..f9fb4c628c 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricResistanceTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricResistanceTestsBase.g.cs @@ -657,6 +657,13 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, ElectricResistance.FromOhms(10)/ElectricResistance.FromOhms(5), OhmsTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(ElectricPotential.FromVolts(20), ElectricResistance.FromOhms(10) * ElectricCurrent.FromAmperes(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricResistivityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricResistivityTestsBase.g.cs index ce35d0b79f..052fa2b9d4 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricResistivityTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricResistivityTestsBase.g.cs @@ -837,6 +837,25 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, ElectricResistivity.FromOhmMeters(10)/ElectricResistivity.FromOhmMeters(5), OhmMetersTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(ElectricConductivity.FromSiemensPerMeter(5), 10 / ElectricResistivity.FromOhmMeters(2)); + Assert.Equal(20, ElectricResistivity.FromOhmMeters(10) * ElectricConductivity.FromSiemensPerMeter(2)); + } + + [Fact] + public void InverseMethod() + { + ElectricResistivity v = ElectricResistivity.FromOhmMeters(10); + + ElectricConductivity inverse = v.Inverse(); + + AssertEx.EqualTolerance(0.1, inverse.Value, 1e-5); + Assert.Equal(ElectricConductivityUnit.SiemensPerMeter, inverse.Unit); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/EnergyDensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/EnergyDensityTestsBase.g.cs index d1170ac3ad..b46e064d16 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/EnergyDensityTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/EnergyDensityTestsBase.g.cs @@ -797,6 +797,13 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, EnergyDensity.FromJoulesPerCubicMeter(10)/EnergyDensity.FromJoulesPerCubicMeter(5), JoulesPerCubicMeterTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Energy.FromJoules(20), EnergyDensity.FromJoulesPerCubicMeter(10) * Volume.FromCubicMeters(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/EnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/EnergyTestsBase.g.cs index deac0da13e..1194df6631 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/EnergyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/EnergyTestsBase.g.cs @@ -2038,6 +2038,25 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, Energy.FromJoules(10)/Energy.FromJoules(5), JoulesTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(AmountOfSubstance.FromMoles(5), Energy.FromJoules(10) / MolarEnergy.FromJoulesPerMole(2)); + Assert.Equal(Duration.FromSeconds(5), Energy.FromJoules(10) / Power.FromWatts(2)); + Assert.Equal(ElectricCharge.FromCoulombs(5), Energy.FromJoules(10) / ElectricPotential.FromVolts(2)); + Assert.Equal(ElectricPotential.FromVolts(5), Energy.FromJoules(10) / ElectricCharge.FromCoulombs(2)); + Assert.Equal(EnergyDensity.FromJoulesPerCubicMeter(5), Energy.FromJoules(10) / Volume.FromCubicMeters(2)); + Assert.Equal(Entropy.FromJoulesPerKelvin(5), Energy.FromJoules(10) / TemperatureDelta.FromKelvins(2)); + Assert.Equal(Mass.FromKilograms(5), Energy.FromJoules(10) / SpecificEnergy.FromJoulesPerKilogram(2)); + Assert.Equal(MolarEnergy.FromJoulesPerMole(5), Energy.FromJoules(10) / AmountOfSubstance.FromMoles(2)); + Assert.Equal(Power.FromWatts(20), Energy.FromJoules(10) * Frequency.FromPerSecond(2)); + Assert.Equal(Power.FromWatts(5), Energy.FromJoules(10) / Duration.FromSeconds(2)); + Assert.Equal(SpecificEnergy.FromJoulesPerKilogram(5), Energy.FromJoules(10) / Mass.FromKilograms(2)); + Assert.Equal(TemperatureDelta.FromKelvins(5), Energy.FromJoules(10) / Entropy.FromJoulesPerKelvin(2)); + Assert.Equal(Volume.FromCubicMeters(5), Energy.FromJoules(10) / EnergyDensity.FromJoulesPerCubicMeter(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/EntropyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/EntropyTestsBase.g.cs index 59ea0ad87f..82ecfc17fa 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/EntropyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/EntropyTestsBase.g.cs @@ -637,6 +637,15 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, Entropy.FromJoulesPerKelvin(10)/Entropy.FromJoulesPerKelvin(5), JoulesPerKelvinTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Energy.FromJoules(20), Entropy.FromJoulesPerKelvin(10) * TemperatureDelta.FromKelvins(2)); + Assert.Equal(Mass.FromKilograms(5), Entropy.FromJoulesPerKelvin(10) / SpecificEntropy.FromJoulesPerKilogramKelvin(2)); + Assert.Equal(SpecificEntropy.FromJoulesPerKilogramKelvin(5), Entropy.FromJoulesPerKelvin(10) / Mass.FromKilograms(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ForceChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ForceChangeRateTestsBase.g.cs index 71f7e85020..30bd2c8bda 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/ForceChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ForceChangeRateTestsBase.g.cs @@ -977,6 +977,13 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, ForceChangeRate.FromNewtonsPerSecond(10)/ForceChangeRate.FromNewtonsPerSecond(5), NewtonsPerSecondTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Force.FromNewtons(20), ForceChangeRate.FromNewtonsPerSecond(10) * Duration.FromSeconds(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ForcePerLengthTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ForcePerLengthTestsBase.g.cs index 009824af70..027fdd83d7 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/ForcePerLengthTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ForcePerLengthTestsBase.g.cs @@ -1779,6 +1779,21 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, ForcePerLength.FromNewtonsPerMeter(10)/ForcePerLength.FromNewtonsPerMeter(5), NewtonsPerMeterTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Area.FromSquareMeters(5), ForcePerLength.FromNewtonsPerMeter(10) / SpecificWeight.FromNewtonsPerCubicMeter(2)); + Assert.Equal(Force.FromNewtons(20), ForcePerLength.FromNewtonsPerMeter(10) * Length.FromMeters(2)); + Assert.Equal(Force.FromNewtons(5), ForcePerLength.FromNewtonsPerMeter(10) / ReciprocalLength.FromInverseMeters(2)); + Assert.Equal(Length.FromMeters(5), ForcePerLength.FromNewtonsPerMeter(10) / Pressure.FromNewtonsPerSquareMeter(2)); + Assert.Equal(Pressure.FromNewtonsPerSquareMeter(20), ForcePerLength.FromNewtonsPerMeter(10) * ReciprocalLength.FromInverseMeters(2)); + Assert.Equal(Pressure.FromNewtonsPerSquareMeter(5), ForcePerLength.FromNewtonsPerMeter(10) / Length.FromMeters(2)); + Assert.Equal(ReciprocalLength.FromInverseMeters(5), ForcePerLength.FromNewtonsPerMeter(10) / Force.FromNewtons(2)); + Assert.Equal(SpecificWeight.FromNewtonsPerCubicMeter(5), ForcePerLength.FromNewtonsPerMeter(10) / Area.FromSquareMeters(2)); + Assert.Equal(Torque.FromNewtonMeters(20), ForcePerLength.FromNewtonsPerMeter(10) * Area.FromSquareMeters(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ForceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ForceTestsBase.g.cs index 596f6baf4e..f73e1d7aec 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/ForceTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ForceTestsBase.g.cs @@ -1223,6 +1223,24 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, Force.FromNewtons(10)/Force.FromNewtons(5), NewtonsTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Acceleration.FromMetersPerSecondSquared(5), Force.FromNewtons(10) / Mass.FromKilograms(2)); + Assert.Equal(Area.FromSquareMeters(5), Force.FromNewtons(10) / Pressure.FromPascals(2)); + Assert.Equal(Duration.FromSeconds(5), Force.FromNewtons(10) / ForceChangeRate.FromNewtonsPerSecond(2)); + Assert.Equal(ForceChangeRate.FromNewtonsPerSecond(5), Force.FromNewtons(10) / Duration.FromSeconds(2)); + Assert.Equal(ForcePerLength.FromNewtonsPerMeter(20), Force.FromNewtons(10) * ReciprocalLength.FromInverseMeters(2)); + Assert.Equal(ForcePerLength.FromNewtonsPerMeter(5), Force.FromNewtons(10) / Length.FromMeters(2)); + Assert.Equal(Length.FromMeters(5), Force.FromNewtons(10) / ForcePerLength.FromNewtonsPerMeter(2)); + Assert.Equal(Mass.FromKilograms(5), Force.FromNewtons(10) / Acceleration.FromMetersPerSecondSquared(2)); + Assert.Equal(Power.FromWatts(20), Force.FromNewtons(10) * Speed.FromMetersPerSecond(2)); + Assert.Equal(Pressure.FromNewtonsPerSquareMeter(20), Force.FromNewtons(10) * ReciprocalArea.FromInverseSquareMeters(2)); + Assert.Equal(Pressure.FromPascals(5), Force.FromNewtons(10) / Area.FromSquareMeters(2)); + Assert.Equal(Torque.FromNewtonMeters(20), Force.FromNewtons(10) * Length.FromMeters(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/FrequencyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/FrequencyTestsBase.g.cs index 0f21f9f0eb..45cb16dbbc 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/FrequencyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/FrequencyTestsBase.g.cs @@ -926,6 +926,13 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, Frequency.FromHertz(10)/Frequency.FromHertz(5), HertzTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Power.FromWatts(20), Frequency.FromPerSecond(10) * Energy.FromJoules(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/HeatFluxTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/HeatFluxTestsBase.g.cs index c9342f9574..030f94b936 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/HeatFluxTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/HeatFluxTestsBase.g.cs @@ -1010,6 +1010,13 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, HeatFlux.FromWattsPerSquareMeter(10)/HeatFlux.FromWattsPerSquareMeter(5), WattsPerSquareMeterTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Power.FromWatts(20), HeatFlux.FromWattsPerSquareMeter(10) * Area.FromSquareMeters(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/IlluminanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/IlluminanceTestsBase.g.cs index 4cd667e085..bd9a8275c1 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/IlluminanceTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/IlluminanceTestsBase.g.cs @@ -529,6 +529,13 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, Illuminance.FromLux(10)/Illuminance.FromLux(5), LuxTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(LuminousFlux.FromLumens(20), Illuminance.FromLux(10) * Area.FromSquareMeters(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/JerkTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/JerkTestsBase.g.cs index 65c5d79c7f..fa33017569 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/JerkTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/JerkTestsBase.g.cs @@ -952,6 +952,13 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, Jerk.FromMetersPerSecondCubed(10)/Jerk.FromMetersPerSecondCubed(5), MetersPerSecondCubedTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Acceleration.FromMetersPerSecondSquared(20), Jerk.FromMetersPerSecondCubed(10) * Duration.FromSeconds(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/KinematicViscosityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/KinematicViscosityTestsBase.g.cs index 925f9934b8..3fe5fbe094 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/KinematicViscosityTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/KinematicViscosityTestsBase.g.cs @@ -837,6 +837,16 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, KinematicViscosity.FromSquareMetersPerSecond(10)/KinematicViscosity.FromSquareMetersPerSecond(5), SquareMetersPerSecondTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Area.FromSquareMeters(20), KinematicViscosity.FromSquareMetersPerSecond(10) * Duration.FromSeconds(2)); + Assert.Equal(DynamicViscosity.FromNewtonSecondsPerMeterSquared(20), KinematicViscosity.FromSquareMetersPerSecond(10) * Density.FromKilogramsPerCubicMeter(2)); + Assert.Equal(Length.FromMeters(5), KinematicViscosity.FromSquareMetersPerSecond(10) / Speed.FromMetersPerSecond(2)); + Assert.Equal(Speed.FromMetersPerSecond(5), KinematicViscosity.FromSquareMetersPerSecond(10) / Length.FromMeters(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/LengthTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/LengthTestsBase.g.cs index 19d718d8f5..3ad7df52f8 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/LengthTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/LengthTestsBase.g.cs @@ -2579,6 +2579,43 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, Length.FromMeters(10)/Length.FromMeters(5), MetersTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Area.FromSquareMeters(20), Length.FromMeters(10) * Length.FromMeters(2)); + Assert.Equal(Area.FromSquareMeters(5), Length.FromMeters(10) / ReciprocalLength.FromInverseMeters(2)); + Assert.Equal(AreaMomentOfInertia.FromMetersToTheFourth(20), Length.FromMeters(10) * Volume.FromCubicMeters(2)); + Assert.Equal(Duration.FromSeconds(5), Length.FromMeters(10) / Speed.FromMetersPerSecond(2)); + Assert.Equal(Force.FromNewtons(20), Length.FromMeters(10) * ForcePerLength.FromNewtonsPerMeter(2)); + Assert.Equal(ForcePerLength.FromNewtonsPerMeter(20), Length.FromMeters(10) * Pressure.FromNewtonsPerSquareMeter(2)); + Assert.Equal(KinematicViscosity.FromSquareMetersPerSecond(20), Length.FromMeters(10) * Speed.FromMetersPerSecond(2)); + Assert.Equal(Mass.FromKilograms(20), Length.FromMeters(10) * LinearDensity.FromKilogramsPerMeter(2)); + Assert.Equal(Pressure.FromPascals(20), Length.FromMeters(10) * SpecificWeight.FromNewtonsPerCubicMeter(2)); + Assert.Equal(ReciprocalArea.FromInverseSquareMeters(5), Length.FromMeters(10) / Volume.FromCubicMeters(2)); + Assert.Equal(ReciprocalLength.FromInverseMeters(20), Length.FromMeters(10) * ReciprocalArea.FromInverseSquareMeters(2)); + Assert.Equal(ReciprocalLength.FromInverseMeters(5), Length.FromMeters(10) / Area.FromSquareMeters(2)); + Assert.Equal(ReciprocalLength.FromInverseMeters(5), 10 / Length.FromMeters(2)); + Assert.Equal(RotationalStiffness.FromNewtonMetersPerRadian(20), Length.FromMeters(10) * RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(2)); + Assert.Equal(Speed.FromMetersPerSecond(5), Length.FromMeters(10) / Duration.FromSeconds(2)); + Assert.Equal(TemperatureDelta.FromDegreesCelsius(20), Length.FromKilometers(10) * TemperatureGradient.FromDegreesCelsiusPerKilometer(2)); + Assert.Equal(Torque.FromNewtonMeters(20), Length.FromMeters(10) * Force.FromNewtons(2)); + Assert.Equal(Volume.FromCubicMeters(20), Length.FromMeters(10) * Area.FromSquareMeters(2)); + Assert.Equal(Volume.FromCubicMeters(5), Length.FromMeters(10) / ReciprocalArea.FromInverseSquareMeters(2)); + Assert.Equal(20, Length.FromMeters(10) * ReciprocalLength.FromInverseMeters(2)); + } + + [Fact] + public void InverseMethod() + { + Length v = Length.FromMeters(10); + + ReciprocalLength inverse = v.Inverse(); + + AssertEx.EqualTolerance(0.1, inverse.Value, 1e-5); + Assert.Equal(ReciprocalLengthUnit.InverseMeter, inverse.Unit); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/LinearDensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/LinearDensityTestsBase.g.cs index c3b8bcbd16..86fe2623be 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/LinearDensityTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/LinearDensityTestsBase.g.cs @@ -989,6 +989,15 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, LinearDensity.FromKilogramsPerMeter(10)/LinearDensity.FromKilogramsPerMeter(5), KilogramsPerMeterTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Area.FromSquareMeters(5), LinearDensity.FromKilogramsPerMeter(10) / Density.FromKilogramsPerCubicMeter(2)); + Assert.Equal(Density.FromKilogramsPerCubicMeter(5), LinearDensity.FromKilogramsPerMeter(10) / Area.FromSquareMeters(2)); + Assert.Equal(Mass.FromKilograms(20), LinearDensity.FromKilogramsPerMeter(10) * Length.FromMeters(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/LuminanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/LuminanceTestsBase.g.cs index 697d5f6627..989e0916b0 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/LuminanceTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/LuminanceTestsBase.g.cs @@ -733,6 +733,13 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, Luminance.FromCandelasPerSquareMeter(10)/Luminance.FromCandelasPerSquareMeter(5), CandelasPerSquareMeterTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(LuminousIntensity.FromCandela(20), Luminance.FromCandelasPerSquareMeter(10) * Area.FromSquareMeters(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/LuminousFluxTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/LuminousFluxTestsBase.g.cs index 6bb7cdbd0d..980f481b75 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/LuminousFluxTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/LuminousFluxTestsBase.g.cs @@ -445,6 +445,14 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, LuminousFlux.FromLumens(10)/LuminousFlux.FromLumens(5), LumensTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Area.FromSquareMeters(5), LuminousFlux.FromLumens(10) / Illuminance.FromLux(2)); + Assert.Equal(Illuminance.FromLux(5), LuminousFlux.FromLumens(10) / Area.FromSquareMeters(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/LuminousIntensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/LuminousIntensityTestsBase.g.cs index 41d1623280..5b69ac670c 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/LuminousIntensityTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/LuminousIntensityTestsBase.g.cs @@ -445,6 +445,14 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, LuminousIntensity.FromCandela(10)/LuminousIntensity.FromCandela(5), CandelaTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Area.FromSquareMeters(5), LuminousIntensity.FromCandela(10) / Luminance.FromCandelasPerSquareMeter(2)); + Assert.Equal(Luminance.FromCandelasPerSquareMeter(5), LuminousIntensity.FromCandela(10) / Area.FromSquareMeters(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MassConcentrationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MassConcentrationTestsBase.g.cs index f4452e2d44..7342874c91 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/MassConcentrationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MassConcentrationTestsBase.g.cs @@ -2049,6 +2049,17 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, MassConcentration.FromKilogramsPerCubicMeter(10)/MassConcentration.FromKilogramsPerCubicMeter(5), KilogramsPerCubicMeterTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Density.FromKilogramsPerCubicMeter(5), MassConcentration.FromKilogramsPerCubicMeter(10) / VolumeConcentration.FromDecimalFractions(2)); + Assert.Equal(Mass.FromKilograms(20), MassConcentration.FromKilogramsPerCubicMeter(10) * Volume.FromCubicMeters(2)); + Assert.Equal(MolarMass.FromKilogramsPerMole(5), MassConcentration.FromKilogramsPerCubicMeter(10) / Molarity.FromMolesPerCubicMeter(2)); + Assert.Equal(Molarity.FromMolesPerCubicMeter(5), MassConcentration.FromKilogramsPerCubicMeter(10) / MolarMass.FromKilogramsPerMole(2)); + Assert.Equal(VolumeConcentration.FromDecimalFractions(5), MassConcentration.FromKilogramsPerCubicMeter(10) / Density.FromKilogramsPerCubicMeter(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MassFlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MassFlowTestsBase.g.cs index 3b39e35ead..0cbb32ce8a 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/MassFlowTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MassFlowTestsBase.g.cs @@ -1680,6 +1680,22 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, MassFlow.FromGramsPerSecond(10)/MassFlow.FromGramsPerSecond(5), GramsPerSecondTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Area.FromSquareMeters(5), MassFlow.FromKilogramsPerSecond(10) / MassFlux.FromKilogramsPerSecondPerSquareMeter(2)); + Assert.Equal(BrakeSpecificFuelConsumption.FromKilogramsPerJoule(5), MassFlow.FromKilogramsPerSecond(10) / Power.FromWatts(2)); + Assert.Equal(Density.FromKilogramsPerCubicMeter(5), MassFlow.FromKilogramsPerSecond(10) / VolumeFlow.FromCubicMetersPerSecond(2)); + Assert.Equal(Mass.FromKilograms(20), MassFlow.FromKilogramsPerSecond(10) * Duration.FromSeconds(2)); + Assert.Equal(MassFlux.FromKilogramsPerSecondPerSquareMeter(5), MassFlow.FromKilogramsPerSecond(10) / Area.FromSquareMeters(2)); + Assert.Equal(MolarFlow.FromKilomolesPerSecond(5), MassFlow.FromKilogramsPerSecond(10) / MolarMass.FromKilogramsPerKilomole(2)); + Assert.Equal(MolarMass.FromKilogramsPerKilomole(5), MassFlow.FromKilogramsPerSecond(10) / MolarFlow.FromKilomolesPerSecond(2)); + Assert.Equal(Power.FromWatts(20), MassFlow.FromKilogramsPerSecond(10) * SpecificEnergy.FromJoulesPerKilogram(2)); + Assert.Equal(Power.FromWatts(5), MassFlow.FromKilogramsPerSecond(10) / BrakeSpecificFuelConsumption.FromKilogramsPerJoule(2)); + Assert.Equal(VolumeFlow.FromCubicMetersPerSecond(5), MassFlow.FromKilogramsPerSecond(10) / Density.FromKilogramsPerCubicMeter(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MassFluxTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MassFluxTestsBase.g.cs index 91807c4675..0f83105f52 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/MassFluxTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MassFluxTestsBase.g.cs @@ -797,6 +797,15 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, MassFlux.FromKilogramsPerSecondPerSquareMeter(10)/MassFlux.FromKilogramsPerSecondPerSquareMeter(5), KilogramsPerSecondPerSquareMeterTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Density.FromKilogramsPerCubicMeter(5), MassFlux.FromKilogramsPerSecondPerSquareMeter(10) / Speed.FromMetersPerSecond(2)); + Assert.Equal(MassFlow.FromKilogramsPerSecond(20), MassFlux.FromKilogramsPerSecondPerSquareMeter(10) * Area.FromSquareMeters(2)); + Assert.Equal(Speed.FromMetersPerSecond(5), MassFlux.FromKilogramsPerSecondPerSquareMeter(10) / Density.FromKilogramsPerCubicMeter(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MassFractionTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MassFractionTestsBase.g.cs index d8ea83e2f5..e703a143e0 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/MassFractionTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MassFractionTestsBase.g.cs @@ -1142,6 +1142,13 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, MassFraction.FromDecimalFractions(10)/MassFraction.FromDecimalFractions(5), DecimalFractionsTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Mass.FromKilograms(20), MassFraction.FromDecimalFractions(10) * Mass.FromKilograms(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MassTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MassTestsBase.g.cs index 99787d81b5..97c6cc7704 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/MassTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MassTestsBase.g.cs @@ -2103,6 +2103,28 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, Mass.FromKilograms(10)/Mass.FromKilograms(5), KilogramsTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(AmountOfSubstance.FromMoles(5), Mass.FromKilograms(10) / MolarMass.FromKilogramsPerMole(2)); + Assert.Equal(Area.FromSquareMeters(5), Mass.FromKilograms(10) / AreaDensity.FromKilogramsPerSquareMeter(2)); + Assert.Equal(AreaDensity.FromKilogramsPerSquareMeter(5), Mass.FromKilograms(10) / Area.FromSquareMeters(2)); + Assert.Equal(Density.FromKilogramsPerCubicMeter(5), Mass.FromKilograms(10) / Volume.FromCubicMeters(2)); + Assert.Equal(Duration.FromSeconds(5), Mass.FromKilograms(10) / MassFlow.FromKilogramsPerSecond(2)); + Assert.Equal(Energy.FromJoules(20), Mass.FromKilograms(10) * SpecificEnergy.FromJoulesPerKilogram(2)); + Assert.Equal(Entropy.FromJoulesPerKelvin(20), Mass.FromKilograms(10) * SpecificEntropy.FromJoulesPerKilogramKelvin(2)); + Assert.Equal(Force.FromNewtons(20), Mass.FromKilograms(10) * Acceleration.FromMetersPerSecondSquared(2)); + Assert.Equal(Length.FromMeters(5), Mass.FromKilograms(10) / LinearDensity.FromKilogramsPerMeter(2)); + Assert.Equal(LinearDensity.FromKilogramsPerMeter(5), Mass.FromKilograms(10) / Length.FromMeters(2)); + Assert.Equal(Mass.FromKilograms(20), Mass.FromKilograms(10) * MassFraction.FromDecimalFractions(2)); + Assert.Equal(Mass.FromKilograms(5), Mass.FromKilograms(10) / MassFraction.FromDecimalFractions(2)); + Assert.Equal(MassFlow.FromKilogramsPerSecond(5), Mass.FromKilograms(10) / Duration.FromSeconds(2)); + Assert.Equal(MolarMass.FromKilogramsPerMole(5), Mass.FromKilograms(10) / AmountOfSubstance.FromMoles(2)); + Assert.Equal(Volume.FromCubicMeters(20), Mass.FromKilograms(10) * SpecificVolume.FromCubicMetersPerKilogram(2)); + Assert.Equal(Volume.FromCubicMeters(5), Mass.FromKilograms(10) / Density.FromKilogramsPerCubicMeter(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MolarEnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MolarEnergyTestsBase.g.cs index 38499ca4df..97b6c27870 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/MolarEnergyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MolarEnergyTestsBase.g.cs @@ -509,6 +509,13 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, MolarEnergy.FromJoulesPerMole(10)/MolarEnergy.FromJoulesPerMole(5), JoulesPerMoleTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Energy.FromJoules(20), MolarEnergy.FromJoulesPerMole(10) * AmountOfSubstance.FromMoles(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MolarFlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MolarFlowTestsBase.g.cs index bd6eb60f16..1ea7ef07cc 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/MolarFlowTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MolarFlowTestsBase.g.cs @@ -701,6 +701,16 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, MolarFlow.FromMolesPerSecond(10)/MolarFlow.FromMolesPerSecond(5), MolesPerSecondTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(AmountOfSubstance.FromMoles(20), MolarFlow.FromMolesPerSecond(10) * Duration.FromSeconds(2)); + Assert.Equal(MassFlow.FromKilogramsPerSecond(20), MolarFlow.FromKilomolesPerSecond(10) * MolarMass.FromKilogramsPerKilomole(2)); + Assert.Equal(Molarity.FromMolesPerCubicMeter(5), MolarFlow.FromMolesPerSecond(10) / VolumeFlow.FromCubicMetersPerSecond(2)); + Assert.Equal(VolumeFlow.FromCubicMetersPerSecond(5), MolarFlow.FromMolesPerSecond(10) / Molarity.FromMolesPerCubicMeter(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MolarMassTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MolarMassTestsBase.g.cs index d2d864a7f9..4d1debff5f 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/MolarMassTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MolarMassTestsBase.g.cs @@ -1033,6 +1033,15 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, MolarMass.FromKilogramsPerMole(10)/MolarMass.FromKilogramsPerMole(5), KilogramsPerMoleTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Mass.FromKilograms(20), MolarMass.FromKilogramsPerMole(10) * AmountOfSubstance.FromMoles(2)); + Assert.Equal(MassConcentration.FromKilogramsPerCubicMeter(20), MolarMass.FromKilogramsPerMole(10) * Molarity.FromMolesPerCubicMeter(2)); + Assert.Equal(MassFlow.FromKilogramsPerSecond(20), MolarMass.FromKilogramsPerKilomole(10) * MolarFlow.FromKilomolesPerSecond(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MolarityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MolarityTestsBase.g.cs index 7f61722283..7476dc2c2d 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/MolarityTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MolarityTestsBase.g.cs @@ -933,6 +933,17 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, Molarity.FromMolesPerCubicMeter(10)/Molarity.FromMolesPerCubicMeter(5), MolesPerCubicMeterTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(AmountOfSubstance.FromMoles(20), Molarity.FromMolesPerCubicMeter(10) * Volume.FromCubicMeters(2)); + Assert.Equal(MassConcentration.FromKilogramsPerCubicMeter(20), Molarity.FromMolesPerCubicMeter(10) * MolarMass.FromKilogramsPerMole(2)); + Assert.Equal(MolarFlow.FromMolesPerSecond(20), Molarity.FromMolesPerCubicMeter(10) * VolumeFlow.FromCubicMetersPerSecond(2)); + Assert.Equal(Molarity.FromMolesPerCubicMeter(20), Molarity.FromMolesPerCubicMeter(10) * VolumeConcentration.FromDecimalFractions(2)); + Assert.Equal(Molarity.FromMolesPerCubicMeter(5), Molarity.FromMolesPerCubicMeter(10) / VolumeConcentration.FromDecimalFractions(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/PowerTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/PowerTestsBase.g.cs index 4eb21688af..4e4780e7fa 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/PowerTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/PowerTestsBase.g.cs @@ -1304,6 +1304,26 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, Power.FromWatts(10)/Power.FromWatts(5), WattsTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Area.FromSquareMeters(5), Power.FromWatts(10) / HeatFlux.FromWattsPerSquareMeter(2)); + Assert.Equal(ElectricCurrent.FromAmperes(5), Power.FromWatts(10) / ElectricPotential.FromVolts(2)); + Assert.Equal(ElectricPotential.FromVolts(5), Power.FromWatts(10) / ElectricCurrent.FromAmperes(2)); + Assert.Equal(Energy.FromJoules(20), Power.FromWatts(10) * Duration.FromSeconds(2)); + Assert.Equal(Energy.FromJoules(5), Power.FromWatts(10) / Frequency.FromPerSecond(2)); + Assert.Equal(Force.FromNewtons(5), Power.FromWatts(10) / Speed.FromMetersPerSecond(2)); + Assert.Equal(Frequency.FromPerSecond(5), Power.FromWatts(10) / Energy.FromJoules(2)); + Assert.Equal(HeatFlux.FromWattsPerSquareMeter(5), Power.FromWatts(10) / Area.FromSquareMeters(2)); + Assert.Equal(MassFlow.FromKilogramsPerSecond(20), Power.FromWatts(10) * BrakeSpecificFuelConsumption.FromKilogramsPerJoule(2)); + Assert.Equal(MassFlow.FromKilogramsPerSecond(5), Power.FromWatts(10) / SpecificEnergy.FromJoulesPerKilogram(2)); + Assert.Equal(RotationalSpeed.FromRadiansPerSecond(5), Power.FromWatts(10) / Torque.FromNewtonMeters(2)); + Assert.Equal(SpecificEnergy.FromJoulesPerKilogram(5), Power.FromWatts(10) / MassFlow.FromKilogramsPerSecond(2)); + Assert.Equal(Speed.FromMetersPerSecond(5), Power.FromWatts(10) / Force.FromNewtons(2)); + Assert.Equal(Torque.FromNewtonMeters(5), Power.FromWatts(10) / RotationalSpeed.FromRadiansPerSecond(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/PressureChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/PressureChangeRateTestsBase.g.cs index 8881ab41ae..b2aebbd1a3 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/PressureChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/PressureChangeRateTestsBase.g.cs @@ -1523,6 +1523,13 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, PressureChangeRate.FromPascalsPerSecond(10)/PressureChangeRate.FromPascalsPerSecond(5), PascalsPerSecondTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Pressure.FromPascals(20), PressureChangeRate.FromPascalsPerSecond(10) * Duration.FromSeconds(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/PressureTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/PressureTestsBase.g.cs index d0815e9271..3a73d35de3 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/PressureTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/PressureTestsBase.g.cs @@ -2733,6 +2733,22 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, Pressure.FromPascals(10)/Pressure.FromPascals(5), PascalsTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Duration.FromSeconds(5), Pressure.FromPascals(10) / PressureChangeRate.FromPascalsPerSecond(2)); + Assert.Equal(Force.FromNewtons(5), Pressure.FromNewtonsPerSquareMeter(10) / ReciprocalArea.FromInverseSquareMeters(2)); + Assert.Equal(Force.FromNewtons(20), Pressure.FromPascals(10) * Area.FromSquareMeters(2)); + Assert.Equal(ForcePerLength.FromNewtonsPerMeter(20), Pressure.FromNewtonsPerSquareMeter(10) * Length.FromMeters(2)); + Assert.Equal(ForcePerLength.FromNewtonsPerMeter(5), Pressure.FromNewtonsPerSquareMeter(10) / ReciprocalLength.FromInverseMeters(2)); + Assert.Equal(Length.FromMeters(5), Pressure.FromPascals(10) / SpecificWeight.FromNewtonsPerCubicMeter(2)); + Assert.Equal(PressureChangeRate.FromPascalsPerSecond(5), Pressure.FromPascals(10) / Duration.FromSeconds(2)); + Assert.Equal(ReciprocalArea.FromInverseSquareMeters(5), Pressure.FromNewtonsPerSquareMeter(10) / Force.FromNewtons(2)); + Assert.Equal(ReciprocalLength.FromInverseMeters(5), Pressure.FromNewtonsPerSquareMeter(10) / ForcePerLength.FromNewtonsPerMeter(2)); + Assert.Equal(SpecificWeight.FromNewtonsPerCubicMeter(5), Pressure.FromPascals(10) / Length.FromMeters(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/RadiationEquivalentDoseRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/RadiationEquivalentDoseRateTestsBase.g.cs index ad98696554..68bd833dec 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/RadiationEquivalentDoseRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/RadiationEquivalentDoseRateTestsBase.g.cs @@ -869,6 +869,13 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, RadiationEquivalentDoseRate.FromSievertsPerSecond(10)/RadiationEquivalentDoseRate.FromSievertsPerSecond(5), SievertsPerSecondTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(RadiationEquivalentDose.FromSieverts(20), RadiationEquivalentDoseRate.FromSievertsPerHour(10) * Duration.FromHours(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/RadiationEquivalentDoseTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/RadiationEquivalentDoseTestsBase.g.cs index 7c6fd0e6ec..103a2fcb54 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/RadiationEquivalentDoseTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/RadiationEquivalentDoseTestsBase.g.cs @@ -673,6 +673,14 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, RadiationEquivalentDose.FromSieverts(10)/RadiationEquivalentDose.FromSieverts(5), SievertsTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Duration.FromHours(5), RadiationEquivalentDose.FromSieverts(10) / RadiationEquivalentDoseRate.FromSievertsPerHour(2)); + Assert.Equal(RadiationEquivalentDoseRate.FromSievertsPerHour(5), RadiationEquivalentDose.FromSieverts(10) / Duration.FromHours(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ReciprocalAreaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ReciprocalAreaTestsBase.g.cs index 85afe81976..ad39326628 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/ReciprocalAreaTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ReciprocalAreaTestsBase.g.cs @@ -765,6 +765,28 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, ReciprocalArea.FromInverseSquareMeters(10)/ReciprocalArea.FromInverseSquareMeters(5), InverseSquareMetersTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Length.FromMeters(20), ReciprocalArea.FromInverseSquareMeters(10) * Volume.FromCubicMeters(2)); + Assert.Equal(Pressure.FromNewtonsPerSquareMeter(20), ReciprocalArea.FromInverseSquareMeters(10) * Force.FromNewtons(2)); + Assert.Equal(Ratio.FromDecimalFractions(20), ReciprocalArea.FromInverseSquareMeters(10) * Area.FromSquareMeters(2)); + Assert.Equal(ReciprocalLength.FromInverseMeters(20), ReciprocalArea.FromInverseSquareMeters(10) * Length.FromMeters(2)); + Assert.Equal(ReciprocalLength.FromInverseMeters(5), ReciprocalArea.FromInverseSquareMeters(10) / ReciprocalLength.FromInverseMeters(2)); + } + + [Fact] + public void InverseMethod() + { + ReciprocalArea v = ReciprocalArea.FromInverseSquareMeters(10); + + Area inverse = v.Inverse(); + + AssertEx.EqualTolerance(0.1, inverse.Value, 1e-5); + Assert.Equal(AreaUnit.SquareMeter, inverse.Unit); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ReciprocalLengthTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ReciprocalLengthTestsBase.g.cs index cd93811dd3..457d779095 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/ReciprocalLengthTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ReciprocalLengthTestsBase.g.cs @@ -943,6 +943,32 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, ReciprocalLength.FromInverseMeters(10)/ReciprocalLength.FromInverseMeters(5), InverseMetersTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Area.FromSquareMeters(20), ReciprocalLength.FromInverseMeters(10) * Volume.FromCubicMeters(2)); + Assert.Equal(ForcePerLength.FromNewtonsPerMeter(20), ReciprocalLength.FromInverseMeters(10) * Force.FromNewtons(2)); + Assert.Equal(Length.FromMeters(20), ReciprocalLength.FromInverseMeters(10) * Area.FromSquareMeters(2)); + Assert.Equal(Length.FromMeters(5), ReciprocalLength.FromInverseMeters(10) / ReciprocalArea.FromInverseSquareMeters(2)); + Assert.Equal(Length.FromMeters(5), 10 / ReciprocalLength.FromInverseMeters(2)); + Assert.Equal(Pressure.FromNewtonsPerSquareMeter(20), ReciprocalLength.FromInverseMeters(10) * ForcePerLength.FromNewtonsPerMeter(2)); + Assert.Equal(ReciprocalArea.FromInverseSquareMeters(20), ReciprocalLength.FromInverseMeters(10) * ReciprocalLength.FromInverseMeters(2)); + Assert.Equal(ReciprocalArea.FromInverseSquareMeters(5), ReciprocalLength.FromInverseMeters(10) / Length.FromMeters(2)); + Assert.Equal(20, ReciprocalLength.FromInverseMeters(10) * Length.FromMeters(2)); + } + + [Fact] + public void InverseMethod() + { + ReciprocalLength v = ReciprocalLength.FromInverseMeters(10); + + Length inverse = v.Inverse(); + + AssertEx.EqualTolerance(0.1, inverse.Value, 1e-5); + Assert.Equal(LengthUnit.Meter, inverse.Unit); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalSpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalSpeedTestsBase.g.cs index 26828b6d84..6410393081 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalSpeedTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalSpeedTestsBase.g.cs @@ -1159,6 +1159,14 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, RotationalSpeed.FromRadiansPerSecond(10)/RotationalSpeed.FromRadiansPerSecond(5), RadiansPerSecondTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Angle.FromRadians(20), RotationalSpeed.FromRadiansPerSecond(10) * Duration.FromSeconds(2)); + Assert.Equal(Power.FromWatts(20), RotationalSpeed.FromRadiansPerSecond(10) * Torque.FromNewtonMeters(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessPerLengthTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessPerLengthTestsBase.g.cs index c44f3f0299..d4e2995649 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessPerLengthTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessPerLengthTestsBase.g.cs @@ -741,6 +741,13 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(10)/RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(5), NewtonMetersPerRadianPerMeterTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(RotationalStiffness.FromNewtonMetersPerRadian(20), RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(10) * Length.FromMeters(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessTestsBase.g.cs index 508614dbae..5f2a0d121c 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessTestsBase.g.cs @@ -2840,6 +2840,15 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, RotationalStiffness.FromNewtonMetersPerRadian(10)/RotationalStiffness.FromNewtonMetersPerRadian(5), NewtonMetersPerRadianTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Length.FromMeters(5), RotationalStiffness.FromNewtonMetersPerRadian(10) / RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(2)); + Assert.Equal(RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(5), RotationalStiffness.FromNewtonMetersPerRadian(10) / Length.FromMeters(2)); + Assert.Equal(Torque.FromNewtonMeters(20), RotationalStiffness.FromNewtonMetersPerRadian(10) * Angle.FromRadians(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificEnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificEnergyTestsBase.g.cs index 91b3e5ef87..182378814b 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificEnergyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificEnergyTestsBase.g.cs @@ -1373,6 +1373,19 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, SpecificEnergy.FromJoulesPerKilogram(10)/SpecificEnergy.FromJoulesPerKilogram(5), JoulesPerKilogramTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(BrakeSpecificFuelConsumption.FromKilogramsPerJoule(5), 10 / SpecificEnergy.FromJoulesPerKilogram(2)); + Assert.Equal(Energy.FromJoules(20), SpecificEnergy.FromJoulesPerKilogram(10) * Mass.FromKilograms(2)); + Assert.Equal(Power.FromWatts(20), SpecificEnergy.FromJoulesPerKilogram(10) * MassFlow.FromKilogramsPerSecond(2)); + Assert.Equal(SpecificEntropy.FromJoulesPerKilogramKelvin(5), SpecificEnergy.FromJoulesPerKilogram(10) / TemperatureDelta.FromKelvins(2)); + Assert.Equal(Speed.FromMetersPerSecond(5), SpecificEnergy.FromJoulesPerKilogram(10) / Speed.FromMetersPerSecond(2)); + Assert.Equal(TemperatureDelta.FromKelvins(5), SpecificEnergy.FromJoulesPerKilogram(10) / SpecificEntropy.FromJoulesPerKilogramKelvin(2)); + Assert.Equal(20, SpecificEnergy.FromJoulesPerKilogram(10) * BrakeSpecificFuelConsumption.FromKilogramsPerJoule(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificEntropyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificEntropyTestsBase.g.cs index fffd2ae534..f09158d7cc 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificEntropyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificEntropyTestsBase.g.cs @@ -722,6 +722,14 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, SpecificEntropy.FromJoulesPerKilogramKelvin(10)/SpecificEntropy.FromJoulesPerKilogramKelvin(5), JoulesPerKilogramKelvinTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Entropy.FromJoulesPerKelvin(20), SpecificEntropy.FromJoulesPerKilogramKelvin(10) * Mass.FromKilograms(2)); + Assert.Equal(SpecificEnergy.FromJoulesPerKilogram(20), SpecificEntropy.FromJoulesPerKilogramKelvin(10) * TemperatureDelta.FromKelvins(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificVolumeTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificVolumeTestsBase.g.cs index 7580f7a71b..40d05460fe 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificVolumeTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificVolumeTestsBase.g.cs @@ -509,6 +509,26 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, SpecificVolume.FromCubicMetersPerKilogram(10)/SpecificVolume.FromCubicMetersPerKilogram(5), CubicMetersPerKilogramTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Density.FromKilogramsPerCubicMeter(5), 10 / SpecificVolume.FromCubicMetersPerKilogram(2)); + Assert.Equal(Volume.FromCubicMeters(20), SpecificVolume.FromCubicMetersPerKilogram(10) * Mass.FromKilograms(2)); + Assert.Equal(20, SpecificVolume.FromCubicMetersPerKilogram(10) * Density.FromKilogramsPerCubicMeter(2)); + } + + [Fact] + public void InverseMethod() + { + SpecificVolume v = SpecificVolume.FromCubicMetersPerKilogram(10); + + Density inverse = v.Inverse(); + + AssertEx.EqualTolerance(0.1, inverse.Value, 1e-5); + Assert.Equal(DensityUnit.KilogramPerCubicMeter, inverse.Unit); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificWeightTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificWeightTestsBase.g.cs index ef46d3c56d..03d0680eb3 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificWeightTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificWeightTestsBase.g.cs @@ -957,6 +957,16 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, SpecificWeight.FromNewtonsPerCubicMeter(10)/SpecificWeight.FromNewtonsPerCubicMeter(5), NewtonsPerCubicMeterTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Acceleration.FromMetersPerSecondSquared(5), SpecificWeight.FromNewtonsPerCubicMeter(10) / Density.FromKilogramsPerCubicMeter(2)); + Assert.Equal(Density.FromKilogramsPerCubicMeter(5), SpecificWeight.FromNewtonsPerCubicMeter(10) / Acceleration.FromMetersPerSecondSquared(2)); + Assert.Equal(ForcePerLength.FromNewtonsPerMeter(20), SpecificWeight.FromNewtonsPerCubicMeter(10) * Area.FromSquareMeters(2)); + Assert.Equal(Pressure.FromPascals(20), SpecificWeight.FromNewtonsPerCubicMeter(10) * Length.FromMeters(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/SpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/SpeedTestsBase.g.cs index 186a2d8e99..fe602fcb33 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/SpeedTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/SpeedTestsBase.g.cs @@ -2003,6 +2003,20 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, Speed.FromMetersPerSecond(10)/Speed.FromMetersPerSecond(5), MetersPerSecondTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Acceleration.FromMetersPerSecondSquared(5), Speed.FromMetersPerSecond(10) / Duration.FromSeconds(2)); + Assert.Equal(Duration.FromSeconds(5), Speed.FromMetersPerSecond(10) / Acceleration.FromMetersPerSecondSquared(2)); + Assert.Equal(KinematicViscosity.FromSquareMetersPerSecond(20), Speed.FromMetersPerSecond(10) * Length.FromMeters(2)); + Assert.Equal(Length.FromMeters(20), Speed.FromMetersPerSecond(10) * Duration.FromSeconds(2)); + Assert.Equal(MassFlux.FromKilogramsPerSecondPerSquareMeter(20), Speed.FromMetersPerSecond(10) * Density.FromKilogramsPerCubicMeter(2)); + Assert.Equal(Power.FromWatts(20), Speed.FromMetersPerSecond(10) * Force.FromNewtons(2)); + Assert.Equal(SpecificEnergy.FromJoulesPerKilogram(20), Speed.FromMetersPerSecond(10) * Speed.FromMetersPerSecond(2)); + Assert.Equal(VolumeFlow.FromCubicMetersPerSecond(20), Speed.FromMetersPerSecond(10) * Area.FromSquareMeters(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureChangeRateTestsBase.g.cs index 3f93f54c57..fb721d38f6 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureChangeRateTestsBase.g.cs @@ -957,6 +957,13 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, TemperatureChangeRate.FromDegreesCelsiusPerSecond(10)/TemperatureChangeRate.FromDegreesCelsiusPerSecond(5), DegreesCelsiusPerSecondTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(TemperatureDelta.FromDegreesCelsius(20), TemperatureChangeRate.FromDegreesCelsiusPerSecond(10) * Duration.FromSeconds(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureDeltaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureDeltaTestsBase.g.cs index eb7acaf065..4d52f1784c 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureDeltaTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureDeltaTestsBase.g.cs @@ -701,6 +701,19 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, TemperatureDelta.FromKelvins(10)/TemperatureDelta.FromKelvins(5), KelvinsTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Duration.FromSeconds(5), TemperatureDelta.FromDegreesCelsius(10) / TemperatureChangeRate.FromDegreesCelsiusPerSecond(2)); + Assert.Equal(Energy.FromJoules(20), TemperatureDelta.FromKelvins(10) * Entropy.FromJoulesPerKelvin(2)); + Assert.Equal(Length.FromKilometers(5), TemperatureDelta.FromDegreesCelsius(10) / TemperatureGradient.FromDegreesCelsiusPerKilometer(2)); + Assert.Equal(Ratio.FromDecimalFractions(20), TemperatureDelta.FromKelvins(10) * CoefficientOfThermalExpansion.FromPerKelvin(2)); + Assert.Equal(SpecificEnergy.FromJoulesPerKilogram(20), TemperatureDelta.FromKelvins(10) * SpecificEntropy.FromJoulesPerKilogramKelvin(2)); + Assert.Equal(TemperatureChangeRate.FromDegreesCelsiusPerSecond(5), TemperatureDelta.FromDegreesCelsius(10) / Duration.FromSeconds(2)); + Assert.Equal(TemperatureGradient.FromDegreesCelsiusPerKilometer(5), TemperatureDelta.FromDegreesCelsius(10) / Length.FromKilometers(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureGradientTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureGradientTestsBase.g.cs index feb6d435cc..4b7c57ebd0 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureGradientTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureGradientTestsBase.g.cs @@ -541,6 +541,13 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, TemperatureGradient.FromKelvinsPerMeter(10)/TemperatureGradient.FromKelvinsPerMeter(5), KelvinsPerMeterTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(TemperatureDelta.FromDegreesCelsius(20), TemperatureGradient.FromDegreesCelsiusPerKilometer(10) * Length.FromKilometers(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/TorqueTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/TorqueTestsBase.g.cs index 024286685b..4c2e5fe45b 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/TorqueTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/TorqueTestsBase.g.cs @@ -1264,6 +1264,19 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, Torque.FromNewtonMeters(10)/Torque.FromNewtonMeters(5), NewtonMetersTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Angle.FromRadians(5), Torque.FromNewtonMeters(10) / RotationalStiffness.FromNewtonMetersPerRadian(2)); + Assert.Equal(Area.FromSquareMeters(5), Torque.FromNewtonMeters(10) / ForcePerLength.FromNewtonsPerMeter(2)); + Assert.Equal(Force.FromNewtons(5), Torque.FromNewtonMeters(10) / Length.FromMeters(2)); + Assert.Equal(ForcePerLength.FromNewtonsPerMeter(5), Torque.FromNewtonMeters(10) / Area.FromSquareMeters(2)); + Assert.Equal(Length.FromMeters(5), Torque.FromNewtonMeters(10) / Force.FromNewtons(2)); + Assert.Equal(Power.FromWatts(20), Torque.FromNewtonMeters(10) * RotationalSpeed.FromRadiansPerSecond(2)); + Assert.Equal(RotationalStiffness.FromNewtonMetersPerRadian(5), Torque.FromNewtonMeters(10) / Angle.FromRadians(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeConcentrationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeConcentrationTestsBase.g.cs index bd01c8516d..eabb440102 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeConcentrationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeConcentrationTestsBase.g.cs @@ -1014,6 +1014,14 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, VolumeConcentration.FromDecimalFractions(10)/VolumeConcentration.FromDecimalFractions(5), DecimalFractionsTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(MassConcentration.FromKilogramsPerCubicMeter(20), VolumeConcentration.FromDecimalFractions(10) * Density.FromKilogramsPerCubicMeter(2)); + Assert.Equal(Molarity.FromMolesPerCubicMeter(20), VolumeConcentration.FromDecimalFractions(10) * Molarity.FromMolesPerCubicMeter(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeFlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeFlowTestsBase.g.cs index b44ad00ce2..004baa47ed 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeFlowTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeFlowTestsBase.g.cs @@ -4520,6 +4520,17 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, VolumeFlow.FromCubicMetersPerSecond(10)/VolumeFlow.FromCubicMetersPerSecond(5), CubicMetersPerSecondTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(Area.FromSquareMeters(5), VolumeFlow.FromCubicMetersPerSecond(10) / Speed.FromMetersPerSecond(2)); + Assert.Equal(MassFlow.FromKilogramsPerSecond(20), VolumeFlow.FromCubicMetersPerSecond(10) * Density.FromKilogramsPerCubicMeter(2)); + Assert.Equal(MolarFlow.FromMolesPerSecond(20), VolumeFlow.FromCubicMetersPerSecond(10) * Molarity.FromMolesPerCubicMeter(2)); + Assert.Equal(Speed.FromMetersPerSecond(5), VolumeFlow.FromCubicMetersPerSecond(10) / Area.FromSquareMeters(2)); + Assert.Equal(Volume.FromCubicMeters(20), VolumeFlow.FromCubicMetersPerSecond(10) * Duration.FromSeconds(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeTestsBase.g.cs index bb7f1dabf7..9e0dc269c9 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeTestsBase.g.cs @@ -3036,6 +3036,25 @@ public void ArithmeticOperators() AssertEx.EqualTolerance(2, Volume.FromCubicMeters(10)/Volume.FromCubicMeters(5), CubicMetersTolerance); } + /// Tests generated arithmetic operators for quantity relations defined in Common/UnitRelations.json + [Fact] + public void ArithmeticOperators_Relational() + { + Assert.Equal(AmountOfSubstance.FromMoles(20), Volume.FromCubicMeters(10) * Molarity.FromMolesPerCubicMeter(2)); + Assert.Equal(Area.FromSquareMeters(20), Volume.FromCubicMeters(10) * ReciprocalLength.FromInverseMeters(2)); + Assert.Equal(Area.FromSquareMeters(5), Volume.FromCubicMeters(10) / Length.FromMeters(2)); + Assert.Equal(AreaMomentOfInertia.FromMetersToTheFourth(20), Volume.FromCubicMeters(10) * Length.FromMeters(2)); + Assert.Equal(Duration.FromSeconds(5), Volume.FromCubicMeters(10) / VolumeFlow.FromCubicMetersPerSecond(2)); + Assert.Equal(Energy.FromJoules(20), Volume.FromCubicMeters(10) * EnergyDensity.FromJoulesPerCubicMeter(2)); + Assert.Equal(Length.FromMeters(20), Volume.FromCubicMeters(10) * ReciprocalArea.FromInverseSquareMeters(2)); + Assert.Equal(Length.FromMeters(5), Volume.FromCubicMeters(10) / Area.FromSquareMeters(2)); + Assert.Equal(Mass.FromKilograms(20), Volume.FromCubicMeters(10) * Density.FromKilogramsPerCubicMeter(2)); + Assert.Equal(Mass.FromKilograms(20), Volume.FromCubicMeters(10) * MassConcentration.FromKilogramsPerCubicMeter(2)); + Assert.Equal(Mass.FromKilograms(5), Volume.FromCubicMeters(10) / SpecificVolume.FromCubicMetersPerKilogram(2)); + Assert.Equal(SpecificVolume.FromCubicMetersPerKilogram(5), Volume.FromCubicMeters(10) / Mass.FromKilograms(2)); + Assert.Equal(VolumeFlow.FromCubicMetersPerSecond(5), Volume.FromCubicMeters(10) / Duration.FromSeconds(2)); + } + [Fact] public void ComparisonOperators() { diff --git a/UnitsNet/GeneratedCode/Quantities/Density.g.cs b/UnitsNet/GeneratedCode/Quantities/Density.g.cs index 0172155c0b..e1924540b1 100644 --- a/UnitsNet/GeneratedCode/Quantities/Density.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Density.g.cs @@ -49,6 +49,7 @@ namespace UnitsNet IMultiplyOperators, IMultiplyOperators, IMultiplyOperators, + IMultiplyOperators, #endif #if NET7_0_OR_GREATER IComparisonOperators, @@ -1421,12 +1422,24 @@ public SpecificVolume Inverse() return MassFlux.FromKilogramsPerSecondPerSquareMeter(density.KilogramsPerCubicMeter * speed.MetersPerSecond); } + /// Get from / . + public static SpecificVolume operator /(double value, Density density) + { + return SpecificVolume.FromCubicMetersPerKilogram(value / density.KilogramsPerCubicMeter); + } + /// Get from * . public static SpecificWeight operator *(Density density, Acceleration acceleration) { return SpecificWeight.FromNewtonsPerCubicMeter(density.KilogramsPerCubicMeter * acceleration.MetersPerSecondSquared); } + /// Get from * . + public static double operator *(Density density, SpecificVolume specificVolume) + { + return density.KilogramsPerCubicMeter * specificVolume.CubicMetersPerKilogram; + } + #endregion #region Equality / IComparable diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs index c6640f9ed8..a36b14554a 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs @@ -41,6 +41,9 @@ namespace UnitsNet [DebuggerTypeProxy(typeof(QuantityDisplay))] public readonly partial struct ElectricConductivity : IArithmeticQuantity, +#if NET7_0_OR_GREATER + IMultiplyOperators, +#endif #if NET7_0_OR_GREATER IComparisonOperators, IParsable, @@ -576,6 +579,18 @@ public ElectricResistivity Inverse() return ElectricResistivity.FromOhmMeters(1 / SiemensPerMeter); } + /// Get from / . + public static ElectricResistivity operator /(double value, ElectricConductivity electricConductivity) + { + return ElectricResistivity.FromOhmMeters(value / electricConductivity.SiemensPerMeter); + } + + /// Get from * . + public static double operator *(ElectricConductivity electricConductivity, ElectricResistivity electricResistivity) + { + return electricConductivity.SiemensPerMeter * electricResistivity.OhmMeters; + } + #endregion #region Equality / IComparable diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs index 35408b639f..a14c64aec2 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs @@ -41,6 +41,9 @@ namespace UnitsNet [DebuggerTypeProxy(typeof(QuantityDisplay))] public readonly partial struct ElectricResistivity : IArithmeticQuantity, +#if NET7_0_OR_GREATER + IMultiplyOperators, +#endif #if NET7_0_OR_GREATER IComparisonOperators, IParsable, @@ -704,6 +707,18 @@ public ElectricConductivity Inverse() return ElectricConductivity.FromSiemensPerMeter(1 / OhmMeters); } + /// Get from / . + public static ElectricConductivity operator /(double value, ElectricResistivity electricResistivity) + { + return ElectricConductivity.FromSiemensPerMeter(value / electricResistivity.OhmMeters); + } + + /// Get from * . + public static double operator *(ElectricResistivity electricResistivity, ElectricConductivity electricConductivity) + { + return electricResistivity.OhmMeters * electricConductivity.SiemensPerMeter; + } + #endregion #region Equality / IComparable diff --git a/UnitsNet/GeneratedCode/Quantities/Length.g.cs b/UnitsNet/GeneratedCode/Quantities/Length.g.cs index c7b6885b1d..c42c07d4df 100644 --- a/UnitsNet/GeneratedCode/Quantities/Length.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Length.g.cs @@ -57,6 +57,7 @@ namespace UnitsNet IMultiplyOperators, IMultiplyOperators, IDivisionOperators, + IMultiplyOperators, #endif #if NET7_0_OR_GREATER IComparisonOperators, @@ -1241,6 +1242,12 @@ public ReciprocalLength Inverse() return ReciprocalLength.FromInverseMeters(length.Meters / area.SquareMeters); } + /// Get from / . + public static ReciprocalLength operator /(double value, Length length) + { + return ReciprocalLength.FromInverseMeters(value / length.Meters); + } + /// Get from * . public static RotationalStiffness operator *(Length length, RotationalStiffnessPerLength rotationalStiffnessPerLength) { @@ -1277,6 +1284,12 @@ public ReciprocalLength Inverse() return Volume.FromCubicMeters(length.Meters / reciprocalArea.InverseSquareMeters); } + /// Get from * . + public static double operator *(Length length, ReciprocalLength reciprocalLength) + { + return length.Meters * reciprocalLength.InverseMeters; + } + #endregion #region Equality / IComparable diff --git a/UnitsNet/GeneratedCode/Quantities/ReciprocalLength.g.cs b/UnitsNet/GeneratedCode/Quantities/ReciprocalLength.g.cs index 8cd64726bf..6cc266280f 100644 --- a/UnitsNet/GeneratedCode/Quantities/ReciprocalLength.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ReciprocalLength.g.cs @@ -49,6 +49,7 @@ namespace UnitsNet IMultiplyOperators, IMultiplyOperators, IDivisionOperators, + IMultiplyOperators, #endif #if NET7_0_OR_GREATER IComparisonOperators, @@ -673,6 +674,12 @@ public Length Inverse() return Length.FromMeters(reciprocalLength.InverseMeters / reciprocalArea.InverseSquareMeters); } + /// Get from / . + public static Length operator /(double value, ReciprocalLength reciprocalLength) + { + return Length.FromMeters(value / reciprocalLength.InverseMeters); + } + /// Get from * . public static Pressure operator *(ReciprocalLength reciprocalLength, ForcePerLength forcePerLength) { @@ -691,6 +698,12 @@ public Length Inverse() return ReciprocalArea.FromInverseSquareMeters(reciprocalLength.InverseMeters / length.Meters); } + /// Get from * . + public static double operator *(ReciprocalLength reciprocalLength, Length length) + { + return reciprocalLength.InverseMeters * length.Meters; + } + #endregion #region Equality / IComparable diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs index fc38800fae..ff74cd6c79 100644 --- a/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs @@ -40,6 +40,7 @@ namespace UnitsNet IArithmeticQuantity, #if NET7_0_OR_GREATER IMultiplyOperators, + IMultiplyOperators, #endif #if NET7_0_OR_GREATER IComparisonOperators, @@ -528,12 +529,24 @@ public Density Inverse() return Density.FromKilogramsPerCubicMeter(1 / CubicMetersPerKilogram); } + /// Get from / . + public static Density operator /(double value, SpecificVolume specificVolume) + { + return Density.FromKilogramsPerCubicMeter(value / specificVolume.CubicMetersPerKilogram); + } + /// Get from * . public static Volume operator *(SpecificVolume specificVolume, Mass mass) { return Volume.FromCubicMeters(specificVolume.CubicMetersPerKilogram * mass.Kilograms); } + /// Get from * . + public static double operator *(SpecificVolume specificVolume, Density density) + { + return specificVolume.CubicMetersPerKilogram * density.KilogramsPerCubicMeter; + } + #endregion #region Equality / IComparable