From fa70088b3979385ac0b93570b38bcb8ca513dcd1 Mon Sep 17 00:00:00 2001 From: Andreas Gullberg Larsen Date: Thu, 8 Nov 2018 23:03:32 +0100 Subject: [PATCH 1/4] Add tests failing on Temperature plus/minus operators --- UnitsNet.Tests/CustomCode/TemperatureTests.cs | 24 +++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/UnitsNet.Tests/CustomCode/TemperatureTests.cs b/UnitsNet.Tests/CustomCode/TemperatureTests.cs index a923721e86..d9efc924cd 100644 --- a/UnitsNet.Tests/CustomCode/TemperatureTests.cs +++ b/UnitsNet.Tests/CustomCode/TemperatureTests.cs @@ -45,6 +45,30 @@ public class TemperatureTests : TemperatureTestsBase protected override double KelvinsInOneKelvin => 1; + [Theory] + [InlineData(TemperatureUnit.DegreeCelsius, 10, 20, "303.15 °C")] + [InlineData(TemperatureUnit.DegreeFahrenheit, 100, 100, "659.67 °F")] + [InlineData(TemperatureUnit.Kelvin, 50, 100, "150 K")] + public void TemperaturePlusTemperatureEqualsTemperatureAddedInKelvins(TemperatureUnit unit, int left, int right, string expected) + { + var leftTemp = Temperature.From(left, unit); + var rightTemp = Temperature.From(right, unit); + Assert.Equal(expected, (leftTemp + rightTemp).ToString()); + } + + [Theory] + [InlineData(TemperatureUnit.DegreeCelsius, 30, 20, "-263.15 °C")] + [InlineData(TemperatureUnit.DegreeCelsius, 30, 30, "-273.15 °C")] + [InlineData(TemperatureUnit.DegreeFahrenheit, 100, 70, "-429.67 °F")] + [InlineData(TemperatureUnit.Kelvin, 300, 200, "100 K")] + [InlineData(TemperatureUnit.Kelvin, 200, 300, "-100 K")] + public void TemperatureMinusTemperatureEqualsTemperatureSubtractedInKelvins(TemperatureUnit unit, int left, int right, string expected) + { + var leftTemp = Temperature.From(left, unit); + var rightTemp = Temperature.From(right, unit); + Assert.Equal(expected, (leftTemp - rightTemp).ToString()); + } + [Theory] [InlineData(TemperatureUnit.DegreeCelsius, -10, 0, "-10 °C")] [InlineData(TemperatureUnit.DegreeCelsius, -10, 10, "0 °C")] From b7250930722ff5c0d84c8d0769d0c7d1f2c8d8a3 Mon Sep 17 00:00:00 2001 From: Andreas Gullberg Larsen Date: Thu, 8 Nov 2018 23:15:02 +0100 Subject: [PATCH 2/4] Fix Temperature arithmetic manually --- .../Quantities/Temperature.NetFramework.g.cs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/UnitsNet/GeneratedCode/Quantities/Temperature.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Temperature.NetFramework.g.cs index 5ed37bd6d7..f553652e46 100644 --- a/UnitsNet/GeneratedCode/Quantities/Temperature.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Temperature.NetFramework.g.cs @@ -454,12 +454,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Temper public static Temperature operator +(Temperature left, Temperature right) { - return new Temperature(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Temperature operator -(Temperature left, Temperature right) { - return new Temperature(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Temperature operator *(double left, Temperature right) @@ -506,12 +506,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Temper return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(Temperature left, Temperature right) + public static bool operator ==(Temperature left, Temperature right) { return left.Equals(right); } - public static bool operator !=(Temperature left, Temperature right) + public static bool operator !=(Temperature left, Temperature right) { return !(left == right); } From c94fd1f3a56b36712f68b49824e129d8b05601c5 Mon Sep 17 00:00:00 2001 From: Andreas Gullberg Larsen Date: Thu, 8 Nov 2018 23:16:12 +0100 Subject: [PATCH 3/4] Fix codegen script --- .../Include-GenerateQuantitySourceCodeNetFramework.ps1 | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/UnitsNet/Scripts/Include-GenerateQuantitySourceCodeNetFramework.ps1 b/UnitsNet/Scripts/Include-GenerateQuantitySourceCodeNetFramework.ps1 index d876ece7bb..e80a6612aa 100644 --- a/UnitsNet/Scripts/Include-GenerateQuantitySourceCodeNetFramework.ps1 +++ b/UnitsNet/Scripts/Include-GenerateQuantitySourceCodeNetFramework.ps1 @@ -750,12 +750,12 @@ function GenerateArithmeticOperators([GeneratorArgs]$genArgs) public static $quantityName operator +($quantityName left, $quantityName right) { - return new $quantityName(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static $quantityName operator -($quantityName left, $quantityName right) { - return new $quantityName(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static $quantityName operator *($valueType left, $quantityName right) @@ -812,12 +812,12 @@ function GenerateEqualityAndComparison([GeneratorArgs]$genArgs) return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==($quantityName left, $quantityName right) + public static bool operator ==($quantityName left, $quantityName right) { return left.Equals(right); } - public static bool operator !=($quantityName left, $quantityName right) + public static bool operator !=($quantityName left, $quantityName right) { return !(left == right); } From 5633e018b160a8fdd57e0a80df568c97fed1882f Mon Sep 17 00:00:00 2001 From: Andreas Gullberg Larsen Date: Thu, 8 Nov 2018 23:16:37 +0100 Subject: [PATCH 4/4] Regen code --- .../Quantities/Acceleration.NetFramework.g.cs | 8 ++++---- .../Quantities/AmountOfSubstance.NetFramework.g.cs | 8 ++++---- .../Quantities/AmplitudeRatio.NetFramework.g.cs | 4 ++-- UnitsNet/GeneratedCode/Quantities/Angle.NetFramework.g.cs | 8 ++++---- .../Quantities/ApparentEnergy.NetFramework.g.cs | 8 ++++---- .../Quantities/ApparentPower.NetFramework.g.cs | 8 ++++---- UnitsNet/GeneratedCode/Quantities/Area.NetFramework.g.cs | 8 ++++---- .../Quantities/AreaDensity.NetFramework.g.cs | 8 ++++---- .../Quantities/AreaMomentOfInertia.NetFramework.g.cs | 8 ++++---- .../GeneratedCode/Quantities/BitRate.NetFramework.g.cs | 8 ++++---- .../BrakeSpecificFuelConsumption.NetFramework.g.cs | 8 ++++---- .../Quantities/Capacitance.NetFramework.g.cs | 8 ++++---- .../CoefficientOfThermalExpansion.NetFramework.g.cs | 8 ++++---- .../GeneratedCode/Quantities/Density.NetFramework.g.cs | 8 ++++---- .../GeneratedCode/Quantities/Duration.NetFramework.g.cs | 8 ++++---- .../Quantities/DynamicViscosity.NetFramework.g.cs | 8 ++++---- .../Quantities/ElectricAdmittance.NetFramework.g.cs | 8 ++++---- .../Quantities/ElectricCharge.NetFramework.g.cs | 8 ++++---- .../Quantities/ElectricChargeDensity.NetFramework.g.cs | 8 ++++---- .../Quantities/ElectricConductance.NetFramework.g.cs | 8 ++++---- .../Quantities/ElectricConductivity.NetFramework.g.cs | 8 ++++---- .../Quantities/ElectricCurrent.NetFramework.g.cs | 8 ++++---- .../Quantities/ElectricCurrentDensity.NetFramework.g.cs | 8 ++++---- .../Quantities/ElectricCurrentGradient.NetFramework.g.cs | 8 ++++---- .../Quantities/ElectricField.NetFramework.g.cs | 8 ++++---- .../Quantities/ElectricInductance.NetFramework.g.cs | 8 ++++---- .../Quantities/ElectricPotential.NetFramework.g.cs | 8 ++++---- .../Quantities/ElectricPotentialAc.NetFramework.g.cs | 8 ++++---- .../Quantities/ElectricPotentialDc.NetFramework.g.cs | 8 ++++---- .../Quantities/ElectricResistance.NetFramework.g.cs | 8 ++++---- .../Quantities/ElectricResistivity.NetFramework.g.cs | 8 ++++---- .../GeneratedCode/Quantities/Energy.NetFramework.g.cs | 8 ++++---- .../GeneratedCode/Quantities/Entropy.NetFramework.g.cs | 8 ++++---- UnitsNet/GeneratedCode/Quantities/Force.NetFramework.g.cs | 8 ++++---- .../Quantities/ForceChangeRate.NetFramework.g.cs | 8 ++++---- .../Quantities/ForcePerLength.NetFramework.g.cs | 8 ++++---- .../GeneratedCode/Quantities/Frequency.NetFramework.g.cs | 8 ++++---- .../GeneratedCode/Quantities/HeatFlux.NetFramework.g.cs | 8 ++++---- .../Quantities/HeatTransferCoefficient.NetFramework.g.cs | 8 ++++---- .../Quantities/Illuminance.NetFramework.g.cs | 8 ++++---- .../Quantities/Information.NetFramework.g.cs | 8 ++++---- .../GeneratedCode/Quantities/Irradiance.NetFramework.g.cs | 8 ++++---- .../Quantities/Irradiation.NetFramework.g.cs | 8 ++++---- .../Quantities/KinematicViscosity.NetFramework.g.cs | 8 ++++---- .../GeneratedCode/Quantities/LapseRate.NetFramework.g.cs | 8 ++++---- .../GeneratedCode/Quantities/Length.NetFramework.g.cs | 8 ++++---- UnitsNet/GeneratedCode/Quantities/Level.NetFramework.g.cs | 4 ++-- .../Quantities/LinearDensity.NetFramework.g.cs | 8 ++++---- .../Quantities/LuminousFlux.NetFramework.g.cs | 8 ++++---- .../Quantities/LuminousIntensity.NetFramework.g.cs | 8 ++++---- .../Quantities/MagneticField.NetFramework.g.cs | 8 ++++---- .../Quantities/MagneticFlux.NetFramework.g.cs | 8 ++++---- .../Quantities/Magnetization.NetFramework.g.cs | 8 ++++---- UnitsNet/GeneratedCode/Quantities/Mass.NetFramework.g.cs | 8 ++++---- .../GeneratedCode/Quantities/MassFlow.NetFramework.g.cs | 8 ++++---- .../GeneratedCode/Quantities/MassFlux.NetFramework.g.cs | 8 ++++---- .../Quantities/MassMomentOfInertia.NetFramework.g.cs | 8 ++++---- .../Quantities/MolarEnergy.NetFramework.g.cs | 8 ++++---- .../Quantities/MolarEntropy.NetFramework.g.cs | 8 ++++---- .../GeneratedCode/Quantities/MolarMass.NetFramework.g.cs | 8 ++++---- .../GeneratedCode/Quantities/Molarity.NetFramework.g.cs | 8 ++++---- .../Quantities/Permeability.NetFramework.g.cs | 8 ++++---- .../Quantities/Permittivity.NetFramework.g.cs | 8 ++++---- UnitsNet/GeneratedCode/Quantities/Power.NetFramework.g.cs | 8 ++++---- .../Quantities/PowerDensity.NetFramework.g.cs | 8 ++++---- .../GeneratedCode/Quantities/PowerRatio.NetFramework.g.cs | 4 ++-- .../GeneratedCode/Quantities/Pressure.NetFramework.g.cs | 8 ++++---- .../Quantities/PressureChangeRate.NetFramework.g.cs | 8 ++++---- UnitsNet/GeneratedCode/Quantities/Ratio.NetFramework.g.cs | 8 ++++---- .../Quantities/ReactiveEnergy.NetFramework.g.cs | 8 ++++---- .../Quantities/ReactivePower.NetFramework.g.cs | 8 ++++---- .../Quantities/RotationalAcceleration.NetFramework.g.cs | 8 ++++---- .../Quantities/RotationalSpeed.NetFramework.g.cs | 8 ++++---- .../Quantities/RotationalStiffness.NetFramework.g.cs | 8 ++++---- .../RotationalStiffnessPerLength.NetFramework.g.cs | 8 ++++---- .../GeneratedCode/Quantities/SolidAngle.NetFramework.g.cs | 8 ++++---- .../Quantities/SpecificEnergy.NetFramework.g.cs | 8 ++++---- .../Quantities/SpecificEntropy.NetFramework.g.cs | 8 ++++---- .../Quantities/SpecificVolume.NetFramework.g.cs | 8 ++++---- .../Quantities/SpecificWeight.NetFramework.g.cs | 8 ++++---- UnitsNet/GeneratedCode/Quantities/Speed.NetFramework.g.cs | 8 ++++---- .../Quantities/TemperatureChangeRate.NetFramework.g.cs | 8 ++++---- .../Quantities/TemperatureDelta.NetFramework.g.cs | 8 ++++---- .../Quantities/ThermalConductivity.NetFramework.g.cs | 8 ++++---- .../Quantities/ThermalResistance.NetFramework.g.cs | 8 ++++---- .../GeneratedCode/Quantities/Torque.NetFramework.g.cs | 8 ++++---- .../GeneratedCode/Quantities/VitaminA.NetFramework.g.cs | 8 ++++---- .../GeneratedCode/Quantities/Volume.NetFramework.g.cs | 8 ++++---- .../GeneratedCode/Quantities/VolumeFlow.NetFramework.g.cs | 8 ++++---- 89 files changed, 350 insertions(+), 350 deletions(-) diff --git a/UnitsNet/GeneratedCode/Quantities/Acceleration.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Acceleration.NetFramework.g.cs index 84ccd613a6..743c3fa0a7 100644 --- a/UnitsNet/GeneratedCode/Quantities/Acceleration.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Acceleration.NetFramework.g.cs @@ -524,12 +524,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Accele public static Acceleration operator +(Acceleration left, Acceleration right) { - return new Acceleration(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Acceleration operator -(Acceleration left, Acceleration right) { - return new Acceleration(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Acceleration operator *(double left, Acceleration right) @@ -576,12 +576,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Accele return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(Acceleration left, Acceleration right) + public static bool operator ==(Acceleration left, Acceleration right) { return left.Equals(right); } - public static bool operator !=(Acceleration left, Acceleration right) + public static bool operator !=(Acceleration left, Acceleration right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.NetFramework.g.cs index 0c444e8343..217b034585 100644 --- a/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.NetFramework.g.cs @@ -538,12 +538,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Amount public static AmountOfSubstance operator +(AmountOfSubstance left, AmountOfSubstance right) { - return new AmountOfSubstance(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static AmountOfSubstance operator -(AmountOfSubstance left, AmountOfSubstance right) { - return new AmountOfSubstance(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static AmountOfSubstance operator *(double left, AmountOfSubstance right) @@ -590,12 +590,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Amount return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(AmountOfSubstance left, AmountOfSubstance right) + public static bool operator ==(AmountOfSubstance left, AmountOfSubstance right) { return left.Equals(right); } - public static bool operator !=(AmountOfSubstance left, AmountOfSubstance right) + public static bool operator !=(AmountOfSubstance left, AmountOfSubstance right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.NetFramework.g.cs index 5c92424eee..33facbf90d 100644 --- a/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.NetFramework.g.cs @@ -458,12 +458,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Amplit return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(AmplitudeRatio left, AmplitudeRatio right) + public static bool operator ==(AmplitudeRatio left, AmplitudeRatio right) { return left.Equals(right); } - public static bool operator !=(AmplitudeRatio left, AmplitudeRatio right) + public static bool operator !=(AmplitudeRatio left, AmplitudeRatio right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/Angle.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Angle.NetFramework.g.cs index da67ba174f..e0ea28cfe9 100644 --- a/UnitsNet/GeneratedCode/Quantities/Angle.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Angle.NetFramework.g.cs @@ -538,12 +538,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out AngleU public static Angle operator +(Angle left, Angle right) { - return new Angle(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Angle operator -(Angle left, Angle right) { - return new Angle(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Angle operator *(double left, Angle right) @@ -590,12 +590,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out AngleU return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(Angle left, Angle right) + public static bool operator ==(Angle left, Angle right) { return left.Equals(right); } - public static bool operator !=(Angle left, Angle right) + public static bool operator !=(Angle left, Angle right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/ApparentEnergy.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ApparentEnergy.NetFramework.g.cs index d9ffd9f485..43e204e8ae 100644 --- a/UnitsNet/GeneratedCode/Quantities/ApparentEnergy.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ApparentEnergy.NetFramework.g.cs @@ -384,12 +384,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Appare public static ApparentEnergy operator +(ApparentEnergy left, ApparentEnergy right) { - return new ApparentEnergy(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ApparentEnergy operator -(ApparentEnergy left, ApparentEnergy right) { - return new ApparentEnergy(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ApparentEnergy operator *(double left, ApparentEnergy right) @@ -436,12 +436,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Appare return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(ApparentEnergy left, ApparentEnergy right) + public static bool operator ==(ApparentEnergy left, ApparentEnergy right) { return left.Equals(right); } - public static bool operator !=(ApparentEnergy left, ApparentEnergy right) + public static bool operator !=(ApparentEnergy left, ApparentEnergy right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/ApparentPower.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ApparentPower.NetFramework.g.cs index 339f0a85ed..e7700568e0 100644 --- a/UnitsNet/GeneratedCode/Quantities/ApparentPower.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ApparentPower.NetFramework.g.cs @@ -398,12 +398,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Appare public static ApparentPower operator +(ApparentPower left, ApparentPower right) { - return new ApparentPower(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ApparentPower operator -(ApparentPower left, ApparentPower right) { - return new ApparentPower(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ApparentPower operator *(double left, ApparentPower right) @@ -450,12 +450,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Appare return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(ApparentPower left, ApparentPower right) + public static bool operator ==(ApparentPower left, ApparentPower right) { return left.Equals(right); } - public static bool operator !=(ApparentPower left, ApparentPower right) + public static bool operator !=(ApparentPower left, ApparentPower right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/Area.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Area.NetFramework.g.cs index 834ca4aa2e..eeca3d4536 100644 --- a/UnitsNet/GeneratedCode/Quantities/Area.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Area.NetFramework.g.cs @@ -524,12 +524,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out AreaUn public static Area operator +(Area left, Area right) { - return new Area(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Area operator -(Area left, Area right) { - return new Area(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Area operator *(double left, Area right) @@ -576,12 +576,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out AreaUn return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(Area left, Area right) + public static bool operator ==(Area left, Area right) { return left.Equals(right); } - public static bool operator !=(Area left, Area right) + public static bool operator !=(Area left, Area right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/AreaDensity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/AreaDensity.NetFramework.g.cs index 4d2aa8e3c4..f152fb5f30 100644 --- a/UnitsNet/GeneratedCode/Quantities/AreaDensity.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/AreaDensity.NetFramework.g.cs @@ -356,12 +356,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out AreaDe public static AreaDensity operator +(AreaDensity left, AreaDensity right) { - return new AreaDensity(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static AreaDensity operator -(AreaDensity left, AreaDensity right) { - return new AreaDensity(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static AreaDensity operator *(double left, AreaDensity right) @@ -408,12 +408,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out AreaDe return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(AreaDensity left, AreaDensity right) + public static bool operator ==(AreaDensity left, AreaDensity right) { return left.Equals(right); } - public static bool operator !=(AreaDensity left, AreaDensity right) + public static bool operator !=(AreaDensity left, AreaDensity right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.NetFramework.g.cs index df5403d431..f2c95ac986 100644 --- a/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.NetFramework.g.cs @@ -426,12 +426,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out AreaMo public static AreaMomentOfInertia operator +(AreaMomentOfInertia left, AreaMomentOfInertia right) { - return new AreaMomentOfInertia(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static AreaMomentOfInertia operator -(AreaMomentOfInertia left, AreaMomentOfInertia right) { - return new AreaMomentOfInertia(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static AreaMomentOfInertia operator *(double left, AreaMomentOfInertia right) @@ -478,12 +478,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out AreaMo return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(AreaMomentOfInertia left, AreaMomentOfInertia right) + public static bool operator ==(AreaMomentOfInertia left, AreaMomentOfInertia right) { return left.Equals(right); } - public static bool operator !=(AreaMomentOfInertia left, AreaMomentOfInertia right) + public static bool operator !=(AreaMomentOfInertia left, AreaMomentOfInertia right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/BitRate.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/BitRate.NetFramework.g.cs index bc9a4ed598..3dcb3840fd 100644 --- a/UnitsNet/GeneratedCode/Quantities/BitRate.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/BitRate.NetFramework.g.cs @@ -709,12 +709,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out BitRat public static BitRate operator +(BitRate left, BitRate right) { - return new BitRate(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static BitRate operator -(BitRate left, BitRate right) { - return new BitRate(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static BitRate operator *(decimal left, BitRate right) @@ -761,12 +761,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out BitRat return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(BitRate left, BitRate right) + public static bool operator ==(BitRate left, BitRate right) { return left.Equals(right); } - public static bool operator !=(BitRate left, BitRate right) + public static bool operator !=(BitRate left, BitRate right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.NetFramework.g.cs index 24001bf446..a6501abe59 100644 --- a/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.NetFramework.g.cs @@ -384,12 +384,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out BrakeS public static BrakeSpecificFuelConsumption operator +(BrakeSpecificFuelConsumption left, BrakeSpecificFuelConsumption right) { - return new BrakeSpecificFuelConsumption(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static BrakeSpecificFuelConsumption operator -(BrakeSpecificFuelConsumption left, BrakeSpecificFuelConsumption right) { - return new BrakeSpecificFuelConsumption(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static BrakeSpecificFuelConsumption operator *(double left, BrakeSpecificFuelConsumption right) @@ -436,12 +436,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out BrakeS return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(BrakeSpecificFuelConsumption left, BrakeSpecificFuelConsumption right) + public static bool operator ==(BrakeSpecificFuelConsumption left, BrakeSpecificFuelConsumption right) { return left.Equals(right); } - public static bool operator !=(BrakeSpecificFuelConsumption left, BrakeSpecificFuelConsumption right) + public static bool operator !=(BrakeSpecificFuelConsumption left, BrakeSpecificFuelConsumption right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/Capacitance.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Capacitance.NetFramework.g.cs index fb834ff5cc..8df5c004a7 100644 --- a/UnitsNet/GeneratedCode/Quantities/Capacitance.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Capacitance.NetFramework.g.cs @@ -359,12 +359,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Capaci public static Capacitance operator +(Capacitance left, Capacitance right) { - return new Capacitance(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Capacitance operator -(Capacitance left, Capacitance right) { - return new Capacitance(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Capacitance operator *(double left, Capacitance right) @@ -411,12 +411,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Capaci return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(Capacitance left, Capacitance right) + public static bool operator ==(Capacitance left, Capacitance right) { return left.Equals(right); } - public static bool operator !=(Capacitance left, Capacitance right) + public static bool operator !=(Capacitance left, Capacitance right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.NetFramework.g.cs index f0f973ddc0..7ab2cec13b 100644 --- a/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.NetFramework.g.cs @@ -384,12 +384,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Coeffi public static CoefficientOfThermalExpansion operator +(CoefficientOfThermalExpansion left, CoefficientOfThermalExpansion right) { - return new CoefficientOfThermalExpansion(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static CoefficientOfThermalExpansion operator -(CoefficientOfThermalExpansion left, CoefficientOfThermalExpansion right) { - return new CoefficientOfThermalExpansion(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static CoefficientOfThermalExpansion operator *(double left, CoefficientOfThermalExpansion right) @@ -436,12 +436,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Coeffi return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(CoefficientOfThermalExpansion left, CoefficientOfThermalExpansion right) + public static bool operator ==(CoefficientOfThermalExpansion left, CoefficientOfThermalExpansion right) { return left.Equals(right); } - public static bool operator !=(CoefficientOfThermalExpansion left, CoefficientOfThermalExpansion right) + public static bool operator !=(CoefficientOfThermalExpansion left, CoefficientOfThermalExpansion right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/Density.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Density.NetFramework.g.cs index a1bc4cec77..7dd782634f 100644 --- a/UnitsNet/GeneratedCode/Quantities/Density.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Density.NetFramework.g.cs @@ -877,12 +877,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Densit public static Density operator +(Density left, Density right) { - return new Density(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Density operator -(Density left, Density right) { - return new Density(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Density operator *(double left, Density right) @@ -929,12 +929,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Densit return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(Density left, Density right) + public static bool operator ==(Density left, Density right) { return left.Equals(right); } - public static bool operator !=(Density left, Density right) + public static bool operator !=(Density left, Density right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/Duration.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Duration.NetFramework.g.cs index a492045fa3..8e5ac4024a 100644 --- a/UnitsNet/GeneratedCode/Quantities/Duration.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Duration.NetFramework.g.cs @@ -482,12 +482,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Durati public static Duration operator +(Duration left, Duration right) { - return new Duration(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Duration operator -(Duration left, Duration right) { - return new Duration(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Duration operator *(double left, Duration right) @@ -534,12 +534,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Durati return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(Duration left, Duration right) + public static bool operator ==(Duration left, Duration right) { return left.Equals(right); } - public static bool operator !=(Duration left, Duration right) + public static bool operator !=(Duration left, Duration right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.NetFramework.g.cs index c6f68cbcb4..4c824cc60d 100644 --- a/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.NetFramework.g.cs @@ -429,12 +429,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Dynami public static DynamicViscosity operator +(DynamicViscosity left, DynamicViscosity right) { - return new DynamicViscosity(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static DynamicViscosity operator -(DynamicViscosity left, DynamicViscosity right) { - return new DynamicViscosity(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static DynamicViscosity operator *(double left, DynamicViscosity right) @@ -481,12 +481,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Dynami return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(DynamicViscosity left, DynamicViscosity right) + public static bool operator ==(DynamicViscosity left, DynamicViscosity right) { return left.Equals(right); } - public static bool operator !=(DynamicViscosity left, DynamicViscosity right) + public static bool operator !=(DynamicViscosity left, DynamicViscosity right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.NetFramework.g.cs index 0aa8614684..24fd8e5412 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.NetFramework.g.cs @@ -398,12 +398,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr public static ElectricAdmittance operator +(ElectricAdmittance left, ElectricAdmittance right) { - return new ElectricAdmittance(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ElectricAdmittance operator -(ElectricAdmittance left, ElectricAdmittance right) { - return new ElectricAdmittance(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ElectricAdmittance operator *(double left, ElectricAdmittance right) @@ -450,12 +450,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(ElectricAdmittance left, ElectricAdmittance right) + public static bool operator ==(ElectricAdmittance left, ElectricAdmittance right) { return left.Equals(right); } - public static bool operator !=(ElectricAdmittance left, ElectricAdmittance right) + public static bool operator !=(ElectricAdmittance left, ElectricAdmittance right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCharge.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCharge.NetFramework.g.cs index ad8c89f4e9..62fef07ece 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricCharge.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricCharge.NetFramework.g.cs @@ -359,12 +359,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr public static ElectricCharge operator +(ElectricCharge left, ElectricCharge right) { - return new ElectricCharge(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ElectricCharge operator -(ElectricCharge left, ElectricCharge right) { - return new ElectricCharge(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ElectricCharge operator *(double left, ElectricCharge right) @@ -411,12 +411,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(ElectricCharge left, ElectricCharge right) + public static bool operator ==(ElectricCharge left, ElectricCharge right) { return left.Equals(right); } - public static bool operator !=(ElectricCharge left, ElectricCharge right) + public static bool operator !=(ElectricCharge left, ElectricCharge right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.NetFramework.g.cs index c7f07b4c82..4f3f96130b 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.NetFramework.g.cs @@ -359,12 +359,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr public static ElectricChargeDensity operator +(ElectricChargeDensity left, ElectricChargeDensity right) { - return new ElectricChargeDensity(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ElectricChargeDensity operator -(ElectricChargeDensity left, ElectricChargeDensity right) { - return new ElectricChargeDensity(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ElectricChargeDensity operator *(double left, ElectricChargeDensity right) @@ -411,12 +411,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(ElectricChargeDensity left, ElectricChargeDensity right) + public static bool operator ==(ElectricChargeDensity left, ElectricChargeDensity right) { return left.Equals(right); } - public static bool operator !=(ElectricChargeDensity left, ElectricChargeDensity right) + public static bool operator !=(ElectricChargeDensity left, ElectricChargeDensity right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricConductance.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricConductance.NetFramework.g.cs index 055e85ca6e..b70360c86b 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricConductance.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricConductance.NetFramework.g.cs @@ -387,12 +387,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr public static ElectricConductance operator +(ElectricConductance left, ElectricConductance right) { - return new ElectricConductance(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ElectricConductance operator -(ElectricConductance left, ElectricConductance right) { - return new ElectricConductance(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ElectricConductance operator *(double left, ElectricConductance right) @@ -439,12 +439,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(ElectricConductance left, ElectricConductance right) + public static bool operator ==(ElectricConductance left, ElectricConductance right) { return left.Equals(right); } - public static bool operator !=(ElectricConductance left, ElectricConductance right) + public static bool operator !=(ElectricConductance left, ElectricConductance right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.NetFramework.g.cs index 2bf2645bb3..ac92eafaa8 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.NetFramework.g.cs @@ -359,12 +359,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr public static ElectricConductivity operator +(ElectricConductivity left, ElectricConductivity right) { - return new ElectricConductivity(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ElectricConductivity operator -(ElectricConductivity left, ElectricConductivity right) { - return new ElectricConductivity(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ElectricConductivity operator *(double left, ElectricConductivity right) @@ -411,12 +411,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(ElectricConductivity left, ElectricConductivity right) + public static bool operator ==(ElectricConductivity left, ElectricConductivity right) { return left.Equals(right); } - public static bool operator !=(ElectricConductivity left, ElectricConductivity right) + public static bool operator !=(ElectricConductivity left, ElectricConductivity right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.NetFramework.g.cs index 297cf7cb67..b1903b9f73 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.NetFramework.g.cs @@ -454,12 +454,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr public static ElectricCurrent operator +(ElectricCurrent left, ElectricCurrent right) { - return new ElectricCurrent(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ElectricCurrent operator -(ElectricCurrent left, ElectricCurrent right) { - return new ElectricCurrent(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ElectricCurrent operator *(double left, ElectricCurrent right) @@ -506,12 +506,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(ElectricCurrent left, ElectricCurrent right) + public static bool operator ==(ElectricCurrent left, ElectricCurrent right) { return left.Equals(right); } - public static bool operator !=(ElectricCurrent left, ElectricCurrent right) + public static bool operator !=(ElectricCurrent left, ElectricCurrent right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.NetFramework.g.cs index 454421c96a..ba7de2dd15 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.NetFramework.g.cs @@ -359,12 +359,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr public static ElectricCurrentDensity operator +(ElectricCurrentDensity left, ElectricCurrentDensity right) { - return new ElectricCurrentDensity(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ElectricCurrentDensity operator -(ElectricCurrentDensity left, ElectricCurrentDensity right) { - return new ElectricCurrentDensity(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ElectricCurrentDensity operator *(double left, ElectricCurrentDensity right) @@ -411,12 +411,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(ElectricCurrentDensity left, ElectricCurrentDensity right) + public static bool operator ==(ElectricCurrentDensity left, ElectricCurrentDensity right) { return left.Equals(right); } - public static bool operator !=(ElectricCurrentDensity left, ElectricCurrentDensity right) + public static bool operator !=(ElectricCurrentDensity left, ElectricCurrentDensity right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.NetFramework.g.cs index 45c50ff74e..943b795f75 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.NetFramework.g.cs @@ -356,12 +356,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr public static ElectricCurrentGradient operator +(ElectricCurrentGradient left, ElectricCurrentGradient right) { - return new ElectricCurrentGradient(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ElectricCurrentGradient operator -(ElectricCurrentGradient left, ElectricCurrentGradient right) { - return new ElectricCurrentGradient(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ElectricCurrentGradient operator *(double left, ElectricCurrentGradient right) @@ -408,12 +408,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(ElectricCurrentGradient left, ElectricCurrentGradient right) + public static bool operator ==(ElectricCurrentGradient left, ElectricCurrentGradient right) { return left.Equals(right); } - public static bool operator !=(ElectricCurrentGradient left, ElectricCurrentGradient right) + public static bool operator !=(ElectricCurrentGradient left, ElectricCurrentGradient right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricField.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricField.NetFramework.g.cs index 92ad660991..686bc23983 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricField.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricField.NetFramework.g.cs @@ -359,12 +359,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr public static ElectricField operator +(ElectricField left, ElectricField right) { - return new ElectricField(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ElectricField operator -(ElectricField left, ElectricField right) { - return new ElectricField(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ElectricField operator *(double left, ElectricField right) @@ -411,12 +411,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(ElectricField left, ElectricField right) + public static bool operator ==(ElectricField left, ElectricField right) { return left.Equals(right); } - public static bool operator !=(ElectricField left, ElectricField right) + public static bool operator !=(ElectricField left, ElectricField right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricInductance.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricInductance.NetFramework.g.cs index f16d5ea0be..b94f325fe8 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricInductance.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricInductance.NetFramework.g.cs @@ -359,12 +359,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr public static ElectricInductance operator +(ElectricInductance left, ElectricInductance right) { - return new ElectricInductance(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ElectricInductance operator -(ElectricInductance left, ElectricInductance right) { - return new ElectricInductance(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ElectricInductance operator *(double left, ElectricInductance right) @@ -411,12 +411,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(ElectricInductance left, ElectricInductance right) + public static bool operator ==(ElectricInductance left, ElectricInductance right) { return left.Equals(right); } - public static bool operator !=(ElectricInductance left, ElectricInductance right) + public static bool operator !=(ElectricInductance left, ElectricInductance right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotential.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotential.NetFramework.g.cs index 94bb36db61..d9cac9a4b6 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricPotential.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricPotential.NetFramework.g.cs @@ -412,12 +412,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr public static ElectricPotential operator +(ElectricPotential left, ElectricPotential right) { - return new ElectricPotential(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ElectricPotential operator -(ElectricPotential left, ElectricPotential right) { - return new ElectricPotential(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ElectricPotential operator *(double left, ElectricPotential right) @@ -464,12 +464,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(ElectricPotential left, ElectricPotential right) + public static bool operator ==(ElectricPotential left, ElectricPotential right) { return left.Equals(right); } - public static bool operator !=(ElectricPotential left, ElectricPotential right) + public static bool operator !=(ElectricPotential left, ElectricPotential right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialAc.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialAc.NetFramework.g.cs index decd51b7f0..6f0f849f9b 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialAc.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialAc.NetFramework.g.cs @@ -412,12 +412,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr public static ElectricPotentialAc operator +(ElectricPotentialAc left, ElectricPotentialAc right) { - return new ElectricPotentialAc(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ElectricPotentialAc operator -(ElectricPotentialAc left, ElectricPotentialAc right) { - return new ElectricPotentialAc(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ElectricPotentialAc operator *(double left, ElectricPotentialAc right) @@ -464,12 +464,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(ElectricPotentialAc left, ElectricPotentialAc right) + public static bool operator ==(ElectricPotentialAc left, ElectricPotentialAc right) { return left.Equals(right); } - public static bool operator !=(ElectricPotentialAc left, ElectricPotentialAc right) + public static bool operator !=(ElectricPotentialAc left, ElectricPotentialAc right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialDc.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialDc.NetFramework.g.cs index 8e52d3a11f..df8cf351d8 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialDc.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialDc.NetFramework.g.cs @@ -412,12 +412,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr public static ElectricPotentialDc operator +(ElectricPotentialDc left, ElectricPotentialDc right) { - return new ElectricPotentialDc(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ElectricPotentialDc operator -(ElectricPotentialDc left, ElectricPotentialDc right) { - return new ElectricPotentialDc(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ElectricPotentialDc operator *(double left, ElectricPotentialDc right) @@ -464,12 +464,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(ElectricPotentialDc left, ElectricPotentialDc right) + public static bool operator ==(ElectricPotentialDc left, ElectricPotentialDc right) { return left.Equals(right); } - public static bool operator !=(ElectricPotentialDc left, ElectricPotentialDc right) + public static bool operator !=(ElectricPotentialDc left, ElectricPotentialDc right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricResistance.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricResistance.NetFramework.g.cs index 39977abb4c..e8e2be73d1 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricResistance.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricResistance.NetFramework.g.cs @@ -398,12 +398,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr public static ElectricResistance operator +(ElectricResistance left, ElectricResistance right) { - return new ElectricResistance(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ElectricResistance operator -(ElectricResistance left, ElectricResistance right) { - return new ElectricResistance(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ElectricResistance operator *(double left, ElectricResistance right) @@ -450,12 +450,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(ElectricResistance left, ElectricResistance right) + public static bool operator ==(ElectricResistance left, ElectricResistance right) { return left.Equals(right); } - public static bool operator !=(ElectricResistance left, ElectricResistance right) + public static bool operator !=(ElectricResistance left, ElectricResistance right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.NetFramework.g.cs index 9a5659af14..aeb3a69593 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.NetFramework.g.cs @@ -401,12 +401,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr public static ElectricResistivity operator +(ElectricResistivity left, ElectricResistivity right) { - return new ElectricResistivity(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ElectricResistivity operator -(ElectricResistivity left, ElectricResistivity right) { - return new ElectricResistivity(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ElectricResistivity operator *(double left, ElectricResistivity right) @@ -453,12 +453,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(ElectricResistivity left, ElectricResistivity right) + public static bool operator ==(ElectricResistivity left, ElectricResistivity right) { return left.Equals(right); } - public static bool operator !=(ElectricResistivity left, ElectricResistivity right) + public static bool operator !=(ElectricResistivity left, ElectricResistivity right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/Energy.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Energy.NetFramework.g.cs index 70dd0022b9..58589767b4 100644 --- a/UnitsNet/GeneratedCode/Quantities/Energy.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Energy.NetFramework.g.cs @@ -650,12 +650,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Energy public static Energy operator +(Energy left, Energy right) { - return new Energy(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Energy operator -(Energy left, Energy right) { - return new Energy(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Energy operator *(double left, Energy right) @@ -702,12 +702,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Energy return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(Energy left, Energy right) + public static bool operator ==(Energy left, Energy right) { return left.Equals(right); } - public static bool operator !=(Energy left, Energy right) + public static bool operator !=(Energy left, Energy right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/Entropy.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Entropy.NetFramework.g.cs index d70b0e10ea..fa7cc77afe 100644 --- a/UnitsNet/GeneratedCode/Quantities/Entropy.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Entropy.NetFramework.g.cs @@ -440,12 +440,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Entrop public static Entropy operator +(Entropy left, Entropy right) { - return new Entropy(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Entropy operator -(Entropy left, Entropy right) { - return new Entropy(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Entropy operator *(double left, Entropy right) @@ -492,12 +492,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Entrop return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(Entropy left, Entropy right) + public static bool operator ==(Entropy left, Entropy right) { return left.Equals(right); } - public static bool operator !=(Entropy left, Entropy right) + public static bool operator !=(Entropy left, Entropy right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/Force.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Force.NetFramework.g.cs index be24f8f69e..2f45ad80ae 100644 --- a/UnitsNet/GeneratedCode/Quantities/Force.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Force.NetFramework.g.cs @@ -524,12 +524,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out ForceU public static Force operator +(Force left, Force right) { - return new Force(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Force operator -(Force left, Force right) { - return new Force(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Force operator *(double left, Force right) @@ -576,12 +576,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out ForceU return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(Force left, Force right) + public static bool operator ==(Force left, Force right) { return left.Equals(right); } - public static bool operator !=(Force left, Force right) + public static bool operator !=(Force left, Force right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.NetFramework.g.cs index 0d6065acc8..1e608e48cc 100644 --- a/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.NetFramework.g.cs @@ -496,12 +496,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out ForceC public static ForceChangeRate operator +(ForceChangeRate left, ForceChangeRate right) { - return new ForceChangeRate(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ForceChangeRate operator -(ForceChangeRate left, ForceChangeRate right) { - return new ForceChangeRate(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ForceChangeRate operator *(double left, ForceChangeRate right) @@ -548,12 +548,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out ForceC return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(ForceChangeRate left, ForceChangeRate right) + public static bool operator ==(ForceChangeRate left, ForceChangeRate right) { return left.Equals(right); } - public static bool operator !=(ForceChangeRate left, ForceChangeRate right) + public static bool operator !=(ForceChangeRate left, ForceChangeRate right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/ForcePerLength.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ForcePerLength.NetFramework.g.cs index 1cf9184c55..34a8af516f 100644 --- a/UnitsNet/GeneratedCode/Quantities/ForcePerLength.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ForcePerLength.NetFramework.g.cs @@ -468,12 +468,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out ForceP public static ForcePerLength operator +(ForcePerLength left, ForcePerLength right) { - return new ForcePerLength(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ForcePerLength operator -(ForcePerLength left, ForcePerLength right) { - return new ForcePerLength(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ForcePerLength operator *(double left, ForcePerLength right) @@ -520,12 +520,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out ForceP return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(ForcePerLength left, ForcePerLength right) + public static bool operator ==(ForcePerLength left, ForcePerLength right) { return left.Equals(right); } - public static bool operator !=(ForcePerLength left, ForcePerLength right) + public static bool operator !=(ForcePerLength left, ForcePerLength right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/Frequency.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Frequency.NetFramework.g.cs index b3a24c9827..553ee96902 100644 --- a/UnitsNet/GeneratedCode/Quantities/Frequency.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Frequency.NetFramework.g.cs @@ -454,12 +454,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Freque public static Frequency operator +(Frequency left, Frequency right) { - return new Frequency(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Frequency operator -(Frequency left, Frequency right) { - return new Frequency(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Frequency operator *(double left, Frequency right) @@ -506,12 +506,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Freque return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(Frequency left, Frequency right) + public static bool operator ==(Frequency left, Frequency right) { return left.Equals(right); } - public static bool operator !=(Frequency left, Frequency right) + public static bool operator !=(Frequency left, Frequency right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/HeatFlux.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/HeatFlux.NetFramework.g.cs index 81a2941027..5542a7e590 100644 --- a/UnitsNet/GeneratedCode/Quantities/HeatFlux.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/HeatFlux.NetFramework.g.cs @@ -594,12 +594,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out HeatFl public static HeatFlux operator +(HeatFlux left, HeatFlux right) { - return new HeatFlux(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static HeatFlux operator -(HeatFlux left, HeatFlux right) { - return new HeatFlux(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static HeatFlux operator *(double left, HeatFlux right) @@ -646,12 +646,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out HeatFl return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(HeatFlux left, HeatFlux right) + public static bool operator ==(HeatFlux left, HeatFlux right) { return left.Equals(right); } - public static bool operator !=(HeatFlux left, HeatFlux right) + public static bool operator !=(HeatFlux left, HeatFlux right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.NetFramework.g.cs index c355fb90d4..bc4a2c3c8c 100644 --- a/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.NetFramework.g.cs @@ -370,12 +370,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out HeatTr public static HeatTransferCoefficient operator +(HeatTransferCoefficient left, HeatTransferCoefficient right) { - return new HeatTransferCoefficient(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static HeatTransferCoefficient operator -(HeatTransferCoefficient left, HeatTransferCoefficient right) { - return new HeatTransferCoefficient(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static HeatTransferCoefficient operator *(double left, HeatTransferCoefficient right) @@ -422,12 +422,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out HeatTr return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(HeatTransferCoefficient left, HeatTransferCoefficient right) + public static bool operator ==(HeatTransferCoefficient left, HeatTransferCoefficient right) { return left.Equals(right); } - public static bool operator !=(HeatTransferCoefficient left, HeatTransferCoefficient right) + public static bool operator !=(HeatTransferCoefficient left, HeatTransferCoefficient right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/Illuminance.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Illuminance.NetFramework.g.cs index c5da84031f..2129367161 100644 --- a/UnitsNet/GeneratedCode/Quantities/Illuminance.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Illuminance.NetFramework.g.cs @@ -401,12 +401,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Illumi public static Illuminance operator +(Illuminance left, Illuminance right) { - return new Illuminance(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Illuminance operator -(Illuminance left, Illuminance right) { - return new Illuminance(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Illuminance operator *(double left, Illuminance right) @@ -453,12 +453,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Illumi return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(Illuminance left, Illuminance right) + public static bool operator ==(Illuminance left, Illuminance right) { return left.Equals(right); } - public static bool operator !=(Illuminance left, Illuminance right) + public static bool operator !=(Illuminance left, Illuminance right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/Information.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Information.NetFramework.g.cs index d713e80770..0cab76a145 100644 --- a/UnitsNet/GeneratedCode/Quantities/Information.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Information.NetFramework.g.cs @@ -706,12 +706,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Inform public static Information operator +(Information left, Information right) { - return new Information(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Information operator -(Information left, Information right) { - return new Information(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Information operator *(decimal left, Information right) @@ -758,12 +758,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Inform return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(Information left, Information right) + public static bool operator ==(Information left, Information right) { return left.Equals(right); } - public static bool operator !=(Information left, Information right) + public static bool operator !=(Information left, Information right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/Irradiance.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Irradiance.NetFramework.g.cs index 8a216b2374..78e3505c71 100644 --- a/UnitsNet/GeneratedCode/Quantities/Irradiance.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Irradiance.NetFramework.g.cs @@ -370,12 +370,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Irradi public static Irradiance operator +(Irradiance left, Irradiance right) { - return new Irradiance(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Irradiance operator -(Irradiance left, Irradiance right) { - return new Irradiance(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Irradiance operator *(double left, Irradiance right) @@ -422,12 +422,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Irradi return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(Irradiance left, Irradiance right) + public static bool operator ==(Irradiance left, Irradiance right) { return left.Equals(right); } - public static bool operator !=(Irradiance left, Irradiance right) + public static bool operator !=(Irradiance left, Irradiance right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/Irradiation.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Irradiation.NetFramework.g.cs index 9661a629eb..f37bc45a2d 100644 --- a/UnitsNet/GeneratedCode/Quantities/Irradiation.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Irradiation.NetFramework.g.cs @@ -387,12 +387,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Irradi public static Irradiation operator +(Irradiation left, Irradiation right) { - return new Irradiation(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Irradiation operator -(Irradiation left, Irradiation right) { - return new Irradiation(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Irradiation operator *(double left, Irradiation right) @@ -439,12 +439,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Irradi return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(Irradiation left, Irradiation right) + public static bool operator ==(Irradiation left, Irradiation right) { return left.Equals(right); } - public static bool operator !=(Irradiation left, Irradiation right) + public static bool operator !=(Irradiation left, Irradiation right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.NetFramework.g.cs index 7f291dac8a..19e00e906b 100644 --- a/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.NetFramework.g.cs @@ -457,12 +457,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Kinema public static KinematicViscosity operator +(KinematicViscosity left, KinematicViscosity right) { - return new KinematicViscosity(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static KinematicViscosity operator -(KinematicViscosity left, KinematicViscosity right) { - return new KinematicViscosity(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static KinematicViscosity operator *(double left, KinematicViscosity right) @@ -509,12 +509,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Kinema return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(KinematicViscosity left, KinematicViscosity right) + public static bool operator ==(KinematicViscosity left, KinematicViscosity right) { return left.Equals(right); } - public static bool operator !=(KinematicViscosity left, KinematicViscosity right) + public static bool operator !=(KinematicViscosity left, KinematicViscosity right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/LapseRate.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/LapseRate.NetFramework.g.cs index be4066d7f3..d4c9e15adf 100644 --- a/UnitsNet/GeneratedCode/Quantities/LapseRate.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/LapseRate.NetFramework.g.cs @@ -356,12 +356,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out LapseR public static LapseRate operator +(LapseRate left, LapseRate right) { - return new LapseRate(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static LapseRate operator -(LapseRate left, LapseRate right) { - return new LapseRate(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static LapseRate operator *(double left, LapseRate right) @@ -408,12 +408,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out LapseR return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(LapseRate left, LapseRate right) + public static bool operator ==(LapseRate left, LapseRate right) { return left.Equals(right); } - public static bool operator !=(LapseRate left, LapseRate right) + public static bool operator !=(LapseRate left, LapseRate right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/Length.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Length.NetFramework.g.cs index e03e322247..5caecadeef 100644 --- a/UnitsNet/GeneratedCode/Quantities/Length.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Length.NetFramework.g.cs @@ -650,12 +650,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Length public static Length operator +(Length left, Length right) { - return new Length(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Length operator -(Length left, Length right) { - return new Length(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Length operator *(double left, Length right) @@ -702,12 +702,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Length return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(Length left, Length right) + public static bool operator ==(Length left, Length right) { return left.Equals(right); } - public static bool operator !=(Length left, Length right) + public static bool operator !=(Length left, Length right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/Level.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Level.NetFramework.g.cs index e35db5d5c1..1f2e935c04 100644 --- a/UnitsNet/GeneratedCode/Quantities/Level.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Level.NetFramework.g.cs @@ -430,12 +430,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out LevelU return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(Level left, Level right) + public static bool operator ==(Level left, Level right) { return left.Equals(right); } - public static bool operator !=(Level left, Level right) + public static bool operator !=(Level left, Level right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/LinearDensity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/LinearDensity.NetFramework.g.cs index cbf5870f3b..ca56e47507 100644 --- a/UnitsNet/GeneratedCode/Quantities/LinearDensity.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/LinearDensity.NetFramework.g.cs @@ -387,12 +387,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Linear public static LinearDensity operator +(LinearDensity left, LinearDensity right) { - return new LinearDensity(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static LinearDensity operator -(LinearDensity left, LinearDensity right) { - return new LinearDensity(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static LinearDensity operator *(double left, LinearDensity right) @@ -439,12 +439,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Linear return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(LinearDensity left, LinearDensity right) + public static bool operator ==(LinearDensity left, LinearDensity right) { return left.Equals(right); } - public static bool operator !=(LinearDensity left, LinearDensity right) + public static bool operator !=(LinearDensity left, LinearDensity right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/LuminousFlux.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/LuminousFlux.NetFramework.g.cs index a7ee796bb5..66be11b123 100644 --- a/UnitsNet/GeneratedCode/Quantities/LuminousFlux.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/LuminousFlux.NetFramework.g.cs @@ -359,12 +359,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Lumino public static LuminousFlux operator +(LuminousFlux left, LuminousFlux right) { - return new LuminousFlux(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static LuminousFlux operator -(LuminousFlux left, LuminousFlux right) { - return new LuminousFlux(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static LuminousFlux operator *(double left, LuminousFlux right) @@ -411,12 +411,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Lumino return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(LuminousFlux left, LuminousFlux right) + public static bool operator ==(LuminousFlux left, LuminousFlux right) { return left.Equals(right); } - public static bool operator !=(LuminousFlux left, LuminousFlux right) + public static bool operator !=(LuminousFlux left, LuminousFlux right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.NetFramework.g.cs index ebfd3b327e..a19be23912 100644 --- a/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.NetFramework.g.cs @@ -359,12 +359,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Lumino public static LuminousIntensity operator +(LuminousIntensity left, LuminousIntensity right) { - return new LuminousIntensity(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static LuminousIntensity operator -(LuminousIntensity left, LuminousIntensity right) { - return new LuminousIntensity(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static LuminousIntensity operator *(double left, LuminousIntensity right) @@ -411,12 +411,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Lumino return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(LuminousIntensity left, LuminousIntensity right) + public static bool operator ==(LuminousIntensity left, LuminousIntensity right) { return left.Equals(right); } - public static bool operator !=(LuminousIntensity left, LuminousIntensity right) + public static bool operator !=(LuminousIntensity left, LuminousIntensity right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/MagneticField.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/MagneticField.NetFramework.g.cs index 53efad53e9..0102eea325 100644 --- a/UnitsNet/GeneratedCode/Quantities/MagneticField.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MagneticField.NetFramework.g.cs @@ -359,12 +359,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Magnet public static MagneticField operator +(MagneticField left, MagneticField right) { - return new MagneticField(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static MagneticField operator -(MagneticField left, MagneticField right) { - return new MagneticField(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static MagneticField operator *(double left, MagneticField right) @@ -411,12 +411,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Magnet return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(MagneticField left, MagneticField right) + public static bool operator ==(MagneticField left, MagneticField right) { return left.Equals(right); } - public static bool operator !=(MagneticField left, MagneticField right) + public static bool operator !=(MagneticField left, MagneticField right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/MagneticFlux.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/MagneticFlux.NetFramework.g.cs index 6758122032..2af012cd21 100644 --- a/UnitsNet/GeneratedCode/Quantities/MagneticFlux.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MagneticFlux.NetFramework.g.cs @@ -359,12 +359,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Magnet public static MagneticFlux operator +(MagneticFlux left, MagneticFlux right) { - return new MagneticFlux(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static MagneticFlux operator -(MagneticFlux left, MagneticFlux right) { - return new MagneticFlux(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static MagneticFlux operator *(double left, MagneticFlux right) @@ -411,12 +411,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Magnet return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(MagneticFlux left, MagneticFlux right) + public static bool operator ==(MagneticFlux left, MagneticFlux right) { return left.Equals(right); } - public static bool operator !=(MagneticFlux left, MagneticFlux right) + public static bool operator !=(MagneticFlux left, MagneticFlux right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/Magnetization.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Magnetization.NetFramework.g.cs index fb03bce307..c282623d74 100644 --- a/UnitsNet/GeneratedCode/Quantities/Magnetization.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Magnetization.NetFramework.g.cs @@ -359,12 +359,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Magnet public static Magnetization operator +(Magnetization left, Magnetization right) { - return new Magnetization(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Magnetization operator -(Magnetization left, Magnetization right) { - return new Magnetization(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Magnetization operator *(double left, Magnetization right) @@ -411,12 +411,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Magnet return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(Magnetization left, Magnetization right) + public static bool operator ==(Magnetization left, Magnetization right) { return left.Equals(right); } - public static bool operator !=(Magnetization left, Magnetization right) + public static bool operator !=(Magnetization left, Magnetization right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/Mass.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Mass.NetFramework.g.cs index f68c7a731b..627c38f2cd 100644 --- a/UnitsNet/GeneratedCode/Quantities/Mass.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Mass.NetFramework.g.cs @@ -650,12 +650,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out MassUn public static Mass operator +(Mass left, Mass right) { - return new Mass(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Mass operator -(Mass left, Mass right) { - return new Mass(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Mass operator *(double left, Mass right) @@ -702,12 +702,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out MassUn return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(Mass left, Mass right) + public static bool operator ==(Mass left, Mass right) { return left.Equals(right); } - public static bool operator !=(Mass left, Mass right) + public static bool operator !=(Mass left, Mass right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/MassFlow.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/MassFlow.NetFramework.g.cs index 1b21e02463..3fff0df321 100644 --- a/UnitsNet/GeneratedCode/Quantities/MassFlow.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MassFlow.NetFramework.g.cs @@ -580,12 +580,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out MassFl public static MassFlow operator +(MassFlow left, MassFlow right) { - return new MassFlow(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static MassFlow operator -(MassFlow left, MassFlow right) { - return new MassFlow(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static MassFlow operator *(double left, MassFlow right) @@ -632,12 +632,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out MassFl return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(MassFlow left, MassFlow right) + public static bool operator ==(MassFlow left, MassFlow right) { return left.Equals(right); } - public static bool operator !=(MassFlow left, MassFlow right) + public static bool operator !=(MassFlow left, MassFlow right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/MassFlux.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/MassFlux.NetFramework.g.cs index 6e77cad9f0..17cbe03e78 100644 --- a/UnitsNet/GeneratedCode/Quantities/MassFlux.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MassFlux.NetFramework.g.cs @@ -370,12 +370,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out MassFl public static MassFlux operator +(MassFlux left, MassFlux right) { - return new MassFlux(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static MassFlux operator -(MassFlux left, MassFlux right) { - return new MassFlux(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static MassFlux operator *(double left, MassFlux right) @@ -422,12 +422,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out MassFl return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(MassFlux left, MassFlux right) + public static bool operator ==(MassFlux left, MassFlux right) { return left.Equals(right); } - public static bool operator !=(MassFlux left, MassFlux right) + public static bool operator !=(MassFlux left, MassFlux right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.NetFramework.g.cs index 8a99f8e914..3c652a393c 100644 --- a/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.NetFramework.g.cs @@ -734,12 +734,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out MassMo public static MassMomentOfInertia operator +(MassMomentOfInertia left, MassMomentOfInertia right) { - return new MassMomentOfInertia(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static MassMomentOfInertia operator -(MassMomentOfInertia left, MassMomentOfInertia right) { - return new MassMomentOfInertia(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static MassMomentOfInertia operator *(double left, MassMomentOfInertia right) @@ -786,12 +786,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out MassMo return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(MassMomentOfInertia left, MassMomentOfInertia right) + public static bool operator ==(MassMomentOfInertia left, MassMomentOfInertia right) { return left.Equals(right); } - public static bool operator !=(MassMomentOfInertia left, MassMomentOfInertia right) + public static bool operator !=(MassMomentOfInertia left, MassMomentOfInertia right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/MolarEnergy.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarEnergy.NetFramework.g.cs index a1e0c9befd..26b749d0a0 100644 --- a/UnitsNet/GeneratedCode/Quantities/MolarEnergy.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MolarEnergy.NetFramework.g.cs @@ -384,12 +384,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out MolarE public static MolarEnergy operator +(MolarEnergy left, MolarEnergy right) { - return new MolarEnergy(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static MolarEnergy operator -(MolarEnergy left, MolarEnergy right) { - return new MolarEnergy(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static MolarEnergy operator *(double left, MolarEnergy right) @@ -436,12 +436,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out MolarE return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(MolarEnergy left, MolarEnergy right) + public static bool operator ==(MolarEnergy left, MolarEnergy right) { return left.Equals(right); } - public static bool operator !=(MolarEnergy left, MolarEnergy right) + public static bool operator !=(MolarEnergy left, MolarEnergy right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/MolarEntropy.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarEntropy.NetFramework.g.cs index 807f2ef8b4..581ee0391f 100644 --- a/UnitsNet/GeneratedCode/Quantities/MolarEntropy.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MolarEntropy.NetFramework.g.cs @@ -384,12 +384,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out MolarE public static MolarEntropy operator +(MolarEntropy left, MolarEntropy right) { - return new MolarEntropy(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static MolarEntropy operator -(MolarEntropy left, MolarEntropy right) { - return new MolarEntropy(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static MolarEntropy operator *(double left, MolarEntropy right) @@ -436,12 +436,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out MolarE return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(MolarEntropy left, MolarEntropy right) + public static bool operator ==(MolarEntropy left, MolarEntropy right) { return left.Equals(right); } - public static bool operator !=(MolarEntropy left, MolarEntropy right) + public static bool operator !=(MolarEntropy left, MolarEntropy right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/MolarMass.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarMass.NetFramework.g.cs index a9ac972482..4082747948 100644 --- a/UnitsNet/GeneratedCode/Quantities/MolarMass.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MolarMass.NetFramework.g.cs @@ -510,12 +510,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out MolarM public static MolarMass operator +(MolarMass left, MolarMass right) { - return new MolarMass(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static MolarMass operator -(MolarMass left, MolarMass right) { - return new MolarMass(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static MolarMass operator *(double left, MolarMass right) @@ -562,12 +562,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out MolarM return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(MolarMass left, MolarMass right) + public static bool operator ==(MolarMass left, MolarMass right) { return left.Equals(right); } - public static bool operator !=(MolarMass left, MolarMass right) + public static bool operator !=(MolarMass left, MolarMass right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/Molarity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Molarity.NetFramework.g.cs index c3bb500b58..abbd08ac12 100644 --- a/UnitsNet/GeneratedCode/Quantities/Molarity.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Molarity.NetFramework.g.cs @@ -457,12 +457,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Molari public static Molarity operator +(Molarity left, Molarity right) { - return new Molarity(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Molarity operator -(Molarity left, Molarity right) { - return new Molarity(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Molarity operator *(double left, Molarity right) @@ -509,12 +509,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Molari return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(Molarity left, Molarity right) + public static bool operator ==(Molarity left, Molarity right) { return left.Equals(right); } - public static bool operator !=(Molarity left, Molarity right) + public static bool operator !=(Molarity left, Molarity right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/Permeability.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Permeability.NetFramework.g.cs index c837854442..1cd1543505 100644 --- a/UnitsNet/GeneratedCode/Quantities/Permeability.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Permeability.NetFramework.g.cs @@ -359,12 +359,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Permea public static Permeability operator +(Permeability left, Permeability right) { - return new Permeability(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Permeability operator -(Permeability left, Permeability right) { - return new Permeability(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Permeability operator *(double left, Permeability right) @@ -411,12 +411,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Permea return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(Permeability left, Permeability right) + public static bool operator ==(Permeability left, Permeability right) { return left.Equals(right); } - public static bool operator !=(Permeability left, Permeability right) + public static bool operator !=(Permeability left, Permeability right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/Permittivity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Permittivity.NetFramework.g.cs index 0135c92d4c..fed0439d49 100644 --- a/UnitsNet/GeneratedCode/Quantities/Permittivity.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Permittivity.NetFramework.g.cs @@ -359,12 +359,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Permit public static Permittivity operator +(Permittivity left, Permittivity right) { - return new Permittivity(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Permittivity operator -(Permittivity left, Permittivity right) { - return new Permittivity(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Permittivity operator *(double left, Permittivity right) @@ -411,12 +411,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Permit return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(Permittivity left, Permittivity right) + public static bool operator ==(Permittivity left, Permittivity right) { return left.Equals(right); } - public static bool operator !=(Permittivity left, Permittivity right) + public static bool operator !=(Permittivity left, Permittivity right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/Power.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Power.NetFramework.g.cs index 5af1aba2d9..48002742aa 100644 --- a/UnitsNet/GeneratedCode/Quantities/Power.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Power.NetFramework.g.cs @@ -622,12 +622,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out PowerU public static Power operator +(Power left, Power right) { - return new Power(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Power operator -(Power left, Power right) { - return new Power(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Power operator *(decimal left, Power right) @@ -674,12 +674,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out PowerU return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(Power left, Power right) + public static bool operator ==(Power left, Power right) { return left.Equals(right); } - public static bool operator !=(Power left, Power right) + public static bool operator !=(Power left, Power right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/PowerDensity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/PowerDensity.NetFramework.g.cs index 0561b93c66..29cb88acb7 100644 --- a/UnitsNet/GeneratedCode/Quantities/PowerDensity.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/PowerDensity.NetFramework.g.cs @@ -958,12 +958,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out PowerD public static PowerDensity operator +(PowerDensity left, PowerDensity right) { - return new PowerDensity(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static PowerDensity operator -(PowerDensity left, PowerDensity right) { - return new PowerDensity(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static PowerDensity operator *(double left, PowerDensity right) @@ -1010,12 +1010,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out PowerD return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(PowerDensity left, PowerDensity right) + public static bool operator ==(PowerDensity left, PowerDensity right) { return left.Equals(right); } - public static bool operator !=(PowerDensity left, PowerDensity right) + public static bool operator !=(PowerDensity left, PowerDensity right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/PowerRatio.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/PowerRatio.NetFramework.g.cs index 3173544500..8a7e6c615e 100644 --- a/UnitsNet/GeneratedCode/Quantities/PowerRatio.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/PowerRatio.NetFramework.g.cs @@ -430,12 +430,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out PowerR return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(PowerRatio left, PowerRatio right) + public static bool operator ==(PowerRatio left, PowerRatio right) { return left.Equals(right); } - public static bool operator !=(PowerRatio left, PowerRatio right) + public static bool operator !=(PowerRatio left, PowerRatio right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/Pressure.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Pressure.NetFramework.g.cs index 3071a864d3..e48a76741e 100644 --- a/UnitsNet/GeneratedCode/Quantities/Pressure.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Pressure.NetFramework.g.cs @@ -902,12 +902,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Pressu public static Pressure operator +(Pressure left, Pressure right) { - return new Pressure(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Pressure operator -(Pressure left, Pressure right) { - return new Pressure(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Pressure operator *(double left, Pressure right) @@ -954,12 +954,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Pressu return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(Pressure left, Pressure right) + public static bool operator ==(Pressure left, Pressure right) { return left.Equals(right); } - public static bool operator !=(Pressure left, Pressure right) + public static bool operator !=(Pressure left, Pressure right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.NetFramework.g.cs index eebe52221b..fb0b2e93ce 100644 --- a/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.NetFramework.g.cs @@ -398,12 +398,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Pressu public static PressureChangeRate operator +(PressureChangeRate left, PressureChangeRate right) { - return new PressureChangeRate(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static PressureChangeRate operator -(PressureChangeRate left, PressureChangeRate right) { - return new PressureChangeRate(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static PressureChangeRate operator *(double left, PressureChangeRate right) @@ -450,12 +450,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Pressu return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(PressureChangeRate left, PressureChangeRate right) + public static bool operator ==(PressureChangeRate left, PressureChangeRate right) { return left.Equals(right); } - public static bool operator !=(PressureChangeRate left, PressureChangeRate right) + public static bool operator !=(PressureChangeRate left, PressureChangeRate right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/Ratio.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Ratio.NetFramework.g.cs index 3162555801..f3a15fdbb8 100644 --- a/UnitsNet/GeneratedCode/Quantities/Ratio.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Ratio.NetFramework.g.cs @@ -426,12 +426,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out RatioU public static Ratio operator +(Ratio left, Ratio right) { - return new Ratio(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Ratio operator -(Ratio left, Ratio right) { - return new Ratio(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Ratio operator *(double left, Ratio right) @@ -478,12 +478,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out RatioU return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(Ratio left, Ratio right) + public static bool operator ==(Ratio left, Ratio right) { return left.Equals(right); } - public static bool operator !=(Ratio left, Ratio right) + public static bool operator !=(Ratio left, Ratio right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/ReactiveEnergy.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ReactiveEnergy.NetFramework.g.cs index 11a5edac93..979467bb0b 100644 --- a/UnitsNet/GeneratedCode/Quantities/ReactiveEnergy.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ReactiveEnergy.NetFramework.g.cs @@ -384,12 +384,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Reacti public static ReactiveEnergy operator +(ReactiveEnergy left, ReactiveEnergy right) { - return new ReactiveEnergy(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ReactiveEnergy operator -(ReactiveEnergy left, ReactiveEnergy right) { - return new ReactiveEnergy(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ReactiveEnergy operator *(double left, ReactiveEnergy right) @@ -436,12 +436,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Reacti return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(ReactiveEnergy left, ReactiveEnergy right) + public static bool operator ==(ReactiveEnergy left, ReactiveEnergy right) { return left.Equals(right); } - public static bool operator !=(ReactiveEnergy left, ReactiveEnergy right) + public static bool operator !=(ReactiveEnergy left, ReactiveEnergy right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/ReactivePower.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ReactivePower.NetFramework.g.cs index aa09b88dd1..e4da4d8352 100644 --- a/UnitsNet/GeneratedCode/Quantities/ReactivePower.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ReactivePower.NetFramework.g.cs @@ -398,12 +398,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Reacti public static ReactivePower operator +(ReactivePower left, ReactivePower right) { - return new ReactivePower(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ReactivePower operator -(ReactivePower left, ReactivePower right) { - return new ReactivePower(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ReactivePower operator *(double left, ReactivePower right) @@ -450,12 +450,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Reacti return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(ReactivePower left, ReactivePower right) + public static bool operator ==(ReactivePower left, ReactivePower right) { return left.Equals(right); } - public static bool operator !=(ReactivePower left, ReactivePower right) + public static bool operator !=(ReactivePower left, ReactivePower right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.NetFramework.g.cs index 687e2d4e0e..2d31f120dc 100644 --- a/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.NetFramework.g.cs @@ -384,12 +384,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Rotati public static RotationalAcceleration operator +(RotationalAcceleration left, RotationalAcceleration right) { - return new RotationalAcceleration(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static RotationalAcceleration operator -(RotationalAcceleration left, RotationalAcceleration right) { - return new RotationalAcceleration(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static RotationalAcceleration operator *(double left, RotationalAcceleration right) @@ -436,12 +436,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Rotati return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(RotationalAcceleration left, RotationalAcceleration right) + public static bool operator ==(RotationalAcceleration left, RotationalAcceleration right) { return left.Equals(right); } - public static bool operator !=(RotationalAcceleration left, RotationalAcceleration right) + public static bool operator !=(RotationalAcceleration left, RotationalAcceleration right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.NetFramework.g.cs index 9757bcca37..fc2cbf973a 100644 --- a/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.NetFramework.g.cs @@ -524,12 +524,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Rotati public static RotationalSpeed operator +(RotationalSpeed left, RotationalSpeed right) { - return new RotationalSpeed(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static RotationalSpeed operator -(RotationalSpeed left, RotationalSpeed right) { - return new RotationalSpeed(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static RotationalSpeed operator *(double left, RotationalSpeed right) @@ -576,12 +576,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Rotati return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(RotationalSpeed left, RotationalSpeed right) + public static bool operator ==(RotationalSpeed left, RotationalSpeed right) { return left.Equals(right); } - public static bool operator !=(RotationalSpeed left, RotationalSpeed right) + public static bool operator !=(RotationalSpeed left, RotationalSpeed right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.NetFramework.g.cs index 083edb31ff..b6bea41eaf 100644 --- a/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.NetFramework.g.cs @@ -384,12 +384,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Rotati public static RotationalStiffness operator +(RotationalStiffness left, RotationalStiffness right) { - return new RotationalStiffness(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static RotationalStiffness operator -(RotationalStiffness left, RotationalStiffness right) { - return new RotationalStiffness(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static RotationalStiffness operator *(double left, RotationalStiffness right) @@ -436,12 +436,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Rotati return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(RotationalStiffness left, RotationalStiffness right) + public static bool operator ==(RotationalStiffness left, RotationalStiffness right) { return left.Equals(right); } - public static bool operator !=(RotationalStiffness left, RotationalStiffness right) + public static bool operator !=(RotationalStiffness left, RotationalStiffness right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.NetFramework.g.cs index 7c0d807bcc..828161a5a8 100644 --- a/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.NetFramework.g.cs @@ -384,12 +384,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Rotati public static RotationalStiffnessPerLength operator +(RotationalStiffnessPerLength left, RotationalStiffnessPerLength right) { - return new RotationalStiffnessPerLength(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static RotationalStiffnessPerLength operator -(RotationalStiffnessPerLength left, RotationalStiffnessPerLength right) { - return new RotationalStiffnessPerLength(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static RotationalStiffnessPerLength operator *(double left, RotationalStiffnessPerLength right) @@ -436,12 +436,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Rotati return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(RotationalStiffnessPerLength left, RotationalStiffnessPerLength right) + public static bool operator ==(RotationalStiffnessPerLength left, RotationalStiffnessPerLength right) { return left.Equals(right); } - public static bool operator !=(RotationalStiffnessPerLength left, RotationalStiffnessPerLength right) + public static bool operator !=(RotationalStiffnessPerLength left, RotationalStiffnessPerLength right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/SolidAngle.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/SolidAngle.NetFramework.g.cs index d8f03d8b08..a4d486729a 100644 --- a/UnitsNet/GeneratedCode/Quantities/SolidAngle.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/SolidAngle.NetFramework.g.cs @@ -359,12 +359,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out SolidA public static SolidAngle operator +(SolidAngle left, SolidAngle right) { - return new SolidAngle(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static SolidAngle operator -(SolidAngle left, SolidAngle right) { - return new SolidAngle(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static SolidAngle operator *(double left, SolidAngle right) @@ -411,12 +411,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out SolidA return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(SolidAngle left, SolidAngle right) + public static bool operator ==(SolidAngle left, SolidAngle right) { return left.Equals(right); } - public static bool operator !=(SolidAngle left, SolidAngle right) + public static bool operator !=(SolidAngle left, SolidAngle right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.NetFramework.g.cs index d72c3d329b..d70e9bcc54 100644 --- a/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.NetFramework.g.cs @@ -457,12 +457,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Specif public static SpecificEnergy operator +(SpecificEnergy left, SpecificEnergy right) { - return new SpecificEnergy(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static SpecificEnergy operator -(SpecificEnergy left, SpecificEnergy right) { - return new SpecificEnergy(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static SpecificEnergy operator *(double left, SpecificEnergy right) @@ -509,12 +509,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Specif return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(SpecificEnergy left, SpecificEnergy right) + public static bool operator ==(SpecificEnergy left, SpecificEnergy right) { return left.Equals(right); } - public static bool operator !=(SpecificEnergy left, SpecificEnergy right) + public static bool operator !=(SpecificEnergy left, SpecificEnergy right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.NetFramework.g.cs index b91712cb2e..164f6797bf 100644 --- a/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.NetFramework.g.cs @@ -454,12 +454,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Specif public static SpecificEntropy operator +(SpecificEntropy left, SpecificEntropy right) { - return new SpecificEntropy(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static SpecificEntropy operator -(SpecificEntropy left, SpecificEntropy right) { - return new SpecificEntropy(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static SpecificEntropy operator *(double left, SpecificEntropy right) @@ -506,12 +506,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Specif return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(SpecificEntropy left, SpecificEntropy right) + public static bool operator ==(SpecificEntropy left, SpecificEntropy right) { return left.Equals(right); } - public static bool operator !=(SpecificEntropy left, SpecificEntropy right) + public static bool operator !=(SpecificEntropy left, SpecificEntropy right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificVolume.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificVolume.NetFramework.g.cs index 04e161eb6a..23b6fe03af 100644 --- a/UnitsNet/GeneratedCode/Quantities/SpecificVolume.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/SpecificVolume.NetFramework.g.cs @@ -370,12 +370,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Specif public static SpecificVolume operator +(SpecificVolume left, SpecificVolume right) { - return new SpecificVolume(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static SpecificVolume operator -(SpecificVolume left, SpecificVolume right) { - return new SpecificVolume(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static SpecificVolume operator *(double left, SpecificVolume right) @@ -422,12 +422,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Specif return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(SpecificVolume left, SpecificVolume right) + public static bool operator ==(SpecificVolume left, SpecificVolume right) { return left.Equals(right); } - public static bool operator !=(SpecificVolume left, SpecificVolume right) + public static bool operator !=(SpecificVolume left, SpecificVolume right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificWeight.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificWeight.NetFramework.g.cs index ce31c9bb27..90bf610912 100644 --- a/UnitsNet/GeneratedCode/Quantities/SpecificWeight.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/SpecificWeight.NetFramework.g.cs @@ -583,12 +583,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Specif public static SpecificWeight operator +(SpecificWeight left, SpecificWeight right) { - return new SpecificWeight(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static SpecificWeight operator -(SpecificWeight left, SpecificWeight right) { - return new SpecificWeight(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static SpecificWeight operator *(double left, SpecificWeight right) @@ -635,12 +635,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Specif return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(SpecificWeight left, SpecificWeight right) + public static bool operator ==(SpecificWeight left, SpecificWeight right) { return left.Equals(right); } - public static bool operator !=(SpecificWeight left, SpecificWeight right) + public static bool operator !=(SpecificWeight left, SpecificWeight right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/Speed.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Speed.NetFramework.g.cs index a557138fe8..a5bfba7dce 100644 --- a/UnitsNet/GeneratedCode/Quantities/Speed.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Speed.NetFramework.g.cs @@ -790,12 +790,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out SpeedU public static Speed operator +(Speed left, Speed right) { - return new Speed(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Speed operator -(Speed left, Speed right) { - return new Speed(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Speed operator *(double left, Speed right) @@ -842,12 +842,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out SpeedU return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(Speed left, Speed right) + public static bool operator ==(Speed left, Speed right) { return left.Equals(right); } - public static bool operator !=(Speed left, Speed right) + public static bool operator !=(Speed left, Speed right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.NetFramework.g.cs index 40a63cb355..f093e9dd65 100644 --- a/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.NetFramework.g.cs @@ -482,12 +482,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Temper public static TemperatureChangeRate operator +(TemperatureChangeRate left, TemperatureChangeRate right) { - return new TemperatureChangeRate(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static TemperatureChangeRate operator -(TemperatureChangeRate left, TemperatureChangeRate right) { - return new TemperatureChangeRate(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static TemperatureChangeRate operator *(double left, TemperatureChangeRate right) @@ -534,12 +534,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Temper return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(TemperatureChangeRate left, TemperatureChangeRate right) + public static bool operator ==(TemperatureChangeRate left, TemperatureChangeRate right) { return left.Equals(right); } - public static bool operator !=(TemperatureChangeRate left, TemperatureChangeRate right) + public static bool operator !=(TemperatureChangeRate left, TemperatureChangeRate right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.NetFramework.g.cs index b30f38b0c6..def150e54e 100644 --- a/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.NetFramework.g.cs @@ -454,12 +454,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Temper public static TemperatureDelta operator +(TemperatureDelta left, TemperatureDelta right) { - return new TemperatureDelta(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static TemperatureDelta operator -(TemperatureDelta left, TemperatureDelta right) { - return new TemperatureDelta(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static TemperatureDelta operator *(double left, TemperatureDelta right) @@ -506,12 +506,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Temper return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(TemperatureDelta left, TemperatureDelta right) + public static bool operator ==(TemperatureDelta left, TemperatureDelta right) { return left.Equals(right); } - public static bool operator !=(TemperatureDelta left, TemperatureDelta right) + public static bool operator !=(TemperatureDelta left, TemperatureDelta right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.NetFramework.g.cs index 77ee8a8895..6a30643a5d 100644 --- a/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.NetFramework.g.cs @@ -373,12 +373,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Therma public static ThermalConductivity operator +(ThermalConductivity left, ThermalConductivity right) { - return new ThermalConductivity(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ThermalConductivity operator -(ThermalConductivity left, ThermalConductivity right) { - return new ThermalConductivity(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ThermalConductivity operator *(double left, ThermalConductivity right) @@ -425,12 +425,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Therma return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(ThermalConductivity left, ThermalConductivity right) + public static bool operator ==(ThermalConductivity left, ThermalConductivity right) { return left.Equals(right); } - public static bool operator !=(ThermalConductivity left, ThermalConductivity right) + public static bool operator !=(ThermalConductivity left, ThermalConductivity right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/ThermalResistance.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ThermalResistance.NetFramework.g.cs index 1c7fd72572..f84714d0a4 100644 --- a/UnitsNet/GeneratedCode/Quantities/ThermalResistance.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ThermalResistance.NetFramework.g.cs @@ -412,12 +412,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Therma public static ThermalResistance operator +(ThermalResistance left, ThermalResistance right) { - return new ThermalResistance(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ThermalResistance operator -(ThermalResistance left, ThermalResistance right) { - return new ThermalResistance(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static ThermalResistance operator *(double left, ThermalResistance right) @@ -464,12 +464,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Therma return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(ThermalResistance left, ThermalResistance right) + public static bool operator ==(ThermalResistance left, ThermalResistance right) { return left.Equals(right); } - public static bool operator !=(ThermalResistance left, ThermalResistance right) + public static bool operator !=(ThermalResistance left, ThermalResistance right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/Torque.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Torque.NetFramework.g.cs index a73e74b5fc..a22b196525 100644 --- a/UnitsNet/GeneratedCode/Quantities/Torque.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Torque.NetFramework.g.cs @@ -636,12 +636,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Torque public static Torque operator +(Torque left, Torque right) { - return new Torque(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Torque operator -(Torque left, Torque right) { - return new Torque(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Torque operator *(double left, Torque right) @@ -688,12 +688,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Torque return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(Torque left, Torque right) + public static bool operator ==(Torque left, Torque right) { return left.Equals(right); } - public static bool operator !=(Torque left, Torque right) + public static bool operator !=(Torque left, Torque right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/VitaminA.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/VitaminA.NetFramework.g.cs index e27bca2e83..e059d6d590 100644 --- a/UnitsNet/GeneratedCode/Quantities/VitaminA.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/VitaminA.NetFramework.g.cs @@ -356,12 +356,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Vitami public static VitaminA operator +(VitaminA left, VitaminA right) { - return new VitaminA(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static VitaminA operator -(VitaminA left, VitaminA right) { - return new VitaminA(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static VitaminA operator *(double left, VitaminA right) @@ -408,12 +408,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Vitami return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(VitaminA left, VitaminA right) + public static bool operator ==(VitaminA left, VitaminA right) { return left.Equals(right); } - public static bool operator !=(VitaminA left, VitaminA right) + public static bool operator !=(VitaminA left, VitaminA right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/Volume.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Volume.NetFramework.g.cs index 5dfddc94db..45acdf0b24 100644 --- a/UnitsNet/GeneratedCode/Quantities/Volume.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Volume.NetFramework.g.cs @@ -944,12 +944,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Volume public static Volume operator +(Volume left, Volume right) { - return new Volume(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Volume operator -(Volume left, Volume right) { - return new Volume(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static Volume operator *(double left, Volume right) @@ -996,12 +996,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Volume return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(Volume left, Volume right) + public static bool operator ==(Volume left, Volume right) { return left.Equals(right); } - public static bool operator !=(Volume left, Volume right) + public static bool operator !=(Volume left, Volume right) { return !(left == right); } diff --git a/UnitsNet/GeneratedCode/Quantities/VolumeFlow.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumeFlow.NetFramework.g.cs index c43ad13b3c..1ea0cbd255 100644 --- a/UnitsNet/GeneratedCode/Quantities/VolumeFlow.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/VolumeFlow.NetFramework.g.cs @@ -706,12 +706,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Volume public static VolumeFlow operator +(VolumeFlow left, VolumeFlow right) { - return new VolumeFlow(left.Value + right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() + right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static VolumeFlow operator -(VolumeFlow left, VolumeFlow right) { - return new VolumeFlow(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return From(left.AsBaseUnit() - right.AsBaseUnit(), BaseUnit).ToUnit(left.Unit); } public static VolumeFlow operator *(double left, VolumeFlow right) @@ -758,12 +758,12 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Volume return left.Value > right.AsBaseNumericType(left.Unit); } - public static bool operator ==(VolumeFlow left, VolumeFlow right) + public static bool operator ==(VolumeFlow left, VolumeFlow right) { return left.Equals(right); } - public static bool operator !=(VolumeFlow left, VolumeFlow right) + public static bool operator !=(VolumeFlow left, VolumeFlow right) { return !(left == right); }