From 16a485483c824d40abede5953c9b0977f099a954 Mon Sep 17 00:00:00 2001 From: Tristan Milnthorp Date: Thu, 24 Jan 2019 11:32:29 -0500 Subject: [PATCH 01/21] Allowing custom unit conversion functions to be specified --- UnitsNet.Tests/UnitConverterTest.cs | 12 +++++++- UnitsNet/UnitConverter.cs | 46 +++++++++++++++++++++++++---- 2 files changed, 52 insertions(+), 6 deletions(-) diff --git a/UnitsNet.Tests/UnitConverterTest.cs b/UnitsNet.Tests/UnitConverterTest.cs index f656ea3a14..b31993b065 100644 --- a/UnitsNet.Tests/UnitConverterTest.cs +++ b/UnitsNet.Tests/UnitConverterTest.cs @@ -19,12 +19,22 @@ // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // THE SOFTWARE. +using UnitsNet.Units; using Xunit; namespace UnitsNet.Tests { public class UnitConverterTest { + [Fact] + public void CustomVersionFunctionWorks() + { + UnitsNet.ConversionFunction conversionFunction = ( from ) => Length.FromInches( 18 ); + UnitConverter.Default.AddConversionFunction( LengthUnit.Meter, LengthUnit.Inch, conversionFunction ); + var converter = UnitConverter.Default.GetConversionFunction( LengthUnit.Meter, LengthUnit.Inch ); + var converted = converter( Length.FromMeters( 1.0 ) ); + } + [Theory] [InlineData(0, 0, "Length", "Meter", "Centimeter")] [InlineData(100, 1, "Length", "Meter", "Centimeter")] @@ -119,4 +129,4 @@ public void TryConvertByAbbreviation_ReturnsTrueOnSuccessAndOutputsResult(double Assert.Equal(expectedValue, result); } } -} \ No newline at end of file +} diff --git a/UnitsNet/UnitConverter.cs b/UnitsNet/UnitConverter.cs index cf5ac3a15a..09365c7f8f 100644 --- a/UnitsNet/UnitConverter.cs +++ b/UnitsNet/UnitConverter.cs @@ -20,30 +20,66 @@ // THE SOFTWARE. using System; +using System.Collections.Generic; using System.Globalization; using System.Linq; using System.Reflection; using UnitsNet.InternalHelpers; using UnitsNet.Units; + #if WINDOWS_UWP -using Culture = System.String; -using FromValue = System.Double; + using FromValue = System.Double; #else -using Culture = System.IFormatProvider; -using FromValue = UnitsNet.QuantityValue; + using FromValue = UnitsNet.QuantityValue; #endif namespace UnitsNet { + using FromToPair = ValueTuple; + + public delegate IQuantity ConversionFunction( IQuantity value ); + /// /// Convert between units of a quantity, such as converting from meters to centimeters of a given length. /// - public static class UnitConverter + public sealed class UnitConverter { + public static UnitConverter Default { get; } + private static readonly string QuantityNamespace = typeof(Length).Namespace; private static readonly string UnitTypeNamespace = typeof(LengthUnit).Namespace; private static readonly Assembly UnitsNetAssembly = typeof(Length).GetAssembly(); + private Dictionary conversionFunctions; + + public UnitConverter() + { + conversionFunctions = new Dictionary(); + } + + public void AddConversionFunction( Enum from, Enum to, ConversionFunction conversionFunction ) + { + var fromTo = new FromToPair( from, to ); + conversionFunctions.Add( fromTo, conversionFunction ); + } + + public ConversionFunction GetConversionFunction( Enum from, Enum to ) + { + var fromTo = new FromToPair( from, to ); + return conversionFunctions[ fromTo ]; + } + + public bool TryGetConversionFunction( Enum from, Enum to, out ConversionFunction conversionFunction ) + { + var fromTo = new FromToPair( from, to ); + return conversionFunctions.TryGetValue( fromTo, out conversionFunction ); + } + + static UnitConverter() + { + Default = new UnitConverter(); + } + /// /// Convert between any two quantity units by their names, such as converting a "Length" of N "Meter" to "Centimeter". /// This is particularly useful for creating things like a generated unit conversion UI, From fa2a2c16351c61b248c18b50a1cf438baf963302 Mon Sep 17 00:00:00 2001 From: Tristan Milnthorp Date: Fri, 25 Jan 2019 11:57:41 -0500 Subject: [PATCH 02/21] Registering default base->unit and unit->base conversion functions in UnitConverter. Adding test for custom direct conversions --- UnitsNet.Tests/UnitConverterTest.cs | 29 +- .../Acceleration.WindowsRuntimeComponent.g.cs | 44 +- ...ntOfSubstance.WindowsRuntimeComponent.g.cs | 50 +- ...mplitudeRatio.WindowsRuntimeComponent.g.cs | 17 +- .../Angle.WindowsRuntimeComponent.g.cs | 47 +- ...pparentEnergy.WindowsRuntimeComponent.g.cs | 14 +- ...ApparentPower.WindowsRuntimeComponent.g.cs | 17 +- .../Area.WindowsRuntimeComponent.g.cs | 44 +- .../AreaDensity.WindowsRuntimeComponent.g.cs | 8 +- ...mentOfInertia.WindowsRuntimeComponent.g.cs | 23 +- .../BitRate.WindowsRuntimeComponent.g.cs | 83 +- ...elConsumption.WindowsRuntimeComponent.g.cs | 14 +- .../Capacitance.WindowsRuntimeComponent.g.cs | 26 +- ...rmalExpansion.WindowsRuntimeComponent.g.cs | 14 +- .../Density.WindowsRuntimeComponent.g.cs | 122 +- .../Duration.WindowsRuntimeComponent.g.cs | 35 +- ...amicViscosity.WindowsRuntimeComponent.g.cs | 23 +- ...ricAdmittance.WindowsRuntimeComponent.g.cs | 17 +- ...lectricCharge.WindowsRuntimeComponent.g.cs | 8 +- ...ChargeDensity.WindowsRuntimeComponent.g.cs | 8 +- ...icConductance.WindowsRuntimeComponent.g.cs | 14 +- ...cConductivity.WindowsRuntimeComponent.g.cs | 8 +- ...ectricCurrent.WindowsRuntimeComponent.g.cs | 29 +- ...urrentDensity.WindowsRuntimeComponent.g.cs | 8 +- ...rrentGradient.WindowsRuntimeComponent.g.cs | 8 +- ...ElectricField.WindowsRuntimeComponent.g.cs | 8 +- ...ricInductance.WindowsRuntimeComponent.g.cs | 17 +- ...tricPotential.WindowsRuntimeComponent.g.cs | 20 +- ...icPotentialAc.WindowsRuntimeComponent.g.cs | 20 +- ...icPotentialDc.WindowsRuntimeComponent.g.cs | 20 +- ...ricResistance.WindowsRuntimeComponent.g.cs | 20 +- ...icResistivity.WindowsRuntimeComponent.g.cs | 47 +- .../Energy.WindowsRuntimeComponent.g.cs | 71 +- .../Entropy.WindowsRuntimeComponent.g.cs | 26 +- .../Force.WindowsRuntimeComponent.g.cs | 44 +- ...rceChangeRate.WindowsRuntimeComponent.g.cs | 38 +- ...orcePerLength.WindowsRuntimeComponent.g.cs | 32 +- .../Frequency.WindowsRuntimeComponent.g.cs | 29 +- .../HeatFlux.WindowsRuntimeComponent.g.cs | 59 +- ...erCoefficient.WindowsRuntimeComponent.g.cs | 11 +- .../Illuminance.WindowsRuntimeComponent.g.cs | 17 +- .../Information.WindowsRuntimeComponent.g.cs | 83 +- .../Irradiance.WindowsRuntimeComponent.g.cs | 47 +- .../Irradiation.WindowsRuntimeComponent.g.cs | 17 +- ...aticViscosity.WindowsRuntimeComponent.g.cs | 29 +- .../LapseRate.WindowsRuntimeComponent.g.cs | 8 +- .../Length.WindowsRuntimeComponent.g.cs | 71 +- .../Level.WindowsRuntimeComponent.g.cs | 11 +- ...LinearDensity.WindowsRuntimeComponent.g.cs | 14 +- .../LuminousFlux.WindowsRuntimeComponent.g.cs | 8 +- ...nousIntensity.WindowsRuntimeComponent.g.cs | 8 +- ...MagneticField.WindowsRuntimeComponent.g.cs | 17 +- .../MagneticFlux.WindowsRuntimeComponent.g.cs | 8 +- ...Magnetization.WindowsRuntimeComponent.g.cs | 8 +- .../Mass.WindowsRuntimeComponent.g.cs | 74 +- .../MassFlow.WindowsRuntimeComponent.g.cs | 95 +- .../MassFlux.WindowsRuntimeComponent.g.cs | 11 +- ...mentOfInertia.WindowsRuntimeComponent.g.cs | 89 +- .../MolarEnergy.WindowsRuntimeComponent.g.cs | 14 +- .../MolarEntropy.WindowsRuntimeComponent.g.cs | 14 +- .../MolarMass.WindowsRuntimeComponent.g.cs | 41 +- .../Molarity.WindowsRuntimeComponent.g.cs | 29 +- .../Permeability.WindowsRuntimeComponent.g.cs | 8 +- .../Permittivity.WindowsRuntimeComponent.g.cs | 8 +- .../Power.WindowsRuntimeComponent.g.cs | 65 +- .../PowerDensity.WindowsRuntimeComponent.g.cs | 137 +- .../PowerRatio.WindowsRuntimeComponent.g.cs | 11 +- .../Pressure.WindowsRuntimeComponent.g.cs | 131 +- ...ureChangeRate.WindowsRuntimeComponent.g.cs | 26 +- .../Ratio.WindowsRuntimeComponent.g.cs | 23 +- ...eactiveEnergy.WindowsRuntimeComponent.g.cs | 14 +- ...ReactivePower.WindowsRuntimeComponent.g.cs | 17 +- ...lAcceleration.WindowsRuntimeComponent.g.cs | 14 +- ...tationalSpeed.WindowsRuntimeComponent.g.cs | 44 +- ...onalStiffness.WindowsRuntimeComponent.g.cs | 14 +- ...nessPerLength.WindowsRuntimeComponent.g.cs | 14 +- .../SolidAngle.WindowsRuntimeComponent.g.cs | 8 +- ...pecificEnergy.WindowsRuntimeComponent.g.cs | 32 +- ...ecificEntropy.WindowsRuntimeComponent.g.cs | 29 +- ...pecificVolume.WindowsRuntimeComponent.g.cs | 14 +- ...pecificWeight.WindowsRuntimeComponent.g.cs | 56 +- .../Speed.WindowsRuntimeComponent.g.cs | 101 +- .../Temperature.WindowsRuntimeComponent.g.cs | 29 +- ...ureChangeRate.WindowsRuntimeComponent.g.cs | 35 +- ...peratureDelta.WindowsRuntimeComponent.g.cs | 29 +- ...lConductivity.WindowsRuntimeComponent.g.cs | 11 +- ...malResistance.WindowsRuntimeComponent.g.cs | 20 +- .../Torque.WindowsRuntimeComponent.g.cs | 68 +- .../VitaminA.WindowsRuntimeComponent.g.cs | 8 +- .../Volume.WindowsRuntimeComponent.g.cs | 140 +- .../VolumeFlow.WindowsRuntimeComponent.g.cs | 149 +- .../Quantities/Acceleration.NetFramework.g.cs | 44 +- .../AmountOfSubstance.NetFramework.g.cs | 50 +- .../AmplitudeRatio.NetFramework.g.cs | 17 +- .../Quantities/Angle.NetFramework.g.cs | 47 +- .../ApparentEnergy.NetFramework.g.cs | 14 +- .../ApparentPower.NetFramework.g.cs | 17 +- .../Quantities/Area.NetFramework.g.cs | 44 +- .../Quantities/AreaDensity.NetFramework.g.cs | 8 +- .../AreaMomentOfInertia.NetFramework.g.cs | 23 +- .../Quantities/BitRate.NetFramework.g.cs | 83 +- ...eSpecificFuelConsumption.NetFramework.g.cs | 14 +- .../Quantities/Capacitance.NetFramework.g.cs | 26 +- ...icientOfThermalExpansion.NetFramework.g.cs | 14 +- .../Quantities/Density.NetFramework.g.cs | 122 +- .../Quantities/Duration.NetFramework.g.cs | 35 +- .../DynamicViscosity.NetFramework.g.cs | 23 +- .../ElectricAdmittance.NetFramework.g.cs | 17 +- .../ElectricCharge.NetFramework.g.cs | 8 +- .../ElectricChargeDensity.NetFramework.g.cs | 8 +- .../ElectricConductance.NetFramework.g.cs | 14 +- .../ElectricConductivity.NetFramework.g.cs | 8 +- .../ElectricCurrent.NetFramework.g.cs | 29 +- .../ElectricCurrentDensity.NetFramework.g.cs | 8 +- .../ElectricCurrentGradient.NetFramework.g.cs | 8 +- .../ElectricField.NetFramework.g.cs | 8 +- .../ElectricInductance.NetFramework.g.cs | 17 +- .../ElectricPotential.NetFramework.g.cs | 20 +- .../ElectricPotentialAc.NetFramework.g.cs | 20 +- .../ElectricPotentialDc.NetFramework.g.cs | 20 +- .../ElectricResistance.NetFramework.g.cs | 20 +- .../ElectricResistivity.NetFramework.g.cs | 47 +- .../Quantities/Energy.NetFramework.g.cs | 71 +- .../Quantities/Entropy.NetFramework.g.cs | 26 +- .../Quantities/Force.NetFramework.g.cs | 44 +- .../ForceChangeRate.NetFramework.g.cs | 38 +- .../ForcePerLength.NetFramework.g.cs | 32 +- .../Quantities/Frequency.NetFramework.g.cs | 29 +- .../Quantities/HeatFlux.NetFramework.g.cs | 59 +- .../HeatTransferCoefficient.NetFramework.g.cs | 11 +- .../Quantities/Illuminance.NetFramework.g.cs | 17 +- .../Quantities/Information.NetFramework.g.cs | 83 +- .../Quantities/Irradiance.NetFramework.g.cs | 47 +- .../Quantities/Irradiation.NetFramework.g.cs | 17 +- .../KinematicViscosity.NetFramework.g.cs | 29 +- .../Quantities/LapseRate.NetFramework.g.cs | 8 +- .../Quantities/Length.NetFramework.g.cs | 71 +- .../Quantities/Level.NetFramework.g.cs | 11 +- .../LinearDensity.NetFramework.g.cs | 14 +- .../Quantities/LuminousFlux.NetFramework.g.cs | 8 +- .../LuminousIntensity.NetFramework.g.cs | 8 +- .../MagneticField.NetFramework.g.cs | 17 +- .../Quantities/MagneticFlux.NetFramework.g.cs | 8 +- .../Magnetization.NetFramework.g.cs | 8 +- .../Quantities/Mass.NetFramework.g.cs | 74 +- .../Quantities/MassFlow.NetFramework.g.cs | 95 +- .../Quantities/MassFlux.NetFramework.g.cs | 11 +- .../MassMomentOfInertia.NetFramework.g.cs | 89 +- .../Quantities/MolarEnergy.NetFramework.g.cs | 14 +- .../Quantities/MolarEntropy.NetFramework.g.cs | 14 +- .../Quantities/MolarMass.NetFramework.g.cs | 41 +- .../Quantities/Molarity.NetFramework.g.cs | 29 +- .../Quantities/Permeability.NetFramework.g.cs | 8 +- .../Quantities/Permittivity.NetFramework.g.cs | 8 +- .../Quantities/Power.NetFramework.g.cs | 65 +- .../Quantities/PowerDensity.NetFramework.g.cs | 137 +- .../Quantities/PowerRatio.NetFramework.g.cs | 11 +- .../Quantities/Pressure.NetFramework.g.cs | 131 +- .../PressureChangeRate.NetFramework.g.cs | 26 +- .../Quantities/Ratio.NetFramework.g.cs | 23 +- .../ReactiveEnergy.NetFramework.g.cs | 14 +- .../ReactivePower.NetFramework.g.cs | 17 +- .../RotationalAcceleration.NetFramework.g.cs | 14 +- .../RotationalSpeed.NetFramework.g.cs | 44 +- .../RotationalStiffness.NetFramework.g.cs | 14 +- ...tionalStiffnessPerLength.NetFramework.g.cs | 14 +- .../Quantities/SolidAngle.NetFramework.g.cs | 8 +- .../SpecificEnergy.NetFramework.g.cs | 32 +- .../SpecificEntropy.NetFramework.g.cs | 29 +- .../SpecificVolume.NetFramework.g.cs | 14 +- .../SpecificWeight.NetFramework.g.cs | 56 +- .../Quantities/Speed.NetFramework.g.cs | 101 +- .../Quantities/Temperature.NetFramework.g.cs | 29 +- .../TemperatureChangeRate.NetFramework.g.cs | 35 +- .../TemperatureDelta.NetFramework.g.cs | 29 +- .../ThermalConductivity.NetFramework.g.cs | 11 +- .../ThermalResistance.NetFramework.g.cs | 20 +- .../Quantities/Torque.NetFramework.g.cs | 68 +- .../Quantities/VitaminA.NetFramework.g.cs | 8 +- .../Quantities/Volume.NetFramework.g.cs | 140 +- .../Quantities/VolumeFlow.NetFramework.g.cs | 149 +- UnitsNet/GeneratedCode/UnitConverter.g.cs | 1738 +++++++++++++++++ UnitsNet/Scripts/GenerateUnits.ps1 | 15 + ...GenerateQuantitySourceCodeNetFramework.ps1 | 8 +- ...GenerateUnitConverterDefaultSourceCode.ps1 | 85 + UnitsNet/UnitConverter.cs | 53 +- 186 files changed, 5992 insertions(+), 2158 deletions(-) create mode 100644 UnitsNet/GeneratedCode/UnitConverter.g.cs create mode 100644 UnitsNet/Scripts/Include-GenerateUnitConverterDefaultSourceCode.ps1 diff --git a/UnitsNet.Tests/UnitConverterTest.cs b/UnitsNet.Tests/UnitConverterTest.cs index b31993b065..dad4a95ac9 100644 --- a/UnitsNet.Tests/UnitConverterTest.cs +++ b/UnitsNet.Tests/UnitConverterTest.cs @@ -27,12 +27,31 @@ namespace UnitsNet.Tests public class UnitConverterTest { [Fact] - public void CustomVersionFunctionWorks() + public void CustomConversionFunctionWorks() { - UnitsNet.ConversionFunction conversionFunction = ( from ) => Length.FromInches( 18 ); - UnitConverter.Default.AddConversionFunction( LengthUnit.Meter, LengthUnit.Inch, conversionFunction ); - var converter = UnitConverter.Default.GetConversionFunction( LengthUnit.Meter, LengthUnit.Inch ); - var converted = converter( Length.FromMeters( 1.0 ) ); + ConversionFunction conversionFunction = ( from ) => Length.FromInches( 18 ); + + var unitConverter = new UnitConverter(); + unitConverter.SetConversionFunction( LengthUnit.Meter, LengthUnit.Inch, conversionFunction ); + + var foundConversionFunction = unitConverter.GetConversionFunction( LengthUnit.Meter, LengthUnit.Inch ); + var converted = foundConversionFunction( Length.FromMeters( 1.0 ) ); + + Assert.Equal( Length.FromInches( 18 ), converted ); + } + + [Fact] + public void TryCustomConversionForOilBarrelsToUsGallons() + { + ConversionFunction conversionFunction = ( from ) => Volume.FromUsGallons( ((Volume)from).Value * 42 ); + + var unitConverter = new UnitConverter(); + unitConverter.SetConversionFunction( VolumeUnit.OilBarrel, VolumeUnit.UsGallon, conversionFunction ); + + var foundConversionFunction = unitConverter.GetConversionFunction( VolumeUnit.OilBarrel, VolumeUnit.UsGallon ); + var converted = foundConversionFunction( Volume.FromOilBarrels( 1 ) ); + + Assert.Equal( Volume.FromUsGallons( 42 ), converted ); } [Theory] diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Acceleration.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Acceleration.WindowsRuntimeComponent.g.cs index 683d1e5f9f..4059b5623f 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Acceleration.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Acceleration.WindowsRuntimeComponent.g.cs @@ -671,23 +671,36 @@ public Acceleration ToUnit(AccelerationUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Acceleration AsBaseUnit() { switch(Unit) { - case AccelerationUnit.CentimeterPerSecondSquared: return (_value) * 1e-2d; - case AccelerationUnit.DecimeterPerSecondSquared: return (_value) * 1e-1d; - case AccelerationUnit.FootPerSecondSquared: return _value*0.304800; - case AccelerationUnit.InchPerSecondSquared: return _value*0.0254; - case AccelerationUnit.KilometerPerSecondSquared: return (_value) * 1e3d; - case AccelerationUnit.KnotPerHour: return _value*0.5144444444444/3600; - case AccelerationUnit.KnotPerMinute: return _value*0.5144444444444/60; - case AccelerationUnit.KnotPerSecond: return _value*0.5144444444444; - case AccelerationUnit.MeterPerSecondSquared: return _value; - case AccelerationUnit.MicrometerPerSecondSquared: return (_value) * 1e-6d; - case AccelerationUnit.MillimeterPerSecondSquared: return (_value) * 1e-3d; - case AccelerationUnit.NanometerPerSecondSquared: return (_value) * 1e-9d; - case AccelerationUnit.StandardGravity: return _value*9.80665; + case AccelerationUnit.CentimeterPerSecondSquared: + return new Acceleration((_value) * 1e-2d, BaseUnit); + case AccelerationUnit.DecimeterPerSecondSquared: + return new Acceleration((_value) * 1e-1d, BaseUnit); + case AccelerationUnit.FootPerSecondSquared: + return new Acceleration(_value*0.304800, BaseUnit); + case AccelerationUnit.InchPerSecondSquared: + return new Acceleration(_value*0.0254, BaseUnit); + case AccelerationUnit.KilometerPerSecondSquared: + return new Acceleration((_value) * 1e3d, BaseUnit); + case AccelerationUnit.KnotPerHour: + return new Acceleration(_value*0.5144444444444/3600, BaseUnit); + case AccelerationUnit.KnotPerMinute: + return new Acceleration(_value*0.5144444444444/60, BaseUnit); + case AccelerationUnit.KnotPerSecond: + return new Acceleration(_value*0.5144444444444, BaseUnit); + case AccelerationUnit.MeterPerSecondSquared: + return new Acceleration(_value, BaseUnit); + case AccelerationUnit.MicrometerPerSecondSquared: + return new Acceleration((_value) * 1e-6d, BaseUnit); + case AccelerationUnit.MillimeterPerSecondSquared: + return new Acceleration((_value) * 1e-3d, BaseUnit); + case AccelerationUnit.NanometerPerSecondSquared: + return new Acceleration((_value) * 1e-9d, BaseUnit); + case AccelerationUnit.StandardGravity: + return new Acceleration(_value*9.80665, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -698,7 +711,8 @@ private double AsBaseNumericType(AccelerationUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmountOfSubstance.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmountOfSubstance.WindowsRuntimeComponent.g.cs index 289ef02cee..144c4af162 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmountOfSubstance.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmountOfSubstance.WindowsRuntimeComponent.g.cs @@ -701,25 +701,40 @@ public AmountOfSubstance ToUnit(AmountOfSubstanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal AmountOfSubstance AsBaseUnit() { switch(Unit) { - case AmountOfSubstanceUnit.Centimole: return (_value) * 1e-2d; - case AmountOfSubstanceUnit.CentipoundMole: return (_value*453.59237) * 1e-2d; - case AmountOfSubstanceUnit.Decimole: return (_value) * 1e-1d; - case AmountOfSubstanceUnit.DecipoundMole: return (_value*453.59237) * 1e-1d; - case AmountOfSubstanceUnit.Kilomole: return (_value) * 1e3d; - case AmountOfSubstanceUnit.KilopoundMole: return (_value*453.59237) * 1e3d; - case AmountOfSubstanceUnit.Megamole: return (_value) * 1e6d; - case AmountOfSubstanceUnit.Micromole: return (_value) * 1e-6d; - case AmountOfSubstanceUnit.MicropoundMole: return (_value*453.59237) * 1e-6d; - case AmountOfSubstanceUnit.Millimole: return (_value) * 1e-3d; - case AmountOfSubstanceUnit.MillipoundMole: return (_value*453.59237) * 1e-3d; - case AmountOfSubstanceUnit.Mole: return _value; - case AmountOfSubstanceUnit.Nanomole: return (_value) * 1e-9d; - case AmountOfSubstanceUnit.NanopoundMole: return (_value*453.59237) * 1e-9d; - case AmountOfSubstanceUnit.PoundMole: return _value*453.59237; + case AmountOfSubstanceUnit.Centimole: + return new AmountOfSubstance((_value) * 1e-2d, BaseUnit); + case AmountOfSubstanceUnit.CentipoundMole: + return new AmountOfSubstance((_value*453.59237) * 1e-2d, BaseUnit); + case AmountOfSubstanceUnit.Decimole: + return new AmountOfSubstance((_value) * 1e-1d, BaseUnit); + case AmountOfSubstanceUnit.DecipoundMole: + return new AmountOfSubstance((_value*453.59237) * 1e-1d, BaseUnit); + case AmountOfSubstanceUnit.Kilomole: + return new AmountOfSubstance((_value) * 1e3d, BaseUnit); + case AmountOfSubstanceUnit.KilopoundMole: + return new AmountOfSubstance((_value*453.59237) * 1e3d, BaseUnit); + case AmountOfSubstanceUnit.Megamole: + return new AmountOfSubstance((_value) * 1e6d, BaseUnit); + case AmountOfSubstanceUnit.Micromole: + return new AmountOfSubstance((_value) * 1e-6d, BaseUnit); + case AmountOfSubstanceUnit.MicropoundMole: + return new AmountOfSubstance((_value*453.59237) * 1e-6d, BaseUnit); + case AmountOfSubstanceUnit.Millimole: + return new AmountOfSubstance((_value) * 1e-3d, BaseUnit); + case AmountOfSubstanceUnit.MillipoundMole: + return new AmountOfSubstance((_value*453.59237) * 1e-3d, BaseUnit); + case AmountOfSubstanceUnit.Mole: + return new AmountOfSubstance(_value, BaseUnit); + case AmountOfSubstanceUnit.Nanomole: + return new AmountOfSubstance((_value) * 1e-9d, BaseUnit); + case AmountOfSubstanceUnit.NanopoundMole: + return new AmountOfSubstance((_value*453.59237) * 1e-9d, BaseUnit); + case AmountOfSubstanceUnit.PoundMole: + return new AmountOfSubstance(_value*453.59237, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -730,7 +745,8 @@ private double AsBaseNumericType(AmountOfSubstanceUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmplitudeRatio.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmplitudeRatio.WindowsRuntimeComponent.g.cs index fd7bcd0813..aff0608085 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmplitudeRatio.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmplitudeRatio.WindowsRuntimeComponent.g.cs @@ -536,14 +536,18 @@ public AmplitudeRatio ToUnit(AmplitudeRatioUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal AmplitudeRatio AsBaseUnit() { switch(Unit) { - case AmplitudeRatioUnit.DecibelMicrovolt: return _value - 120; - case AmplitudeRatioUnit.DecibelMillivolt: return _value - 60; - case AmplitudeRatioUnit.DecibelUnloaded: return _value - 2.218487499; - case AmplitudeRatioUnit.DecibelVolt: return _value; + case AmplitudeRatioUnit.DecibelMicrovolt: + return new AmplitudeRatio(_value - 120, BaseUnit); + case AmplitudeRatioUnit.DecibelMillivolt: + return new AmplitudeRatio(_value - 60, BaseUnit); + case AmplitudeRatioUnit.DecibelUnloaded: + return new AmplitudeRatio(_value - 2.218487499, BaseUnit); + case AmplitudeRatioUnit.DecibelVolt: + return new AmplitudeRatio(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -554,7 +558,8 @@ private double AsBaseNumericType(AmplitudeRatioUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Angle.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Angle.WindowsRuntimeComponent.g.cs index 00d0b13620..069674ecb8 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Angle.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Angle.WindowsRuntimeComponent.g.cs @@ -686,24 +686,38 @@ public Angle ToUnit(AngleUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Angle AsBaseUnit() { switch(Unit) { - case AngleUnit.Arcminute: return _value/60; - case AngleUnit.Arcsecond: return _value/3600; - case AngleUnit.Centiradian: return (_value*180/Math.PI) * 1e-2d; - case AngleUnit.Deciradian: return (_value*180/Math.PI) * 1e-1d; - case AngleUnit.Degree: return _value; - case AngleUnit.Gradian: return _value*0.9; - case AngleUnit.Microdegree: return (_value) * 1e-6d; - case AngleUnit.Microradian: return (_value*180/Math.PI) * 1e-6d; - case AngleUnit.Millidegree: return (_value) * 1e-3d; - case AngleUnit.Milliradian: return (_value*180/Math.PI) * 1e-3d; - case AngleUnit.Nanodegree: return (_value) * 1e-9d; - case AngleUnit.Nanoradian: return (_value*180/Math.PI) * 1e-9d; - case AngleUnit.Radian: return _value*180/Math.PI; - case AngleUnit.Revolution: return _value*360; + case AngleUnit.Arcminute: + return new Angle(_value/60, BaseUnit); + case AngleUnit.Arcsecond: + return new Angle(_value/3600, BaseUnit); + case AngleUnit.Centiradian: + return new Angle((_value*180/Math.PI) * 1e-2d, BaseUnit); + case AngleUnit.Deciradian: + return new Angle((_value*180/Math.PI) * 1e-1d, BaseUnit); + case AngleUnit.Degree: + return new Angle(_value, BaseUnit); + case AngleUnit.Gradian: + return new Angle(_value*0.9, BaseUnit); + case AngleUnit.Microdegree: + return new Angle((_value) * 1e-6d, BaseUnit); + case AngleUnit.Microradian: + return new Angle((_value*180/Math.PI) * 1e-6d, BaseUnit); + case AngleUnit.Millidegree: + return new Angle((_value) * 1e-3d, BaseUnit); + case AngleUnit.Milliradian: + return new Angle((_value*180/Math.PI) * 1e-3d, BaseUnit); + case AngleUnit.Nanodegree: + return new Angle((_value) * 1e-9d, BaseUnit); + case AngleUnit.Nanoradian: + return new Angle((_value*180/Math.PI) * 1e-9d, BaseUnit); + case AngleUnit.Radian: + return new Angle(_value*180/Math.PI, BaseUnit); + case AngleUnit.Revolution: + return new Angle(_value*360, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -714,7 +728,8 @@ private double AsBaseNumericType(AngleUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentEnergy.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentEnergy.WindowsRuntimeComponent.g.cs index cbc5a659c1..02b6ad4070 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentEnergy.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentEnergy.WindowsRuntimeComponent.g.cs @@ -521,13 +521,16 @@ public ApparentEnergy ToUnit(ApparentEnergyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ApparentEnergy AsBaseUnit() { switch(Unit) { - case ApparentEnergyUnit.KilovoltampereHour: return (_value) * 1e3d; - case ApparentEnergyUnit.MegavoltampereHour: return (_value) * 1e6d; - case ApparentEnergyUnit.VoltampereHour: return _value; + case ApparentEnergyUnit.KilovoltampereHour: + return new ApparentEnergy((_value) * 1e3d, BaseUnit); + case ApparentEnergyUnit.MegavoltampereHour: + return new ApparentEnergy((_value) * 1e6d, BaseUnit); + case ApparentEnergyUnit.VoltampereHour: + return new ApparentEnergy(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -538,7 +541,8 @@ private double AsBaseNumericType(ApparentEnergyUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentPower.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentPower.WindowsRuntimeComponent.g.cs index daaf46e2cd..b8024b0ecc 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentPower.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentPower.WindowsRuntimeComponent.g.cs @@ -536,14 +536,18 @@ public ApparentPower ToUnit(ApparentPowerUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ApparentPower AsBaseUnit() { switch(Unit) { - case ApparentPowerUnit.Gigavoltampere: return (_value) * 1e9d; - case ApparentPowerUnit.Kilovoltampere: return (_value) * 1e3d; - case ApparentPowerUnit.Megavoltampere: return (_value) * 1e6d; - case ApparentPowerUnit.Voltampere: return _value; + case ApparentPowerUnit.Gigavoltampere: + return new ApparentPower((_value) * 1e9d, BaseUnit); + case ApparentPowerUnit.Kilovoltampere: + return new ApparentPower((_value) * 1e3d, BaseUnit); + case ApparentPowerUnit.Megavoltampere: + return new ApparentPower((_value) * 1e6d, BaseUnit); + case ApparentPowerUnit.Voltampere: + return new ApparentPower(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -554,7 +558,8 @@ private double AsBaseNumericType(ApparentPowerUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Area.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Area.WindowsRuntimeComponent.g.cs index a586b76c29..69b4108a96 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Area.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Area.WindowsRuntimeComponent.g.cs @@ -671,23 +671,36 @@ public Area ToUnit(AreaUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Area AsBaseUnit() { switch(Unit) { - case AreaUnit.Acre: return _value*4046.85642; - case AreaUnit.Hectare: return _value*1e4; - case AreaUnit.SquareCentimeter: return _value*1e-4; - case AreaUnit.SquareDecimeter: return _value*1e-2; - case AreaUnit.SquareFoot: return _value*0.092903; - case AreaUnit.SquareInch: return _value*0.00064516; - case AreaUnit.SquareKilometer: return _value*1e6; - case AreaUnit.SquareMeter: return _value; - case AreaUnit.SquareMicrometer: return _value*1e-12; - case AreaUnit.SquareMile: return _value*2.59e6; - case AreaUnit.SquareMillimeter: return _value*1e-6; - case AreaUnit.SquareYard: return _value*0.836127; - case AreaUnit.UsSurveySquareFoot: return _value*0.09290341161; + case AreaUnit.Acre: + return new Area(_value*4046.85642, BaseUnit); + case AreaUnit.Hectare: + return new Area(_value*1e4, BaseUnit); + case AreaUnit.SquareCentimeter: + return new Area(_value*1e-4, BaseUnit); + case AreaUnit.SquareDecimeter: + return new Area(_value*1e-2, BaseUnit); + case AreaUnit.SquareFoot: + return new Area(_value*0.092903, BaseUnit); + case AreaUnit.SquareInch: + return new Area(_value*0.00064516, BaseUnit); + case AreaUnit.SquareKilometer: + return new Area(_value*1e6, BaseUnit); + case AreaUnit.SquareMeter: + return new Area(_value, BaseUnit); + case AreaUnit.SquareMicrometer: + return new Area(_value*1e-12, BaseUnit); + case AreaUnit.SquareMile: + return new Area(_value*2.59e6, BaseUnit); + case AreaUnit.SquareMillimeter: + return new Area(_value*1e-6, BaseUnit); + case AreaUnit.SquareYard: + return new Area(_value*0.836127, BaseUnit); + case AreaUnit.UsSurveySquareFoot: + return new Area(_value*0.09290341161, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -698,7 +711,8 @@ private double AsBaseNumericType(AreaUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaDensity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaDensity.WindowsRuntimeComponent.g.cs index 10bf58c368..9b90626f1d 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaDensity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaDensity.WindowsRuntimeComponent.g.cs @@ -491,11 +491,12 @@ public AreaDensity ToUnit(AreaDensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal AreaDensity AsBaseUnit() { switch(Unit) { - case AreaDensityUnit.KilogramPerSquareMeter: return _value; + case AreaDensityUnit.KilogramPerSquareMeter: + return new AreaDensity(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -506,7 +507,8 @@ private double AsBaseNumericType(AreaDensityUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaMomentOfInertia.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaMomentOfInertia.WindowsRuntimeComponent.g.cs index 88e609fde3..9851e595f5 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaMomentOfInertia.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaMomentOfInertia.WindowsRuntimeComponent.g.cs @@ -566,16 +566,22 @@ public AreaMomentOfInertia ToUnit(AreaMomentOfInertiaUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal AreaMomentOfInertia AsBaseUnit() { switch(Unit) { - case AreaMomentOfInertiaUnit.CentimeterToTheFourth: return _value/1e8; - case AreaMomentOfInertiaUnit.DecimeterToTheFourth: return _value/1e4; - case AreaMomentOfInertiaUnit.FootToTheFourth: return _value*Math.Pow(0.3048, 4); - case AreaMomentOfInertiaUnit.InchToTheFourth: return _value*Math.Pow(2.54e-2, 4); - case AreaMomentOfInertiaUnit.MeterToTheFourth: return _value; - case AreaMomentOfInertiaUnit.MillimeterToTheFourth: return _value/1e12; + case AreaMomentOfInertiaUnit.CentimeterToTheFourth: + return new AreaMomentOfInertia(_value/1e8, BaseUnit); + case AreaMomentOfInertiaUnit.DecimeterToTheFourth: + return new AreaMomentOfInertia(_value/1e4, BaseUnit); + case AreaMomentOfInertiaUnit.FootToTheFourth: + return new AreaMomentOfInertia(_value*Math.Pow(0.3048, 4), BaseUnit); + case AreaMomentOfInertiaUnit.InchToTheFourth: + return new AreaMomentOfInertia(_value*Math.Pow(2.54e-2, 4), BaseUnit); + case AreaMomentOfInertiaUnit.MeterToTheFourth: + return new AreaMomentOfInertia(_value, BaseUnit); + case AreaMomentOfInertiaUnit.MillimeterToTheFourth: + return new AreaMomentOfInertia(_value/1e12, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -586,7 +592,8 @@ private double AsBaseNumericType(AreaMomentOfInertiaUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BitRate.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BitRate.WindowsRuntimeComponent.g.cs index 9f94b2b184..a083dd7b36 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BitRate.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BitRate.WindowsRuntimeComponent.g.cs @@ -869,36 +869,62 @@ public BitRate ToUnit(BitRateUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private decimal AsBaseUnit() + internal BitRate AsBaseUnit() { switch(Unit) { - case BitRateUnit.BitPerSecond: return _value; - case BitRateUnit.BytePerSecond: return _value*8m; - case BitRateUnit.ExabitPerSecond: return (_value) * 1e18m; - case BitRateUnit.ExabytePerSecond: return (_value*8m) * 1e18m; - case BitRateUnit.ExbibitPerSecond: return (_value) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024); - case BitRateUnit.ExbibytePerSecond: return (_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024); - case BitRateUnit.GibibitPerSecond: return (_value) * (1024m * 1024 * 1024); - case BitRateUnit.GibibytePerSecond: return (_value*8m) * (1024m * 1024 * 1024); - case BitRateUnit.GigabitPerSecond: return (_value) * 1e9m; - case BitRateUnit.GigabytePerSecond: return (_value*8m) * 1e9m; - case BitRateUnit.KibibitPerSecond: return (_value) * 1024m; - case BitRateUnit.KibibytePerSecond: return (_value*8m) * 1024m; - case BitRateUnit.KilobitPerSecond: return (_value) * 1e3m; - case BitRateUnit.KilobytePerSecond: return (_value*8m) * 1e3m; - case BitRateUnit.MebibitPerSecond: return (_value) * (1024m * 1024); - case BitRateUnit.MebibytePerSecond: return (_value*8m) * (1024m * 1024); - case BitRateUnit.MegabitPerSecond: return (_value) * 1e6m; - case BitRateUnit.MegabytePerSecond: return (_value*8m) * 1e6m; - case BitRateUnit.PebibitPerSecond: return (_value) * (1024m * 1024 * 1024 * 1024 * 1024); - case BitRateUnit.PebibytePerSecond: return (_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024); - case BitRateUnit.PetabitPerSecond: return (_value) * 1e15m; - case BitRateUnit.PetabytePerSecond: return (_value*8m) * 1e15m; - case BitRateUnit.TebibitPerSecond: return (_value) * (1024m * 1024 * 1024 * 1024); - case BitRateUnit.TebibytePerSecond: return (_value*8m) * (1024m * 1024 * 1024 * 1024); - case BitRateUnit.TerabitPerSecond: return (_value) * 1e12m; - case BitRateUnit.TerabytePerSecond: return (_value*8m) * 1e12m; + case BitRateUnit.BitPerSecond: + return new BitRate(_value, BaseUnit); + case BitRateUnit.BytePerSecond: + return new BitRate(_value*8m, BaseUnit); + case BitRateUnit.ExabitPerSecond: + return new BitRate((_value) * 1e18m, BaseUnit); + case BitRateUnit.ExabytePerSecond: + return new BitRate((_value*8m) * 1e18m, BaseUnit); + case BitRateUnit.ExbibitPerSecond: + return new BitRate((_value) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024), BaseUnit); + case BitRateUnit.ExbibytePerSecond: + return new BitRate((_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024), BaseUnit); + case BitRateUnit.GibibitPerSecond: + return new BitRate((_value) * (1024m * 1024 * 1024), BaseUnit); + case BitRateUnit.GibibytePerSecond: + return new BitRate((_value*8m) * (1024m * 1024 * 1024), BaseUnit); + case BitRateUnit.GigabitPerSecond: + return new BitRate((_value) * 1e9m, BaseUnit); + case BitRateUnit.GigabytePerSecond: + return new BitRate((_value*8m) * 1e9m, BaseUnit); + case BitRateUnit.KibibitPerSecond: + return new BitRate((_value) * 1024m, BaseUnit); + case BitRateUnit.KibibytePerSecond: + return new BitRate((_value*8m) * 1024m, BaseUnit); + case BitRateUnit.KilobitPerSecond: + return new BitRate((_value) * 1e3m, BaseUnit); + case BitRateUnit.KilobytePerSecond: + return new BitRate((_value*8m) * 1e3m, BaseUnit); + case BitRateUnit.MebibitPerSecond: + return new BitRate((_value) * (1024m * 1024), BaseUnit); + case BitRateUnit.MebibytePerSecond: + return new BitRate((_value*8m) * (1024m * 1024), BaseUnit); + case BitRateUnit.MegabitPerSecond: + return new BitRate((_value) * 1e6m, BaseUnit); + case BitRateUnit.MegabytePerSecond: + return new BitRate((_value*8m) * 1e6m, BaseUnit); + case BitRateUnit.PebibitPerSecond: + return new BitRate((_value) * (1024m * 1024 * 1024 * 1024 * 1024), BaseUnit); + case BitRateUnit.PebibytePerSecond: + return new BitRate((_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024), BaseUnit); + case BitRateUnit.PetabitPerSecond: + return new BitRate((_value) * 1e15m, BaseUnit); + case BitRateUnit.PetabytePerSecond: + return new BitRate((_value*8m) * 1e15m, BaseUnit); + case BitRateUnit.TebibitPerSecond: + return new BitRate((_value) * (1024m * 1024 * 1024 * 1024), BaseUnit); + case BitRateUnit.TebibytePerSecond: + return new BitRate((_value*8m) * (1024m * 1024 * 1024 * 1024), BaseUnit); + case BitRateUnit.TerabitPerSecond: + return new BitRate((_value) * 1e12m, BaseUnit); + case BitRateUnit.TerabytePerSecond: + return new BitRate((_value*8m) * 1e12m, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -909,7 +935,8 @@ private decimal AsBaseNumericType(BitRateUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.WindowsRuntimeComponent.g.cs index 7951122f05..14e9fea1db 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.WindowsRuntimeComponent.g.cs @@ -521,13 +521,16 @@ public BrakeSpecificFuelConsumption ToUnit(BrakeSpecificFuelConsumptionUnit unit /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal BrakeSpecificFuelConsumption AsBaseUnit() { switch(Unit) { - case BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour: return _value/3.6e9; - case BrakeSpecificFuelConsumptionUnit.KilogramPerJoule: return _value; - case BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour: return _value*1.689659410672e-7; + case BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour: + return new BrakeSpecificFuelConsumption(_value/3.6e9, BaseUnit); + case BrakeSpecificFuelConsumptionUnit.KilogramPerJoule: + return new BrakeSpecificFuelConsumption(_value, BaseUnit); + case BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour: + return new BrakeSpecificFuelConsumption(_value*1.689659410672e-7, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -538,7 +541,8 @@ private double AsBaseNumericType(BrakeSpecificFuelConsumptionUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Capacitance.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Capacitance.WindowsRuntimeComponent.g.cs index e3c5e0539c..ab3653b750 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Capacitance.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Capacitance.WindowsRuntimeComponent.g.cs @@ -584,17 +584,24 @@ public Capacitance ToUnit(CapacitanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Capacitance AsBaseUnit() { switch(Unit) { - case CapacitanceUnit.Farad: return _value; - case CapacitanceUnit.Kilofarad: return (_value) * 1e3d; - case CapacitanceUnit.Megafarad: return (_value) * 1e6d; - case CapacitanceUnit.Microfarad: return (_value) * 1e-6d; - case CapacitanceUnit.Millifarad: return (_value) * 1e-3d; - case CapacitanceUnit.Nanofarad: return (_value) * 1e-9d; - case CapacitanceUnit.Picofarad: return (_value) * 1e-12d; + case CapacitanceUnit.Farad: + return new Capacitance(_value, BaseUnit); + case CapacitanceUnit.Kilofarad: + return new Capacitance((_value) * 1e3d, BaseUnit); + case CapacitanceUnit.Megafarad: + return new Capacitance((_value) * 1e6d, BaseUnit); + case CapacitanceUnit.Microfarad: + return new Capacitance((_value) * 1e-6d, BaseUnit); + case CapacitanceUnit.Millifarad: + return new Capacitance((_value) * 1e-3d, BaseUnit); + case CapacitanceUnit.Nanofarad: + return new Capacitance((_value) * 1e-9d, BaseUnit); + case CapacitanceUnit.Picofarad: + return new Capacitance((_value) * 1e-12d, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -605,7 +612,8 @@ private double AsBaseNumericType(CapacitanceUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/CoefficientOfThermalExpansion.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/CoefficientOfThermalExpansion.WindowsRuntimeComponent.g.cs index 5fbf89f4fa..35ad844c76 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/CoefficientOfThermalExpansion.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/CoefficientOfThermalExpansion.WindowsRuntimeComponent.g.cs @@ -521,13 +521,16 @@ public CoefficientOfThermalExpansion ToUnit(CoefficientOfThermalExpansionUnit un /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal CoefficientOfThermalExpansion AsBaseUnit() { switch(Unit) { - case CoefficientOfThermalExpansionUnit.InverseDegreeCelsius: return _value; - case CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit: return _value*5/9; - case CoefficientOfThermalExpansionUnit.InverseKelvin: return _value; + case CoefficientOfThermalExpansionUnit.InverseDegreeCelsius: + return new CoefficientOfThermalExpansion(_value, BaseUnit); + case CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit: + return new CoefficientOfThermalExpansion(_value*5/9, BaseUnit); + case CoefficientOfThermalExpansionUnit.InverseKelvin: + return new CoefficientOfThermalExpansion(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -538,7 +541,8 @@ private double AsBaseNumericType(CoefficientOfThermalExpansionUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Density.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Density.WindowsRuntimeComponent.g.cs index e0e50bf45c..1488b6b381 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Density.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Density.WindowsRuntimeComponent.g.cs @@ -1064,49 +1064,88 @@ public Density ToUnit(DensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Density AsBaseUnit() { switch(Unit) { - case DensityUnit.CentigramPerDeciliter: return (_value/1e-1) * 1e-2d; - case DensityUnit.CentigramPerLiter: return (_value/1) * 1e-2d; - case DensityUnit.CentigramPerMilliliter: return (_value/1e-3) * 1e-2d; - case DensityUnit.DecigramPerDeciliter: return (_value/1e-1) * 1e-1d; - case DensityUnit.DecigramPerLiter: return (_value/1) * 1e-1d; - case DensityUnit.DecigramPerMilliliter: return (_value/1e-3) * 1e-1d; - case DensityUnit.GramPerCubicCentimeter: return _value/1e-3; - case DensityUnit.GramPerCubicMeter: return _value/1e3; - case DensityUnit.GramPerCubicMillimeter: return _value/1e-6; - case DensityUnit.GramPerDeciliter: return _value/1e-1; - case DensityUnit.GramPerLiter: return _value/1; - case DensityUnit.GramPerMilliliter: return _value/1e-3; - case DensityUnit.KilogramPerCubicCentimeter: return (_value/1e-3) * 1e3d; - case DensityUnit.KilogramPerCubicMeter: return (_value/1e3) * 1e3d; - case DensityUnit.KilogramPerCubicMillimeter: return (_value/1e-6) * 1e3d; - case DensityUnit.KilopoundPerCubicFoot: return (_value/0.062427961) * 1e3d; - case DensityUnit.KilopoundPerCubicInch: return (_value/3.6127298147753e-5) * 1e3d; - case DensityUnit.MicrogramPerCubicMeter: return (_value/1e3) * 1e-6d; - case DensityUnit.MicrogramPerDeciliter: return (_value/1e-1) * 1e-6d; - case DensityUnit.MicrogramPerLiter: return (_value/1) * 1e-6d; - case DensityUnit.MicrogramPerMilliliter: return (_value/1e-3) * 1e-6d; - case DensityUnit.MilligramPerCubicMeter: return (_value/1e3) * 1e-3d; - case DensityUnit.MilligramPerDeciliter: return (_value/1e-1) * 1e-3d; - case DensityUnit.MilligramPerLiter: return (_value/1) * 1e-3d; - case DensityUnit.MilligramPerMilliliter: return (_value/1e-3) * 1e-3d; - case DensityUnit.NanogramPerDeciliter: return (_value/1e-1) * 1e-9d; - case DensityUnit.NanogramPerLiter: return (_value/1) * 1e-9d; - case DensityUnit.NanogramPerMilliliter: return (_value/1e-3) * 1e-9d; - case DensityUnit.PicogramPerDeciliter: return (_value/1e-1) * 1e-12d; - case DensityUnit.PicogramPerLiter: return (_value/1) * 1e-12d; - case DensityUnit.PicogramPerMilliliter: return (_value/1e-3) * 1e-12d; - case DensityUnit.PoundPerCubicFoot: return _value/0.062427961; - case DensityUnit.PoundPerCubicInch: return _value/3.6127298147753e-5; - case DensityUnit.PoundPerImperialGallon: return _value*9.9776398e1; - case DensityUnit.PoundPerUSGallon: return _value*1.19826427e2; - case DensityUnit.SlugPerCubicFoot: return _value*515.378818; - case DensityUnit.TonnePerCubicCentimeter: return _value/1e-9; - case DensityUnit.TonnePerCubicMeter: return _value/0.001; - case DensityUnit.TonnePerCubicMillimeter: return _value/1e-12; + case DensityUnit.CentigramPerDeciliter: + return new Density((_value/1e-1) * 1e-2d, BaseUnit); + case DensityUnit.CentigramPerLiter: + return new Density((_value/1) * 1e-2d, BaseUnit); + case DensityUnit.CentigramPerMilliliter: + return new Density((_value/1e-3) * 1e-2d, BaseUnit); + case DensityUnit.DecigramPerDeciliter: + return new Density((_value/1e-1) * 1e-1d, BaseUnit); + case DensityUnit.DecigramPerLiter: + return new Density((_value/1) * 1e-1d, BaseUnit); + case DensityUnit.DecigramPerMilliliter: + return new Density((_value/1e-3) * 1e-1d, BaseUnit); + case DensityUnit.GramPerCubicCentimeter: + return new Density(_value/1e-3, BaseUnit); + case DensityUnit.GramPerCubicMeter: + return new Density(_value/1e3, BaseUnit); + case DensityUnit.GramPerCubicMillimeter: + return new Density(_value/1e-6, BaseUnit); + case DensityUnit.GramPerDeciliter: + return new Density(_value/1e-1, BaseUnit); + case DensityUnit.GramPerLiter: + return new Density(_value/1, BaseUnit); + case DensityUnit.GramPerMilliliter: + return new Density(_value/1e-3, BaseUnit); + case DensityUnit.KilogramPerCubicCentimeter: + return new Density((_value/1e-3) * 1e3d, BaseUnit); + case DensityUnit.KilogramPerCubicMeter: + return new Density((_value/1e3) * 1e3d, BaseUnit); + case DensityUnit.KilogramPerCubicMillimeter: + return new Density((_value/1e-6) * 1e3d, BaseUnit); + case DensityUnit.KilopoundPerCubicFoot: + return new Density((_value/0.062427961) * 1e3d, BaseUnit); + case DensityUnit.KilopoundPerCubicInch: + return new Density((_value/3.6127298147753e-5) * 1e3d, BaseUnit); + case DensityUnit.MicrogramPerCubicMeter: + return new Density((_value/1e3) * 1e-6d, BaseUnit); + case DensityUnit.MicrogramPerDeciliter: + return new Density((_value/1e-1) * 1e-6d, BaseUnit); + case DensityUnit.MicrogramPerLiter: + return new Density((_value/1) * 1e-6d, BaseUnit); + case DensityUnit.MicrogramPerMilliliter: + return new Density((_value/1e-3) * 1e-6d, BaseUnit); + case DensityUnit.MilligramPerCubicMeter: + return new Density((_value/1e3) * 1e-3d, BaseUnit); + case DensityUnit.MilligramPerDeciliter: + return new Density((_value/1e-1) * 1e-3d, BaseUnit); + case DensityUnit.MilligramPerLiter: + return new Density((_value/1) * 1e-3d, BaseUnit); + case DensityUnit.MilligramPerMilliliter: + return new Density((_value/1e-3) * 1e-3d, BaseUnit); + case DensityUnit.NanogramPerDeciliter: + return new Density((_value/1e-1) * 1e-9d, BaseUnit); + case DensityUnit.NanogramPerLiter: + return new Density((_value/1) * 1e-9d, BaseUnit); + case DensityUnit.NanogramPerMilliliter: + return new Density((_value/1e-3) * 1e-9d, BaseUnit); + case DensityUnit.PicogramPerDeciliter: + return new Density((_value/1e-1) * 1e-12d, BaseUnit); + case DensityUnit.PicogramPerLiter: + return new Density((_value/1) * 1e-12d, BaseUnit); + case DensityUnit.PicogramPerMilliliter: + return new Density((_value/1e-3) * 1e-12d, BaseUnit); + case DensityUnit.PoundPerCubicFoot: + return new Density(_value/0.062427961, BaseUnit); + case DensityUnit.PoundPerCubicInch: + return new Density(_value/3.6127298147753e-5, BaseUnit); + case DensityUnit.PoundPerImperialGallon: + return new Density(_value*9.9776398e1, BaseUnit); + case DensityUnit.PoundPerUSGallon: + return new Density(_value*1.19826427e2, BaseUnit); + case DensityUnit.SlugPerCubicFoot: + return new Density(_value*515.378818, BaseUnit); + case DensityUnit.TonnePerCubicCentimeter: + return new Density(_value/1e-9, BaseUnit); + case DensityUnit.TonnePerCubicMeter: + return new Density(_value/0.001, BaseUnit); + case DensityUnit.TonnePerCubicMillimeter: + return new Density(_value/1e-12, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -1117,7 +1156,8 @@ private double AsBaseNumericType(DensityUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Duration.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Duration.WindowsRuntimeComponent.g.cs index e57ea85bbd..8cc701f276 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Duration.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Duration.WindowsRuntimeComponent.g.cs @@ -626,20 +626,30 @@ public Duration ToUnit(DurationUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Duration AsBaseUnit() { switch(Unit) { - case DurationUnit.Day: return _value*24*3600; - case DurationUnit.Hour: return _value*3600; - case DurationUnit.Microsecond: return (_value) * 1e-6d; - case DurationUnit.Millisecond: return (_value) * 1e-3d; - case DurationUnit.Minute: return _value*60; - case DurationUnit.Month30: return _value*30*24*3600; - case DurationUnit.Nanosecond: return (_value) * 1e-9d; - case DurationUnit.Second: return _value; - case DurationUnit.Week: return _value*7*24*3600; - case DurationUnit.Year365: return _value*365*24*3600; + case DurationUnit.Day: + return new Duration(_value*24*3600, BaseUnit); + case DurationUnit.Hour: + return new Duration(_value*3600, BaseUnit); + case DurationUnit.Microsecond: + return new Duration((_value) * 1e-6d, BaseUnit); + case DurationUnit.Millisecond: + return new Duration((_value) * 1e-3d, BaseUnit); + case DurationUnit.Minute: + return new Duration(_value*60, BaseUnit); + case DurationUnit.Month30: + return new Duration(_value*30*24*3600, BaseUnit); + case DurationUnit.Nanosecond: + return new Duration((_value) * 1e-9d, BaseUnit); + case DurationUnit.Second: + return new Duration(_value, BaseUnit); + case DurationUnit.Week: + return new Duration(_value*7*24*3600, BaseUnit); + case DurationUnit.Year365: + return new Duration(_value*365*24*3600, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -650,7 +660,8 @@ private double AsBaseNumericType(DurationUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/DynamicViscosity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/DynamicViscosity.WindowsRuntimeComponent.g.cs index 20534fd15c..53802949db 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/DynamicViscosity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/DynamicViscosity.WindowsRuntimeComponent.g.cs @@ -569,16 +569,22 @@ public DynamicViscosity ToUnit(DynamicViscosityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal DynamicViscosity AsBaseUnit() { switch(Unit) { - case DynamicViscosityUnit.Centipoise: return (_value/10) * 1e-2d; - case DynamicViscosityUnit.MicropascalSecond: return (_value) * 1e-6d; - case DynamicViscosityUnit.MillipascalSecond: return (_value) * 1e-3d; - case DynamicViscosityUnit.NewtonSecondPerMeterSquared: return _value; - case DynamicViscosityUnit.PascalSecond: return _value; - case DynamicViscosityUnit.Poise: return _value/10; + case DynamicViscosityUnit.Centipoise: + return new DynamicViscosity((_value/10) * 1e-2d, BaseUnit); + case DynamicViscosityUnit.MicropascalSecond: + return new DynamicViscosity((_value) * 1e-6d, BaseUnit); + case DynamicViscosityUnit.MillipascalSecond: + return new DynamicViscosity((_value) * 1e-3d, BaseUnit); + case DynamicViscosityUnit.NewtonSecondPerMeterSquared: + return new DynamicViscosity(_value, BaseUnit); + case DynamicViscosityUnit.PascalSecond: + return new DynamicViscosity(_value, BaseUnit); + case DynamicViscosityUnit.Poise: + return new DynamicViscosity(_value/10, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -589,7 +595,8 @@ private double AsBaseNumericType(DynamicViscosityUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricAdmittance.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricAdmittance.WindowsRuntimeComponent.g.cs index f22a5da97d..ae0bba44f1 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricAdmittance.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricAdmittance.WindowsRuntimeComponent.g.cs @@ -536,14 +536,18 @@ public ElectricAdmittance ToUnit(ElectricAdmittanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ElectricAdmittance AsBaseUnit() { switch(Unit) { - case ElectricAdmittanceUnit.Microsiemens: return (_value) * 1e-6d; - case ElectricAdmittanceUnit.Millisiemens: return (_value) * 1e-3d; - case ElectricAdmittanceUnit.Nanosiemens: return (_value) * 1e-9d; - case ElectricAdmittanceUnit.Siemens: return _value; + case ElectricAdmittanceUnit.Microsiemens: + return new ElectricAdmittance((_value) * 1e-6d, BaseUnit); + case ElectricAdmittanceUnit.Millisiemens: + return new ElectricAdmittance((_value) * 1e-3d, BaseUnit); + case ElectricAdmittanceUnit.Nanosiemens: + return new ElectricAdmittance((_value) * 1e-9d, BaseUnit); + case ElectricAdmittanceUnit.Siemens: + return new ElectricAdmittance(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -554,7 +558,8 @@ private double AsBaseNumericType(ElectricAdmittanceUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCharge.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCharge.WindowsRuntimeComponent.g.cs index bb6f5726f4..afe3e662e1 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCharge.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCharge.WindowsRuntimeComponent.g.cs @@ -494,11 +494,12 @@ public ElectricCharge ToUnit(ElectricChargeUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ElectricCharge AsBaseUnit() { switch(Unit) { - case ElectricChargeUnit.Coulomb: return _value; + case ElectricChargeUnit.Coulomb: + return new ElectricCharge(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -509,7 +510,8 @@ private double AsBaseNumericType(ElectricChargeUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricChargeDensity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricChargeDensity.WindowsRuntimeComponent.g.cs index 1bc6aa4bd2..d3d6c3b2e8 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricChargeDensity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricChargeDensity.WindowsRuntimeComponent.g.cs @@ -494,11 +494,12 @@ public ElectricChargeDensity ToUnit(ElectricChargeDensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ElectricChargeDensity AsBaseUnit() { switch(Unit) { - case ElectricChargeDensityUnit.CoulombPerCubicMeter: return _value; + case ElectricChargeDensityUnit.CoulombPerCubicMeter: + return new ElectricChargeDensity(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -509,7 +510,8 @@ private double AsBaseNumericType(ElectricChargeDensityUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductance.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductance.WindowsRuntimeComponent.g.cs index a8ea454d26..fdacb57502 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductance.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductance.WindowsRuntimeComponent.g.cs @@ -524,13 +524,16 @@ public ElectricConductance ToUnit(ElectricConductanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ElectricConductance AsBaseUnit() { switch(Unit) { - case ElectricConductanceUnit.Microsiemens: return (_value) * 1e-6d; - case ElectricConductanceUnit.Millisiemens: return (_value) * 1e-3d; - case ElectricConductanceUnit.Siemens: return _value; + case ElectricConductanceUnit.Microsiemens: + return new ElectricConductance((_value) * 1e-6d, BaseUnit); + case ElectricConductanceUnit.Millisiemens: + return new ElectricConductance((_value) * 1e-3d, BaseUnit); + case ElectricConductanceUnit.Siemens: + return new ElectricConductance(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -541,7 +544,8 @@ private double AsBaseNumericType(ElectricConductanceUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductivity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductivity.WindowsRuntimeComponent.g.cs index 843805c29e..882618e4bf 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductivity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductivity.WindowsRuntimeComponent.g.cs @@ -494,11 +494,12 @@ public ElectricConductivity ToUnit(ElectricConductivityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ElectricConductivity AsBaseUnit() { switch(Unit) { - case ElectricConductivityUnit.SiemensPerMeter: return _value; + case ElectricConductivityUnit.SiemensPerMeter: + return new ElectricConductivity(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -509,7 +510,8 @@ private double AsBaseNumericType(ElectricConductivityUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrent.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrent.WindowsRuntimeComponent.g.cs index 31c19ff2db..7b9e4efde3 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrent.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrent.WindowsRuntimeComponent.g.cs @@ -596,18 +596,26 @@ public ElectricCurrent ToUnit(ElectricCurrentUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ElectricCurrent AsBaseUnit() { switch(Unit) { - case ElectricCurrentUnit.Ampere: return _value; - case ElectricCurrentUnit.Centiampere: return (_value) * 1e-2d; - case ElectricCurrentUnit.Kiloampere: return (_value) * 1e3d; - case ElectricCurrentUnit.Megaampere: return (_value) * 1e6d; - case ElectricCurrentUnit.Microampere: return (_value) * 1e-6d; - case ElectricCurrentUnit.Milliampere: return (_value) * 1e-3d; - case ElectricCurrentUnit.Nanoampere: return (_value) * 1e-9d; - case ElectricCurrentUnit.Picoampere: return (_value) * 1e-12d; + case ElectricCurrentUnit.Ampere: + return new ElectricCurrent(_value, BaseUnit); + case ElectricCurrentUnit.Centiampere: + return new ElectricCurrent((_value) * 1e-2d, BaseUnit); + case ElectricCurrentUnit.Kiloampere: + return new ElectricCurrent((_value) * 1e3d, BaseUnit); + case ElectricCurrentUnit.Megaampere: + return new ElectricCurrent((_value) * 1e6d, BaseUnit); + case ElectricCurrentUnit.Microampere: + return new ElectricCurrent((_value) * 1e-6d, BaseUnit); + case ElectricCurrentUnit.Milliampere: + return new ElectricCurrent((_value) * 1e-3d, BaseUnit); + case ElectricCurrentUnit.Nanoampere: + return new ElectricCurrent((_value) * 1e-9d, BaseUnit); + case ElectricCurrentUnit.Picoampere: + return new ElectricCurrent((_value) * 1e-12d, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -618,7 +626,8 @@ private double AsBaseNumericType(ElectricCurrentUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentDensity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentDensity.WindowsRuntimeComponent.g.cs index ba1566386b..b5d5af7b1c 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentDensity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentDensity.WindowsRuntimeComponent.g.cs @@ -494,11 +494,12 @@ public ElectricCurrentDensity ToUnit(ElectricCurrentDensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ElectricCurrentDensity AsBaseUnit() { switch(Unit) { - case ElectricCurrentDensityUnit.AmperePerSquareMeter: return _value; + case ElectricCurrentDensityUnit.AmperePerSquareMeter: + return new ElectricCurrentDensity(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -509,7 +510,8 @@ private double AsBaseNumericType(ElectricCurrentDensityUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentGradient.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentGradient.WindowsRuntimeComponent.g.cs index 79a90f05ca..32f5a1fa01 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentGradient.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentGradient.WindowsRuntimeComponent.g.cs @@ -491,11 +491,12 @@ public ElectricCurrentGradient ToUnit(ElectricCurrentGradientUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ElectricCurrentGradient AsBaseUnit() { switch(Unit) { - case ElectricCurrentGradientUnit.AmperePerSecond: return _value; + case ElectricCurrentGradientUnit.AmperePerSecond: + return new ElectricCurrentGradient(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -506,7 +507,8 @@ private double AsBaseNumericType(ElectricCurrentGradientUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricField.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricField.WindowsRuntimeComponent.g.cs index 758928d9bf..9232262da4 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricField.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricField.WindowsRuntimeComponent.g.cs @@ -494,11 +494,12 @@ public ElectricField ToUnit(ElectricFieldUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ElectricField AsBaseUnit() { switch(Unit) { - case ElectricFieldUnit.VoltPerMeter: return _value; + case ElectricFieldUnit.VoltPerMeter: + return new ElectricField(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -509,7 +510,8 @@ private double AsBaseNumericType(ElectricFieldUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricInductance.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricInductance.WindowsRuntimeComponent.g.cs index 6fee355e37..85808f06f6 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricInductance.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricInductance.WindowsRuntimeComponent.g.cs @@ -539,14 +539,18 @@ public ElectricInductance ToUnit(ElectricInductanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ElectricInductance AsBaseUnit() { switch(Unit) { - case ElectricInductanceUnit.Henry: return _value; - case ElectricInductanceUnit.Microhenry: return (_value) * 1e-6d; - case ElectricInductanceUnit.Millihenry: return (_value) * 1e-3d; - case ElectricInductanceUnit.Nanohenry: return (_value) * 1e-9d; + case ElectricInductanceUnit.Henry: + return new ElectricInductance(_value, BaseUnit); + case ElectricInductanceUnit.Microhenry: + return new ElectricInductance((_value) * 1e-6d, BaseUnit); + case ElectricInductanceUnit.Millihenry: + return new ElectricInductance((_value) * 1e-3d, BaseUnit); + case ElectricInductanceUnit.Nanohenry: + return new ElectricInductance((_value) * 1e-9d, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -557,7 +561,8 @@ private double AsBaseNumericType(ElectricInductanceUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotential.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotential.WindowsRuntimeComponent.g.cs index 546af6e12b..a75690004d 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotential.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotential.WindowsRuntimeComponent.g.cs @@ -551,15 +551,20 @@ public ElectricPotential ToUnit(ElectricPotentialUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ElectricPotential AsBaseUnit() { switch(Unit) { - case ElectricPotentialUnit.Kilovolt: return (_value) * 1e3d; - case ElectricPotentialUnit.Megavolt: return (_value) * 1e6d; - case ElectricPotentialUnit.Microvolt: return (_value) * 1e-6d; - case ElectricPotentialUnit.Millivolt: return (_value) * 1e-3d; - case ElectricPotentialUnit.Volt: return _value; + case ElectricPotentialUnit.Kilovolt: + return new ElectricPotential((_value) * 1e3d, BaseUnit); + case ElectricPotentialUnit.Megavolt: + return new ElectricPotential((_value) * 1e6d, BaseUnit); + case ElectricPotentialUnit.Microvolt: + return new ElectricPotential((_value) * 1e-6d, BaseUnit); + case ElectricPotentialUnit.Millivolt: + return new ElectricPotential((_value) * 1e-3d, BaseUnit); + case ElectricPotentialUnit.Volt: + return new ElectricPotential(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -570,7 +575,8 @@ private double AsBaseNumericType(ElectricPotentialUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialAc.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialAc.WindowsRuntimeComponent.g.cs index 153a1e0aa2..cd672a8021 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialAc.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialAc.WindowsRuntimeComponent.g.cs @@ -551,15 +551,20 @@ public ElectricPotentialAc ToUnit(ElectricPotentialAcUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ElectricPotentialAc AsBaseUnit() { switch(Unit) { - case ElectricPotentialAcUnit.KilovoltAc: return (_value) * 1e3d; - case ElectricPotentialAcUnit.MegavoltAc: return (_value) * 1e6d; - case ElectricPotentialAcUnit.MicrovoltAc: return (_value) * 1e-6d; - case ElectricPotentialAcUnit.MillivoltAc: return (_value) * 1e-3d; - case ElectricPotentialAcUnit.VoltAc: return _value; + case ElectricPotentialAcUnit.KilovoltAc: + return new ElectricPotentialAc((_value) * 1e3d, BaseUnit); + case ElectricPotentialAcUnit.MegavoltAc: + return new ElectricPotentialAc((_value) * 1e6d, BaseUnit); + case ElectricPotentialAcUnit.MicrovoltAc: + return new ElectricPotentialAc((_value) * 1e-6d, BaseUnit); + case ElectricPotentialAcUnit.MillivoltAc: + return new ElectricPotentialAc((_value) * 1e-3d, BaseUnit); + case ElectricPotentialAcUnit.VoltAc: + return new ElectricPotentialAc(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -570,7 +575,8 @@ private double AsBaseNumericType(ElectricPotentialAcUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialDc.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialDc.WindowsRuntimeComponent.g.cs index adf9532fd1..75259bcb7d 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialDc.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialDc.WindowsRuntimeComponent.g.cs @@ -551,15 +551,20 @@ public ElectricPotentialDc ToUnit(ElectricPotentialDcUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ElectricPotentialDc AsBaseUnit() { switch(Unit) { - case ElectricPotentialDcUnit.KilovoltDc: return (_value) * 1e3d; - case ElectricPotentialDcUnit.MegavoltDc: return (_value) * 1e6d; - case ElectricPotentialDcUnit.MicrovoltDc: return (_value) * 1e-6d; - case ElectricPotentialDcUnit.MillivoltDc: return (_value) * 1e-3d; - case ElectricPotentialDcUnit.VoltDc: return _value; + case ElectricPotentialDcUnit.KilovoltDc: + return new ElectricPotentialDc((_value) * 1e3d, BaseUnit); + case ElectricPotentialDcUnit.MegavoltDc: + return new ElectricPotentialDc((_value) * 1e6d, BaseUnit); + case ElectricPotentialDcUnit.MicrovoltDc: + return new ElectricPotentialDc((_value) * 1e-6d, BaseUnit); + case ElectricPotentialDcUnit.MillivoltDc: + return new ElectricPotentialDc((_value) * 1e-3d, BaseUnit); + case ElectricPotentialDcUnit.VoltDc: + return new ElectricPotentialDc(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -570,7 +575,8 @@ private double AsBaseNumericType(ElectricPotentialDcUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistance.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistance.WindowsRuntimeComponent.g.cs index 3784856cea..87b43bf943 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistance.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistance.WindowsRuntimeComponent.g.cs @@ -551,15 +551,20 @@ public ElectricResistance ToUnit(ElectricResistanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ElectricResistance AsBaseUnit() { switch(Unit) { - case ElectricResistanceUnit.Gigaohm: return (_value) * 1e9d; - case ElectricResistanceUnit.Kiloohm: return (_value) * 1e3d; - case ElectricResistanceUnit.Megaohm: return (_value) * 1e6d; - case ElectricResistanceUnit.Milliohm: return (_value) * 1e-3d; - case ElectricResistanceUnit.Ohm: return _value; + case ElectricResistanceUnit.Gigaohm: + return new ElectricResistance((_value) * 1e9d, BaseUnit); + case ElectricResistanceUnit.Kiloohm: + return new ElectricResistance((_value) * 1e3d, BaseUnit); + case ElectricResistanceUnit.Megaohm: + return new ElectricResistance((_value) * 1e6d, BaseUnit); + case ElectricResistanceUnit.Milliohm: + return new ElectricResistance((_value) * 1e-3d, BaseUnit); + case ElectricResistanceUnit.Ohm: + return new ElectricResistance(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -570,7 +575,8 @@ private double AsBaseNumericType(ElectricResistanceUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistivity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistivity.WindowsRuntimeComponent.g.cs index 48a115c831..4e13b4d07a 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistivity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistivity.WindowsRuntimeComponent.g.cs @@ -689,24 +689,38 @@ public ElectricResistivity ToUnit(ElectricResistivityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ElectricResistivity AsBaseUnit() { switch(Unit) { - case ElectricResistivityUnit.KiloohmCentimeter: return (_value/100) * 1e3d; - case ElectricResistivityUnit.KiloohmMeter: return (_value) * 1e3d; - case ElectricResistivityUnit.MegaohmCentimeter: return (_value/100) * 1e6d; - case ElectricResistivityUnit.MegaohmMeter: return (_value) * 1e6d; - case ElectricResistivityUnit.MicroohmCentimeter: return (_value/100) * 1e-6d; - case ElectricResistivityUnit.MicroohmMeter: return (_value) * 1e-6d; - case ElectricResistivityUnit.MilliohmCentimeter: return (_value/100) * 1e-3d; - case ElectricResistivityUnit.MilliohmMeter: return (_value) * 1e-3d; - case ElectricResistivityUnit.NanoohmCentimeter: return (_value/100) * 1e-9d; - case ElectricResistivityUnit.NanoohmMeter: return (_value) * 1e-9d; - case ElectricResistivityUnit.OhmCentimeter: return _value/100; - case ElectricResistivityUnit.OhmMeter: return _value; - case ElectricResistivityUnit.PicoohmCentimeter: return (_value/100) * 1e-12d; - case ElectricResistivityUnit.PicoohmMeter: return (_value) * 1e-12d; + case ElectricResistivityUnit.KiloohmCentimeter: + return new ElectricResistivity((_value/100) * 1e3d, BaseUnit); + case ElectricResistivityUnit.KiloohmMeter: + return new ElectricResistivity((_value) * 1e3d, BaseUnit); + case ElectricResistivityUnit.MegaohmCentimeter: + return new ElectricResistivity((_value/100) * 1e6d, BaseUnit); + case ElectricResistivityUnit.MegaohmMeter: + return new ElectricResistivity((_value) * 1e6d, BaseUnit); + case ElectricResistivityUnit.MicroohmCentimeter: + return new ElectricResistivity((_value/100) * 1e-6d, BaseUnit); + case ElectricResistivityUnit.MicroohmMeter: + return new ElectricResistivity((_value) * 1e-6d, BaseUnit); + case ElectricResistivityUnit.MilliohmCentimeter: + return new ElectricResistivity((_value/100) * 1e-3d, BaseUnit); + case ElectricResistivityUnit.MilliohmMeter: + return new ElectricResistivity((_value) * 1e-3d, BaseUnit); + case ElectricResistivityUnit.NanoohmCentimeter: + return new ElectricResistivity((_value/100) * 1e-9d, BaseUnit); + case ElectricResistivityUnit.NanoohmMeter: + return new ElectricResistivity((_value) * 1e-9d, BaseUnit); + case ElectricResistivityUnit.OhmCentimeter: + return new ElectricResistivity(_value/100, BaseUnit); + case ElectricResistivityUnit.OhmMeter: + return new ElectricResistivity(_value, BaseUnit); + case ElectricResistivityUnit.PicoohmCentimeter: + return new ElectricResistivity((_value/100) * 1e-12d, BaseUnit); + case ElectricResistivityUnit.PicoohmMeter: + return new ElectricResistivity((_value) * 1e-12d, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -717,7 +731,8 @@ private double AsBaseNumericType(ElectricResistivityUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Energy.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Energy.WindowsRuntimeComponent.g.cs index 6003594404..ae66713ee1 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Energy.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Energy.WindowsRuntimeComponent.g.cs @@ -806,32 +806,54 @@ public Energy ToUnit(EnergyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Energy AsBaseUnit() { switch(Unit) { - case EnergyUnit.BritishThermalUnit: return _value*1055.05585262; - case EnergyUnit.Calorie: return _value*4.184; - case EnergyUnit.DecathermEc: return (_value*1.05505585262e8) * 1e1d; - case EnergyUnit.DecathermImperial: return (_value*1.05505585257348e8) * 1e1d; - case EnergyUnit.DecathermUs: return (_value*1.054804e8) * 1e1d; - case EnergyUnit.ElectronVolt: return _value*1.602176565e-19; - case EnergyUnit.Erg: return _value*1e-7; - case EnergyUnit.FootPound: return _value*1.355817948; - case EnergyUnit.GigabritishThermalUnit: return (_value*1055.05585262) * 1e9d; - case EnergyUnit.GigawattHour: return (_value*3600d) * 1e9d; - case EnergyUnit.Joule: return _value; - case EnergyUnit.KilobritishThermalUnit: return (_value*1055.05585262) * 1e3d; - case EnergyUnit.Kilocalorie: return (_value*4.184) * 1e3d; - case EnergyUnit.Kilojoule: return (_value) * 1e3d; - case EnergyUnit.KilowattHour: return (_value*3600d) * 1e3d; - case EnergyUnit.MegabritishThermalUnit: return (_value*1055.05585262) * 1e6d; - case EnergyUnit.Megajoule: return (_value) * 1e6d; - case EnergyUnit.MegawattHour: return (_value*3600d) * 1e6d; - case EnergyUnit.ThermEc: return _value*1.05505585262e8; - case EnergyUnit.ThermImperial: return _value*1.05505585257348e8; - case EnergyUnit.ThermUs: return _value*1.054804e8; - case EnergyUnit.WattHour: return _value*3600d; + case EnergyUnit.BritishThermalUnit: + return new Energy(_value*1055.05585262, BaseUnit); + case EnergyUnit.Calorie: + return new Energy(_value*4.184, BaseUnit); + case EnergyUnit.DecathermEc: + return new Energy((_value*1.05505585262e8) * 1e1d, BaseUnit); + case EnergyUnit.DecathermImperial: + return new Energy((_value*1.05505585257348e8) * 1e1d, BaseUnit); + case EnergyUnit.DecathermUs: + return new Energy((_value*1.054804e8) * 1e1d, BaseUnit); + case EnergyUnit.ElectronVolt: + return new Energy(_value*1.602176565e-19, BaseUnit); + case EnergyUnit.Erg: + return new Energy(_value*1e-7, BaseUnit); + case EnergyUnit.FootPound: + return new Energy(_value*1.355817948, BaseUnit); + case EnergyUnit.GigabritishThermalUnit: + return new Energy((_value*1055.05585262) * 1e9d, BaseUnit); + case EnergyUnit.GigawattHour: + return new Energy((_value*3600d) * 1e9d, BaseUnit); + case EnergyUnit.Joule: + return new Energy(_value, BaseUnit); + case EnergyUnit.KilobritishThermalUnit: + return new Energy((_value*1055.05585262) * 1e3d, BaseUnit); + case EnergyUnit.Kilocalorie: + return new Energy((_value*4.184) * 1e3d, BaseUnit); + case EnergyUnit.Kilojoule: + return new Energy((_value) * 1e3d, BaseUnit); + case EnergyUnit.KilowattHour: + return new Energy((_value*3600d) * 1e3d, BaseUnit); + case EnergyUnit.MegabritishThermalUnit: + return new Energy((_value*1055.05585262) * 1e6d, BaseUnit); + case EnergyUnit.Megajoule: + return new Energy((_value) * 1e6d, BaseUnit); + case EnergyUnit.MegawattHour: + return new Energy((_value*3600d) * 1e6d, BaseUnit); + case EnergyUnit.ThermEc: + return new Energy(_value*1.05505585262e8, BaseUnit); + case EnergyUnit.ThermImperial: + return new Energy(_value*1.05505585257348e8, BaseUnit); + case EnergyUnit.ThermUs: + return new Energy(_value*1.054804e8, BaseUnit); + case EnergyUnit.WattHour: + return new Energy(_value*3600d, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -842,7 +864,8 @@ private double AsBaseNumericType(EnergyUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Entropy.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Entropy.WindowsRuntimeComponent.g.cs index 3bb85a46fd..aa0393c7da 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Entropy.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Entropy.WindowsRuntimeComponent.g.cs @@ -581,17 +581,24 @@ public Entropy ToUnit(EntropyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Entropy AsBaseUnit() { switch(Unit) { - case EntropyUnit.CaloriePerKelvin: return _value*4.184; - case EntropyUnit.JoulePerDegreeCelsius: return _value; - case EntropyUnit.JoulePerKelvin: return _value; - case EntropyUnit.KilocaloriePerKelvin: return (_value*4.184) * 1e3d; - case EntropyUnit.KilojoulePerDegreeCelsius: return (_value) * 1e3d; - case EntropyUnit.KilojoulePerKelvin: return (_value) * 1e3d; - case EntropyUnit.MegajoulePerKelvin: return (_value) * 1e6d; + case EntropyUnit.CaloriePerKelvin: + return new Entropy(_value*4.184, BaseUnit); + case EntropyUnit.JoulePerDegreeCelsius: + return new Entropy(_value, BaseUnit); + case EntropyUnit.JoulePerKelvin: + return new Entropy(_value, BaseUnit); + case EntropyUnit.KilocaloriePerKelvin: + return new Entropy((_value*4.184) * 1e3d, BaseUnit); + case EntropyUnit.KilojoulePerDegreeCelsius: + return new Entropy((_value) * 1e3d, BaseUnit); + case EntropyUnit.KilojoulePerKelvin: + return new Entropy((_value) * 1e3d, BaseUnit); + case EntropyUnit.MegajoulePerKelvin: + return new Entropy((_value) * 1e6d, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -602,7 +609,8 @@ private double AsBaseNumericType(EntropyUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Force.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Force.WindowsRuntimeComponent.g.cs index f681bc23b8..45c6b1065a 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Force.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Force.WindowsRuntimeComponent.g.cs @@ -671,23 +671,36 @@ public Force ToUnit(ForceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Force AsBaseUnit() { switch(Unit) { - case ForceUnit.Decanewton: return (_value) * 1e1d; - case ForceUnit.Dyn: return _value/1e5; - case ForceUnit.KilogramForce: return _value*9.80665002864; - case ForceUnit.Kilonewton: return (_value) * 1e3d; - case ForceUnit.KiloPond: return _value*9.80665002864; - case ForceUnit.Meganewton: return (_value) * 1e6d; - case ForceUnit.Micronewton: return (_value) * 1e-6d; - case ForceUnit.Millinewton: return (_value) * 1e-3d; - case ForceUnit.Newton: return _value; - case ForceUnit.OunceForce: return _value*2.780138509537812e-1; - case ForceUnit.Poundal: return _value*0.13825502798973041652092282466083; - case ForceUnit.PoundForce: return _value*4.4482216152605095551842641431421; - case ForceUnit.TonneForce: return _value*9.80665002864e3; + case ForceUnit.Decanewton: + return new Force((_value) * 1e1d, BaseUnit); + case ForceUnit.Dyn: + return new Force(_value/1e5, BaseUnit); + case ForceUnit.KilogramForce: + return new Force(_value*9.80665002864, BaseUnit); + case ForceUnit.Kilonewton: + return new Force((_value) * 1e3d, BaseUnit); + case ForceUnit.KiloPond: + return new Force(_value*9.80665002864, BaseUnit); + case ForceUnit.Meganewton: + return new Force((_value) * 1e6d, BaseUnit); + case ForceUnit.Micronewton: + return new Force((_value) * 1e-6d, BaseUnit); + case ForceUnit.Millinewton: + return new Force((_value) * 1e-3d, BaseUnit); + case ForceUnit.Newton: + return new Force(_value, BaseUnit); + case ForceUnit.OunceForce: + return new Force(_value*2.780138509537812e-1, BaseUnit); + case ForceUnit.Poundal: + return new Force(_value*0.13825502798973041652092282466083, BaseUnit); + case ForceUnit.PoundForce: + return new Force(_value*4.4482216152605095551842641431421, BaseUnit); + case ForceUnit.TonneForce: + return new Force(_value*9.80665002864e3, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -698,7 +711,8 @@ private double AsBaseNumericType(ForceUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForceChangeRate.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForceChangeRate.WindowsRuntimeComponent.g.cs index 130bbaaab2..be431a94ef 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForceChangeRate.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForceChangeRate.WindowsRuntimeComponent.g.cs @@ -641,21 +641,32 @@ public ForceChangeRate ToUnit(ForceChangeRateUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ForceChangeRate AsBaseUnit() { switch(Unit) { - case ForceChangeRateUnit.CentinewtonPerSecond: return (_value) * 1e-2d; - case ForceChangeRateUnit.DecanewtonPerMinute: return (_value/60) * 1e1d; - case ForceChangeRateUnit.DecanewtonPerSecond: return (_value) * 1e1d; - case ForceChangeRateUnit.DecinewtonPerSecond: return (_value) * 1e-1d; - case ForceChangeRateUnit.KilonewtonPerMinute: return (_value/60) * 1e3d; - case ForceChangeRateUnit.KilonewtonPerSecond: return (_value) * 1e3d; - case ForceChangeRateUnit.MicronewtonPerSecond: return (_value) * 1e-6d; - case ForceChangeRateUnit.MillinewtonPerSecond: return (_value) * 1e-3d; - case ForceChangeRateUnit.NanonewtonPerSecond: return (_value) * 1e-9d; - case ForceChangeRateUnit.NewtonPerMinute: return _value/60; - case ForceChangeRateUnit.NewtonPerSecond: return _value; + case ForceChangeRateUnit.CentinewtonPerSecond: + return new ForceChangeRate((_value) * 1e-2d, BaseUnit); + case ForceChangeRateUnit.DecanewtonPerMinute: + return new ForceChangeRate((_value/60) * 1e1d, BaseUnit); + case ForceChangeRateUnit.DecanewtonPerSecond: + return new ForceChangeRate((_value) * 1e1d, BaseUnit); + case ForceChangeRateUnit.DecinewtonPerSecond: + return new ForceChangeRate((_value) * 1e-1d, BaseUnit); + case ForceChangeRateUnit.KilonewtonPerMinute: + return new ForceChangeRate((_value/60) * 1e3d, BaseUnit); + case ForceChangeRateUnit.KilonewtonPerSecond: + return new ForceChangeRate((_value) * 1e3d, BaseUnit); + case ForceChangeRateUnit.MicronewtonPerSecond: + return new ForceChangeRate((_value) * 1e-6d, BaseUnit); + case ForceChangeRateUnit.MillinewtonPerSecond: + return new ForceChangeRate((_value) * 1e-3d, BaseUnit); + case ForceChangeRateUnit.NanonewtonPerSecond: + return new ForceChangeRate((_value) * 1e-9d, BaseUnit); + case ForceChangeRateUnit.NewtonPerMinute: + return new ForceChangeRate(_value/60, BaseUnit); + case ForceChangeRateUnit.NewtonPerSecond: + return new ForceChangeRate(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -666,7 +677,8 @@ private double AsBaseNumericType(ForceChangeRateUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForcePerLength.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForcePerLength.WindowsRuntimeComponent.g.cs index 0d349719e1..c26b0826b4 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForcePerLength.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForcePerLength.WindowsRuntimeComponent.g.cs @@ -611,19 +611,28 @@ public ForcePerLength ToUnit(ForcePerLengthUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ForcePerLength AsBaseUnit() { switch(Unit) { - case ForcePerLengthUnit.CentinewtonPerMeter: return (_value) * 1e-2d; - case ForcePerLengthUnit.DecinewtonPerMeter: return (_value) * 1e-1d; - case ForcePerLengthUnit.KilogramForcePerMeter: return _value*9.80665002864; - case ForcePerLengthUnit.KilonewtonPerMeter: return (_value) * 1e3d; - case ForcePerLengthUnit.MeganewtonPerMeter: return (_value) * 1e6d; - case ForcePerLengthUnit.MicronewtonPerMeter: return (_value) * 1e-6d; - case ForcePerLengthUnit.MillinewtonPerMeter: return (_value) * 1e-3d; - case ForcePerLengthUnit.NanonewtonPerMeter: return (_value) * 1e-9d; - case ForcePerLengthUnit.NewtonPerMeter: return _value; + case ForcePerLengthUnit.CentinewtonPerMeter: + return new ForcePerLength((_value) * 1e-2d, BaseUnit); + case ForcePerLengthUnit.DecinewtonPerMeter: + return new ForcePerLength((_value) * 1e-1d, BaseUnit); + case ForcePerLengthUnit.KilogramForcePerMeter: + return new ForcePerLength(_value*9.80665002864, BaseUnit); + case ForcePerLengthUnit.KilonewtonPerMeter: + return new ForcePerLength((_value) * 1e3d, BaseUnit); + case ForcePerLengthUnit.MeganewtonPerMeter: + return new ForcePerLength((_value) * 1e6d, BaseUnit); + case ForcePerLengthUnit.MicronewtonPerMeter: + return new ForcePerLength((_value) * 1e-6d, BaseUnit); + case ForcePerLengthUnit.MillinewtonPerMeter: + return new ForcePerLength((_value) * 1e-3d, BaseUnit); + case ForcePerLengthUnit.NanonewtonPerMeter: + return new ForcePerLength((_value) * 1e-9d, BaseUnit); + case ForcePerLengthUnit.NewtonPerMeter: + return new ForcePerLength(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -634,7 +643,8 @@ private double AsBaseNumericType(ForcePerLengthUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Frequency.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Frequency.WindowsRuntimeComponent.g.cs index 91e1b46e3d..040699ac7f 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Frequency.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Frequency.WindowsRuntimeComponent.g.cs @@ -596,18 +596,26 @@ public Frequency ToUnit(FrequencyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Frequency AsBaseUnit() { switch(Unit) { - case FrequencyUnit.CyclePerHour: return _value/3600; - case FrequencyUnit.CyclePerMinute: return _value/60; - case FrequencyUnit.Gigahertz: return (_value) * 1e9d; - case FrequencyUnit.Hertz: return _value; - case FrequencyUnit.Kilohertz: return (_value) * 1e3d; - case FrequencyUnit.Megahertz: return (_value) * 1e6d; - case FrequencyUnit.RadianPerSecond: return _value/6.2831853072; - case FrequencyUnit.Terahertz: return (_value) * 1e12d; + case FrequencyUnit.CyclePerHour: + return new Frequency(_value/3600, BaseUnit); + case FrequencyUnit.CyclePerMinute: + return new Frequency(_value/60, BaseUnit); + case FrequencyUnit.Gigahertz: + return new Frequency((_value) * 1e9d, BaseUnit); + case FrequencyUnit.Hertz: + return new Frequency(_value, BaseUnit); + case FrequencyUnit.Kilohertz: + return new Frequency((_value) * 1e3d, BaseUnit); + case FrequencyUnit.Megahertz: + return new Frequency((_value) * 1e6d, BaseUnit); + case FrequencyUnit.RadianPerSecond: + return new Frequency(_value/6.2831853072, BaseUnit); + case FrequencyUnit.Terahertz: + return new Frequency((_value) * 1e12d, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -618,7 +626,8 @@ private double AsBaseNumericType(FrequencyUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatFlux.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatFlux.WindowsRuntimeComponent.g.cs index b7451ac273..bd584ca3d6 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatFlux.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatFlux.WindowsRuntimeComponent.g.cs @@ -746,28 +746,46 @@ public HeatFlux ToUnit(HeatFluxUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal HeatFlux AsBaseUnit() { switch(Unit) { - case HeatFluxUnit.BtuPerHourSquareFoot: return _value*3.15459075; - case HeatFluxUnit.BtuPerMinuteSquareFoot: return _value*1.89275445e2; - case HeatFluxUnit.BtuPerSecondSquareFoot: return _value*1.13565267e4; - case HeatFluxUnit.BtuPerSecondSquareInch: return _value*1.63533984e6; - case HeatFluxUnit.CaloriePerSecondSquareCentimeter: return _value*4.1868e4; - case HeatFluxUnit.CentiwattPerSquareMeter: return (_value) * 1e-2d; - case HeatFluxUnit.DeciwattPerSquareMeter: return (_value) * 1e-1d; - case HeatFluxUnit.KilocaloriePerHourSquareMeter: return _value*1.163; - case HeatFluxUnit.KilocaloriePerSecondSquareCentimeter: return (_value*4.1868e4) * 1e3d; - case HeatFluxUnit.KilowattPerSquareMeter: return (_value) * 1e3d; - case HeatFluxUnit.MicrowattPerSquareMeter: return (_value) * 1e-6d; - case HeatFluxUnit.MilliwattPerSquareMeter: return (_value) * 1e-3d; - case HeatFluxUnit.NanowattPerSquareMeter: return (_value) * 1e-9d; - case HeatFluxUnit.PoundForcePerFootSecond: return _value*1.459390293720636e1; - case HeatFluxUnit.PoundPerSecondCubed: return _value*4.5359237e-1; - case HeatFluxUnit.WattPerSquareFoot: return _value*1.07639e1; - case HeatFluxUnit.WattPerSquareInch: return _value*1.5500031e3; - case HeatFluxUnit.WattPerSquareMeter: return _value; + case HeatFluxUnit.BtuPerHourSquareFoot: + return new HeatFlux(_value*3.15459075, BaseUnit); + case HeatFluxUnit.BtuPerMinuteSquareFoot: + return new HeatFlux(_value*1.89275445e2, BaseUnit); + case HeatFluxUnit.BtuPerSecondSquareFoot: + return new HeatFlux(_value*1.13565267e4, BaseUnit); + case HeatFluxUnit.BtuPerSecondSquareInch: + return new HeatFlux(_value*1.63533984e6, BaseUnit); + case HeatFluxUnit.CaloriePerSecondSquareCentimeter: + return new HeatFlux(_value*4.1868e4, BaseUnit); + case HeatFluxUnit.CentiwattPerSquareMeter: + return new HeatFlux((_value) * 1e-2d, BaseUnit); + case HeatFluxUnit.DeciwattPerSquareMeter: + return new HeatFlux((_value) * 1e-1d, BaseUnit); + case HeatFluxUnit.KilocaloriePerHourSquareMeter: + return new HeatFlux(_value*1.163, BaseUnit); + case HeatFluxUnit.KilocaloriePerSecondSquareCentimeter: + return new HeatFlux((_value*4.1868e4) * 1e3d, BaseUnit); + case HeatFluxUnit.KilowattPerSquareMeter: + return new HeatFlux((_value) * 1e3d, BaseUnit); + case HeatFluxUnit.MicrowattPerSquareMeter: + return new HeatFlux((_value) * 1e-6d, BaseUnit); + case HeatFluxUnit.MilliwattPerSquareMeter: + return new HeatFlux((_value) * 1e-3d, BaseUnit); + case HeatFluxUnit.NanowattPerSquareMeter: + return new HeatFlux((_value) * 1e-9d, BaseUnit); + case HeatFluxUnit.PoundForcePerFootSecond: + return new HeatFlux(_value*1.459390293720636e1, BaseUnit); + case HeatFluxUnit.PoundPerSecondCubed: + return new HeatFlux(_value*4.5359237e-1, BaseUnit); + case HeatFluxUnit.WattPerSquareFoot: + return new HeatFlux(_value*1.07639e1, BaseUnit); + case HeatFluxUnit.WattPerSquareInch: + return new HeatFlux(_value*1.5500031e3, BaseUnit); + case HeatFluxUnit.WattPerSquareMeter: + return new HeatFlux(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -778,7 +796,8 @@ private double AsBaseNumericType(HeatFluxUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatTransferCoefficient.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatTransferCoefficient.WindowsRuntimeComponent.g.cs index 40413dc114..8312bcbd3f 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatTransferCoefficient.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatTransferCoefficient.WindowsRuntimeComponent.g.cs @@ -506,12 +506,14 @@ public HeatTransferCoefficient ToUnit(HeatTransferCoefficientUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal HeatTransferCoefficient AsBaseUnit() { switch(Unit) { - case HeatTransferCoefficientUnit.WattPerSquareMeterCelsius: return _value; - case HeatTransferCoefficientUnit.WattPerSquareMeterKelvin: return _value; + case HeatTransferCoefficientUnit.WattPerSquareMeterCelsius: + return new HeatTransferCoefficient(_value, BaseUnit); + case HeatTransferCoefficientUnit.WattPerSquareMeterKelvin: + return new HeatTransferCoefficient(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -522,7 +524,8 @@ private double AsBaseNumericType(HeatTransferCoefficientUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Illuminance.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Illuminance.WindowsRuntimeComponent.g.cs index a5f6ee518a..37f1f261f6 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Illuminance.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Illuminance.WindowsRuntimeComponent.g.cs @@ -539,14 +539,18 @@ public Illuminance ToUnit(IlluminanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Illuminance AsBaseUnit() { switch(Unit) { - case IlluminanceUnit.Kilolux: return (_value) * 1e3d; - case IlluminanceUnit.Lux: return _value; - case IlluminanceUnit.Megalux: return (_value) * 1e6d; - case IlluminanceUnit.Millilux: return (_value) * 1e-3d; + case IlluminanceUnit.Kilolux: + return new Illuminance((_value) * 1e3d, BaseUnit); + case IlluminanceUnit.Lux: + return new Illuminance(_value, BaseUnit); + case IlluminanceUnit.Megalux: + return new Illuminance((_value) * 1e6d, BaseUnit); + case IlluminanceUnit.Millilux: + return new Illuminance((_value) * 1e-3d, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -557,7 +561,8 @@ private double AsBaseNumericType(IlluminanceUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Information.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Information.WindowsRuntimeComponent.g.cs index 8e51a2ef3f..4f30d436f1 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Information.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Information.WindowsRuntimeComponent.g.cs @@ -866,36 +866,62 @@ public Information ToUnit(InformationUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private decimal AsBaseUnit() + internal Information AsBaseUnit() { switch(Unit) { - case InformationUnit.Bit: return _value; - case InformationUnit.Byte: return _value*8m; - case InformationUnit.Exabit: return (_value) * 1e18m; - case InformationUnit.Exabyte: return (_value*8m) * 1e18m; - case InformationUnit.Exbibit: return (_value) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024); - case InformationUnit.Exbibyte: return (_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024); - case InformationUnit.Gibibit: return (_value) * (1024m * 1024 * 1024); - case InformationUnit.Gibibyte: return (_value*8m) * (1024m * 1024 * 1024); - case InformationUnit.Gigabit: return (_value) * 1e9m; - case InformationUnit.Gigabyte: return (_value*8m) * 1e9m; - case InformationUnit.Kibibit: return (_value) * 1024m; - case InformationUnit.Kibibyte: return (_value*8m) * 1024m; - case InformationUnit.Kilobit: return (_value) * 1e3m; - case InformationUnit.Kilobyte: return (_value*8m) * 1e3m; - case InformationUnit.Mebibit: return (_value) * (1024m * 1024); - case InformationUnit.Mebibyte: return (_value*8m) * (1024m * 1024); - case InformationUnit.Megabit: return (_value) * 1e6m; - case InformationUnit.Megabyte: return (_value*8m) * 1e6m; - case InformationUnit.Pebibit: return (_value) * (1024m * 1024 * 1024 * 1024 * 1024); - case InformationUnit.Pebibyte: return (_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024); - case InformationUnit.Petabit: return (_value) * 1e15m; - case InformationUnit.Petabyte: return (_value*8m) * 1e15m; - case InformationUnit.Tebibit: return (_value) * (1024m * 1024 * 1024 * 1024); - case InformationUnit.Tebibyte: return (_value*8m) * (1024m * 1024 * 1024 * 1024); - case InformationUnit.Terabit: return (_value) * 1e12m; - case InformationUnit.Terabyte: return (_value*8m) * 1e12m; + case InformationUnit.Bit: + return new Information(_value, BaseUnit); + case InformationUnit.Byte: + return new Information(_value*8m, BaseUnit); + case InformationUnit.Exabit: + return new Information((_value) * 1e18m, BaseUnit); + case InformationUnit.Exabyte: + return new Information((_value*8m) * 1e18m, BaseUnit); + case InformationUnit.Exbibit: + return new Information((_value) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024), BaseUnit); + case InformationUnit.Exbibyte: + return new Information((_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024), BaseUnit); + case InformationUnit.Gibibit: + return new Information((_value) * (1024m * 1024 * 1024), BaseUnit); + case InformationUnit.Gibibyte: + return new Information((_value*8m) * (1024m * 1024 * 1024), BaseUnit); + case InformationUnit.Gigabit: + return new Information((_value) * 1e9m, BaseUnit); + case InformationUnit.Gigabyte: + return new Information((_value*8m) * 1e9m, BaseUnit); + case InformationUnit.Kibibit: + return new Information((_value) * 1024m, BaseUnit); + case InformationUnit.Kibibyte: + return new Information((_value*8m) * 1024m, BaseUnit); + case InformationUnit.Kilobit: + return new Information((_value) * 1e3m, BaseUnit); + case InformationUnit.Kilobyte: + return new Information((_value*8m) * 1e3m, BaseUnit); + case InformationUnit.Mebibit: + return new Information((_value) * (1024m * 1024), BaseUnit); + case InformationUnit.Mebibyte: + return new Information((_value*8m) * (1024m * 1024), BaseUnit); + case InformationUnit.Megabit: + return new Information((_value) * 1e6m, BaseUnit); + case InformationUnit.Megabyte: + return new Information((_value*8m) * 1e6m, BaseUnit); + case InformationUnit.Pebibit: + return new Information((_value) * (1024m * 1024 * 1024 * 1024 * 1024), BaseUnit); + case InformationUnit.Pebibyte: + return new Information((_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024), BaseUnit); + case InformationUnit.Petabit: + return new Information((_value) * 1e15m, BaseUnit); + case InformationUnit.Petabyte: + return new Information((_value*8m) * 1e15m, BaseUnit); + case InformationUnit.Tebibit: + return new Information((_value) * (1024m * 1024 * 1024 * 1024), BaseUnit); + case InformationUnit.Tebibyte: + return new Information((_value*8m) * (1024m * 1024 * 1024 * 1024), BaseUnit); + case InformationUnit.Terabit: + return new Information((_value) * 1e12m, BaseUnit); + case InformationUnit.Terabyte: + return new Information((_value*8m) * 1e12m, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -906,7 +932,8 @@ private decimal AsBaseNumericType(InformationUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiance.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiance.WindowsRuntimeComponent.g.cs index 87612c4635..426a6dfb8d 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiance.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiance.WindowsRuntimeComponent.g.cs @@ -686,24 +686,38 @@ public Irradiance ToUnit(IrradianceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Irradiance AsBaseUnit() { switch(Unit) { - case IrradianceUnit.KilowattPerSquareCentimeter: return (_value*10000) * 1e3d; - case IrradianceUnit.KilowattPerSquareMeter: return (_value) * 1e3d; - case IrradianceUnit.MegawattPerSquareCentimeter: return (_value*10000) * 1e6d; - case IrradianceUnit.MegawattPerSquareMeter: return (_value) * 1e6d; - case IrradianceUnit.MicrowattPerSquareCentimeter: return (_value*10000) * 1e-6d; - case IrradianceUnit.MicrowattPerSquareMeter: return (_value) * 1e-6d; - case IrradianceUnit.MilliwattPerSquareCentimeter: return (_value*10000) * 1e-3d; - case IrradianceUnit.MilliwattPerSquareMeter: return (_value) * 1e-3d; - case IrradianceUnit.NanowattPerSquareCentimeter: return (_value*10000) * 1e-9d; - case IrradianceUnit.NanowattPerSquareMeter: return (_value) * 1e-9d; - case IrradianceUnit.PicowattPerSquareCentimeter: return (_value*10000) * 1e-12d; - case IrradianceUnit.PicowattPerSquareMeter: return (_value) * 1e-12d; - case IrradianceUnit.WattPerSquareCentimeter: return _value*10000; - case IrradianceUnit.WattPerSquareMeter: return _value; + case IrradianceUnit.KilowattPerSquareCentimeter: + return new Irradiance((_value*10000) * 1e3d, BaseUnit); + case IrradianceUnit.KilowattPerSquareMeter: + return new Irradiance((_value) * 1e3d, BaseUnit); + case IrradianceUnit.MegawattPerSquareCentimeter: + return new Irradiance((_value*10000) * 1e6d, BaseUnit); + case IrradianceUnit.MegawattPerSquareMeter: + return new Irradiance((_value) * 1e6d, BaseUnit); + case IrradianceUnit.MicrowattPerSquareCentimeter: + return new Irradiance((_value*10000) * 1e-6d, BaseUnit); + case IrradianceUnit.MicrowattPerSquareMeter: + return new Irradiance((_value) * 1e-6d, BaseUnit); + case IrradianceUnit.MilliwattPerSquareCentimeter: + return new Irradiance((_value*10000) * 1e-3d, BaseUnit); + case IrradianceUnit.MilliwattPerSquareMeter: + return new Irradiance((_value) * 1e-3d, BaseUnit); + case IrradianceUnit.NanowattPerSquareCentimeter: + return new Irradiance((_value*10000) * 1e-9d, BaseUnit); + case IrradianceUnit.NanowattPerSquareMeter: + return new Irradiance((_value) * 1e-9d, BaseUnit); + case IrradianceUnit.PicowattPerSquareCentimeter: + return new Irradiance((_value*10000) * 1e-12d, BaseUnit); + case IrradianceUnit.PicowattPerSquareMeter: + return new Irradiance((_value) * 1e-12d, BaseUnit); + case IrradianceUnit.WattPerSquareCentimeter: + return new Irradiance(_value*10000, BaseUnit); + case IrradianceUnit.WattPerSquareMeter: + return new Irradiance(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -714,7 +728,8 @@ private double AsBaseNumericType(IrradianceUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiation.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiation.WindowsRuntimeComponent.g.cs index 598771539f..08f07e0aa6 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiation.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiation.WindowsRuntimeComponent.g.cs @@ -539,14 +539,18 @@ public Irradiation ToUnit(IrradiationUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Irradiation AsBaseUnit() { switch(Unit) { - case IrradiationUnit.JoulePerSquareMeter: return _value; - case IrradiationUnit.JoulePerSquareMillimeter: return _value*1e6; - case IrradiationUnit.KilowattHourPerSquareMeter: return (_value*3600d) * 1e3d; - case IrradiationUnit.WattHourPerSquareMeter: return _value*3600d; + case IrradiationUnit.JoulePerSquareMeter: + return new Irradiation(_value, BaseUnit); + case IrradiationUnit.JoulePerSquareMillimeter: + return new Irradiation(_value*1e6, BaseUnit); + case IrradiationUnit.KilowattHourPerSquareMeter: + return new Irradiation((_value*3600d) * 1e3d, BaseUnit); + case IrradiationUnit.WattHourPerSquareMeter: + return new Irradiation(_value*3600d, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -557,7 +561,8 @@ private double AsBaseNumericType(IrradiationUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/KinematicViscosity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/KinematicViscosity.WindowsRuntimeComponent.g.cs index f2944f61d5..4885d84abd 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/KinematicViscosity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/KinematicViscosity.WindowsRuntimeComponent.g.cs @@ -599,18 +599,26 @@ public KinematicViscosity ToUnit(KinematicViscosityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal KinematicViscosity AsBaseUnit() { switch(Unit) { - case KinematicViscosityUnit.Centistokes: return (_value/1e4) * 1e-2d; - case KinematicViscosityUnit.Decistokes: return (_value/1e4) * 1e-1d; - case KinematicViscosityUnit.Kilostokes: return (_value/1e4) * 1e3d; - case KinematicViscosityUnit.Microstokes: return (_value/1e4) * 1e-6d; - case KinematicViscosityUnit.Millistokes: return (_value/1e4) * 1e-3d; - case KinematicViscosityUnit.Nanostokes: return (_value/1e4) * 1e-9d; - case KinematicViscosityUnit.SquareMeterPerSecond: return _value; - case KinematicViscosityUnit.Stokes: return _value/1e4; + case KinematicViscosityUnit.Centistokes: + return new KinematicViscosity((_value/1e4) * 1e-2d, BaseUnit); + case KinematicViscosityUnit.Decistokes: + return new KinematicViscosity((_value/1e4) * 1e-1d, BaseUnit); + case KinematicViscosityUnit.Kilostokes: + return new KinematicViscosity((_value/1e4) * 1e3d, BaseUnit); + case KinematicViscosityUnit.Microstokes: + return new KinematicViscosity((_value/1e4) * 1e-6d, BaseUnit); + case KinematicViscosityUnit.Millistokes: + return new KinematicViscosity((_value/1e4) * 1e-3d, BaseUnit); + case KinematicViscosityUnit.Nanostokes: + return new KinematicViscosity((_value/1e4) * 1e-9d, BaseUnit); + case KinematicViscosityUnit.SquareMeterPerSecond: + return new KinematicViscosity(_value, BaseUnit); + case KinematicViscosityUnit.Stokes: + return new KinematicViscosity(_value/1e4, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -621,7 +629,8 @@ private double AsBaseNumericType(KinematicViscosityUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LapseRate.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LapseRate.WindowsRuntimeComponent.g.cs index 1242a38c3d..0d7ea852c4 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LapseRate.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LapseRate.WindowsRuntimeComponent.g.cs @@ -491,11 +491,12 @@ public LapseRate ToUnit(LapseRateUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal LapseRate AsBaseUnit() { switch(Unit) { - case LapseRateUnit.DegreeCelsiusPerKilometer: return _value; + case LapseRateUnit.DegreeCelsiusPerKilometer: + return new LapseRate(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -506,7 +507,8 @@ private double AsBaseNumericType(LapseRateUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Length.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Length.WindowsRuntimeComponent.g.cs index c3caf25b5d..d88e505794 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Length.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Length.WindowsRuntimeComponent.g.cs @@ -806,32 +806,54 @@ public Length ToUnit(LengthUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Length AsBaseUnit() { switch(Unit) { - case LengthUnit.Centimeter: return (_value) * 1e-2d; - case LengthUnit.Decimeter: return (_value) * 1e-1d; - case LengthUnit.DtpPica: return _value/236.220472441; - case LengthUnit.DtpPoint: return (_value/72)*2.54e-2; - case LengthUnit.Fathom: return _value*1.8288; - case LengthUnit.Foot: return _value*0.3048; - case LengthUnit.Inch: return _value*2.54e-2; - case LengthUnit.Kilometer: return (_value) * 1e3d; - case LengthUnit.Meter: return _value; - case LengthUnit.Microinch: return _value*2.54e-8; - case LengthUnit.Micrometer: return (_value) * 1e-6d; - case LengthUnit.Mil: return _value*2.54e-5; - case LengthUnit.Mile: return _value*1609.34; - case LengthUnit.Millimeter: return (_value) * 1e-3d; - case LengthUnit.Nanometer: return (_value) * 1e-9d; - case LengthUnit.NauticalMile: return _value*1852; - case LengthUnit.PrinterPica: return _value/237.106301584; - case LengthUnit.PrinterPoint: return (_value/72.27)*2.54e-2; - case LengthUnit.Shackle: return _value*27.432; - case LengthUnit.Twip: return _value/56692.913385826; - case LengthUnit.UsSurveyFoot: return _value*1200/3937; - case LengthUnit.Yard: return _value*0.9144; + case LengthUnit.Centimeter: + return new Length((_value) * 1e-2d, BaseUnit); + case LengthUnit.Decimeter: + return new Length((_value) * 1e-1d, BaseUnit); + case LengthUnit.DtpPica: + return new Length(_value/236.220472441, BaseUnit); + case LengthUnit.DtpPoint: + return new Length((_value/72)*2.54e-2, BaseUnit); + case LengthUnit.Fathom: + return new Length(_value*1.8288, BaseUnit); + case LengthUnit.Foot: + return new Length(_value*0.3048, BaseUnit); + case LengthUnit.Inch: + return new Length(_value*2.54e-2, BaseUnit); + case LengthUnit.Kilometer: + return new Length((_value) * 1e3d, BaseUnit); + case LengthUnit.Meter: + return new Length(_value, BaseUnit); + case LengthUnit.Microinch: + return new Length(_value*2.54e-8, BaseUnit); + case LengthUnit.Micrometer: + return new Length((_value) * 1e-6d, BaseUnit); + case LengthUnit.Mil: + return new Length(_value*2.54e-5, BaseUnit); + case LengthUnit.Mile: + return new Length(_value*1609.34, BaseUnit); + case LengthUnit.Millimeter: + return new Length((_value) * 1e-3d, BaseUnit); + case LengthUnit.Nanometer: + return new Length((_value) * 1e-9d, BaseUnit); + case LengthUnit.NauticalMile: + return new Length(_value*1852, BaseUnit); + case LengthUnit.PrinterPica: + return new Length(_value/237.106301584, BaseUnit); + case LengthUnit.PrinterPoint: + return new Length((_value/72.27)*2.54e-2, BaseUnit); + case LengthUnit.Shackle: + return new Length(_value*27.432, BaseUnit); + case LengthUnit.Twip: + return new Length(_value/56692.913385826, BaseUnit); + case LengthUnit.UsSurveyFoot: + return new Length(_value*1200/3937, BaseUnit); + case LengthUnit.Yard: + return new Length(_value*0.9144, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -842,7 +864,8 @@ private double AsBaseNumericType(LengthUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Level.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Level.WindowsRuntimeComponent.g.cs index 67f61d03d0..c8fef0f5f3 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Level.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Level.WindowsRuntimeComponent.g.cs @@ -506,12 +506,14 @@ public Level ToUnit(LevelUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Level AsBaseUnit() { switch(Unit) { - case LevelUnit.Decibel: return _value; - case LevelUnit.Neper: return (1/0.115129254)*_value; + case LevelUnit.Decibel: + return new Level(_value, BaseUnit); + case LevelUnit.Neper: + return new Level((1/0.115129254)*_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -522,7 +524,8 @@ private double AsBaseNumericType(LevelUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearDensity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearDensity.WindowsRuntimeComponent.g.cs index 7dad64c701..4a22d323a1 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearDensity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearDensity.WindowsRuntimeComponent.g.cs @@ -524,13 +524,16 @@ public LinearDensity ToUnit(LinearDensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal LinearDensity AsBaseUnit() { switch(Unit) { - case LinearDensityUnit.GramPerMeter: return _value*1e-3; - case LinearDensityUnit.KilogramPerMeter: return (_value*1e-3) * 1e3d; - case LinearDensityUnit.PoundPerFoot: return _value*1.48816394; + case LinearDensityUnit.GramPerMeter: + return new LinearDensity(_value*1e-3, BaseUnit); + case LinearDensityUnit.KilogramPerMeter: + return new LinearDensity((_value*1e-3) * 1e3d, BaseUnit); + case LinearDensityUnit.PoundPerFoot: + return new LinearDensity(_value*1.48816394, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -541,7 +544,8 @@ private double AsBaseNumericType(LinearDensityUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousFlux.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousFlux.WindowsRuntimeComponent.g.cs index 9d867e79a5..1ece43509c 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousFlux.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousFlux.WindowsRuntimeComponent.g.cs @@ -494,11 +494,12 @@ public LuminousFlux ToUnit(LuminousFluxUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal LuminousFlux AsBaseUnit() { switch(Unit) { - case LuminousFluxUnit.Lumen: return _value; + case LuminousFluxUnit.Lumen: + return new LuminousFlux(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -509,7 +510,8 @@ private double AsBaseNumericType(LuminousFluxUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousIntensity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousIntensity.WindowsRuntimeComponent.g.cs index 6ba10e506e..14795c5db9 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousIntensity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousIntensity.WindowsRuntimeComponent.g.cs @@ -494,11 +494,12 @@ public LuminousIntensity ToUnit(LuminousIntensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal LuminousIntensity AsBaseUnit() { switch(Unit) { - case LuminousIntensityUnit.Candela: return _value; + case LuminousIntensityUnit.Candela: + return new LuminousIntensity(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -509,7 +510,8 @@ private double AsBaseNumericType(LuminousIntensityUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticField.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticField.WindowsRuntimeComponent.g.cs index 86caad02ba..713eef1c8f 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticField.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticField.WindowsRuntimeComponent.g.cs @@ -539,14 +539,18 @@ public MagneticField ToUnit(MagneticFieldUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal MagneticField AsBaseUnit() { switch(Unit) { - case MagneticFieldUnit.Microtesla: return (_value) * 1e-6d; - case MagneticFieldUnit.Millitesla: return (_value) * 1e-3d; - case MagneticFieldUnit.Nanotesla: return (_value) * 1e-9d; - case MagneticFieldUnit.Tesla: return _value; + case MagneticFieldUnit.Microtesla: + return new MagneticField((_value) * 1e-6d, BaseUnit); + case MagneticFieldUnit.Millitesla: + return new MagneticField((_value) * 1e-3d, BaseUnit); + case MagneticFieldUnit.Nanotesla: + return new MagneticField((_value) * 1e-9d, BaseUnit); + case MagneticFieldUnit.Tesla: + return new MagneticField(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -557,7 +561,8 @@ private double AsBaseNumericType(MagneticFieldUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticFlux.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticFlux.WindowsRuntimeComponent.g.cs index ba0b4d1bb1..ebf516c1e0 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticFlux.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticFlux.WindowsRuntimeComponent.g.cs @@ -494,11 +494,12 @@ public MagneticFlux ToUnit(MagneticFluxUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal MagneticFlux AsBaseUnit() { switch(Unit) { - case MagneticFluxUnit.Weber: return _value; + case MagneticFluxUnit.Weber: + return new MagneticFlux(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -509,7 +510,8 @@ private double AsBaseNumericType(MagneticFluxUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Magnetization.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Magnetization.WindowsRuntimeComponent.g.cs index 0c3a26cf2d..9128f939f6 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Magnetization.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Magnetization.WindowsRuntimeComponent.g.cs @@ -494,11 +494,12 @@ public Magnetization ToUnit(MagnetizationUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Magnetization AsBaseUnit() { switch(Unit) { - case MagnetizationUnit.AmperePerMeter: return _value; + case MagnetizationUnit.AmperePerMeter: + return new Magnetization(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -509,7 +510,8 @@ private double AsBaseNumericType(MagnetizationUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Mass.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Mass.WindowsRuntimeComponent.g.cs index 6151a5f747..1a560d134f 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Mass.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Mass.WindowsRuntimeComponent.g.cs @@ -821,33 +821,56 @@ public Mass ToUnit(MassUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Mass AsBaseUnit() { switch(Unit) { - case MassUnit.Centigram: return (_value/1e3) * 1e-2d; - case MassUnit.Decagram: return (_value/1e3) * 1e1d; - case MassUnit.Decigram: return (_value/1e3) * 1e-1d; - case MassUnit.Grain: return _value/15432.358352941431; - case MassUnit.Gram: return _value/1e3; - case MassUnit.Hectogram: return (_value/1e3) * 1e2d; - case MassUnit.Kilogram: return (_value/1e3) * 1e3d; - case MassUnit.Kilopound: return (_value*0.45359237) * 1e3d; - case MassUnit.Kilotonne: return (_value*1e3) * 1e3d; - case MassUnit.LongHundredweight: return _value/0.01968413055222121; - case MassUnit.LongTon: return _value*1.0160469088e3; - case MassUnit.Megapound: return (_value*0.45359237) * 1e6d; - case MassUnit.Megatonne: return (_value*1e3) * 1e6d; - case MassUnit.Microgram: return (_value/1e3) * 1e-6d; - case MassUnit.Milligram: return (_value/1e3) * 1e-3d; - case MassUnit.Nanogram: return (_value/1e3) * 1e-9d; - case MassUnit.Ounce: return _value/35.2739619; - case MassUnit.Pound: return _value*0.45359237; - case MassUnit.ShortHundredweight: return _value/0.022046226218487758; - case MassUnit.ShortTon: return _value*9.0718474e2; - case MassUnit.Slug: return _value/6.852176556196105e-2; - case MassUnit.Stone: return _value/0.1574731728702698; - case MassUnit.Tonne: return _value*1e3; + case MassUnit.Centigram: + return new Mass((_value/1e3) * 1e-2d, BaseUnit); + case MassUnit.Decagram: + return new Mass((_value/1e3) * 1e1d, BaseUnit); + case MassUnit.Decigram: + return new Mass((_value/1e3) * 1e-1d, BaseUnit); + case MassUnit.Grain: + return new Mass(_value/15432.358352941431, BaseUnit); + case MassUnit.Gram: + return new Mass(_value/1e3, BaseUnit); + case MassUnit.Hectogram: + return new Mass((_value/1e3) * 1e2d, BaseUnit); + case MassUnit.Kilogram: + return new Mass((_value/1e3) * 1e3d, BaseUnit); + case MassUnit.Kilopound: + return new Mass((_value*0.45359237) * 1e3d, BaseUnit); + case MassUnit.Kilotonne: + return new Mass((_value*1e3) * 1e3d, BaseUnit); + case MassUnit.LongHundredweight: + return new Mass(_value/0.01968413055222121, BaseUnit); + case MassUnit.LongTon: + return new Mass(_value*1.0160469088e3, BaseUnit); + case MassUnit.Megapound: + return new Mass((_value*0.45359237) * 1e6d, BaseUnit); + case MassUnit.Megatonne: + return new Mass((_value*1e3) * 1e6d, BaseUnit); + case MassUnit.Microgram: + return new Mass((_value/1e3) * 1e-6d, BaseUnit); + case MassUnit.Milligram: + return new Mass((_value/1e3) * 1e-3d, BaseUnit); + case MassUnit.Nanogram: + return new Mass((_value/1e3) * 1e-9d, BaseUnit); + case MassUnit.Ounce: + return new Mass(_value/35.2739619, BaseUnit); + case MassUnit.Pound: + return new Mass(_value*0.45359237, BaseUnit); + case MassUnit.ShortHundredweight: + return new Mass(_value/0.022046226218487758, BaseUnit); + case MassUnit.ShortTon: + return new Mass(_value*9.0718474e2, BaseUnit); + case MassUnit.Slug: + return new Mass(_value/6.852176556196105e-2, BaseUnit); + case MassUnit.Stone: + return new Mass(_value/0.1574731728702698, BaseUnit); + case MassUnit.Tonne: + return new Mass(_value*1e3, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -858,7 +881,8 @@ private double AsBaseNumericType(MassUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlow.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlow.WindowsRuntimeComponent.g.cs index 201a361242..9c5e1f21db 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlow.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlow.WindowsRuntimeComponent.g.cs @@ -926,40 +926,70 @@ public MassFlow ToUnit(MassFlowUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal MassFlow AsBaseUnit() { switch(Unit) { - case MassFlowUnit.CentigramPerDay: return (_value/86400) * 1e-2d; - case MassFlowUnit.CentigramPerSecond: return (_value) * 1e-2d; - case MassFlowUnit.DecagramPerDay: return (_value/86400) * 1e1d; - case MassFlowUnit.DecagramPerSecond: return (_value) * 1e1d; - case MassFlowUnit.DecigramPerDay: return (_value/86400) * 1e-1d; - case MassFlowUnit.DecigramPerSecond: return (_value) * 1e-1d; - case MassFlowUnit.GramPerDay: return _value/86400; - case MassFlowUnit.GramPerSecond: return _value; - case MassFlowUnit.HectogramPerDay: return (_value/86400) * 1e2d; - case MassFlowUnit.HectogramPerSecond: return (_value) * 1e2d; - case MassFlowUnit.KilogramPerDay: return (_value/86400) * 1e3d; - case MassFlowUnit.KilogramPerHour: return _value/3.6; - case MassFlowUnit.KilogramPerMinute: return _value/0.06; - case MassFlowUnit.KilogramPerSecond: return (_value) * 1e3d; - case MassFlowUnit.MegagramPerDay: return (_value/86400) * 1e6d; - case MassFlowUnit.MegapoundPerDay: return (_value/190.47936) * 1e6d; - case MassFlowUnit.MegapoundPerHour: return (_value/7.93664) * 1e6d; - case MassFlowUnit.MegapoundPerMinute: return (_value/0.132277) * 1e6d; - case MassFlowUnit.MicrogramPerDay: return (_value/86400) * 1e-6d; - case MassFlowUnit.MicrogramPerSecond: return (_value) * 1e-6d; - case MassFlowUnit.MilligramPerDay: return (_value/86400) * 1e-3d; - case MassFlowUnit.MilligramPerSecond: return (_value) * 1e-3d; - case MassFlowUnit.NanogramPerDay: return (_value/86400) * 1e-9d; - case MassFlowUnit.NanogramPerSecond: return (_value) * 1e-9d; - case MassFlowUnit.PoundPerDay: return _value/190.47936; - case MassFlowUnit.PoundPerHour: return _value/7.93664; - case MassFlowUnit.PoundPerMinute: return _value/0.132277; - case MassFlowUnit.ShortTonPerHour: return _value*251.9957611; - case MassFlowUnit.TonnePerDay: return _value/0.0864000; - case MassFlowUnit.TonnePerHour: return 1000*_value/3.6; + case MassFlowUnit.CentigramPerDay: + return new MassFlow((_value/86400) * 1e-2d, BaseUnit); + case MassFlowUnit.CentigramPerSecond: + return new MassFlow((_value) * 1e-2d, BaseUnit); + case MassFlowUnit.DecagramPerDay: + return new MassFlow((_value/86400) * 1e1d, BaseUnit); + case MassFlowUnit.DecagramPerSecond: + return new MassFlow((_value) * 1e1d, BaseUnit); + case MassFlowUnit.DecigramPerDay: + return new MassFlow((_value/86400) * 1e-1d, BaseUnit); + case MassFlowUnit.DecigramPerSecond: + return new MassFlow((_value) * 1e-1d, BaseUnit); + case MassFlowUnit.GramPerDay: + return new MassFlow(_value/86400, BaseUnit); + case MassFlowUnit.GramPerSecond: + return new MassFlow(_value, BaseUnit); + case MassFlowUnit.HectogramPerDay: + return new MassFlow((_value/86400) * 1e2d, BaseUnit); + case MassFlowUnit.HectogramPerSecond: + return new MassFlow((_value) * 1e2d, BaseUnit); + case MassFlowUnit.KilogramPerDay: + return new MassFlow((_value/86400) * 1e3d, BaseUnit); + case MassFlowUnit.KilogramPerHour: + return new MassFlow(_value/3.6, BaseUnit); + case MassFlowUnit.KilogramPerMinute: + return new MassFlow(_value/0.06, BaseUnit); + case MassFlowUnit.KilogramPerSecond: + return new MassFlow((_value) * 1e3d, BaseUnit); + case MassFlowUnit.MegagramPerDay: + return new MassFlow((_value/86400) * 1e6d, BaseUnit); + case MassFlowUnit.MegapoundPerDay: + return new MassFlow((_value/190.47936) * 1e6d, BaseUnit); + case MassFlowUnit.MegapoundPerHour: + return new MassFlow((_value/7.93664) * 1e6d, BaseUnit); + case MassFlowUnit.MegapoundPerMinute: + return new MassFlow((_value/0.132277) * 1e6d, BaseUnit); + case MassFlowUnit.MicrogramPerDay: + return new MassFlow((_value/86400) * 1e-6d, BaseUnit); + case MassFlowUnit.MicrogramPerSecond: + return new MassFlow((_value) * 1e-6d, BaseUnit); + case MassFlowUnit.MilligramPerDay: + return new MassFlow((_value/86400) * 1e-3d, BaseUnit); + case MassFlowUnit.MilligramPerSecond: + return new MassFlow((_value) * 1e-3d, BaseUnit); + case MassFlowUnit.NanogramPerDay: + return new MassFlow((_value/86400) * 1e-9d, BaseUnit); + case MassFlowUnit.NanogramPerSecond: + return new MassFlow((_value) * 1e-9d, BaseUnit); + case MassFlowUnit.PoundPerDay: + return new MassFlow(_value/190.47936, BaseUnit); + case MassFlowUnit.PoundPerHour: + return new MassFlow(_value/7.93664, BaseUnit); + case MassFlowUnit.PoundPerMinute: + return new MassFlow(_value/0.132277, BaseUnit); + case MassFlowUnit.ShortTonPerHour: + return new MassFlow(_value*251.9957611, BaseUnit); + case MassFlowUnit.TonnePerDay: + return new MassFlow(_value/0.0864000, BaseUnit); + case MassFlowUnit.TonnePerHour: + return new MassFlow(1000*_value/3.6, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -970,7 +1000,8 @@ private double AsBaseNumericType(MassFlowUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlux.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlux.WindowsRuntimeComponent.g.cs index 32a8c1697c..b753e52f45 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlux.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlux.WindowsRuntimeComponent.g.cs @@ -506,12 +506,14 @@ public MassFlux ToUnit(MassFluxUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal MassFlux AsBaseUnit() { switch(Unit) { - case MassFluxUnit.GramPerSecondPerSquareMeter: return _value/1e3; - case MassFluxUnit.KilogramPerSecondPerSquareMeter: return (_value/1e3) * 1e3d; + case MassFluxUnit.GramPerSecondPerSquareMeter: + return new MassFlux(_value/1e3, BaseUnit); + case MassFluxUnit.KilogramPerSecondPerSquareMeter: + return new MassFlux((_value/1e3) * 1e3d, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -522,7 +524,8 @@ private double AsBaseNumericType(MassFluxUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassMomentOfInertia.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassMomentOfInertia.WindowsRuntimeComponent.g.cs index 39191b30f7..597b24601c 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassMomentOfInertia.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassMomentOfInertia.WindowsRuntimeComponent.g.cs @@ -896,38 +896,66 @@ public MassMomentOfInertia ToUnit(MassMomentOfInertiaUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal MassMomentOfInertia AsBaseUnit() { switch(Unit) { - case MassMomentOfInertiaUnit.GramSquareCentimeter: return _value/1e7; - case MassMomentOfInertiaUnit.GramSquareDecimeter: return _value/1e5; - case MassMomentOfInertiaUnit.GramSquareMeter: return _value/1e3; - case MassMomentOfInertiaUnit.GramSquareMillimeter: return _value/1e9; - case MassMomentOfInertiaUnit.KilogramSquareCentimeter: return (_value/1e7) * 1e3d; - case MassMomentOfInertiaUnit.KilogramSquareDecimeter: return (_value/1e5) * 1e3d; - case MassMomentOfInertiaUnit.KilogramSquareMeter: return (_value/1e3) * 1e3d; - case MassMomentOfInertiaUnit.KilogramSquareMillimeter: return (_value/1e9) * 1e3d; - case MassMomentOfInertiaUnit.KilotonneSquareCentimeter: return (_value/1e1) * 1e3d; - case MassMomentOfInertiaUnit.KilotonneSquareDecimeter: return (_value/1e-1) * 1e3d; - case MassMomentOfInertiaUnit.KilotonneSquareMeter: return (_value/1e-3) * 1e3d; - case MassMomentOfInertiaUnit.KilotonneSquareMilimeter: return (_value/1e3) * 1e3d; - case MassMomentOfInertiaUnit.MegatonneSquareCentimeter: return (_value/1e1) * 1e6d; - case MassMomentOfInertiaUnit.MegatonneSquareDecimeter: return (_value/1e-1) * 1e6d; - case MassMomentOfInertiaUnit.MegatonneSquareMeter: return (_value/1e-3) * 1e6d; - case MassMomentOfInertiaUnit.MegatonneSquareMilimeter: return (_value/1e3) * 1e6d; - case MassMomentOfInertiaUnit.MilligramSquareCentimeter: return (_value/1e7) * 1e-3d; - case MassMomentOfInertiaUnit.MilligramSquareDecimeter: return (_value/1e5) * 1e-3d; - case MassMomentOfInertiaUnit.MilligramSquareMeter: return (_value/1e3) * 1e-3d; - case MassMomentOfInertiaUnit.MilligramSquareMillimeter: return (_value/1e9) * 1e-3d; - case MassMomentOfInertiaUnit.PoundSquareFoot: return _value*4.21401101e-2; - case MassMomentOfInertiaUnit.PoundSquareInch: return _value*2.9263965e-4; - case MassMomentOfInertiaUnit.SlugSquareFoot: return _value*1.3558179619; - case MassMomentOfInertiaUnit.SlugSquareInch: return _value*9.41540242e-3; - case MassMomentOfInertiaUnit.TonneSquareCentimeter: return _value/1e1; - case MassMomentOfInertiaUnit.TonneSquareDecimeter: return _value/1e-1; - case MassMomentOfInertiaUnit.TonneSquareMeter: return _value/1e-3; - case MassMomentOfInertiaUnit.TonneSquareMilimeter: return _value/1e3; + case MassMomentOfInertiaUnit.GramSquareCentimeter: + return new MassMomentOfInertia(_value/1e7, BaseUnit); + case MassMomentOfInertiaUnit.GramSquareDecimeter: + return new MassMomentOfInertia(_value/1e5, BaseUnit); + case MassMomentOfInertiaUnit.GramSquareMeter: + return new MassMomentOfInertia(_value/1e3, BaseUnit); + case MassMomentOfInertiaUnit.GramSquareMillimeter: + return new MassMomentOfInertia(_value/1e9, BaseUnit); + case MassMomentOfInertiaUnit.KilogramSquareCentimeter: + return new MassMomentOfInertia((_value/1e7) * 1e3d, BaseUnit); + case MassMomentOfInertiaUnit.KilogramSquareDecimeter: + return new MassMomentOfInertia((_value/1e5) * 1e3d, BaseUnit); + case MassMomentOfInertiaUnit.KilogramSquareMeter: + return new MassMomentOfInertia((_value/1e3) * 1e3d, BaseUnit); + case MassMomentOfInertiaUnit.KilogramSquareMillimeter: + return new MassMomentOfInertia((_value/1e9) * 1e3d, BaseUnit); + case MassMomentOfInertiaUnit.KilotonneSquareCentimeter: + return new MassMomentOfInertia((_value/1e1) * 1e3d, BaseUnit); + case MassMomentOfInertiaUnit.KilotonneSquareDecimeter: + return new MassMomentOfInertia((_value/1e-1) * 1e3d, BaseUnit); + case MassMomentOfInertiaUnit.KilotonneSquareMeter: + return new MassMomentOfInertia((_value/1e-3) * 1e3d, BaseUnit); + case MassMomentOfInertiaUnit.KilotonneSquareMilimeter: + return new MassMomentOfInertia((_value/1e3) * 1e3d, BaseUnit); + case MassMomentOfInertiaUnit.MegatonneSquareCentimeter: + return new MassMomentOfInertia((_value/1e1) * 1e6d, BaseUnit); + case MassMomentOfInertiaUnit.MegatonneSquareDecimeter: + return new MassMomentOfInertia((_value/1e-1) * 1e6d, BaseUnit); + case MassMomentOfInertiaUnit.MegatonneSquareMeter: + return new MassMomentOfInertia((_value/1e-3) * 1e6d, BaseUnit); + case MassMomentOfInertiaUnit.MegatonneSquareMilimeter: + return new MassMomentOfInertia((_value/1e3) * 1e6d, BaseUnit); + case MassMomentOfInertiaUnit.MilligramSquareCentimeter: + return new MassMomentOfInertia((_value/1e7) * 1e-3d, BaseUnit); + case MassMomentOfInertiaUnit.MilligramSquareDecimeter: + return new MassMomentOfInertia((_value/1e5) * 1e-3d, BaseUnit); + case MassMomentOfInertiaUnit.MilligramSquareMeter: + return new MassMomentOfInertia((_value/1e3) * 1e-3d, BaseUnit); + case MassMomentOfInertiaUnit.MilligramSquareMillimeter: + return new MassMomentOfInertia((_value/1e9) * 1e-3d, BaseUnit); + case MassMomentOfInertiaUnit.PoundSquareFoot: + return new MassMomentOfInertia(_value*4.21401101e-2, BaseUnit); + case MassMomentOfInertiaUnit.PoundSquareInch: + return new MassMomentOfInertia(_value*2.9263965e-4, BaseUnit); + case MassMomentOfInertiaUnit.SlugSquareFoot: + return new MassMomentOfInertia(_value*1.3558179619, BaseUnit); + case MassMomentOfInertiaUnit.SlugSquareInch: + return new MassMomentOfInertia(_value*9.41540242e-3, BaseUnit); + case MassMomentOfInertiaUnit.TonneSquareCentimeter: + return new MassMomentOfInertia(_value/1e1, BaseUnit); + case MassMomentOfInertiaUnit.TonneSquareDecimeter: + return new MassMomentOfInertia(_value/1e-1, BaseUnit); + case MassMomentOfInertiaUnit.TonneSquareMeter: + return new MassMomentOfInertia(_value/1e-3, BaseUnit); + case MassMomentOfInertiaUnit.TonneSquareMilimeter: + return new MassMomentOfInertia(_value/1e3, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -938,7 +966,8 @@ private double AsBaseNumericType(MassMomentOfInertiaUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEnergy.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEnergy.WindowsRuntimeComponent.g.cs index e52392f58c..39d421083d 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEnergy.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEnergy.WindowsRuntimeComponent.g.cs @@ -521,13 +521,16 @@ public MolarEnergy ToUnit(MolarEnergyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal MolarEnergy AsBaseUnit() { switch(Unit) { - case MolarEnergyUnit.JoulePerMole: return _value; - case MolarEnergyUnit.KilojoulePerMole: return (_value) * 1e3d; - case MolarEnergyUnit.MegajoulePerMole: return (_value) * 1e6d; + case MolarEnergyUnit.JoulePerMole: + return new MolarEnergy(_value, BaseUnit); + case MolarEnergyUnit.KilojoulePerMole: + return new MolarEnergy((_value) * 1e3d, BaseUnit); + case MolarEnergyUnit.MegajoulePerMole: + return new MolarEnergy((_value) * 1e6d, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -538,7 +541,8 @@ private double AsBaseNumericType(MolarEnergyUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEntropy.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEntropy.WindowsRuntimeComponent.g.cs index 8aeef88d13..829c1efbe7 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEntropy.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEntropy.WindowsRuntimeComponent.g.cs @@ -521,13 +521,16 @@ public MolarEntropy ToUnit(MolarEntropyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal MolarEntropy AsBaseUnit() { switch(Unit) { - case MolarEntropyUnit.JoulePerMoleKelvin: return _value; - case MolarEntropyUnit.KilojoulePerMoleKelvin: return (_value) * 1e3d; - case MolarEntropyUnit.MegajoulePerMoleKelvin: return (_value) * 1e6d; + case MolarEntropyUnit.JoulePerMoleKelvin: + return new MolarEntropy(_value, BaseUnit); + case MolarEntropyUnit.KilojoulePerMoleKelvin: + return new MolarEntropy((_value) * 1e3d, BaseUnit); + case MolarEntropyUnit.MegajoulePerMoleKelvin: + return new MolarEntropy((_value) * 1e6d, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -538,7 +541,8 @@ private double AsBaseNumericType(MolarEntropyUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarMass.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarMass.WindowsRuntimeComponent.g.cs index 3c1d4158ed..4037f56d7e 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarMass.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarMass.WindowsRuntimeComponent.g.cs @@ -656,22 +656,34 @@ public MolarMass ToUnit(MolarMassUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal MolarMass AsBaseUnit() { switch(Unit) { - case MolarMassUnit.CentigramPerMole: return (_value/1e3) * 1e-2d; - case MolarMassUnit.DecagramPerMole: return (_value/1e3) * 1e1d; - case MolarMassUnit.DecigramPerMole: return (_value/1e3) * 1e-1d; - case MolarMassUnit.GramPerMole: return _value/1e3; - case MolarMassUnit.HectogramPerMole: return (_value/1e3) * 1e2d; - case MolarMassUnit.KilogramPerMole: return (_value/1e3) * 1e3d; - case MolarMassUnit.KilopoundPerMole: return (_value*0.45359237) * 1e3d; - case MolarMassUnit.MegapoundPerMole: return (_value*0.45359237) * 1e6d; - case MolarMassUnit.MicrogramPerMole: return (_value/1e3) * 1e-6d; - case MolarMassUnit.MilligramPerMole: return (_value/1e3) * 1e-3d; - case MolarMassUnit.NanogramPerMole: return (_value/1e3) * 1e-9d; - case MolarMassUnit.PoundPerMole: return _value*0.45359237; + case MolarMassUnit.CentigramPerMole: + return new MolarMass((_value/1e3) * 1e-2d, BaseUnit); + case MolarMassUnit.DecagramPerMole: + return new MolarMass((_value/1e3) * 1e1d, BaseUnit); + case MolarMassUnit.DecigramPerMole: + return new MolarMass((_value/1e3) * 1e-1d, BaseUnit); + case MolarMassUnit.GramPerMole: + return new MolarMass(_value/1e3, BaseUnit); + case MolarMassUnit.HectogramPerMole: + return new MolarMass((_value/1e3) * 1e2d, BaseUnit); + case MolarMassUnit.KilogramPerMole: + return new MolarMass((_value/1e3) * 1e3d, BaseUnit); + case MolarMassUnit.KilopoundPerMole: + return new MolarMass((_value*0.45359237) * 1e3d, BaseUnit); + case MolarMassUnit.MegapoundPerMole: + return new MolarMass((_value*0.45359237) * 1e6d, BaseUnit); + case MolarMassUnit.MicrogramPerMole: + return new MolarMass((_value/1e3) * 1e-6d, BaseUnit); + case MolarMassUnit.MilligramPerMole: + return new MolarMass((_value/1e3) * 1e-3d, BaseUnit); + case MolarMassUnit.NanogramPerMole: + return new MolarMass((_value/1e3) * 1e-9d, BaseUnit); + case MolarMassUnit.PoundPerMole: + return new MolarMass(_value*0.45359237, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -682,7 +694,8 @@ private double AsBaseNumericType(MolarMassUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Molarity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Molarity.WindowsRuntimeComponent.g.cs index f84d42c175..80b84cf43e 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Molarity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Molarity.WindowsRuntimeComponent.g.cs @@ -599,18 +599,26 @@ public Molarity ToUnit(MolarityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Molarity AsBaseUnit() { switch(Unit) { - case MolarityUnit.CentimolesPerLiter: return (_value/1e-3) * 1e-2d; - case MolarityUnit.DecimolesPerLiter: return (_value/1e-3) * 1e-1d; - case MolarityUnit.MicromolesPerLiter: return (_value/1e-3) * 1e-6d; - case MolarityUnit.MillimolesPerLiter: return (_value/1e-3) * 1e-3d; - case MolarityUnit.MolesPerCubicMeter: return _value; - case MolarityUnit.MolesPerLiter: return _value/1e-3; - case MolarityUnit.NanomolesPerLiter: return (_value/1e-3) * 1e-9d; - case MolarityUnit.PicomolesPerLiter: return (_value/1e-3) * 1e-12d; + case MolarityUnit.CentimolesPerLiter: + return new Molarity((_value/1e-3) * 1e-2d, BaseUnit); + case MolarityUnit.DecimolesPerLiter: + return new Molarity((_value/1e-3) * 1e-1d, BaseUnit); + case MolarityUnit.MicromolesPerLiter: + return new Molarity((_value/1e-3) * 1e-6d, BaseUnit); + case MolarityUnit.MillimolesPerLiter: + return new Molarity((_value/1e-3) * 1e-3d, BaseUnit); + case MolarityUnit.MolesPerCubicMeter: + return new Molarity(_value, BaseUnit); + case MolarityUnit.MolesPerLiter: + return new Molarity(_value/1e-3, BaseUnit); + case MolarityUnit.NanomolesPerLiter: + return new Molarity((_value/1e-3) * 1e-9d, BaseUnit); + case MolarityUnit.PicomolesPerLiter: + return new Molarity((_value/1e-3) * 1e-12d, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -621,7 +629,8 @@ private double AsBaseNumericType(MolarityUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permeability.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permeability.WindowsRuntimeComponent.g.cs index 2916a7cc26..e133089875 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permeability.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permeability.WindowsRuntimeComponent.g.cs @@ -494,11 +494,12 @@ public Permeability ToUnit(PermeabilityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Permeability AsBaseUnit() { switch(Unit) { - case PermeabilityUnit.HenryPerMeter: return _value; + case PermeabilityUnit.HenryPerMeter: + return new Permeability(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -509,7 +510,8 @@ private double AsBaseNumericType(PermeabilityUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permittivity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permittivity.WindowsRuntimeComponent.g.cs index 8ddb1a058e..902c682010 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permittivity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permittivity.WindowsRuntimeComponent.g.cs @@ -494,11 +494,12 @@ public Permittivity ToUnit(PermittivityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Permittivity AsBaseUnit() { switch(Unit) { - case PermittivityUnit.FaradPerMeter: return _value; + case PermittivityUnit.FaradPerMeter: + return new Permittivity(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -509,7 +510,8 @@ private double AsBaseNumericType(PermittivityUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Power.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Power.WindowsRuntimeComponent.g.cs index 142abfee8c..6c2aaab521 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Power.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Power.WindowsRuntimeComponent.g.cs @@ -776,30 +776,50 @@ public Power ToUnit(PowerUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private decimal AsBaseUnit() + internal Power AsBaseUnit() { switch(Unit) { - case PowerUnit.BoilerHorsepower: return _value*9812.5m; - case PowerUnit.BritishThermalUnitPerHour: return _value*0.293071m; - case PowerUnit.Decawatt: return (_value) * 1e1m; - case PowerUnit.Deciwatt: return (_value) * 1e-1m; - case PowerUnit.ElectricalHorsepower: return _value*746m; - case PowerUnit.Femtowatt: return (_value) * 1e-15m; - case PowerUnit.Gigawatt: return (_value) * 1e9m; - case PowerUnit.HydraulicHorsepower: return _value*745.69988145m; - case PowerUnit.KilobritishThermalUnitPerHour: return (_value*0.293071m) * 1e3m; - case PowerUnit.Kilowatt: return (_value) * 1e3m; - case PowerUnit.MechanicalHorsepower: return _value*745.69m; - case PowerUnit.Megawatt: return (_value) * 1e6m; - case PowerUnit.MetricHorsepower: return _value*735.49875m; - case PowerUnit.Microwatt: return (_value) * 1e-6m; - case PowerUnit.Milliwatt: return (_value) * 1e-3m; - case PowerUnit.Nanowatt: return (_value) * 1e-9m; - case PowerUnit.Petawatt: return (_value) * 1e15m; - case PowerUnit.Picowatt: return (_value) * 1e-12m; - case PowerUnit.Terawatt: return (_value) * 1e12m; - case PowerUnit.Watt: return _value; + case PowerUnit.BoilerHorsepower: + return new Power(_value*9812.5m, BaseUnit); + case PowerUnit.BritishThermalUnitPerHour: + return new Power(_value*0.293071m, BaseUnit); + case PowerUnit.Decawatt: + return new Power((_value) * 1e1m, BaseUnit); + case PowerUnit.Deciwatt: + return new Power((_value) * 1e-1m, BaseUnit); + case PowerUnit.ElectricalHorsepower: + return new Power(_value*746m, BaseUnit); + case PowerUnit.Femtowatt: + return new Power((_value) * 1e-15m, BaseUnit); + case PowerUnit.Gigawatt: + return new Power((_value) * 1e9m, BaseUnit); + case PowerUnit.HydraulicHorsepower: + return new Power(_value*745.69988145m, BaseUnit); + case PowerUnit.KilobritishThermalUnitPerHour: + return new Power((_value*0.293071m) * 1e3m, BaseUnit); + case PowerUnit.Kilowatt: + return new Power((_value) * 1e3m, BaseUnit); + case PowerUnit.MechanicalHorsepower: + return new Power(_value*745.69m, BaseUnit); + case PowerUnit.Megawatt: + return new Power((_value) * 1e6m, BaseUnit); + case PowerUnit.MetricHorsepower: + return new Power(_value*735.49875m, BaseUnit); + case PowerUnit.Microwatt: + return new Power((_value) * 1e-6m, BaseUnit); + case PowerUnit.Milliwatt: + return new Power((_value) * 1e-3m, BaseUnit); + case PowerUnit.Nanowatt: + return new Power((_value) * 1e-9m, BaseUnit); + case PowerUnit.Petawatt: + return new Power((_value) * 1e15m, BaseUnit); + case PowerUnit.Picowatt: + return new Power((_value) * 1e-12m, BaseUnit); + case PowerUnit.Terawatt: + return new Power((_value) * 1e12m, BaseUnit); + case PowerUnit.Watt: + return new Power(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -810,7 +830,8 @@ private decimal AsBaseNumericType(PowerUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerDensity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerDensity.WindowsRuntimeComponent.g.cs index 47ea186351..f59cc3c602 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerDensity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerDensity.WindowsRuntimeComponent.g.cs @@ -1136,54 +1136,98 @@ public PowerDensity ToUnit(PowerDensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal PowerDensity AsBaseUnit() { switch(Unit) { - case PowerDensityUnit.DecawattPerCubicFoot: return (_value*3.531466672148859e1) * 1e1d; - case PowerDensityUnit.DecawattPerCubicInch: return (_value*6.102374409473228e4) * 1e1d; - case PowerDensityUnit.DecawattPerCubicMeter: return (_value) * 1e1d; - case PowerDensityUnit.DecawattPerLiter: return (_value*1.0e3) * 1e1d; - case PowerDensityUnit.DeciwattPerCubicFoot: return (_value*3.531466672148859e1) * 1e-1d; - case PowerDensityUnit.DeciwattPerCubicInch: return (_value*6.102374409473228e4) * 1e-1d; - case PowerDensityUnit.DeciwattPerCubicMeter: return (_value) * 1e-1d; - case PowerDensityUnit.DeciwattPerLiter: return (_value*1.0e3) * 1e-1d; - case PowerDensityUnit.GigawattPerCubicFoot: return (_value*3.531466672148859e1) * 1e9d; - case PowerDensityUnit.GigawattPerCubicInch: return (_value*6.102374409473228e4) * 1e9d; - case PowerDensityUnit.GigawattPerCubicMeter: return (_value) * 1e9d; - case PowerDensityUnit.GigawattPerLiter: return (_value*1.0e3) * 1e9d; - case PowerDensityUnit.KilowattPerCubicFoot: return (_value*3.531466672148859e1) * 1e3d; - case PowerDensityUnit.KilowattPerCubicInch: return (_value*6.102374409473228e4) * 1e3d; - case PowerDensityUnit.KilowattPerCubicMeter: return (_value) * 1e3d; - case PowerDensityUnit.KilowattPerLiter: return (_value*1.0e3) * 1e3d; - case PowerDensityUnit.MegawattPerCubicFoot: return (_value*3.531466672148859e1) * 1e6d; - case PowerDensityUnit.MegawattPerCubicInch: return (_value*6.102374409473228e4) * 1e6d; - case PowerDensityUnit.MegawattPerCubicMeter: return (_value) * 1e6d; - case PowerDensityUnit.MegawattPerLiter: return (_value*1.0e3) * 1e6d; - case PowerDensityUnit.MicrowattPerCubicFoot: return (_value*3.531466672148859e1) * 1e-6d; - case PowerDensityUnit.MicrowattPerCubicInch: return (_value*6.102374409473228e4) * 1e-6d; - case PowerDensityUnit.MicrowattPerCubicMeter: return (_value) * 1e-6d; - case PowerDensityUnit.MicrowattPerLiter: return (_value*1.0e3) * 1e-6d; - case PowerDensityUnit.MilliwattPerCubicFoot: return (_value*3.531466672148859e1) * 1e-3d; - case PowerDensityUnit.MilliwattPerCubicInch: return (_value*6.102374409473228e4) * 1e-3d; - case PowerDensityUnit.MilliwattPerCubicMeter: return (_value) * 1e-3d; - case PowerDensityUnit.MilliwattPerLiter: return (_value*1.0e3) * 1e-3d; - case PowerDensityUnit.NanowattPerCubicFoot: return (_value*3.531466672148859e1) * 1e-9d; - case PowerDensityUnit.NanowattPerCubicInch: return (_value*6.102374409473228e4) * 1e-9d; - case PowerDensityUnit.NanowattPerCubicMeter: return (_value) * 1e-9d; - case PowerDensityUnit.NanowattPerLiter: return (_value*1.0e3) * 1e-9d; - case PowerDensityUnit.PicowattPerCubicFoot: return (_value*3.531466672148859e1) * 1e-12d; - case PowerDensityUnit.PicowattPerCubicInch: return (_value*6.102374409473228e4) * 1e-12d; - case PowerDensityUnit.PicowattPerCubicMeter: return (_value) * 1e-12d; - case PowerDensityUnit.PicowattPerLiter: return (_value*1.0e3) * 1e-12d; - case PowerDensityUnit.TerawattPerCubicFoot: return (_value*3.531466672148859e1) * 1e12d; - case PowerDensityUnit.TerawattPerCubicInch: return (_value*6.102374409473228e4) * 1e12d; - case PowerDensityUnit.TerawattPerCubicMeter: return (_value) * 1e12d; - case PowerDensityUnit.TerawattPerLiter: return (_value*1.0e3) * 1e12d; - case PowerDensityUnit.WattPerCubicFoot: return _value*3.531466672148859e1; - case PowerDensityUnit.WattPerCubicInch: return _value*6.102374409473228e4; - case PowerDensityUnit.WattPerCubicMeter: return _value; - case PowerDensityUnit.WattPerLiter: return _value*1.0e3; + case PowerDensityUnit.DecawattPerCubicFoot: + return new PowerDensity((_value*3.531466672148859e1) * 1e1d, BaseUnit); + case PowerDensityUnit.DecawattPerCubicInch: + return new PowerDensity((_value*6.102374409473228e4) * 1e1d, BaseUnit); + case PowerDensityUnit.DecawattPerCubicMeter: + return new PowerDensity((_value) * 1e1d, BaseUnit); + case PowerDensityUnit.DecawattPerLiter: + return new PowerDensity((_value*1.0e3) * 1e1d, BaseUnit); + case PowerDensityUnit.DeciwattPerCubicFoot: + return new PowerDensity((_value*3.531466672148859e1) * 1e-1d, BaseUnit); + case PowerDensityUnit.DeciwattPerCubicInch: + return new PowerDensity((_value*6.102374409473228e4) * 1e-1d, BaseUnit); + case PowerDensityUnit.DeciwattPerCubicMeter: + return new PowerDensity((_value) * 1e-1d, BaseUnit); + case PowerDensityUnit.DeciwattPerLiter: + return new PowerDensity((_value*1.0e3) * 1e-1d, BaseUnit); + case PowerDensityUnit.GigawattPerCubicFoot: + return new PowerDensity((_value*3.531466672148859e1) * 1e9d, BaseUnit); + case PowerDensityUnit.GigawattPerCubicInch: + return new PowerDensity((_value*6.102374409473228e4) * 1e9d, BaseUnit); + case PowerDensityUnit.GigawattPerCubicMeter: + return new PowerDensity((_value) * 1e9d, BaseUnit); + case PowerDensityUnit.GigawattPerLiter: + return new PowerDensity((_value*1.0e3) * 1e9d, BaseUnit); + case PowerDensityUnit.KilowattPerCubicFoot: + return new PowerDensity((_value*3.531466672148859e1) * 1e3d, BaseUnit); + case PowerDensityUnit.KilowattPerCubicInch: + return new PowerDensity((_value*6.102374409473228e4) * 1e3d, BaseUnit); + case PowerDensityUnit.KilowattPerCubicMeter: + return new PowerDensity((_value) * 1e3d, BaseUnit); + case PowerDensityUnit.KilowattPerLiter: + return new PowerDensity((_value*1.0e3) * 1e3d, BaseUnit); + case PowerDensityUnit.MegawattPerCubicFoot: + return new PowerDensity((_value*3.531466672148859e1) * 1e6d, BaseUnit); + case PowerDensityUnit.MegawattPerCubicInch: + return new PowerDensity((_value*6.102374409473228e4) * 1e6d, BaseUnit); + case PowerDensityUnit.MegawattPerCubicMeter: + return new PowerDensity((_value) * 1e6d, BaseUnit); + case PowerDensityUnit.MegawattPerLiter: + return new PowerDensity((_value*1.0e3) * 1e6d, BaseUnit); + case PowerDensityUnit.MicrowattPerCubicFoot: + return new PowerDensity((_value*3.531466672148859e1) * 1e-6d, BaseUnit); + case PowerDensityUnit.MicrowattPerCubicInch: + return new PowerDensity((_value*6.102374409473228e4) * 1e-6d, BaseUnit); + case PowerDensityUnit.MicrowattPerCubicMeter: + return new PowerDensity((_value) * 1e-6d, BaseUnit); + case PowerDensityUnit.MicrowattPerLiter: + return new PowerDensity((_value*1.0e3) * 1e-6d, BaseUnit); + case PowerDensityUnit.MilliwattPerCubicFoot: + return new PowerDensity((_value*3.531466672148859e1) * 1e-3d, BaseUnit); + case PowerDensityUnit.MilliwattPerCubicInch: + return new PowerDensity((_value*6.102374409473228e4) * 1e-3d, BaseUnit); + case PowerDensityUnit.MilliwattPerCubicMeter: + return new PowerDensity((_value) * 1e-3d, BaseUnit); + case PowerDensityUnit.MilliwattPerLiter: + return new PowerDensity((_value*1.0e3) * 1e-3d, BaseUnit); + case PowerDensityUnit.NanowattPerCubicFoot: + return new PowerDensity((_value*3.531466672148859e1) * 1e-9d, BaseUnit); + case PowerDensityUnit.NanowattPerCubicInch: + return new PowerDensity((_value*6.102374409473228e4) * 1e-9d, BaseUnit); + case PowerDensityUnit.NanowattPerCubicMeter: + return new PowerDensity((_value) * 1e-9d, BaseUnit); + case PowerDensityUnit.NanowattPerLiter: + return new PowerDensity((_value*1.0e3) * 1e-9d, BaseUnit); + case PowerDensityUnit.PicowattPerCubicFoot: + return new PowerDensity((_value*3.531466672148859e1) * 1e-12d, BaseUnit); + case PowerDensityUnit.PicowattPerCubicInch: + return new PowerDensity((_value*6.102374409473228e4) * 1e-12d, BaseUnit); + case PowerDensityUnit.PicowattPerCubicMeter: + return new PowerDensity((_value) * 1e-12d, BaseUnit); + case PowerDensityUnit.PicowattPerLiter: + return new PowerDensity((_value*1.0e3) * 1e-12d, BaseUnit); + case PowerDensityUnit.TerawattPerCubicFoot: + return new PowerDensity((_value*3.531466672148859e1) * 1e12d, BaseUnit); + case PowerDensityUnit.TerawattPerCubicInch: + return new PowerDensity((_value*6.102374409473228e4) * 1e12d, BaseUnit); + case PowerDensityUnit.TerawattPerCubicMeter: + return new PowerDensity((_value) * 1e12d, BaseUnit); + case PowerDensityUnit.TerawattPerLiter: + return new PowerDensity((_value*1.0e3) * 1e12d, BaseUnit); + case PowerDensityUnit.WattPerCubicFoot: + return new PowerDensity(_value*3.531466672148859e1, BaseUnit); + case PowerDensityUnit.WattPerCubicInch: + return new PowerDensity(_value*6.102374409473228e4, BaseUnit); + case PowerDensityUnit.WattPerCubicMeter: + return new PowerDensity(_value, BaseUnit); + case PowerDensityUnit.WattPerLiter: + return new PowerDensity(_value*1.0e3, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -1194,7 +1238,8 @@ private double AsBaseNumericType(PowerDensityUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerRatio.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerRatio.WindowsRuntimeComponent.g.cs index e603267b0e..3af29d9ba8 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerRatio.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerRatio.WindowsRuntimeComponent.g.cs @@ -506,12 +506,14 @@ public PowerRatio ToUnit(PowerRatioUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal PowerRatio AsBaseUnit() { switch(Unit) { - case PowerRatioUnit.DecibelMilliwatt: return _value - 30; - case PowerRatioUnit.DecibelWatt: return _value; + case PowerRatioUnit.DecibelMilliwatt: + return new PowerRatio(_value - 30, BaseUnit); + case PowerRatioUnit.DecibelWatt: + return new PowerRatio(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -522,7 +524,8 @@ private double AsBaseNumericType(PowerRatioUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Pressure.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Pressure.WindowsRuntimeComponent.g.cs index 8785243aa8..6a8b9b8855 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Pressure.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Pressure.WindowsRuntimeComponent.g.cs @@ -1106,52 +1106,94 @@ public Pressure ToUnit(PressureUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Pressure AsBaseUnit() { switch(Unit) { - case PressureUnit.Atmosphere: return _value*1.01325*1e5; - case PressureUnit.Bar: return _value*1e5; - case PressureUnit.Centibar: return (_value*1e5) * 1e-2d; - case PressureUnit.Decapascal: return (_value) * 1e1d; - case PressureUnit.Decibar: return (_value*1e5) * 1e-1d; - case PressureUnit.DynePerSquareCentimeter: return _value*1.0e-1; - case PressureUnit.FootOfHead: return _value*2989.0669; - case PressureUnit.Gigapascal: return (_value) * 1e9d; - case PressureUnit.Hectopascal: return (_value) * 1e2d; - case PressureUnit.InchOfMercury: return _value/2.95299830714159e-4; - case PressureUnit.InchOfWaterColumn: return _value*249.08890833333; - case PressureUnit.Kilobar: return (_value*1e5) * 1e3d; - case PressureUnit.KilogramForcePerSquareCentimeter: return _value*9.80665e4; - case PressureUnit.KilogramForcePerSquareMeter: return _value*9.80665019960652; - case PressureUnit.KilogramForcePerSquareMillimeter: return _value*9.80665e6; - case PressureUnit.KilonewtonPerSquareCentimeter: return (_value*1e4) * 1e3d; - case PressureUnit.KilonewtonPerSquareMeter: return (_value) * 1e3d; - case PressureUnit.KilonewtonPerSquareMillimeter: return (_value*1e6) * 1e3d; - case PressureUnit.Kilopascal: return (_value) * 1e3d; - case PressureUnit.KilopoundForcePerSquareFoot: return (_value*4.788025898033584e1) * 1e3d; - case PressureUnit.KilopoundForcePerSquareInch: return (_value*6.894757293168361e3) * 1e3d; - case PressureUnit.Megabar: return (_value*1e5) * 1e6d; - case PressureUnit.MeganewtonPerSquareMeter: return (_value) * 1e6d; - case PressureUnit.Megapascal: return (_value) * 1e6d; - case PressureUnit.MeterOfHead: return _value*9804.139432; - case PressureUnit.Microbar: return (_value*1e5) * 1e-6d; - case PressureUnit.Micropascal: return (_value) * 1e-6d; - case PressureUnit.Millibar: return (_value*1e5) * 1e-3d; - case PressureUnit.MillimeterOfMercury: return _value/7.50061561302643e-3; - case PressureUnit.Millipascal: return (_value) * 1e-3d; - case PressureUnit.NewtonPerSquareCentimeter: return _value*1e4; - case PressureUnit.NewtonPerSquareMeter: return _value; - case PressureUnit.NewtonPerSquareMillimeter: return _value*1e6; - case PressureUnit.Pascal: return _value; - case PressureUnit.PoundForcePerSquareFoot: return _value*4.788025898033584e1; - case PressureUnit.PoundForcePerSquareInch: return _value*6.894757293168361e3; - case PressureUnit.PoundPerInchSecondSquared: return _value*1.785796732283465e1; - case PressureUnit.TechnicalAtmosphere: return _value*9.80680592331*1e4; - case PressureUnit.TonneForcePerSquareCentimeter: return _value*9.80665e7; - case PressureUnit.TonneForcePerSquareMeter: return _value*9.80665e3; - case PressureUnit.TonneForcePerSquareMillimeter: return _value*9.80665e9; - case PressureUnit.Torr: return _value*1.3332266752*1e2; + case PressureUnit.Atmosphere: + return new Pressure(_value*1.01325*1e5, BaseUnit); + case PressureUnit.Bar: + return new Pressure(_value*1e5, BaseUnit); + case PressureUnit.Centibar: + return new Pressure((_value*1e5) * 1e-2d, BaseUnit); + case PressureUnit.Decapascal: + return new Pressure((_value) * 1e1d, BaseUnit); + case PressureUnit.Decibar: + return new Pressure((_value*1e5) * 1e-1d, BaseUnit); + case PressureUnit.DynePerSquareCentimeter: + return new Pressure(_value*1.0e-1, BaseUnit); + case PressureUnit.FootOfHead: + return new Pressure(_value*2989.0669, BaseUnit); + case PressureUnit.Gigapascal: + return new Pressure((_value) * 1e9d, BaseUnit); + case PressureUnit.Hectopascal: + return new Pressure((_value) * 1e2d, BaseUnit); + case PressureUnit.InchOfMercury: + return new Pressure(_value/2.95299830714159e-4, BaseUnit); + case PressureUnit.InchOfWaterColumn: + return new Pressure(_value*249.08890833333, BaseUnit); + case PressureUnit.Kilobar: + return new Pressure((_value*1e5) * 1e3d, BaseUnit); + case PressureUnit.KilogramForcePerSquareCentimeter: + return new Pressure(_value*9.80665e4, BaseUnit); + case PressureUnit.KilogramForcePerSquareMeter: + return new Pressure(_value*9.80665019960652, BaseUnit); + case PressureUnit.KilogramForcePerSquareMillimeter: + return new Pressure(_value*9.80665e6, BaseUnit); + case PressureUnit.KilonewtonPerSquareCentimeter: + return new Pressure((_value*1e4) * 1e3d, BaseUnit); + case PressureUnit.KilonewtonPerSquareMeter: + return new Pressure((_value) * 1e3d, BaseUnit); + case PressureUnit.KilonewtonPerSquareMillimeter: + return new Pressure((_value*1e6) * 1e3d, BaseUnit); + case PressureUnit.Kilopascal: + return new Pressure((_value) * 1e3d, BaseUnit); + case PressureUnit.KilopoundForcePerSquareFoot: + return new Pressure((_value*4.788025898033584e1) * 1e3d, BaseUnit); + case PressureUnit.KilopoundForcePerSquareInch: + return new Pressure((_value*6.894757293168361e3) * 1e3d, BaseUnit); + case PressureUnit.Megabar: + return new Pressure((_value*1e5) * 1e6d, BaseUnit); + case PressureUnit.MeganewtonPerSquareMeter: + return new Pressure((_value) * 1e6d, BaseUnit); + case PressureUnit.Megapascal: + return new Pressure((_value) * 1e6d, BaseUnit); + case PressureUnit.MeterOfHead: + return new Pressure(_value*9804.139432, BaseUnit); + case PressureUnit.Microbar: + return new Pressure((_value*1e5) * 1e-6d, BaseUnit); + case PressureUnit.Micropascal: + return new Pressure((_value) * 1e-6d, BaseUnit); + case PressureUnit.Millibar: + return new Pressure((_value*1e5) * 1e-3d, BaseUnit); + case PressureUnit.MillimeterOfMercury: + return new Pressure(_value/7.50061561302643e-3, BaseUnit); + case PressureUnit.Millipascal: + return new Pressure((_value) * 1e-3d, BaseUnit); + case PressureUnit.NewtonPerSquareCentimeter: + return new Pressure(_value*1e4, BaseUnit); + case PressureUnit.NewtonPerSquareMeter: + return new Pressure(_value, BaseUnit); + case PressureUnit.NewtonPerSquareMillimeter: + return new Pressure(_value*1e6, BaseUnit); + case PressureUnit.Pascal: + return new Pressure(_value, BaseUnit); + case PressureUnit.PoundForcePerSquareFoot: + return new Pressure(_value*4.788025898033584e1, BaseUnit); + case PressureUnit.PoundForcePerSquareInch: + return new Pressure(_value*6.894757293168361e3, BaseUnit); + case PressureUnit.PoundPerInchSecondSquared: + return new Pressure(_value*1.785796732283465e1, BaseUnit); + case PressureUnit.TechnicalAtmosphere: + return new Pressure(_value*9.80680592331*1e4, BaseUnit); + case PressureUnit.TonneForcePerSquareCentimeter: + return new Pressure(_value*9.80665e7, BaseUnit); + case PressureUnit.TonneForcePerSquareMeter: + return new Pressure(_value*9.80665e3, BaseUnit); + case PressureUnit.TonneForcePerSquareMillimeter: + return new Pressure(_value*9.80665e9, BaseUnit); + case PressureUnit.Torr: + return new Pressure(_value*1.3332266752*1e2, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -1162,7 +1204,8 @@ private double AsBaseNumericType(PressureUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PressureChangeRate.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PressureChangeRate.WindowsRuntimeComponent.g.cs index 8b74cbc58a..9fe78941e0 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PressureChangeRate.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PressureChangeRate.WindowsRuntimeComponent.g.cs @@ -581,17 +581,24 @@ public PressureChangeRate ToUnit(PressureChangeRateUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal PressureChangeRate AsBaseUnit() { switch(Unit) { - case PressureChangeRateUnit.AtmospherePerSecond: return _value * 1.01325*1e5; - case PressureChangeRateUnit.KilopascalPerMinute: return (_value/60) * 1e3d; - case PressureChangeRateUnit.KilopascalPerSecond: return (_value) * 1e3d; - case PressureChangeRateUnit.MegapascalPerMinute: return (_value/60) * 1e6d; - case PressureChangeRateUnit.MegapascalPerSecond: return (_value) * 1e6d; - case PressureChangeRateUnit.PascalPerMinute: return _value/60; - case PressureChangeRateUnit.PascalPerSecond: return _value; + case PressureChangeRateUnit.AtmospherePerSecond: + return new PressureChangeRate(_value * 1.01325*1e5, BaseUnit); + case PressureChangeRateUnit.KilopascalPerMinute: + return new PressureChangeRate((_value/60) * 1e3d, BaseUnit); + case PressureChangeRateUnit.KilopascalPerSecond: + return new PressureChangeRate((_value) * 1e3d, BaseUnit); + case PressureChangeRateUnit.MegapascalPerMinute: + return new PressureChangeRate((_value/60) * 1e6d, BaseUnit); + case PressureChangeRateUnit.MegapascalPerSecond: + return new PressureChangeRate((_value) * 1e6d, BaseUnit); + case PressureChangeRateUnit.PascalPerMinute: + return new PressureChangeRate(_value/60, BaseUnit); + case PressureChangeRateUnit.PascalPerSecond: + return new PressureChangeRate(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -602,7 +609,8 @@ private double AsBaseNumericType(PressureChangeRateUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Ratio.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Ratio.WindowsRuntimeComponent.g.cs index 8eb8809246..f20aa02e65 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Ratio.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Ratio.WindowsRuntimeComponent.g.cs @@ -566,16 +566,22 @@ public Ratio ToUnit(RatioUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Ratio AsBaseUnit() { switch(Unit) { - case RatioUnit.DecimalFraction: return _value; - case RatioUnit.PartPerBillion: return _value/1e9; - case RatioUnit.PartPerMillion: return _value/1e6; - case RatioUnit.PartPerThousand: return _value/1e3; - case RatioUnit.PartPerTrillion: return _value/1e12; - case RatioUnit.Percent: return _value/1e2; + case RatioUnit.DecimalFraction: + return new Ratio(_value, BaseUnit); + case RatioUnit.PartPerBillion: + return new Ratio(_value/1e9, BaseUnit); + case RatioUnit.PartPerMillion: + return new Ratio(_value/1e6, BaseUnit); + case RatioUnit.PartPerThousand: + return new Ratio(_value/1e3, BaseUnit); + case RatioUnit.PartPerTrillion: + return new Ratio(_value/1e12, BaseUnit); + case RatioUnit.Percent: + return new Ratio(_value/1e2, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -586,7 +592,8 @@ private double AsBaseNumericType(RatioUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactiveEnergy.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactiveEnergy.WindowsRuntimeComponent.g.cs index 4416fafce4..2e6129acb7 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactiveEnergy.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactiveEnergy.WindowsRuntimeComponent.g.cs @@ -521,13 +521,16 @@ public ReactiveEnergy ToUnit(ReactiveEnergyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ReactiveEnergy AsBaseUnit() { switch(Unit) { - case ReactiveEnergyUnit.KilovoltampereReactiveHour: return (_value) * 1e3d; - case ReactiveEnergyUnit.MegavoltampereReactiveHour: return (_value) * 1e6d; - case ReactiveEnergyUnit.VoltampereReactiveHour: return _value; + case ReactiveEnergyUnit.KilovoltampereReactiveHour: + return new ReactiveEnergy((_value) * 1e3d, BaseUnit); + case ReactiveEnergyUnit.MegavoltampereReactiveHour: + return new ReactiveEnergy((_value) * 1e6d, BaseUnit); + case ReactiveEnergyUnit.VoltampereReactiveHour: + return new ReactiveEnergy(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -538,7 +541,8 @@ private double AsBaseNumericType(ReactiveEnergyUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactivePower.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactivePower.WindowsRuntimeComponent.g.cs index 586c4fba33..5d06811450 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactivePower.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactivePower.WindowsRuntimeComponent.g.cs @@ -536,14 +536,18 @@ public ReactivePower ToUnit(ReactivePowerUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ReactivePower AsBaseUnit() { switch(Unit) { - case ReactivePowerUnit.GigavoltampereReactive: return (_value) * 1e9d; - case ReactivePowerUnit.KilovoltampereReactive: return (_value) * 1e3d; - case ReactivePowerUnit.MegavoltampereReactive: return (_value) * 1e6d; - case ReactivePowerUnit.VoltampereReactive: return _value; + case ReactivePowerUnit.GigavoltampereReactive: + return new ReactivePower((_value) * 1e9d, BaseUnit); + case ReactivePowerUnit.KilovoltampereReactive: + return new ReactivePower((_value) * 1e3d, BaseUnit); + case ReactivePowerUnit.MegavoltampereReactive: + return new ReactivePower((_value) * 1e6d, BaseUnit); + case ReactivePowerUnit.VoltampereReactive: + return new ReactivePower(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -554,7 +558,8 @@ private double AsBaseNumericType(ReactivePowerUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalAcceleration.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalAcceleration.WindowsRuntimeComponent.g.cs index f8b24a5ec0..e42a3ba838 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalAcceleration.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalAcceleration.WindowsRuntimeComponent.g.cs @@ -521,13 +521,16 @@ public RotationalAcceleration ToUnit(RotationalAccelerationUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal RotationalAcceleration AsBaseUnit() { switch(Unit) { - case RotationalAccelerationUnit.DegreePerSecondSquared: return (Math.PI/180)*_value; - case RotationalAccelerationUnit.RadianPerSecondSquared: return _value; - case RotationalAccelerationUnit.RevolutionPerMinutePerSecond: return ((2*Math.PI)/60)*_value; + case RotationalAccelerationUnit.DegreePerSecondSquared: + return new RotationalAcceleration((Math.PI/180)*_value, BaseUnit); + case RotationalAccelerationUnit.RadianPerSecondSquared: + return new RotationalAcceleration(_value, BaseUnit); + case RotationalAccelerationUnit.RevolutionPerMinutePerSecond: + return new RotationalAcceleration(((2*Math.PI)/60)*_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -538,7 +541,8 @@ private double AsBaseNumericType(RotationalAccelerationUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalSpeed.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalSpeed.WindowsRuntimeComponent.g.cs index 9a2c78e98a..f35c5a1f98 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalSpeed.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalSpeed.WindowsRuntimeComponent.g.cs @@ -671,23 +671,36 @@ public RotationalSpeed ToUnit(RotationalSpeedUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal RotationalSpeed AsBaseUnit() { switch(Unit) { - case RotationalSpeedUnit.CentiradianPerSecond: return (_value) * 1e-2d; - case RotationalSpeedUnit.DeciradianPerSecond: return (_value) * 1e-1d; - case RotationalSpeedUnit.DegreePerMinute: return (Math.PI/(180*60))*_value; - case RotationalSpeedUnit.DegreePerSecond: return (Math.PI/180)*_value; - case RotationalSpeedUnit.MicrodegreePerSecond: return ((Math.PI/180)*_value) * 1e-6d; - case RotationalSpeedUnit.MicroradianPerSecond: return (_value) * 1e-6d; - case RotationalSpeedUnit.MillidegreePerSecond: return ((Math.PI/180)*_value) * 1e-3d; - case RotationalSpeedUnit.MilliradianPerSecond: return (_value) * 1e-3d; - case RotationalSpeedUnit.NanodegreePerSecond: return ((Math.PI/180)*_value) * 1e-9d; - case RotationalSpeedUnit.NanoradianPerSecond: return (_value) * 1e-9d; - case RotationalSpeedUnit.RadianPerSecond: return _value; - case RotationalSpeedUnit.RevolutionPerMinute: return (_value*6.2831853072)/60; - case RotationalSpeedUnit.RevolutionPerSecond: return _value*6.2831853072; + case RotationalSpeedUnit.CentiradianPerSecond: + return new RotationalSpeed((_value) * 1e-2d, BaseUnit); + case RotationalSpeedUnit.DeciradianPerSecond: + return new RotationalSpeed((_value) * 1e-1d, BaseUnit); + case RotationalSpeedUnit.DegreePerMinute: + return new RotationalSpeed((Math.PI/(180*60))*_value, BaseUnit); + case RotationalSpeedUnit.DegreePerSecond: + return new RotationalSpeed((Math.PI/180)*_value, BaseUnit); + case RotationalSpeedUnit.MicrodegreePerSecond: + return new RotationalSpeed(((Math.PI/180)*_value) * 1e-6d, BaseUnit); + case RotationalSpeedUnit.MicroradianPerSecond: + return new RotationalSpeed((_value) * 1e-6d, BaseUnit); + case RotationalSpeedUnit.MillidegreePerSecond: + return new RotationalSpeed(((Math.PI/180)*_value) * 1e-3d, BaseUnit); + case RotationalSpeedUnit.MilliradianPerSecond: + return new RotationalSpeed((_value) * 1e-3d, BaseUnit); + case RotationalSpeedUnit.NanodegreePerSecond: + return new RotationalSpeed(((Math.PI/180)*_value) * 1e-9d, BaseUnit); + case RotationalSpeedUnit.NanoradianPerSecond: + return new RotationalSpeed((_value) * 1e-9d, BaseUnit); + case RotationalSpeedUnit.RadianPerSecond: + return new RotationalSpeed(_value, BaseUnit); + case RotationalSpeedUnit.RevolutionPerMinute: + return new RotationalSpeed((_value*6.2831853072)/60, BaseUnit); + case RotationalSpeedUnit.RevolutionPerSecond: + return new RotationalSpeed(_value*6.2831853072, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -698,7 +711,8 @@ private double AsBaseNumericType(RotationalSpeedUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffness.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffness.WindowsRuntimeComponent.g.cs index 61fc5c97dd..fba6778aa5 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffness.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffness.WindowsRuntimeComponent.g.cs @@ -521,13 +521,16 @@ public RotationalStiffness ToUnit(RotationalStiffnessUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal RotationalStiffness AsBaseUnit() { switch(Unit) { - case RotationalStiffnessUnit.KilonewtonMeterPerRadian: return (_value) * 1e3d; - case RotationalStiffnessUnit.MeganewtonMeterPerRadian: return (_value) * 1e6d; - case RotationalStiffnessUnit.NewtonMeterPerRadian: return _value; + case RotationalStiffnessUnit.KilonewtonMeterPerRadian: + return new RotationalStiffness((_value) * 1e3d, BaseUnit); + case RotationalStiffnessUnit.MeganewtonMeterPerRadian: + return new RotationalStiffness((_value) * 1e6d, BaseUnit); + case RotationalStiffnessUnit.NewtonMeterPerRadian: + return new RotationalStiffness(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -538,7 +541,8 @@ private double AsBaseNumericType(RotationalStiffnessUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffnessPerLength.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffnessPerLength.WindowsRuntimeComponent.g.cs index 2e47b2cfe3..b286c55335 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffnessPerLength.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffnessPerLength.WindowsRuntimeComponent.g.cs @@ -521,13 +521,16 @@ public RotationalStiffnessPerLength ToUnit(RotationalStiffnessPerLengthUnit unit /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal RotationalStiffnessPerLength AsBaseUnit() { switch(Unit) { - case RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter: return (_value) * 1e3d; - case RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter: return (_value) * 1e6d; - case RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter: return _value; + case RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter: + return new RotationalStiffnessPerLength((_value) * 1e3d, BaseUnit); + case RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter: + return new RotationalStiffnessPerLength((_value) * 1e6d, BaseUnit); + case RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter: + return new RotationalStiffnessPerLength(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -538,7 +541,8 @@ private double AsBaseNumericType(RotationalStiffnessPerLengthUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SolidAngle.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SolidAngle.WindowsRuntimeComponent.g.cs index 77bdb7da20..a80553c73a 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SolidAngle.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SolidAngle.WindowsRuntimeComponent.g.cs @@ -494,11 +494,12 @@ public SolidAngle ToUnit(SolidAngleUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal SolidAngle AsBaseUnit() { switch(Unit) { - case SolidAngleUnit.Steradian: return _value; + case SolidAngleUnit.Steradian: + return new SolidAngle(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -509,7 +510,8 @@ private double AsBaseNumericType(SolidAngleUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEnergy.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEnergy.WindowsRuntimeComponent.g.cs index 734fa9e4ca..81cddac4a5 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEnergy.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEnergy.WindowsRuntimeComponent.g.cs @@ -614,19 +614,28 @@ public SpecificEnergy ToUnit(SpecificEnergyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal SpecificEnergy AsBaseUnit() { switch(Unit) { - case SpecificEnergyUnit.BtuPerPound: return _value*2326.000075362; - case SpecificEnergyUnit.CaloriePerGram: return _value*4.184e3; - case SpecificEnergyUnit.JoulePerKilogram: return _value; - case SpecificEnergyUnit.KilocaloriePerGram: return (_value*4.184e3) * 1e3d; - case SpecificEnergyUnit.KilojoulePerKilogram: return (_value) * 1e3d; - case SpecificEnergyUnit.KilowattHourPerKilogram: return (_value*3.6e3) * 1e3d; - case SpecificEnergyUnit.MegajoulePerKilogram: return (_value) * 1e6d; - case SpecificEnergyUnit.MegawattHourPerKilogram: return (_value*3.6e3) * 1e6d; - case SpecificEnergyUnit.WattHourPerKilogram: return _value*3.6e3; + case SpecificEnergyUnit.BtuPerPound: + return new SpecificEnergy(_value*2326.000075362, BaseUnit); + case SpecificEnergyUnit.CaloriePerGram: + return new SpecificEnergy(_value*4.184e3, BaseUnit); + case SpecificEnergyUnit.JoulePerKilogram: + return new SpecificEnergy(_value, BaseUnit); + case SpecificEnergyUnit.KilocaloriePerGram: + return new SpecificEnergy((_value*4.184e3) * 1e3d, BaseUnit); + case SpecificEnergyUnit.KilojoulePerKilogram: + return new SpecificEnergy((_value) * 1e3d, BaseUnit); + case SpecificEnergyUnit.KilowattHourPerKilogram: + return new SpecificEnergy((_value*3.6e3) * 1e3d, BaseUnit); + case SpecificEnergyUnit.MegajoulePerKilogram: + return new SpecificEnergy((_value) * 1e6d, BaseUnit); + case SpecificEnergyUnit.MegawattHourPerKilogram: + return new SpecificEnergy((_value*3.6e3) * 1e6d, BaseUnit); + case SpecificEnergyUnit.WattHourPerKilogram: + return new SpecificEnergy(_value*3.6e3, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -637,7 +646,8 @@ private double AsBaseNumericType(SpecificEnergyUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEntropy.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEntropy.WindowsRuntimeComponent.g.cs index 2b5bad71d1..f6a75b786a 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEntropy.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEntropy.WindowsRuntimeComponent.g.cs @@ -596,18 +596,26 @@ public SpecificEntropy ToUnit(SpecificEntropyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal SpecificEntropy AsBaseUnit() { switch(Unit) { - case SpecificEntropyUnit.CaloriePerGramKelvin: return _value*4.184e3; - case SpecificEntropyUnit.JoulePerKilogramDegreeCelsius: return _value; - case SpecificEntropyUnit.JoulePerKilogramKelvin: return _value; - case SpecificEntropyUnit.KilocaloriePerGramKelvin: return (_value*4.184e3) * 1e3d; - case SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius: return (_value) * 1e3d; - case SpecificEntropyUnit.KilojoulePerKilogramKelvin: return (_value) * 1e3d; - case SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius: return (_value) * 1e6d; - case SpecificEntropyUnit.MegajoulePerKilogramKelvin: return (_value) * 1e6d; + case SpecificEntropyUnit.CaloriePerGramKelvin: + return new SpecificEntropy(_value*4.184e3, BaseUnit); + case SpecificEntropyUnit.JoulePerKilogramDegreeCelsius: + return new SpecificEntropy(_value, BaseUnit); + case SpecificEntropyUnit.JoulePerKilogramKelvin: + return new SpecificEntropy(_value, BaseUnit); + case SpecificEntropyUnit.KilocaloriePerGramKelvin: + return new SpecificEntropy((_value*4.184e3) * 1e3d, BaseUnit); + case SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius: + return new SpecificEntropy((_value) * 1e3d, BaseUnit); + case SpecificEntropyUnit.KilojoulePerKilogramKelvin: + return new SpecificEntropy((_value) * 1e3d, BaseUnit); + case SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius: + return new SpecificEntropy((_value) * 1e6d, BaseUnit); + case SpecificEntropyUnit.MegajoulePerKilogramKelvin: + return new SpecificEntropy((_value) * 1e6d, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -618,7 +626,8 @@ private double AsBaseNumericType(SpecificEntropyUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificVolume.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificVolume.WindowsRuntimeComponent.g.cs index c139dbbd8a..993682e9bc 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificVolume.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificVolume.WindowsRuntimeComponent.g.cs @@ -521,13 +521,16 @@ public SpecificVolume ToUnit(SpecificVolumeUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal SpecificVolume AsBaseUnit() { switch(Unit) { - case SpecificVolumeUnit.CubicFootPerPound: return _value/16.01846353; - case SpecificVolumeUnit.CubicMeterPerKilogram: return _value; - case SpecificVolumeUnit.MillicubicMeterPerKilogram: return (_value) * 1e-3d; + case SpecificVolumeUnit.CubicFootPerPound: + return new SpecificVolume(_value/16.01846353, BaseUnit); + case SpecificVolumeUnit.CubicMeterPerKilogram: + return new SpecificVolume(_value, BaseUnit); + case SpecificVolumeUnit.MillicubicMeterPerKilogram: + return new SpecificVolume((_value) * 1e-3d, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -538,7 +541,8 @@ private double AsBaseNumericType(SpecificVolumeUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificWeight.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificWeight.WindowsRuntimeComponent.g.cs index 6d8f47f547..30c51b3c39 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificWeight.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificWeight.WindowsRuntimeComponent.g.cs @@ -734,27 +734,44 @@ public SpecificWeight ToUnit(SpecificWeightUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal SpecificWeight AsBaseUnit() { switch(Unit) { - case SpecificWeightUnit.KilogramForcePerCubicCentimeter: return _value*9.80665e6; - case SpecificWeightUnit.KilogramForcePerCubicMeter: return _value*9.80665; - case SpecificWeightUnit.KilogramForcePerCubicMillimeter: return _value*9.80665e9; - case SpecificWeightUnit.KilonewtonPerCubicCentimeter: return (_value*1000000) * 1e3d; - case SpecificWeightUnit.KilonewtonPerCubicMeter: return (_value) * 1e3d; - case SpecificWeightUnit.KilonewtonPerCubicMillimeter: return (_value*1000000000) * 1e3d; - case SpecificWeightUnit.KilopoundForcePerCubicFoot: return (_value*1.570874638462462e2) * 1e3d; - case SpecificWeightUnit.KilopoundForcePerCubicInch: return (_value*2.714471375263134e5) * 1e3d; - case SpecificWeightUnit.MeganewtonPerCubicMeter: return (_value) * 1e6d; - case SpecificWeightUnit.NewtonPerCubicCentimeter: return _value*1000000; - case SpecificWeightUnit.NewtonPerCubicMeter: return _value; - case SpecificWeightUnit.NewtonPerCubicMillimeter: return _value*1000000000; - case SpecificWeightUnit.PoundForcePerCubicFoot: return _value*1.570874638462462e2; - case SpecificWeightUnit.PoundForcePerCubicInch: return _value*2.714471375263134e5; - case SpecificWeightUnit.TonneForcePerCubicCentimeter: return _value*9.80665e9; - case SpecificWeightUnit.TonneForcePerCubicMeter: return _value*9.80665e3; - case SpecificWeightUnit.TonneForcePerCubicMillimeter: return _value*9.80665e12; + case SpecificWeightUnit.KilogramForcePerCubicCentimeter: + return new SpecificWeight(_value*9.80665e6, BaseUnit); + case SpecificWeightUnit.KilogramForcePerCubicMeter: + return new SpecificWeight(_value*9.80665, BaseUnit); + case SpecificWeightUnit.KilogramForcePerCubicMillimeter: + return new SpecificWeight(_value*9.80665e9, BaseUnit); + case SpecificWeightUnit.KilonewtonPerCubicCentimeter: + return new SpecificWeight((_value*1000000) * 1e3d, BaseUnit); + case SpecificWeightUnit.KilonewtonPerCubicMeter: + return new SpecificWeight((_value) * 1e3d, BaseUnit); + case SpecificWeightUnit.KilonewtonPerCubicMillimeter: + return new SpecificWeight((_value*1000000000) * 1e3d, BaseUnit); + case SpecificWeightUnit.KilopoundForcePerCubicFoot: + return new SpecificWeight((_value*1.570874638462462e2) * 1e3d, BaseUnit); + case SpecificWeightUnit.KilopoundForcePerCubicInch: + return new SpecificWeight((_value*2.714471375263134e5) * 1e3d, BaseUnit); + case SpecificWeightUnit.MeganewtonPerCubicMeter: + return new SpecificWeight((_value) * 1e6d, BaseUnit); + case SpecificWeightUnit.NewtonPerCubicCentimeter: + return new SpecificWeight(_value*1000000, BaseUnit); + case SpecificWeightUnit.NewtonPerCubicMeter: + return new SpecificWeight(_value, BaseUnit); + case SpecificWeightUnit.NewtonPerCubicMillimeter: + return new SpecificWeight(_value*1000000000, BaseUnit); + case SpecificWeightUnit.PoundForcePerCubicFoot: + return new SpecificWeight(_value*1.570874638462462e2, BaseUnit); + case SpecificWeightUnit.PoundForcePerCubicInch: + return new SpecificWeight(_value*2.714471375263134e5, BaseUnit); + case SpecificWeightUnit.TonneForcePerCubicCentimeter: + return new SpecificWeight(_value*9.80665e9, BaseUnit); + case SpecificWeightUnit.TonneForcePerCubicMeter: + return new SpecificWeight(_value*9.80665e3, BaseUnit); + case SpecificWeightUnit.TonneForcePerCubicMillimeter: + return new SpecificWeight(_value*9.80665e12, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -765,7 +782,8 @@ private double AsBaseNumericType(SpecificWeightUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Speed.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Speed.WindowsRuntimeComponent.g.cs index c7b3ec280e..136612d29b 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Speed.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Speed.WindowsRuntimeComponent.g.cs @@ -956,42 +956,74 @@ public Speed ToUnit(SpeedUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Speed AsBaseUnit() { switch(Unit) { - case SpeedUnit.CentimeterPerHour: return (_value/3600) * 1e-2d; - case SpeedUnit.CentimeterPerMinute: return (_value/60) * 1e-2d; - case SpeedUnit.CentimeterPerSecond: return (_value) * 1e-2d; - case SpeedUnit.DecimeterPerMinute: return (_value/60) * 1e-1d; - case SpeedUnit.DecimeterPerSecond: return (_value) * 1e-1d; - case SpeedUnit.FootPerHour: return _value*0.3048/3600; - case SpeedUnit.FootPerMinute: return _value*0.3048/60; - case SpeedUnit.FootPerSecond: return _value*0.3048; - case SpeedUnit.InchPerHour: return (_value/3600)*2.54e-2; - case SpeedUnit.InchPerMinute: return (_value/60)*2.54e-2; - case SpeedUnit.InchPerSecond: return _value*2.54e-2; - case SpeedUnit.KilometerPerHour: return (_value/3600) * 1e3d; - case SpeedUnit.KilometerPerMinute: return (_value/60) * 1e3d; - case SpeedUnit.KilometerPerSecond: return (_value) * 1e3d; - case SpeedUnit.Knot: return _value*0.514444; - case SpeedUnit.MeterPerHour: return _value/3600; - case SpeedUnit.MeterPerMinute: return _value/60; - case SpeedUnit.MeterPerSecond: return _value; - case SpeedUnit.MicrometerPerMinute: return (_value/60) * 1e-6d; - case SpeedUnit.MicrometerPerSecond: return (_value) * 1e-6d; - case SpeedUnit.MilePerHour: return _value*0.44704; - case SpeedUnit.MillimeterPerHour: return (_value/3600) * 1e-3d; - case SpeedUnit.MillimeterPerMinute: return (_value/60) * 1e-3d; - case SpeedUnit.MillimeterPerSecond: return (_value) * 1e-3d; - case SpeedUnit.NanometerPerMinute: return (_value/60) * 1e-9d; - case SpeedUnit.NanometerPerSecond: return (_value) * 1e-9d; - case SpeedUnit.UsSurveyFootPerHour: return (_value*1200/3937)/3600; - case SpeedUnit.UsSurveyFootPerMinute: return (_value*1200/3937)/60; - case SpeedUnit.UsSurveyFootPerSecond: return _value*1200/3937; - case SpeedUnit.YardPerHour: return _value*0.9144/3600; - case SpeedUnit.YardPerMinute: return _value*0.9144/60; - case SpeedUnit.YardPerSecond: return _value*0.9144; + case SpeedUnit.CentimeterPerHour: + return new Speed((_value/3600) * 1e-2d, BaseUnit); + case SpeedUnit.CentimeterPerMinute: + return new Speed((_value/60) * 1e-2d, BaseUnit); + case SpeedUnit.CentimeterPerSecond: + return new Speed((_value) * 1e-2d, BaseUnit); + case SpeedUnit.DecimeterPerMinute: + return new Speed((_value/60) * 1e-1d, BaseUnit); + case SpeedUnit.DecimeterPerSecond: + return new Speed((_value) * 1e-1d, BaseUnit); + case SpeedUnit.FootPerHour: + return new Speed(_value*0.3048/3600, BaseUnit); + case SpeedUnit.FootPerMinute: + return new Speed(_value*0.3048/60, BaseUnit); + case SpeedUnit.FootPerSecond: + return new Speed(_value*0.3048, BaseUnit); + case SpeedUnit.InchPerHour: + return new Speed((_value/3600)*2.54e-2, BaseUnit); + case SpeedUnit.InchPerMinute: + return new Speed((_value/60)*2.54e-2, BaseUnit); + case SpeedUnit.InchPerSecond: + return new Speed(_value*2.54e-2, BaseUnit); + case SpeedUnit.KilometerPerHour: + return new Speed((_value/3600) * 1e3d, BaseUnit); + case SpeedUnit.KilometerPerMinute: + return new Speed((_value/60) * 1e3d, BaseUnit); + case SpeedUnit.KilometerPerSecond: + return new Speed((_value) * 1e3d, BaseUnit); + case SpeedUnit.Knot: + return new Speed(_value*0.514444, BaseUnit); + case SpeedUnit.MeterPerHour: + return new Speed(_value/3600, BaseUnit); + case SpeedUnit.MeterPerMinute: + return new Speed(_value/60, BaseUnit); + case SpeedUnit.MeterPerSecond: + return new Speed(_value, BaseUnit); + case SpeedUnit.MicrometerPerMinute: + return new Speed((_value/60) * 1e-6d, BaseUnit); + case SpeedUnit.MicrometerPerSecond: + return new Speed((_value) * 1e-6d, BaseUnit); + case SpeedUnit.MilePerHour: + return new Speed(_value*0.44704, BaseUnit); + case SpeedUnit.MillimeterPerHour: + return new Speed((_value/3600) * 1e-3d, BaseUnit); + case SpeedUnit.MillimeterPerMinute: + return new Speed((_value/60) * 1e-3d, BaseUnit); + case SpeedUnit.MillimeterPerSecond: + return new Speed((_value) * 1e-3d, BaseUnit); + case SpeedUnit.NanometerPerMinute: + return new Speed((_value/60) * 1e-9d, BaseUnit); + case SpeedUnit.NanometerPerSecond: + return new Speed((_value) * 1e-9d, BaseUnit); + case SpeedUnit.UsSurveyFootPerHour: + return new Speed((_value*1200/3937)/3600, BaseUnit); + case SpeedUnit.UsSurveyFootPerMinute: + return new Speed((_value*1200/3937)/60, BaseUnit); + case SpeedUnit.UsSurveyFootPerSecond: + return new Speed(_value*1200/3937, BaseUnit); + case SpeedUnit.YardPerHour: + return new Speed(_value*0.9144/3600, BaseUnit); + case SpeedUnit.YardPerMinute: + return new Speed(_value*0.9144/60, BaseUnit); + case SpeedUnit.YardPerSecond: + return new Speed(_value*0.9144, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -1002,7 +1034,8 @@ private double AsBaseNumericType(SpeedUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Temperature.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Temperature.WindowsRuntimeComponent.g.cs index 77796a121f..ab26301ef8 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Temperature.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Temperature.WindowsRuntimeComponent.g.cs @@ -596,18 +596,26 @@ public Temperature ToUnit(TemperatureUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Temperature AsBaseUnit() { switch(Unit) { - case TemperatureUnit.DegreeCelsius: return _value + 273.15; - case TemperatureUnit.DegreeDelisle: return _value*-2/3 + 373.15; - case TemperatureUnit.DegreeFahrenheit: return _value*5/9 + 459.67*5/9; - case TemperatureUnit.DegreeNewton: return _value*100/33 + 273.15; - case TemperatureUnit.DegreeRankine: return _value*5/9; - case TemperatureUnit.DegreeReaumur: return _value*5/4 + 273.15; - case TemperatureUnit.DegreeRoemer: return _value*40/21 + 273.15 - 7.5*40d/21; - case TemperatureUnit.Kelvin: return _value; + case TemperatureUnit.DegreeCelsius: + return new Temperature(_value + 273.15, BaseUnit); + case TemperatureUnit.DegreeDelisle: + return new Temperature(_value*-2/3 + 373.15, BaseUnit); + case TemperatureUnit.DegreeFahrenheit: + return new Temperature(_value*5/9 + 459.67*5/9, BaseUnit); + case TemperatureUnit.DegreeNewton: + return new Temperature(_value*100/33 + 273.15, BaseUnit); + case TemperatureUnit.DegreeRankine: + return new Temperature(_value*5/9, BaseUnit); + case TemperatureUnit.DegreeReaumur: + return new Temperature(_value*5/4 + 273.15, BaseUnit); + case TemperatureUnit.DegreeRoemer: + return new Temperature(_value*40/21 + 273.15 - 7.5*40d/21, BaseUnit); + case TemperatureUnit.Kelvin: + return new Temperature(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -618,7 +626,8 @@ private double AsBaseNumericType(TemperatureUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureChangeRate.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureChangeRate.WindowsRuntimeComponent.g.cs index 0c244aa4d8..eaf8d61cad 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureChangeRate.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureChangeRate.WindowsRuntimeComponent.g.cs @@ -626,20 +626,30 @@ public TemperatureChangeRate ToUnit(TemperatureChangeRateUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal TemperatureChangeRate AsBaseUnit() { switch(Unit) { - case TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond: return (_value) * 1e-2d; - case TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond: return (_value) * 1e1d; - case TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond: return (_value) * 1e-1d; - case TemperatureChangeRateUnit.DegreeCelsiusPerMinute: return _value/60; - case TemperatureChangeRateUnit.DegreeCelsiusPerSecond: return _value; - case TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond: return (_value) * 1e2d; - case TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond: return (_value) * 1e3d; - case TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond: return (_value) * 1e-6d; - case TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond: return (_value) * 1e-3d; - case TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond: return (_value) * 1e-9d; + case TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond: + return new TemperatureChangeRate((_value) * 1e-2d, BaseUnit); + case TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond: + return new TemperatureChangeRate((_value) * 1e1d, BaseUnit); + case TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond: + return new TemperatureChangeRate((_value) * 1e-1d, BaseUnit); + case TemperatureChangeRateUnit.DegreeCelsiusPerMinute: + return new TemperatureChangeRate(_value/60, BaseUnit); + case TemperatureChangeRateUnit.DegreeCelsiusPerSecond: + return new TemperatureChangeRate(_value, BaseUnit); + case TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond: + return new TemperatureChangeRate((_value) * 1e2d, BaseUnit); + case TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond: + return new TemperatureChangeRate((_value) * 1e3d, BaseUnit); + case TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond: + return new TemperatureChangeRate((_value) * 1e-6d, BaseUnit); + case TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond: + return new TemperatureChangeRate((_value) * 1e-3d, BaseUnit); + case TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond: + return new TemperatureChangeRate((_value) * 1e-9d, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -650,7 +660,8 @@ private double AsBaseNumericType(TemperatureChangeRateUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureDelta.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureDelta.WindowsRuntimeComponent.g.cs index f5343b234c..d91904a35d 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureDelta.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureDelta.WindowsRuntimeComponent.g.cs @@ -596,18 +596,26 @@ public TemperatureDelta ToUnit(TemperatureDeltaUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal TemperatureDelta AsBaseUnit() { switch(Unit) { - case TemperatureDeltaUnit.DegreeCelsius: return _value; - case TemperatureDeltaUnit.DegreeDelisle: return _value*-2/3; - case TemperatureDeltaUnit.DegreeFahrenheit: return _value*5/9; - case TemperatureDeltaUnit.DegreeNewton: return _value*100/33; - case TemperatureDeltaUnit.DegreeRankine: return _value*5/9; - case TemperatureDeltaUnit.DegreeReaumur: return _value*5/4; - case TemperatureDeltaUnit.DegreeRoemer: return _value*40/21; - case TemperatureDeltaUnit.Kelvin: return _value; + case TemperatureDeltaUnit.DegreeCelsius: + return new TemperatureDelta(_value, BaseUnit); + case TemperatureDeltaUnit.DegreeDelisle: + return new TemperatureDelta(_value*-2/3, BaseUnit); + case TemperatureDeltaUnit.DegreeFahrenheit: + return new TemperatureDelta(_value*5/9, BaseUnit); + case TemperatureDeltaUnit.DegreeNewton: + return new TemperatureDelta(_value*100/33, BaseUnit); + case TemperatureDeltaUnit.DegreeRankine: + return new TemperatureDelta(_value*5/9, BaseUnit); + case TemperatureDeltaUnit.DegreeReaumur: + return new TemperatureDelta(_value*5/4, BaseUnit); + case TemperatureDeltaUnit.DegreeRoemer: + return new TemperatureDelta(_value*40/21, BaseUnit); + case TemperatureDeltaUnit.Kelvin: + return new TemperatureDelta(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -618,7 +626,8 @@ private double AsBaseNumericType(TemperatureDeltaUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalConductivity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalConductivity.WindowsRuntimeComponent.g.cs index aaa091df43..88e4d76218 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalConductivity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalConductivity.WindowsRuntimeComponent.g.cs @@ -509,12 +509,14 @@ public ThermalConductivity ToUnit(ThermalConductivityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ThermalConductivity AsBaseUnit() { switch(Unit) { - case ThermalConductivityUnit.BtuPerHourFootFahrenheit: return _value*1.73073467; - case ThermalConductivityUnit.WattPerMeterKelvin: return _value; + case ThermalConductivityUnit.BtuPerHourFootFahrenheit: + return new ThermalConductivity(_value*1.73073467, BaseUnit); + case ThermalConductivityUnit.WattPerMeterKelvin: + return new ThermalConductivity(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -525,7 +527,8 @@ private double AsBaseNumericType(ThermalConductivityUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalResistance.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalResistance.WindowsRuntimeComponent.g.cs index ba41692a9b..f38d1ae1e5 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalResistance.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalResistance.WindowsRuntimeComponent.g.cs @@ -551,15 +551,20 @@ public ThermalResistance ToUnit(ThermalResistanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ThermalResistance AsBaseUnit() { switch(Unit) { - case ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu: return _value*176.1121482159839; - case ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie: return _value*0.0859779507590433; - case ThermalResistanceUnit.SquareCentimeterKelvinPerWatt: return _value*0.0999964777570357; - case ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt: return _value*1000.088056074108; - case ThermalResistanceUnit.SquareMeterKelvinPerKilowatt: return _value; + case ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu: + return new ThermalResistance(_value*176.1121482159839, BaseUnit); + case ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie: + return new ThermalResistance(_value*0.0859779507590433, BaseUnit); + case ThermalResistanceUnit.SquareCentimeterKelvinPerWatt: + return new ThermalResistance(_value*0.0999964777570357, BaseUnit); + case ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt: + return new ThermalResistance(_value*1000.088056074108, BaseUnit); + case ThermalResistanceUnit.SquareMeterKelvinPerKilowatt: + return new ThermalResistance(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -570,7 +575,8 @@ private double AsBaseNumericType(ThermalResistanceUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Torque.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Torque.WindowsRuntimeComponent.g.cs index b94c2afb09..c3030710ed 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Torque.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Torque.WindowsRuntimeComponent.g.cs @@ -791,31 +791,52 @@ public Torque ToUnit(TorqueUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Torque AsBaseUnit() { switch(Unit) { - case TorqueUnit.KilogramForceCentimeter: return _value*0.0980665019960652; - case TorqueUnit.KilogramForceMeter: return _value*9.80665019960652; - case TorqueUnit.KilogramForceMillimeter: return _value*0.00980665019960652; - case TorqueUnit.KilonewtonCentimeter: return (_value*0.01) * 1e3d; - case TorqueUnit.KilonewtonMeter: return (_value) * 1e3d; - case TorqueUnit.KilonewtonMillimeter: return (_value*0.001) * 1e3d; - case TorqueUnit.KilopoundForceFoot: return (_value*1.3558179483314) * 1e3d; - case TorqueUnit.KilopoundForceInch: return (_value*1.129848290276167e-1) * 1e3d; - case TorqueUnit.MeganewtonCentimeter: return (_value*0.01) * 1e6d; - case TorqueUnit.MeganewtonMeter: return (_value) * 1e6d; - case TorqueUnit.MeganewtonMillimeter: return (_value*0.001) * 1e6d; - case TorqueUnit.MegapoundForceFoot: return (_value*1.3558179483314) * 1e6d; - case TorqueUnit.MegapoundForceInch: return (_value*1.129848290276167e-1) * 1e6d; - case TorqueUnit.NewtonCentimeter: return _value*0.01; - case TorqueUnit.NewtonMeter: return _value; - case TorqueUnit.NewtonMillimeter: return _value*0.001; - case TorqueUnit.PoundForceFoot: return _value*1.3558179483314; - case TorqueUnit.PoundForceInch: return _value*1.129848290276167e-1; - case TorqueUnit.TonneForceCentimeter: return _value*98.0665019960652; - case TorqueUnit.TonneForceMeter: return _value*9806.65019960653; - case TorqueUnit.TonneForceMillimeter: return _value*9.80665019960652; + case TorqueUnit.KilogramForceCentimeter: + return new Torque(_value*0.0980665019960652, BaseUnit); + case TorqueUnit.KilogramForceMeter: + return new Torque(_value*9.80665019960652, BaseUnit); + case TorqueUnit.KilogramForceMillimeter: + return new Torque(_value*0.00980665019960652, BaseUnit); + case TorqueUnit.KilonewtonCentimeter: + return new Torque((_value*0.01) * 1e3d, BaseUnit); + case TorqueUnit.KilonewtonMeter: + return new Torque((_value) * 1e3d, BaseUnit); + case TorqueUnit.KilonewtonMillimeter: + return new Torque((_value*0.001) * 1e3d, BaseUnit); + case TorqueUnit.KilopoundForceFoot: + return new Torque((_value*1.3558179483314) * 1e3d, BaseUnit); + case TorqueUnit.KilopoundForceInch: + return new Torque((_value*1.129848290276167e-1) * 1e3d, BaseUnit); + case TorqueUnit.MeganewtonCentimeter: + return new Torque((_value*0.01) * 1e6d, BaseUnit); + case TorqueUnit.MeganewtonMeter: + return new Torque((_value) * 1e6d, BaseUnit); + case TorqueUnit.MeganewtonMillimeter: + return new Torque((_value*0.001) * 1e6d, BaseUnit); + case TorqueUnit.MegapoundForceFoot: + return new Torque((_value*1.3558179483314) * 1e6d, BaseUnit); + case TorqueUnit.MegapoundForceInch: + return new Torque((_value*1.129848290276167e-1) * 1e6d, BaseUnit); + case TorqueUnit.NewtonCentimeter: + return new Torque(_value*0.01, BaseUnit); + case TorqueUnit.NewtonMeter: + return new Torque(_value, BaseUnit); + case TorqueUnit.NewtonMillimeter: + return new Torque(_value*0.001, BaseUnit); + case TorqueUnit.PoundForceFoot: + return new Torque(_value*1.3558179483314, BaseUnit); + case TorqueUnit.PoundForceInch: + return new Torque(_value*1.129848290276167e-1, BaseUnit); + case TorqueUnit.TonneForceCentimeter: + return new Torque(_value*98.0665019960652, BaseUnit); + case TorqueUnit.TonneForceMeter: + return new Torque(_value*9806.65019960653, BaseUnit); + case TorqueUnit.TonneForceMillimeter: + return new Torque(_value*9.80665019960652, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -826,7 +847,8 @@ private double AsBaseNumericType(TorqueUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VitaminA.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VitaminA.WindowsRuntimeComponent.g.cs index ae58a1d057..0357f107ba 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VitaminA.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VitaminA.WindowsRuntimeComponent.g.cs @@ -491,11 +491,12 @@ public VitaminA ToUnit(VitaminAUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal VitaminA AsBaseUnit() { switch(Unit) { - case VitaminAUnit.InternationalUnit: return _value; + case VitaminAUnit.InternationalUnit: + return new VitaminA(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -506,7 +507,8 @@ private double AsBaseNumericType(VitaminAUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Volume.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Volume.WindowsRuntimeComponent.g.cs index 84fa309611..ac1b69a063 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Volume.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Volume.WindowsRuntimeComponent.g.cs @@ -1151,55 +1151,100 @@ public Volume ToUnit(VolumeUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Volume AsBaseUnit() { switch(Unit) { - case VolumeUnit.AcreFoot: return _value/0.000810714; - case VolumeUnit.AuTablespoon: return _value*2e-5; - case VolumeUnit.Centiliter: return (_value/1e3) * 1e-2d; - case VolumeUnit.CubicCentimeter: return _value/1e6; - case VolumeUnit.CubicDecimeter: return _value/1e3; - case VolumeUnit.CubicFoot: return _value*0.0283168; - case VolumeUnit.CubicInch: return _value*1.6387*1e-5; - case VolumeUnit.CubicKilometer: return _value*1e9; - case VolumeUnit.CubicMeter: return _value; - case VolumeUnit.CubicMicrometer: return _value/1e18; - case VolumeUnit.CubicMile: return _value*4.16818182544058e9; - case VolumeUnit.CubicMillimeter: return _value/1e9; - case VolumeUnit.CubicYard: return _value*0.764554858; - case VolumeUnit.Deciliter: return (_value/1e3) * 1e-1d; - case VolumeUnit.HectocubicFoot: return (_value*0.0283168) * 1e2d; - case VolumeUnit.HectocubicMeter: return (_value) * 1e2d; - case VolumeUnit.Hectoliter: return (_value/1e3) * 1e2d; - case VolumeUnit.ImperialBeerBarrel: return _value*0.16365924; - case VolumeUnit.ImperialGallon: return _value*0.00454609000000181429905810072407; - case VolumeUnit.ImperialOunce: return _value*2.8413062499962901241875439064617e-5; - case VolumeUnit.KilocubicFoot: return (_value*0.0283168) * 1e3d; - case VolumeUnit.KilocubicMeter: return (_value) * 1e3d; - case VolumeUnit.KiloimperialGallon: return (_value*0.00454609000000181429905810072407) * 1e3d; - case VolumeUnit.Kiloliter: return (_value/1e3) * 1e3d; - case VolumeUnit.KilousGallon: return (_value*0.00378541) * 1e3d; - case VolumeUnit.Liter: return _value/1e3; - case VolumeUnit.MegacubicFoot: return (_value*0.0283168) * 1e6d; - case VolumeUnit.MegaimperialGallon: return (_value*0.00454609000000181429905810072407) * 1e6d; - case VolumeUnit.Megaliter: return (_value/1e3) * 1e6d; - case VolumeUnit.MegausGallon: return (_value*0.00378541) * 1e6d; - case VolumeUnit.MetricCup: return _value*0.00025; - case VolumeUnit.MetricTeaspoon: return _value*0.5e-5; - case VolumeUnit.Microliter: return (_value/1e3) * 1e-6d; - case VolumeUnit.Milliliter: return (_value/1e3) * 1e-3d; - case VolumeUnit.OilBarrel: return _value*0.158987294928; - case VolumeUnit.UkTablespoon: return _value*1.5e-5; - case VolumeUnit.UsBeerBarrel: return _value*0.1173477658; - case VolumeUnit.UsCustomaryCup: return _value*0.0002365882365; - case VolumeUnit.UsGallon: return _value*0.00378541; - case VolumeUnit.UsLegalCup: return _value*0.00024; - case VolumeUnit.UsOunce: return _value*2.957352956253760505068307980135e-5; - case VolumeUnit.UsPint: return _value*4.73176473e-4; - case VolumeUnit.UsQuart: return _value*9.46352946e-4; - case VolumeUnit.UsTablespoon: return _value*1.478676478125e-5; - case VolumeUnit.UsTeaspoon: return _value*4.92892159375e-6; + case VolumeUnit.AcreFoot: + return new Volume(_value/0.000810714, BaseUnit); + case VolumeUnit.AuTablespoon: + return new Volume(_value*2e-5, BaseUnit); + case VolumeUnit.Centiliter: + return new Volume((_value/1e3) * 1e-2d, BaseUnit); + case VolumeUnit.CubicCentimeter: + return new Volume(_value/1e6, BaseUnit); + case VolumeUnit.CubicDecimeter: + return new Volume(_value/1e3, BaseUnit); + case VolumeUnit.CubicFoot: + return new Volume(_value*0.0283168, BaseUnit); + case VolumeUnit.CubicInch: + return new Volume(_value*1.6387*1e-5, BaseUnit); + case VolumeUnit.CubicKilometer: + return new Volume(_value*1e9, BaseUnit); + case VolumeUnit.CubicMeter: + return new Volume(_value, BaseUnit); + case VolumeUnit.CubicMicrometer: + return new Volume(_value/1e18, BaseUnit); + case VolumeUnit.CubicMile: + return new Volume(_value*4.16818182544058e9, BaseUnit); + case VolumeUnit.CubicMillimeter: + return new Volume(_value/1e9, BaseUnit); + case VolumeUnit.CubicYard: + return new Volume(_value*0.764554858, BaseUnit); + case VolumeUnit.Deciliter: + return new Volume((_value/1e3) * 1e-1d, BaseUnit); + case VolumeUnit.HectocubicFoot: + return new Volume((_value*0.0283168) * 1e2d, BaseUnit); + case VolumeUnit.HectocubicMeter: + return new Volume((_value) * 1e2d, BaseUnit); + case VolumeUnit.Hectoliter: + return new Volume((_value/1e3) * 1e2d, BaseUnit); + case VolumeUnit.ImperialBeerBarrel: + return new Volume(_value*0.16365924, BaseUnit); + case VolumeUnit.ImperialGallon: + return new Volume(_value*0.00454609000000181429905810072407, BaseUnit); + case VolumeUnit.ImperialOunce: + return new Volume(_value*2.8413062499962901241875439064617e-5, BaseUnit); + case VolumeUnit.KilocubicFoot: + return new Volume((_value*0.0283168) * 1e3d, BaseUnit); + case VolumeUnit.KilocubicMeter: + return new Volume((_value) * 1e3d, BaseUnit); + case VolumeUnit.KiloimperialGallon: + return new Volume((_value*0.00454609000000181429905810072407) * 1e3d, BaseUnit); + case VolumeUnit.Kiloliter: + return new Volume((_value/1e3) * 1e3d, BaseUnit); + case VolumeUnit.KilousGallon: + return new Volume((_value*0.00378541) * 1e3d, BaseUnit); + case VolumeUnit.Liter: + return new Volume(_value/1e3, BaseUnit); + case VolumeUnit.MegacubicFoot: + return new Volume((_value*0.0283168) * 1e6d, BaseUnit); + case VolumeUnit.MegaimperialGallon: + return new Volume((_value*0.00454609000000181429905810072407) * 1e6d, BaseUnit); + case VolumeUnit.Megaliter: + return new Volume((_value/1e3) * 1e6d, BaseUnit); + case VolumeUnit.MegausGallon: + return new Volume((_value*0.00378541) * 1e6d, BaseUnit); + case VolumeUnit.MetricCup: + return new Volume(_value*0.00025, BaseUnit); + case VolumeUnit.MetricTeaspoon: + return new Volume(_value*0.5e-5, BaseUnit); + case VolumeUnit.Microliter: + return new Volume((_value/1e3) * 1e-6d, BaseUnit); + case VolumeUnit.Milliliter: + return new Volume((_value/1e3) * 1e-3d, BaseUnit); + case VolumeUnit.OilBarrel: + return new Volume(_value*0.158987294928, BaseUnit); + case VolumeUnit.UkTablespoon: + return new Volume(_value*1.5e-5, BaseUnit); + case VolumeUnit.UsBeerBarrel: + return new Volume(_value*0.1173477658, BaseUnit); + case VolumeUnit.UsCustomaryCup: + return new Volume(_value*0.0002365882365, BaseUnit); + case VolumeUnit.UsGallon: + return new Volume(_value*0.00378541, BaseUnit); + case VolumeUnit.UsLegalCup: + return new Volume(_value*0.00024, BaseUnit); + case VolumeUnit.UsOunce: + return new Volume(_value*2.957352956253760505068307980135e-5, BaseUnit); + case VolumeUnit.UsPint: + return new Volume(_value*4.73176473e-4, BaseUnit); + case VolumeUnit.UsQuart: + return new Volume(_value*9.46352946e-4, BaseUnit); + case VolumeUnit.UsTablespoon: + return new Volume(_value*1.478676478125e-5, BaseUnit); + case VolumeUnit.UsTeaspoon: + return new Volume(_value*4.92892159375e-6, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -1210,7 +1255,8 @@ private double AsBaseNumericType(VolumeUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeFlow.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeFlow.WindowsRuntimeComponent.g.cs index 21babd80b2..4d9053066e 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeFlow.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeFlow.WindowsRuntimeComponent.g.cs @@ -1196,58 +1196,106 @@ public VolumeFlow ToUnit(VolumeFlowUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal VolumeFlow AsBaseUnit() { switch(Unit) { - case VolumeFlowUnit.AcreFootPerDay: return _value/70.0457; - case VolumeFlowUnit.AcreFootPerHour: return _value/2.91857; - case VolumeFlowUnit.AcreFootPerMinute: return _value/0.0486427916; - case VolumeFlowUnit.AcreFootPerSecond: return _value/0.000810713194; - case VolumeFlowUnit.CentiliterPerDay: return (_value/86400000) * 1e-2d; - case VolumeFlowUnit.CentiliterPerMinute: return (_value/60000.00000) * 1e-2d; - case VolumeFlowUnit.CubicDecimeterPerMinute: return _value/60000.00000; - case VolumeFlowUnit.CubicFootPerHour: return _value*7.8657907199999087346816086183876e-6; - case VolumeFlowUnit.CubicFootPerMinute: return _value/2118.88000326; - case VolumeFlowUnit.CubicFootPerSecond: return _value/35.314666721; - case VolumeFlowUnit.CubicMeterPerDay: return _value/86400; - case VolumeFlowUnit.CubicMeterPerHour: return _value/3600; - case VolumeFlowUnit.CubicMeterPerMinute: return _value/60; - case VolumeFlowUnit.CubicMeterPerSecond: return _value; - case VolumeFlowUnit.CubicMillimeterPerSecond: return _value*1e-9; - case VolumeFlowUnit.CubicYardPerDay: return _value/113007; - case VolumeFlowUnit.CubicYardPerHour: return _value*2.1237634944E-4; - case VolumeFlowUnit.CubicYardPerMinute: return _value*0.0127425809664; - case VolumeFlowUnit.CubicYardPerSecond: return _value*0.764554857984; - case VolumeFlowUnit.DeciliterPerDay: return (_value/86400000) * 1e-1d; - case VolumeFlowUnit.DeciliterPerMinute: return (_value/60000.00000) * 1e-1d; - case VolumeFlowUnit.KiloliterPerDay: return (_value/86400000) * 1e3d; - case VolumeFlowUnit.KiloliterPerMinute: return (_value/60000.00000) * 1e3d; - case VolumeFlowUnit.KilousGallonPerMinute: return _value/15.850323141489; - case VolumeFlowUnit.LiterPerDay: return _value/86400000; - case VolumeFlowUnit.LiterPerHour: return _value/3600000.000; - case VolumeFlowUnit.LiterPerMinute: return _value/60000.00000; - case VolumeFlowUnit.LiterPerSecond: return _value/1000; - case VolumeFlowUnit.MegaliterPerDay: return (_value/86400000) * 1e6d; - case VolumeFlowUnit.MegaukGallonPerSecond: return (_value/219.969) * 1e6d; - case VolumeFlowUnit.MicroliterPerDay: return (_value/86400000) * 1e-6d; - case VolumeFlowUnit.MicroliterPerMinute: return (_value/60000.00000) * 1e-6d; - case VolumeFlowUnit.MilliliterPerDay: return (_value/86400000) * 1e-3d; - case VolumeFlowUnit.MilliliterPerMinute: return (_value/60000.00000) * 1e-3d; - case VolumeFlowUnit.MillionUsGallonsPerDay: return _value/22.824465227; - case VolumeFlowUnit.NanoliterPerDay: return (_value/86400000) * 1e-9d; - case VolumeFlowUnit.NanoliterPerMinute: return (_value/60000.00000) * 1e-9d; - case VolumeFlowUnit.OilBarrelPerDay: return _value*1.8401307283333333333333333333333e-6; - case VolumeFlowUnit.OilBarrelPerHour: return _value*4.41631375e-5; - case VolumeFlowUnit.OilBarrelPerMinute: return _value*2.64978825e-3; - case VolumeFlowUnit.OilBarrelPerSecond: return _value/6.28981; - case VolumeFlowUnit.UkGallonPerDay: return _value/19005304; - case VolumeFlowUnit.UkGallonPerMinute: return _value/13198.2; - case VolumeFlowUnit.UkGallonPerSecond: return _value/219.969; - case VolumeFlowUnit.UsGallonPerDay: return _value/22824465.227; - case VolumeFlowUnit.UsGallonPerHour: return _value/951019.38848933424; - case VolumeFlowUnit.UsGallonPerMinute: return _value/15850.323141489; - case VolumeFlowUnit.UsGallonPerSecond: return _value/264.1720523581484; + case VolumeFlowUnit.AcreFootPerDay: + return new VolumeFlow(_value/70.0457, BaseUnit); + case VolumeFlowUnit.AcreFootPerHour: + return new VolumeFlow(_value/2.91857, BaseUnit); + case VolumeFlowUnit.AcreFootPerMinute: + return new VolumeFlow(_value/0.0486427916, BaseUnit); + case VolumeFlowUnit.AcreFootPerSecond: + return new VolumeFlow(_value/0.000810713194, BaseUnit); + case VolumeFlowUnit.CentiliterPerDay: + return new VolumeFlow((_value/86400000) * 1e-2d, BaseUnit); + case VolumeFlowUnit.CentiliterPerMinute: + return new VolumeFlow((_value/60000.00000) * 1e-2d, BaseUnit); + case VolumeFlowUnit.CubicDecimeterPerMinute: + return new VolumeFlow(_value/60000.00000, BaseUnit); + case VolumeFlowUnit.CubicFootPerHour: + return new VolumeFlow(_value*7.8657907199999087346816086183876e-6, BaseUnit); + case VolumeFlowUnit.CubicFootPerMinute: + return new VolumeFlow(_value/2118.88000326, BaseUnit); + case VolumeFlowUnit.CubicFootPerSecond: + return new VolumeFlow(_value/35.314666721, BaseUnit); + case VolumeFlowUnit.CubicMeterPerDay: + return new VolumeFlow(_value/86400, BaseUnit); + case VolumeFlowUnit.CubicMeterPerHour: + return new VolumeFlow(_value/3600, BaseUnit); + case VolumeFlowUnit.CubicMeterPerMinute: + return new VolumeFlow(_value/60, BaseUnit); + case VolumeFlowUnit.CubicMeterPerSecond: + return new VolumeFlow(_value, BaseUnit); + case VolumeFlowUnit.CubicMillimeterPerSecond: + return new VolumeFlow(_value*1e-9, BaseUnit); + case VolumeFlowUnit.CubicYardPerDay: + return new VolumeFlow(_value/113007, BaseUnit); + case VolumeFlowUnit.CubicYardPerHour: + return new VolumeFlow(_value*2.1237634944E-4, BaseUnit); + case VolumeFlowUnit.CubicYardPerMinute: + return new VolumeFlow(_value*0.0127425809664, BaseUnit); + case VolumeFlowUnit.CubicYardPerSecond: + return new VolumeFlow(_value*0.764554857984, BaseUnit); + case VolumeFlowUnit.DeciliterPerDay: + return new VolumeFlow((_value/86400000) * 1e-1d, BaseUnit); + case VolumeFlowUnit.DeciliterPerMinute: + return new VolumeFlow((_value/60000.00000) * 1e-1d, BaseUnit); + case VolumeFlowUnit.KiloliterPerDay: + return new VolumeFlow((_value/86400000) * 1e3d, BaseUnit); + case VolumeFlowUnit.KiloliterPerMinute: + return new VolumeFlow((_value/60000.00000) * 1e3d, BaseUnit); + case VolumeFlowUnit.KilousGallonPerMinute: + return new VolumeFlow(_value/15.850323141489, BaseUnit); + case VolumeFlowUnit.LiterPerDay: + return new VolumeFlow(_value/86400000, BaseUnit); + case VolumeFlowUnit.LiterPerHour: + return new VolumeFlow(_value/3600000.000, BaseUnit); + case VolumeFlowUnit.LiterPerMinute: + return new VolumeFlow(_value/60000.00000, BaseUnit); + case VolumeFlowUnit.LiterPerSecond: + return new VolumeFlow(_value/1000, BaseUnit); + case VolumeFlowUnit.MegaliterPerDay: + return new VolumeFlow((_value/86400000) * 1e6d, BaseUnit); + case VolumeFlowUnit.MegaukGallonPerSecond: + return new VolumeFlow((_value/219.969) * 1e6d, BaseUnit); + case VolumeFlowUnit.MicroliterPerDay: + return new VolumeFlow((_value/86400000) * 1e-6d, BaseUnit); + case VolumeFlowUnit.MicroliterPerMinute: + return new VolumeFlow((_value/60000.00000) * 1e-6d, BaseUnit); + case VolumeFlowUnit.MilliliterPerDay: + return new VolumeFlow((_value/86400000) * 1e-3d, BaseUnit); + case VolumeFlowUnit.MilliliterPerMinute: + return new VolumeFlow((_value/60000.00000) * 1e-3d, BaseUnit); + case VolumeFlowUnit.MillionUsGallonsPerDay: + return new VolumeFlow(_value/22.824465227, BaseUnit); + case VolumeFlowUnit.NanoliterPerDay: + return new VolumeFlow((_value/86400000) * 1e-9d, BaseUnit); + case VolumeFlowUnit.NanoliterPerMinute: + return new VolumeFlow((_value/60000.00000) * 1e-9d, BaseUnit); + case VolumeFlowUnit.OilBarrelPerDay: + return new VolumeFlow(_value*1.8401307283333333333333333333333e-6, BaseUnit); + case VolumeFlowUnit.OilBarrelPerHour: + return new VolumeFlow(_value*4.41631375e-5, BaseUnit); + case VolumeFlowUnit.OilBarrelPerMinute: + return new VolumeFlow(_value*2.64978825e-3, BaseUnit); + case VolumeFlowUnit.OilBarrelPerSecond: + return new VolumeFlow(_value/6.28981, BaseUnit); + case VolumeFlowUnit.UkGallonPerDay: + return new VolumeFlow(_value/19005304, BaseUnit); + case VolumeFlowUnit.UkGallonPerMinute: + return new VolumeFlow(_value/13198.2, BaseUnit); + case VolumeFlowUnit.UkGallonPerSecond: + return new VolumeFlow(_value/219.969, BaseUnit); + case VolumeFlowUnit.UsGallonPerDay: + return new VolumeFlow(_value/22824465.227, BaseUnit); + case VolumeFlowUnit.UsGallonPerHour: + return new VolumeFlow(_value/951019.38848933424, BaseUnit); + case VolumeFlowUnit.UsGallonPerMinute: + return new VolumeFlow(_value/15850.323141489, BaseUnit); + case VolumeFlowUnit.UsGallonPerSecond: + return new VolumeFlow(_value/264.1720523581484, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -1258,7 +1306,8 @@ private double AsBaseNumericType(VolumeFlowUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Acceleration.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Acceleration.NetFramework.g.cs index 84ccd613a6..ff40fbc367 100644 --- a/UnitsNet/GeneratedCode/Quantities/Acceleration.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Acceleration.NetFramework.g.cs @@ -705,23 +705,36 @@ public Acceleration ToUnit(AccelerationUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Acceleration AsBaseUnit() { switch(Unit) { - case AccelerationUnit.CentimeterPerSecondSquared: return (_value) * 1e-2d; - case AccelerationUnit.DecimeterPerSecondSquared: return (_value) * 1e-1d; - case AccelerationUnit.FootPerSecondSquared: return _value*0.304800; - case AccelerationUnit.InchPerSecondSquared: return _value*0.0254; - case AccelerationUnit.KilometerPerSecondSquared: return (_value) * 1e3d; - case AccelerationUnit.KnotPerHour: return _value*0.5144444444444/3600; - case AccelerationUnit.KnotPerMinute: return _value*0.5144444444444/60; - case AccelerationUnit.KnotPerSecond: return _value*0.5144444444444; - case AccelerationUnit.MeterPerSecondSquared: return _value; - case AccelerationUnit.MicrometerPerSecondSquared: return (_value) * 1e-6d; - case AccelerationUnit.MillimeterPerSecondSquared: return (_value) * 1e-3d; - case AccelerationUnit.NanometerPerSecondSquared: return (_value) * 1e-9d; - case AccelerationUnit.StandardGravity: return _value*9.80665; + case AccelerationUnit.CentimeterPerSecondSquared: + return new Acceleration((_value) * 1e-2d, BaseUnit); + case AccelerationUnit.DecimeterPerSecondSquared: + return new Acceleration((_value) * 1e-1d, BaseUnit); + case AccelerationUnit.FootPerSecondSquared: + return new Acceleration(_value*0.304800, BaseUnit); + case AccelerationUnit.InchPerSecondSquared: + return new Acceleration(_value*0.0254, BaseUnit); + case AccelerationUnit.KilometerPerSecondSquared: + return new Acceleration((_value) * 1e3d, BaseUnit); + case AccelerationUnit.KnotPerHour: + return new Acceleration(_value*0.5144444444444/3600, BaseUnit); + case AccelerationUnit.KnotPerMinute: + return new Acceleration(_value*0.5144444444444/60, BaseUnit); + case AccelerationUnit.KnotPerSecond: + return new Acceleration(_value*0.5144444444444, BaseUnit); + case AccelerationUnit.MeterPerSecondSquared: + return new Acceleration(_value, BaseUnit); + case AccelerationUnit.MicrometerPerSecondSquared: + return new Acceleration((_value) * 1e-6d, BaseUnit); + case AccelerationUnit.MillimeterPerSecondSquared: + return new Acceleration((_value) * 1e-3d, BaseUnit); + case AccelerationUnit.NanometerPerSecondSquared: + return new Acceleration((_value) * 1e-9d, BaseUnit); + case AccelerationUnit.StandardGravity: + return new Acceleration(_value*9.80665, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -732,7 +745,8 @@ private double AsBaseNumericType(AccelerationUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.NetFramework.g.cs index 90bf50a26d..a50e23a711 100644 --- a/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.NetFramework.g.cs @@ -733,25 +733,40 @@ public AmountOfSubstance ToUnit(AmountOfSubstanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal AmountOfSubstance AsBaseUnit() { switch(Unit) { - case AmountOfSubstanceUnit.Centimole: return (_value) * 1e-2d; - case AmountOfSubstanceUnit.CentipoundMole: return (_value*453.59237) * 1e-2d; - case AmountOfSubstanceUnit.Decimole: return (_value) * 1e-1d; - case AmountOfSubstanceUnit.DecipoundMole: return (_value*453.59237) * 1e-1d; - case AmountOfSubstanceUnit.Kilomole: return (_value) * 1e3d; - case AmountOfSubstanceUnit.KilopoundMole: return (_value*453.59237) * 1e3d; - case AmountOfSubstanceUnit.Megamole: return (_value) * 1e6d; - case AmountOfSubstanceUnit.Micromole: return (_value) * 1e-6d; - case AmountOfSubstanceUnit.MicropoundMole: return (_value*453.59237) * 1e-6d; - case AmountOfSubstanceUnit.Millimole: return (_value) * 1e-3d; - case AmountOfSubstanceUnit.MillipoundMole: return (_value*453.59237) * 1e-3d; - case AmountOfSubstanceUnit.Mole: return _value; - case AmountOfSubstanceUnit.Nanomole: return (_value) * 1e-9d; - case AmountOfSubstanceUnit.NanopoundMole: return (_value*453.59237) * 1e-9d; - case AmountOfSubstanceUnit.PoundMole: return _value*453.59237; + case AmountOfSubstanceUnit.Centimole: + return new AmountOfSubstance((_value) * 1e-2d, BaseUnit); + case AmountOfSubstanceUnit.CentipoundMole: + return new AmountOfSubstance((_value*453.59237) * 1e-2d, BaseUnit); + case AmountOfSubstanceUnit.Decimole: + return new AmountOfSubstance((_value) * 1e-1d, BaseUnit); + case AmountOfSubstanceUnit.DecipoundMole: + return new AmountOfSubstance((_value*453.59237) * 1e-1d, BaseUnit); + case AmountOfSubstanceUnit.Kilomole: + return new AmountOfSubstance((_value) * 1e3d, BaseUnit); + case AmountOfSubstanceUnit.KilopoundMole: + return new AmountOfSubstance((_value*453.59237) * 1e3d, BaseUnit); + case AmountOfSubstanceUnit.Megamole: + return new AmountOfSubstance((_value) * 1e6d, BaseUnit); + case AmountOfSubstanceUnit.Micromole: + return new AmountOfSubstance((_value) * 1e-6d, BaseUnit); + case AmountOfSubstanceUnit.MicropoundMole: + return new AmountOfSubstance((_value*453.59237) * 1e-6d, BaseUnit); + case AmountOfSubstanceUnit.Millimole: + return new AmountOfSubstance((_value) * 1e-3d, BaseUnit); + case AmountOfSubstanceUnit.MillipoundMole: + return new AmountOfSubstance((_value*453.59237) * 1e-3d, BaseUnit); + case AmountOfSubstanceUnit.Mole: + return new AmountOfSubstance(_value, BaseUnit); + case AmountOfSubstanceUnit.Nanomole: + return new AmountOfSubstance((_value) * 1e-9d, BaseUnit); + case AmountOfSubstanceUnit.NanopoundMole: + return new AmountOfSubstance((_value*453.59237) * 1e-9d, BaseUnit); + case AmountOfSubstanceUnit.PoundMole: + return new AmountOfSubstance(_value*453.59237, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -762,7 +777,8 @@ private double AsBaseNumericType(AmountOfSubstanceUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.NetFramework.g.cs index 5c92424eee..3575a340af 100644 --- a/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.NetFramework.g.cs @@ -587,14 +587,18 @@ public AmplitudeRatio ToUnit(AmplitudeRatioUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal AmplitudeRatio AsBaseUnit() { switch(Unit) { - case AmplitudeRatioUnit.DecibelMicrovolt: return _value - 120; - case AmplitudeRatioUnit.DecibelMillivolt: return _value - 60; - case AmplitudeRatioUnit.DecibelUnloaded: return _value - 2.218487499; - case AmplitudeRatioUnit.DecibelVolt: return _value; + case AmplitudeRatioUnit.DecibelMicrovolt: + return new AmplitudeRatio(_value - 120, BaseUnit); + case AmplitudeRatioUnit.DecibelMillivolt: + return new AmplitudeRatio(_value - 60, BaseUnit); + case AmplitudeRatioUnit.DecibelUnloaded: + return new AmplitudeRatio(_value - 2.218487499, BaseUnit); + case AmplitudeRatioUnit.DecibelVolt: + return new AmplitudeRatio(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -605,7 +609,8 @@ private double AsBaseNumericType(AmplitudeRatioUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Angle.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Angle.NetFramework.g.cs index da67ba174f..97b2e5c248 100644 --- a/UnitsNet/GeneratedCode/Quantities/Angle.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Angle.NetFramework.g.cs @@ -719,24 +719,38 @@ public Angle ToUnit(AngleUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Angle AsBaseUnit() { switch(Unit) { - case AngleUnit.Arcminute: return _value/60; - case AngleUnit.Arcsecond: return _value/3600; - case AngleUnit.Centiradian: return (_value*180/Math.PI) * 1e-2d; - case AngleUnit.Deciradian: return (_value*180/Math.PI) * 1e-1d; - case AngleUnit.Degree: return _value; - case AngleUnit.Gradian: return _value*0.9; - case AngleUnit.Microdegree: return (_value) * 1e-6d; - case AngleUnit.Microradian: return (_value*180/Math.PI) * 1e-6d; - case AngleUnit.Millidegree: return (_value) * 1e-3d; - case AngleUnit.Milliradian: return (_value*180/Math.PI) * 1e-3d; - case AngleUnit.Nanodegree: return (_value) * 1e-9d; - case AngleUnit.Nanoradian: return (_value*180/Math.PI) * 1e-9d; - case AngleUnit.Radian: return _value*180/Math.PI; - case AngleUnit.Revolution: return _value*360; + case AngleUnit.Arcminute: + return new Angle(_value/60, BaseUnit); + case AngleUnit.Arcsecond: + return new Angle(_value/3600, BaseUnit); + case AngleUnit.Centiradian: + return new Angle((_value*180/Math.PI) * 1e-2d, BaseUnit); + case AngleUnit.Deciradian: + return new Angle((_value*180/Math.PI) * 1e-1d, BaseUnit); + case AngleUnit.Degree: + return new Angle(_value, BaseUnit); + case AngleUnit.Gradian: + return new Angle(_value*0.9, BaseUnit); + case AngleUnit.Microdegree: + return new Angle((_value) * 1e-6d, BaseUnit); + case AngleUnit.Microradian: + return new Angle((_value*180/Math.PI) * 1e-6d, BaseUnit); + case AngleUnit.Millidegree: + return new Angle((_value) * 1e-3d, BaseUnit); + case AngleUnit.Milliradian: + return new Angle((_value*180/Math.PI) * 1e-3d, BaseUnit); + case AngleUnit.Nanodegree: + return new Angle((_value) * 1e-9d, BaseUnit); + case AngleUnit.Nanoradian: + return new Angle((_value*180/Math.PI) * 1e-9d, BaseUnit); + case AngleUnit.Radian: + return new Angle(_value*180/Math.PI, BaseUnit); + case AngleUnit.Revolution: + return new Angle(_value*360, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -747,7 +761,8 @@ private double AsBaseNumericType(AngleUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ApparentEnergy.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ApparentEnergy.NetFramework.g.cs index d9ffd9f485..9dfdcb3dca 100644 --- a/UnitsNet/GeneratedCode/Quantities/ApparentEnergy.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ApparentEnergy.NetFramework.g.cs @@ -565,13 +565,16 @@ public ApparentEnergy ToUnit(ApparentEnergyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ApparentEnergy AsBaseUnit() { switch(Unit) { - case ApparentEnergyUnit.KilovoltampereHour: return (_value) * 1e3d; - case ApparentEnergyUnit.MegavoltampereHour: return (_value) * 1e6d; - case ApparentEnergyUnit.VoltampereHour: return _value; + case ApparentEnergyUnit.KilovoltampereHour: + return new ApparentEnergy((_value) * 1e3d, BaseUnit); + case ApparentEnergyUnit.MegavoltampereHour: + return new ApparentEnergy((_value) * 1e6d, BaseUnit); + case ApparentEnergyUnit.VoltampereHour: + return new ApparentEnergy(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -582,7 +585,8 @@ private double AsBaseNumericType(ApparentEnergyUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ApparentPower.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ApparentPower.NetFramework.g.cs index 339f0a85ed..6c98748c0f 100644 --- a/UnitsNet/GeneratedCode/Quantities/ApparentPower.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ApparentPower.NetFramework.g.cs @@ -579,14 +579,18 @@ public ApparentPower ToUnit(ApparentPowerUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ApparentPower AsBaseUnit() { switch(Unit) { - case ApparentPowerUnit.Gigavoltampere: return (_value) * 1e9d; - case ApparentPowerUnit.Kilovoltampere: return (_value) * 1e3d; - case ApparentPowerUnit.Megavoltampere: return (_value) * 1e6d; - case ApparentPowerUnit.Voltampere: return _value; + case ApparentPowerUnit.Gigavoltampere: + return new ApparentPower((_value) * 1e9d, BaseUnit); + case ApparentPowerUnit.Kilovoltampere: + return new ApparentPower((_value) * 1e3d, BaseUnit); + case ApparentPowerUnit.Megavoltampere: + return new ApparentPower((_value) * 1e6d, BaseUnit); + case ApparentPowerUnit.Voltampere: + return new ApparentPower(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -597,7 +601,8 @@ private double AsBaseNumericType(ApparentPowerUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Area.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Area.NetFramework.g.cs index 834ca4aa2e..46bc60c19f 100644 --- a/UnitsNet/GeneratedCode/Quantities/Area.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Area.NetFramework.g.cs @@ -705,23 +705,36 @@ public Area ToUnit(AreaUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Area AsBaseUnit() { switch(Unit) { - case AreaUnit.Acre: return _value*4046.85642; - case AreaUnit.Hectare: return _value*1e4; - case AreaUnit.SquareCentimeter: return _value*1e-4; - case AreaUnit.SquareDecimeter: return _value*1e-2; - case AreaUnit.SquareFoot: return _value*0.092903; - case AreaUnit.SquareInch: return _value*0.00064516; - case AreaUnit.SquareKilometer: return _value*1e6; - case AreaUnit.SquareMeter: return _value; - case AreaUnit.SquareMicrometer: return _value*1e-12; - case AreaUnit.SquareMile: return _value*2.59e6; - case AreaUnit.SquareMillimeter: return _value*1e-6; - case AreaUnit.SquareYard: return _value*0.836127; - case AreaUnit.UsSurveySquareFoot: return _value*0.09290341161; + case AreaUnit.Acre: + return new Area(_value*4046.85642, BaseUnit); + case AreaUnit.Hectare: + return new Area(_value*1e4, BaseUnit); + case AreaUnit.SquareCentimeter: + return new Area(_value*1e-4, BaseUnit); + case AreaUnit.SquareDecimeter: + return new Area(_value*1e-2, BaseUnit); + case AreaUnit.SquareFoot: + return new Area(_value*0.092903, BaseUnit); + case AreaUnit.SquareInch: + return new Area(_value*0.00064516, BaseUnit); + case AreaUnit.SquareKilometer: + return new Area(_value*1e6, BaseUnit); + case AreaUnit.SquareMeter: + return new Area(_value, BaseUnit); + case AreaUnit.SquareMicrometer: + return new Area(_value*1e-12, BaseUnit); + case AreaUnit.SquareMile: + return new Area(_value*2.59e6, BaseUnit); + case AreaUnit.SquareMillimeter: + return new Area(_value*1e-6, BaseUnit); + case AreaUnit.SquareYard: + return new Area(_value*0.836127, BaseUnit); + case AreaUnit.UsSurveySquareFoot: + return new Area(_value*0.09290341161, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -732,7 +745,8 @@ private double AsBaseNumericType(AreaUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/AreaDensity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/AreaDensity.NetFramework.g.cs index 4d2aa8e3c4..bb47afbd42 100644 --- a/UnitsNet/GeneratedCode/Quantities/AreaDensity.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/AreaDensity.NetFramework.g.cs @@ -537,11 +537,12 @@ public AreaDensity ToUnit(AreaDensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal AreaDensity AsBaseUnit() { switch(Unit) { - case AreaDensityUnit.KilogramPerSquareMeter: return _value; + case AreaDensityUnit.KilogramPerSquareMeter: + return new AreaDensity(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -552,7 +553,8 @@ private double AsBaseNumericType(AreaDensityUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.NetFramework.g.cs index df5403d431..3b3db57d79 100644 --- a/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.NetFramework.g.cs @@ -607,16 +607,22 @@ public AreaMomentOfInertia ToUnit(AreaMomentOfInertiaUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal AreaMomentOfInertia AsBaseUnit() { switch(Unit) { - case AreaMomentOfInertiaUnit.CentimeterToTheFourth: return _value/1e8; - case AreaMomentOfInertiaUnit.DecimeterToTheFourth: return _value/1e4; - case AreaMomentOfInertiaUnit.FootToTheFourth: return _value*Math.Pow(0.3048, 4); - case AreaMomentOfInertiaUnit.InchToTheFourth: return _value*Math.Pow(2.54e-2, 4); - case AreaMomentOfInertiaUnit.MeterToTheFourth: return _value; - case AreaMomentOfInertiaUnit.MillimeterToTheFourth: return _value/1e12; + case AreaMomentOfInertiaUnit.CentimeterToTheFourth: + return new AreaMomentOfInertia(_value/1e8, BaseUnit); + case AreaMomentOfInertiaUnit.DecimeterToTheFourth: + return new AreaMomentOfInertia(_value/1e4, BaseUnit); + case AreaMomentOfInertiaUnit.FootToTheFourth: + return new AreaMomentOfInertia(_value*Math.Pow(0.3048, 4), BaseUnit); + case AreaMomentOfInertiaUnit.InchToTheFourth: + return new AreaMomentOfInertia(_value*Math.Pow(2.54e-2, 4), BaseUnit); + case AreaMomentOfInertiaUnit.MeterToTheFourth: + return new AreaMomentOfInertia(_value, BaseUnit); + case AreaMomentOfInertiaUnit.MillimeterToTheFourth: + return new AreaMomentOfInertia(_value/1e12, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -627,7 +633,8 @@ private double AsBaseNumericType(AreaMomentOfInertiaUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/BitRate.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/BitRate.NetFramework.g.cs index bc9a4ed598..597dc04e30 100644 --- a/UnitsNet/GeneratedCode/Quantities/BitRate.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/BitRate.NetFramework.g.cs @@ -890,36 +890,62 @@ public BitRate ToUnit(BitRateUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private decimal AsBaseUnit() + internal BitRate AsBaseUnit() { switch(Unit) { - case BitRateUnit.BitPerSecond: return _value; - case BitRateUnit.BytePerSecond: return _value*8m; - case BitRateUnit.ExabitPerSecond: return (_value) * 1e18m; - case BitRateUnit.ExabytePerSecond: return (_value*8m) * 1e18m; - case BitRateUnit.ExbibitPerSecond: return (_value) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024); - case BitRateUnit.ExbibytePerSecond: return (_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024); - case BitRateUnit.GibibitPerSecond: return (_value) * (1024m * 1024 * 1024); - case BitRateUnit.GibibytePerSecond: return (_value*8m) * (1024m * 1024 * 1024); - case BitRateUnit.GigabitPerSecond: return (_value) * 1e9m; - case BitRateUnit.GigabytePerSecond: return (_value*8m) * 1e9m; - case BitRateUnit.KibibitPerSecond: return (_value) * 1024m; - case BitRateUnit.KibibytePerSecond: return (_value*8m) * 1024m; - case BitRateUnit.KilobitPerSecond: return (_value) * 1e3m; - case BitRateUnit.KilobytePerSecond: return (_value*8m) * 1e3m; - case BitRateUnit.MebibitPerSecond: return (_value) * (1024m * 1024); - case BitRateUnit.MebibytePerSecond: return (_value*8m) * (1024m * 1024); - case BitRateUnit.MegabitPerSecond: return (_value) * 1e6m; - case BitRateUnit.MegabytePerSecond: return (_value*8m) * 1e6m; - case BitRateUnit.PebibitPerSecond: return (_value) * (1024m * 1024 * 1024 * 1024 * 1024); - case BitRateUnit.PebibytePerSecond: return (_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024); - case BitRateUnit.PetabitPerSecond: return (_value) * 1e15m; - case BitRateUnit.PetabytePerSecond: return (_value*8m) * 1e15m; - case BitRateUnit.TebibitPerSecond: return (_value) * (1024m * 1024 * 1024 * 1024); - case BitRateUnit.TebibytePerSecond: return (_value*8m) * (1024m * 1024 * 1024 * 1024); - case BitRateUnit.TerabitPerSecond: return (_value) * 1e12m; - case BitRateUnit.TerabytePerSecond: return (_value*8m) * 1e12m; + case BitRateUnit.BitPerSecond: + return new BitRate(_value, BaseUnit); + case BitRateUnit.BytePerSecond: + return new BitRate(_value*8m, BaseUnit); + case BitRateUnit.ExabitPerSecond: + return new BitRate((_value) * 1e18m, BaseUnit); + case BitRateUnit.ExabytePerSecond: + return new BitRate((_value*8m) * 1e18m, BaseUnit); + case BitRateUnit.ExbibitPerSecond: + return new BitRate((_value) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024), BaseUnit); + case BitRateUnit.ExbibytePerSecond: + return new BitRate((_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024), BaseUnit); + case BitRateUnit.GibibitPerSecond: + return new BitRate((_value) * (1024m * 1024 * 1024), BaseUnit); + case BitRateUnit.GibibytePerSecond: + return new BitRate((_value*8m) * (1024m * 1024 * 1024), BaseUnit); + case BitRateUnit.GigabitPerSecond: + return new BitRate((_value) * 1e9m, BaseUnit); + case BitRateUnit.GigabytePerSecond: + return new BitRate((_value*8m) * 1e9m, BaseUnit); + case BitRateUnit.KibibitPerSecond: + return new BitRate((_value) * 1024m, BaseUnit); + case BitRateUnit.KibibytePerSecond: + return new BitRate((_value*8m) * 1024m, BaseUnit); + case BitRateUnit.KilobitPerSecond: + return new BitRate((_value) * 1e3m, BaseUnit); + case BitRateUnit.KilobytePerSecond: + return new BitRate((_value*8m) * 1e3m, BaseUnit); + case BitRateUnit.MebibitPerSecond: + return new BitRate((_value) * (1024m * 1024), BaseUnit); + case BitRateUnit.MebibytePerSecond: + return new BitRate((_value*8m) * (1024m * 1024), BaseUnit); + case BitRateUnit.MegabitPerSecond: + return new BitRate((_value) * 1e6m, BaseUnit); + case BitRateUnit.MegabytePerSecond: + return new BitRate((_value*8m) * 1e6m, BaseUnit); + case BitRateUnit.PebibitPerSecond: + return new BitRate((_value) * (1024m * 1024 * 1024 * 1024 * 1024), BaseUnit); + case BitRateUnit.PebibytePerSecond: + return new BitRate((_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024), BaseUnit); + case BitRateUnit.PetabitPerSecond: + return new BitRate((_value) * 1e15m, BaseUnit); + case BitRateUnit.PetabytePerSecond: + return new BitRate((_value*8m) * 1e15m, BaseUnit); + case BitRateUnit.TebibitPerSecond: + return new BitRate((_value) * (1024m * 1024 * 1024 * 1024), BaseUnit); + case BitRateUnit.TebibytePerSecond: + return new BitRate((_value*8m) * (1024m * 1024 * 1024 * 1024), BaseUnit); + case BitRateUnit.TerabitPerSecond: + return new BitRate((_value) * 1e12m, BaseUnit); + case BitRateUnit.TerabytePerSecond: + return new BitRate((_value*8m) * 1e12m, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -930,7 +956,8 @@ private decimal AsBaseNumericType(BitRateUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.NetFramework.g.cs index 24001bf446..f716eaef0c 100644 --- a/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.NetFramework.g.cs @@ -565,13 +565,16 @@ public BrakeSpecificFuelConsumption ToUnit(BrakeSpecificFuelConsumptionUnit unit /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal BrakeSpecificFuelConsumption AsBaseUnit() { switch(Unit) { - case BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour: return _value/3.6e9; - case BrakeSpecificFuelConsumptionUnit.KilogramPerJoule: return _value; - case BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour: return _value*1.689659410672e-7; + case BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour: + return new BrakeSpecificFuelConsumption(_value/3.6e9, BaseUnit); + case BrakeSpecificFuelConsumptionUnit.KilogramPerJoule: + return new BrakeSpecificFuelConsumption(_value, BaseUnit); + case BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour: + return new BrakeSpecificFuelConsumption(_value*1.689659410672e-7, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -582,7 +585,8 @@ private double AsBaseNumericType(BrakeSpecificFuelConsumptionUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Capacitance.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Capacitance.NetFramework.g.cs index 98506bea99..bb4465fde5 100644 --- a/UnitsNet/GeneratedCode/Quantities/Capacitance.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Capacitance.NetFramework.g.cs @@ -624,17 +624,24 @@ public Capacitance ToUnit(CapacitanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Capacitance AsBaseUnit() { switch(Unit) { - case CapacitanceUnit.Farad: return _value; - case CapacitanceUnit.Kilofarad: return (_value) * 1e3d; - case CapacitanceUnit.Megafarad: return (_value) * 1e6d; - case CapacitanceUnit.Microfarad: return (_value) * 1e-6d; - case CapacitanceUnit.Millifarad: return (_value) * 1e-3d; - case CapacitanceUnit.Nanofarad: return (_value) * 1e-9d; - case CapacitanceUnit.Picofarad: return (_value) * 1e-12d; + case CapacitanceUnit.Farad: + return new Capacitance(_value, BaseUnit); + case CapacitanceUnit.Kilofarad: + return new Capacitance((_value) * 1e3d, BaseUnit); + case CapacitanceUnit.Megafarad: + return new Capacitance((_value) * 1e6d, BaseUnit); + case CapacitanceUnit.Microfarad: + return new Capacitance((_value) * 1e-6d, BaseUnit); + case CapacitanceUnit.Millifarad: + return new Capacitance((_value) * 1e-3d, BaseUnit); + case CapacitanceUnit.Nanofarad: + return new Capacitance((_value) * 1e-9d, BaseUnit); + case CapacitanceUnit.Picofarad: + return new Capacitance((_value) * 1e-12d, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -645,7 +652,8 @@ private double AsBaseNumericType(CapacitanceUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.NetFramework.g.cs index f0f973ddc0..c8b7c0e4a8 100644 --- a/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.NetFramework.g.cs @@ -565,13 +565,16 @@ public CoefficientOfThermalExpansion ToUnit(CoefficientOfThermalExpansionUnit un /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal CoefficientOfThermalExpansion AsBaseUnit() { switch(Unit) { - case CoefficientOfThermalExpansionUnit.InverseDegreeCelsius: return _value; - case CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit: return _value*5/9; - case CoefficientOfThermalExpansionUnit.InverseKelvin: return _value; + case CoefficientOfThermalExpansionUnit.InverseDegreeCelsius: + return new CoefficientOfThermalExpansion(_value, BaseUnit); + case CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit: + return new CoefficientOfThermalExpansion(_value*5/9, BaseUnit); + case CoefficientOfThermalExpansionUnit.InverseKelvin: + return new CoefficientOfThermalExpansion(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -582,7 +585,8 @@ private double AsBaseNumericType(CoefficientOfThermalExpansionUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Density.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Density.NetFramework.g.cs index dee1b4c8da..82cfe28079 100644 --- a/UnitsNet/GeneratedCode/Quantities/Density.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Density.NetFramework.g.cs @@ -1072,49 +1072,88 @@ public Density ToUnit(DensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Density AsBaseUnit() { switch(Unit) { - case DensityUnit.CentigramPerDeciliter: return (_value/1e-1) * 1e-2d; - case DensityUnit.CentigramPerLiter: return (_value/1) * 1e-2d; - case DensityUnit.CentigramPerMilliliter: return (_value/1e-3) * 1e-2d; - case DensityUnit.DecigramPerDeciliter: return (_value/1e-1) * 1e-1d; - case DensityUnit.DecigramPerLiter: return (_value/1) * 1e-1d; - case DensityUnit.DecigramPerMilliliter: return (_value/1e-3) * 1e-1d; - case DensityUnit.GramPerCubicCentimeter: return _value/1e-3; - case DensityUnit.GramPerCubicMeter: return _value/1e3; - case DensityUnit.GramPerCubicMillimeter: return _value/1e-6; - case DensityUnit.GramPerDeciliter: return _value/1e-1; - case DensityUnit.GramPerLiter: return _value/1; - case DensityUnit.GramPerMilliliter: return _value/1e-3; - case DensityUnit.KilogramPerCubicCentimeter: return (_value/1e-3) * 1e3d; - case DensityUnit.KilogramPerCubicMeter: return (_value/1e3) * 1e3d; - case DensityUnit.KilogramPerCubicMillimeter: return (_value/1e-6) * 1e3d; - case DensityUnit.KilopoundPerCubicFoot: return (_value/0.062427961) * 1e3d; - case DensityUnit.KilopoundPerCubicInch: return (_value/3.6127298147753e-5) * 1e3d; - case DensityUnit.MicrogramPerCubicMeter: return (_value/1e3) * 1e-6d; - case DensityUnit.MicrogramPerDeciliter: return (_value/1e-1) * 1e-6d; - case DensityUnit.MicrogramPerLiter: return (_value/1) * 1e-6d; - case DensityUnit.MicrogramPerMilliliter: return (_value/1e-3) * 1e-6d; - case DensityUnit.MilligramPerCubicMeter: return (_value/1e3) * 1e-3d; - case DensityUnit.MilligramPerDeciliter: return (_value/1e-1) * 1e-3d; - case DensityUnit.MilligramPerLiter: return (_value/1) * 1e-3d; - case DensityUnit.MilligramPerMilliliter: return (_value/1e-3) * 1e-3d; - case DensityUnit.NanogramPerDeciliter: return (_value/1e-1) * 1e-9d; - case DensityUnit.NanogramPerLiter: return (_value/1) * 1e-9d; - case DensityUnit.NanogramPerMilliliter: return (_value/1e-3) * 1e-9d; - case DensityUnit.PicogramPerDeciliter: return (_value/1e-1) * 1e-12d; - case DensityUnit.PicogramPerLiter: return (_value/1) * 1e-12d; - case DensityUnit.PicogramPerMilliliter: return (_value/1e-3) * 1e-12d; - case DensityUnit.PoundPerCubicFoot: return _value/0.062427961; - case DensityUnit.PoundPerCubicInch: return _value/3.6127298147753e-5; - case DensityUnit.PoundPerImperialGallon: return _value*9.9776398e1; - case DensityUnit.PoundPerUSGallon: return _value*1.19826427e2; - case DensityUnit.SlugPerCubicFoot: return _value*515.378818; - case DensityUnit.TonnePerCubicCentimeter: return _value/1e-9; - case DensityUnit.TonnePerCubicMeter: return _value/0.001; - case DensityUnit.TonnePerCubicMillimeter: return _value/1e-12; + case DensityUnit.CentigramPerDeciliter: + return new Density((_value/1e-1) * 1e-2d, BaseUnit); + case DensityUnit.CentigramPerLiter: + return new Density((_value/1) * 1e-2d, BaseUnit); + case DensityUnit.CentigramPerMilliliter: + return new Density((_value/1e-3) * 1e-2d, BaseUnit); + case DensityUnit.DecigramPerDeciliter: + return new Density((_value/1e-1) * 1e-1d, BaseUnit); + case DensityUnit.DecigramPerLiter: + return new Density((_value/1) * 1e-1d, BaseUnit); + case DensityUnit.DecigramPerMilliliter: + return new Density((_value/1e-3) * 1e-1d, BaseUnit); + case DensityUnit.GramPerCubicCentimeter: + return new Density(_value/1e-3, BaseUnit); + case DensityUnit.GramPerCubicMeter: + return new Density(_value/1e3, BaseUnit); + case DensityUnit.GramPerCubicMillimeter: + return new Density(_value/1e-6, BaseUnit); + case DensityUnit.GramPerDeciliter: + return new Density(_value/1e-1, BaseUnit); + case DensityUnit.GramPerLiter: + return new Density(_value/1, BaseUnit); + case DensityUnit.GramPerMilliliter: + return new Density(_value/1e-3, BaseUnit); + case DensityUnit.KilogramPerCubicCentimeter: + return new Density((_value/1e-3) * 1e3d, BaseUnit); + case DensityUnit.KilogramPerCubicMeter: + return new Density((_value/1e3) * 1e3d, BaseUnit); + case DensityUnit.KilogramPerCubicMillimeter: + return new Density((_value/1e-6) * 1e3d, BaseUnit); + case DensityUnit.KilopoundPerCubicFoot: + return new Density((_value/0.062427961) * 1e3d, BaseUnit); + case DensityUnit.KilopoundPerCubicInch: + return new Density((_value/3.6127298147753e-5) * 1e3d, BaseUnit); + case DensityUnit.MicrogramPerCubicMeter: + return new Density((_value/1e3) * 1e-6d, BaseUnit); + case DensityUnit.MicrogramPerDeciliter: + return new Density((_value/1e-1) * 1e-6d, BaseUnit); + case DensityUnit.MicrogramPerLiter: + return new Density((_value/1) * 1e-6d, BaseUnit); + case DensityUnit.MicrogramPerMilliliter: + return new Density((_value/1e-3) * 1e-6d, BaseUnit); + case DensityUnit.MilligramPerCubicMeter: + return new Density((_value/1e3) * 1e-3d, BaseUnit); + case DensityUnit.MilligramPerDeciliter: + return new Density((_value/1e-1) * 1e-3d, BaseUnit); + case DensityUnit.MilligramPerLiter: + return new Density((_value/1) * 1e-3d, BaseUnit); + case DensityUnit.MilligramPerMilliliter: + return new Density((_value/1e-3) * 1e-3d, BaseUnit); + case DensityUnit.NanogramPerDeciliter: + return new Density((_value/1e-1) * 1e-9d, BaseUnit); + case DensityUnit.NanogramPerLiter: + return new Density((_value/1) * 1e-9d, BaseUnit); + case DensityUnit.NanogramPerMilliliter: + return new Density((_value/1e-3) * 1e-9d, BaseUnit); + case DensityUnit.PicogramPerDeciliter: + return new Density((_value/1e-1) * 1e-12d, BaseUnit); + case DensityUnit.PicogramPerLiter: + return new Density((_value/1) * 1e-12d, BaseUnit); + case DensityUnit.PicogramPerMilliliter: + return new Density((_value/1e-3) * 1e-12d, BaseUnit); + case DensityUnit.PoundPerCubicFoot: + return new Density(_value/0.062427961, BaseUnit); + case DensityUnit.PoundPerCubicInch: + return new Density(_value/3.6127298147753e-5, BaseUnit); + case DensityUnit.PoundPerImperialGallon: + return new Density(_value*9.9776398e1, BaseUnit); + case DensityUnit.PoundPerUSGallon: + return new Density(_value*1.19826427e2, BaseUnit); + case DensityUnit.SlugPerCubicFoot: + return new Density(_value*515.378818, BaseUnit); + case DensityUnit.TonnePerCubicCentimeter: + return new Density(_value/1e-9, BaseUnit); + case DensityUnit.TonnePerCubicMeter: + return new Density(_value/0.001, BaseUnit); + case DensityUnit.TonnePerCubicMillimeter: + return new Density(_value/1e-12, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -1125,7 +1164,8 @@ private double AsBaseNumericType(DensityUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Duration.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Duration.NetFramework.g.cs index a492045fa3..af1c517f59 100644 --- a/UnitsNet/GeneratedCode/Quantities/Duration.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Duration.NetFramework.g.cs @@ -663,20 +663,30 @@ public Duration ToUnit(DurationUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Duration AsBaseUnit() { switch(Unit) { - case DurationUnit.Day: return _value*24*3600; - case DurationUnit.Hour: return _value*3600; - case DurationUnit.Microsecond: return (_value) * 1e-6d; - case DurationUnit.Millisecond: return (_value) * 1e-3d; - case DurationUnit.Minute: return _value*60; - case DurationUnit.Month30: return _value*30*24*3600; - case DurationUnit.Nanosecond: return (_value) * 1e-9d; - case DurationUnit.Second: return _value; - case DurationUnit.Week: return _value*7*24*3600; - case DurationUnit.Year365: return _value*365*24*3600; + case DurationUnit.Day: + return new Duration(_value*24*3600, BaseUnit); + case DurationUnit.Hour: + return new Duration(_value*3600, BaseUnit); + case DurationUnit.Microsecond: + return new Duration((_value) * 1e-6d, BaseUnit); + case DurationUnit.Millisecond: + return new Duration((_value) * 1e-3d, BaseUnit); + case DurationUnit.Minute: + return new Duration(_value*60, BaseUnit); + case DurationUnit.Month30: + return new Duration(_value*30*24*3600, BaseUnit); + case DurationUnit.Nanosecond: + return new Duration((_value) * 1e-9d, BaseUnit); + case DurationUnit.Second: + return new Duration(_value, BaseUnit); + case DurationUnit.Week: + return new Duration(_value*7*24*3600, BaseUnit); + case DurationUnit.Year365: + return new Duration(_value*365*24*3600, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -687,7 +697,8 @@ private double AsBaseNumericType(DurationUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.NetFramework.g.cs index c6f68cbcb4..c46c919958 100644 --- a/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.NetFramework.g.cs @@ -610,16 +610,22 @@ public DynamicViscosity ToUnit(DynamicViscosityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal DynamicViscosity AsBaseUnit() { switch(Unit) { - case DynamicViscosityUnit.Centipoise: return (_value/10) * 1e-2d; - case DynamicViscosityUnit.MicropascalSecond: return (_value) * 1e-6d; - case DynamicViscosityUnit.MillipascalSecond: return (_value) * 1e-3d; - case DynamicViscosityUnit.NewtonSecondPerMeterSquared: return _value; - case DynamicViscosityUnit.PascalSecond: return _value; - case DynamicViscosityUnit.Poise: return _value/10; + case DynamicViscosityUnit.Centipoise: + return new DynamicViscosity((_value/10) * 1e-2d, BaseUnit); + case DynamicViscosityUnit.MicropascalSecond: + return new DynamicViscosity((_value) * 1e-6d, BaseUnit); + case DynamicViscosityUnit.MillipascalSecond: + return new DynamicViscosity((_value) * 1e-3d, BaseUnit); + case DynamicViscosityUnit.NewtonSecondPerMeterSquared: + return new DynamicViscosity(_value, BaseUnit); + case DynamicViscosityUnit.PascalSecond: + return new DynamicViscosity(_value, BaseUnit); + case DynamicViscosityUnit.Poise: + return new DynamicViscosity(_value/10, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -630,7 +636,8 @@ private double AsBaseNumericType(DynamicViscosityUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.NetFramework.g.cs index 0aa8614684..29591e11c9 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.NetFramework.g.cs @@ -579,14 +579,18 @@ public ElectricAdmittance ToUnit(ElectricAdmittanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ElectricAdmittance AsBaseUnit() { switch(Unit) { - case ElectricAdmittanceUnit.Microsiemens: return (_value) * 1e-6d; - case ElectricAdmittanceUnit.Millisiemens: return (_value) * 1e-3d; - case ElectricAdmittanceUnit.Nanosiemens: return (_value) * 1e-9d; - case ElectricAdmittanceUnit.Siemens: return _value; + case ElectricAdmittanceUnit.Microsiemens: + return new ElectricAdmittance((_value) * 1e-6d, BaseUnit); + case ElectricAdmittanceUnit.Millisiemens: + return new ElectricAdmittance((_value) * 1e-3d, BaseUnit); + case ElectricAdmittanceUnit.Nanosiemens: + return new ElectricAdmittance((_value) * 1e-9d, BaseUnit); + case ElectricAdmittanceUnit.Siemens: + return new ElectricAdmittance(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -597,7 +601,8 @@ private double AsBaseNumericType(ElectricAdmittanceUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCharge.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCharge.NetFramework.g.cs index ad8c89f4e9..f59a06725a 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricCharge.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricCharge.NetFramework.g.cs @@ -540,11 +540,12 @@ public ElectricCharge ToUnit(ElectricChargeUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ElectricCharge AsBaseUnit() { switch(Unit) { - case ElectricChargeUnit.Coulomb: return _value; + case ElectricChargeUnit.Coulomb: + return new ElectricCharge(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -555,7 +556,8 @@ private double AsBaseNumericType(ElectricChargeUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.NetFramework.g.cs index c7f07b4c82..7345a01b8a 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.NetFramework.g.cs @@ -540,11 +540,12 @@ public ElectricChargeDensity ToUnit(ElectricChargeDensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ElectricChargeDensity AsBaseUnit() { switch(Unit) { - case ElectricChargeDensityUnit.CoulombPerCubicMeter: return _value; + case ElectricChargeDensityUnit.CoulombPerCubicMeter: + return new ElectricChargeDensity(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -555,7 +556,8 @@ private double AsBaseNumericType(ElectricChargeDensityUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricConductance.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricConductance.NetFramework.g.cs index 055e85ca6e..8b2052aefa 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricConductance.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricConductance.NetFramework.g.cs @@ -568,13 +568,16 @@ public ElectricConductance ToUnit(ElectricConductanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ElectricConductance AsBaseUnit() { switch(Unit) { - case ElectricConductanceUnit.Microsiemens: return (_value) * 1e-6d; - case ElectricConductanceUnit.Millisiemens: return (_value) * 1e-3d; - case ElectricConductanceUnit.Siemens: return _value; + case ElectricConductanceUnit.Microsiemens: + return new ElectricConductance((_value) * 1e-6d, BaseUnit); + case ElectricConductanceUnit.Millisiemens: + return new ElectricConductance((_value) * 1e-3d, BaseUnit); + case ElectricConductanceUnit.Siemens: + return new ElectricConductance(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -585,7 +588,8 @@ private double AsBaseNumericType(ElectricConductanceUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.NetFramework.g.cs index 2bf2645bb3..cee6cf9bfb 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.NetFramework.g.cs @@ -540,11 +540,12 @@ public ElectricConductivity ToUnit(ElectricConductivityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ElectricConductivity AsBaseUnit() { switch(Unit) { - case ElectricConductivityUnit.SiemensPerMeter: return _value; + case ElectricConductivityUnit.SiemensPerMeter: + return new ElectricConductivity(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -555,7 +556,8 @@ private double AsBaseNumericType(ElectricConductivityUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.NetFramework.g.cs index 297cf7cb67..d3a7e4ecfd 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.NetFramework.g.cs @@ -635,18 +635,26 @@ public ElectricCurrent ToUnit(ElectricCurrentUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ElectricCurrent AsBaseUnit() { switch(Unit) { - case ElectricCurrentUnit.Ampere: return _value; - case ElectricCurrentUnit.Centiampere: return (_value) * 1e-2d; - case ElectricCurrentUnit.Kiloampere: return (_value) * 1e3d; - case ElectricCurrentUnit.Megaampere: return (_value) * 1e6d; - case ElectricCurrentUnit.Microampere: return (_value) * 1e-6d; - case ElectricCurrentUnit.Milliampere: return (_value) * 1e-3d; - case ElectricCurrentUnit.Nanoampere: return (_value) * 1e-9d; - case ElectricCurrentUnit.Picoampere: return (_value) * 1e-12d; + case ElectricCurrentUnit.Ampere: + return new ElectricCurrent(_value, BaseUnit); + case ElectricCurrentUnit.Centiampere: + return new ElectricCurrent((_value) * 1e-2d, BaseUnit); + case ElectricCurrentUnit.Kiloampere: + return new ElectricCurrent((_value) * 1e3d, BaseUnit); + case ElectricCurrentUnit.Megaampere: + return new ElectricCurrent((_value) * 1e6d, BaseUnit); + case ElectricCurrentUnit.Microampere: + return new ElectricCurrent((_value) * 1e-6d, BaseUnit); + case ElectricCurrentUnit.Milliampere: + return new ElectricCurrent((_value) * 1e-3d, BaseUnit); + case ElectricCurrentUnit.Nanoampere: + return new ElectricCurrent((_value) * 1e-9d, BaseUnit); + case ElectricCurrentUnit.Picoampere: + return new ElectricCurrent((_value) * 1e-12d, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -657,7 +665,8 @@ private double AsBaseNumericType(ElectricCurrentUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.NetFramework.g.cs index 454421c96a..fd6feda30d 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.NetFramework.g.cs @@ -540,11 +540,12 @@ public ElectricCurrentDensity ToUnit(ElectricCurrentDensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ElectricCurrentDensity AsBaseUnit() { switch(Unit) { - case ElectricCurrentDensityUnit.AmperePerSquareMeter: return _value; + case ElectricCurrentDensityUnit.AmperePerSquareMeter: + return new ElectricCurrentDensity(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -555,7 +556,8 @@ private double AsBaseNumericType(ElectricCurrentDensityUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.NetFramework.g.cs index 45c50ff74e..7c242f0df8 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.NetFramework.g.cs @@ -537,11 +537,12 @@ public ElectricCurrentGradient ToUnit(ElectricCurrentGradientUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ElectricCurrentGradient AsBaseUnit() { switch(Unit) { - case ElectricCurrentGradientUnit.AmperePerSecond: return _value; + case ElectricCurrentGradientUnit.AmperePerSecond: + return new ElectricCurrentGradient(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -552,7 +553,8 @@ private double AsBaseNumericType(ElectricCurrentGradientUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricField.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricField.NetFramework.g.cs index 92ad660991..07882f9100 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricField.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricField.NetFramework.g.cs @@ -540,11 +540,12 @@ public ElectricField ToUnit(ElectricFieldUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ElectricField AsBaseUnit() { switch(Unit) { - case ElectricFieldUnit.VoltPerMeter: return _value; + case ElectricFieldUnit.VoltPerMeter: + return new ElectricField(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -555,7 +556,8 @@ private double AsBaseNumericType(ElectricFieldUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricInductance.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricInductance.NetFramework.g.cs index b8122cd354..5fef7cb7d6 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricInductance.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricInductance.NetFramework.g.cs @@ -582,14 +582,18 @@ public ElectricInductance ToUnit(ElectricInductanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ElectricInductance AsBaseUnit() { switch(Unit) { - case ElectricInductanceUnit.Henry: return _value; - case ElectricInductanceUnit.Microhenry: return (_value) * 1e-6d; - case ElectricInductanceUnit.Millihenry: return (_value) * 1e-3d; - case ElectricInductanceUnit.Nanohenry: return (_value) * 1e-9d; + case ElectricInductanceUnit.Henry: + return new ElectricInductance(_value, BaseUnit); + case ElectricInductanceUnit.Microhenry: + return new ElectricInductance((_value) * 1e-6d, BaseUnit); + case ElectricInductanceUnit.Millihenry: + return new ElectricInductance((_value) * 1e-3d, BaseUnit); + case ElectricInductanceUnit.Nanohenry: + return new ElectricInductance((_value) * 1e-9d, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -600,7 +604,8 @@ private double AsBaseNumericType(ElectricInductanceUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotential.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotential.NetFramework.g.cs index 94bb36db61..76858eb10b 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricPotential.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricPotential.NetFramework.g.cs @@ -593,15 +593,20 @@ public ElectricPotential ToUnit(ElectricPotentialUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ElectricPotential AsBaseUnit() { switch(Unit) { - case ElectricPotentialUnit.Kilovolt: return (_value) * 1e3d; - case ElectricPotentialUnit.Megavolt: return (_value) * 1e6d; - case ElectricPotentialUnit.Microvolt: return (_value) * 1e-6d; - case ElectricPotentialUnit.Millivolt: return (_value) * 1e-3d; - case ElectricPotentialUnit.Volt: return _value; + case ElectricPotentialUnit.Kilovolt: + return new ElectricPotential((_value) * 1e3d, BaseUnit); + case ElectricPotentialUnit.Megavolt: + return new ElectricPotential((_value) * 1e6d, BaseUnit); + case ElectricPotentialUnit.Microvolt: + return new ElectricPotential((_value) * 1e-6d, BaseUnit); + case ElectricPotentialUnit.Millivolt: + return new ElectricPotential((_value) * 1e-3d, BaseUnit); + case ElectricPotentialUnit.Volt: + return new ElectricPotential(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -612,7 +617,8 @@ private double AsBaseNumericType(ElectricPotentialUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialAc.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialAc.NetFramework.g.cs index decd51b7f0..307b7e25a1 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialAc.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialAc.NetFramework.g.cs @@ -593,15 +593,20 @@ public ElectricPotentialAc ToUnit(ElectricPotentialAcUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ElectricPotentialAc AsBaseUnit() { switch(Unit) { - case ElectricPotentialAcUnit.KilovoltAc: return (_value) * 1e3d; - case ElectricPotentialAcUnit.MegavoltAc: return (_value) * 1e6d; - case ElectricPotentialAcUnit.MicrovoltAc: return (_value) * 1e-6d; - case ElectricPotentialAcUnit.MillivoltAc: return (_value) * 1e-3d; - case ElectricPotentialAcUnit.VoltAc: return _value; + case ElectricPotentialAcUnit.KilovoltAc: + return new ElectricPotentialAc((_value) * 1e3d, BaseUnit); + case ElectricPotentialAcUnit.MegavoltAc: + return new ElectricPotentialAc((_value) * 1e6d, BaseUnit); + case ElectricPotentialAcUnit.MicrovoltAc: + return new ElectricPotentialAc((_value) * 1e-6d, BaseUnit); + case ElectricPotentialAcUnit.MillivoltAc: + return new ElectricPotentialAc((_value) * 1e-3d, BaseUnit); + case ElectricPotentialAcUnit.VoltAc: + return new ElectricPotentialAc(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -612,7 +617,8 @@ private double AsBaseNumericType(ElectricPotentialAcUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialDc.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialDc.NetFramework.g.cs index 8e52d3a11f..4602de0391 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialDc.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialDc.NetFramework.g.cs @@ -593,15 +593,20 @@ public ElectricPotentialDc ToUnit(ElectricPotentialDcUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ElectricPotentialDc AsBaseUnit() { switch(Unit) { - case ElectricPotentialDcUnit.KilovoltDc: return (_value) * 1e3d; - case ElectricPotentialDcUnit.MegavoltDc: return (_value) * 1e6d; - case ElectricPotentialDcUnit.MicrovoltDc: return (_value) * 1e-6d; - case ElectricPotentialDcUnit.MillivoltDc: return (_value) * 1e-3d; - case ElectricPotentialDcUnit.VoltDc: return _value; + case ElectricPotentialDcUnit.KilovoltDc: + return new ElectricPotentialDc((_value) * 1e3d, BaseUnit); + case ElectricPotentialDcUnit.MegavoltDc: + return new ElectricPotentialDc((_value) * 1e6d, BaseUnit); + case ElectricPotentialDcUnit.MicrovoltDc: + return new ElectricPotentialDc((_value) * 1e-6d, BaseUnit); + case ElectricPotentialDcUnit.MillivoltDc: + return new ElectricPotentialDc((_value) * 1e-3d, BaseUnit); + case ElectricPotentialDcUnit.VoltDc: + return new ElectricPotentialDc(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -612,7 +617,8 @@ private double AsBaseNumericType(ElectricPotentialDcUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricResistance.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricResistance.NetFramework.g.cs index 62a484bcd7..31bb712fdb 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricResistance.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricResistance.NetFramework.g.cs @@ -593,15 +593,20 @@ public ElectricResistance ToUnit(ElectricResistanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ElectricResistance AsBaseUnit() { switch(Unit) { - case ElectricResistanceUnit.Gigaohm: return (_value) * 1e9d; - case ElectricResistanceUnit.Kiloohm: return (_value) * 1e3d; - case ElectricResistanceUnit.Megaohm: return (_value) * 1e6d; - case ElectricResistanceUnit.Milliohm: return (_value) * 1e-3d; - case ElectricResistanceUnit.Ohm: return _value; + case ElectricResistanceUnit.Gigaohm: + return new ElectricResistance((_value) * 1e9d, BaseUnit); + case ElectricResistanceUnit.Kiloohm: + return new ElectricResistance((_value) * 1e3d, BaseUnit); + case ElectricResistanceUnit.Megaohm: + return new ElectricResistance((_value) * 1e6d, BaseUnit); + case ElectricResistanceUnit.Milliohm: + return new ElectricResistance((_value) * 1e-3d, BaseUnit); + case ElectricResistanceUnit.Ohm: + return new ElectricResistance(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -612,7 +617,8 @@ private double AsBaseNumericType(ElectricResistanceUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.NetFramework.g.cs index beacbd46fd..c4233349cb 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.NetFramework.g.cs @@ -722,24 +722,38 @@ public ElectricResistivity ToUnit(ElectricResistivityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ElectricResistivity AsBaseUnit() { switch(Unit) { - case ElectricResistivityUnit.KiloohmCentimeter: return (_value/100) * 1e3d; - case ElectricResistivityUnit.KiloohmMeter: return (_value) * 1e3d; - case ElectricResistivityUnit.MegaohmCentimeter: return (_value/100) * 1e6d; - case ElectricResistivityUnit.MegaohmMeter: return (_value) * 1e6d; - case ElectricResistivityUnit.MicroohmCentimeter: return (_value/100) * 1e-6d; - case ElectricResistivityUnit.MicroohmMeter: return (_value) * 1e-6d; - case ElectricResistivityUnit.MilliohmCentimeter: return (_value/100) * 1e-3d; - case ElectricResistivityUnit.MilliohmMeter: return (_value) * 1e-3d; - case ElectricResistivityUnit.NanoohmCentimeter: return (_value/100) * 1e-9d; - case ElectricResistivityUnit.NanoohmMeter: return (_value) * 1e-9d; - case ElectricResistivityUnit.OhmCentimeter: return _value/100; - case ElectricResistivityUnit.OhmMeter: return _value; - case ElectricResistivityUnit.PicoohmCentimeter: return (_value/100) * 1e-12d; - case ElectricResistivityUnit.PicoohmMeter: return (_value) * 1e-12d; + case ElectricResistivityUnit.KiloohmCentimeter: + return new ElectricResistivity((_value/100) * 1e3d, BaseUnit); + case ElectricResistivityUnit.KiloohmMeter: + return new ElectricResistivity((_value) * 1e3d, BaseUnit); + case ElectricResistivityUnit.MegaohmCentimeter: + return new ElectricResistivity((_value/100) * 1e6d, BaseUnit); + case ElectricResistivityUnit.MegaohmMeter: + return new ElectricResistivity((_value) * 1e6d, BaseUnit); + case ElectricResistivityUnit.MicroohmCentimeter: + return new ElectricResistivity((_value/100) * 1e-6d, BaseUnit); + case ElectricResistivityUnit.MicroohmMeter: + return new ElectricResistivity((_value) * 1e-6d, BaseUnit); + case ElectricResistivityUnit.MilliohmCentimeter: + return new ElectricResistivity((_value/100) * 1e-3d, BaseUnit); + case ElectricResistivityUnit.MilliohmMeter: + return new ElectricResistivity((_value) * 1e-3d, BaseUnit); + case ElectricResistivityUnit.NanoohmCentimeter: + return new ElectricResistivity((_value/100) * 1e-9d, BaseUnit); + case ElectricResistivityUnit.NanoohmMeter: + return new ElectricResistivity((_value) * 1e-9d, BaseUnit); + case ElectricResistivityUnit.OhmCentimeter: + return new ElectricResistivity(_value/100, BaseUnit); + case ElectricResistivityUnit.OhmMeter: + return new ElectricResistivity(_value, BaseUnit); + case ElectricResistivityUnit.PicoohmCentimeter: + return new ElectricResistivity((_value/100) * 1e-12d, BaseUnit); + case ElectricResistivityUnit.PicoohmMeter: + return new ElectricResistivity((_value) * 1e-12d, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -750,7 +764,8 @@ private double AsBaseNumericType(ElectricResistivityUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Energy.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Energy.NetFramework.g.cs index 70dd0022b9..f3a5850fa7 100644 --- a/UnitsNet/GeneratedCode/Quantities/Energy.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Energy.NetFramework.g.cs @@ -831,32 +831,54 @@ public Energy ToUnit(EnergyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Energy AsBaseUnit() { switch(Unit) { - case EnergyUnit.BritishThermalUnit: return _value*1055.05585262; - case EnergyUnit.Calorie: return _value*4.184; - case EnergyUnit.DecathermEc: return (_value*1.05505585262e8) * 1e1d; - case EnergyUnit.DecathermImperial: return (_value*1.05505585257348e8) * 1e1d; - case EnergyUnit.DecathermUs: return (_value*1.054804e8) * 1e1d; - case EnergyUnit.ElectronVolt: return _value*1.602176565e-19; - case EnergyUnit.Erg: return _value*1e-7; - case EnergyUnit.FootPound: return _value*1.355817948; - case EnergyUnit.GigabritishThermalUnit: return (_value*1055.05585262) * 1e9d; - case EnergyUnit.GigawattHour: return (_value*3600d) * 1e9d; - case EnergyUnit.Joule: return _value; - case EnergyUnit.KilobritishThermalUnit: return (_value*1055.05585262) * 1e3d; - case EnergyUnit.Kilocalorie: return (_value*4.184) * 1e3d; - case EnergyUnit.Kilojoule: return (_value) * 1e3d; - case EnergyUnit.KilowattHour: return (_value*3600d) * 1e3d; - case EnergyUnit.MegabritishThermalUnit: return (_value*1055.05585262) * 1e6d; - case EnergyUnit.Megajoule: return (_value) * 1e6d; - case EnergyUnit.MegawattHour: return (_value*3600d) * 1e6d; - case EnergyUnit.ThermEc: return _value*1.05505585262e8; - case EnergyUnit.ThermImperial: return _value*1.05505585257348e8; - case EnergyUnit.ThermUs: return _value*1.054804e8; - case EnergyUnit.WattHour: return _value*3600d; + case EnergyUnit.BritishThermalUnit: + return new Energy(_value*1055.05585262, BaseUnit); + case EnergyUnit.Calorie: + return new Energy(_value*4.184, BaseUnit); + case EnergyUnit.DecathermEc: + return new Energy((_value*1.05505585262e8) * 1e1d, BaseUnit); + case EnergyUnit.DecathermImperial: + return new Energy((_value*1.05505585257348e8) * 1e1d, BaseUnit); + case EnergyUnit.DecathermUs: + return new Energy((_value*1.054804e8) * 1e1d, BaseUnit); + case EnergyUnit.ElectronVolt: + return new Energy(_value*1.602176565e-19, BaseUnit); + case EnergyUnit.Erg: + return new Energy(_value*1e-7, BaseUnit); + case EnergyUnit.FootPound: + return new Energy(_value*1.355817948, BaseUnit); + case EnergyUnit.GigabritishThermalUnit: + return new Energy((_value*1055.05585262) * 1e9d, BaseUnit); + case EnergyUnit.GigawattHour: + return new Energy((_value*3600d) * 1e9d, BaseUnit); + case EnergyUnit.Joule: + return new Energy(_value, BaseUnit); + case EnergyUnit.KilobritishThermalUnit: + return new Energy((_value*1055.05585262) * 1e3d, BaseUnit); + case EnergyUnit.Kilocalorie: + return new Energy((_value*4.184) * 1e3d, BaseUnit); + case EnergyUnit.Kilojoule: + return new Energy((_value) * 1e3d, BaseUnit); + case EnergyUnit.KilowattHour: + return new Energy((_value*3600d) * 1e3d, BaseUnit); + case EnergyUnit.MegabritishThermalUnit: + return new Energy((_value*1055.05585262) * 1e6d, BaseUnit); + case EnergyUnit.Megajoule: + return new Energy((_value) * 1e6d, BaseUnit); + case EnergyUnit.MegawattHour: + return new Energy((_value*3600d) * 1e6d, BaseUnit); + case EnergyUnit.ThermEc: + return new Energy(_value*1.05505585262e8, BaseUnit); + case EnergyUnit.ThermImperial: + return new Energy(_value*1.05505585257348e8, BaseUnit); + case EnergyUnit.ThermUs: + return new Energy(_value*1.054804e8, BaseUnit); + case EnergyUnit.WattHour: + return new Energy(_value*3600d, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -867,7 +889,8 @@ private double AsBaseNumericType(EnergyUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Entropy.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Entropy.NetFramework.g.cs index d70b0e10ea..6103be5357 100644 --- a/UnitsNet/GeneratedCode/Quantities/Entropy.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Entropy.NetFramework.g.cs @@ -621,17 +621,24 @@ public Entropy ToUnit(EntropyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Entropy AsBaseUnit() { switch(Unit) { - case EntropyUnit.CaloriePerKelvin: return _value*4.184; - case EntropyUnit.JoulePerDegreeCelsius: return _value; - case EntropyUnit.JoulePerKelvin: return _value; - case EntropyUnit.KilocaloriePerKelvin: return (_value*4.184) * 1e3d; - case EntropyUnit.KilojoulePerDegreeCelsius: return (_value) * 1e3d; - case EntropyUnit.KilojoulePerKelvin: return (_value) * 1e3d; - case EntropyUnit.MegajoulePerKelvin: return (_value) * 1e6d; + case EntropyUnit.CaloriePerKelvin: + return new Entropy(_value*4.184, BaseUnit); + case EntropyUnit.JoulePerDegreeCelsius: + return new Entropy(_value, BaseUnit); + case EntropyUnit.JoulePerKelvin: + return new Entropy(_value, BaseUnit); + case EntropyUnit.KilocaloriePerKelvin: + return new Entropy((_value*4.184) * 1e3d, BaseUnit); + case EntropyUnit.KilojoulePerDegreeCelsius: + return new Entropy((_value) * 1e3d, BaseUnit); + case EntropyUnit.KilojoulePerKelvin: + return new Entropy((_value) * 1e3d, BaseUnit); + case EntropyUnit.MegajoulePerKelvin: + return new Entropy((_value) * 1e6d, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -642,7 +649,8 @@ private double AsBaseNumericType(EntropyUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Force.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Force.NetFramework.g.cs index be24f8f69e..99a8c417e1 100644 --- a/UnitsNet/GeneratedCode/Quantities/Force.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Force.NetFramework.g.cs @@ -705,23 +705,36 @@ public Force ToUnit(ForceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Force AsBaseUnit() { switch(Unit) { - case ForceUnit.Decanewton: return (_value) * 1e1d; - case ForceUnit.Dyn: return _value/1e5; - case ForceUnit.KilogramForce: return _value*9.80665002864; - case ForceUnit.Kilonewton: return (_value) * 1e3d; - case ForceUnit.KiloPond: return _value*9.80665002864; - case ForceUnit.Meganewton: return (_value) * 1e6d; - case ForceUnit.Micronewton: return (_value) * 1e-6d; - case ForceUnit.Millinewton: return (_value) * 1e-3d; - case ForceUnit.Newton: return _value; - case ForceUnit.OunceForce: return _value*2.780138509537812e-1; - case ForceUnit.Poundal: return _value*0.13825502798973041652092282466083; - case ForceUnit.PoundForce: return _value*4.4482216152605095551842641431421; - case ForceUnit.TonneForce: return _value*9.80665002864e3; + case ForceUnit.Decanewton: + return new Force((_value) * 1e1d, BaseUnit); + case ForceUnit.Dyn: + return new Force(_value/1e5, BaseUnit); + case ForceUnit.KilogramForce: + return new Force(_value*9.80665002864, BaseUnit); + case ForceUnit.Kilonewton: + return new Force((_value) * 1e3d, BaseUnit); + case ForceUnit.KiloPond: + return new Force(_value*9.80665002864, BaseUnit); + case ForceUnit.Meganewton: + return new Force((_value) * 1e6d, BaseUnit); + case ForceUnit.Micronewton: + return new Force((_value) * 1e-6d, BaseUnit); + case ForceUnit.Millinewton: + return new Force((_value) * 1e-3d, BaseUnit); + case ForceUnit.Newton: + return new Force(_value, BaseUnit); + case ForceUnit.OunceForce: + return new Force(_value*2.780138509537812e-1, BaseUnit); + case ForceUnit.Poundal: + return new Force(_value*0.13825502798973041652092282466083, BaseUnit); + case ForceUnit.PoundForce: + return new Force(_value*4.4482216152605095551842641431421, BaseUnit); + case ForceUnit.TonneForce: + return new Force(_value*9.80665002864e3, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -732,7 +745,8 @@ private double AsBaseNumericType(ForceUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.NetFramework.g.cs index 0d6065acc8..688a394d8b 100644 --- a/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.NetFramework.g.cs @@ -677,21 +677,32 @@ public ForceChangeRate ToUnit(ForceChangeRateUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ForceChangeRate AsBaseUnit() { switch(Unit) { - case ForceChangeRateUnit.CentinewtonPerSecond: return (_value) * 1e-2d; - case ForceChangeRateUnit.DecanewtonPerMinute: return (_value/60) * 1e1d; - case ForceChangeRateUnit.DecanewtonPerSecond: return (_value) * 1e1d; - case ForceChangeRateUnit.DecinewtonPerSecond: return (_value) * 1e-1d; - case ForceChangeRateUnit.KilonewtonPerMinute: return (_value/60) * 1e3d; - case ForceChangeRateUnit.KilonewtonPerSecond: return (_value) * 1e3d; - case ForceChangeRateUnit.MicronewtonPerSecond: return (_value) * 1e-6d; - case ForceChangeRateUnit.MillinewtonPerSecond: return (_value) * 1e-3d; - case ForceChangeRateUnit.NanonewtonPerSecond: return (_value) * 1e-9d; - case ForceChangeRateUnit.NewtonPerMinute: return _value/60; - case ForceChangeRateUnit.NewtonPerSecond: return _value; + case ForceChangeRateUnit.CentinewtonPerSecond: + return new ForceChangeRate((_value) * 1e-2d, BaseUnit); + case ForceChangeRateUnit.DecanewtonPerMinute: + return new ForceChangeRate((_value/60) * 1e1d, BaseUnit); + case ForceChangeRateUnit.DecanewtonPerSecond: + return new ForceChangeRate((_value) * 1e1d, BaseUnit); + case ForceChangeRateUnit.DecinewtonPerSecond: + return new ForceChangeRate((_value) * 1e-1d, BaseUnit); + case ForceChangeRateUnit.KilonewtonPerMinute: + return new ForceChangeRate((_value/60) * 1e3d, BaseUnit); + case ForceChangeRateUnit.KilonewtonPerSecond: + return new ForceChangeRate((_value) * 1e3d, BaseUnit); + case ForceChangeRateUnit.MicronewtonPerSecond: + return new ForceChangeRate((_value) * 1e-6d, BaseUnit); + case ForceChangeRateUnit.MillinewtonPerSecond: + return new ForceChangeRate((_value) * 1e-3d, BaseUnit); + case ForceChangeRateUnit.NanonewtonPerSecond: + return new ForceChangeRate((_value) * 1e-9d, BaseUnit); + case ForceChangeRateUnit.NewtonPerMinute: + return new ForceChangeRate(_value/60, BaseUnit); + case ForceChangeRateUnit.NewtonPerSecond: + return new ForceChangeRate(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -702,7 +713,8 @@ private double AsBaseNumericType(ForceChangeRateUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ForcePerLength.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ForcePerLength.NetFramework.g.cs index 1cf9184c55..6f34587c4b 100644 --- a/UnitsNet/GeneratedCode/Quantities/ForcePerLength.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ForcePerLength.NetFramework.g.cs @@ -649,19 +649,28 @@ public ForcePerLength ToUnit(ForcePerLengthUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ForcePerLength AsBaseUnit() { switch(Unit) { - case ForcePerLengthUnit.CentinewtonPerMeter: return (_value) * 1e-2d; - case ForcePerLengthUnit.DecinewtonPerMeter: return (_value) * 1e-1d; - case ForcePerLengthUnit.KilogramForcePerMeter: return _value*9.80665002864; - case ForcePerLengthUnit.KilonewtonPerMeter: return (_value) * 1e3d; - case ForcePerLengthUnit.MeganewtonPerMeter: return (_value) * 1e6d; - case ForcePerLengthUnit.MicronewtonPerMeter: return (_value) * 1e-6d; - case ForcePerLengthUnit.MillinewtonPerMeter: return (_value) * 1e-3d; - case ForcePerLengthUnit.NanonewtonPerMeter: return (_value) * 1e-9d; - case ForcePerLengthUnit.NewtonPerMeter: return _value; + case ForcePerLengthUnit.CentinewtonPerMeter: + return new ForcePerLength((_value) * 1e-2d, BaseUnit); + case ForcePerLengthUnit.DecinewtonPerMeter: + return new ForcePerLength((_value) * 1e-1d, BaseUnit); + case ForcePerLengthUnit.KilogramForcePerMeter: + return new ForcePerLength(_value*9.80665002864, BaseUnit); + case ForcePerLengthUnit.KilonewtonPerMeter: + return new ForcePerLength((_value) * 1e3d, BaseUnit); + case ForcePerLengthUnit.MeganewtonPerMeter: + return new ForcePerLength((_value) * 1e6d, BaseUnit); + case ForcePerLengthUnit.MicronewtonPerMeter: + return new ForcePerLength((_value) * 1e-6d, BaseUnit); + case ForcePerLengthUnit.MillinewtonPerMeter: + return new ForcePerLength((_value) * 1e-3d, BaseUnit); + case ForcePerLengthUnit.NanonewtonPerMeter: + return new ForcePerLength((_value) * 1e-9d, BaseUnit); + case ForcePerLengthUnit.NewtonPerMeter: + return new ForcePerLength(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -672,7 +681,8 @@ private double AsBaseNumericType(ForcePerLengthUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Frequency.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Frequency.NetFramework.g.cs index b3a24c9827..e8cd88dbf9 100644 --- a/UnitsNet/GeneratedCode/Quantities/Frequency.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Frequency.NetFramework.g.cs @@ -635,18 +635,26 @@ public Frequency ToUnit(FrequencyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Frequency AsBaseUnit() { switch(Unit) { - case FrequencyUnit.CyclePerHour: return _value/3600; - case FrequencyUnit.CyclePerMinute: return _value/60; - case FrequencyUnit.Gigahertz: return (_value) * 1e9d; - case FrequencyUnit.Hertz: return _value; - case FrequencyUnit.Kilohertz: return (_value) * 1e3d; - case FrequencyUnit.Megahertz: return (_value) * 1e6d; - case FrequencyUnit.RadianPerSecond: return _value/6.2831853072; - case FrequencyUnit.Terahertz: return (_value) * 1e12d; + case FrequencyUnit.CyclePerHour: + return new Frequency(_value/3600, BaseUnit); + case FrequencyUnit.CyclePerMinute: + return new Frequency(_value/60, BaseUnit); + case FrequencyUnit.Gigahertz: + return new Frequency((_value) * 1e9d, BaseUnit); + case FrequencyUnit.Hertz: + return new Frequency(_value, BaseUnit); + case FrequencyUnit.Kilohertz: + return new Frequency((_value) * 1e3d, BaseUnit); + case FrequencyUnit.Megahertz: + return new Frequency((_value) * 1e6d, BaseUnit); + case FrequencyUnit.RadianPerSecond: + return new Frequency(_value/6.2831853072, BaseUnit); + case FrequencyUnit.Terahertz: + return new Frequency((_value) * 1e12d, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -657,7 +665,8 @@ private double AsBaseNumericType(FrequencyUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/HeatFlux.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/HeatFlux.NetFramework.g.cs index 81a2941027..ba83b69d86 100644 --- a/UnitsNet/GeneratedCode/Quantities/HeatFlux.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/HeatFlux.NetFramework.g.cs @@ -775,28 +775,46 @@ public HeatFlux ToUnit(HeatFluxUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal HeatFlux AsBaseUnit() { switch(Unit) { - case HeatFluxUnit.BtuPerHourSquareFoot: return _value*3.15459075; - case HeatFluxUnit.BtuPerMinuteSquareFoot: return _value*1.89275445e2; - case HeatFluxUnit.BtuPerSecondSquareFoot: return _value*1.13565267e4; - case HeatFluxUnit.BtuPerSecondSquareInch: return _value*1.63533984e6; - case HeatFluxUnit.CaloriePerSecondSquareCentimeter: return _value*4.1868e4; - case HeatFluxUnit.CentiwattPerSquareMeter: return (_value) * 1e-2d; - case HeatFluxUnit.DeciwattPerSquareMeter: return (_value) * 1e-1d; - case HeatFluxUnit.KilocaloriePerHourSquareMeter: return _value*1.163; - case HeatFluxUnit.KilocaloriePerSecondSquareCentimeter: return (_value*4.1868e4) * 1e3d; - case HeatFluxUnit.KilowattPerSquareMeter: return (_value) * 1e3d; - case HeatFluxUnit.MicrowattPerSquareMeter: return (_value) * 1e-6d; - case HeatFluxUnit.MilliwattPerSquareMeter: return (_value) * 1e-3d; - case HeatFluxUnit.NanowattPerSquareMeter: return (_value) * 1e-9d; - case HeatFluxUnit.PoundForcePerFootSecond: return _value*1.459390293720636e1; - case HeatFluxUnit.PoundPerSecondCubed: return _value*4.5359237e-1; - case HeatFluxUnit.WattPerSquareFoot: return _value*1.07639e1; - case HeatFluxUnit.WattPerSquareInch: return _value*1.5500031e3; - case HeatFluxUnit.WattPerSquareMeter: return _value; + case HeatFluxUnit.BtuPerHourSquareFoot: + return new HeatFlux(_value*3.15459075, BaseUnit); + case HeatFluxUnit.BtuPerMinuteSquareFoot: + return new HeatFlux(_value*1.89275445e2, BaseUnit); + case HeatFluxUnit.BtuPerSecondSquareFoot: + return new HeatFlux(_value*1.13565267e4, BaseUnit); + case HeatFluxUnit.BtuPerSecondSquareInch: + return new HeatFlux(_value*1.63533984e6, BaseUnit); + case HeatFluxUnit.CaloriePerSecondSquareCentimeter: + return new HeatFlux(_value*4.1868e4, BaseUnit); + case HeatFluxUnit.CentiwattPerSquareMeter: + return new HeatFlux((_value) * 1e-2d, BaseUnit); + case HeatFluxUnit.DeciwattPerSquareMeter: + return new HeatFlux((_value) * 1e-1d, BaseUnit); + case HeatFluxUnit.KilocaloriePerHourSquareMeter: + return new HeatFlux(_value*1.163, BaseUnit); + case HeatFluxUnit.KilocaloriePerSecondSquareCentimeter: + return new HeatFlux((_value*4.1868e4) * 1e3d, BaseUnit); + case HeatFluxUnit.KilowattPerSquareMeter: + return new HeatFlux((_value) * 1e3d, BaseUnit); + case HeatFluxUnit.MicrowattPerSquareMeter: + return new HeatFlux((_value) * 1e-6d, BaseUnit); + case HeatFluxUnit.MilliwattPerSquareMeter: + return new HeatFlux((_value) * 1e-3d, BaseUnit); + case HeatFluxUnit.NanowattPerSquareMeter: + return new HeatFlux((_value) * 1e-9d, BaseUnit); + case HeatFluxUnit.PoundForcePerFootSecond: + return new HeatFlux(_value*1.459390293720636e1, BaseUnit); + case HeatFluxUnit.PoundPerSecondCubed: + return new HeatFlux(_value*4.5359237e-1, BaseUnit); + case HeatFluxUnit.WattPerSquareFoot: + return new HeatFlux(_value*1.07639e1, BaseUnit); + case HeatFluxUnit.WattPerSquareInch: + return new HeatFlux(_value*1.5500031e3, BaseUnit); + case HeatFluxUnit.WattPerSquareMeter: + return new HeatFlux(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -807,7 +825,8 @@ private double AsBaseNumericType(HeatFluxUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.NetFramework.g.cs index c355fb90d4..ce5317406e 100644 --- a/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.NetFramework.g.cs @@ -551,12 +551,14 @@ public HeatTransferCoefficient ToUnit(HeatTransferCoefficientUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal HeatTransferCoefficient AsBaseUnit() { switch(Unit) { - case HeatTransferCoefficientUnit.WattPerSquareMeterCelsius: return _value; - case HeatTransferCoefficientUnit.WattPerSquareMeterKelvin: return _value; + case HeatTransferCoefficientUnit.WattPerSquareMeterCelsius: + return new HeatTransferCoefficient(_value, BaseUnit); + case HeatTransferCoefficientUnit.WattPerSquareMeterKelvin: + return new HeatTransferCoefficient(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -567,7 +569,8 @@ private double AsBaseNumericType(HeatTransferCoefficientUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Illuminance.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Illuminance.NetFramework.g.cs index c5da84031f..74abea1524 100644 --- a/UnitsNet/GeneratedCode/Quantities/Illuminance.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Illuminance.NetFramework.g.cs @@ -582,14 +582,18 @@ public Illuminance ToUnit(IlluminanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Illuminance AsBaseUnit() { switch(Unit) { - case IlluminanceUnit.Kilolux: return (_value) * 1e3d; - case IlluminanceUnit.Lux: return _value; - case IlluminanceUnit.Megalux: return (_value) * 1e6d; - case IlluminanceUnit.Millilux: return (_value) * 1e-3d; + case IlluminanceUnit.Kilolux: + return new Illuminance((_value) * 1e3d, BaseUnit); + case IlluminanceUnit.Lux: + return new Illuminance(_value, BaseUnit); + case IlluminanceUnit.Megalux: + return new Illuminance((_value) * 1e6d, BaseUnit); + case IlluminanceUnit.Millilux: + return new Illuminance((_value) * 1e-3d, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -600,7 +604,8 @@ private double AsBaseNumericType(IlluminanceUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Information.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Information.NetFramework.g.cs index d713e80770..b12a951e26 100644 --- a/UnitsNet/GeneratedCode/Quantities/Information.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Information.NetFramework.g.cs @@ -887,36 +887,62 @@ public Information ToUnit(InformationUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private decimal AsBaseUnit() + internal Information AsBaseUnit() { switch(Unit) { - case InformationUnit.Bit: return _value; - case InformationUnit.Byte: return _value*8m; - case InformationUnit.Exabit: return (_value) * 1e18m; - case InformationUnit.Exabyte: return (_value*8m) * 1e18m; - case InformationUnit.Exbibit: return (_value) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024); - case InformationUnit.Exbibyte: return (_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024); - case InformationUnit.Gibibit: return (_value) * (1024m * 1024 * 1024); - case InformationUnit.Gibibyte: return (_value*8m) * (1024m * 1024 * 1024); - case InformationUnit.Gigabit: return (_value) * 1e9m; - case InformationUnit.Gigabyte: return (_value*8m) * 1e9m; - case InformationUnit.Kibibit: return (_value) * 1024m; - case InformationUnit.Kibibyte: return (_value*8m) * 1024m; - case InformationUnit.Kilobit: return (_value) * 1e3m; - case InformationUnit.Kilobyte: return (_value*8m) * 1e3m; - case InformationUnit.Mebibit: return (_value) * (1024m * 1024); - case InformationUnit.Mebibyte: return (_value*8m) * (1024m * 1024); - case InformationUnit.Megabit: return (_value) * 1e6m; - case InformationUnit.Megabyte: return (_value*8m) * 1e6m; - case InformationUnit.Pebibit: return (_value) * (1024m * 1024 * 1024 * 1024 * 1024); - case InformationUnit.Pebibyte: return (_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024); - case InformationUnit.Petabit: return (_value) * 1e15m; - case InformationUnit.Petabyte: return (_value*8m) * 1e15m; - case InformationUnit.Tebibit: return (_value) * (1024m * 1024 * 1024 * 1024); - case InformationUnit.Tebibyte: return (_value*8m) * (1024m * 1024 * 1024 * 1024); - case InformationUnit.Terabit: return (_value) * 1e12m; - case InformationUnit.Terabyte: return (_value*8m) * 1e12m; + case InformationUnit.Bit: + return new Information(_value, BaseUnit); + case InformationUnit.Byte: + return new Information(_value*8m, BaseUnit); + case InformationUnit.Exabit: + return new Information((_value) * 1e18m, BaseUnit); + case InformationUnit.Exabyte: + return new Information((_value*8m) * 1e18m, BaseUnit); + case InformationUnit.Exbibit: + return new Information((_value) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024), BaseUnit); + case InformationUnit.Exbibyte: + return new Information((_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024), BaseUnit); + case InformationUnit.Gibibit: + return new Information((_value) * (1024m * 1024 * 1024), BaseUnit); + case InformationUnit.Gibibyte: + return new Information((_value*8m) * (1024m * 1024 * 1024), BaseUnit); + case InformationUnit.Gigabit: + return new Information((_value) * 1e9m, BaseUnit); + case InformationUnit.Gigabyte: + return new Information((_value*8m) * 1e9m, BaseUnit); + case InformationUnit.Kibibit: + return new Information((_value) * 1024m, BaseUnit); + case InformationUnit.Kibibyte: + return new Information((_value*8m) * 1024m, BaseUnit); + case InformationUnit.Kilobit: + return new Information((_value) * 1e3m, BaseUnit); + case InformationUnit.Kilobyte: + return new Information((_value*8m) * 1e3m, BaseUnit); + case InformationUnit.Mebibit: + return new Information((_value) * (1024m * 1024), BaseUnit); + case InformationUnit.Mebibyte: + return new Information((_value*8m) * (1024m * 1024), BaseUnit); + case InformationUnit.Megabit: + return new Information((_value) * 1e6m, BaseUnit); + case InformationUnit.Megabyte: + return new Information((_value*8m) * 1e6m, BaseUnit); + case InformationUnit.Pebibit: + return new Information((_value) * (1024m * 1024 * 1024 * 1024 * 1024), BaseUnit); + case InformationUnit.Pebibyte: + return new Information((_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024), BaseUnit); + case InformationUnit.Petabit: + return new Information((_value) * 1e15m, BaseUnit); + case InformationUnit.Petabyte: + return new Information((_value*8m) * 1e15m, BaseUnit); + case InformationUnit.Tebibit: + return new Information((_value) * (1024m * 1024 * 1024 * 1024), BaseUnit); + case InformationUnit.Tebibyte: + return new Information((_value*8m) * (1024m * 1024 * 1024 * 1024), BaseUnit); + case InformationUnit.Terabit: + return new Information((_value) * 1e12m, BaseUnit); + case InformationUnit.Terabyte: + return new Information((_value*8m) * 1e12m, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -927,7 +953,8 @@ private decimal AsBaseNumericType(InformationUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Irradiance.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Irradiance.NetFramework.g.cs index 0b844c8377..f8a302ac4d 100644 --- a/UnitsNet/GeneratedCode/Quantities/Irradiance.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Irradiance.NetFramework.g.cs @@ -719,24 +719,38 @@ public Irradiance ToUnit(IrradianceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Irradiance AsBaseUnit() { switch(Unit) { - case IrradianceUnit.KilowattPerSquareCentimeter: return (_value*10000) * 1e3d; - case IrradianceUnit.KilowattPerSquareMeter: return (_value) * 1e3d; - case IrradianceUnit.MegawattPerSquareCentimeter: return (_value*10000) * 1e6d; - case IrradianceUnit.MegawattPerSquareMeter: return (_value) * 1e6d; - case IrradianceUnit.MicrowattPerSquareCentimeter: return (_value*10000) * 1e-6d; - case IrradianceUnit.MicrowattPerSquareMeter: return (_value) * 1e-6d; - case IrradianceUnit.MilliwattPerSquareCentimeter: return (_value*10000) * 1e-3d; - case IrradianceUnit.MilliwattPerSquareMeter: return (_value) * 1e-3d; - case IrradianceUnit.NanowattPerSquareCentimeter: return (_value*10000) * 1e-9d; - case IrradianceUnit.NanowattPerSquareMeter: return (_value) * 1e-9d; - case IrradianceUnit.PicowattPerSquareCentimeter: return (_value*10000) * 1e-12d; - case IrradianceUnit.PicowattPerSquareMeter: return (_value) * 1e-12d; - case IrradianceUnit.WattPerSquareCentimeter: return _value*10000; - case IrradianceUnit.WattPerSquareMeter: return _value; + case IrradianceUnit.KilowattPerSquareCentimeter: + return new Irradiance((_value*10000) * 1e3d, BaseUnit); + case IrradianceUnit.KilowattPerSquareMeter: + return new Irradiance((_value) * 1e3d, BaseUnit); + case IrradianceUnit.MegawattPerSquareCentimeter: + return new Irradiance((_value*10000) * 1e6d, BaseUnit); + case IrradianceUnit.MegawattPerSquareMeter: + return new Irradiance((_value) * 1e6d, BaseUnit); + case IrradianceUnit.MicrowattPerSquareCentimeter: + return new Irradiance((_value*10000) * 1e-6d, BaseUnit); + case IrradianceUnit.MicrowattPerSquareMeter: + return new Irradiance((_value) * 1e-6d, BaseUnit); + case IrradianceUnit.MilliwattPerSquareCentimeter: + return new Irradiance((_value*10000) * 1e-3d, BaseUnit); + case IrradianceUnit.MilliwattPerSquareMeter: + return new Irradiance((_value) * 1e-3d, BaseUnit); + case IrradianceUnit.NanowattPerSquareCentimeter: + return new Irradiance((_value*10000) * 1e-9d, BaseUnit); + case IrradianceUnit.NanowattPerSquareMeter: + return new Irradiance((_value) * 1e-9d, BaseUnit); + case IrradianceUnit.PicowattPerSquareCentimeter: + return new Irradiance((_value*10000) * 1e-12d, BaseUnit); + case IrradianceUnit.PicowattPerSquareMeter: + return new Irradiance((_value) * 1e-12d, BaseUnit); + case IrradianceUnit.WattPerSquareCentimeter: + return new Irradiance(_value*10000, BaseUnit); + case IrradianceUnit.WattPerSquareMeter: + return new Irradiance(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -747,7 +761,8 @@ private double AsBaseNumericType(IrradianceUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Irradiation.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Irradiation.NetFramework.g.cs index 6a1b662c8d..9d6331f288 100644 --- a/UnitsNet/GeneratedCode/Quantities/Irradiation.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Irradiation.NetFramework.g.cs @@ -582,14 +582,18 @@ public Irradiation ToUnit(IrradiationUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Irradiation AsBaseUnit() { switch(Unit) { - case IrradiationUnit.JoulePerSquareMeter: return _value; - case IrradiationUnit.JoulePerSquareMillimeter: return _value*1e6; - case IrradiationUnit.KilowattHourPerSquareMeter: return (_value*3600d) * 1e3d; - case IrradiationUnit.WattHourPerSquareMeter: return _value*3600d; + case IrradiationUnit.JoulePerSquareMeter: + return new Irradiation(_value, BaseUnit); + case IrradiationUnit.JoulePerSquareMillimeter: + return new Irradiation(_value*1e6, BaseUnit); + case IrradiationUnit.KilowattHourPerSquareMeter: + return new Irradiation((_value*3600d) * 1e3d, BaseUnit); + case IrradiationUnit.WattHourPerSquareMeter: + return new Irradiation(_value*3600d, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -600,7 +604,8 @@ private double AsBaseNumericType(IrradiationUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.NetFramework.g.cs index 7f291dac8a..e7a89fc246 100644 --- a/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.NetFramework.g.cs @@ -638,18 +638,26 @@ public KinematicViscosity ToUnit(KinematicViscosityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal KinematicViscosity AsBaseUnit() { switch(Unit) { - case KinematicViscosityUnit.Centistokes: return (_value/1e4) * 1e-2d; - case KinematicViscosityUnit.Decistokes: return (_value/1e4) * 1e-1d; - case KinematicViscosityUnit.Kilostokes: return (_value/1e4) * 1e3d; - case KinematicViscosityUnit.Microstokes: return (_value/1e4) * 1e-6d; - case KinematicViscosityUnit.Millistokes: return (_value/1e4) * 1e-3d; - case KinematicViscosityUnit.Nanostokes: return (_value/1e4) * 1e-9d; - case KinematicViscosityUnit.SquareMeterPerSecond: return _value; - case KinematicViscosityUnit.Stokes: return _value/1e4; + case KinematicViscosityUnit.Centistokes: + return new KinematicViscosity((_value/1e4) * 1e-2d, BaseUnit); + case KinematicViscosityUnit.Decistokes: + return new KinematicViscosity((_value/1e4) * 1e-1d, BaseUnit); + case KinematicViscosityUnit.Kilostokes: + return new KinematicViscosity((_value/1e4) * 1e3d, BaseUnit); + case KinematicViscosityUnit.Microstokes: + return new KinematicViscosity((_value/1e4) * 1e-6d, BaseUnit); + case KinematicViscosityUnit.Millistokes: + return new KinematicViscosity((_value/1e4) * 1e-3d, BaseUnit); + case KinematicViscosityUnit.Nanostokes: + return new KinematicViscosity((_value/1e4) * 1e-9d, BaseUnit); + case KinematicViscosityUnit.SquareMeterPerSecond: + return new KinematicViscosity(_value, BaseUnit); + case KinematicViscosityUnit.Stokes: + return new KinematicViscosity(_value/1e4, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -660,7 +668,8 @@ private double AsBaseNumericType(KinematicViscosityUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/LapseRate.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/LapseRate.NetFramework.g.cs index be4066d7f3..a7b9f4b22d 100644 --- a/UnitsNet/GeneratedCode/Quantities/LapseRate.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/LapseRate.NetFramework.g.cs @@ -537,11 +537,12 @@ public LapseRate ToUnit(LapseRateUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal LapseRate AsBaseUnit() { switch(Unit) { - case LapseRateUnit.DegreeCelsiusPerKilometer: return _value; + case LapseRateUnit.DegreeCelsiusPerKilometer: + return new LapseRate(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -552,7 +553,8 @@ private double AsBaseNumericType(LapseRateUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Length.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Length.NetFramework.g.cs index e03e322247..8f2a6e34cf 100644 --- a/UnitsNet/GeneratedCode/Quantities/Length.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Length.NetFramework.g.cs @@ -831,32 +831,54 @@ public Length ToUnit(LengthUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Length AsBaseUnit() { switch(Unit) { - case LengthUnit.Centimeter: return (_value) * 1e-2d; - case LengthUnit.Decimeter: return (_value) * 1e-1d; - case LengthUnit.DtpPica: return _value/236.220472441; - case LengthUnit.DtpPoint: return (_value/72)*2.54e-2; - case LengthUnit.Fathom: return _value*1.8288; - case LengthUnit.Foot: return _value*0.3048; - case LengthUnit.Inch: return _value*2.54e-2; - case LengthUnit.Kilometer: return (_value) * 1e3d; - case LengthUnit.Meter: return _value; - case LengthUnit.Microinch: return _value*2.54e-8; - case LengthUnit.Micrometer: return (_value) * 1e-6d; - case LengthUnit.Mil: return _value*2.54e-5; - case LengthUnit.Mile: return _value*1609.34; - case LengthUnit.Millimeter: return (_value) * 1e-3d; - case LengthUnit.Nanometer: return (_value) * 1e-9d; - case LengthUnit.NauticalMile: return _value*1852; - case LengthUnit.PrinterPica: return _value/237.106301584; - case LengthUnit.PrinterPoint: return (_value/72.27)*2.54e-2; - case LengthUnit.Shackle: return _value*27.432; - case LengthUnit.Twip: return _value/56692.913385826; - case LengthUnit.UsSurveyFoot: return _value*1200/3937; - case LengthUnit.Yard: return _value*0.9144; + case LengthUnit.Centimeter: + return new Length((_value) * 1e-2d, BaseUnit); + case LengthUnit.Decimeter: + return new Length((_value) * 1e-1d, BaseUnit); + case LengthUnit.DtpPica: + return new Length(_value/236.220472441, BaseUnit); + case LengthUnit.DtpPoint: + return new Length((_value/72)*2.54e-2, BaseUnit); + case LengthUnit.Fathom: + return new Length(_value*1.8288, BaseUnit); + case LengthUnit.Foot: + return new Length(_value*0.3048, BaseUnit); + case LengthUnit.Inch: + return new Length(_value*2.54e-2, BaseUnit); + case LengthUnit.Kilometer: + return new Length((_value) * 1e3d, BaseUnit); + case LengthUnit.Meter: + return new Length(_value, BaseUnit); + case LengthUnit.Microinch: + return new Length(_value*2.54e-8, BaseUnit); + case LengthUnit.Micrometer: + return new Length((_value) * 1e-6d, BaseUnit); + case LengthUnit.Mil: + return new Length(_value*2.54e-5, BaseUnit); + case LengthUnit.Mile: + return new Length(_value*1609.34, BaseUnit); + case LengthUnit.Millimeter: + return new Length((_value) * 1e-3d, BaseUnit); + case LengthUnit.Nanometer: + return new Length((_value) * 1e-9d, BaseUnit); + case LengthUnit.NauticalMile: + return new Length(_value*1852, BaseUnit); + case LengthUnit.PrinterPica: + return new Length(_value/237.106301584, BaseUnit); + case LengthUnit.PrinterPoint: + return new Length((_value/72.27)*2.54e-2, BaseUnit); + case LengthUnit.Shackle: + return new Length(_value*27.432, BaseUnit); + case LengthUnit.Twip: + return new Length(_value/56692.913385826, BaseUnit); + case LengthUnit.UsSurveyFoot: + return new Length(_value*1200/3937, BaseUnit); + case LengthUnit.Yard: + return new Length(_value*0.9144, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -867,7 +889,8 @@ private double AsBaseNumericType(LengthUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Level.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Level.NetFramework.g.cs index e35db5d5c1..70def151cd 100644 --- a/UnitsNet/GeneratedCode/Quantities/Level.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Level.NetFramework.g.cs @@ -559,12 +559,14 @@ public Level ToUnit(LevelUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Level AsBaseUnit() { switch(Unit) { - case LevelUnit.Decibel: return _value; - case LevelUnit.Neper: return (1/0.115129254)*_value; + case LevelUnit.Decibel: + return new Level(_value, BaseUnit); + case LevelUnit.Neper: + return new Level((1/0.115129254)*_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -575,7 +577,8 @@ private double AsBaseNumericType(LevelUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/LinearDensity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/LinearDensity.NetFramework.g.cs index cbf5870f3b..c6a84b4ee9 100644 --- a/UnitsNet/GeneratedCode/Quantities/LinearDensity.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/LinearDensity.NetFramework.g.cs @@ -568,13 +568,16 @@ public LinearDensity ToUnit(LinearDensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal LinearDensity AsBaseUnit() { switch(Unit) { - case LinearDensityUnit.GramPerMeter: return _value*1e-3; - case LinearDensityUnit.KilogramPerMeter: return (_value*1e-3) * 1e3d; - case LinearDensityUnit.PoundPerFoot: return _value*1.48816394; + case LinearDensityUnit.GramPerMeter: + return new LinearDensity(_value*1e-3, BaseUnit); + case LinearDensityUnit.KilogramPerMeter: + return new LinearDensity((_value*1e-3) * 1e3d, BaseUnit); + case LinearDensityUnit.PoundPerFoot: + return new LinearDensity(_value*1.48816394, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -585,7 +588,8 @@ private double AsBaseNumericType(LinearDensityUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/LuminousFlux.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/LuminousFlux.NetFramework.g.cs index a7ee796bb5..6f03dce364 100644 --- a/UnitsNet/GeneratedCode/Quantities/LuminousFlux.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/LuminousFlux.NetFramework.g.cs @@ -540,11 +540,12 @@ public LuminousFlux ToUnit(LuminousFluxUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal LuminousFlux AsBaseUnit() { switch(Unit) { - case LuminousFluxUnit.Lumen: return _value; + case LuminousFluxUnit.Lumen: + return new LuminousFlux(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -555,7 +556,8 @@ private double AsBaseNumericType(LuminousFluxUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.NetFramework.g.cs index ebfd3b327e..f3a6682791 100644 --- a/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.NetFramework.g.cs @@ -540,11 +540,12 @@ public LuminousIntensity ToUnit(LuminousIntensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal LuminousIntensity AsBaseUnit() { switch(Unit) { - case LuminousIntensityUnit.Candela: return _value; + case LuminousIntensityUnit.Candela: + return new LuminousIntensity(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -555,7 +556,8 @@ private double AsBaseNumericType(LuminousIntensityUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/MagneticField.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/MagneticField.NetFramework.g.cs index 3e218c9500..fde369e861 100644 --- a/UnitsNet/GeneratedCode/Quantities/MagneticField.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MagneticField.NetFramework.g.cs @@ -582,14 +582,18 @@ public MagneticField ToUnit(MagneticFieldUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal MagneticField AsBaseUnit() { switch(Unit) { - case MagneticFieldUnit.Microtesla: return (_value) * 1e-6d; - case MagneticFieldUnit.Millitesla: return (_value) * 1e-3d; - case MagneticFieldUnit.Nanotesla: return (_value) * 1e-9d; - case MagneticFieldUnit.Tesla: return _value; + case MagneticFieldUnit.Microtesla: + return new MagneticField((_value) * 1e-6d, BaseUnit); + case MagneticFieldUnit.Millitesla: + return new MagneticField((_value) * 1e-3d, BaseUnit); + case MagneticFieldUnit.Nanotesla: + return new MagneticField((_value) * 1e-9d, BaseUnit); + case MagneticFieldUnit.Tesla: + return new MagneticField(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -600,7 +604,8 @@ private double AsBaseNumericType(MagneticFieldUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/MagneticFlux.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/MagneticFlux.NetFramework.g.cs index 6758122032..b637c79689 100644 --- a/UnitsNet/GeneratedCode/Quantities/MagneticFlux.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MagneticFlux.NetFramework.g.cs @@ -540,11 +540,12 @@ public MagneticFlux ToUnit(MagneticFluxUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal MagneticFlux AsBaseUnit() { switch(Unit) { - case MagneticFluxUnit.Weber: return _value; + case MagneticFluxUnit.Weber: + return new MagneticFlux(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -555,7 +556,8 @@ private double AsBaseNumericType(MagneticFluxUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Magnetization.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Magnetization.NetFramework.g.cs index fb03bce307..a6d6dd54aa 100644 --- a/UnitsNet/GeneratedCode/Quantities/Magnetization.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Magnetization.NetFramework.g.cs @@ -540,11 +540,12 @@ public Magnetization ToUnit(MagnetizationUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Magnetization AsBaseUnit() { switch(Unit) { - case MagnetizationUnit.AmperePerMeter: return _value; + case MagnetizationUnit.AmperePerMeter: + return new Magnetization(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -555,7 +556,8 @@ private double AsBaseNumericType(MagnetizationUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Mass.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Mass.NetFramework.g.cs index eae1d5a933..07cff60d18 100644 --- a/UnitsNet/GeneratedCode/Quantities/Mass.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Mass.NetFramework.g.cs @@ -845,33 +845,56 @@ public Mass ToUnit(MassUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Mass AsBaseUnit() { switch(Unit) { - case MassUnit.Centigram: return (_value/1e3) * 1e-2d; - case MassUnit.Decagram: return (_value/1e3) * 1e1d; - case MassUnit.Decigram: return (_value/1e3) * 1e-1d; - case MassUnit.Grain: return _value/15432.358352941431; - case MassUnit.Gram: return _value/1e3; - case MassUnit.Hectogram: return (_value/1e3) * 1e2d; - case MassUnit.Kilogram: return (_value/1e3) * 1e3d; - case MassUnit.Kilopound: return (_value*0.45359237) * 1e3d; - case MassUnit.Kilotonne: return (_value*1e3) * 1e3d; - case MassUnit.LongHundredweight: return _value/0.01968413055222121; - case MassUnit.LongTon: return _value*1.0160469088e3; - case MassUnit.Megapound: return (_value*0.45359237) * 1e6d; - case MassUnit.Megatonne: return (_value*1e3) * 1e6d; - case MassUnit.Microgram: return (_value/1e3) * 1e-6d; - case MassUnit.Milligram: return (_value/1e3) * 1e-3d; - case MassUnit.Nanogram: return (_value/1e3) * 1e-9d; - case MassUnit.Ounce: return _value/35.2739619; - case MassUnit.Pound: return _value*0.45359237; - case MassUnit.ShortHundredweight: return _value/0.022046226218487758; - case MassUnit.ShortTon: return _value*9.0718474e2; - case MassUnit.Slug: return _value/6.852176556196105e-2; - case MassUnit.Stone: return _value/0.1574731728702698; - case MassUnit.Tonne: return _value*1e3; + case MassUnit.Centigram: + return new Mass((_value/1e3) * 1e-2d, BaseUnit); + case MassUnit.Decagram: + return new Mass((_value/1e3) * 1e1d, BaseUnit); + case MassUnit.Decigram: + return new Mass((_value/1e3) * 1e-1d, BaseUnit); + case MassUnit.Grain: + return new Mass(_value/15432.358352941431, BaseUnit); + case MassUnit.Gram: + return new Mass(_value/1e3, BaseUnit); + case MassUnit.Hectogram: + return new Mass((_value/1e3) * 1e2d, BaseUnit); + case MassUnit.Kilogram: + return new Mass((_value/1e3) * 1e3d, BaseUnit); + case MassUnit.Kilopound: + return new Mass((_value*0.45359237) * 1e3d, BaseUnit); + case MassUnit.Kilotonne: + return new Mass((_value*1e3) * 1e3d, BaseUnit); + case MassUnit.LongHundredweight: + return new Mass(_value/0.01968413055222121, BaseUnit); + case MassUnit.LongTon: + return new Mass(_value*1.0160469088e3, BaseUnit); + case MassUnit.Megapound: + return new Mass((_value*0.45359237) * 1e6d, BaseUnit); + case MassUnit.Megatonne: + return new Mass((_value*1e3) * 1e6d, BaseUnit); + case MassUnit.Microgram: + return new Mass((_value/1e3) * 1e-6d, BaseUnit); + case MassUnit.Milligram: + return new Mass((_value/1e3) * 1e-3d, BaseUnit); + case MassUnit.Nanogram: + return new Mass((_value/1e3) * 1e-9d, BaseUnit); + case MassUnit.Ounce: + return new Mass(_value/35.2739619, BaseUnit); + case MassUnit.Pound: + return new Mass(_value*0.45359237, BaseUnit); + case MassUnit.ShortHundredweight: + return new Mass(_value/0.022046226218487758, BaseUnit); + case MassUnit.ShortTon: + return new Mass(_value*9.0718474e2, BaseUnit); + case MassUnit.Slug: + return new Mass(_value/6.852176556196105e-2, BaseUnit); + case MassUnit.Stone: + return new Mass(_value/0.1574731728702698, BaseUnit); + case MassUnit.Tonne: + return new Mass(_value*1e3, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -882,7 +905,8 @@ private double AsBaseNumericType(MassUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/MassFlow.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/MassFlow.NetFramework.g.cs index 9f38386230..8c57c9fe99 100644 --- a/UnitsNet/GeneratedCode/Quantities/MassFlow.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MassFlow.NetFramework.g.cs @@ -943,40 +943,70 @@ public MassFlow ToUnit(MassFlowUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal MassFlow AsBaseUnit() { switch(Unit) { - case MassFlowUnit.CentigramPerDay: return (_value/86400) * 1e-2d; - case MassFlowUnit.CentigramPerSecond: return (_value) * 1e-2d; - case MassFlowUnit.DecagramPerDay: return (_value/86400) * 1e1d; - case MassFlowUnit.DecagramPerSecond: return (_value) * 1e1d; - case MassFlowUnit.DecigramPerDay: return (_value/86400) * 1e-1d; - case MassFlowUnit.DecigramPerSecond: return (_value) * 1e-1d; - case MassFlowUnit.GramPerDay: return _value/86400; - case MassFlowUnit.GramPerSecond: return _value; - case MassFlowUnit.HectogramPerDay: return (_value/86400) * 1e2d; - case MassFlowUnit.HectogramPerSecond: return (_value) * 1e2d; - case MassFlowUnit.KilogramPerDay: return (_value/86400) * 1e3d; - case MassFlowUnit.KilogramPerHour: return _value/3.6; - case MassFlowUnit.KilogramPerMinute: return _value/0.06; - case MassFlowUnit.KilogramPerSecond: return (_value) * 1e3d; - case MassFlowUnit.MegagramPerDay: return (_value/86400) * 1e6d; - case MassFlowUnit.MegapoundPerDay: return (_value/190.47936) * 1e6d; - case MassFlowUnit.MegapoundPerHour: return (_value/7.93664) * 1e6d; - case MassFlowUnit.MegapoundPerMinute: return (_value/0.132277) * 1e6d; - case MassFlowUnit.MicrogramPerDay: return (_value/86400) * 1e-6d; - case MassFlowUnit.MicrogramPerSecond: return (_value) * 1e-6d; - case MassFlowUnit.MilligramPerDay: return (_value/86400) * 1e-3d; - case MassFlowUnit.MilligramPerSecond: return (_value) * 1e-3d; - case MassFlowUnit.NanogramPerDay: return (_value/86400) * 1e-9d; - case MassFlowUnit.NanogramPerSecond: return (_value) * 1e-9d; - case MassFlowUnit.PoundPerDay: return _value/190.47936; - case MassFlowUnit.PoundPerHour: return _value/7.93664; - case MassFlowUnit.PoundPerMinute: return _value/0.132277; - case MassFlowUnit.ShortTonPerHour: return _value*251.9957611; - case MassFlowUnit.TonnePerDay: return _value/0.0864000; - case MassFlowUnit.TonnePerHour: return 1000*_value/3.6; + case MassFlowUnit.CentigramPerDay: + return new MassFlow((_value/86400) * 1e-2d, BaseUnit); + case MassFlowUnit.CentigramPerSecond: + return new MassFlow((_value) * 1e-2d, BaseUnit); + case MassFlowUnit.DecagramPerDay: + return new MassFlow((_value/86400) * 1e1d, BaseUnit); + case MassFlowUnit.DecagramPerSecond: + return new MassFlow((_value) * 1e1d, BaseUnit); + case MassFlowUnit.DecigramPerDay: + return new MassFlow((_value/86400) * 1e-1d, BaseUnit); + case MassFlowUnit.DecigramPerSecond: + return new MassFlow((_value) * 1e-1d, BaseUnit); + case MassFlowUnit.GramPerDay: + return new MassFlow(_value/86400, BaseUnit); + case MassFlowUnit.GramPerSecond: + return new MassFlow(_value, BaseUnit); + case MassFlowUnit.HectogramPerDay: + return new MassFlow((_value/86400) * 1e2d, BaseUnit); + case MassFlowUnit.HectogramPerSecond: + return new MassFlow((_value) * 1e2d, BaseUnit); + case MassFlowUnit.KilogramPerDay: + return new MassFlow((_value/86400) * 1e3d, BaseUnit); + case MassFlowUnit.KilogramPerHour: + return new MassFlow(_value/3.6, BaseUnit); + case MassFlowUnit.KilogramPerMinute: + return new MassFlow(_value/0.06, BaseUnit); + case MassFlowUnit.KilogramPerSecond: + return new MassFlow((_value) * 1e3d, BaseUnit); + case MassFlowUnit.MegagramPerDay: + return new MassFlow((_value/86400) * 1e6d, BaseUnit); + case MassFlowUnit.MegapoundPerDay: + return new MassFlow((_value/190.47936) * 1e6d, BaseUnit); + case MassFlowUnit.MegapoundPerHour: + return new MassFlow((_value/7.93664) * 1e6d, BaseUnit); + case MassFlowUnit.MegapoundPerMinute: + return new MassFlow((_value/0.132277) * 1e6d, BaseUnit); + case MassFlowUnit.MicrogramPerDay: + return new MassFlow((_value/86400) * 1e-6d, BaseUnit); + case MassFlowUnit.MicrogramPerSecond: + return new MassFlow((_value) * 1e-6d, BaseUnit); + case MassFlowUnit.MilligramPerDay: + return new MassFlow((_value/86400) * 1e-3d, BaseUnit); + case MassFlowUnit.MilligramPerSecond: + return new MassFlow((_value) * 1e-3d, BaseUnit); + case MassFlowUnit.NanogramPerDay: + return new MassFlow((_value/86400) * 1e-9d, BaseUnit); + case MassFlowUnit.NanogramPerSecond: + return new MassFlow((_value) * 1e-9d, BaseUnit); + case MassFlowUnit.PoundPerDay: + return new MassFlow(_value/190.47936, BaseUnit); + case MassFlowUnit.PoundPerHour: + return new MassFlow(_value/7.93664, BaseUnit); + case MassFlowUnit.PoundPerMinute: + return new MassFlow(_value/0.132277, BaseUnit); + case MassFlowUnit.ShortTonPerHour: + return new MassFlow(_value*251.9957611, BaseUnit); + case MassFlowUnit.TonnePerDay: + return new MassFlow(_value/0.0864000, BaseUnit); + case MassFlowUnit.TonnePerHour: + return new MassFlow(1000*_value/3.6, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -987,7 +1017,8 @@ private double AsBaseNumericType(MassFlowUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/MassFlux.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/MassFlux.NetFramework.g.cs index 6e77cad9f0..e21442f379 100644 --- a/UnitsNet/GeneratedCode/Quantities/MassFlux.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MassFlux.NetFramework.g.cs @@ -551,12 +551,14 @@ public MassFlux ToUnit(MassFluxUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal MassFlux AsBaseUnit() { switch(Unit) { - case MassFluxUnit.GramPerSecondPerSquareMeter: return _value/1e3; - case MassFluxUnit.KilogramPerSecondPerSquareMeter: return (_value/1e3) * 1e3d; + case MassFluxUnit.GramPerSecondPerSquareMeter: + return new MassFlux(_value/1e3, BaseUnit); + case MassFluxUnit.KilogramPerSecondPerSquareMeter: + return new MassFlux((_value/1e3) * 1e3d, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -567,7 +569,8 @@ private double AsBaseNumericType(MassFluxUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.NetFramework.g.cs index 8a99f8e914..f506dac0eb 100644 --- a/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.NetFramework.g.cs @@ -915,38 +915,66 @@ public MassMomentOfInertia ToUnit(MassMomentOfInertiaUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal MassMomentOfInertia AsBaseUnit() { switch(Unit) { - case MassMomentOfInertiaUnit.GramSquareCentimeter: return _value/1e7; - case MassMomentOfInertiaUnit.GramSquareDecimeter: return _value/1e5; - case MassMomentOfInertiaUnit.GramSquareMeter: return _value/1e3; - case MassMomentOfInertiaUnit.GramSquareMillimeter: return _value/1e9; - case MassMomentOfInertiaUnit.KilogramSquareCentimeter: return (_value/1e7) * 1e3d; - case MassMomentOfInertiaUnit.KilogramSquareDecimeter: return (_value/1e5) * 1e3d; - case MassMomentOfInertiaUnit.KilogramSquareMeter: return (_value/1e3) * 1e3d; - case MassMomentOfInertiaUnit.KilogramSquareMillimeter: return (_value/1e9) * 1e3d; - case MassMomentOfInertiaUnit.KilotonneSquareCentimeter: return (_value/1e1) * 1e3d; - case MassMomentOfInertiaUnit.KilotonneSquareDecimeter: return (_value/1e-1) * 1e3d; - case MassMomentOfInertiaUnit.KilotonneSquareMeter: return (_value/1e-3) * 1e3d; - case MassMomentOfInertiaUnit.KilotonneSquareMilimeter: return (_value/1e3) * 1e3d; - case MassMomentOfInertiaUnit.MegatonneSquareCentimeter: return (_value/1e1) * 1e6d; - case MassMomentOfInertiaUnit.MegatonneSquareDecimeter: return (_value/1e-1) * 1e6d; - case MassMomentOfInertiaUnit.MegatonneSquareMeter: return (_value/1e-3) * 1e6d; - case MassMomentOfInertiaUnit.MegatonneSquareMilimeter: return (_value/1e3) * 1e6d; - case MassMomentOfInertiaUnit.MilligramSquareCentimeter: return (_value/1e7) * 1e-3d; - case MassMomentOfInertiaUnit.MilligramSquareDecimeter: return (_value/1e5) * 1e-3d; - case MassMomentOfInertiaUnit.MilligramSquareMeter: return (_value/1e3) * 1e-3d; - case MassMomentOfInertiaUnit.MilligramSquareMillimeter: return (_value/1e9) * 1e-3d; - case MassMomentOfInertiaUnit.PoundSquareFoot: return _value*4.21401101e-2; - case MassMomentOfInertiaUnit.PoundSquareInch: return _value*2.9263965e-4; - case MassMomentOfInertiaUnit.SlugSquareFoot: return _value*1.3558179619; - case MassMomentOfInertiaUnit.SlugSquareInch: return _value*9.41540242e-3; - case MassMomentOfInertiaUnit.TonneSquareCentimeter: return _value/1e1; - case MassMomentOfInertiaUnit.TonneSquareDecimeter: return _value/1e-1; - case MassMomentOfInertiaUnit.TonneSquareMeter: return _value/1e-3; - case MassMomentOfInertiaUnit.TonneSquareMilimeter: return _value/1e3; + case MassMomentOfInertiaUnit.GramSquareCentimeter: + return new MassMomentOfInertia(_value/1e7, BaseUnit); + case MassMomentOfInertiaUnit.GramSquareDecimeter: + return new MassMomentOfInertia(_value/1e5, BaseUnit); + case MassMomentOfInertiaUnit.GramSquareMeter: + return new MassMomentOfInertia(_value/1e3, BaseUnit); + case MassMomentOfInertiaUnit.GramSquareMillimeter: + return new MassMomentOfInertia(_value/1e9, BaseUnit); + case MassMomentOfInertiaUnit.KilogramSquareCentimeter: + return new MassMomentOfInertia((_value/1e7) * 1e3d, BaseUnit); + case MassMomentOfInertiaUnit.KilogramSquareDecimeter: + return new MassMomentOfInertia((_value/1e5) * 1e3d, BaseUnit); + case MassMomentOfInertiaUnit.KilogramSquareMeter: + return new MassMomentOfInertia((_value/1e3) * 1e3d, BaseUnit); + case MassMomentOfInertiaUnit.KilogramSquareMillimeter: + return new MassMomentOfInertia((_value/1e9) * 1e3d, BaseUnit); + case MassMomentOfInertiaUnit.KilotonneSquareCentimeter: + return new MassMomentOfInertia((_value/1e1) * 1e3d, BaseUnit); + case MassMomentOfInertiaUnit.KilotonneSquareDecimeter: + return new MassMomentOfInertia((_value/1e-1) * 1e3d, BaseUnit); + case MassMomentOfInertiaUnit.KilotonneSquareMeter: + return new MassMomentOfInertia((_value/1e-3) * 1e3d, BaseUnit); + case MassMomentOfInertiaUnit.KilotonneSquareMilimeter: + return new MassMomentOfInertia((_value/1e3) * 1e3d, BaseUnit); + case MassMomentOfInertiaUnit.MegatonneSquareCentimeter: + return new MassMomentOfInertia((_value/1e1) * 1e6d, BaseUnit); + case MassMomentOfInertiaUnit.MegatonneSquareDecimeter: + return new MassMomentOfInertia((_value/1e-1) * 1e6d, BaseUnit); + case MassMomentOfInertiaUnit.MegatonneSquareMeter: + return new MassMomentOfInertia((_value/1e-3) * 1e6d, BaseUnit); + case MassMomentOfInertiaUnit.MegatonneSquareMilimeter: + return new MassMomentOfInertia((_value/1e3) * 1e6d, BaseUnit); + case MassMomentOfInertiaUnit.MilligramSquareCentimeter: + return new MassMomentOfInertia((_value/1e7) * 1e-3d, BaseUnit); + case MassMomentOfInertiaUnit.MilligramSquareDecimeter: + return new MassMomentOfInertia((_value/1e5) * 1e-3d, BaseUnit); + case MassMomentOfInertiaUnit.MilligramSquareMeter: + return new MassMomentOfInertia((_value/1e3) * 1e-3d, BaseUnit); + case MassMomentOfInertiaUnit.MilligramSquareMillimeter: + return new MassMomentOfInertia((_value/1e9) * 1e-3d, BaseUnit); + case MassMomentOfInertiaUnit.PoundSquareFoot: + return new MassMomentOfInertia(_value*4.21401101e-2, BaseUnit); + case MassMomentOfInertiaUnit.PoundSquareInch: + return new MassMomentOfInertia(_value*2.9263965e-4, BaseUnit); + case MassMomentOfInertiaUnit.SlugSquareFoot: + return new MassMomentOfInertia(_value*1.3558179619, BaseUnit); + case MassMomentOfInertiaUnit.SlugSquareInch: + return new MassMomentOfInertia(_value*9.41540242e-3, BaseUnit); + case MassMomentOfInertiaUnit.TonneSquareCentimeter: + return new MassMomentOfInertia(_value/1e1, BaseUnit); + case MassMomentOfInertiaUnit.TonneSquareDecimeter: + return new MassMomentOfInertia(_value/1e-1, BaseUnit); + case MassMomentOfInertiaUnit.TonneSquareMeter: + return new MassMomentOfInertia(_value/1e-3, BaseUnit); + case MassMomentOfInertiaUnit.TonneSquareMilimeter: + return new MassMomentOfInertia(_value/1e3, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -957,7 +985,8 @@ private double AsBaseNumericType(MassMomentOfInertiaUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/MolarEnergy.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarEnergy.NetFramework.g.cs index a1e0c9befd..a7ef49358d 100644 --- a/UnitsNet/GeneratedCode/Quantities/MolarEnergy.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MolarEnergy.NetFramework.g.cs @@ -565,13 +565,16 @@ public MolarEnergy ToUnit(MolarEnergyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal MolarEnergy AsBaseUnit() { switch(Unit) { - case MolarEnergyUnit.JoulePerMole: return _value; - case MolarEnergyUnit.KilojoulePerMole: return (_value) * 1e3d; - case MolarEnergyUnit.MegajoulePerMole: return (_value) * 1e6d; + case MolarEnergyUnit.JoulePerMole: + return new MolarEnergy(_value, BaseUnit); + case MolarEnergyUnit.KilojoulePerMole: + return new MolarEnergy((_value) * 1e3d, BaseUnit); + case MolarEnergyUnit.MegajoulePerMole: + return new MolarEnergy((_value) * 1e6d, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -582,7 +585,8 @@ private double AsBaseNumericType(MolarEnergyUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/MolarEntropy.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarEntropy.NetFramework.g.cs index 807f2ef8b4..71b26c6201 100644 --- a/UnitsNet/GeneratedCode/Quantities/MolarEntropy.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MolarEntropy.NetFramework.g.cs @@ -565,13 +565,16 @@ public MolarEntropy ToUnit(MolarEntropyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal MolarEntropy AsBaseUnit() { switch(Unit) { - case MolarEntropyUnit.JoulePerMoleKelvin: return _value; - case MolarEntropyUnit.KilojoulePerMoleKelvin: return (_value) * 1e3d; - case MolarEntropyUnit.MegajoulePerMoleKelvin: return (_value) * 1e6d; + case MolarEntropyUnit.JoulePerMoleKelvin: + return new MolarEntropy(_value, BaseUnit); + case MolarEntropyUnit.KilojoulePerMoleKelvin: + return new MolarEntropy((_value) * 1e3d, BaseUnit); + case MolarEntropyUnit.MegajoulePerMoleKelvin: + return new MolarEntropy((_value) * 1e6d, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -582,7 +585,8 @@ private double AsBaseNumericType(MolarEntropyUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/MolarMass.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarMass.NetFramework.g.cs index a9ac972482..79cb6b382c 100644 --- a/UnitsNet/GeneratedCode/Quantities/MolarMass.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MolarMass.NetFramework.g.cs @@ -691,22 +691,34 @@ public MolarMass ToUnit(MolarMassUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal MolarMass AsBaseUnit() { switch(Unit) { - case MolarMassUnit.CentigramPerMole: return (_value/1e3) * 1e-2d; - case MolarMassUnit.DecagramPerMole: return (_value/1e3) * 1e1d; - case MolarMassUnit.DecigramPerMole: return (_value/1e3) * 1e-1d; - case MolarMassUnit.GramPerMole: return _value/1e3; - case MolarMassUnit.HectogramPerMole: return (_value/1e3) * 1e2d; - case MolarMassUnit.KilogramPerMole: return (_value/1e3) * 1e3d; - case MolarMassUnit.KilopoundPerMole: return (_value*0.45359237) * 1e3d; - case MolarMassUnit.MegapoundPerMole: return (_value*0.45359237) * 1e6d; - case MolarMassUnit.MicrogramPerMole: return (_value/1e3) * 1e-6d; - case MolarMassUnit.MilligramPerMole: return (_value/1e3) * 1e-3d; - case MolarMassUnit.NanogramPerMole: return (_value/1e3) * 1e-9d; - case MolarMassUnit.PoundPerMole: return _value*0.45359237; + case MolarMassUnit.CentigramPerMole: + return new MolarMass((_value/1e3) * 1e-2d, BaseUnit); + case MolarMassUnit.DecagramPerMole: + return new MolarMass((_value/1e3) * 1e1d, BaseUnit); + case MolarMassUnit.DecigramPerMole: + return new MolarMass((_value/1e3) * 1e-1d, BaseUnit); + case MolarMassUnit.GramPerMole: + return new MolarMass(_value/1e3, BaseUnit); + case MolarMassUnit.HectogramPerMole: + return new MolarMass((_value/1e3) * 1e2d, BaseUnit); + case MolarMassUnit.KilogramPerMole: + return new MolarMass((_value/1e3) * 1e3d, BaseUnit); + case MolarMassUnit.KilopoundPerMole: + return new MolarMass((_value*0.45359237) * 1e3d, BaseUnit); + case MolarMassUnit.MegapoundPerMole: + return new MolarMass((_value*0.45359237) * 1e6d, BaseUnit); + case MolarMassUnit.MicrogramPerMole: + return new MolarMass((_value/1e3) * 1e-6d, BaseUnit); + case MolarMassUnit.MilligramPerMole: + return new MolarMass((_value/1e3) * 1e-3d, BaseUnit); + case MolarMassUnit.NanogramPerMole: + return new MolarMass((_value/1e3) * 1e-9d, BaseUnit); + case MolarMassUnit.PoundPerMole: + return new MolarMass(_value*0.45359237, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -717,7 +729,8 @@ private double AsBaseNumericType(MolarMassUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Molarity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Molarity.NetFramework.g.cs index c3bb500b58..f9c834028e 100644 --- a/UnitsNet/GeneratedCode/Quantities/Molarity.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Molarity.NetFramework.g.cs @@ -638,18 +638,26 @@ public Molarity ToUnit(MolarityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Molarity AsBaseUnit() { switch(Unit) { - case MolarityUnit.CentimolesPerLiter: return (_value/1e-3) * 1e-2d; - case MolarityUnit.DecimolesPerLiter: return (_value/1e-3) * 1e-1d; - case MolarityUnit.MicromolesPerLiter: return (_value/1e-3) * 1e-6d; - case MolarityUnit.MillimolesPerLiter: return (_value/1e-3) * 1e-3d; - case MolarityUnit.MolesPerCubicMeter: return _value; - case MolarityUnit.MolesPerLiter: return _value/1e-3; - case MolarityUnit.NanomolesPerLiter: return (_value/1e-3) * 1e-9d; - case MolarityUnit.PicomolesPerLiter: return (_value/1e-3) * 1e-12d; + case MolarityUnit.CentimolesPerLiter: + return new Molarity((_value/1e-3) * 1e-2d, BaseUnit); + case MolarityUnit.DecimolesPerLiter: + return new Molarity((_value/1e-3) * 1e-1d, BaseUnit); + case MolarityUnit.MicromolesPerLiter: + return new Molarity((_value/1e-3) * 1e-6d, BaseUnit); + case MolarityUnit.MillimolesPerLiter: + return new Molarity((_value/1e-3) * 1e-3d, BaseUnit); + case MolarityUnit.MolesPerCubicMeter: + return new Molarity(_value, BaseUnit); + case MolarityUnit.MolesPerLiter: + return new Molarity(_value/1e-3, BaseUnit); + case MolarityUnit.NanomolesPerLiter: + return new Molarity((_value/1e-3) * 1e-9d, BaseUnit); + case MolarityUnit.PicomolesPerLiter: + return new Molarity((_value/1e-3) * 1e-12d, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -660,7 +668,8 @@ private double AsBaseNumericType(MolarityUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Permeability.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Permeability.NetFramework.g.cs index c837854442..1137cb4036 100644 --- a/UnitsNet/GeneratedCode/Quantities/Permeability.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Permeability.NetFramework.g.cs @@ -540,11 +540,12 @@ public Permeability ToUnit(PermeabilityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Permeability AsBaseUnit() { switch(Unit) { - case PermeabilityUnit.HenryPerMeter: return _value; + case PermeabilityUnit.HenryPerMeter: + return new Permeability(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -555,7 +556,8 @@ private double AsBaseNumericType(PermeabilityUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Permittivity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Permittivity.NetFramework.g.cs index 0135c92d4c..a361542ba9 100644 --- a/UnitsNet/GeneratedCode/Quantities/Permittivity.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Permittivity.NetFramework.g.cs @@ -540,11 +540,12 @@ public Permittivity ToUnit(PermittivityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Permittivity AsBaseUnit() { switch(Unit) { - case PermittivityUnit.FaradPerMeter: return _value; + case PermittivityUnit.FaradPerMeter: + return new Permittivity(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -555,7 +556,8 @@ private double AsBaseNumericType(PermittivityUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Power.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Power.NetFramework.g.cs index 5af1aba2d9..feecc630c3 100644 --- a/UnitsNet/GeneratedCode/Quantities/Power.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Power.NetFramework.g.cs @@ -803,30 +803,50 @@ public Power ToUnit(PowerUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private decimal AsBaseUnit() + internal Power AsBaseUnit() { switch(Unit) { - case PowerUnit.BoilerHorsepower: return _value*9812.5m; - case PowerUnit.BritishThermalUnitPerHour: return _value*0.293071m; - case PowerUnit.Decawatt: return (_value) * 1e1m; - case PowerUnit.Deciwatt: return (_value) * 1e-1m; - case PowerUnit.ElectricalHorsepower: return _value*746m; - case PowerUnit.Femtowatt: return (_value) * 1e-15m; - case PowerUnit.Gigawatt: return (_value) * 1e9m; - case PowerUnit.HydraulicHorsepower: return _value*745.69988145m; - case PowerUnit.KilobritishThermalUnitPerHour: return (_value*0.293071m) * 1e3m; - case PowerUnit.Kilowatt: return (_value) * 1e3m; - case PowerUnit.MechanicalHorsepower: return _value*745.69m; - case PowerUnit.Megawatt: return (_value) * 1e6m; - case PowerUnit.MetricHorsepower: return _value*735.49875m; - case PowerUnit.Microwatt: return (_value) * 1e-6m; - case PowerUnit.Milliwatt: return (_value) * 1e-3m; - case PowerUnit.Nanowatt: return (_value) * 1e-9m; - case PowerUnit.Petawatt: return (_value) * 1e15m; - case PowerUnit.Picowatt: return (_value) * 1e-12m; - case PowerUnit.Terawatt: return (_value) * 1e12m; - case PowerUnit.Watt: return _value; + case PowerUnit.BoilerHorsepower: + return new Power(_value*9812.5m, BaseUnit); + case PowerUnit.BritishThermalUnitPerHour: + return new Power(_value*0.293071m, BaseUnit); + case PowerUnit.Decawatt: + return new Power((_value) * 1e1m, BaseUnit); + case PowerUnit.Deciwatt: + return new Power((_value) * 1e-1m, BaseUnit); + case PowerUnit.ElectricalHorsepower: + return new Power(_value*746m, BaseUnit); + case PowerUnit.Femtowatt: + return new Power((_value) * 1e-15m, BaseUnit); + case PowerUnit.Gigawatt: + return new Power((_value) * 1e9m, BaseUnit); + case PowerUnit.HydraulicHorsepower: + return new Power(_value*745.69988145m, BaseUnit); + case PowerUnit.KilobritishThermalUnitPerHour: + return new Power((_value*0.293071m) * 1e3m, BaseUnit); + case PowerUnit.Kilowatt: + return new Power((_value) * 1e3m, BaseUnit); + case PowerUnit.MechanicalHorsepower: + return new Power(_value*745.69m, BaseUnit); + case PowerUnit.Megawatt: + return new Power((_value) * 1e6m, BaseUnit); + case PowerUnit.MetricHorsepower: + return new Power(_value*735.49875m, BaseUnit); + case PowerUnit.Microwatt: + return new Power((_value) * 1e-6m, BaseUnit); + case PowerUnit.Milliwatt: + return new Power((_value) * 1e-3m, BaseUnit); + case PowerUnit.Nanowatt: + return new Power((_value) * 1e-9m, BaseUnit); + case PowerUnit.Petawatt: + return new Power((_value) * 1e15m, BaseUnit); + case PowerUnit.Picowatt: + return new Power((_value) * 1e-12m, BaseUnit); + case PowerUnit.Terawatt: + return new Power((_value) * 1e12m, BaseUnit); + case PowerUnit.Watt: + return new Power(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -837,7 +857,8 @@ private decimal AsBaseNumericType(PowerUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/PowerDensity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/PowerDensity.NetFramework.g.cs index 0561b93c66..87f715d862 100644 --- a/UnitsNet/GeneratedCode/Quantities/PowerDensity.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/PowerDensity.NetFramework.g.cs @@ -1139,54 +1139,98 @@ public PowerDensity ToUnit(PowerDensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal PowerDensity AsBaseUnit() { switch(Unit) { - case PowerDensityUnit.DecawattPerCubicFoot: return (_value*3.531466672148859e1) * 1e1d; - case PowerDensityUnit.DecawattPerCubicInch: return (_value*6.102374409473228e4) * 1e1d; - case PowerDensityUnit.DecawattPerCubicMeter: return (_value) * 1e1d; - case PowerDensityUnit.DecawattPerLiter: return (_value*1.0e3) * 1e1d; - case PowerDensityUnit.DeciwattPerCubicFoot: return (_value*3.531466672148859e1) * 1e-1d; - case PowerDensityUnit.DeciwattPerCubicInch: return (_value*6.102374409473228e4) * 1e-1d; - case PowerDensityUnit.DeciwattPerCubicMeter: return (_value) * 1e-1d; - case PowerDensityUnit.DeciwattPerLiter: return (_value*1.0e3) * 1e-1d; - case PowerDensityUnit.GigawattPerCubicFoot: return (_value*3.531466672148859e1) * 1e9d; - case PowerDensityUnit.GigawattPerCubicInch: return (_value*6.102374409473228e4) * 1e9d; - case PowerDensityUnit.GigawattPerCubicMeter: return (_value) * 1e9d; - case PowerDensityUnit.GigawattPerLiter: return (_value*1.0e3) * 1e9d; - case PowerDensityUnit.KilowattPerCubicFoot: return (_value*3.531466672148859e1) * 1e3d; - case PowerDensityUnit.KilowattPerCubicInch: return (_value*6.102374409473228e4) * 1e3d; - case PowerDensityUnit.KilowattPerCubicMeter: return (_value) * 1e3d; - case PowerDensityUnit.KilowattPerLiter: return (_value*1.0e3) * 1e3d; - case PowerDensityUnit.MegawattPerCubicFoot: return (_value*3.531466672148859e1) * 1e6d; - case PowerDensityUnit.MegawattPerCubicInch: return (_value*6.102374409473228e4) * 1e6d; - case PowerDensityUnit.MegawattPerCubicMeter: return (_value) * 1e6d; - case PowerDensityUnit.MegawattPerLiter: return (_value*1.0e3) * 1e6d; - case PowerDensityUnit.MicrowattPerCubicFoot: return (_value*3.531466672148859e1) * 1e-6d; - case PowerDensityUnit.MicrowattPerCubicInch: return (_value*6.102374409473228e4) * 1e-6d; - case PowerDensityUnit.MicrowattPerCubicMeter: return (_value) * 1e-6d; - case PowerDensityUnit.MicrowattPerLiter: return (_value*1.0e3) * 1e-6d; - case PowerDensityUnit.MilliwattPerCubicFoot: return (_value*3.531466672148859e1) * 1e-3d; - case PowerDensityUnit.MilliwattPerCubicInch: return (_value*6.102374409473228e4) * 1e-3d; - case PowerDensityUnit.MilliwattPerCubicMeter: return (_value) * 1e-3d; - case PowerDensityUnit.MilliwattPerLiter: return (_value*1.0e3) * 1e-3d; - case PowerDensityUnit.NanowattPerCubicFoot: return (_value*3.531466672148859e1) * 1e-9d; - case PowerDensityUnit.NanowattPerCubicInch: return (_value*6.102374409473228e4) * 1e-9d; - case PowerDensityUnit.NanowattPerCubicMeter: return (_value) * 1e-9d; - case PowerDensityUnit.NanowattPerLiter: return (_value*1.0e3) * 1e-9d; - case PowerDensityUnit.PicowattPerCubicFoot: return (_value*3.531466672148859e1) * 1e-12d; - case PowerDensityUnit.PicowattPerCubicInch: return (_value*6.102374409473228e4) * 1e-12d; - case PowerDensityUnit.PicowattPerCubicMeter: return (_value) * 1e-12d; - case PowerDensityUnit.PicowattPerLiter: return (_value*1.0e3) * 1e-12d; - case PowerDensityUnit.TerawattPerCubicFoot: return (_value*3.531466672148859e1) * 1e12d; - case PowerDensityUnit.TerawattPerCubicInch: return (_value*6.102374409473228e4) * 1e12d; - case PowerDensityUnit.TerawattPerCubicMeter: return (_value) * 1e12d; - case PowerDensityUnit.TerawattPerLiter: return (_value*1.0e3) * 1e12d; - case PowerDensityUnit.WattPerCubicFoot: return _value*3.531466672148859e1; - case PowerDensityUnit.WattPerCubicInch: return _value*6.102374409473228e4; - case PowerDensityUnit.WattPerCubicMeter: return _value; - case PowerDensityUnit.WattPerLiter: return _value*1.0e3; + case PowerDensityUnit.DecawattPerCubicFoot: + return new PowerDensity((_value*3.531466672148859e1) * 1e1d, BaseUnit); + case PowerDensityUnit.DecawattPerCubicInch: + return new PowerDensity((_value*6.102374409473228e4) * 1e1d, BaseUnit); + case PowerDensityUnit.DecawattPerCubicMeter: + return new PowerDensity((_value) * 1e1d, BaseUnit); + case PowerDensityUnit.DecawattPerLiter: + return new PowerDensity((_value*1.0e3) * 1e1d, BaseUnit); + case PowerDensityUnit.DeciwattPerCubicFoot: + return new PowerDensity((_value*3.531466672148859e1) * 1e-1d, BaseUnit); + case PowerDensityUnit.DeciwattPerCubicInch: + return new PowerDensity((_value*6.102374409473228e4) * 1e-1d, BaseUnit); + case PowerDensityUnit.DeciwattPerCubicMeter: + return new PowerDensity((_value) * 1e-1d, BaseUnit); + case PowerDensityUnit.DeciwattPerLiter: + return new PowerDensity((_value*1.0e3) * 1e-1d, BaseUnit); + case PowerDensityUnit.GigawattPerCubicFoot: + return new PowerDensity((_value*3.531466672148859e1) * 1e9d, BaseUnit); + case PowerDensityUnit.GigawattPerCubicInch: + return new PowerDensity((_value*6.102374409473228e4) * 1e9d, BaseUnit); + case PowerDensityUnit.GigawattPerCubicMeter: + return new PowerDensity((_value) * 1e9d, BaseUnit); + case PowerDensityUnit.GigawattPerLiter: + return new PowerDensity((_value*1.0e3) * 1e9d, BaseUnit); + case PowerDensityUnit.KilowattPerCubicFoot: + return new PowerDensity((_value*3.531466672148859e1) * 1e3d, BaseUnit); + case PowerDensityUnit.KilowattPerCubicInch: + return new PowerDensity((_value*6.102374409473228e4) * 1e3d, BaseUnit); + case PowerDensityUnit.KilowattPerCubicMeter: + return new PowerDensity((_value) * 1e3d, BaseUnit); + case PowerDensityUnit.KilowattPerLiter: + return new PowerDensity((_value*1.0e3) * 1e3d, BaseUnit); + case PowerDensityUnit.MegawattPerCubicFoot: + return new PowerDensity((_value*3.531466672148859e1) * 1e6d, BaseUnit); + case PowerDensityUnit.MegawattPerCubicInch: + return new PowerDensity((_value*6.102374409473228e4) * 1e6d, BaseUnit); + case PowerDensityUnit.MegawattPerCubicMeter: + return new PowerDensity((_value) * 1e6d, BaseUnit); + case PowerDensityUnit.MegawattPerLiter: + return new PowerDensity((_value*1.0e3) * 1e6d, BaseUnit); + case PowerDensityUnit.MicrowattPerCubicFoot: + return new PowerDensity((_value*3.531466672148859e1) * 1e-6d, BaseUnit); + case PowerDensityUnit.MicrowattPerCubicInch: + return new PowerDensity((_value*6.102374409473228e4) * 1e-6d, BaseUnit); + case PowerDensityUnit.MicrowattPerCubicMeter: + return new PowerDensity((_value) * 1e-6d, BaseUnit); + case PowerDensityUnit.MicrowattPerLiter: + return new PowerDensity((_value*1.0e3) * 1e-6d, BaseUnit); + case PowerDensityUnit.MilliwattPerCubicFoot: + return new PowerDensity((_value*3.531466672148859e1) * 1e-3d, BaseUnit); + case PowerDensityUnit.MilliwattPerCubicInch: + return new PowerDensity((_value*6.102374409473228e4) * 1e-3d, BaseUnit); + case PowerDensityUnit.MilliwattPerCubicMeter: + return new PowerDensity((_value) * 1e-3d, BaseUnit); + case PowerDensityUnit.MilliwattPerLiter: + return new PowerDensity((_value*1.0e3) * 1e-3d, BaseUnit); + case PowerDensityUnit.NanowattPerCubicFoot: + return new PowerDensity((_value*3.531466672148859e1) * 1e-9d, BaseUnit); + case PowerDensityUnit.NanowattPerCubicInch: + return new PowerDensity((_value*6.102374409473228e4) * 1e-9d, BaseUnit); + case PowerDensityUnit.NanowattPerCubicMeter: + return new PowerDensity((_value) * 1e-9d, BaseUnit); + case PowerDensityUnit.NanowattPerLiter: + return new PowerDensity((_value*1.0e3) * 1e-9d, BaseUnit); + case PowerDensityUnit.PicowattPerCubicFoot: + return new PowerDensity((_value*3.531466672148859e1) * 1e-12d, BaseUnit); + case PowerDensityUnit.PicowattPerCubicInch: + return new PowerDensity((_value*6.102374409473228e4) * 1e-12d, BaseUnit); + case PowerDensityUnit.PicowattPerCubicMeter: + return new PowerDensity((_value) * 1e-12d, BaseUnit); + case PowerDensityUnit.PicowattPerLiter: + return new PowerDensity((_value*1.0e3) * 1e-12d, BaseUnit); + case PowerDensityUnit.TerawattPerCubicFoot: + return new PowerDensity((_value*3.531466672148859e1) * 1e12d, BaseUnit); + case PowerDensityUnit.TerawattPerCubicInch: + return new PowerDensity((_value*6.102374409473228e4) * 1e12d, BaseUnit); + case PowerDensityUnit.TerawattPerCubicMeter: + return new PowerDensity((_value) * 1e12d, BaseUnit); + case PowerDensityUnit.TerawattPerLiter: + return new PowerDensity((_value*1.0e3) * 1e12d, BaseUnit); + case PowerDensityUnit.WattPerCubicFoot: + return new PowerDensity(_value*3.531466672148859e1, BaseUnit); + case PowerDensityUnit.WattPerCubicInch: + return new PowerDensity(_value*6.102374409473228e4, BaseUnit); + case PowerDensityUnit.WattPerCubicMeter: + return new PowerDensity(_value, BaseUnit); + case PowerDensityUnit.WattPerLiter: + return new PowerDensity(_value*1.0e3, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -1197,7 +1241,8 @@ private double AsBaseNumericType(PowerDensityUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/PowerRatio.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/PowerRatio.NetFramework.g.cs index 3173544500..16386a24a2 100644 --- a/UnitsNet/GeneratedCode/Quantities/PowerRatio.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/PowerRatio.NetFramework.g.cs @@ -559,12 +559,14 @@ public PowerRatio ToUnit(PowerRatioUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal PowerRatio AsBaseUnit() { switch(Unit) { - case PowerRatioUnit.DecibelMilliwatt: return _value - 30; - case PowerRatioUnit.DecibelWatt: return _value; + case PowerRatioUnit.DecibelMilliwatt: + return new PowerRatio(_value - 30, BaseUnit); + case PowerRatioUnit.DecibelWatt: + return new PowerRatio(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -575,7 +577,8 @@ private double AsBaseNumericType(PowerRatioUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Pressure.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Pressure.NetFramework.g.cs index 6f3c83bb1b..503c39a007 100644 --- a/UnitsNet/GeneratedCode/Quantities/Pressure.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Pressure.NetFramework.g.cs @@ -1111,52 +1111,94 @@ public Pressure ToUnit(PressureUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Pressure AsBaseUnit() { switch(Unit) { - case PressureUnit.Atmosphere: return _value*1.01325*1e5; - case PressureUnit.Bar: return _value*1e5; - case PressureUnit.Centibar: return (_value*1e5) * 1e-2d; - case PressureUnit.Decapascal: return (_value) * 1e1d; - case PressureUnit.Decibar: return (_value*1e5) * 1e-1d; - case PressureUnit.DynePerSquareCentimeter: return _value*1.0e-1; - case PressureUnit.FootOfHead: return _value*2989.0669; - case PressureUnit.Gigapascal: return (_value) * 1e9d; - case PressureUnit.Hectopascal: return (_value) * 1e2d; - case PressureUnit.InchOfMercury: return _value/2.95299830714159e-4; - case PressureUnit.InchOfWaterColumn: return _value*249.08890833333; - case PressureUnit.Kilobar: return (_value*1e5) * 1e3d; - case PressureUnit.KilogramForcePerSquareCentimeter: return _value*9.80665e4; - case PressureUnit.KilogramForcePerSquareMeter: return _value*9.80665019960652; - case PressureUnit.KilogramForcePerSquareMillimeter: return _value*9.80665e6; - case PressureUnit.KilonewtonPerSquareCentimeter: return (_value*1e4) * 1e3d; - case PressureUnit.KilonewtonPerSquareMeter: return (_value) * 1e3d; - case PressureUnit.KilonewtonPerSquareMillimeter: return (_value*1e6) * 1e3d; - case PressureUnit.Kilopascal: return (_value) * 1e3d; - case PressureUnit.KilopoundForcePerSquareFoot: return (_value*4.788025898033584e1) * 1e3d; - case PressureUnit.KilopoundForcePerSquareInch: return (_value*6.894757293168361e3) * 1e3d; - case PressureUnit.Megabar: return (_value*1e5) * 1e6d; - case PressureUnit.MeganewtonPerSquareMeter: return (_value) * 1e6d; - case PressureUnit.Megapascal: return (_value) * 1e6d; - case PressureUnit.MeterOfHead: return _value*9804.139432; - case PressureUnit.Microbar: return (_value*1e5) * 1e-6d; - case PressureUnit.Micropascal: return (_value) * 1e-6d; - case PressureUnit.Millibar: return (_value*1e5) * 1e-3d; - case PressureUnit.MillimeterOfMercury: return _value/7.50061561302643e-3; - case PressureUnit.Millipascal: return (_value) * 1e-3d; - case PressureUnit.NewtonPerSquareCentimeter: return _value*1e4; - case PressureUnit.NewtonPerSquareMeter: return _value; - case PressureUnit.NewtonPerSquareMillimeter: return _value*1e6; - case PressureUnit.Pascal: return _value; - case PressureUnit.PoundForcePerSquareFoot: return _value*4.788025898033584e1; - case PressureUnit.PoundForcePerSquareInch: return _value*6.894757293168361e3; - case PressureUnit.PoundPerInchSecondSquared: return _value*1.785796732283465e1; - case PressureUnit.TechnicalAtmosphere: return _value*9.80680592331*1e4; - case PressureUnit.TonneForcePerSquareCentimeter: return _value*9.80665e7; - case PressureUnit.TonneForcePerSquareMeter: return _value*9.80665e3; - case PressureUnit.TonneForcePerSquareMillimeter: return _value*9.80665e9; - case PressureUnit.Torr: return _value*1.3332266752*1e2; + case PressureUnit.Atmosphere: + return new Pressure(_value*1.01325*1e5, BaseUnit); + case PressureUnit.Bar: + return new Pressure(_value*1e5, BaseUnit); + case PressureUnit.Centibar: + return new Pressure((_value*1e5) * 1e-2d, BaseUnit); + case PressureUnit.Decapascal: + return new Pressure((_value) * 1e1d, BaseUnit); + case PressureUnit.Decibar: + return new Pressure((_value*1e5) * 1e-1d, BaseUnit); + case PressureUnit.DynePerSquareCentimeter: + return new Pressure(_value*1.0e-1, BaseUnit); + case PressureUnit.FootOfHead: + return new Pressure(_value*2989.0669, BaseUnit); + case PressureUnit.Gigapascal: + return new Pressure((_value) * 1e9d, BaseUnit); + case PressureUnit.Hectopascal: + return new Pressure((_value) * 1e2d, BaseUnit); + case PressureUnit.InchOfMercury: + return new Pressure(_value/2.95299830714159e-4, BaseUnit); + case PressureUnit.InchOfWaterColumn: + return new Pressure(_value*249.08890833333, BaseUnit); + case PressureUnit.Kilobar: + return new Pressure((_value*1e5) * 1e3d, BaseUnit); + case PressureUnit.KilogramForcePerSquareCentimeter: + return new Pressure(_value*9.80665e4, BaseUnit); + case PressureUnit.KilogramForcePerSquareMeter: + return new Pressure(_value*9.80665019960652, BaseUnit); + case PressureUnit.KilogramForcePerSquareMillimeter: + return new Pressure(_value*9.80665e6, BaseUnit); + case PressureUnit.KilonewtonPerSquareCentimeter: + return new Pressure((_value*1e4) * 1e3d, BaseUnit); + case PressureUnit.KilonewtonPerSquareMeter: + return new Pressure((_value) * 1e3d, BaseUnit); + case PressureUnit.KilonewtonPerSquareMillimeter: + return new Pressure((_value*1e6) * 1e3d, BaseUnit); + case PressureUnit.Kilopascal: + return new Pressure((_value) * 1e3d, BaseUnit); + case PressureUnit.KilopoundForcePerSquareFoot: + return new Pressure((_value*4.788025898033584e1) * 1e3d, BaseUnit); + case PressureUnit.KilopoundForcePerSquareInch: + return new Pressure((_value*6.894757293168361e3) * 1e3d, BaseUnit); + case PressureUnit.Megabar: + return new Pressure((_value*1e5) * 1e6d, BaseUnit); + case PressureUnit.MeganewtonPerSquareMeter: + return new Pressure((_value) * 1e6d, BaseUnit); + case PressureUnit.Megapascal: + return new Pressure((_value) * 1e6d, BaseUnit); + case PressureUnit.MeterOfHead: + return new Pressure(_value*9804.139432, BaseUnit); + case PressureUnit.Microbar: + return new Pressure((_value*1e5) * 1e-6d, BaseUnit); + case PressureUnit.Micropascal: + return new Pressure((_value) * 1e-6d, BaseUnit); + case PressureUnit.Millibar: + return new Pressure((_value*1e5) * 1e-3d, BaseUnit); + case PressureUnit.MillimeterOfMercury: + return new Pressure(_value/7.50061561302643e-3, BaseUnit); + case PressureUnit.Millipascal: + return new Pressure((_value) * 1e-3d, BaseUnit); + case PressureUnit.NewtonPerSquareCentimeter: + return new Pressure(_value*1e4, BaseUnit); + case PressureUnit.NewtonPerSquareMeter: + return new Pressure(_value, BaseUnit); + case PressureUnit.NewtonPerSquareMillimeter: + return new Pressure(_value*1e6, BaseUnit); + case PressureUnit.Pascal: + return new Pressure(_value, BaseUnit); + case PressureUnit.PoundForcePerSquareFoot: + return new Pressure(_value*4.788025898033584e1, BaseUnit); + case PressureUnit.PoundForcePerSquareInch: + return new Pressure(_value*6.894757293168361e3, BaseUnit); + case PressureUnit.PoundPerInchSecondSquared: + return new Pressure(_value*1.785796732283465e1, BaseUnit); + case PressureUnit.TechnicalAtmosphere: + return new Pressure(_value*9.80680592331*1e4, BaseUnit); + case PressureUnit.TonneForcePerSquareCentimeter: + return new Pressure(_value*9.80665e7, BaseUnit); + case PressureUnit.TonneForcePerSquareMeter: + return new Pressure(_value*9.80665e3, BaseUnit); + case PressureUnit.TonneForcePerSquareMillimeter: + return new Pressure(_value*9.80665e9, BaseUnit); + case PressureUnit.Torr: + return new Pressure(_value*1.3332266752*1e2, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -1167,7 +1209,8 @@ private double AsBaseNumericType(PressureUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.NetFramework.g.cs index fa8d86b36f..a238c9964f 100644 --- a/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.NetFramework.g.cs @@ -621,17 +621,24 @@ public PressureChangeRate ToUnit(PressureChangeRateUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal PressureChangeRate AsBaseUnit() { switch(Unit) { - case PressureChangeRateUnit.AtmospherePerSecond: return _value * 1.01325*1e5; - case PressureChangeRateUnit.KilopascalPerMinute: return (_value/60) * 1e3d; - case PressureChangeRateUnit.KilopascalPerSecond: return (_value) * 1e3d; - case PressureChangeRateUnit.MegapascalPerMinute: return (_value/60) * 1e6d; - case PressureChangeRateUnit.MegapascalPerSecond: return (_value) * 1e6d; - case PressureChangeRateUnit.PascalPerMinute: return _value/60; - case PressureChangeRateUnit.PascalPerSecond: return _value; + case PressureChangeRateUnit.AtmospherePerSecond: + return new PressureChangeRate(_value * 1.01325*1e5, BaseUnit); + case PressureChangeRateUnit.KilopascalPerMinute: + return new PressureChangeRate((_value/60) * 1e3d, BaseUnit); + case PressureChangeRateUnit.KilopascalPerSecond: + return new PressureChangeRate((_value) * 1e3d, BaseUnit); + case PressureChangeRateUnit.MegapascalPerMinute: + return new PressureChangeRate((_value/60) * 1e6d, BaseUnit); + case PressureChangeRateUnit.MegapascalPerSecond: + return new PressureChangeRate((_value) * 1e6d, BaseUnit); + case PressureChangeRateUnit.PascalPerMinute: + return new PressureChangeRate(_value/60, BaseUnit); + case PressureChangeRateUnit.PascalPerSecond: + return new PressureChangeRate(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -642,7 +649,8 @@ private double AsBaseNumericType(PressureChangeRateUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Ratio.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Ratio.NetFramework.g.cs index 3162555801..e4c3c35647 100644 --- a/UnitsNet/GeneratedCode/Quantities/Ratio.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Ratio.NetFramework.g.cs @@ -607,16 +607,22 @@ public Ratio ToUnit(RatioUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Ratio AsBaseUnit() { switch(Unit) { - case RatioUnit.DecimalFraction: return _value; - case RatioUnit.PartPerBillion: return _value/1e9; - case RatioUnit.PartPerMillion: return _value/1e6; - case RatioUnit.PartPerThousand: return _value/1e3; - case RatioUnit.PartPerTrillion: return _value/1e12; - case RatioUnit.Percent: return _value/1e2; + case RatioUnit.DecimalFraction: + return new Ratio(_value, BaseUnit); + case RatioUnit.PartPerBillion: + return new Ratio(_value/1e9, BaseUnit); + case RatioUnit.PartPerMillion: + return new Ratio(_value/1e6, BaseUnit); + case RatioUnit.PartPerThousand: + return new Ratio(_value/1e3, BaseUnit); + case RatioUnit.PartPerTrillion: + return new Ratio(_value/1e12, BaseUnit); + case RatioUnit.Percent: + return new Ratio(_value/1e2, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -627,7 +633,8 @@ private double AsBaseNumericType(RatioUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ReactiveEnergy.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ReactiveEnergy.NetFramework.g.cs index 11a5edac93..4767c0ee5d 100644 --- a/UnitsNet/GeneratedCode/Quantities/ReactiveEnergy.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ReactiveEnergy.NetFramework.g.cs @@ -565,13 +565,16 @@ public ReactiveEnergy ToUnit(ReactiveEnergyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ReactiveEnergy AsBaseUnit() { switch(Unit) { - case ReactiveEnergyUnit.KilovoltampereReactiveHour: return (_value) * 1e3d; - case ReactiveEnergyUnit.MegavoltampereReactiveHour: return (_value) * 1e6d; - case ReactiveEnergyUnit.VoltampereReactiveHour: return _value; + case ReactiveEnergyUnit.KilovoltampereReactiveHour: + return new ReactiveEnergy((_value) * 1e3d, BaseUnit); + case ReactiveEnergyUnit.MegavoltampereReactiveHour: + return new ReactiveEnergy((_value) * 1e6d, BaseUnit); + case ReactiveEnergyUnit.VoltampereReactiveHour: + return new ReactiveEnergy(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -582,7 +585,8 @@ private double AsBaseNumericType(ReactiveEnergyUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ReactivePower.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ReactivePower.NetFramework.g.cs index aa09b88dd1..26833d6150 100644 --- a/UnitsNet/GeneratedCode/Quantities/ReactivePower.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ReactivePower.NetFramework.g.cs @@ -579,14 +579,18 @@ public ReactivePower ToUnit(ReactivePowerUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ReactivePower AsBaseUnit() { switch(Unit) { - case ReactivePowerUnit.GigavoltampereReactive: return (_value) * 1e9d; - case ReactivePowerUnit.KilovoltampereReactive: return (_value) * 1e3d; - case ReactivePowerUnit.MegavoltampereReactive: return (_value) * 1e6d; - case ReactivePowerUnit.VoltampereReactive: return _value; + case ReactivePowerUnit.GigavoltampereReactive: + return new ReactivePower((_value) * 1e9d, BaseUnit); + case ReactivePowerUnit.KilovoltampereReactive: + return new ReactivePower((_value) * 1e3d, BaseUnit); + case ReactivePowerUnit.MegavoltampereReactive: + return new ReactivePower((_value) * 1e6d, BaseUnit); + case ReactivePowerUnit.VoltampereReactive: + return new ReactivePower(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -597,7 +601,8 @@ private double AsBaseNumericType(ReactivePowerUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.NetFramework.g.cs index 687e2d4e0e..18dac3c34f 100644 --- a/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.NetFramework.g.cs @@ -565,13 +565,16 @@ public RotationalAcceleration ToUnit(RotationalAccelerationUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal RotationalAcceleration AsBaseUnit() { switch(Unit) { - case RotationalAccelerationUnit.DegreePerSecondSquared: return (Math.PI/180)*_value; - case RotationalAccelerationUnit.RadianPerSecondSquared: return _value; - case RotationalAccelerationUnit.RevolutionPerMinutePerSecond: return ((2*Math.PI)/60)*_value; + case RotationalAccelerationUnit.DegreePerSecondSquared: + return new RotationalAcceleration((Math.PI/180)*_value, BaseUnit); + case RotationalAccelerationUnit.RadianPerSecondSquared: + return new RotationalAcceleration(_value, BaseUnit); + case RotationalAccelerationUnit.RevolutionPerMinutePerSecond: + return new RotationalAcceleration(((2*Math.PI)/60)*_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -582,7 +585,8 @@ private double AsBaseNumericType(RotationalAccelerationUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.NetFramework.g.cs index 9757bcca37..bfa7453284 100644 --- a/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.NetFramework.g.cs @@ -705,23 +705,36 @@ public RotationalSpeed ToUnit(RotationalSpeedUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal RotationalSpeed AsBaseUnit() { switch(Unit) { - case RotationalSpeedUnit.CentiradianPerSecond: return (_value) * 1e-2d; - case RotationalSpeedUnit.DeciradianPerSecond: return (_value) * 1e-1d; - case RotationalSpeedUnit.DegreePerMinute: return (Math.PI/(180*60))*_value; - case RotationalSpeedUnit.DegreePerSecond: return (Math.PI/180)*_value; - case RotationalSpeedUnit.MicrodegreePerSecond: return ((Math.PI/180)*_value) * 1e-6d; - case RotationalSpeedUnit.MicroradianPerSecond: return (_value) * 1e-6d; - case RotationalSpeedUnit.MillidegreePerSecond: return ((Math.PI/180)*_value) * 1e-3d; - case RotationalSpeedUnit.MilliradianPerSecond: return (_value) * 1e-3d; - case RotationalSpeedUnit.NanodegreePerSecond: return ((Math.PI/180)*_value) * 1e-9d; - case RotationalSpeedUnit.NanoradianPerSecond: return (_value) * 1e-9d; - case RotationalSpeedUnit.RadianPerSecond: return _value; - case RotationalSpeedUnit.RevolutionPerMinute: return (_value*6.2831853072)/60; - case RotationalSpeedUnit.RevolutionPerSecond: return _value*6.2831853072; + case RotationalSpeedUnit.CentiradianPerSecond: + return new RotationalSpeed((_value) * 1e-2d, BaseUnit); + case RotationalSpeedUnit.DeciradianPerSecond: + return new RotationalSpeed((_value) * 1e-1d, BaseUnit); + case RotationalSpeedUnit.DegreePerMinute: + return new RotationalSpeed((Math.PI/(180*60))*_value, BaseUnit); + case RotationalSpeedUnit.DegreePerSecond: + return new RotationalSpeed((Math.PI/180)*_value, BaseUnit); + case RotationalSpeedUnit.MicrodegreePerSecond: + return new RotationalSpeed(((Math.PI/180)*_value) * 1e-6d, BaseUnit); + case RotationalSpeedUnit.MicroradianPerSecond: + return new RotationalSpeed((_value) * 1e-6d, BaseUnit); + case RotationalSpeedUnit.MillidegreePerSecond: + return new RotationalSpeed(((Math.PI/180)*_value) * 1e-3d, BaseUnit); + case RotationalSpeedUnit.MilliradianPerSecond: + return new RotationalSpeed((_value) * 1e-3d, BaseUnit); + case RotationalSpeedUnit.NanodegreePerSecond: + return new RotationalSpeed(((Math.PI/180)*_value) * 1e-9d, BaseUnit); + case RotationalSpeedUnit.NanoradianPerSecond: + return new RotationalSpeed((_value) * 1e-9d, BaseUnit); + case RotationalSpeedUnit.RadianPerSecond: + return new RotationalSpeed(_value, BaseUnit); + case RotationalSpeedUnit.RevolutionPerMinute: + return new RotationalSpeed((_value*6.2831853072)/60, BaseUnit); + case RotationalSpeedUnit.RevolutionPerSecond: + return new RotationalSpeed(_value*6.2831853072, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -732,7 +745,8 @@ private double AsBaseNumericType(RotationalSpeedUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.NetFramework.g.cs index 083edb31ff..a0be432bf4 100644 --- a/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.NetFramework.g.cs @@ -565,13 +565,16 @@ public RotationalStiffness ToUnit(RotationalStiffnessUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal RotationalStiffness AsBaseUnit() { switch(Unit) { - case RotationalStiffnessUnit.KilonewtonMeterPerRadian: return (_value) * 1e3d; - case RotationalStiffnessUnit.MeganewtonMeterPerRadian: return (_value) * 1e6d; - case RotationalStiffnessUnit.NewtonMeterPerRadian: return _value; + case RotationalStiffnessUnit.KilonewtonMeterPerRadian: + return new RotationalStiffness((_value) * 1e3d, BaseUnit); + case RotationalStiffnessUnit.MeganewtonMeterPerRadian: + return new RotationalStiffness((_value) * 1e6d, BaseUnit); + case RotationalStiffnessUnit.NewtonMeterPerRadian: + return new RotationalStiffness(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -582,7 +585,8 @@ private double AsBaseNumericType(RotationalStiffnessUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.NetFramework.g.cs index 7c0d807bcc..55cbcb0133 100644 --- a/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.NetFramework.g.cs @@ -565,13 +565,16 @@ public RotationalStiffnessPerLength ToUnit(RotationalStiffnessPerLengthUnit unit /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal RotationalStiffnessPerLength AsBaseUnit() { switch(Unit) { - case RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter: return (_value) * 1e3d; - case RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter: return (_value) * 1e6d; - case RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter: return _value; + case RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter: + return new RotationalStiffnessPerLength((_value) * 1e3d, BaseUnit); + case RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter: + return new RotationalStiffnessPerLength((_value) * 1e6d, BaseUnit); + case RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter: + return new RotationalStiffnessPerLength(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -582,7 +585,8 @@ private double AsBaseNumericType(RotationalStiffnessPerLengthUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/SolidAngle.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/SolidAngle.NetFramework.g.cs index d8f03d8b08..39a07e5e0a 100644 --- a/UnitsNet/GeneratedCode/Quantities/SolidAngle.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/SolidAngle.NetFramework.g.cs @@ -540,11 +540,12 @@ public SolidAngle ToUnit(SolidAngleUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal SolidAngle AsBaseUnit() { switch(Unit) { - case SolidAngleUnit.Steradian: return _value; + case SolidAngleUnit.Steradian: + return new SolidAngle(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -555,7 +556,8 @@ private double AsBaseNumericType(SolidAngleUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.NetFramework.g.cs index 11422766f9..63f468ddec 100644 --- a/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.NetFramework.g.cs @@ -652,19 +652,28 @@ public SpecificEnergy ToUnit(SpecificEnergyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal SpecificEnergy AsBaseUnit() { switch(Unit) { - case SpecificEnergyUnit.BtuPerPound: return _value*2326.000075362; - case SpecificEnergyUnit.CaloriePerGram: return _value*4.184e3; - case SpecificEnergyUnit.JoulePerKilogram: return _value; - case SpecificEnergyUnit.KilocaloriePerGram: return (_value*4.184e3) * 1e3d; - case SpecificEnergyUnit.KilojoulePerKilogram: return (_value) * 1e3d; - case SpecificEnergyUnit.KilowattHourPerKilogram: return (_value*3.6e3) * 1e3d; - case SpecificEnergyUnit.MegajoulePerKilogram: return (_value) * 1e6d; - case SpecificEnergyUnit.MegawattHourPerKilogram: return (_value*3.6e3) * 1e6d; - case SpecificEnergyUnit.WattHourPerKilogram: return _value*3.6e3; + case SpecificEnergyUnit.BtuPerPound: + return new SpecificEnergy(_value*2326.000075362, BaseUnit); + case SpecificEnergyUnit.CaloriePerGram: + return new SpecificEnergy(_value*4.184e3, BaseUnit); + case SpecificEnergyUnit.JoulePerKilogram: + return new SpecificEnergy(_value, BaseUnit); + case SpecificEnergyUnit.KilocaloriePerGram: + return new SpecificEnergy((_value*4.184e3) * 1e3d, BaseUnit); + case SpecificEnergyUnit.KilojoulePerKilogram: + return new SpecificEnergy((_value) * 1e3d, BaseUnit); + case SpecificEnergyUnit.KilowattHourPerKilogram: + return new SpecificEnergy((_value*3.6e3) * 1e3d, BaseUnit); + case SpecificEnergyUnit.MegajoulePerKilogram: + return new SpecificEnergy((_value) * 1e6d, BaseUnit); + case SpecificEnergyUnit.MegawattHourPerKilogram: + return new SpecificEnergy((_value*3.6e3) * 1e6d, BaseUnit); + case SpecificEnergyUnit.WattHourPerKilogram: + return new SpecificEnergy(_value*3.6e3, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -675,7 +684,8 @@ private double AsBaseNumericType(SpecificEnergyUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.NetFramework.g.cs index b91712cb2e..de4a009668 100644 --- a/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.NetFramework.g.cs @@ -635,18 +635,26 @@ public SpecificEntropy ToUnit(SpecificEntropyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal SpecificEntropy AsBaseUnit() { switch(Unit) { - case SpecificEntropyUnit.CaloriePerGramKelvin: return _value*4.184e3; - case SpecificEntropyUnit.JoulePerKilogramDegreeCelsius: return _value; - case SpecificEntropyUnit.JoulePerKilogramKelvin: return _value; - case SpecificEntropyUnit.KilocaloriePerGramKelvin: return (_value*4.184e3) * 1e3d; - case SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius: return (_value) * 1e3d; - case SpecificEntropyUnit.KilojoulePerKilogramKelvin: return (_value) * 1e3d; - case SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius: return (_value) * 1e6d; - case SpecificEntropyUnit.MegajoulePerKilogramKelvin: return (_value) * 1e6d; + case SpecificEntropyUnit.CaloriePerGramKelvin: + return new SpecificEntropy(_value*4.184e3, BaseUnit); + case SpecificEntropyUnit.JoulePerKilogramDegreeCelsius: + return new SpecificEntropy(_value, BaseUnit); + case SpecificEntropyUnit.JoulePerKilogramKelvin: + return new SpecificEntropy(_value, BaseUnit); + case SpecificEntropyUnit.KilocaloriePerGramKelvin: + return new SpecificEntropy((_value*4.184e3) * 1e3d, BaseUnit); + case SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius: + return new SpecificEntropy((_value) * 1e3d, BaseUnit); + case SpecificEntropyUnit.KilojoulePerKilogramKelvin: + return new SpecificEntropy((_value) * 1e3d, BaseUnit); + case SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius: + return new SpecificEntropy((_value) * 1e6d, BaseUnit); + case SpecificEntropyUnit.MegajoulePerKilogramKelvin: + return new SpecificEntropy((_value) * 1e6d, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -657,7 +665,8 @@ private double AsBaseNumericType(SpecificEntropyUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificVolume.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificVolume.NetFramework.g.cs index 8932433b24..08184ebe7b 100644 --- a/UnitsNet/GeneratedCode/Quantities/SpecificVolume.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/SpecificVolume.NetFramework.g.cs @@ -565,13 +565,16 @@ public SpecificVolume ToUnit(SpecificVolumeUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal SpecificVolume AsBaseUnit() { switch(Unit) { - case SpecificVolumeUnit.CubicFootPerPound: return _value/16.01846353; - case SpecificVolumeUnit.CubicMeterPerKilogram: return _value; - case SpecificVolumeUnit.MillicubicMeterPerKilogram: return (_value) * 1e-3d; + case SpecificVolumeUnit.CubicFootPerPound: + return new SpecificVolume(_value/16.01846353, BaseUnit); + case SpecificVolumeUnit.CubicMeterPerKilogram: + return new SpecificVolume(_value, BaseUnit); + case SpecificVolumeUnit.MillicubicMeterPerKilogram: + return new SpecificVolume((_value) * 1e-3d, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -582,7 +585,8 @@ private double AsBaseNumericType(SpecificVolumeUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificWeight.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificWeight.NetFramework.g.cs index ce31c9bb27..ef193664d3 100644 --- a/UnitsNet/GeneratedCode/Quantities/SpecificWeight.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/SpecificWeight.NetFramework.g.cs @@ -764,27 +764,44 @@ public SpecificWeight ToUnit(SpecificWeightUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal SpecificWeight AsBaseUnit() { switch(Unit) { - case SpecificWeightUnit.KilogramForcePerCubicCentimeter: return _value*9.80665e6; - case SpecificWeightUnit.KilogramForcePerCubicMeter: return _value*9.80665; - case SpecificWeightUnit.KilogramForcePerCubicMillimeter: return _value*9.80665e9; - case SpecificWeightUnit.KilonewtonPerCubicCentimeter: return (_value*1000000) * 1e3d; - case SpecificWeightUnit.KilonewtonPerCubicMeter: return (_value) * 1e3d; - case SpecificWeightUnit.KilonewtonPerCubicMillimeter: return (_value*1000000000) * 1e3d; - case SpecificWeightUnit.KilopoundForcePerCubicFoot: return (_value*1.570874638462462e2) * 1e3d; - case SpecificWeightUnit.KilopoundForcePerCubicInch: return (_value*2.714471375263134e5) * 1e3d; - case SpecificWeightUnit.MeganewtonPerCubicMeter: return (_value) * 1e6d; - case SpecificWeightUnit.NewtonPerCubicCentimeter: return _value*1000000; - case SpecificWeightUnit.NewtonPerCubicMeter: return _value; - case SpecificWeightUnit.NewtonPerCubicMillimeter: return _value*1000000000; - case SpecificWeightUnit.PoundForcePerCubicFoot: return _value*1.570874638462462e2; - case SpecificWeightUnit.PoundForcePerCubicInch: return _value*2.714471375263134e5; - case SpecificWeightUnit.TonneForcePerCubicCentimeter: return _value*9.80665e9; - case SpecificWeightUnit.TonneForcePerCubicMeter: return _value*9.80665e3; - case SpecificWeightUnit.TonneForcePerCubicMillimeter: return _value*9.80665e12; + case SpecificWeightUnit.KilogramForcePerCubicCentimeter: + return new SpecificWeight(_value*9.80665e6, BaseUnit); + case SpecificWeightUnit.KilogramForcePerCubicMeter: + return new SpecificWeight(_value*9.80665, BaseUnit); + case SpecificWeightUnit.KilogramForcePerCubicMillimeter: + return new SpecificWeight(_value*9.80665e9, BaseUnit); + case SpecificWeightUnit.KilonewtonPerCubicCentimeter: + return new SpecificWeight((_value*1000000) * 1e3d, BaseUnit); + case SpecificWeightUnit.KilonewtonPerCubicMeter: + return new SpecificWeight((_value) * 1e3d, BaseUnit); + case SpecificWeightUnit.KilonewtonPerCubicMillimeter: + return new SpecificWeight((_value*1000000000) * 1e3d, BaseUnit); + case SpecificWeightUnit.KilopoundForcePerCubicFoot: + return new SpecificWeight((_value*1.570874638462462e2) * 1e3d, BaseUnit); + case SpecificWeightUnit.KilopoundForcePerCubicInch: + return new SpecificWeight((_value*2.714471375263134e5) * 1e3d, BaseUnit); + case SpecificWeightUnit.MeganewtonPerCubicMeter: + return new SpecificWeight((_value) * 1e6d, BaseUnit); + case SpecificWeightUnit.NewtonPerCubicCentimeter: + return new SpecificWeight(_value*1000000, BaseUnit); + case SpecificWeightUnit.NewtonPerCubicMeter: + return new SpecificWeight(_value, BaseUnit); + case SpecificWeightUnit.NewtonPerCubicMillimeter: + return new SpecificWeight(_value*1000000000, BaseUnit); + case SpecificWeightUnit.PoundForcePerCubicFoot: + return new SpecificWeight(_value*1.570874638462462e2, BaseUnit); + case SpecificWeightUnit.PoundForcePerCubicInch: + return new SpecificWeight(_value*2.714471375263134e5, BaseUnit); + case SpecificWeightUnit.TonneForcePerCubicCentimeter: + return new SpecificWeight(_value*9.80665e9, BaseUnit); + case SpecificWeightUnit.TonneForcePerCubicMeter: + return new SpecificWeight(_value*9.80665e3, BaseUnit); + case SpecificWeightUnit.TonneForcePerCubicMillimeter: + return new SpecificWeight(_value*9.80665e12, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -795,7 +812,8 @@ private double AsBaseNumericType(SpecificWeightUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Speed.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Speed.NetFramework.g.cs index a557138fe8..a18e19fcb8 100644 --- a/UnitsNet/GeneratedCode/Quantities/Speed.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Speed.NetFramework.g.cs @@ -971,42 +971,74 @@ public Speed ToUnit(SpeedUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Speed AsBaseUnit() { switch(Unit) { - case SpeedUnit.CentimeterPerHour: return (_value/3600) * 1e-2d; - case SpeedUnit.CentimeterPerMinute: return (_value/60) * 1e-2d; - case SpeedUnit.CentimeterPerSecond: return (_value) * 1e-2d; - case SpeedUnit.DecimeterPerMinute: return (_value/60) * 1e-1d; - case SpeedUnit.DecimeterPerSecond: return (_value) * 1e-1d; - case SpeedUnit.FootPerHour: return _value*0.3048/3600; - case SpeedUnit.FootPerMinute: return _value*0.3048/60; - case SpeedUnit.FootPerSecond: return _value*0.3048; - case SpeedUnit.InchPerHour: return (_value/3600)*2.54e-2; - case SpeedUnit.InchPerMinute: return (_value/60)*2.54e-2; - case SpeedUnit.InchPerSecond: return _value*2.54e-2; - case SpeedUnit.KilometerPerHour: return (_value/3600) * 1e3d; - case SpeedUnit.KilometerPerMinute: return (_value/60) * 1e3d; - case SpeedUnit.KilometerPerSecond: return (_value) * 1e3d; - case SpeedUnit.Knot: return _value*0.514444; - case SpeedUnit.MeterPerHour: return _value/3600; - case SpeedUnit.MeterPerMinute: return _value/60; - case SpeedUnit.MeterPerSecond: return _value; - case SpeedUnit.MicrometerPerMinute: return (_value/60) * 1e-6d; - case SpeedUnit.MicrometerPerSecond: return (_value) * 1e-6d; - case SpeedUnit.MilePerHour: return _value*0.44704; - case SpeedUnit.MillimeterPerHour: return (_value/3600) * 1e-3d; - case SpeedUnit.MillimeterPerMinute: return (_value/60) * 1e-3d; - case SpeedUnit.MillimeterPerSecond: return (_value) * 1e-3d; - case SpeedUnit.NanometerPerMinute: return (_value/60) * 1e-9d; - case SpeedUnit.NanometerPerSecond: return (_value) * 1e-9d; - case SpeedUnit.UsSurveyFootPerHour: return (_value*1200/3937)/3600; - case SpeedUnit.UsSurveyFootPerMinute: return (_value*1200/3937)/60; - case SpeedUnit.UsSurveyFootPerSecond: return _value*1200/3937; - case SpeedUnit.YardPerHour: return _value*0.9144/3600; - case SpeedUnit.YardPerMinute: return _value*0.9144/60; - case SpeedUnit.YardPerSecond: return _value*0.9144; + case SpeedUnit.CentimeterPerHour: + return new Speed((_value/3600) * 1e-2d, BaseUnit); + case SpeedUnit.CentimeterPerMinute: + return new Speed((_value/60) * 1e-2d, BaseUnit); + case SpeedUnit.CentimeterPerSecond: + return new Speed((_value) * 1e-2d, BaseUnit); + case SpeedUnit.DecimeterPerMinute: + return new Speed((_value/60) * 1e-1d, BaseUnit); + case SpeedUnit.DecimeterPerSecond: + return new Speed((_value) * 1e-1d, BaseUnit); + case SpeedUnit.FootPerHour: + return new Speed(_value*0.3048/3600, BaseUnit); + case SpeedUnit.FootPerMinute: + return new Speed(_value*0.3048/60, BaseUnit); + case SpeedUnit.FootPerSecond: + return new Speed(_value*0.3048, BaseUnit); + case SpeedUnit.InchPerHour: + return new Speed((_value/3600)*2.54e-2, BaseUnit); + case SpeedUnit.InchPerMinute: + return new Speed((_value/60)*2.54e-2, BaseUnit); + case SpeedUnit.InchPerSecond: + return new Speed(_value*2.54e-2, BaseUnit); + case SpeedUnit.KilometerPerHour: + return new Speed((_value/3600) * 1e3d, BaseUnit); + case SpeedUnit.KilometerPerMinute: + return new Speed((_value/60) * 1e3d, BaseUnit); + case SpeedUnit.KilometerPerSecond: + return new Speed((_value) * 1e3d, BaseUnit); + case SpeedUnit.Knot: + return new Speed(_value*0.514444, BaseUnit); + case SpeedUnit.MeterPerHour: + return new Speed(_value/3600, BaseUnit); + case SpeedUnit.MeterPerMinute: + return new Speed(_value/60, BaseUnit); + case SpeedUnit.MeterPerSecond: + return new Speed(_value, BaseUnit); + case SpeedUnit.MicrometerPerMinute: + return new Speed((_value/60) * 1e-6d, BaseUnit); + case SpeedUnit.MicrometerPerSecond: + return new Speed((_value) * 1e-6d, BaseUnit); + case SpeedUnit.MilePerHour: + return new Speed(_value*0.44704, BaseUnit); + case SpeedUnit.MillimeterPerHour: + return new Speed((_value/3600) * 1e-3d, BaseUnit); + case SpeedUnit.MillimeterPerMinute: + return new Speed((_value/60) * 1e-3d, BaseUnit); + case SpeedUnit.MillimeterPerSecond: + return new Speed((_value) * 1e-3d, BaseUnit); + case SpeedUnit.NanometerPerMinute: + return new Speed((_value/60) * 1e-9d, BaseUnit); + case SpeedUnit.NanometerPerSecond: + return new Speed((_value) * 1e-9d, BaseUnit); + case SpeedUnit.UsSurveyFootPerHour: + return new Speed((_value*1200/3937)/3600, BaseUnit); + case SpeedUnit.UsSurveyFootPerMinute: + return new Speed((_value*1200/3937)/60, BaseUnit); + case SpeedUnit.UsSurveyFootPerSecond: + return new Speed(_value*1200/3937, BaseUnit); + case SpeedUnit.YardPerHour: + return new Speed(_value*0.9144/3600, BaseUnit); + case SpeedUnit.YardPerMinute: + return new Speed(_value*0.9144/60, BaseUnit); + case SpeedUnit.YardPerSecond: + return new Speed(_value*0.9144, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -1017,7 +1049,8 @@ private double AsBaseNumericType(SpeedUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Temperature.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Temperature.NetFramework.g.cs index 6f4ad8306c..a65075d8f9 100644 --- a/UnitsNet/GeneratedCode/Quantities/Temperature.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Temperature.NetFramework.g.cs @@ -596,18 +596,26 @@ public Temperature ToUnit(TemperatureUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Temperature AsBaseUnit() { switch(Unit) { - case TemperatureUnit.DegreeCelsius: return _value + 273.15; - case TemperatureUnit.DegreeDelisle: return _value*-2/3 + 373.15; - case TemperatureUnit.DegreeFahrenheit: return _value*5/9 + 459.67*5/9; - case TemperatureUnit.DegreeNewton: return _value*100/33 + 273.15; - case TemperatureUnit.DegreeRankine: return _value*5/9; - case TemperatureUnit.DegreeReaumur: return _value*5/4 + 273.15; - case TemperatureUnit.DegreeRoemer: return _value*40/21 + 273.15 - 7.5*40d/21; - case TemperatureUnit.Kelvin: return _value; + case TemperatureUnit.DegreeCelsius: + return new Temperature(_value + 273.15, BaseUnit); + case TemperatureUnit.DegreeDelisle: + return new Temperature(_value*-2/3 + 373.15, BaseUnit); + case TemperatureUnit.DegreeFahrenheit: + return new Temperature(_value*5/9 + 459.67*5/9, BaseUnit); + case TemperatureUnit.DegreeNewton: + return new Temperature(_value*100/33 + 273.15, BaseUnit); + case TemperatureUnit.DegreeRankine: + return new Temperature(_value*5/9, BaseUnit); + case TemperatureUnit.DegreeReaumur: + return new Temperature(_value*5/4 + 273.15, BaseUnit); + case TemperatureUnit.DegreeRoemer: + return new Temperature(_value*40/21 + 273.15 - 7.5*40d/21, BaseUnit); + case TemperatureUnit.Kelvin: + return new Temperature(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -618,7 +626,8 @@ private double AsBaseNumericType(TemperatureUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.NetFramework.g.cs index 40a63cb355..d1b6077e89 100644 --- a/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.NetFramework.g.cs @@ -663,20 +663,30 @@ public TemperatureChangeRate ToUnit(TemperatureChangeRateUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal TemperatureChangeRate AsBaseUnit() { switch(Unit) { - case TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond: return (_value) * 1e-2d; - case TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond: return (_value) * 1e1d; - case TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond: return (_value) * 1e-1d; - case TemperatureChangeRateUnit.DegreeCelsiusPerMinute: return _value/60; - case TemperatureChangeRateUnit.DegreeCelsiusPerSecond: return _value; - case TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond: return (_value) * 1e2d; - case TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond: return (_value) * 1e3d; - case TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond: return (_value) * 1e-6d; - case TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond: return (_value) * 1e-3d; - case TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond: return (_value) * 1e-9d; + case TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond: + return new TemperatureChangeRate((_value) * 1e-2d, BaseUnit); + case TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond: + return new TemperatureChangeRate((_value) * 1e1d, BaseUnit); + case TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond: + return new TemperatureChangeRate((_value) * 1e-1d, BaseUnit); + case TemperatureChangeRateUnit.DegreeCelsiusPerMinute: + return new TemperatureChangeRate(_value/60, BaseUnit); + case TemperatureChangeRateUnit.DegreeCelsiusPerSecond: + return new TemperatureChangeRate(_value, BaseUnit); + case TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond: + return new TemperatureChangeRate((_value) * 1e2d, BaseUnit); + case TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond: + return new TemperatureChangeRate((_value) * 1e3d, BaseUnit); + case TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond: + return new TemperatureChangeRate((_value) * 1e-6d, BaseUnit); + case TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond: + return new TemperatureChangeRate((_value) * 1e-3d, BaseUnit); + case TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond: + return new TemperatureChangeRate((_value) * 1e-9d, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -687,7 +697,8 @@ private double AsBaseNumericType(TemperatureChangeRateUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.NetFramework.g.cs index b30f38b0c6..0606013fce 100644 --- a/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.NetFramework.g.cs @@ -635,18 +635,26 @@ public TemperatureDelta ToUnit(TemperatureDeltaUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal TemperatureDelta AsBaseUnit() { switch(Unit) { - case TemperatureDeltaUnit.DegreeCelsius: return _value; - case TemperatureDeltaUnit.DegreeDelisle: return _value*-2/3; - case TemperatureDeltaUnit.DegreeFahrenheit: return _value*5/9; - case TemperatureDeltaUnit.DegreeNewton: return _value*100/33; - case TemperatureDeltaUnit.DegreeRankine: return _value*5/9; - case TemperatureDeltaUnit.DegreeReaumur: return _value*5/4; - case TemperatureDeltaUnit.DegreeRoemer: return _value*40/21; - case TemperatureDeltaUnit.Kelvin: return _value; + case TemperatureDeltaUnit.DegreeCelsius: + return new TemperatureDelta(_value, BaseUnit); + case TemperatureDeltaUnit.DegreeDelisle: + return new TemperatureDelta(_value*-2/3, BaseUnit); + case TemperatureDeltaUnit.DegreeFahrenheit: + return new TemperatureDelta(_value*5/9, BaseUnit); + case TemperatureDeltaUnit.DegreeNewton: + return new TemperatureDelta(_value*100/33, BaseUnit); + case TemperatureDeltaUnit.DegreeRankine: + return new TemperatureDelta(_value*5/9, BaseUnit); + case TemperatureDeltaUnit.DegreeReaumur: + return new TemperatureDelta(_value*5/4, BaseUnit); + case TemperatureDeltaUnit.DegreeRoemer: + return new TemperatureDelta(_value*40/21, BaseUnit); + case TemperatureDeltaUnit.Kelvin: + return new TemperatureDelta(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -657,7 +665,8 @@ private double AsBaseNumericType(TemperatureDeltaUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.NetFramework.g.cs index 77ee8a8895..e28192aeb3 100644 --- a/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.NetFramework.g.cs @@ -554,12 +554,14 @@ public ThermalConductivity ToUnit(ThermalConductivityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ThermalConductivity AsBaseUnit() { switch(Unit) { - case ThermalConductivityUnit.BtuPerHourFootFahrenheit: return _value*1.73073467; - case ThermalConductivityUnit.WattPerMeterKelvin: return _value; + case ThermalConductivityUnit.BtuPerHourFootFahrenheit: + return new ThermalConductivity(_value*1.73073467, BaseUnit); + case ThermalConductivityUnit.WattPerMeterKelvin: + return new ThermalConductivity(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -570,7 +572,8 @@ private double AsBaseNumericType(ThermalConductivityUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ThermalResistance.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ThermalResistance.NetFramework.g.cs index 1c7fd72572..f8591ee250 100644 --- a/UnitsNet/GeneratedCode/Quantities/ThermalResistance.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ThermalResistance.NetFramework.g.cs @@ -593,15 +593,20 @@ public ThermalResistance ToUnit(ThermalResistanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal ThermalResistance AsBaseUnit() { switch(Unit) { - case ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu: return _value*176.1121482159839; - case ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie: return _value*0.0859779507590433; - case ThermalResistanceUnit.SquareCentimeterKelvinPerWatt: return _value*0.0999964777570357; - case ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt: return _value*1000.088056074108; - case ThermalResistanceUnit.SquareMeterKelvinPerKilowatt: return _value; + case ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu: + return new ThermalResistance(_value*176.1121482159839, BaseUnit); + case ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie: + return new ThermalResistance(_value*0.0859779507590433, BaseUnit); + case ThermalResistanceUnit.SquareCentimeterKelvinPerWatt: + return new ThermalResistance(_value*0.0999964777570357, BaseUnit); + case ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt: + return new ThermalResistance(_value*1000.088056074108, BaseUnit); + case ThermalResistanceUnit.SquareMeterKelvinPerKilowatt: + return new ThermalResistance(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -612,7 +617,8 @@ private double AsBaseNumericType(ThermalResistanceUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Torque.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Torque.NetFramework.g.cs index a73e74b5fc..b317b46ab0 100644 --- a/UnitsNet/GeneratedCode/Quantities/Torque.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Torque.NetFramework.g.cs @@ -817,31 +817,52 @@ public Torque ToUnit(TorqueUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Torque AsBaseUnit() { switch(Unit) { - case TorqueUnit.KilogramForceCentimeter: return _value*0.0980665019960652; - case TorqueUnit.KilogramForceMeter: return _value*9.80665019960652; - case TorqueUnit.KilogramForceMillimeter: return _value*0.00980665019960652; - case TorqueUnit.KilonewtonCentimeter: return (_value*0.01) * 1e3d; - case TorqueUnit.KilonewtonMeter: return (_value) * 1e3d; - case TorqueUnit.KilonewtonMillimeter: return (_value*0.001) * 1e3d; - case TorqueUnit.KilopoundForceFoot: return (_value*1.3558179483314) * 1e3d; - case TorqueUnit.KilopoundForceInch: return (_value*1.129848290276167e-1) * 1e3d; - case TorqueUnit.MeganewtonCentimeter: return (_value*0.01) * 1e6d; - case TorqueUnit.MeganewtonMeter: return (_value) * 1e6d; - case TorqueUnit.MeganewtonMillimeter: return (_value*0.001) * 1e6d; - case TorqueUnit.MegapoundForceFoot: return (_value*1.3558179483314) * 1e6d; - case TorqueUnit.MegapoundForceInch: return (_value*1.129848290276167e-1) * 1e6d; - case TorqueUnit.NewtonCentimeter: return _value*0.01; - case TorqueUnit.NewtonMeter: return _value; - case TorqueUnit.NewtonMillimeter: return _value*0.001; - case TorqueUnit.PoundForceFoot: return _value*1.3558179483314; - case TorqueUnit.PoundForceInch: return _value*1.129848290276167e-1; - case TorqueUnit.TonneForceCentimeter: return _value*98.0665019960652; - case TorqueUnit.TonneForceMeter: return _value*9806.65019960653; - case TorqueUnit.TonneForceMillimeter: return _value*9.80665019960652; + case TorqueUnit.KilogramForceCentimeter: + return new Torque(_value*0.0980665019960652, BaseUnit); + case TorqueUnit.KilogramForceMeter: + return new Torque(_value*9.80665019960652, BaseUnit); + case TorqueUnit.KilogramForceMillimeter: + return new Torque(_value*0.00980665019960652, BaseUnit); + case TorqueUnit.KilonewtonCentimeter: + return new Torque((_value*0.01) * 1e3d, BaseUnit); + case TorqueUnit.KilonewtonMeter: + return new Torque((_value) * 1e3d, BaseUnit); + case TorqueUnit.KilonewtonMillimeter: + return new Torque((_value*0.001) * 1e3d, BaseUnit); + case TorqueUnit.KilopoundForceFoot: + return new Torque((_value*1.3558179483314) * 1e3d, BaseUnit); + case TorqueUnit.KilopoundForceInch: + return new Torque((_value*1.129848290276167e-1) * 1e3d, BaseUnit); + case TorqueUnit.MeganewtonCentimeter: + return new Torque((_value*0.01) * 1e6d, BaseUnit); + case TorqueUnit.MeganewtonMeter: + return new Torque((_value) * 1e6d, BaseUnit); + case TorqueUnit.MeganewtonMillimeter: + return new Torque((_value*0.001) * 1e6d, BaseUnit); + case TorqueUnit.MegapoundForceFoot: + return new Torque((_value*1.3558179483314) * 1e6d, BaseUnit); + case TorqueUnit.MegapoundForceInch: + return new Torque((_value*1.129848290276167e-1) * 1e6d, BaseUnit); + case TorqueUnit.NewtonCentimeter: + return new Torque(_value*0.01, BaseUnit); + case TorqueUnit.NewtonMeter: + return new Torque(_value, BaseUnit); + case TorqueUnit.NewtonMillimeter: + return new Torque(_value*0.001, BaseUnit); + case TorqueUnit.PoundForceFoot: + return new Torque(_value*1.3558179483314, BaseUnit); + case TorqueUnit.PoundForceInch: + return new Torque(_value*1.129848290276167e-1, BaseUnit); + case TorqueUnit.TonneForceCentimeter: + return new Torque(_value*98.0665019960652, BaseUnit); + case TorqueUnit.TonneForceMeter: + return new Torque(_value*9806.65019960653, BaseUnit); + case TorqueUnit.TonneForceMillimeter: + return new Torque(_value*9.80665019960652, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -852,7 +873,8 @@ private double AsBaseNumericType(TorqueUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/VitaminA.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/VitaminA.NetFramework.g.cs index e27bca2e83..7283b0e7c2 100644 --- a/UnitsNet/GeneratedCode/Quantities/VitaminA.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/VitaminA.NetFramework.g.cs @@ -537,11 +537,12 @@ public VitaminA ToUnit(VitaminAUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal VitaminA AsBaseUnit() { switch(Unit) { - case VitaminAUnit.InternationalUnit: return _value; + case VitaminAUnit.InternationalUnit: + return new VitaminA(_value, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -552,7 +553,8 @@ private double AsBaseNumericType(VitaminAUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Volume.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Volume.NetFramework.g.cs index d15b9e90f2..922e4ca8fa 100644 --- a/UnitsNet/GeneratedCode/Quantities/Volume.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Volume.NetFramework.g.cs @@ -1153,55 +1153,100 @@ public Volume ToUnit(VolumeUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal Volume AsBaseUnit() { switch(Unit) { - case VolumeUnit.AcreFoot: return _value/0.000810714; - case VolumeUnit.AuTablespoon: return _value*2e-5; - case VolumeUnit.Centiliter: return (_value/1e3) * 1e-2d; - case VolumeUnit.CubicCentimeter: return _value/1e6; - case VolumeUnit.CubicDecimeter: return _value/1e3; - case VolumeUnit.CubicFoot: return _value*0.0283168; - case VolumeUnit.CubicInch: return _value*1.6387*1e-5; - case VolumeUnit.CubicKilometer: return _value*1e9; - case VolumeUnit.CubicMeter: return _value; - case VolumeUnit.CubicMicrometer: return _value/1e18; - case VolumeUnit.CubicMile: return _value*4.16818182544058e9; - case VolumeUnit.CubicMillimeter: return _value/1e9; - case VolumeUnit.CubicYard: return _value*0.764554858; - case VolumeUnit.Deciliter: return (_value/1e3) * 1e-1d; - case VolumeUnit.HectocubicFoot: return (_value*0.0283168) * 1e2d; - case VolumeUnit.HectocubicMeter: return (_value) * 1e2d; - case VolumeUnit.Hectoliter: return (_value/1e3) * 1e2d; - case VolumeUnit.ImperialBeerBarrel: return _value*0.16365924; - case VolumeUnit.ImperialGallon: return _value*0.00454609000000181429905810072407; - case VolumeUnit.ImperialOunce: return _value*2.8413062499962901241875439064617e-5; - case VolumeUnit.KilocubicFoot: return (_value*0.0283168) * 1e3d; - case VolumeUnit.KilocubicMeter: return (_value) * 1e3d; - case VolumeUnit.KiloimperialGallon: return (_value*0.00454609000000181429905810072407) * 1e3d; - case VolumeUnit.Kiloliter: return (_value/1e3) * 1e3d; - case VolumeUnit.KilousGallon: return (_value*0.00378541) * 1e3d; - case VolumeUnit.Liter: return _value/1e3; - case VolumeUnit.MegacubicFoot: return (_value*0.0283168) * 1e6d; - case VolumeUnit.MegaimperialGallon: return (_value*0.00454609000000181429905810072407) * 1e6d; - case VolumeUnit.Megaliter: return (_value/1e3) * 1e6d; - case VolumeUnit.MegausGallon: return (_value*0.00378541) * 1e6d; - case VolumeUnit.MetricCup: return _value*0.00025; - case VolumeUnit.MetricTeaspoon: return _value*0.5e-5; - case VolumeUnit.Microliter: return (_value/1e3) * 1e-6d; - case VolumeUnit.Milliliter: return (_value/1e3) * 1e-3d; - case VolumeUnit.OilBarrel: return _value*0.158987294928; - case VolumeUnit.UkTablespoon: return _value*1.5e-5; - case VolumeUnit.UsBeerBarrel: return _value*0.1173477658; - case VolumeUnit.UsCustomaryCup: return _value*0.0002365882365; - case VolumeUnit.UsGallon: return _value*0.00378541; - case VolumeUnit.UsLegalCup: return _value*0.00024; - case VolumeUnit.UsOunce: return _value*2.957352956253760505068307980135e-5; - case VolumeUnit.UsPint: return _value*4.73176473e-4; - case VolumeUnit.UsQuart: return _value*9.46352946e-4; - case VolumeUnit.UsTablespoon: return _value*1.478676478125e-5; - case VolumeUnit.UsTeaspoon: return _value*4.92892159375e-6; + case VolumeUnit.AcreFoot: + return new Volume(_value/0.000810714, BaseUnit); + case VolumeUnit.AuTablespoon: + return new Volume(_value*2e-5, BaseUnit); + case VolumeUnit.Centiliter: + return new Volume((_value/1e3) * 1e-2d, BaseUnit); + case VolumeUnit.CubicCentimeter: + return new Volume(_value/1e6, BaseUnit); + case VolumeUnit.CubicDecimeter: + return new Volume(_value/1e3, BaseUnit); + case VolumeUnit.CubicFoot: + return new Volume(_value*0.0283168, BaseUnit); + case VolumeUnit.CubicInch: + return new Volume(_value*1.6387*1e-5, BaseUnit); + case VolumeUnit.CubicKilometer: + return new Volume(_value*1e9, BaseUnit); + case VolumeUnit.CubicMeter: + return new Volume(_value, BaseUnit); + case VolumeUnit.CubicMicrometer: + return new Volume(_value/1e18, BaseUnit); + case VolumeUnit.CubicMile: + return new Volume(_value*4.16818182544058e9, BaseUnit); + case VolumeUnit.CubicMillimeter: + return new Volume(_value/1e9, BaseUnit); + case VolumeUnit.CubicYard: + return new Volume(_value*0.764554858, BaseUnit); + case VolumeUnit.Deciliter: + return new Volume((_value/1e3) * 1e-1d, BaseUnit); + case VolumeUnit.HectocubicFoot: + return new Volume((_value*0.0283168) * 1e2d, BaseUnit); + case VolumeUnit.HectocubicMeter: + return new Volume((_value) * 1e2d, BaseUnit); + case VolumeUnit.Hectoliter: + return new Volume((_value/1e3) * 1e2d, BaseUnit); + case VolumeUnit.ImperialBeerBarrel: + return new Volume(_value*0.16365924, BaseUnit); + case VolumeUnit.ImperialGallon: + return new Volume(_value*0.00454609000000181429905810072407, BaseUnit); + case VolumeUnit.ImperialOunce: + return new Volume(_value*2.8413062499962901241875439064617e-5, BaseUnit); + case VolumeUnit.KilocubicFoot: + return new Volume((_value*0.0283168) * 1e3d, BaseUnit); + case VolumeUnit.KilocubicMeter: + return new Volume((_value) * 1e3d, BaseUnit); + case VolumeUnit.KiloimperialGallon: + return new Volume((_value*0.00454609000000181429905810072407) * 1e3d, BaseUnit); + case VolumeUnit.Kiloliter: + return new Volume((_value/1e3) * 1e3d, BaseUnit); + case VolumeUnit.KilousGallon: + return new Volume((_value*0.00378541) * 1e3d, BaseUnit); + case VolumeUnit.Liter: + return new Volume(_value/1e3, BaseUnit); + case VolumeUnit.MegacubicFoot: + return new Volume((_value*0.0283168) * 1e6d, BaseUnit); + case VolumeUnit.MegaimperialGallon: + return new Volume((_value*0.00454609000000181429905810072407) * 1e6d, BaseUnit); + case VolumeUnit.Megaliter: + return new Volume((_value/1e3) * 1e6d, BaseUnit); + case VolumeUnit.MegausGallon: + return new Volume((_value*0.00378541) * 1e6d, BaseUnit); + case VolumeUnit.MetricCup: + return new Volume(_value*0.00025, BaseUnit); + case VolumeUnit.MetricTeaspoon: + return new Volume(_value*0.5e-5, BaseUnit); + case VolumeUnit.Microliter: + return new Volume((_value/1e3) * 1e-6d, BaseUnit); + case VolumeUnit.Milliliter: + return new Volume((_value/1e3) * 1e-3d, BaseUnit); + case VolumeUnit.OilBarrel: + return new Volume(_value*0.158987294928, BaseUnit); + case VolumeUnit.UkTablespoon: + return new Volume(_value*1.5e-5, BaseUnit); + case VolumeUnit.UsBeerBarrel: + return new Volume(_value*0.1173477658, BaseUnit); + case VolumeUnit.UsCustomaryCup: + return new Volume(_value*0.0002365882365, BaseUnit); + case VolumeUnit.UsGallon: + return new Volume(_value*0.00378541, BaseUnit); + case VolumeUnit.UsLegalCup: + return new Volume(_value*0.00024, BaseUnit); + case VolumeUnit.UsOunce: + return new Volume(_value*2.957352956253760505068307980135e-5, BaseUnit); + case VolumeUnit.UsPint: + return new Volume(_value*4.73176473e-4, BaseUnit); + case VolumeUnit.UsQuart: + return new Volume(_value*9.46352946e-4, BaseUnit); + case VolumeUnit.UsTablespoon: + return new Volume(_value*1.478676478125e-5, BaseUnit); + case VolumeUnit.UsTeaspoon: + return new Volume(_value*4.92892159375e-6, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -1212,7 +1257,8 @@ private double AsBaseNumericType(VolumeUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/VolumeFlow.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumeFlow.NetFramework.g.cs index 041a2e0166..d1feae1fb3 100644 --- a/UnitsNet/GeneratedCode/Quantities/VolumeFlow.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/VolumeFlow.NetFramework.g.cs @@ -1195,58 +1195,106 @@ public VolumeFlow ToUnit(VolumeFlowUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double AsBaseUnit() + internal VolumeFlow AsBaseUnit() { switch(Unit) { - case VolumeFlowUnit.AcreFootPerDay: return _value/70.0457; - case VolumeFlowUnit.AcreFootPerHour: return _value/2.91857; - case VolumeFlowUnit.AcreFootPerMinute: return _value/0.0486427916; - case VolumeFlowUnit.AcreFootPerSecond: return _value/0.000810713194; - case VolumeFlowUnit.CentiliterPerDay: return (_value/86400000) * 1e-2d; - case VolumeFlowUnit.CentiliterPerMinute: return (_value/60000.00000) * 1e-2d; - case VolumeFlowUnit.CubicDecimeterPerMinute: return _value/60000.00000; - case VolumeFlowUnit.CubicFootPerHour: return _value*7.8657907199999087346816086183876e-6; - case VolumeFlowUnit.CubicFootPerMinute: return _value/2118.88000326; - case VolumeFlowUnit.CubicFootPerSecond: return _value/35.314666721; - case VolumeFlowUnit.CubicMeterPerDay: return _value/86400; - case VolumeFlowUnit.CubicMeterPerHour: return _value/3600; - case VolumeFlowUnit.CubicMeterPerMinute: return _value/60; - case VolumeFlowUnit.CubicMeterPerSecond: return _value; - case VolumeFlowUnit.CubicMillimeterPerSecond: return _value*1e-9; - case VolumeFlowUnit.CubicYardPerDay: return _value/113007; - case VolumeFlowUnit.CubicYardPerHour: return _value*2.1237634944E-4; - case VolumeFlowUnit.CubicYardPerMinute: return _value*0.0127425809664; - case VolumeFlowUnit.CubicYardPerSecond: return _value*0.764554857984; - case VolumeFlowUnit.DeciliterPerDay: return (_value/86400000) * 1e-1d; - case VolumeFlowUnit.DeciliterPerMinute: return (_value/60000.00000) * 1e-1d; - case VolumeFlowUnit.KiloliterPerDay: return (_value/86400000) * 1e3d; - case VolumeFlowUnit.KiloliterPerMinute: return (_value/60000.00000) * 1e3d; - case VolumeFlowUnit.KilousGallonPerMinute: return _value/15.850323141489; - case VolumeFlowUnit.LiterPerDay: return _value/86400000; - case VolumeFlowUnit.LiterPerHour: return _value/3600000.000; - case VolumeFlowUnit.LiterPerMinute: return _value/60000.00000; - case VolumeFlowUnit.LiterPerSecond: return _value/1000; - case VolumeFlowUnit.MegaliterPerDay: return (_value/86400000) * 1e6d; - case VolumeFlowUnit.MegaukGallonPerSecond: return (_value/219.969) * 1e6d; - case VolumeFlowUnit.MicroliterPerDay: return (_value/86400000) * 1e-6d; - case VolumeFlowUnit.MicroliterPerMinute: return (_value/60000.00000) * 1e-6d; - case VolumeFlowUnit.MilliliterPerDay: return (_value/86400000) * 1e-3d; - case VolumeFlowUnit.MilliliterPerMinute: return (_value/60000.00000) * 1e-3d; - case VolumeFlowUnit.MillionUsGallonsPerDay: return _value/22.824465227; - case VolumeFlowUnit.NanoliterPerDay: return (_value/86400000) * 1e-9d; - case VolumeFlowUnit.NanoliterPerMinute: return (_value/60000.00000) * 1e-9d; - case VolumeFlowUnit.OilBarrelPerDay: return _value*1.8401307283333333333333333333333e-6; - case VolumeFlowUnit.OilBarrelPerHour: return _value*4.41631375e-5; - case VolumeFlowUnit.OilBarrelPerMinute: return _value*2.64978825e-3; - case VolumeFlowUnit.OilBarrelPerSecond: return _value/6.28981; - case VolumeFlowUnit.UkGallonPerDay: return _value/19005304; - case VolumeFlowUnit.UkGallonPerMinute: return _value/13198.2; - case VolumeFlowUnit.UkGallonPerSecond: return _value/219.969; - case VolumeFlowUnit.UsGallonPerDay: return _value/22824465.227; - case VolumeFlowUnit.UsGallonPerHour: return _value/951019.38848933424; - case VolumeFlowUnit.UsGallonPerMinute: return _value/15850.323141489; - case VolumeFlowUnit.UsGallonPerSecond: return _value/264.1720523581484; + case VolumeFlowUnit.AcreFootPerDay: + return new VolumeFlow(_value/70.0457, BaseUnit); + case VolumeFlowUnit.AcreFootPerHour: + return new VolumeFlow(_value/2.91857, BaseUnit); + case VolumeFlowUnit.AcreFootPerMinute: + return new VolumeFlow(_value/0.0486427916, BaseUnit); + case VolumeFlowUnit.AcreFootPerSecond: + return new VolumeFlow(_value/0.000810713194, BaseUnit); + case VolumeFlowUnit.CentiliterPerDay: + return new VolumeFlow((_value/86400000) * 1e-2d, BaseUnit); + case VolumeFlowUnit.CentiliterPerMinute: + return new VolumeFlow((_value/60000.00000) * 1e-2d, BaseUnit); + case VolumeFlowUnit.CubicDecimeterPerMinute: + return new VolumeFlow(_value/60000.00000, BaseUnit); + case VolumeFlowUnit.CubicFootPerHour: + return new VolumeFlow(_value*7.8657907199999087346816086183876e-6, BaseUnit); + case VolumeFlowUnit.CubicFootPerMinute: + return new VolumeFlow(_value/2118.88000326, BaseUnit); + case VolumeFlowUnit.CubicFootPerSecond: + return new VolumeFlow(_value/35.314666721, BaseUnit); + case VolumeFlowUnit.CubicMeterPerDay: + return new VolumeFlow(_value/86400, BaseUnit); + case VolumeFlowUnit.CubicMeterPerHour: + return new VolumeFlow(_value/3600, BaseUnit); + case VolumeFlowUnit.CubicMeterPerMinute: + return new VolumeFlow(_value/60, BaseUnit); + case VolumeFlowUnit.CubicMeterPerSecond: + return new VolumeFlow(_value, BaseUnit); + case VolumeFlowUnit.CubicMillimeterPerSecond: + return new VolumeFlow(_value*1e-9, BaseUnit); + case VolumeFlowUnit.CubicYardPerDay: + return new VolumeFlow(_value/113007, BaseUnit); + case VolumeFlowUnit.CubicYardPerHour: + return new VolumeFlow(_value*2.1237634944E-4, BaseUnit); + case VolumeFlowUnit.CubicYardPerMinute: + return new VolumeFlow(_value*0.0127425809664, BaseUnit); + case VolumeFlowUnit.CubicYardPerSecond: + return new VolumeFlow(_value*0.764554857984, BaseUnit); + case VolumeFlowUnit.DeciliterPerDay: + return new VolumeFlow((_value/86400000) * 1e-1d, BaseUnit); + case VolumeFlowUnit.DeciliterPerMinute: + return new VolumeFlow((_value/60000.00000) * 1e-1d, BaseUnit); + case VolumeFlowUnit.KiloliterPerDay: + return new VolumeFlow((_value/86400000) * 1e3d, BaseUnit); + case VolumeFlowUnit.KiloliterPerMinute: + return new VolumeFlow((_value/60000.00000) * 1e3d, BaseUnit); + case VolumeFlowUnit.KilousGallonPerMinute: + return new VolumeFlow(_value/15.850323141489, BaseUnit); + case VolumeFlowUnit.LiterPerDay: + return new VolumeFlow(_value/86400000, BaseUnit); + case VolumeFlowUnit.LiterPerHour: + return new VolumeFlow(_value/3600000.000, BaseUnit); + case VolumeFlowUnit.LiterPerMinute: + return new VolumeFlow(_value/60000.00000, BaseUnit); + case VolumeFlowUnit.LiterPerSecond: + return new VolumeFlow(_value/1000, BaseUnit); + case VolumeFlowUnit.MegaliterPerDay: + return new VolumeFlow((_value/86400000) * 1e6d, BaseUnit); + case VolumeFlowUnit.MegaukGallonPerSecond: + return new VolumeFlow((_value/219.969) * 1e6d, BaseUnit); + case VolumeFlowUnit.MicroliterPerDay: + return new VolumeFlow((_value/86400000) * 1e-6d, BaseUnit); + case VolumeFlowUnit.MicroliterPerMinute: + return new VolumeFlow((_value/60000.00000) * 1e-6d, BaseUnit); + case VolumeFlowUnit.MilliliterPerDay: + return new VolumeFlow((_value/86400000) * 1e-3d, BaseUnit); + case VolumeFlowUnit.MilliliterPerMinute: + return new VolumeFlow((_value/60000.00000) * 1e-3d, BaseUnit); + case VolumeFlowUnit.MillionUsGallonsPerDay: + return new VolumeFlow(_value/22.824465227, BaseUnit); + case VolumeFlowUnit.NanoliterPerDay: + return new VolumeFlow((_value/86400000) * 1e-9d, BaseUnit); + case VolumeFlowUnit.NanoliterPerMinute: + return new VolumeFlow((_value/60000.00000) * 1e-9d, BaseUnit); + case VolumeFlowUnit.OilBarrelPerDay: + return new VolumeFlow(_value*1.8401307283333333333333333333333e-6, BaseUnit); + case VolumeFlowUnit.OilBarrelPerHour: + return new VolumeFlow(_value*4.41631375e-5, BaseUnit); + case VolumeFlowUnit.OilBarrelPerMinute: + return new VolumeFlow(_value*2.64978825e-3, BaseUnit); + case VolumeFlowUnit.OilBarrelPerSecond: + return new VolumeFlow(_value/6.28981, BaseUnit); + case VolumeFlowUnit.UkGallonPerDay: + return new VolumeFlow(_value/19005304, BaseUnit); + case VolumeFlowUnit.UkGallonPerMinute: + return new VolumeFlow(_value/13198.2, BaseUnit); + case VolumeFlowUnit.UkGallonPerSecond: + return new VolumeFlow(_value/219.969, BaseUnit); + case VolumeFlowUnit.UsGallonPerDay: + return new VolumeFlow(_value/22824465.227, BaseUnit); + case VolumeFlowUnit.UsGallonPerHour: + return new VolumeFlow(_value/951019.38848933424, BaseUnit); + case VolumeFlowUnit.UsGallonPerMinute: + return new VolumeFlow(_value/15850.323141489, BaseUnit); + case VolumeFlowUnit.UsGallonPerSecond: + return new VolumeFlow(_value/264.1720523581484, BaseUnit); default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -1257,7 +1305,8 @@ private double AsBaseNumericType(VolumeFlowUnit unit) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/GeneratedCode/UnitConverter.g.cs b/UnitsNet/GeneratedCode/UnitConverter.g.cs new file mode 100644 index 0000000000..293f55b55e --- /dev/null +++ b/UnitsNet/GeneratedCode/UnitConverter.g.cs @@ -0,0 +1,1738 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by \generate-code.bat. +// +// Changes to this file will be lost when the code is regenerated. +// The build server regenerates the code before each build and a pre-build +// step will regenerate the code on each local build. +// +// See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units. +// +// Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities. +// Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities. +// +// +//------------------------------------------------------------------------------ + +// Copyright (c) 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). +// https://github.com/angularsen/UnitsNet +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +using System; +using UnitsNet.Units; + +// ReSharper disable RedundantCommaInArrayInitializer +// ReSharper disable once CheckNamespace + +namespace UnitsNet +{ + public sealed partial class UnitConverter + { + public static void RegisterDefaultConversions(UnitConverter unitConverter) + { +#if !WINDOWS_UWP + unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.CentimeterPerSecondSquared, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.CentimeterPerSecondSquared)); + unitConverter.SetConversionFunction(AccelerationUnit.CentimeterPerSecondSquared, Acceleration.BaseUnit, (q) => ((Acceleration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.DecimeterPerSecondSquared, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.DecimeterPerSecondSquared)); + unitConverter.SetConversionFunction(AccelerationUnit.DecimeterPerSecondSquared, Acceleration.BaseUnit, (q) => ((Acceleration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.FootPerSecondSquared, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.FootPerSecondSquared)); + unitConverter.SetConversionFunction(AccelerationUnit.FootPerSecondSquared, Acceleration.BaseUnit, (q) => ((Acceleration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.InchPerSecondSquared, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.InchPerSecondSquared)); + unitConverter.SetConversionFunction(AccelerationUnit.InchPerSecondSquared, Acceleration.BaseUnit, (q) => ((Acceleration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.KilometerPerSecondSquared, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.KilometerPerSecondSquared)); + unitConverter.SetConversionFunction(AccelerationUnit.KilometerPerSecondSquared, Acceleration.BaseUnit, (q) => ((Acceleration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.KnotPerHour, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.KnotPerHour)); + unitConverter.SetConversionFunction(AccelerationUnit.KnotPerHour, Acceleration.BaseUnit, (q) => ((Acceleration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.KnotPerMinute, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.KnotPerMinute)); + unitConverter.SetConversionFunction(AccelerationUnit.KnotPerMinute, Acceleration.BaseUnit, (q) => ((Acceleration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.KnotPerSecond, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.KnotPerSecond)); + unitConverter.SetConversionFunction(AccelerationUnit.KnotPerSecond, Acceleration.BaseUnit, (q) => ((Acceleration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Acceleration.BaseUnit, Acceleration.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.MicrometerPerSecondSquared, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.MicrometerPerSecondSquared)); + unitConverter.SetConversionFunction(AccelerationUnit.MicrometerPerSecondSquared, Acceleration.BaseUnit, (q) => ((Acceleration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.MillimeterPerSecondSquared, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.MillimeterPerSecondSquared)); + unitConverter.SetConversionFunction(AccelerationUnit.MillimeterPerSecondSquared, Acceleration.BaseUnit, (q) => ((Acceleration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.NanometerPerSecondSquared, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.NanometerPerSecondSquared)); + unitConverter.SetConversionFunction(AccelerationUnit.NanometerPerSecondSquared, Acceleration.BaseUnit, (q) => ((Acceleration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.StandardGravity, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.StandardGravity)); + unitConverter.SetConversionFunction(AccelerationUnit.StandardGravity, Acceleration.BaseUnit, (q) => ((Acceleration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Centimole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.Centimole)); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Centimole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.CentipoundMole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.CentipoundMole)); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.CentipoundMole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Decimole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.Decimole)); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Decimole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.DecipoundMole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.DecipoundMole)); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.DecipoundMole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Kilomole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.Kilomole)); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Kilomole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.KilopoundMole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.KilopoundMole)); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.KilopoundMole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Megamole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.Megamole)); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Megamole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Micromole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.Micromole)); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Micromole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.MicropoundMole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.MicropoundMole)); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.MicropoundMole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Millimole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.Millimole)); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Millimole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.MillipoundMole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.MillipoundMole)); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.MillipoundMole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstance.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Nanomole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.Nanomole)); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Nanomole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.NanopoundMole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.NanopoundMole)); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.NanopoundMole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.PoundMole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.PoundMole)); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.PoundMole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmplitudeRatio.BaseUnit, AmplitudeRatioUnit.DecibelMicrovolt, (q) => ((AmplitudeRatio)q).ToUnit(AmplitudeRatioUnit.DecibelMicrovolt)); + unitConverter.SetConversionFunction(AmplitudeRatioUnit.DecibelMicrovolt, AmplitudeRatio.BaseUnit, (q) => ((AmplitudeRatio)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmplitudeRatio.BaseUnit, AmplitudeRatioUnit.DecibelMillivolt, (q) => ((AmplitudeRatio)q).ToUnit(AmplitudeRatioUnit.DecibelMillivolt)); + unitConverter.SetConversionFunction(AmplitudeRatioUnit.DecibelMillivolt, AmplitudeRatio.BaseUnit, (q) => ((AmplitudeRatio)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmplitudeRatio.BaseUnit, AmplitudeRatioUnit.DecibelUnloaded, (q) => ((AmplitudeRatio)q).ToUnit(AmplitudeRatioUnit.DecibelUnloaded)); + unitConverter.SetConversionFunction(AmplitudeRatioUnit.DecibelUnloaded, AmplitudeRatio.BaseUnit, (q) => ((AmplitudeRatio)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmplitudeRatio.BaseUnit, AmplitudeRatio.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Arcminute, (q) => ((Angle)q).ToUnit(AngleUnit.Arcminute)); + unitConverter.SetConversionFunction(AngleUnit.Arcminute, Angle.BaseUnit, (q) => ((Angle)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Arcsecond, (q) => ((Angle)q).ToUnit(AngleUnit.Arcsecond)); + unitConverter.SetConversionFunction(AngleUnit.Arcsecond, Angle.BaseUnit, (q) => ((Angle)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Centiradian, (q) => ((Angle)q).ToUnit(AngleUnit.Centiradian)); + unitConverter.SetConversionFunction(AngleUnit.Centiradian, Angle.BaseUnit, (q) => ((Angle)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Deciradian, (q) => ((Angle)q).ToUnit(AngleUnit.Deciradian)); + unitConverter.SetConversionFunction(AngleUnit.Deciradian, Angle.BaseUnit, (q) => ((Angle)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Angle.BaseUnit, Angle.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Gradian, (q) => ((Angle)q).ToUnit(AngleUnit.Gradian)); + unitConverter.SetConversionFunction(AngleUnit.Gradian, Angle.BaseUnit, (q) => ((Angle)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Microdegree, (q) => ((Angle)q).ToUnit(AngleUnit.Microdegree)); + unitConverter.SetConversionFunction(AngleUnit.Microdegree, Angle.BaseUnit, (q) => ((Angle)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Microradian, (q) => ((Angle)q).ToUnit(AngleUnit.Microradian)); + unitConverter.SetConversionFunction(AngleUnit.Microradian, Angle.BaseUnit, (q) => ((Angle)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Millidegree, (q) => ((Angle)q).ToUnit(AngleUnit.Millidegree)); + unitConverter.SetConversionFunction(AngleUnit.Millidegree, Angle.BaseUnit, (q) => ((Angle)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Milliradian, (q) => ((Angle)q).ToUnit(AngleUnit.Milliradian)); + unitConverter.SetConversionFunction(AngleUnit.Milliradian, Angle.BaseUnit, (q) => ((Angle)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Nanodegree, (q) => ((Angle)q).ToUnit(AngleUnit.Nanodegree)); + unitConverter.SetConversionFunction(AngleUnit.Nanodegree, Angle.BaseUnit, (q) => ((Angle)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Nanoradian, (q) => ((Angle)q).ToUnit(AngleUnit.Nanoradian)); + unitConverter.SetConversionFunction(AngleUnit.Nanoradian, Angle.BaseUnit, (q) => ((Angle)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Radian, (q) => ((Angle)q).ToUnit(AngleUnit.Radian)); + unitConverter.SetConversionFunction(AngleUnit.Radian, Angle.BaseUnit, (q) => ((Angle)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Revolution, (q) => ((Angle)q).ToUnit(AngleUnit.Revolution)); + unitConverter.SetConversionFunction(AngleUnit.Revolution, Angle.BaseUnit, (q) => ((Angle)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ApparentEnergy.BaseUnit, ApparentEnergyUnit.KilovoltampereHour, (q) => ((ApparentEnergy)q).ToUnit(ApparentEnergyUnit.KilovoltampereHour)); + unitConverter.SetConversionFunction(ApparentEnergyUnit.KilovoltampereHour, ApparentEnergy.BaseUnit, (q) => ((ApparentEnergy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ApparentEnergy.BaseUnit, ApparentEnergyUnit.MegavoltampereHour, (q) => ((ApparentEnergy)q).ToUnit(ApparentEnergyUnit.MegavoltampereHour)); + unitConverter.SetConversionFunction(ApparentEnergyUnit.MegavoltampereHour, ApparentEnergy.BaseUnit, (q) => ((ApparentEnergy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ApparentEnergy.BaseUnit, ApparentEnergy.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(ApparentPower.BaseUnit, ApparentPowerUnit.Gigavoltampere, (q) => ((ApparentPower)q).ToUnit(ApparentPowerUnit.Gigavoltampere)); + unitConverter.SetConversionFunction(ApparentPowerUnit.Gigavoltampere, ApparentPower.BaseUnit, (q) => ((ApparentPower)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ApparentPower.BaseUnit, ApparentPowerUnit.Kilovoltampere, (q) => ((ApparentPower)q).ToUnit(ApparentPowerUnit.Kilovoltampere)); + unitConverter.SetConversionFunction(ApparentPowerUnit.Kilovoltampere, ApparentPower.BaseUnit, (q) => ((ApparentPower)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ApparentPower.BaseUnit, ApparentPowerUnit.Megavoltampere, (q) => ((ApparentPower)q).ToUnit(ApparentPowerUnit.Megavoltampere)); + unitConverter.SetConversionFunction(ApparentPowerUnit.Megavoltampere, ApparentPower.BaseUnit, (q) => ((ApparentPower)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ApparentPower.BaseUnit, ApparentPower.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.Acre, (q) => ((Area)q).ToUnit(AreaUnit.Acre)); + unitConverter.SetConversionFunction(AreaUnit.Acre, Area.BaseUnit, (q) => ((Area)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.Hectare, (q) => ((Area)q).ToUnit(AreaUnit.Hectare)); + unitConverter.SetConversionFunction(AreaUnit.Hectare, Area.BaseUnit, (q) => ((Area)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareCentimeter, (q) => ((Area)q).ToUnit(AreaUnit.SquareCentimeter)); + unitConverter.SetConversionFunction(AreaUnit.SquareCentimeter, Area.BaseUnit, (q) => ((Area)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareDecimeter, (q) => ((Area)q).ToUnit(AreaUnit.SquareDecimeter)); + unitConverter.SetConversionFunction(AreaUnit.SquareDecimeter, Area.BaseUnit, (q) => ((Area)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareFoot, (q) => ((Area)q).ToUnit(AreaUnit.SquareFoot)); + unitConverter.SetConversionFunction(AreaUnit.SquareFoot, Area.BaseUnit, (q) => ((Area)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareInch, (q) => ((Area)q).ToUnit(AreaUnit.SquareInch)); + unitConverter.SetConversionFunction(AreaUnit.SquareInch, Area.BaseUnit, (q) => ((Area)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareKilometer, (q) => ((Area)q).ToUnit(AreaUnit.SquareKilometer)); + unitConverter.SetConversionFunction(AreaUnit.SquareKilometer, Area.BaseUnit, (q) => ((Area)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Area.BaseUnit, Area.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareMicrometer, (q) => ((Area)q).ToUnit(AreaUnit.SquareMicrometer)); + unitConverter.SetConversionFunction(AreaUnit.SquareMicrometer, Area.BaseUnit, (q) => ((Area)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareMile, (q) => ((Area)q).ToUnit(AreaUnit.SquareMile)); + unitConverter.SetConversionFunction(AreaUnit.SquareMile, Area.BaseUnit, (q) => ((Area)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareMillimeter, (q) => ((Area)q).ToUnit(AreaUnit.SquareMillimeter)); + unitConverter.SetConversionFunction(AreaUnit.SquareMillimeter, Area.BaseUnit, (q) => ((Area)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareYard, (q) => ((Area)q).ToUnit(AreaUnit.SquareYard)); + unitConverter.SetConversionFunction(AreaUnit.SquareYard, Area.BaseUnit, (q) => ((Area)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.UsSurveySquareFoot, (q) => ((Area)q).ToUnit(AreaUnit.UsSurveySquareFoot)); + unitConverter.SetConversionFunction(AreaUnit.UsSurveySquareFoot, Area.BaseUnit, (q) => ((Area)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AreaDensity.BaseUnit, AreaDensity.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(AreaMomentOfInertia.BaseUnit, AreaMomentOfInertiaUnit.CentimeterToTheFourth, (q) => ((AreaMomentOfInertia)q).ToUnit(AreaMomentOfInertiaUnit.CentimeterToTheFourth)); + unitConverter.SetConversionFunction(AreaMomentOfInertiaUnit.CentimeterToTheFourth, AreaMomentOfInertia.BaseUnit, (q) => ((AreaMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AreaMomentOfInertia.BaseUnit, AreaMomentOfInertiaUnit.DecimeterToTheFourth, (q) => ((AreaMomentOfInertia)q).ToUnit(AreaMomentOfInertiaUnit.DecimeterToTheFourth)); + unitConverter.SetConversionFunction(AreaMomentOfInertiaUnit.DecimeterToTheFourth, AreaMomentOfInertia.BaseUnit, (q) => ((AreaMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AreaMomentOfInertia.BaseUnit, AreaMomentOfInertiaUnit.FootToTheFourth, (q) => ((AreaMomentOfInertia)q).ToUnit(AreaMomentOfInertiaUnit.FootToTheFourth)); + unitConverter.SetConversionFunction(AreaMomentOfInertiaUnit.FootToTheFourth, AreaMomentOfInertia.BaseUnit, (q) => ((AreaMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AreaMomentOfInertia.BaseUnit, AreaMomentOfInertiaUnit.InchToTheFourth, (q) => ((AreaMomentOfInertia)q).ToUnit(AreaMomentOfInertiaUnit.InchToTheFourth)); + unitConverter.SetConversionFunction(AreaMomentOfInertiaUnit.InchToTheFourth, AreaMomentOfInertia.BaseUnit, (q) => ((AreaMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AreaMomentOfInertia.BaseUnit, AreaMomentOfInertia.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(AreaMomentOfInertia.BaseUnit, AreaMomentOfInertiaUnit.MillimeterToTheFourth, (q) => ((AreaMomentOfInertia)q).ToUnit(AreaMomentOfInertiaUnit.MillimeterToTheFourth)); + unitConverter.SetConversionFunction(AreaMomentOfInertiaUnit.MillimeterToTheFourth, AreaMomentOfInertia.BaseUnit, (q) => ((AreaMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRate.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.BytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.BytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.BytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.ExabitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.ExabitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.ExabitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.ExabytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.ExabytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.ExabytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.ExbibitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.ExbibitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.ExbibitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.ExbibytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.ExbibytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.ExbibytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.GibibitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.GibibitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.GibibitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.GibibytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.GibibytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.GibibytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.GigabitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.GigabitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.GigabitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.GigabytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.GigabytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.GigabytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.KibibitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.KibibitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.KibibitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.KibibytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.KibibytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.KibibytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.KilobitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.KilobitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.KilobitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.KilobytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.KilobytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.KilobytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.MebibitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.MebibitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.MebibitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.MebibytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.MebibytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.MebibytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.MegabitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.MegabitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.MegabitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.MegabytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.MegabytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.MegabytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.PebibitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.PebibitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.PebibitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.PebibytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.PebibytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.PebibytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.PetabitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.PetabitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.PetabitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.PetabytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.PetabytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.PetabytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.TebibitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.TebibitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.TebibitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.TebibytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.TebibytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.TebibytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.TerabitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.TerabitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.TerabitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.TerabytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.TerabytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.TerabytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BrakeSpecificFuelConsumption.BaseUnit, BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour, (q) => ((BrakeSpecificFuelConsumption)q).ToUnit(BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour)); + unitConverter.SetConversionFunction(BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour, BrakeSpecificFuelConsumption.BaseUnit, (q) => ((BrakeSpecificFuelConsumption)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BrakeSpecificFuelConsumption.BaseUnit, BrakeSpecificFuelConsumption.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(BrakeSpecificFuelConsumption.BaseUnit, BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour, (q) => ((BrakeSpecificFuelConsumption)q).ToUnit(BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour)); + unitConverter.SetConversionFunction(BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour, BrakeSpecificFuelConsumption.BaseUnit, (q) => ((BrakeSpecificFuelConsumption)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Capacitance.BaseUnit, Capacitance.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Capacitance.BaseUnit, CapacitanceUnit.Kilofarad, (q) => ((Capacitance)q).ToUnit(CapacitanceUnit.Kilofarad)); + unitConverter.SetConversionFunction(CapacitanceUnit.Kilofarad, Capacitance.BaseUnit, (q) => ((Capacitance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Capacitance.BaseUnit, CapacitanceUnit.Megafarad, (q) => ((Capacitance)q).ToUnit(CapacitanceUnit.Megafarad)); + unitConverter.SetConversionFunction(CapacitanceUnit.Megafarad, Capacitance.BaseUnit, (q) => ((Capacitance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Capacitance.BaseUnit, CapacitanceUnit.Microfarad, (q) => ((Capacitance)q).ToUnit(CapacitanceUnit.Microfarad)); + unitConverter.SetConversionFunction(CapacitanceUnit.Microfarad, Capacitance.BaseUnit, (q) => ((Capacitance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Capacitance.BaseUnit, CapacitanceUnit.Millifarad, (q) => ((Capacitance)q).ToUnit(CapacitanceUnit.Millifarad)); + unitConverter.SetConversionFunction(CapacitanceUnit.Millifarad, Capacitance.BaseUnit, (q) => ((Capacitance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Capacitance.BaseUnit, CapacitanceUnit.Nanofarad, (q) => ((Capacitance)q).ToUnit(CapacitanceUnit.Nanofarad)); + unitConverter.SetConversionFunction(CapacitanceUnit.Nanofarad, Capacitance.BaseUnit, (q) => ((Capacitance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Capacitance.BaseUnit, CapacitanceUnit.Picofarad, (q) => ((Capacitance)q).ToUnit(CapacitanceUnit.Picofarad)); + unitConverter.SetConversionFunction(CapacitanceUnit.Picofarad, Capacitance.BaseUnit, (q) => ((Capacitance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(CoefficientOfThermalExpansion.BaseUnit, CoefficientOfThermalExpansionUnit.InverseDegreeCelsius, (q) => ((CoefficientOfThermalExpansion)q).ToUnit(CoefficientOfThermalExpansionUnit.InverseDegreeCelsius)); + unitConverter.SetConversionFunction(CoefficientOfThermalExpansionUnit.InverseDegreeCelsius, CoefficientOfThermalExpansion.BaseUnit, (q) => ((CoefficientOfThermalExpansion)q).AsBaseUnit()); + unitConverter.SetConversionFunction(CoefficientOfThermalExpansion.BaseUnit, CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit, (q) => ((CoefficientOfThermalExpansion)q).ToUnit(CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit)); + unitConverter.SetConversionFunction(CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit, CoefficientOfThermalExpansion.BaseUnit, (q) => ((CoefficientOfThermalExpansion)q).AsBaseUnit()); + unitConverter.SetConversionFunction(CoefficientOfThermalExpansion.BaseUnit, CoefficientOfThermalExpansion.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.CentigramPerDeciliter, (q) => ((Density)q).ToUnit(DensityUnit.CentigramPerDeciliter)); + unitConverter.SetConversionFunction(DensityUnit.CentigramPerDeciliter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.CentigramPerLiter, (q) => ((Density)q).ToUnit(DensityUnit.CentigramPerLiter)); + unitConverter.SetConversionFunction(DensityUnit.CentigramPerLiter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.CentigramPerMilliliter, (q) => ((Density)q).ToUnit(DensityUnit.CentigramPerMilliliter)); + unitConverter.SetConversionFunction(DensityUnit.CentigramPerMilliliter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.DecigramPerDeciliter, (q) => ((Density)q).ToUnit(DensityUnit.DecigramPerDeciliter)); + unitConverter.SetConversionFunction(DensityUnit.DecigramPerDeciliter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.DecigramPerLiter, (q) => ((Density)q).ToUnit(DensityUnit.DecigramPerLiter)); + unitConverter.SetConversionFunction(DensityUnit.DecigramPerLiter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.DecigramPerMilliliter, (q) => ((Density)q).ToUnit(DensityUnit.DecigramPerMilliliter)); + unitConverter.SetConversionFunction(DensityUnit.DecigramPerMilliliter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.GramPerCubicCentimeter, (q) => ((Density)q).ToUnit(DensityUnit.GramPerCubicCentimeter)); + unitConverter.SetConversionFunction(DensityUnit.GramPerCubicCentimeter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.GramPerCubicMeter, (q) => ((Density)q).ToUnit(DensityUnit.GramPerCubicMeter)); + unitConverter.SetConversionFunction(DensityUnit.GramPerCubicMeter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.GramPerCubicMillimeter, (q) => ((Density)q).ToUnit(DensityUnit.GramPerCubicMillimeter)); + unitConverter.SetConversionFunction(DensityUnit.GramPerCubicMillimeter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.GramPerDeciliter, (q) => ((Density)q).ToUnit(DensityUnit.GramPerDeciliter)); + unitConverter.SetConversionFunction(DensityUnit.GramPerDeciliter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.GramPerLiter, (q) => ((Density)q).ToUnit(DensityUnit.GramPerLiter)); + unitConverter.SetConversionFunction(DensityUnit.GramPerLiter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.GramPerMilliliter, (q) => ((Density)q).ToUnit(DensityUnit.GramPerMilliliter)); + unitConverter.SetConversionFunction(DensityUnit.GramPerMilliliter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.KilogramPerCubicCentimeter, (q) => ((Density)q).ToUnit(DensityUnit.KilogramPerCubicCentimeter)); + unitConverter.SetConversionFunction(DensityUnit.KilogramPerCubicCentimeter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, Density.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.KilogramPerCubicMillimeter, (q) => ((Density)q).ToUnit(DensityUnit.KilogramPerCubicMillimeter)); + unitConverter.SetConversionFunction(DensityUnit.KilogramPerCubicMillimeter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.KilopoundPerCubicFoot, (q) => ((Density)q).ToUnit(DensityUnit.KilopoundPerCubicFoot)); + unitConverter.SetConversionFunction(DensityUnit.KilopoundPerCubicFoot, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.KilopoundPerCubicInch, (q) => ((Density)q).ToUnit(DensityUnit.KilopoundPerCubicInch)); + unitConverter.SetConversionFunction(DensityUnit.KilopoundPerCubicInch, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.MicrogramPerCubicMeter, (q) => ((Density)q).ToUnit(DensityUnit.MicrogramPerCubicMeter)); + unitConverter.SetConversionFunction(DensityUnit.MicrogramPerCubicMeter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.MicrogramPerDeciliter, (q) => ((Density)q).ToUnit(DensityUnit.MicrogramPerDeciliter)); + unitConverter.SetConversionFunction(DensityUnit.MicrogramPerDeciliter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.MicrogramPerLiter, (q) => ((Density)q).ToUnit(DensityUnit.MicrogramPerLiter)); + unitConverter.SetConversionFunction(DensityUnit.MicrogramPerLiter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.MicrogramPerMilliliter, (q) => ((Density)q).ToUnit(DensityUnit.MicrogramPerMilliliter)); + unitConverter.SetConversionFunction(DensityUnit.MicrogramPerMilliliter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.MilligramPerCubicMeter, (q) => ((Density)q).ToUnit(DensityUnit.MilligramPerCubicMeter)); + unitConverter.SetConversionFunction(DensityUnit.MilligramPerCubicMeter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.MilligramPerDeciliter, (q) => ((Density)q).ToUnit(DensityUnit.MilligramPerDeciliter)); + unitConverter.SetConversionFunction(DensityUnit.MilligramPerDeciliter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.MilligramPerLiter, (q) => ((Density)q).ToUnit(DensityUnit.MilligramPerLiter)); + unitConverter.SetConversionFunction(DensityUnit.MilligramPerLiter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.MilligramPerMilliliter, (q) => ((Density)q).ToUnit(DensityUnit.MilligramPerMilliliter)); + unitConverter.SetConversionFunction(DensityUnit.MilligramPerMilliliter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.NanogramPerDeciliter, (q) => ((Density)q).ToUnit(DensityUnit.NanogramPerDeciliter)); + unitConverter.SetConversionFunction(DensityUnit.NanogramPerDeciliter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.NanogramPerLiter, (q) => ((Density)q).ToUnit(DensityUnit.NanogramPerLiter)); + unitConverter.SetConversionFunction(DensityUnit.NanogramPerLiter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.NanogramPerMilliliter, (q) => ((Density)q).ToUnit(DensityUnit.NanogramPerMilliliter)); + unitConverter.SetConversionFunction(DensityUnit.NanogramPerMilliliter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PicogramPerDeciliter, (q) => ((Density)q).ToUnit(DensityUnit.PicogramPerDeciliter)); + unitConverter.SetConversionFunction(DensityUnit.PicogramPerDeciliter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PicogramPerLiter, (q) => ((Density)q).ToUnit(DensityUnit.PicogramPerLiter)); + unitConverter.SetConversionFunction(DensityUnit.PicogramPerLiter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PicogramPerMilliliter, (q) => ((Density)q).ToUnit(DensityUnit.PicogramPerMilliliter)); + unitConverter.SetConversionFunction(DensityUnit.PicogramPerMilliliter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PoundPerCubicFoot, (q) => ((Density)q).ToUnit(DensityUnit.PoundPerCubicFoot)); + unitConverter.SetConversionFunction(DensityUnit.PoundPerCubicFoot, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PoundPerCubicInch, (q) => ((Density)q).ToUnit(DensityUnit.PoundPerCubicInch)); + unitConverter.SetConversionFunction(DensityUnit.PoundPerCubicInch, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PoundPerImperialGallon, (q) => ((Density)q).ToUnit(DensityUnit.PoundPerImperialGallon)); + unitConverter.SetConversionFunction(DensityUnit.PoundPerImperialGallon, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PoundPerUSGallon, (q) => ((Density)q).ToUnit(DensityUnit.PoundPerUSGallon)); + unitConverter.SetConversionFunction(DensityUnit.PoundPerUSGallon, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.SlugPerCubicFoot, (q) => ((Density)q).ToUnit(DensityUnit.SlugPerCubicFoot)); + unitConverter.SetConversionFunction(DensityUnit.SlugPerCubicFoot, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.TonnePerCubicCentimeter, (q) => ((Density)q).ToUnit(DensityUnit.TonnePerCubicCentimeter)); + unitConverter.SetConversionFunction(DensityUnit.TonnePerCubicCentimeter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.TonnePerCubicMeter, (q) => ((Density)q).ToUnit(DensityUnit.TonnePerCubicMeter)); + unitConverter.SetConversionFunction(DensityUnit.TonnePerCubicMeter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.TonnePerCubicMillimeter, (q) => ((Density)q).ToUnit(DensityUnit.TonnePerCubicMillimeter)); + unitConverter.SetConversionFunction(DensityUnit.TonnePerCubicMillimeter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Day, (q) => ((Duration)q).ToUnit(DurationUnit.Day)); + unitConverter.SetConversionFunction(DurationUnit.Day, Duration.BaseUnit, (q) => ((Duration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Hour, (q) => ((Duration)q).ToUnit(DurationUnit.Hour)); + unitConverter.SetConversionFunction(DurationUnit.Hour, Duration.BaseUnit, (q) => ((Duration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Microsecond, (q) => ((Duration)q).ToUnit(DurationUnit.Microsecond)); + unitConverter.SetConversionFunction(DurationUnit.Microsecond, Duration.BaseUnit, (q) => ((Duration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Millisecond, (q) => ((Duration)q).ToUnit(DurationUnit.Millisecond)); + unitConverter.SetConversionFunction(DurationUnit.Millisecond, Duration.BaseUnit, (q) => ((Duration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Minute, (q) => ((Duration)q).ToUnit(DurationUnit.Minute)); + unitConverter.SetConversionFunction(DurationUnit.Minute, Duration.BaseUnit, (q) => ((Duration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Month30, (q) => ((Duration)q).ToUnit(DurationUnit.Month30)); + unitConverter.SetConversionFunction(DurationUnit.Month30, Duration.BaseUnit, (q) => ((Duration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Nanosecond, (q) => ((Duration)q).ToUnit(DurationUnit.Nanosecond)); + unitConverter.SetConversionFunction(DurationUnit.Nanosecond, Duration.BaseUnit, (q) => ((Duration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Duration.BaseUnit, Duration.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Week, (q) => ((Duration)q).ToUnit(DurationUnit.Week)); + unitConverter.SetConversionFunction(DurationUnit.Week, Duration.BaseUnit, (q) => ((Duration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Year365, (q) => ((Duration)q).ToUnit(DurationUnit.Year365)); + unitConverter.SetConversionFunction(DurationUnit.Year365, Duration.BaseUnit, (q) => ((Duration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DynamicViscosity.BaseUnit, DynamicViscosityUnit.Centipoise, (q) => ((DynamicViscosity)q).ToUnit(DynamicViscosityUnit.Centipoise)); + unitConverter.SetConversionFunction(DynamicViscosityUnit.Centipoise, DynamicViscosity.BaseUnit, (q) => ((DynamicViscosity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DynamicViscosity.BaseUnit, DynamicViscosityUnit.MicropascalSecond, (q) => ((DynamicViscosity)q).ToUnit(DynamicViscosityUnit.MicropascalSecond)); + unitConverter.SetConversionFunction(DynamicViscosityUnit.MicropascalSecond, DynamicViscosity.BaseUnit, (q) => ((DynamicViscosity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DynamicViscosity.BaseUnit, DynamicViscosityUnit.MillipascalSecond, (q) => ((DynamicViscosity)q).ToUnit(DynamicViscosityUnit.MillipascalSecond)); + unitConverter.SetConversionFunction(DynamicViscosityUnit.MillipascalSecond, DynamicViscosity.BaseUnit, (q) => ((DynamicViscosity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DynamicViscosity.BaseUnit, DynamicViscosity.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(DynamicViscosity.BaseUnit, DynamicViscosityUnit.PascalSecond, (q) => ((DynamicViscosity)q).ToUnit(DynamicViscosityUnit.PascalSecond)); + unitConverter.SetConversionFunction(DynamicViscosityUnit.PascalSecond, DynamicViscosity.BaseUnit, (q) => ((DynamicViscosity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DynamicViscosity.BaseUnit, DynamicViscosityUnit.Poise, (q) => ((DynamicViscosity)q).ToUnit(DynamicViscosityUnit.Poise)); + unitConverter.SetConversionFunction(DynamicViscosityUnit.Poise, DynamicViscosity.BaseUnit, (q) => ((DynamicViscosity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricAdmittance.BaseUnit, ElectricAdmittanceUnit.Microsiemens, (q) => ((ElectricAdmittance)q).ToUnit(ElectricAdmittanceUnit.Microsiemens)); + unitConverter.SetConversionFunction(ElectricAdmittanceUnit.Microsiemens, ElectricAdmittance.BaseUnit, (q) => ((ElectricAdmittance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricAdmittance.BaseUnit, ElectricAdmittanceUnit.Millisiemens, (q) => ((ElectricAdmittance)q).ToUnit(ElectricAdmittanceUnit.Millisiemens)); + unitConverter.SetConversionFunction(ElectricAdmittanceUnit.Millisiemens, ElectricAdmittance.BaseUnit, (q) => ((ElectricAdmittance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricAdmittance.BaseUnit, ElectricAdmittanceUnit.Nanosiemens, (q) => ((ElectricAdmittance)q).ToUnit(ElectricAdmittanceUnit.Nanosiemens)); + unitConverter.SetConversionFunction(ElectricAdmittanceUnit.Nanosiemens, ElectricAdmittance.BaseUnit, (q) => ((ElectricAdmittance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricAdmittance.BaseUnit, ElectricAdmittance.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(ElectricCharge.BaseUnit, ElectricCharge.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(ElectricChargeDensity.BaseUnit, ElectricChargeDensity.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(ElectricConductance.BaseUnit, ElectricConductanceUnit.Microsiemens, (q) => ((ElectricConductance)q).ToUnit(ElectricConductanceUnit.Microsiemens)); + unitConverter.SetConversionFunction(ElectricConductanceUnit.Microsiemens, ElectricConductance.BaseUnit, (q) => ((ElectricConductance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricConductance.BaseUnit, ElectricConductanceUnit.Millisiemens, (q) => ((ElectricConductance)q).ToUnit(ElectricConductanceUnit.Millisiemens)); + unitConverter.SetConversionFunction(ElectricConductanceUnit.Millisiemens, ElectricConductance.BaseUnit, (q) => ((ElectricConductance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricConductance.BaseUnit, ElectricConductance.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(ElectricConductivity.BaseUnit, ElectricConductivity.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(ElectricCurrent.BaseUnit, ElectricCurrent.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Centiampere, (q) => ((ElectricCurrent)q).ToUnit(ElectricCurrentUnit.Centiampere)); + unitConverter.SetConversionFunction(ElectricCurrentUnit.Centiampere, ElectricCurrent.BaseUnit, (q) => ((ElectricCurrent)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Kiloampere, (q) => ((ElectricCurrent)q).ToUnit(ElectricCurrentUnit.Kiloampere)); + unitConverter.SetConversionFunction(ElectricCurrentUnit.Kiloampere, ElectricCurrent.BaseUnit, (q) => ((ElectricCurrent)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Megaampere, (q) => ((ElectricCurrent)q).ToUnit(ElectricCurrentUnit.Megaampere)); + unitConverter.SetConversionFunction(ElectricCurrentUnit.Megaampere, ElectricCurrent.BaseUnit, (q) => ((ElectricCurrent)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Microampere, (q) => ((ElectricCurrent)q).ToUnit(ElectricCurrentUnit.Microampere)); + unitConverter.SetConversionFunction(ElectricCurrentUnit.Microampere, ElectricCurrent.BaseUnit, (q) => ((ElectricCurrent)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Milliampere, (q) => ((ElectricCurrent)q).ToUnit(ElectricCurrentUnit.Milliampere)); + unitConverter.SetConversionFunction(ElectricCurrentUnit.Milliampere, ElectricCurrent.BaseUnit, (q) => ((ElectricCurrent)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Nanoampere, (q) => ((ElectricCurrent)q).ToUnit(ElectricCurrentUnit.Nanoampere)); + unitConverter.SetConversionFunction(ElectricCurrentUnit.Nanoampere, ElectricCurrent.BaseUnit, (q) => ((ElectricCurrent)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Picoampere, (q) => ((ElectricCurrent)q).ToUnit(ElectricCurrentUnit.Picoampere)); + unitConverter.SetConversionFunction(ElectricCurrentUnit.Picoampere, ElectricCurrent.BaseUnit, (q) => ((ElectricCurrent)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricCurrentDensity.BaseUnit, ElectricCurrentDensity.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(ElectricCurrentGradient.BaseUnit, ElectricCurrentGradient.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(ElectricField.BaseUnit, ElectricField.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(ElectricInductance.BaseUnit, ElectricInductance.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(ElectricInductance.BaseUnit, ElectricInductanceUnit.Microhenry, (q) => ((ElectricInductance)q).ToUnit(ElectricInductanceUnit.Microhenry)); + unitConverter.SetConversionFunction(ElectricInductanceUnit.Microhenry, ElectricInductance.BaseUnit, (q) => ((ElectricInductance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricInductance.BaseUnit, ElectricInductanceUnit.Millihenry, (q) => ((ElectricInductance)q).ToUnit(ElectricInductanceUnit.Millihenry)); + unitConverter.SetConversionFunction(ElectricInductanceUnit.Millihenry, ElectricInductance.BaseUnit, (q) => ((ElectricInductance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricInductance.BaseUnit, ElectricInductanceUnit.Nanohenry, (q) => ((ElectricInductance)q).ToUnit(ElectricInductanceUnit.Nanohenry)); + unitConverter.SetConversionFunction(ElectricInductanceUnit.Nanohenry, ElectricInductance.BaseUnit, (q) => ((ElectricInductance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotential.BaseUnit, ElectricPotentialUnit.Kilovolt, (q) => ((ElectricPotential)q).ToUnit(ElectricPotentialUnit.Kilovolt)); + unitConverter.SetConversionFunction(ElectricPotentialUnit.Kilovolt, ElectricPotential.BaseUnit, (q) => ((ElectricPotential)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotential.BaseUnit, ElectricPotentialUnit.Megavolt, (q) => ((ElectricPotential)q).ToUnit(ElectricPotentialUnit.Megavolt)); + unitConverter.SetConversionFunction(ElectricPotentialUnit.Megavolt, ElectricPotential.BaseUnit, (q) => ((ElectricPotential)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotential.BaseUnit, ElectricPotentialUnit.Microvolt, (q) => ((ElectricPotential)q).ToUnit(ElectricPotentialUnit.Microvolt)); + unitConverter.SetConversionFunction(ElectricPotentialUnit.Microvolt, ElectricPotential.BaseUnit, (q) => ((ElectricPotential)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotential.BaseUnit, ElectricPotentialUnit.Millivolt, (q) => ((ElectricPotential)q).ToUnit(ElectricPotentialUnit.Millivolt)); + unitConverter.SetConversionFunction(ElectricPotentialUnit.Millivolt, ElectricPotential.BaseUnit, (q) => ((ElectricPotential)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotential.BaseUnit, ElectricPotential.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(ElectricPotentialAc.BaseUnit, ElectricPotentialAcUnit.KilovoltAc, (q) => ((ElectricPotentialAc)q).ToUnit(ElectricPotentialAcUnit.KilovoltAc)); + unitConverter.SetConversionFunction(ElectricPotentialAcUnit.KilovoltAc, ElectricPotentialAc.BaseUnit, (q) => ((ElectricPotentialAc)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotentialAc.BaseUnit, ElectricPotentialAcUnit.MegavoltAc, (q) => ((ElectricPotentialAc)q).ToUnit(ElectricPotentialAcUnit.MegavoltAc)); + unitConverter.SetConversionFunction(ElectricPotentialAcUnit.MegavoltAc, ElectricPotentialAc.BaseUnit, (q) => ((ElectricPotentialAc)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotentialAc.BaseUnit, ElectricPotentialAcUnit.MicrovoltAc, (q) => ((ElectricPotentialAc)q).ToUnit(ElectricPotentialAcUnit.MicrovoltAc)); + unitConverter.SetConversionFunction(ElectricPotentialAcUnit.MicrovoltAc, ElectricPotentialAc.BaseUnit, (q) => ((ElectricPotentialAc)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotentialAc.BaseUnit, ElectricPotentialAcUnit.MillivoltAc, (q) => ((ElectricPotentialAc)q).ToUnit(ElectricPotentialAcUnit.MillivoltAc)); + unitConverter.SetConversionFunction(ElectricPotentialAcUnit.MillivoltAc, ElectricPotentialAc.BaseUnit, (q) => ((ElectricPotentialAc)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotentialAc.BaseUnit, ElectricPotentialAc.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(ElectricPotentialDc.BaseUnit, ElectricPotentialDcUnit.KilovoltDc, (q) => ((ElectricPotentialDc)q).ToUnit(ElectricPotentialDcUnit.KilovoltDc)); + unitConverter.SetConversionFunction(ElectricPotentialDcUnit.KilovoltDc, ElectricPotentialDc.BaseUnit, (q) => ((ElectricPotentialDc)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotentialDc.BaseUnit, ElectricPotentialDcUnit.MegavoltDc, (q) => ((ElectricPotentialDc)q).ToUnit(ElectricPotentialDcUnit.MegavoltDc)); + unitConverter.SetConversionFunction(ElectricPotentialDcUnit.MegavoltDc, ElectricPotentialDc.BaseUnit, (q) => ((ElectricPotentialDc)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotentialDc.BaseUnit, ElectricPotentialDcUnit.MicrovoltDc, (q) => ((ElectricPotentialDc)q).ToUnit(ElectricPotentialDcUnit.MicrovoltDc)); + unitConverter.SetConversionFunction(ElectricPotentialDcUnit.MicrovoltDc, ElectricPotentialDc.BaseUnit, (q) => ((ElectricPotentialDc)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotentialDc.BaseUnit, ElectricPotentialDcUnit.MillivoltDc, (q) => ((ElectricPotentialDc)q).ToUnit(ElectricPotentialDcUnit.MillivoltDc)); + unitConverter.SetConversionFunction(ElectricPotentialDcUnit.MillivoltDc, ElectricPotentialDc.BaseUnit, (q) => ((ElectricPotentialDc)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotentialDc.BaseUnit, ElectricPotentialDc.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(ElectricResistance.BaseUnit, ElectricResistanceUnit.Gigaohm, (q) => ((ElectricResistance)q).ToUnit(ElectricResistanceUnit.Gigaohm)); + unitConverter.SetConversionFunction(ElectricResistanceUnit.Gigaohm, ElectricResistance.BaseUnit, (q) => ((ElectricResistance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistance.BaseUnit, ElectricResistanceUnit.Kiloohm, (q) => ((ElectricResistance)q).ToUnit(ElectricResistanceUnit.Kiloohm)); + unitConverter.SetConversionFunction(ElectricResistanceUnit.Kiloohm, ElectricResistance.BaseUnit, (q) => ((ElectricResistance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistance.BaseUnit, ElectricResistanceUnit.Megaohm, (q) => ((ElectricResistance)q).ToUnit(ElectricResistanceUnit.Megaohm)); + unitConverter.SetConversionFunction(ElectricResistanceUnit.Megaohm, ElectricResistance.BaseUnit, (q) => ((ElectricResistance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistance.BaseUnit, ElectricResistanceUnit.Milliohm, (q) => ((ElectricResistance)q).ToUnit(ElectricResistanceUnit.Milliohm)); + unitConverter.SetConversionFunction(ElectricResistanceUnit.Milliohm, ElectricResistance.BaseUnit, (q) => ((ElectricResistance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistance.BaseUnit, ElectricResistance.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.KiloohmCentimeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.KiloohmCentimeter)); + unitConverter.SetConversionFunction(ElectricResistivityUnit.KiloohmCentimeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.KiloohmMeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.KiloohmMeter)); + unitConverter.SetConversionFunction(ElectricResistivityUnit.KiloohmMeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.MegaohmCentimeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.MegaohmCentimeter)); + unitConverter.SetConversionFunction(ElectricResistivityUnit.MegaohmCentimeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.MegaohmMeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.MegaohmMeter)); + unitConverter.SetConversionFunction(ElectricResistivityUnit.MegaohmMeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.MicroohmCentimeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.MicroohmCentimeter)); + unitConverter.SetConversionFunction(ElectricResistivityUnit.MicroohmCentimeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.MicroohmMeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.MicroohmMeter)); + unitConverter.SetConversionFunction(ElectricResistivityUnit.MicroohmMeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.MilliohmCentimeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.MilliohmCentimeter)); + unitConverter.SetConversionFunction(ElectricResistivityUnit.MilliohmCentimeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.MilliohmMeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.MilliohmMeter)); + unitConverter.SetConversionFunction(ElectricResistivityUnit.MilliohmMeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.NanoohmCentimeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.NanoohmCentimeter)); + unitConverter.SetConversionFunction(ElectricResistivityUnit.NanoohmCentimeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.NanoohmMeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.NanoohmMeter)); + unitConverter.SetConversionFunction(ElectricResistivityUnit.NanoohmMeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.OhmCentimeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.OhmCentimeter)); + unitConverter.SetConversionFunction(ElectricResistivityUnit.OhmCentimeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivity.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.PicoohmCentimeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.PicoohmCentimeter)); + unitConverter.SetConversionFunction(ElectricResistivityUnit.PicoohmCentimeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.PicoohmMeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.PicoohmMeter)); + unitConverter.SetConversionFunction(ElectricResistivityUnit.PicoohmMeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.BritishThermalUnit, (q) => ((Energy)q).ToUnit(EnergyUnit.BritishThermalUnit)); + unitConverter.SetConversionFunction(EnergyUnit.BritishThermalUnit, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.Calorie, (q) => ((Energy)q).ToUnit(EnergyUnit.Calorie)); + unitConverter.SetConversionFunction(EnergyUnit.Calorie, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.DecathermEc, (q) => ((Energy)q).ToUnit(EnergyUnit.DecathermEc)); + unitConverter.SetConversionFunction(EnergyUnit.DecathermEc, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.DecathermImperial, (q) => ((Energy)q).ToUnit(EnergyUnit.DecathermImperial)); + unitConverter.SetConversionFunction(EnergyUnit.DecathermImperial, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.DecathermUs, (q) => ((Energy)q).ToUnit(EnergyUnit.DecathermUs)); + unitConverter.SetConversionFunction(EnergyUnit.DecathermUs, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.ElectronVolt, (q) => ((Energy)q).ToUnit(EnergyUnit.ElectronVolt)); + unitConverter.SetConversionFunction(EnergyUnit.ElectronVolt, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.Erg, (q) => ((Energy)q).ToUnit(EnergyUnit.Erg)); + unitConverter.SetConversionFunction(EnergyUnit.Erg, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.FootPound, (q) => ((Energy)q).ToUnit(EnergyUnit.FootPound)); + unitConverter.SetConversionFunction(EnergyUnit.FootPound, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.GigabritishThermalUnit, (q) => ((Energy)q).ToUnit(EnergyUnit.GigabritishThermalUnit)); + unitConverter.SetConversionFunction(EnergyUnit.GigabritishThermalUnit, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.GigawattHour, (q) => ((Energy)q).ToUnit(EnergyUnit.GigawattHour)); + unitConverter.SetConversionFunction(EnergyUnit.GigawattHour, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, Energy.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.KilobritishThermalUnit, (q) => ((Energy)q).ToUnit(EnergyUnit.KilobritishThermalUnit)); + unitConverter.SetConversionFunction(EnergyUnit.KilobritishThermalUnit, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.Kilocalorie, (q) => ((Energy)q).ToUnit(EnergyUnit.Kilocalorie)); + unitConverter.SetConversionFunction(EnergyUnit.Kilocalorie, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.Kilojoule, (q) => ((Energy)q).ToUnit(EnergyUnit.Kilojoule)); + unitConverter.SetConversionFunction(EnergyUnit.Kilojoule, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.KilowattHour, (q) => ((Energy)q).ToUnit(EnergyUnit.KilowattHour)); + unitConverter.SetConversionFunction(EnergyUnit.KilowattHour, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.MegabritishThermalUnit, (q) => ((Energy)q).ToUnit(EnergyUnit.MegabritishThermalUnit)); + unitConverter.SetConversionFunction(EnergyUnit.MegabritishThermalUnit, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.Megajoule, (q) => ((Energy)q).ToUnit(EnergyUnit.Megajoule)); + unitConverter.SetConversionFunction(EnergyUnit.Megajoule, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.MegawattHour, (q) => ((Energy)q).ToUnit(EnergyUnit.MegawattHour)); + unitConverter.SetConversionFunction(EnergyUnit.MegawattHour, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.ThermEc, (q) => ((Energy)q).ToUnit(EnergyUnit.ThermEc)); + unitConverter.SetConversionFunction(EnergyUnit.ThermEc, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.ThermImperial, (q) => ((Energy)q).ToUnit(EnergyUnit.ThermImperial)); + unitConverter.SetConversionFunction(EnergyUnit.ThermImperial, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.ThermUs, (q) => ((Energy)q).ToUnit(EnergyUnit.ThermUs)); + unitConverter.SetConversionFunction(EnergyUnit.ThermUs, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.WattHour, (q) => ((Energy)q).ToUnit(EnergyUnit.WattHour)); + unitConverter.SetConversionFunction(EnergyUnit.WattHour, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Entropy.BaseUnit, EntropyUnit.CaloriePerKelvin, (q) => ((Entropy)q).ToUnit(EntropyUnit.CaloriePerKelvin)); + unitConverter.SetConversionFunction(EntropyUnit.CaloriePerKelvin, Entropy.BaseUnit, (q) => ((Entropy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Entropy.BaseUnit, EntropyUnit.JoulePerDegreeCelsius, (q) => ((Entropy)q).ToUnit(EntropyUnit.JoulePerDegreeCelsius)); + unitConverter.SetConversionFunction(EntropyUnit.JoulePerDegreeCelsius, Entropy.BaseUnit, (q) => ((Entropy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Entropy.BaseUnit, Entropy.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Entropy.BaseUnit, EntropyUnit.KilocaloriePerKelvin, (q) => ((Entropy)q).ToUnit(EntropyUnit.KilocaloriePerKelvin)); + unitConverter.SetConversionFunction(EntropyUnit.KilocaloriePerKelvin, Entropy.BaseUnit, (q) => ((Entropy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Entropy.BaseUnit, EntropyUnit.KilojoulePerDegreeCelsius, (q) => ((Entropy)q).ToUnit(EntropyUnit.KilojoulePerDegreeCelsius)); + unitConverter.SetConversionFunction(EntropyUnit.KilojoulePerDegreeCelsius, Entropy.BaseUnit, (q) => ((Entropy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Entropy.BaseUnit, EntropyUnit.KilojoulePerKelvin, (q) => ((Entropy)q).ToUnit(EntropyUnit.KilojoulePerKelvin)); + unitConverter.SetConversionFunction(EntropyUnit.KilojoulePerKelvin, Entropy.BaseUnit, (q) => ((Entropy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Entropy.BaseUnit, EntropyUnit.MegajoulePerKelvin, (q) => ((Entropy)q).ToUnit(EntropyUnit.MegajoulePerKelvin)); + unitConverter.SetConversionFunction(EntropyUnit.MegajoulePerKelvin, Entropy.BaseUnit, (q) => ((Entropy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.Decanewton, (q) => ((Force)q).ToUnit(ForceUnit.Decanewton)); + unitConverter.SetConversionFunction(ForceUnit.Decanewton, Force.BaseUnit, (q) => ((Force)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.Dyn, (q) => ((Force)q).ToUnit(ForceUnit.Dyn)); + unitConverter.SetConversionFunction(ForceUnit.Dyn, Force.BaseUnit, (q) => ((Force)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.KilogramForce, (q) => ((Force)q).ToUnit(ForceUnit.KilogramForce)); + unitConverter.SetConversionFunction(ForceUnit.KilogramForce, Force.BaseUnit, (q) => ((Force)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.Kilonewton, (q) => ((Force)q).ToUnit(ForceUnit.Kilonewton)); + unitConverter.SetConversionFunction(ForceUnit.Kilonewton, Force.BaseUnit, (q) => ((Force)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.KiloPond, (q) => ((Force)q).ToUnit(ForceUnit.KiloPond)); + unitConverter.SetConversionFunction(ForceUnit.KiloPond, Force.BaseUnit, (q) => ((Force)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.Meganewton, (q) => ((Force)q).ToUnit(ForceUnit.Meganewton)); + unitConverter.SetConversionFunction(ForceUnit.Meganewton, Force.BaseUnit, (q) => ((Force)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.Micronewton, (q) => ((Force)q).ToUnit(ForceUnit.Micronewton)); + unitConverter.SetConversionFunction(ForceUnit.Micronewton, Force.BaseUnit, (q) => ((Force)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.Millinewton, (q) => ((Force)q).ToUnit(ForceUnit.Millinewton)); + unitConverter.SetConversionFunction(ForceUnit.Millinewton, Force.BaseUnit, (q) => ((Force)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Force.BaseUnit, Force.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.OunceForce, (q) => ((Force)q).ToUnit(ForceUnit.OunceForce)); + unitConverter.SetConversionFunction(ForceUnit.OunceForce, Force.BaseUnit, (q) => ((Force)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.Poundal, (q) => ((Force)q).ToUnit(ForceUnit.Poundal)); + unitConverter.SetConversionFunction(ForceUnit.Poundal, Force.BaseUnit, (q) => ((Force)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.PoundForce, (q) => ((Force)q).ToUnit(ForceUnit.PoundForce)); + unitConverter.SetConversionFunction(ForceUnit.PoundForce, Force.BaseUnit, (q) => ((Force)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.TonneForce, (q) => ((Force)q).ToUnit(ForceUnit.TonneForce)); + unitConverter.SetConversionFunction(ForceUnit.TonneForce, Force.BaseUnit, (q) => ((Force)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.CentinewtonPerSecond, (q) => ((ForceChangeRate)q).ToUnit(ForceChangeRateUnit.CentinewtonPerSecond)); + unitConverter.SetConversionFunction(ForceChangeRateUnit.CentinewtonPerSecond, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.DecanewtonPerMinute, (q) => ((ForceChangeRate)q).ToUnit(ForceChangeRateUnit.DecanewtonPerMinute)); + unitConverter.SetConversionFunction(ForceChangeRateUnit.DecanewtonPerMinute, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.DecanewtonPerSecond, (q) => ((ForceChangeRate)q).ToUnit(ForceChangeRateUnit.DecanewtonPerSecond)); + unitConverter.SetConversionFunction(ForceChangeRateUnit.DecanewtonPerSecond, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.DecinewtonPerSecond, (q) => ((ForceChangeRate)q).ToUnit(ForceChangeRateUnit.DecinewtonPerSecond)); + unitConverter.SetConversionFunction(ForceChangeRateUnit.DecinewtonPerSecond, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.KilonewtonPerMinute, (q) => ((ForceChangeRate)q).ToUnit(ForceChangeRateUnit.KilonewtonPerMinute)); + unitConverter.SetConversionFunction(ForceChangeRateUnit.KilonewtonPerMinute, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.KilonewtonPerSecond, (q) => ((ForceChangeRate)q).ToUnit(ForceChangeRateUnit.KilonewtonPerSecond)); + unitConverter.SetConversionFunction(ForceChangeRateUnit.KilonewtonPerSecond, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.MicronewtonPerSecond, (q) => ((ForceChangeRate)q).ToUnit(ForceChangeRateUnit.MicronewtonPerSecond)); + unitConverter.SetConversionFunction(ForceChangeRateUnit.MicronewtonPerSecond, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.MillinewtonPerSecond, (q) => ((ForceChangeRate)q).ToUnit(ForceChangeRateUnit.MillinewtonPerSecond)); + unitConverter.SetConversionFunction(ForceChangeRateUnit.MillinewtonPerSecond, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.NanonewtonPerSecond, (q) => ((ForceChangeRate)q).ToUnit(ForceChangeRateUnit.NanonewtonPerSecond)); + unitConverter.SetConversionFunction(ForceChangeRateUnit.NanonewtonPerSecond, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.NewtonPerMinute, (q) => ((ForceChangeRate)q).ToUnit(ForceChangeRateUnit.NewtonPerMinute)); + unitConverter.SetConversionFunction(ForceChangeRateUnit.NewtonPerMinute, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRate.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.CentinewtonPerMeter, (q) => ((ForcePerLength)q).ToUnit(ForcePerLengthUnit.CentinewtonPerMeter)); + unitConverter.SetConversionFunction(ForcePerLengthUnit.CentinewtonPerMeter, ForcePerLength.BaseUnit, (q) => ((ForcePerLength)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.DecinewtonPerMeter, (q) => ((ForcePerLength)q).ToUnit(ForcePerLengthUnit.DecinewtonPerMeter)); + unitConverter.SetConversionFunction(ForcePerLengthUnit.DecinewtonPerMeter, ForcePerLength.BaseUnit, (q) => ((ForcePerLength)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.KilogramForcePerMeter, (q) => ((ForcePerLength)q).ToUnit(ForcePerLengthUnit.KilogramForcePerMeter)); + unitConverter.SetConversionFunction(ForcePerLengthUnit.KilogramForcePerMeter, ForcePerLength.BaseUnit, (q) => ((ForcePerLength)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.KilonewtonPerMeter, (q) => ((ForcePerLength)q).ToUnit(ForcePerLengthUnit.KilonewtonPerMeter)); + unitConverter.SetConversionFunction(ForcePerLengthUnit.KilonewtonPerMeter, ForcePerLength.BaseUnit, (q) => ((ForcePerLength)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.MeganewtonPerMeter, (q) => ((ForcePerLength)q).ToUnit(ForcePerLengthUnit.MeganewtonPerMeter)); + unitConverter.SetConversionFunction(ForcePerLengthUnit.MeganewtonPerMeter, ForcePerLength.BaseUnit, (q) => ((ForcePerLength)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.MicronewtonPerMeter, (q) => ((ForcePerLength)q).ToUnit(ForcePerLengthUnit.MicronewtonPerMeter)); + unitConverter.SetConversionFunction(ForcePerLengthUnit.MicronewtonPerMeter, ForcePerLength.BaseUnit, (q) => ((ForcePerLength)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.MillinewtonPerMeter, (q) => ((ForcePerLength)q).ToUnit(ForcePerLengthUnit.MillinewtonPerMeter)); + unitConverter.SetConversionFunction(ForcePerLengthUnit.MillinewtonPerMeter, ForcePerLength.BaseUnit, (q) => ((ForcePerLength)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.NanonewtonPerMeter, (q) => ((ForcePerLength)q).ToUnit(ForcePerLengthUnit.NanonewtonPerMeter)); + unitConverter.SetConversionFunction(ForcePerLengthUnit.NanonewtonPerMeter, ForcePerLength.BaseUnit, (q) => ((ForcePerLength)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLength.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Frequency.BaseUnit, FrequencyUnit.CyclePerHour, (q) => ((Frequency)q).ToUnit(FrequencyUnit.CyclePerHour)); + unitConverter.SetConversionFunction(FrequencyUnit.CyclePerHour, Frequency.BaseUnit, (q) => ((Frequency)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Frequency.BaseUnit, FrequencyUnit.CyclePerMinute, (q) => ((Frequency)q).ToUnit(FrequencyUnit.CyclePerMinute)); + unitConverter.SetConversionFunction(FrequencyUnit.CyclePerMinute, Frequency.BaseUnit, (q) => ((Frequency)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Frequency.BaseUnit, FrequencyUnit.Gigahertz, (q) => ((Frequency)q).ToUnit(FrequencyUnit.Gigahertz)); + unitConverter.SetConversionFunction(FrequencyUnit.Gigahertz, Frequency.BaseUnit, (q) => ((Frequency)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Frequency.BaseUnit, Frequency.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Frequency.BaseUnit, FrequencyUnit.Kilohertz, (q) => ((Frequency)q).ToUnit(FrequencyUnit.Kilohertz)); + unitConverter.SetConversionFunction(FrequencyUnit.Kilohertz, Frequency.BaseUnit, (q) => ((Frequency)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Frequency.BaseUnit, FrequencyUnit.Megahertz, (q) => ((Frequency)q).ToUnit(FrequencyUnit.Megahertz)); + unitConverter.SetConversionFunction(FrequencyUnit.Megahertz, Frequency.BaseUnit, (q) => ((Frequency)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Frequency.BaseUnit, FrequencyUnit.RadianPerSecond, (q) => ((Frequency)q).ToUnit(FrequencyUnit.RadianPerSecond)); + unitConverter.SetConversionFunction(FrequencyUnit.RadianPerSecond, Frequency.BaseUnit, (q) => ((Frequency)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Frequency.BaseUnit, FrequencyUnit.Terahertz, (q) => ((Frequency)q).ToUnit(FrequencyUnit.Terahertz)); + unitConverter.SetConversionFunction(FrequencyUnit.Terahertz, Frequency.BaseUnit, (q) => ((Frequency)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.BtuPerHourSquareFoot, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.BtuPerHourSquareFoot)); + unitConverter.SetConversionFunction(HeatFluxUnit.BtuPerHourSquareFoot, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.BtuPerMinuteSquareFoot, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.BtuPerMinuteSquareFoot)); + unitConverter.SetConversionFunction(HeatFluxUnit.BtuPerMinuteSquareFoot, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.BtuPerSecondSquareFoot, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.BtuPerSecondSquareFoot)); + unitConverter.SetConversionFunction(HeatFluxUnit.BtuPerSecondSquareFoot, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.BtuPerSecondSquareInch, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.BtuPerSecondSquareInch)); + unitConverter.SetConversionFunction(HeatFluxUnit.BtuPerSecondSquareInch, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.CaloriePerSecondSquareCentimeter, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.CaloriePerSecondSquareCentimeter)); + unitConverter.SetConversionFunction(HeatFluxUnit.CaloriePerSecondSquareCentimeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.CentiwattPerSquareMeter, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.CentiwattPerSquareMeter)); + unitConverter.SetConversionFunction(HeatFluxUnit.CentiwattPerSquareMeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.DeciwattPerSquareMeter, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.DeciwattPerSquareMeter)); + unitConverter.SetConversionFunction(HeatFluxUnit.DeciwattPerSquareMeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.KilocaloriePerHourSquareMeter, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.KilocaloriePerHourSquareMeter)); + unitConverter.SetConversionFunction(HeatFluxUnit.KilocaloriePerHourSquareMeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.KilocaloriePerSecondSquareCentimeter, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.KilocaloriePerSecondSquareCentimeter)); + unitConverter.SetConversionFunction(HeatFluxUnit.KilocaloriePerSecondSquareCentimeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.KilowattPerSquareMeter, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.KilowattPerSquareMeter)); + unitConverter.SetConversionFunction(HeatFluxUnit.KilowattPerSquareMeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.MicrowattPerSquareMeter, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.MicrowattPerSquareMeter)); + unitConverter.SetConversionFunction(HeatFluxUnit.MicrowattPerSquareMeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.MilliwattPerSquareMeter, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.MilliwattPerSquareMeter)); + unitConverter.SetConversionFunction(HeatFluxUnit.MilliwattPerSquareMeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.NanowattPerSquareMeter, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.NanowattPerSquareMeter)); + unitConverter.SetConversionFunction(HeatFluxUnit.NanowattPerSquareMeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.PoundForcePerFootSecond, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.PoundForcePerFootSecond)); + unitConverter.SetConversionFunction(HeatFluxUnit.PoundForcePerFootSecond, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.PoundPerSecondCubed, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.PoundPerSecondCubed)); + unitConverter.SetConversionFunction(HeatFluxUnit.PoundPerSecondCubed, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.WattPerSquareFoot, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.WattPerSquareFoot)); + unitConverter.SetConversionFunction(HeatFluxUnit.WattPerSquareFoot, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.WattPerSquareInch, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.WattPerSquareInch)); + unitConverter.SetConversionFunction(HeatFluxUnit.WattPerSquareInch, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFlux.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(HeatTransferCoefficient.BaseUnit, HeatTransferCoefficientUnit.WattPerSquareMeterCelsius, (q) => ((HeatTransferCoefficient)q).ToUnit(HeatTransferCoefficientUnit.WattPerSquareMeterCelsius)); + unitConverter.SetConversionFunction(HeatTransferCoefficientUnit.WattPerSquareMeterCelsius, HeatTransferCoefficient.BaseUnit, (q) => ((HeatTransferCoefficient)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatTransferCoefficient.BaseUnit, HeatTransferCoefficient.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Illuminance.BaseUnit, IlluminanceUnit.Kilolux, (q) => ((Illuminance)q).ToUnit(IlluminanceUnit.Kilolux)); + unitConverter.SetConversionFunction(IlluminanceUnit.Kilolux, Illuminance.BaseUnit, (q) => ((Illuminance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Illuminance.BaseUnit, Illuminance.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Illuminance.BaseUnit, IlluminanceUnit.Megalux, (q) => ((Illuminance)q).ToUnit(IlluminanceUnit.Megalux)); + unitConverter.SetConversionFunction(IlluminanceUnit.Megalux, Illuminance.BaseUnit, (q) => ((Illuminance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Illuminance.BaseUnit, IlluminanceUnit.Millilux, (q) => ((Illuminance)q).ToUnit(IlluminanceUnit.Millilux)); + unitConverter.SetConversionFunction(IlluminanceUnit.Millilux, Illuminance.BaseUnit, (q) => ((Illuminance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, Information.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Byte, (q) => ((Information)q).ToUnit(InformationUnit.Byte)); + unitConverter.SetConversionFunction(InformationUnit.Byte, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Exabit, (q) => ((Information)q).ToUnit(InformationUnit.Exabit)); + unitConverter.SetConversionFunction(InformationUnit.Exabit, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Exabyte, (q) => ((Information)q).ToUnit(InformationUnit.Exabyte)); + unitConverter.SetConversionFunction(InformationUnit.Exabyte, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Exbibit, (q) => ((Information)q).ToUnit(InformationUnit.Exbibit)); + unitConverter.SetConversionFunction(InformationUnit.Exbibit, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Exbibyte, (q) => ((Information)q).ToUnit(InformationUnit.Exbibyte)); + unitConverter.SetConversionFunction(InformationUnit.Exbibyte, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Gibibit, (q) => ((Information)q).ToUnit(InformationUnit.Gibibit)); + unitConverter.SetConversionFunction(InformationUnit.Gibibit, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Gibibyte, (q) => ((Information)q).ToUnit(InformationUnit.Gibibyte)); + unitConverter.SetConversionFunction(InformationUnit.Gibibyte, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Gigabit, (q) => ((Information)q).ToUnit(InformationUnit.Gigabit)); + unitConverter.SetConversionFunction(InformationUnit.Gigabit, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Gigabyte, (q) => ((Information)q).ToUnit(InformationUnit.Gigabyte)); + unitConverter.SetConversionFunction(InformationUnit.Gigabyte, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Kibibit, (q) => ((Information)q).ToUnit(InformationUnit.Kibibit)); + unitConverter.SetConversionFunction(InformationUnit.Kibibit, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Kibibyte, (q) => ((Information)q).ToUnit(InformationUnit.Kibibyte)); + unitConverter.SetConversionFunction(InformationUnit.Kibibyte, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Kilobit, (q) => ((Information)q).ToUnit(InformationUnit.Kilobit)); + unitConverter.SetConversionFunction(InformationUnit.Kilobit, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Kilobyte, (q) => ((Information)q).ToUnit(InformationUnit.Kilobyte)); + unitConverter.SetConversionFunction(InformationUnit.Kilobyte, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Mebibit, (q) => ((Information)q).ToUnit(InformationUnit.Mebibit)); + unitConverter.SetConversionFunction(InformationUnit.Mebibit, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Mebibyte, (q) => ((Information)q).ToUnit(InformationUnit.Mebibyte)); + unitConverter.SetConversionFunction(InformationUnit.Mebibyte, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Megabit, (q) => ((Information)q).ToUnit(InformationUnit.Megabit)); + unitConverter.SetConversionFunction(InformationUnit.Megabit, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Megabyte, (q) => ((Information)q).ToUnit(InformationUnit.Megabyte)); + unitConverter.SetConversionFunction(InformationUnit.Megabyte, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Pebibit, (q) => ((Information)q).ToUnit(InformationUnit.Pebibit)); + unitConverter.SetConversionFunction(InformationUnit.Pebibit, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Pebibyte, (q) => ((Information)q).ToUnit(InformationUnit.Pebibyte)); + unitConverter.SetConversionFunction(InformationUnit.Pebibyte, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Petabit, (q) => ((Information)q).ToUnit(InformationUnit.Petabit)); + unitConverter.SetConversionFunction(InformationUnit.Petabit, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Petabyte, (q) => ((Information)q).ToUnit(InformationUnit.Petabyte)); + unitConverter.SetConversionFunction(InformationUnit.Petabyte, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Tebibit, (q) => ((Information)q).ToUnit(InformationUnit.Tebibit)); + unitConverter.SetConversionFunction(InformationUnit.Tebibit, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Tebibyte, (q) => ((Information)q).ToUnit(InformationUnit.Tebibyte)); + unitConverter.SetConversionFunction(InformationUnit.Tebibyte, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Terabit, (q) => ((Information)q).ToUnit(InformationUnit.Terabit)); + unitConverter.SetConversionFunction(InformationUnit.Terabit, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Terabyte, (q) => ((Information)q).ToUnit(InformationUnit.Terabyte)); + unitConverter.SetConversionFunction(InformationUnit.Terabyte, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.KilowattPerSquareCentimeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.KilowattPerSquareCentimeter)); + unitConverter.SetConversionFunction(IrradianceUnit.KilowattPerSquareCentimeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.KilowattPerSquareMeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.KilowattPerSquareMeter)); + unitConverter.SetConversionFunction(IrradianceUnit.KilowattPerSquareMeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.MegawattPerSquareCentimeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.MegawattPerSquareCentimeter)); + unitConverter.SetConversionFunction(IrradianceUnit.MegawattPerSquareCentimeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.MegawattPerSquareMeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.MegawattPerSquareMeter)); + unitConverter.SetConversionFunction(IrradianceUnit.MegawattPerSquareMeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.MicrowattPerSquareCentimeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.MicrowattPerSquareCentimeter)); + unitConverter.SetConversionFunction(IrradianceUnit.MicrowattPerSquareCentimeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.MicrowattPerSquareMeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.MicrowattPerSquareMeter)); + unitConverter.SetConversionFunction(IrradianceUnit.MicrowattPerSquareMeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.MilliwattPerSquareCentimeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.MilliwattPerSquareCentimeter)); + unitConverter.SetConversionFunction(IrradianceUnit.MilliwattPerSquareCentimeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.MilliwattPerSquareMeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.MilliwattPerSquareMeter)); + unitConverter.SetConversionFunction(IrradianceUnit.MilliwattPerSquareMeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.NanowattPerSquareCentimeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.NanowattPerSquareCentimeter)); + unitConverter.SetConversionFunction(IrradianceUnit.NanowattPerSquareCentimeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.NanowattPerSquareMeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.NanowattPerSquareMeter)); + unitConverter.SetConversionFunction(IrradianceUnit.NanowattPerSquareMeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.PicowattPerSquareCentimeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.PicowattPerSquareCentimeter)); + unitConverter.SetConversionFunction(IrradianceUnit.PicowattPerSquareCentimeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.PicowattPerSquareMeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.PicowattPerSquareMeter)); + unitConverter.SetConversionFunction(IrradianceUnit.PicowattPerSquareMeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.WattPerSquareCentimeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.WattPerSquareCentimeter)); + unitConverter.SetConversionFunction(IrradianceUnit.WattPerSquareCentimeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Irradiance.BaseUnit, Irradiance.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Irradiation.BaseUnit, Irradiation.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Irradiation.BaseUnit, IrradiationUnit.JoulePerSquareMillimeter, (q) => ((Irradiation)q).ToUnit(IrradiationUnit.JoulePerSquareMillimeter)); + unitConverter.SetConversionFunction(IrradiationUnit.JoulePerSquareMillimeter, Irradiation.BaseUnit, (q) => ((Irradiation)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Irradiation.BaseUnit, IrradiationUnit.KilowattHourPerSquareMeter, (q) => ((Irradiation)q).ToUnit(IrradiationUnit.KilowattHourPerSquareMeter)); + unitConverter.SetConversionFunction(IrradiationUnit.KilowattHourPerSquareMeter, Irradiation.BaseUnit, (q) => ((Irradiation)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Irradiation.BaseUnit, IrradiationUnit.WattHourPerSquareMeter, (q) => ((Irradiation)q).ToUnit(IrradiationUnit.WattHourPerSquareMeter)); + unitConverter.SetConversionFunction(IrradiationUnit.WattHourPerSquareMeter, Irradiation.BaseUnit, (q) => ((Irradiation)q).AsBaseUnit()); + unitConverter.SetConversionFunction(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Centistokes, (q) => ((KinematicViscosity)q).ToUnit(KinematicViscosityUnit.Centistokes)); + unitConverter.SetConversionFunction(KinematicViscosityUnit.Centistokes, KinematicViscosity.BaseUnit, (q) => ((KinematicViscosity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Decistokes, (q) => ((KinematicViscosity)q).ToUnit(KinematicViscosityUnit.Decistokes)); + unitConverter.SetConversionFunction(KinematicViscosityUnit.Decistokes, KinematicViscosity.BaseUnit, (q) => ((KinematicViscosity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Kilostokes, (q) => ((KinematicViscosity)q).ToUnit(KinematicViscosityUnit.Kilostokes)); + unitConverter.SetConversionFunction(KinematicViscosityUnit.Kilostokes, KinematicViscosity.BaseUnit, (q) => ((KinematicViscosity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Microstokes, (q) => ((KinematicViscosity)q).ToUnit(KinematicViscosityUnit.Microstokes)); + unitConverter.SetConversionFunction(KinematicViscosityUnit.Microstokes, KinematicViscosity.BaseUnit, (q) => ((KinematicViscosity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Millistokes, (q) => ((KinematicViscosity)q).ToUnit(KinematicViscosityUnit.Millistokes)); + unitConverter.SetConversionFunction(KinematicViscosityUnit.Millistokes, KinematicViscosity.BaseUnit, (q) => ((KinematicViscosity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Nanostokes, (q) => ((KinematicViscosity)q).ToUnit(KinematicViscosityUnit.Nanostokes)); + unitConverter.SetConversionFunction(KinematicViscosityUnit.Nanostokes, KinematicViscosity.BaseUnit, (q) => ((KinematicViscosity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(KinematicViscosity.BaseUnit, KinematicViscosity.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Stokes, (q) => ((KinematicViscosity)q).ToUnit(KinematicViscosityUnit.Stokes)); + unitConverter.SetConversionFunction(KinematicViscosityUnit.Stokes, KinematicViscosity.BaseUnit, (q) => ((KinematicViscosity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(LapseRate.BaseUnit, LapseRate.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Centimeter, (q) => ((Length)q).ToUnit(LengthUnit.Centimeter)); + unitConverter.SetConversionFunction(LengthUnit.Centimeter, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Decimeter, (q) => ((Length)q).ToUnit(LengthUnit.Decimeter)); + unitConverter.SetConversionFunction(LengthUnit.Decimeter, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.DtpPica, (q) => ((Length)q).ToUnit(LengthUnit.DtpPica)); + unitConverter.SetConversionFunction(LengthUnit.DtpPica, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.DtpPoint, (q) => ((Length)q).ToUnit(LengthUnit.DtpPoint)); + unitConverter.SetConversionFunction(LengthUnit.DtpPoint, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Fathom, (q) => ((Length)q).ToUnit(LengthUnit.Fathom)); + unitConverter.SetConversionFunction(LengthUnit.Fathom, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Foot, (q) => ((Length)q).ToUnit(LengthUnit.Foot)); + unitConverter.SetConversionFunction(LengthUnit.Foot, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Inch, (q) => ((Length)q).ToUnit(LengthUnit.Inch)); + unitConverter.SetConversionFunction(LengthUnit.Inch, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Kilometer, (q) => ((Length)q).ToUnit(LengthUnit.Kilometer)); + unitConverter.SetConversionFunction(LengthUnit.Kilometer, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, Length.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Microinch, (q) => ((Length)q).ToUnit(LengthUnit.Microinch)); + unitConverter.SetConversionFunction(LengthUnit.Microinch, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Micrometer, (q) => ((Length)q).ToUnit(LengthUnit.Micrometer)); + unitConverter.SetConversionFunction(LengthUnit.Micrometer, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Mil, (q) => ((Length)q).ToUnit(LengthUnit.Mil)); + unitConverter.SetConversionFunction(LengthUnit.Mil, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Mile, (q) => ((Length)q).ToUnit(LengthUnit.Mile)); + unitConverter.SetConversionFunction(LengthUnit.Mile, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Millimeter, (q) => ((Length)q).ToUnit(LengthUnit.Millimeter)); + unitConverter.SetConversionFunction(LengthUnit.Millimeter, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Nanometer, (q) => ((Length)q).ToUnit(LengthUnit.Nanometer)); + unitConverter.SetConversionFunction(LengthUnit.Nanometer, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.NauticalMile, (q) => ((Length)q).ToUnit(LengthUnit.NauticalMile)); + unitConverter.SetConversionFunction(LengthUnit.NauticalMile, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.PrinterPica, (q) => ((Length)q).ToUnit(LengthUnit.PrinterPica)); + unitConverter.SetConversionFunction(LengthUnit.PrinterPica, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.PrinterPoint, (q) => ((Length)q).ToUnit(LengthUnit.PrinterPoint)); + unitConverter.SetConversionFunction(LengthUnit.PrinterPoint, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Shackle, (q) => ((Length)q).ToUnit(LengthUnit.Shackle)); + unitConverter.SetConversionFunction(LengthUnit.Shackle, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Twip, (q) => ((Length)q).ToUnit(LengthUnit.Twip)); + unitConverter.SetConversionFunction(LengthUnit.Twip, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.UsSurveyFoot, (q) => ((Length)q).ToUnit(LengthUnit.UsSurveyFoot)); + unitConverter.SetConversionFunction(LengthUnit.UsSurveyFoot, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Yard, (q) => ((Length)q).ToUnit(LengthUnit.Yard)); + unitConverter.SetConversionFunction(LengthUnit.Yard, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Level.BaseUnit, Level.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Level.BaseUnit, LevelUnit.Neper, (q) => ((Level)q).ToUnit(LevelUnit.Neper)); + unitConverter.SetConversionFunction(LevelUnit.Neper, Level.BaseUnit, (q) => ((Level)q).AsBaseUnit()); + unitConverter.SetConversionFunction(LinearDensity.BaseUnit, LinearDensityUnit.GramPerMeter, (q) => ((LinearDensity)q).ToUnit(LinearDensityUnit.GramPerMeter)); + unitConverter.SetConversionFunction(LinearDensityUnit.GramPerMeter, LinearDensity.BaseUnit, (q) => ((LinearDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(LinearDensity.BaseUnit, LinearDensity.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(LinearDensity.BaseUnit, LinearDensityUnit.PoundPerFoot, (q) => ((LinearDensity)q).ToUnit(LinearDensityUnit.PoundPerFoot)); + unitConverter.SetConversionFunction(LinearDensityUnit.PoundPerFoot, LinearDensity.BaseUnit, (q) => ((LinearDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(LuminousFlux.BaseUnit, LuminousFlux.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(LuminousIntensity.BaseUnit, LuminousIntensity.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(MagneticField.BaseUnit, MagneticFieldUnit.Microtesla, (q) => ((MagneticField)q).ToUnit(MagneticFieldUnit.Microtesla)); + unitConverter.SetConversionFunction(MagneticFieldUnit.Microtesla, MagneticField.BaseUnit, (q) => ((MagneticField)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MagneticField.BaseUnit, MagneticFieldUnit.Millitesla, (q) => ((MagneticField)q).ToUnit(MagneticFieldUnit.Millitesla)); + unitConverter.SetConversionFunction(MagneticFieldUnit.Millitesla, MagneticField.BaseUnit, (q) => ((MagneticField)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MagneticField.BaseUnit, MagneticFieldUnit.Nanotesla, (q) => ((MagneticField)q).ToUnit(MagneticFieldUnit.Nanotesla)); + unitConverter.SetConversionFunction(MagneticFieldUnit.Nanotesla, MagneticField.BaseUnit, (q) => ((MagneticField)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MagneticField.BaseUnit, MagneticField.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(MagneticFlux.BaseUnit, MagneticFlux.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Magnetization.BaseUnit, Magnetization.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Centigram, (q) => ((Mass)q).ToUnit(MassUnit.Centigram)); + unitConverter.SetConversionFunction(MassUnit.Centigram, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Decagram, (q) => ((Mass)q).ToUnit(MassUnit.Decagram)); + unitConverter.SetConversionFunction(MassUnit.Decagram, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Decigram, (q) => ((Mass)q).ToUnit(MassUnit.Decigram)); + unitConverter.SetConversionFunction(MassUnit.Decigram, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Grain, (q) => ((Mass)q).ToUnit(MassUnit.Grain)); + unitConverter.SetConversionFunction(MassUnit.Grain, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Gram, (q) => ((Mass)q).ToUnit(MassUnit.Gram)); + unitConverter.SetConversionFunction(MassUnit.Gram, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Hectogram, (q) => ((Mass)q).ToUnit(MassUnit.Hectogram)); + unitConverter.SetConversionFunction(MassUnit.Hectogram, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, Mass.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Kilopound, (q) => ((Mass)q).ToUnit(MassUnit.Kilopound)); + unitConverter.SetConversionFunction(MassUnit.Kilopound, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Kilotonne, (q) => ((Mass)q).ToUnit(MassUnit.Kilotonne)); + unitConverter.SetConversionFunction(MassUnit.Kilotonne, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.LongHundredweight, (q) => ((Mass)q).ToUnit(MassUnit.LongHundredweight)); + unitConverter.SetConversionFunction(MassUnit.LongHundredweight, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.LongTon, (q) => ((Mass)q).ToUnit(MassUnit.LongTon)); + unitConverter.SetConversionFunction(MassUnit.LongTon, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Megapound, (q) => ((Mass)q).ToUnit(MassUnit.Megapound)); + unitConverter.SetConversionFunction(MassUnit.Megapound, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Megatonne, (q) => ((Mass)q).ToUnit(MassUnit.Megatonne)); + unitConverter.SetConversionFunction(MassUnit.Megatonne, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Microgram, (q) => ((Mass)q).ToUnit(MassUnit.Microgram)); + unitConverter.SetConversionFunction(MassUnit.Microgram, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Milligram, (q) => ((Mass)q).ToUnit(MassUnit.Milligram)); + unitConverter.SetConversionFunction(MassUnit.Milligram, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Nanogram, (q) => ((Mass)q).ToUnit(MassUnit.Nanogram)); + unitConverter.SetConversionFunction(MassUnit.Nanogram, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Ounce, (q) => ((Mass)q).ToUnit(MassUnit.Ounce)); + unitConverter.SetConversionFunction(MassUnit.Ounce, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Pound, (q) => ((Mass)q).ToUnit(MassUnit.Pound)); + unitConverter.SetConversionFunction(MassUnit.Pound, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.ShortHundredweight, (q) => ((Mass)q).ToUnit(MassUnit.ShortHundredweight)); + unitConverter.SetConversionFunction(MassUnit.ShortHundredweight, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.ShortTon, (q) => ((Mass)q).ToUnit(MassUnit.ShortTon)); + unitConverter.SetConversionFunction(MassUnit.ShortTon, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Slug, (q) => ((Mass)q).ToUnit(MassUnit.Slug)); + unitConverter.SetConversionFunction(MassUnit.Slug, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Stone, (q) => ((Mass)q).ToUnit(MassUnit.Stone)); + unitConverter.SetConversionFunction(MassUnit.Stone, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Tonne, (q) => ((Mass)q).ToUnit(MassUnit.Tonne)); + unitConverter.SetConversionFunction(MassUnit.Tonne, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.CentigramPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.CentigramPerDay)); + unitConverter.SetConversionFunction(MassFlowUnit.CentigramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.CentigramPerSecond, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.CentigramPerSecond)); + unitConverter.SetConversionFunction(MassFlowUnit.CentigramPerSecond, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.DecagramPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.DecagramPerDay)); + unitConverter.SetConversionFunction(MassFlowUnit.DecagramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.DecagramPerSecond, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.DecagramPerSecond)); + unitConverter.SetConversionFunction(MassFlowUnit.DecagramPerSecond, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.DecigramPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.DecigramPerDay)); + unitConverter.SetConversionFunction(MassFlowUnit.DecigramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.DecigramPerSecond, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.DecigramPerSecond)); + unitConverter.SetConversionFunction(MassFlowUnit.DecigramPerSecond, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.GramPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.GramPerDay)); + unitConverter.SetConversionFunction(MassFlowUnit.GramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlow.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.HectogramPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.HectogramPerDay)); + unitConverter.SetConversionFunction(MassFlowUnit.HectogramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.HectogramPerSecond, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.HectogramPerSecond)); + unitConverter.SetConversionFunction(MassFlowUnit.HectogramPerSecond, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.KilogramPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.KilogramPerDay)); + unitConverter.SetConversionFunction(MassFlowUnit.KilogramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.KilogramPerHour, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.KilogramPerHour)); + unitConverter.SetConversionFunction(MassFlowUnit.KilogramPerHour, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.KilogramPerMinute, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.KilogramPerMinute)); + unitConverter.SetConversionFunction(MassFlowUnit.KilogramPerMinute, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.KilogramPerSecond, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.KilogramPerSecond)); + unitConverter.SetConversionFunction(MassFlowUnit.KilogramPerSecond, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MegagramPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.MegagramPerDay)); + unitConverter.SetConversionFunction(MassFlowUnit.MegagramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MegapoundPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.MegapoundPerDay)); + unitConverter.SetConversionFunction(MassFlowUnit.MegapoundPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MegapoundPerHour, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.MegapoundPerHour)); + unitConverter.SetConversionFunction(MassFlowUnit.MegapoundPerHour, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MegapoundPerMinute, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.MegapoundPerMinute)); + unitConverter.SetConversionFunction(MassFlowUnit.MegapoundPerMinute, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MicrogramPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.MicrogramPerDay)); + unitConverter.SetConversionFunction(MassFlowUnit.MicrogramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MicrogramPerSecond, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.MicrogramPerSecond)); + unitConverter.SetConversionFunction(MassFlowUnit.MicrogramPerSecond, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MilligramPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.MilligramPerDay)); + unitConverter.SetConversionFunction(MassFlowUnit.MilligramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MilligramPerSecond, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.MilligramPerSecond)); + unitConverter.SetConversionFunction(MassFlowUnit.MilligramPerSecond, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.NanogramPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.NanogramPerDay)); + unitConverter.SetConversionFunction(MassFlowUnit.NanogramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.NanogramPerSecond, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.NanogramPerSecond)); + unitConverter.SetConversionFunction(MassFlowUnit.NanogramPerSecond, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.PoundPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.PoundPerDay)); + unitConverter.SetConversionFunction(MassFlowUnit.PoundPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.PoundPerHour, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.PoundPerHour)); + unitConverter.SetConversionFunction(MassFlowUnit.PoundPerHour, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.PoundPerMinute, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.PoundPerMinute)); + unitConverter.SetConversionFunction(MassFlowUnit.PoundPerMinute, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.ShortTonPerHour, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.ShortTonPerHour)); + unitConverter.SetConversionFunction(MassFlowUnit.ShortTonPerHour, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.TonnePerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.TonnePerDay)); + unitConverter.SetConversionFunction(MassFlowUnit.TonnePerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.TonnePerHour, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.TonnePerHour)); + unitConverter.SetConversionFunction(MassFlowUnit.TonnePerHour, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlux.BaseUnit, MassFluxUnit.GramPerSecondPerSquareMeter, (q) => ((MassFlux)q).ToUnit(MassFluxUnit.GramPerSecondPerSquareMeter)); + unitConverter.SetConversionFunction(MassFluxUnit.GramPerSecondPerSquareMeter, MassFlux.BaseUnit, (q) => ((MassFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlux.BaseUnit, MassFlux.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.GramSquareCentimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.GramSquareCentimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.GramSquareCentimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.GramSquareDecimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.GramSquareDecimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.GramSquareDecimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.GramSquareMeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.GramSquareMeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.GramSquareMeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.GramSquareMillimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.GramSquareMillimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.GramSquareMillimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilogramSquareCentimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.KilogramSquareCentimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilogramSquareCentimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilogramSquareDecimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.KilogramSquareDecimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilogramSquareDecimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertia.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilogramSquareMillimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.KilogramSquareMillimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilogramSquareMillimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilotonneSquareCentimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.KilotonneSquareCentimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilotonneSquareCentimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilotonneSquareDecimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.KilotonneSquareDecimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilotonneSquareDecimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilotonneSquareMeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.KilotonneSquareMeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilotonneSquareMeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilotonneSquareMilimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.KilotonneSquareMilimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilotonneSquareMilimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MegatonneSquareCentimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.MegatonneSquareCentimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MegatonneSquareCentimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MegatonneSquareDecimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.MegatonneSquareDecimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MegatonneSquareDecimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MegatonneSquareMeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.MegatonneSquareMeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MegatonneSquareMeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MegatonneSquareMilimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.MegatonneSquareMilimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MegatonneSquareMilimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MilligramSquareCentimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.MilligramSquareCentimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MilligramSquareCentimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MilligramSquareDecimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.MilligramSquareDecimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MilligramSquareDecimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MilligramSquareMeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.MilligramSquareMeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MilligramSquareMeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MilligramSquareMillimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.MilligramSquareMillimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MilligramSquareMillimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.PoundSquareFoot, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.PoundSquareFoot)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.PoundSquareFoot, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.PoundSquareInch, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.PoundSquareInch)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.PoundSquareInch, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.SlugSquareFoot, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.SlugSquareFoot)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.SlugSquareFoot, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.SlugSquareInch, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.SlugSquareInch)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.SlugSquareInch, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.TonneSquareCentimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.TonneSquareCentimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.TonneSquareCentimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.TonneSquareDecimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.TonneSquareDecimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.TonneSquareDecimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.TonneSquareMeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.TonneSquareMeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.TonneSquareMeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.TonneSquareMilimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.TonneSquareMilimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.TonneSquareMilimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarEnergy.BaseUnit, MolarEnergy.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(MolarEnergy.BaseUnit, MolarEnergyUnit.KilojoulePerMole, (q) => ((MolarEnergy)q).ToUnit(MolarEnergyUnit.KilojoulePerMole)); + unitConverter.SetConversionFunction(MolarEnergyUnit.KilojoulePerMole, MolarEnergy.BaseUnit, (q) => ((MolarEnergy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarEnergy.BaseUnit, MolarEnergyUnit.MegajoulePerMole, (q) => ((MolarEnergy)q).ToUnit(MolarEnergyUnit.MegajoulePerMole)); + unitConverter.SetConversionFunction(MolarEnergyUnit.MegajoulePerMole, MolarEnergy.BaseUnit, (q) => ((MolarEnergy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarEntropy.BaseUnit, MolarEntropy.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(MolarEntropy.BaseUnit, MolarEntropyUnit.KilojoulePerMoleKelvin, (q) => ((MolarEntropy)q).ToUnit(MolarEntropyUnit.KilojoulePerMoleKelvin)); + unitConverter.SetConversionFunction(MolarEntropyUnit.KilojoulePerMoleKelvin, MolarEntropy.BaseUnit, (q) => ((MolarEntropy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarEntropy.BaseUnit, MolarEntropyUnit.MegajoulePerMoleKelvin, (q) => ((MolarEntropy)q).ToUnit(MolarEntropyUnit.MegajoulePerMoleKelvin)); + unitConverter.SetConversionFunction(MolarEntropyUnit.MegajoulePerMoleKelvin, MolarEntropy.BaseUnit, (q) => ((MolarEntropy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Molarity.BaseUnit, MolarityUnit.CentimolesPerLiter, (q) => ((Molarity)q).ToUnit(MolarityUnit.CentimolesPerLiter)); + unitConverter.SetConversionFunction(MolarityUnit.CentimolesPerLiter, Molarity.BaseUnit, (q) => ((Molarity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Molarity.BaseUnit, MolarityUnit.DecimolesPerLiter, (q) => ((Molarity)q).ToUnit(MolarityUnit.DecimolesPerLiter)); + unitConverter.SetConversionFunction(MolarityUnit.DecimolesPerLiter, Molarity.BaseUnit, (q) => ((Molarity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Molarity.BaseUnit, MolarityUnit.MicromolesPerLiter, (q) => ((Molarity)q).ToUnit(MolarityUnit.MicromolesPerLiter)); + unitConverter.SetConversionFunction(MolarityUnit.MicromolesPerLiter, Molarity.BaseUnit, (q) => ((Molarity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Molarity.BaseUnit, MolarityUnit.MillimolesPerLiter, (q) => ((Molarity)q).ToUnit(MolarityUnit.MillimolesPerLiter)); + unitConverter.SetConversionFunction(MolarityUnit.MillimolesPerLiter, Molarity.BaseUnit, (q) => ((Molarity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Molarity.BaseUnit, Molarity.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Molarity.BaseUnit, MolarityUnit.MolesPerLiter, (q) => ((Molarity)q).ToUnit(MolarityUnit.MolesPerLiter)); + unitConverter.SetConversionFunction(MolarityUnit.MolesPerLiter, Molarity.BaseUnit, (q) => ((Molarity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Molarity.BaseUnit, MolarityUnit.NanomolesPerLiter, (q) => ((Molarity)q).ToUnit(MolarityUnit.NanomolesPerLiter)); + unitConverter.SetConversionFunction(MolarityUnit.NanomolesPerLiter, Molarity.BaseUnit, (q) => ((Molarity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Molarity.BaseUnit, MolarityUnit.PicomolesPerLiter, (q) => ((Molarity)q).ToUnit(MolarityUnit.PicomolesPerLiter)); + unitConverter.SetConversionFunction(MolarityUnit.PicomolesPerLiter, Molarity.BaseUnit, (q) => ((Molarity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.CentigramPerMole, (q) => ((MolarMass)q).ToUnit(MolarMassUnit.CentigramPerMole)); + unitConverter.SetConversionFunction(MolarMassUnit.CentigramPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.DecagramPerMole, (q) => ((MolarMass)q).ToUnit(MolarMassUnit.DecagramPerMole)); + unitConverter.SetConversionFunction(MolarMassUnit.DecagramPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.DecigramPerMole, (q) => ((MolarMass)q).ToUnit(MolarMassUnit.DecigramPerMole)); + unitConverter.SetConversionFunction(MolarMassUnit.DecigramPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.GramPerMole, (q) => ((MolarMass)q).ToUnit(MolarMassUnit.GramPerMole)); + unitConverter.SetConversionFunction(MolarMassUnit.GramPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.HectogramPerMole, (q) => ((MolarMass)q).ToUnit(MolarMassUnit.HectogramPerMole)); + unitConverter.SetConversionFunction(MolarMassUnit.HectogramPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMass.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.KilopoundPerMole, (q) => ((MolarMass)q).ToUnit(MolarMassUnit.KilopoundPerMole)); + unitConverter.SetConversionFunction(MolarMassUnit.KilopoundPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.MegapoundPerMole, (q) => ((MolarMass)q).ToUnit(MolarMassUnit.MegapoundPerMole)); + unitConverter.SetConversionFunction(MolarMassUnit.MegapoundPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.MicrogramPerMole, (q) => ((MolarMass)q).ToUnit(MolarMassUnit.MicrogramPerMole)); + unitConverter.SetConversionFunction(MolarMassUnit.MicrogramPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.MilligramPerMole, (q) => ((MolarMass)q).ToUnit(MolarMassUnit.MilligramPerMole)); + unitConverter.SetConversionFunction(MolarMassUnit.MilligramPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.NanogramPerMole, (q) => ((MolarMass)q).ToUnit(MolarMassUnit.NanogramPerMole)); + unitConverter.SetConversionFunction(MolarMassUnit.NanogramPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.PoundPerMole, (q) => ((MolarMass)q).ToUnit(MolarMassUnit.PoundPerMole)); + unitConverter.SetConversionFunction(MolarMassUnit.PoundPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Permeability.BaseUnit, Permeability.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Permittivity.BaseUnit, Permittivity.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.BoilerHorsepower, (q) => ((Power)q).ToUnit(PowerUnit.BoilerHorsepower)); + unitConverter.SetConversionFunction(PowerUnit.BoilerHorsepower, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.BritishThermalUnitPerHour, (q) => ((Power)q).ToUnit(PowerUnit.BritishThermalUnitPerHour)); + unitConverter.SetConversionFunction(PowerUnit.BritishThermalUnitPerHour, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Decawatt, (q) => ((Power)q).ToUnit(PowerUnit.Decawatt)); + unitConverter.SetConversionFunction(PowerUnit.Decawatt, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Deciwatt, (q) => ((Power)q).ToUnit(PowerUnit.Deciwatt)); + unitConverter.SetConversionFunction(PowerUnit.Deciwatt, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.ElectricalHorsepower, (q) => ((Power)q).ToUnit(PowerUnit.ElectricalHorsepower)); + unitConverter.SetConversionFunction(PowerUnit.ElectricalHorsepower, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Femtowatt, (q) => ((Power)q).ToUnit(PowerUnit.Femtowatt)); + unitConverter.SetConversionFunction(PowerUnit.Femtowatt, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Gigawatt, (q) => ((Power)q).ToUnit(PowerUnit.Gigawatt)); + unitConverter.SetConversionFunction(PowerUnit.Gigawatt, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.HydraulicHorsepower, (q) => ((Power)q).ToUnit(PowerUnit.HydraulicHorsepower)); + unitConverter.SetConversionFunction(PowerUnit.HydraulicHorsepower, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.KilobritishThermalUnitPerHour, (q) => ((Power)q).ToUnit(PowerUnit.KilobritishThermalUnitPerHour)); + unitConverter.SetConversionFunction(PowerUnit.KilobritishThermalUnitPerHour, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Kilowatt, (q) => ((Power)q).ToUnit(PowerUnit.Kilowatt)); + unitConverter.SetConversionFunction(PowerUnit.Kilowatt, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.MechanicalHorsepower, (q) => ((Power)q).ToUnit(PowerUnit.MechanicalHorsepower)); + unitConverter.SetConversionFunction(PowerUnit.MechanicalHorsepower, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Megawatt, (q) => ((Power)q).ToUnit(PowerUnit.Megawatt)); + unitConverter.SetConversionFunction(PowerUnit.Megawatt, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.MetricHorsepower, (q) => ((Power)q).ToUnit(PowerUnit.MetricHorsepower)); + unitConverter.SetConversionFunction(PowerUnit.MetricHorsepower, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Microwatt, (q) => ((Power)q).ToUnit(PowerUnit.Microwatt)); + unitConverter.SetConversionFunction(PowerUnit.Microwatt, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Milliwatt, (q) => ((Power)q).ToUnit(PowerUnit.Milliwatt)); + unitConverter.SetConversionFunction(PowerUnit.Milliwatt, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Nanowatt, (q) => ((Power)q).ToUnit(PowerUnit.Nanowatt)); + unitConverter.SetConversionFunction(PowerUnit.Nanowatt, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Petawatt, (q) => ((Power)q).ToUnit(PowerUnit.Petawatt)); + unitConverter.SetConversionFunction(PowerUnit.Petawatt, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Picowatt, (q) => ((Power)q).ToUnit(PowerUnit.Picowatt)); + unitConverter.SetConversionFunction(PowerUnit.Picowatt, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Terawatt, (q) => ((Power)q).ToUnit(PowerUnit.Terawatt)); + unitConverter.SetConversionFunction(PowerUnit.Terawatt, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, Power.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.DecawattPerCubicFoot, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.DecawattPerCubicFoot)); + unitConverter.SetConversionFunction(PowerDensityUnit.DecawattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.DecawattPerCubicInch, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.DecawattPerCubicInch)); + unitConverter.SetConversionFunction(PowerDensityUnit.DecawattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.DecawattPerCubicMeter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.DecawattPerCubicMeter)); + unitConverter.SetConversionFunction(PowerDensityUnit.DecawattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.DecawattPerLiter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.DecawattPerLiter)); + unitConverter.SetConversionFunction(PowerDensityUnit.DecawattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.DeciwattPerCubicFoot, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.DeciwattPerCubicFoot)); + unitConverter.SetConversionFunction(PowerDensityUnit.DeciwattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.DeciwattPerCubicInch, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.DeciwattPerCubicInch)); + unitConverter.SetConversionFunction(PowerDensityUnit.DeciwattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.DeciwattPerCubicMeter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.DeciwattPerCubicMeter)); + unitConverter.SetConversionFunction(PowerDensityUnit.DeciwattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.DeciwattPerLiter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.DeciwattPerLiter)); + unitConverter.SetConversionFunction(PowerDensityUnit.DeciwattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.GigawattPerCubicFoot, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.GigawattPerCubicFoot)); + unitConverter.SetConversionFunction(PowerDensityUnit.GigawattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.GigawattPerCubicInch, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.GigawattPerCubicInch)); + unitConverter.SetConversionFunction(PowerDensityUnit.GigawattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.GigawattPerCubicMeter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.GigawattPerCubicMeter)); + unitConverter.SetConversionFunction(PowerDensityUnit.GigawattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.GigawattPerLiter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.GigawattPerLiter)); + unitConverter.SetConversionFunction(PowerDensityUnit.GigawattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.KilowattPerCubicFoot, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.KilowattPerCubicFoot)); + unitConverter.SetConversionFunction(PowerDensityUnit.KilowattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.KilowattPerCubicInch, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.KilowattPerCubicInch)); + unitConverter.SetConversionFunction(PowerDensityUnit.KilowattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.KilowattPerCubicMeter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.KilowattPerCubicMeter)); + unitConverter.SetConversionFunction(PowerDensityUnit.KilowattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.KilowattPerLiter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.KilowattPerLiter)); + unitConverter.SetConversionFunction(PowerDensityUnit.KilowattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MegawattPerCubicFoot, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MegawattPerCubicFoot)); + unitConverter.SetConversionFunction(PowerDensityUnit.MegawattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MegawattPerCubicInch, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MegawattPerCubicInch)); + unitConverter.SetConversionFunction(PowerDensityUnit.MegawattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MegawattPerCubicMeter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MegawattPerCubicMeter)); + unitConverter.SetConversionFunction(PowerDensityUnit.MegawattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MegawattPerLiter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MegawattPerLiter)); + unitConverter.SetConversionFunction(PowerDensityUnit.MegawattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MicrowattPerCubicFoot, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MicrowattPerCubicFoot)); + unitConverter.SetConversionFunction(PowerDensityUnit.MicrowattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MicrowattPerCubicInch, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MicrowattPerCubicInch)); + unitConverter.SetConversionFunction(PowerDensityUnit.MicrowattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MicrowattPerCubicMeter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MicrowattPerCubicMeter)); + unitConverter.SetConversionFunction(PowerDensityUnit.MicrowattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MicrowattPerLiter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MicrowattPerLiter)); + unitConverter.SetConversionFunction(PowerDensityUnit.MicrowattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MilliwattPerCubicFoot, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MilliwattPerCubicFoot)); + unitConverter.SetConversionFunction(PowerDensityUnit.MilliwattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MilliwattPerCubicInch, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MilliwattPerCubicInch)); + unitConverter.SetConversionFunction(PowerDensityUnit.MilliwattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MilliwattPerCubicMeter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MilliwattPerCubicMeter)); + unitConverter.SetConversionFunction(PowerDensityUnit.MilliwattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MilliwattPerLiter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MilliwattPerLiter)); + unitConverter.SetConversionFunction(PowerDensityUnit.MilliwattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.NanowattPerCubicFoot, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.NanowattPerCubicFoot)); + unitConverter.SetConversionFunction(PowerDensityUnit.NanowattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.NanowattPerCubicInch, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.NanowattPerCubicInch)); + unitConverter.SetConversionFunction(PowerDensityUnit.NanowattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.NanowattPerCubicMeter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.NanowattPerCubicMeter)); + unitConverter.SetConversionFunction(PowerDensityUnit.NanowattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.NanowattPerLiter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.NanowattPerLiter)); + unitConverter.SetConversionFunction(PowerDensityUnit.NanowattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.PicowattPerCubicFoot, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.PicowattPerCubicFoot)); + unitConverter.SetConversionFunction(PowerDensityUnit.PicowattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.PicowattPerCubicInch, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.PicowattPerCubicInch)); + unitConverter.SetConversionFunction(PowerDensityUnit.PicowattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.PicowattPerCubicMeter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.PicowattPerCubicMeter)); + unitConverter.SetConversionFunction(PowerDensityUnit.PicowattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.PicowattPerLiter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.PicowattPerLiter)); + unitConverter.SetConversionFunction(PowerDensityUnit.PicowattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.TerawattPerCubicFoot, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.TerawattPerCubicFoot)); + unitConverter.SetConversionFunction(PowerDensityUnit.TerawattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.TerawattPerCubicInch, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.TerawattPerCubicInch)); + unitConverter.SetConversionFunction(PowerDensityUnit.TerawattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.TerawattPerCubicMeter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.TerawattPerCubicMeter)); + unitConverter.SetConversionFunction(PowerDensityUnit.TerawattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.TerawattPerLiter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.TerawattPerLiter)); + unitConverter.SetConversionFunction(PowerDensityUnit.TerawattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.WattPerCubicFoot, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.WattPerCubicFoot)); + unitConverter.SetConversionFunction(PowerDensityUnit.WattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.WattPerCubicInch, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.WattPerCubicInch)); + unitConverter.SetConversionFunction(PowerDensityUnit.WattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensity.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.WattPerLiter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.WattPerLiter)); + unitConverter.SetConversionFunction(PowerDensityUnit.WattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerRatio.BaseUnit, PowerRatioUnit.DecibelMilliwatt, (q) => ((PowerRatio)q).ToUnit(PowerRatioUnit.DecibelMilliwatt)); + unitConverter.SetConversionFunction(PowerRatioUnit.DecibelMilliwatt, PowerRatio.BaseUnit, (q) => ((PowerRatio)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerRatio.BaseUnit, PowerRatio.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Atmosphere, (q) => ((Pressure)q).ToUnit(PressureUnit.Atmosphere)); + unitConverter.SetConversionFunction(PressureUnit.Atmosphere, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Bar, (q) => ((Pressure)q).ToUnit(PressureUnit.Bar)); + unitConverter.SetConversionFunction(PressureUnit.Bar, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Centibar, (q) => ((Pressure)q).ToUnit(PressureUnit.Centibar)); + unitConverter.SetConversionFunction(PressureUnit.Centibar, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Decapascal, (q) => ((Pressure)q).ToUnit(PressureUnit.Decapascal)); + unitConverter.SetConversionFunction(PressureUnit.Decapascal, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Decibar, (q) => ((Pressure)q).ToUnit(PressureUnit.Decibar)); + unitConverter.SetConversionFunction(PressureUnit.Decibar, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.DynePerSquareCentimeter, (q) => ((Pressure)q).ToUnit(PressureUnit.DynePerSquareCentimeter)); + unitConverter.SetConversionFunction(PressureUnit.DynePerSquareCentimeter, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.FootOfHead, (q) => ((Pressure)q).ToUnit(PressureUnit.FootOfHead)); + unitConverter.SetConversionFunction(PressureUnit.FootOfHead, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Gigapascal, (q) => ((Pressure)q).ToUnit(PressureUnit.Gigapascal)); + unitConverter.SetConversionFunction(PressureUnit.Gigapascal, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Hectopascal, (q) => ((Pressure)q).ToUnit(PressureUnit.Hectopascal)); + unitConverter.SetConversionFunction(PressureUnit.Hectopascal, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.InchOfMercury, (q) => ((Pressure)q).ToUnit(PressureUnit.InchOfMercury)); + unitConverter.SetConversionFunction(PressureUnit.InchOfMercury, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.InchOfWaterColumn, (q) => ((Pressure)q).ToUnit(PressureUnit.InchOfWaterColumn)); + unitConverter.SetConversionFunction(PressureUnit.InchOfWaterColumn, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Kilobar, (q) => ((Pressure)q).ToUnit(PressureUnit.Kilobar)); + unitConverter.SetConversionFunction(PressureUnit.Kilobar, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.KilogramForcePerSquareCentimeter, (q) => ((Pressure)q).ToUnit(PressureUnit.KilogramForcePerSquareCentimeter)); + unitConverter.SetConversionFunction(PressureUnit.KilogramForcePerSquareCentimeter, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.KilogramForcePerSquareMeter, (q) => ((Pressure)q).ToUnit(PressureUnit.KilogramForcePerSquareMeter)); + unitConverter.SetConversionFunction(PressureUnit.KilogramForcePerSquareMeter, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.KilogramForcePerSquareMillimeter, (q) => ((Pressure)q).ToUnit(PressureUnit.KilogramForcePerSquareMillimeter)); + unitConverter.SetConversionFunction(PressureUnit.KilogramForcePerSquareMillimeter, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.KilonewtonPerSquareCentimeter, (q) => ((Pressure)q).ToUnit(PressureUnit.KilonewtonPerSquareCentimeter)); + unitConverter.SetConversionFunction(PressureUnit.KilonewtonPerSquareCentimeter, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.KilonewtonPerSquareMeter, (q) => ((Pressure)q).ToUnit(PressureUnit.KilonewtonPerSquareMeter)); + unitConverter.SetConversionFunction(PressureUnit.KilonewtonPerSquareMeter, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.KilonewtonPerSquareMillimeter, (q) => ((Pressure)q).ToUnit(PressureUnit.KilonewtonPerSquareMillimeter)); + unitConverter.SetConversionFunction(PressureUnit.KilonewtonPerSquareMillimeter, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Kilopascal, (q) => ((Pressure)q).ToUnit(PressureUnit.Kilopascal)); + unitConverter.SetConversionFunction(PressureUnit.Kilopascal, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.KilopoundForcePerSquareFoot, (q) => ((Pressure)q).ToUnit(PressureUnit.KilopoundForcePerSquareFoot)); + unitConverter.SetConversionFunction(PressureUnit.KilopoundForcePerSquareFoot, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.KilopoundForcePerSquareInch, (q) => ((Pressure)q).ToUnit(PressureUnit.KilopoundForcePerSquareInch)); + unitConverter.SetConversionFunction(PressureUnit.KilopoundForcePerSquareInch, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Megabar, (q) => ((Pressure)q).ToUnit(PressureUnit.Megabar)); + unitConverter.SetConversionFunction(PressureUnit.Megabar, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.MeganewtonPerSquareMeter, (q) => ((Pressure)q).ToUnit(PressureUnit.MeganewtonPerSquareMeter)); + unitConverter.SetConversionFunction(PressureUnit.MeganewtonPerSquareMeter, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Megapascal, (q) => ((Pressure)q).ToUnit(PressureUnit.Megapascal)); + unitConverter.SetConversionFunction(PressureUnit.Megapascal, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.MeterOfHead, (q) => ((Pressure)q).ToUnit(PressureUnit.MeterOfHead)); + unitConverter.SetConversionFunction(PressureUnit.MeterOfHead, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Microbar, (q) => ((Pressure)q).ToUnit(PressureUnit.Microbar)); + unitConverter.SetConversionFunction(PressureUnit.Microbar, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Micropascal, (q) => ((Pressure)q).ToUnit(PressureUnit.Micropascal)); + unitConverter.SetConversionFunction(PressureUnit.Micropascal, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Millibar, (q) => ((Pressure)q).ToUnit(PressureUnit.Millibar)); + unitConverter.SetConversionFunction(PressureUnit.Millibar, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.MillimeterOfMercury, (q) => ((Pressure)q).ToUnit(PressureUnit.MillimeterOfMercury)); + unitConverter.SetConversionFunction(PressureUnit.MillimeterOfMercury, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Millipascal, (q) => ((Pressure)q).ToUnit(PressureUnit.Millipascal)); + unitConverter.SetConversionFunction(PressureUnit.Millipascal, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.NewtonPerSquareCentimeter, (q) => ((Pressure)q).ToUnit(PressureUnit.NewtonPerSquareCentimeter)); + unitConverter.SetConversionFunction(PressureUnit.NewtonPerSquareCentimeter, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.NewtonPerSquareMeter, (q) => ((Pressure)q).ToUnit(PressureUnit.NewtonPerSquareMeter)); + unitConverter.SetConversionFunction(PressureUnit.NewtonPerSquareMeter, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.NewtonPerSquareMillimeter, (q) => ((Pressure)q).ToUnit(PressureUnit.NewtonPerSquareMillimeter)); + unitConverter.SetConversionFunction(PressureUnit.NewtonPerSquareMillimeter, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, Pressure.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.PoundForcePerSquareFoot, (q) => ((Pressure)q).ToUnit(PressureUnit.PoundForcePerSquareFoot)); + unitConverter.SetConversionFunction(PressureUnit.PoundForcePerSquareFoot, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.PoundForcePerSquareInch, (q) => ((Pressure)q).ToUnit(PressureUnit.PoundForcePerSquareInch)); + unitConverter.SetConversionFunction(PressureUnit.PoundForcePerSquareInch, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.PoundPerInchSecondSquared, (q) => ((Pressure)q).ToUnit(PressureUnit.PoundPerInchSecondSquared)); + unitConverter.SetConversionFunction(PressureUnit.PoundPerInchSecondSquared, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.TechnicalAtmosphere, (q) => ((Pressure)q).ToUnit(PressureUnit.TechnicalAtmosphere)); + unitConverter.SetConversionFunction(PressureUnit.TechnicalAtmosphere, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.TonneForcePerSquareCentimeter, (q) => ((Pressure)q).ToUnit(PressureUnit.TonneForcePerSquareCentimeter)); + unitConverter.SetConversionFunction(PressureUnit.TonneForcePerSquareCentimeter, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.TonneForcePerSquareMeter, (q) => ((Pressure)q).ToUnit(PressureUnit.TonneForcePerSquareMeter)); + unitConverter.SetConversionFunction(PressureUnit.TonneForcePerSquareMeter, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.TonneForcePerSquareMillimeter, (q) => ((Pressure)q).ToUnit(PressureUnit.TonneForcePerSquareMillimeter)); + unitConverter.SetConversionFunction(PressureUnit.TonneForcePerSquareMillimeter, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Torr, (q) => ((Pressure)q).ToUnit(PressureUnit.Torr)); + unitConverter.SetConversionFunction(PressureUnit.Torr, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.AtmospherePerSecond, (q) => ((PressureChangeRate)q).ToUnit(PressureChangeRateUnit.AtmospherePerSecond)); + unitConverter.SetConversionFunction(PressureChangeRateUnit.AtmospherePerSecond, PressureChangeRate.BaseUnit, (q) => ((PressureChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.KilopascalPerMinute, (q) => ((PressureChangeRate)q).ToUnit(PressureChangeRateUnit.KilopascalPerMinute)); + unitConverter.SetConversionFunction(PressureChangeRateUnit.KilopascalPerMinute, PressureChangeRate.BaseUnit, (q) => ((PressureChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.KilopascalPerSecond, (q) => ((PressureChangeRate)q).ToUnit(PressureChangeRateUnit.KilopascalPerSecond)); + unitConverter.SetConversionFunction(PressureChangeRateUnit.KilopascalPerSecond, PressureChangeRate.BaseUnit, (q) => ((PressureChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.MegapascalPerMinute, (q) => ((PressureChangeRate)q).ToUnit(PressureChangeRateUnit.MegapascalPerMinute)); + unitConverter.SetConversionFunction(PressureChangeRateUnit.MegapascalPerMinute, PressureChangeRate.BaseUnit, (q) => ((PressureChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.MegapascalPerSecond, (q) => ((PressureChangeRate)q).ToUnit(PressureChangeRateUnit.MegapascalPerSecond)); + unitConverter.SetConversionFunction(PressureChangeRateUnit.MegapascalPerSecond, PressureChangeRate.BaseUnit, (q) => ((PressureChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.PascalPerMinute, (q) => ((PressureChangeRate)q).ToUnit(PressureChangeRateUnit.PascalPerMinute)); + unitConverter.SetConversionFunction(PressureChangeRateUnit.PascalPerMinute, PressureChangeRate.BaseUnit, (q) => ((PressureChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRate.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Ratio.BaseUnit, Ratio.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Ratio.BaseUnit, RatioUnit.PartPerBillion, (q) => ((Ratio)q).ToUnit(RatioUnit.PartPerBillion)); + unitConverter.SetConversionFunction(RatioUnit.PartPerBillion, Ratio.BaseUnit, (q) => ((Ratio)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Ratio.BaseUnit, RatioUnit.PartPerMillion, (q) => ((Ratio)q).ToUnit(RatioUnit.PartPerMillion)); + unitConverter.SetConversionFunction(RatioUnit.PartPerMillion, Ratio.BaseUnit, (q) => ((Ratio)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Ratio.BaseUnit, RatioUnit.PartPerThousand, (q) => ((Ratio)q).ToUnit(RatioUnit.PartPerThousand)); + unitConverter.SetConversionFunction(RatioUnit.PartPerThousand, Ratio.BaseUnit, (q) => ((Ratio)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Ratio.BaseUnit, RatioUnit.PartPerTrillion, (q) => ((Ratio)q).ToUnit(RatioUnit.PartPerTrillion)); + unitConverter.SetConversionFunction(RatioUnit.PartPerTrillion, Ratio.BaseUnit, (q) => ((Ratio)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Ratio.BaseUnit, RatioUnit.Percent, (q) => ((Ratio)q).ToUnit(RatioUnit.Percent)); + unitConverter.SetConversionFunction(RatioUnit.Percent, Ratio.BaseUnit, (q) => ((Ratio)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ReactiveEnergy.BaseUnit, ReactiveEnergyUnit.KilovoltampereReactiveHour, (q) => ((ReactiveEnergy)q).ToUnit(ReactiveEnergyUnit.KilovoltampereReactiveHour)); + unitConverter.SetConversionFunction(ReactiveEnergyUnit.KilovoltampereReactiveHour, ReactiveEnergy.BaseUnit, (q) => ((ReactiveEnergy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ReactiveEnergy.BaseUnit, ReactiveEnergyUnit.MegavoltampereReactiveHour, (q) => ((ReactiveEnergy)q).ToUnit(ReactiveEnergyUnit.MegavoltampereReactiveHour)); + unitConverter.SetConversionFunction(ReactiveEnergyUnit.MegavoltampereReactiveHour, ReactiveEnergy.BaseUnit, (q) => ((ReactiveEnergy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ReactiveEnergy.BaseUnit, ReactiveEnergy.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(ReactivePower.BaseUnit, ReactivePowerUnit.GigavoltampereReactive, (q) => ((ReactivePower)q).ToUnit(ReactivePowerUnit.GigavoltampereReactive)); + unitConverter.SetConversionFunction(ReactivePowerUnit.GigavoltampereReactive, ReactivePower.BaseUnit, (q) => ((ReactivePower)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ReactivePower.BaseUnit, ReactivePowerUnit.KilovoltampereReactive, (q) => ((ReactivePower)q).ToUnit(ReactivePowerUnit.KilovoltampereReactive)); + unitConverter.SetConversionFunction(ReactivePowerUnit.KilovoltampereReactive, ReactivePower.BaseUnit, (q) => ((ReactivePower)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ReactivePower.BaseUnit, ReactivePowerUnit.MegavoltampereReactive, (q) => ((ReactivePower)q).ToUnit(ReactivePowerUnit.MegavoltampereReactive)); + unitConverter.SetConversionFunction(ReactivePowerUnit.MegavoltampereReactive, ReactivePower.BaseUnit, (q) => ((ReactivePower)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ReactivePower.BaseUnit, ReactivePower.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(RotationalAcceleration.BaseUnit, RotationalAccelerationUnit.DegreePerSecondSquared, (q) => ((RotationalAcceleration)q).ToUnit(RotationalAccelerationUnit.DegreePerSecondSquared)); + unitConverter.SetConversionFunction(RotationalAccelerationUnit.DegreePerSecondSquared, RotationalAcceleration.BaseUnit, (q) => ((RotationalAcceleration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalAcceleration.BaseUnit, RotationalAcceleration.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(RotationalAcceleration.BaseUnit, RotationalAccelerationUnit.RevolutionPerMinutePerSecond, (q) => ((RotationalAcceleration)q).ToUnit(RotationalAccelerationUnit.RevolutionPerMinutePerSecond)); + unitConverter.SetConversionFunction(RotationalAccelerationUnit.RevolutionPerMinutePerSecond, RotationalAcceleration.BaseUnit, (q) => ((RotationalAcceleration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.CentiradianPerSecond, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.CentiradianPerSecond)); + unitConverter.SetConversionFunction(RotationalSpeedUnit.CentiradianPerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.DeciradianPerSecond, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.DeciradianPerSecond)); + unitConverter.SetConversionFunction(RotationalSpeedUnit.DeciradianPerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.DegreePerMinute, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.DegreePerMinute)); + unitConverter.SetConversionFunction(RotationalSpeedUnit.DegreePerMinute, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.DegreePerSecond, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.DegreePerSecond)); + unitConverter.SetConversionFunction(RotationalSpeedUnit.DegreePerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.MicrodegreePerSecond, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.MicrodegreePerSecond)); + unitConverter.SetConversionFunction(RotationalSpeedUnit.MicrodegreePerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.MicroradianPerSecond, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.MicroradianPerSecond)); + unitConverter.SetConversionFunction(RotationalSpeedUnit.MicroradianPerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.MillidegreePerSecond, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.MillidegreePerSecond)); + unitConverter.SetConversionFunction(RotationalSpeedUnit.MillidegreePerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.MilliradianPerSecond, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.MilliradianPerSecond)); + unitConverter.SetConversionFunction(RotationalSpeedUnit.MilliradianPerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.NanodegreePerSecond, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.NanodegreePerSecond)); + unitConverter.SetConversionFunction(RotationalSpeedUnit.NanodegreePerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.NanoradianPerSecond, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.NanoradianPerSecond)); + unitConverter.SetConversionFunction(RotationalSpeedUnit.NanoradianPerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeed.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.RevolutionPerMinute, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.RevolutionPerMinute)); + unitConverter.SetConversionFunction(RotationalSpeedUnit.RevolutionPerMinute, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.RevolutionPerSecond, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.RevolutionPerSecond)); + unitConverter.SetConversionFunction(RotationalSpeedUnit.RevolutionPerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.KilonewtonMeterPerRadian, (q) => ((RotationalStiffness)q).ToUnit(RotationalStiffnessUnit.KilonewtonMeterPerRadian)); + unitConverter.SetConversionFunction(RotationalStiffnessUnit.KilonewtonMeterPerRadian, RotationalStiffness.BaseUnit, (q) => ((RotationalStiffness)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.MeganewtonMeterPerRadian, (q) => ((RotationalStiffness)q).ToUnit(RotationalStiffnessUnit.MeganewtonMeterPerRadian)); + unitConverter.SetConversionFunction(RotationalStiffnessUnit.MeganewtonMeterPerRadian, RotationalStiffness.BaseUnit, (q) => ((RotationalStiffness)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalStiffness.BaseUnit, RotationalStiffness.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(RotationalStiffnessPerLength.BaseUnit, RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter, (q) => ((RotationalStiffnessPerLength)q).ToUnit(RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter)); + unitConverter.SetConversionFunction(RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter, RotationalStiffnessPerLength.BaseUnit, (q) => ((RotationalStiffnessPerLength)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalStiffnessPerLength.BaseUnit, RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter, (q) => ((RotationalStiffnessPerLength)q).ToUnit(RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter)); + unitConverter.SetConversionFunction(RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter, RotationalStiffnessPerLength.BaseUnit, (q) => ((RotationalStiffnessPerLength)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalStiffnessPerLength.BaseUnit, RotationalStiffnessPerLength.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(SolidAngle.BaseUnit, SolidAngle.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergyUnit.BtuPerPound, (q) => ((SpecificEnergy)q).ToUnit(SpecificEnergyUnit.BtuPerPound)); + unitConverter.SetConversionFunction(SpecificEnergyUnit.BtuPerPound, SpecificEnergy.BaseUnit, (q) => ((SpecificEnergy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergyUnit.CaloriePerGram, (q) => ((SpecificEnergy)q).ToUnit(SpecificEnergyUnit.CaloriePerGram)); + unitConverter.SetConversionFunction(SpecificEnergyUnit.CaloriePerGram, SpecificEnergy.BaseUnit, (q) => ((SpecificEnergy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergy.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergyUnit.KilocaloriePerGram, (q) => ((SpecificEnergy)q).ToUnit(SpecificEnergyUnit.KilocaloriePerGram)); + unitConverter.SetConversionFunction(SpecificEnergyUnit.KilocaloriePerGram, SpecificEnergy.BaseUnit, (q) => ((SpecificEnergy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergyUnit.KilojoulePerKilogram, (q) => ((SpecificEnergy)q).ToUnit(SpecificEnergyUnit.KilojoulePerKilogram)); + unitConverter.SetConversionFunction(SpecificEnergyUnit.KilojoulePerKilogram, SpecificEnergy.BaseUnit, (q) => ((SpecificEnergy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergyUnit.KilowattHourPerKilogram, (q) => ((SpecificEnergy)q).ToUnit(SpecificEnergyUnit.KilowattHourPerKilogram)); + unitConverter.SetConversionFunction(SpecificEnergyUnit.KilowattHourPerKilogram, SpecificEnergy.BaseUnit, (q) => ((SpecificEnergy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergyUnit.MegajoulePerKilogram, (q) => ((SpecificEnergy)q).ToUnit(SpecificEnergyUnit.MegajoulePerKilogram)); + unitConverter.SetConversionFunction(SpecificEnergyUnit.MegajoulePerKilogram, SpecificEnergy.BaseUnit, (q) => ((SpecificEnergy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergyUnit.MegawattHourPerKilogram, (q) => ((SpecificEnergy)q).ToUnit(SpecificEnergyUnit.MegawattHourPerKilogram)); + unitConverter.SetConversionFunction(SpecificEnergyUnit.MegawattHourPerKilogram, SpecificEnergy.BaseUnit, (q) => ((SpecificEnergy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergyUnit.WattHourPerKilogram, (q) => ((SpecificEnergy)q).ToUnit(SpecificEnergyUnit.WattHourPerKilogram)); + unitConverter.SetConversionFunction(SpecificEnergyUnit.WattHourPerKilogram, SpecificEnergy.BaseUnit, (q) => ((SpecificEnergy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificEntropy.BaseUnit, SpecificEntropyUnit.CaloriePerGramKelvin, (q) => ((SpecificEntropy)q).ToUnit(SpecificEntropyUnit.CaloriePerGramKelvin)); + unitConverter.SetConversionFunction(SpecificEntropyUnit.CaloriePerGramKelvin, SpecificEntropy.BaseUnit, (q) => ((SpecificEntropy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificEntropy.BaseUnit, SpecificEntropyUnit.JoulePerKilogramDegreeCelsius, (q) => ((SpecificEntropy)q).ToUnit(SpecificEntropyUnit.JoulePerKilogramDegreeCelsius)); + unitConverter.SetConversionFunction(SpecificEntropyUnit.JoulePerKilogramDegreeCelsius, SpecificEntropy.BaseUnit, (q) => ((SpecificEntropy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificEntropy.BaseUnit, SpecificEntropy.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(SpecificEntropy.BaseUnit, SpecificEntropyUnit.KilocaloriePerGramKelvin, (q) => ((SpecificEntropy)q).ToUnit(SpecificEntropyUnit.KilocaloriePerGramKelvin)); + unitConverter.SetConversionFunction(SpecificEntropyUnit.KilocaloriePerGramKelvin, SpecificEntropy.BaseUnit, (q) => ((SpecificEntropy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificEntropy.BaseUnit, SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius, (q) => ((SpecificEntropy)q).ToUnit(SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius)); + unitConverter.SetConversionFunction(SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius, SpecificEntropy.BaseUnit, (q) => ((SpecificEntropy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificEntropy.BaseUnit, SpecificEntropyUnit.KilojoulePerKilogramKelvin, (q) => ((SpecificEntropy)q).ToUnit(SpecificEntropyUnit.KilojoulePerKilogramKelvin)); + unitConverter.SetConversionFunction(SpecificEntropyUnit.KilojoulePerKilogramKelvin, SpecificEntropy.BaseUnit, (q) => ((SpecificEntropy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificEntropy.BaseUnit, SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius, (q) => ((SpecificEntropy)q).ToUnit(SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius)); + unitConverter.SetConversionFunction(SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius, SpecificEntropy.BaseUnit, (q) => ((SpecificEntropy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificEntropy.BaseUnit, SpecificEntropyUnit.MegajoulePerKilogramKelvin, (q) => ((SpecificEntropy)q).ToUnit(SpecificEntropyUnit.MegajoulePerKilogramKelvin)); + unitConverter.SetConversionFunction(SpecificEntropyUnit.MegajoulePerKilogramKelvin, SpecificEntropy.BaseUnit, (q) => ((SpecificEntropy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificVolume.BaseUnit, SpecificVolumeUnit.CubicFootPerPound, (q) => ((SpecificVolume)q).ToUnit(SpecificVolumeUnit.CubicFootPerPound)); + unitConverter.SetConversionFunction(SpecificVolumeUnit.CubicFootPerPound, SpecificVolume.BaseUnit, (q) => ((SpecificVolume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificVolume.BaseUnit, SpecificVolume.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(SpecificVolume.BaseUnit, SpecificVolumeUnit.MillicubicMeterPerKilogram, (q) => ((SpecificVolume)q).ToUnit(SpecificVolumeUnit.MillicubicMeterPerKilogram)); + unitConverter.SetConversionFunction(SpecificVolumeUnit.MillicubicMeterPerKilogram, SpecificVolume.BaseUnit, (q) => ((SpecificVolume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.KilogramForcePerCubicCentimeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.KilogramForcePerCubicCentimeter)); + unitConverter.SetConversionFunction(SpecificWeightUnit.KilogramForcePerCubicCentimeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.KilogramForcePerCubicMeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.KilogramForcePerCubicMeter)); + unitConverter.SetConversionFunction(SpecificWeightUnit.KilogramForcePerCubicMeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.KilogramForcePerCubicMillimeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.KilogramForcePerCubicMillimeter)); + unitConverter.SetConversionFunction(SpecificWeightUnit.KilogramForcePerCubicMillimeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.KilonewtonPerCubicCentimeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.KilonewtonPerCubicCentimeter)); + unitConverter.SetConversionFunction(SpecificWeightUnit.KilonewtonPerCubicCentimeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.KilonewtonPerCubicMeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.KilonewtonPerCubicMeter)); + unitConverter.SetConversionFunction(SpecificWeightUnit.KilonewtonPerCubicMeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.KilonewtonPerCubicMillimeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.KilonewtonPerCubicMillimeter)); + unitConverter.SetConversionFunction(SpecificWeightUnit.KilonewtonPerCubicMillimeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.KilopoundForcePerCubicFoot, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.KilopoundForcePerCubicFoot)); + unitConverter.SetConversionFunction(SpecificWeightUnit.KilopoundForcePerCubicFoot, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.KilopoundForcePerCubicInch, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.KilopoundForcePerCubicInch)); + unitConverter.SetConversionFunction(SpecificWeightUnit.KilopoundForcePerCubicInch, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.MeganewtonPerCubicMeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.MeganewtonPerCubicMeter)); + unitConverter.SetConversionFunction(SpecificWeightUnit.MeganewtonPerCubicMeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.NewtonPerCubicCentimeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.NewtonPerCubicCentimeter)); + unitConverter.SetConversionFunction(SpecificWeightUnit.NewtonPerCubicCentimeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeight.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.NewtonPerCubicMillimeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.NewtonPerCubicMillimeter)); + unitConverter.SetConversionFunction(SpecificWeightUnit.NewtonPerCubicMillimeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.PoundForcePerCubicFoot, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.PoundForcePerCubicFoot)); + unitConverter.SetConversionFunction(SpecificWeightUnit.PoundForcePerCubicFoot, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.PoundForcePerCubicInch, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.PoundForcePerCubicInch)); + unitConverter.SetConversionFunction(SpecificWeightUnit.PoundForcePerCubicInch, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.TonneForcePerCubicCentimeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.TonneForcePerCubicCentimeter)); + unitConverter.SetConversionFunction(SpecificWeightUnit.TonneForcePerCubicCentimeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.TonneForcePerCubicMeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.TonneForcePerCubicMeter)); + unitConverter.SetConversionFunction(SpecificWeightUnit.TonneForcePerCubicMeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.TonneForcePerCubicMillimeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.TonneForcePerCubicMillimeter)); + unitConverter.SetConversionFunction(SpecificWeightUnit.TonneForcePerCubicMillimeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.CentimeterPerHour, (q) => ((Speed)q).ToUnit(SpeedUnit.CentimeterPerHour)); + unitConverter.SetConversionFunction(SpeedUnit.CentimeterPerHour, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.CentimeterPerMinute, (q) => ((Speed)q).ToUnit(SpeedUnit.CentimeterPerMinute)); + unitConverter.SetConversionFunction(SpeedUnit.CentimeterPerMinute, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.CentimeterPerSecond, (q) => ((Speed)q).ToUnit(SpeedUnit.CentimeterPerSecond)); + unitConverter.SetConversionFunction(SpeedUnit.CentimeterPerSecond, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.DecimeterPerMinute, (q) => ((Speed)q).ToUnit(SpeedUnit.DecimeterPerMinute)); + unitConverter.SetConversionFunction(SpeedUnit.DecimeterPerMinute, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.DecimeterPerSecond, (q) => ((Speed)q).ToUnit(SpeedUnit.DecimeterPerSecond)); + unitConverter.SetConversionFunction(SpeedUnit.DecimeterPerSecond, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.FootPerHour, (q) => ((Speed)q).ToUnit(SpeedUnit.FootPerHour)); + unitConverter.SetConversionFunction(SpeedUnit.FootPerHour, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.FootPerMinute, (q) => ((Speed)q).ToUnit(SpeedUnit.FootPerMinute)); + unitConverter.SetConversionFunction(SpeedUnit.FootPerMinute, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.FootPerSecond, (q) => ((Speed)q).ToUnit(SpeedUnit.FootPerSecond)); + unitConverter.SetConversionFunction(SpeedUnit.FootPerSecond, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.InchPerHour, (q) => ((Speed)q).ToUnit(SpeedUnit.InchPerHour)); + unitConverter.SetConversionFunction(SpeedUnit.InchPerHour, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.InchPerMinute, (q) => ((Speed)q).ToUnit(SpeedUnit.InchPerMinute)); + unitConverter.SetConversionFunction(SpeedUnit.InchPerMinute, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.InchPerSecond, (q) => ((Speed)q).ToUnit(SpeedUnit.InchPerSecond)); + unitConverter.SetConversionFunction(SpeedUnit.InchPerSecond, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.KilometerPerHour, (q) => ((Speed)q).ToUnit(SpeedUnit.KilometerPerHour)); + unitConverter.SetConversionFunction(SpeedUnit.KilometerPerHour, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.KilometerPerMinute, (q) => ((Speed)q).ToUnit(SpeedUnit.KilometerPerMinute)); + unitConverter.SetConversionFunction(SpeedUnit.KilometerPerMinute, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.KilometerPerSecond, (q) => ((Speed)q).ToUnit(SpeedUnit.KilometerPerSecond)); + unitConverter.SetConversionFunction(SpeedUnit.KilometerPerSecond, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.Knot, (q) => ((Speed)q).ToUnit(SpeedUnit.Knot)); + unitConverter.SetConversionFunction(SpeedUnit.Knot, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.MeterPerHour, (q) => ((Speed)q).ToUnit(SpeedUnit.MeterPerHour)); + unitConverter.SetConversionFunction(SpeedUnit.MeterPerHour, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.MeterPerMinute, (q) => ((Speed)q).ToUnit(SpeedUnit.MeterPerMinute)); + unitConverter.SetConversionFunction(SpeedUnit.MeterPerMinute, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, Speed.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.MicrometerPerMinute, (q) => ((Speed)q).ToUnit(SpeedUnit.MicrometerPerMinute)); + unitConverter.SetConversionFunction(SpeedUnit.MicrometerPerMinute, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.MicrometerPerSecond, (q) => ((Speed)q).ToUnit(SpeedUnit.MicrometerPerSecond)); + unitConverter.SetConversionFunction(SpeedUnit.MicrometerPerSecond, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.MilePerHour, (q) => ((Speed)q).ToUnit(SpeedUnit.MilePerHour)); + unitConverter.SetConversionFunction(SpeedUnit.MilePerHour, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.MillimeterPerHour, (q) => ((Speed)q).ToUnit(SpeedUnit.MillimeterPerHour)); + unitConverter.SetConversionFunction(SpeedUnit.MillimeterPerHour, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.MillimeterPerMinute, (q) => ((Speed)q).ToUnit(SpeedUnit.MillimeterPerMinute)); + unitConverter.SetConversionFunction(SpeedUnit.MillimeterPerMinute, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.MillimeterPerSecond, (q) => ((Speed)q).ToUnit(SpeedUnit.MillimeterPerSecond)); + unitConverter.SetConversionFunction(SpeedUnit.MillimeterPerSecond, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.NanometerPerMinute, (q) => ((Speed)q).ToUnit(SpeedUnit.NanometerPerMinute)); + unitConverter.SetConversionFunction(SpeedUnit.NanometerPerMinute, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.NanometerPerSecond, (q) => ((Speed)q).ToUnit(SpeedUnit.NanometerPerSecond)); + unitConverter.SetConversionFunction(SpeedUnit.NanometerPerSecond, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.UsSurveyFootPerHour, (q) => ((Speed)q).ToUnit(SpeedUnit.UsSurveyFootPerHour)); + unitConverter.SetConversionFunction(SpeedUnit.UsSurveyFootPerHour, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.UsSurveyFootPerMinute, (q) => ((Speed)q).ToUnit(SpeedUnit.UsSurveyFootPerMinute)); + unitConverter.SetConversionFunction(SpeedUnit.UsSurveyFootPerMinute, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.UsSurveyFootPerSecond, (q) => ((Speed)q).ToUnit(SpeedUnit.UsSurveyFootPerSecond)); + unitConverter.SetConversionFunction(SpeedUnit.UsSurveyFootPerSecond, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.YardPerHour, (q) => ((Speed)q).ToUnit(SpeedUnit.YardPerHour)); + unitConverter.SetConversionFunction(SpeedUnit.YardPerHour, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.YardPerMinute, (q) => ((Speed)q).ToUnit(SpeedUnit.YardPerMinute)); + unitConverter.SetConversionFunction(SpeedUnit.YardPerMinute, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.YardPerSecond, (q) => ((Speed)q).ToUnit(SpeedUnit.YardPerSecond)); + unitConverter.SetConversionFunction(SpeedUnit.YardPerSecond, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Temperature.BaseUnit, TemperatureUnit.DegreeCelsius, (q) => ((Temperature)q).ToUnit(TemperatureUnit.DegreeCelsius)); + unitConverter.SetConversionFunction(TemperatureUnit.DegreeCelsius, Temperature.BaseUnit, (q) => ((Temperature)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Temperature.BaseUnit, TemperatureUnit.DegreeDelisle, (q) => ((Temperature)q).ToUnit(TemperatureUnit.DegreeDelisle)); + unitConverter.SetConversionFunction(TemperatureUnit.DegreeDelisle, Temperature.BaseUnit, (q) => ((Temperature)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Temperature.BaseUnit, TemperatureUnit.DegreeFahrenheit, (q) => ((Temperature)q).ToUnit(TemperatureUnit.DegreeFahrenheit)); + unitConverter.SetConversionFunction(TemperatureUnit.DegreeFahrenheit, Temperature.BaseUnit, (q) => ((Temperature)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Temperature.BaseUnit, TemperatureUnit.DegreeNewton, (q) => ((Temperature)q).ToUnit(TemperatureUnit.DegreeNewton)); + unitConverter.SetConversionFunction(TemperatureUnit.DegreeNewton, Temperature.BaseUnit, (q) => ((Temperature)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Temperature.BaseUnit, TemperatureUnit.DegreeRankine, (q) => ((Temperature)q).ToUnit(TemperatureUnit.DegreeRankine)); + unitConverter.SetConversionFunction(TemperatureUnit.DegreeRankine, Temperature.BaseUnit, (q) => ((Temperature)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Temperature.BaseUnit, TemperatureUnit.DegreeReaumur, (q) => ((Temperature)q).ToUnit(TemperatureUnit.DegreeReaumur)); + unitConverter.SetConversionFunction(TemperatureUnit.DegreeReaumur, Temperature.BaseUnit, (q) => ((Temperature)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Temperature.BaseUnit, TemperatureUnit.DegreeRoemer, (q) => ((Temperature)q).ToUnit(TemperatureUnit.DegreeRoemer)); + unitConverter.SetConversionFunction(TemperatureUnit.DegreeRoemer, Temperature.BaseUnit, (q) => ((Temperature)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Temperature.BaseUnit, Temperature.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond, (q) => ((TemperatureChangeRate)q).ToUnit(TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond)); + unitConverter.SetConversionFunction(TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond, (q) => ((TemperatureChangeRate)q).ToUnit(TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond)); + unitConverter.SetConversionFunction(TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond, (q) => ((TemperatureChangeRate)q).ToUnit(TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond)); + unitConverter.SetConversionFunction(TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.DegreeCelsiusPerMinute, (q) => ((TemperatureChangeRate)q).ToUnit(TemperatureChangeRateUnit.DegreeCelsiusPerMinute)); + unitConverter.SetConversionFunction(TemperatureChangeRateUnit.DegreeCelsiusPerMinute, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRate.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond, (q) => ((TemperatureChangeRate)q).ToUnit(TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond)); + unitConverter.SetConversionFunction(TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond, (q) => ((TemperatureChangeRate)q).ToUnit(TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond)); + unitConverter.SetConversionFunction(TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond, (q) => ((TemperatureChangeRate)q).ToUnit(TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond)); + unitConverter.SetConversionFunction(TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond, (q) => ((TemperatureChangeRate)q).ToUnit(TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond)); + unitConverter.SetConversionFunction(TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond, (q) => ((TemperatureChangeRate)q).ToUnit(TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond)); + unitConverter.SetConversionFunction(TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeCelsius, (q) => ((TemperatureDelta)q).ToUnit(TemperatureDeltaUnit.DegreeCelsius)); + unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeCelsius, TemperatureDelta.BaseUnit, (q) => ((TemperatureDelta)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeDelisle, (q) => ((TemperatureDelta)q).ToUnit(TemperatureDeltaUnit.DegreeDelisle)); + unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeDelisle, TemperatureDelta.BaseUnit, (q) => ((TemperatureDelta)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeFahrenheit, (q) => ((TemperatureDelta)q).ToUnit(TemperatureDeltaUnit.DegreeFahrenheit)); + unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeFahrenheit, TemperatureDelta.BaseUnit, (q) => ((TemperatureDelta)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeNewton, (q) => ((TemperatureDelta)q).ToUnit(TemperatureDeltaUnit.DegreeNewton)); + unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeNewton, TemperatureDelta.BaseUnit, (q) => ((TemperatureDelta)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeRankine, (q) => ((TemperatureDelta)q).ToUnit(TemperatureDeltaUnit.DegreeRankine)); + unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeRankine, TemperatureDelta.BaseUnit, (q) => ((TemperatureDelta)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeReaumur, (q) => ((TemperatureDelta)q).ToUnit(TemperatureDeltaUnit.DegreeReaumur)); + unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeReaumur, TemperatureDelta.BaseUnit, (q) => ((TemperatureDelta)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeRoemer, (q) => ((TemperatureDelta)q).ToUnit(TemperatureDeltaUnit.DegreeRoemer)); + unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeRoemer, TemperatureDelta.BaseUnit, (q) => ((TemperatureDelta)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureDelta.BaseUnit, TemperatureDelta.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(ThermalConductivity.BaseUnit, ThermalConductivityUnit.BtuPerHourFootFahrenheit, (q) => ((ThermalConductivity)q).ToUnit(ThermalConductivityUnit.BtuPerHourFootFahrenheit)); + unitConverter.SetConversionFunction(ThermalConductivityUnit.BtuPerHourFootFahrenheit, ThermalConductivity.BaseUnit, (q) => ((ThermalConductivity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ThermalConductivity.BaseUnit, ThermalConductivity.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(ThermalResistance.BaseUnit, ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu, (q) => ((ThermalResistance)q).ToUnit(ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu)); + unitConverter.SetConversionFunction(ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu, ThermalResistance.BaseUnit, (q) => ((ThermalResistance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ThermalResistance.BaseUnit, ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie, (q) => ((ThermalResistance)q).ToUnit(ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie)); + unitConverter.SetConversionFunction(ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie, ThermalResistance.BaseUnit, (q) => ((ThermalResistance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ThermalResistance.BaseUnit, ThermalResistanceUnit.SquareCentimeterKelvinPerWatt, (q) => ((ThermalResistance)q).ToUnit(ThermalResistanceUnit.SquareCentimeterKelvinPerWatt)); + unitConverter.SetConversionFunction(ThermalResistanceUnit.SquareCentimeterKelvinPerWatt, ThermalResistance.BaseUnit, (q) => ((ThermalResistance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ThermalResistance.BaseUnit, ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt, (q) => ((ThermalResistance)q).ToUnit(ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt)); + unitConverter.SetConversionFunction(ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt, ThermalResistance.BaseUnit, (q) => ((ThermalResistance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ThermalResistance.BaseUnit, ThermalResistance.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.KilogramForceCentimeter, (q) => ((Torque)q).ToUnit(TorqueUnit.KilogramForceCentimeter)); + unitConverter.SetConversionFunction(TorqueUnit.KilogramForceCentimeter, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.KilogramForceMeter, (q) => ((Torque)q).ToUnit(TorqueUnit.KilogramForceMeter)); + unitConverter.SetConversionFunction(TorqueUnit.KilogramForceMeter, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.KilogramForceMillimeter, (q) => ((Torque)q).ToUnit(TorqueUnit.KilogramForceMillimeter)); + unitConverter.SetConversionFunction(TorqueUnit.KilogramForceMillimeter, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.KilonewtonCentimeter, (q) => ((Torque)q).ToUnit(TorqueUnit.KilonewtonCentimeter)); + unitConverter.SetConversionFunction(TorqueUnit.KilonewtonCentimeter, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.KilonewtonMeter, (q) => ((Torque)q).ToUnit(TorqueUnit.KilonewtonMeter)); + unitConverter.SetConversionFunction(TorqueUnit.KilonewtonMeter, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.KilonewtonMillimeter, (q) => ((Torque)q).ToUnit(TorqueUnit.KilonewtonMillimeter)); + unitConverter.SetConversionFunction(TorqueUnit.KilonewtonMillimeter, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.KilopoundForceFoot, (q) => ((Torque)q).ToUnit(TorqueUnit.KilopoundForceFoot)); + unitConverter.SetConversionFunction(TorqueUnit.KilopoundForceFoot, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.KilopoundForceInch, (q) => ((Torque)q).ToUnit(TorqueUnit.KilopoundForceInch)); + unitConverter.SetConversionFunction(TorqueUnit.KilopoundForceInch, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.MeganewtonCentimeter, (q) => ((Torque)q).ToUnit(TorqueUnit.MeganewtonCentimeter)); + unitConverter.SetConversionFunction(TorqueUnit.MeganewtonCentimeter, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.MeganewtonMeter, (q) => ((Torque)q).ToUnit(TorqueUnit.MeganewtonMeter)); + unitConverter.SetConversionFunction(TorqueUnit.MeganewtonMeter, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.MeganewtonMillimeter, (q) => ((Torque)q).ToUnit(TorqueUnit.MeganewtonMillimeter)); + unitConverter.SetConversionFunction(TorqueUnit.MeganewtonMillimeter, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.MegapoundForceFoot, (q) => ((Torque)q).ToUnit(TorqueUnit.MegapoundForceFoot)); + unitConverter.SetConversionFunction(TorqueUnit.MegapoundForceFoot, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.MegapoundForceInch, (q) => ((Torque)q).ToUnit(TorqueUnit.MegapoundForceInch)); + unitConverter.SetConversionFunction(TorqueUnit.MegapoundForceInch, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.NewtonCentimeter, (q) => ((Torque)q).ToUnit(TorqueUnit.NewtonCentimeter)); + unitConverter.SetConversionFunction(TorqueUnit.NewtonCentimeter, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, Torque.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.NewtonMillimeter, (q) => ((Torque)q).ToUnit(TorqueUnit.NewtonMillimeter)); + unitConverter.SetConversionFunction(TorqueUnit.NewtonMillimeter, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.PoundForceFoot, (q) => ((Torque)q).ToUnit(TorqueUnit.PoundForceFoot)); + unitConverter.SetConversionFunction(TorqueUnit.PoundForceFoot, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.PoundForceInch, (q) => ((Torque)q).ToUnit(TorqueUnit.PoundForceInch)); + unitConverter.SetConversionFunction(TorqueUnit.PoundForceInch, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.TonneForceCentimeter, (q) => ((Torque)q).ToUnit(TorqueUnit.TonneForceCentimeter)); + unitConverter.SetConversionFunction(TorqueUnit.TonneForceCentimeter, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.TonneForceMeter, (q) => ((Torque)q).ToUnit(TorqueUnit.TonneForceMeter)); + unitConverter.SetConversionFunction(TorqueUnit.TonneForceMeter, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.TonneForceMillimeter, (q) => ((Torque)q).ToUnit(TorqueUnit.TonneForceMillimeter)); + unitConverter.SetConversionFunction(TorqueUnit.TonneForceMillimeter, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VitaminA.BaseUnit, VitaminA.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.AcreFoot, (q) => ((Volume)q).ToUnit(VolumeUnit.AcreFoot)); + unitConverter.SetConversionFunction(VolumeUnit.AcreFoot, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.AuTablespoon, (q) => ((Volume)q).ToUnit(VolumeUnit.AuTablespoon)); + unitConverter.SetConversionFunction(VolumeUnit.AuTablespoon, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.Centiliter, (q) => ((Volume)q).ToUnit(VolumeUnit.Centiliter)); + unitConverter.SetConversionFunction(VolumeUnit.Centiliter, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicCentimeter, (q) => ((Volume)q).ToUnit(VolumeUnit.CubicCentimeter)); + unitConverter.SetConversionFunction(VolumeUnit.CubicCentimeter, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicDecimeter, (q) => ((Volume)q).ToUnit(VolumeUnit.CubicDecimeter)); + unitConverter.SetConversionFunction(VolumeUnit.CubicDecimeter, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicFoot, (q) => ((Volume)q).ToUnit(VolumeUnit.CubicFoot)); + unitConverter.SetConversionFunction(VolumeUnit.CubicFoot, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicInch, (q) => ((Volume)q).ToUnit(VolumeUnit.CubicInch)); + unitConverter.SetConversionFunction(VolumeUnit.CubicInch, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicKilometer, (q) => ((Volume)q).ToUnit(VolumeUnit.CubicKilometer)); + unitConverter.SetConversionFunction(VolumeUnit.CubicKilometer, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, Volume.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicMicrometer, (q) => ((Volume)q).ToUnit(VolumeUnit.CubicMicrometer)); + unitConverter.SetConversionFunction(VolumeUnit.CubicMicrometer, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicMile, (q) => ((Volume)q).ToUnit(VolumeUnit.CubicMile)); + unitConverter.SetConversionFunction(VolumeUnit.CubicMile, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicMillimeter, (q) => ((Volume)q).ToUnit(VolumeUnit.CubicMillimeter)); + unitConverter.SetConversionFunction(VolumeUnit.CubicMillimeter, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicYard, (q) => ((Volume)q).ToUnit(VolumeUnit.CubicYard)); + unitConverter.SetConversionFunction(VolumeUnit.CubicYard, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.Deciliter, (q) => ((Volume)q).ToUnit(VolumeUnit.Deciliter)); + unitConverter.SetConversionFunction(VolumeUnit.Deciliter, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.HectocubicFoot, (q) => ((Volume)q).ToUnit(VolumeUnit.HectocubicFoot)); + unitConverter.SetConversionFunction(VolumeUnit.HectocubicFoot, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.HectocubicMeter, (q) => ((Volume)q).ToUnit(VolumeUnit.HectocubicMeter)); + unitConverter.SetConversionFunction(VolumeUnit.HectocubicMeter, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.Hectoliter, (q) => ((Volume)q).ToUnit(VolumeUnit.Hectoliter)); + unitConverter.SetConversionFunction(VolumeUnit.Hectoliter, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.ImperialBeerBarrel, (q) => ((Volume)q).ToUnit(VolumeUnit.ImperialBeerBarrel)); + unitConverter.SetConversionFunction(VolumeUnit.ImperialBeerBarrel, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.ImperialGallon, (q) => ((Volume)q).ToUnit(VolumeUnit.ImperialGallon)); + unitConverter.SetConversionFunction(VolumeUnit.ImperialGallon, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.ImperialOunce, (q) => ((Volume)q).ToUnit(VolumeUnit.ImperialOunce)); + unitConverter.SetConversionFunction(VolumeUnit.ImperialOunce, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.KilocubicFoot, (q) => ((Volume)q).ToUnit(VolumeUnit.KilocubicFoot)); + unitConverter.SetConversionFunction(VolumeUnit.KilocubicFoot, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.KilocubicMeter, (q) => ((Volume)q).ToUnit(VolumeUnit.KilocubicMeter)); + unitConverter.SetConversionFunction(VolumeUnit.KilocubicMeter, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.KiloimperialGallon, (q) => ((Volume)q).ToUnit(VolumeUnit.KiloimperialGallon)); + unitConverter.SetConversionFunction(VolumeUnit.KiloimperialGallon, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.Kiloliter, (q) => ((Volume)q).ToUnit(VolumeUnit.Kiloliter)); + unitConverter.SetConversionFunction(VolumeUnit.Kiloliter, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.KilousGallon, (q) => ((Volume)q).ToUnit(VolumeUnit.KilousGallon)); + unitConverter.SetConversionFunction(VolumeUnit.KilousGallon, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.Liter, (q) => ((Volume)q).ToUnit(VolumeUnit.Liter)); + unitConverter.SetConversionFunction(VolumeUnit.Liter, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.MegacubicFoot, (q) => ((Volume)q).ToUnit(VolumeUnit.MegacubicFoot)); + unitConverter.SetConversionFunction(VolumeUnit.MegacubicFoot, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.MegaimperialGallon, (q) => ((Volume)q).ToUnit(VolumeUnit.MegaimperialGallon)); + unitConverter.SetConversionFunction(VolumeUnit.MegaimperialGallon, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.Megaliter, (q) => ((Volume)q).ToUnit(VolumeUnit.Megaliter)); + unitConverter.SetConversionFunction(VolumeUnit.Megaliter, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.MegausGallon, (q) => ((Volume)q).ToUnit(VolumeUnit.MegausGallon)); + unitConverter.SetConversionFunction(VolumeUnit.MegausGallon, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.MetricCup, (q) => ((Volume)q).ToUnit(VolumeUnit.MetricCup)); + unitConverter.SetConversionFunction(VolumeUnit.MetricCup, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.MetricTeaspoon, (q) => ((Volume)q).ToUnit(VolumeUnit.MetricTeaspoon)); + unitConverter.SetConversionFunction(VolumeUnit.MetricTeaspoon, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.Microliter, (q) => ((Volume)q).ToUnit(VolumeUnit.Microliter)); + unitConverter.SetConversionFunction(VolumeUnit.Microliter, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.Milliliter, (q) => ((Volume)q).ToUnit(VolumeUnit.Milliliter)); + unitConverter.SetConversionFunction(VolumeUnit.Milliliter, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.OilBarrel, (q) => ((Volume)q).ToUnit(VolumeUnit.OilBarrel)); + unitConverter.SetConversionFunction(VolumeUnit.OilBarrel, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UkTablespoon, (q) => ((Volume)q).ToUnit(VolumeUnit.UkTablespoon)); + unitConverter.SetConversionFunction(VolumeUnit.UkTablespoon, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsBeerBarrel, (q) => ((Volume)q).ToUnit(VolumeUnit.UsBeerBarrel)); + unitConverter.SetConversionFunction(VolumeUnit.UsBeerBarrel, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsCustomaryCup, (q) => ((Volume)q).ToUnit(VolumeUnit.UsCustomaryCup)); + unitConverter.SetConversionFunction(VolumeUnit.UsCustomaryCup, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsGallon, (q) => ((Volume)q).ToUnit(VolumeUnit.UsGallon)); + unitConverter.SetConversionFunction(VolumeUnit.UsGallon, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsLegalCup, (q) => ((Volume)q).ToUnit(VolumeUnit.UsLegalCup)); + unitConverter.SetConversionFunction(VolumeUnit.UsLegalCup, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsOunce, (q) => ((Volume)q).ToUnit(VolumeUnit.UsOunce)); + unitConverter.SetConversionFunction(VolumeUnit.UsOunce, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsPint, (q) => ((Volume)q).ToUnit(VolumeUnit.UsPint)); + unitConverter.SetConversionFunction(VolumeUnit.UsPint, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsQuart, (q) => ((Volume)q).ToUnit(VolumeUnit.UsQuart)); + unitConverter.SetConversionFunction(VolumeUnit.UsQuart, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsTablespoon, (q) => ((Volume)q).ToUnit(VolumeUnit.UsTablespoon)); + unitConverter.SetConversionFunction(VolumeUnit.UsTablespoon, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsTeaspoon, (q) => ((Volume)q).ToUnit(VolumeUnit.UsTeaspoon)); + unitConverter.SetConversionFunction(VolumeUnit.UsTeaspoon, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.AcreFootPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.AcreFootPerDay)); + unitConverter.SetConversionFunction(VolumeFlowUnit.AcreFootPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.AcreFootPerHour, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.AcreFootPerHour)); + unitConverter.SetConversionFunction(VolumeFlowUnit.AcreFootPerHour, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.AcreFootPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.AcreFootPerMinute)); + unitConverter.SetConversionFunction(VolumeFlowUnit.AcreFootPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.AcreFootPerSecond, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.AcreFootPerSecond)); + unitConverter.SetConversionFunction(VolumeFlowUnit.AcreFootPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CentiliterPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CentiliterPerDay)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CentiliterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CentiliterPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CentiliterPerMinute)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CentiliterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicDecimeterPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicDecimeterPerMinute)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicDecimeterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicFootPerHour, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicFootPerHour)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicFootPerHour, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicFootPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicFootPerMinute)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicFootPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicFootPerSecond, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicFootPerSecond)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicFootPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicMeterPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicMeterPerDay)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMeterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicMeterPerHour, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicMeterPerHour)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMeterPerHour, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicMeterPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicMeterPerMinute)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMeterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlow.BaseUnit, (q) => q); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicMillimeterPerSecond, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicMillimeterPerSecond)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMillimeterPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicYardPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicYardPerDay)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicYardPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicYardPerHour, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicYardPerHour)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicYardPerHour, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicYardPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicYardPerMinute)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicYardPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicYardPerSecond, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicYardPerSecond)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicYardPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.DeciliterPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.DeciliterPerDay)); + unitConverter.SetConversionFunction(VolumeFlowUnit.DeciliterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.DeciliterPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.DeciliterPerMinute)); + unitConverter.SetConversionFunction(VolumeFlowUnit.DeciliterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.KiloliterPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.KiloliterPerDay)); + unitConverter.SetConversionFunction(VolumeFlowUnit.KiloliterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.KiloliterPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.KiloliterPerMinute)); + unitConverter.SetConversionFunction(VolumeFlowUnit.KiloliterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.KilousGallonPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.KilousGallonPerMinute)); + unitConverter.SetConversionFunction(VolumeFlowUnit.KilousGallonPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.LiterPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.LiterPerDay)); + unitConverter.SetConversionFunction(VolumeFlowUnit.LiterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.LiterPerHour, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.LiterPerHour)); + unitConverter.SetConversionFunction(VolumeFlowUnit.LiterPerHour, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.LiterPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.LiterPerMinute)); + unitConverter.SetConversionFunction(VolumeFlowUnit.LiterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.LiterPerSecond, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.LiterPerSecond)); + unitConverter.SetConversionFunction(VolumeFlowUnit.LiterPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.MegaliterPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.MegaliterPerDay)); + unitConverter.SetConversionFunction(VolumeFlowUnit.MegaliterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.MegaukGallonPerSecond, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.MegaukGallonPerSecond)); + unitConverter.SetConversionFunction(VolumeFlowUnit.MegaukGallonPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.MicroliterPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.MicroliterPerDay)); + unitConverter.SetConversionFunction(VolumeFlowUnit.MicroliterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.MicroliterPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.MicroliterPerMinute)); + unitConverter.SetConversionFunction(VolumeFlowUnit.MicroliterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.MilliliterPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.MilliliterPerDay)); + unitConverter.SetConversionFunction(VolumeFlowUnit.MilliliterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.MilliliterPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.MilliliterPerMinute)); + unitConverter.SetConversionFunction(VolumeFlowUnit.MilliliterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.MillionUsGallonsPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.MillionUsGallonsPerDay)); + unitConverter.SetConversionFunction(VolumeFlowUnit.MillionUsGallonsPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.NanoliterPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.NanoliterPerDay)); + unitConverter.SetConversionFunction(VolumeFlowUnit.NanoliterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.NanoliterPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.NanoliterPerMinute)); + unitConverter.SetConversionFunction(VolumeFlowUnit.NanoliterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.OilBarrelPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.OilBarrelPerDay)); + unitConverter.SetConversionFunction(VolumeFlowUnit.OilBarrelPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.OilBarrelPerHour, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.OilBarrelPerHour)); + unitConverter.SetConversionFunction(VolumeFlowUnit.OilBarrelPerHour, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.OilBarrelPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.OilBarrelPerMinute)); + unitConverter.SetConversionFunction(VolumeFlowUnit.OilBarrelPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.OilBarrelPerSecond, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.OilBarrelPerSecond)); + unitConverter.SetConversionFunction(VolumeFlowUnit.OilBarrelPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.UkGallonPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.UkGallonPerDay)); + unitConverter.SetConversionFunction(VolumeFlowUnit.UkGallonPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.UkGallonPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.UkGallonPerMinute)); + unitConverter.SetConversionFunction(VolumeFlowUnit.UkGallonPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.UkGallonPerSecond, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.UkGallonPerSecond)); + unitConverter.SetConversionFunction(VolumeFlowUnit.UkGallonPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.UsGallonPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.UsGallonPerDay)); + unitConverter.SetConversionFunction(VolumeFlowUnit.UsGallonPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.UsGallonPerHour, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.UsGallonPerHour)); + unitConverter.SetConversionFunction(VolumeFlowUnit.UsGallonPerHour, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.UsGallonPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.UsGallonPerMinute)); + unitConverter.SetConversionFunction(VolumeFlowUnit.UsGallonPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.UsGallonPerSecond, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.UsGallonPerSecond)); + unitConverter.SetConversionFunction(VolumeFlowUnit.UsGallonPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); +#endif + } + } +} diff --git a/UnitsNet/Scripts/GenerateUnits.ps1 b/UnitsNet/Scripts/GenerateUnits.ps1 index 1b305d79a5..b5ed73d507 100644 --- a/UnitsNet/Scripts/GenerateUnits.ps1 +++ b/UnitsNet/Scripts/GenerateUnits.ps1 @@ -69,6 +69,19 @@ function GenerateUnitType([Quantity]$quantity, $outDir) Write-Host -NoNewline "unit(OK) " } +function GenerateUnitConverterDefault($quantities, $outDir) +{ + Write-Host -NoNewline "UnitConverter.g.cs: " + $outFileName = "$outDir/UnitConverter.g.cs" + + GenerateUnitConverterDefaultSourceCode $quantities | Out-File -Encoding "UTF8" -Force $outFileName | Out-Null + if (!$?) { + Write-Host "(error) " + exit 1 + } + Write-Host "(OK) " +} + function GenerateUnitSystemDefault($quantities, $outDir) { Write-Host -NoNewline "UnitAbbreviationsCache.g.cs: " @@ -227,6 +240,7 @@ function Add-InheritedUnits([Quantity]$quantity, $quantities) { # Load external generator functions with same name as file . "$PSScriptRoot/Include-GenerateTemplates.ps1" +. "$PSScriptRoot/Include-GenerateUnitConverterDefaultSourceCode.ps1" . "$PSScriptRoot/Include-GenerateUnitSystemDefaultSourceCode.ps1" . "$PSScriptRoot/Include-GenerateQuantityTypeSourceCode.ps1" . "$PSScriptRoot/Include-GenerateQuantitySourceCodeNetFramework.ps1" @@ -309,6 +323,7 @@ foreach ($quantity in $quantities) { } Write-Host "" +GenerateUnitConverterDefault $quantities $unitSystemDir GenerateUnitSystemDefault $quantities $unitSystemDir GenerateQuantityType $quantities $unitSystemDir diff --git a/UnitsNet/Scripts/Include-GenerateQuantitySourceCodeNetFramework.ps1 b/UnitsNet/Scripts/Include-GenerateQuantitySourceCodeNetFramework.ps1 index d876ece7bb..799e99f592 100644 --- a/UnitsNet/Scripts/Include-GenerateQuantitySourceCodeNetFramework.ps1 +++ b/UnitsNet/Scripts/Include-GenerateQuantitySourceCodeNetFramework.ps1 @@ -957,13 +957,14 @@ function GenerateConversionMethods([GeneratorArgs]$genArgs) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private $valueType AsBaseUnit() + internal $quantityName AsBaseUnit() { switch(Unit) { "@; foreach ($unit in $units) { $func = $unit.FromUnitToBaseFunc.Replace("x", "_value");@" - case $unitEnumName.$($unit.SingularName): return $func; + case $unitEnumName.$($unit.SingularName): + return new $quantityName($func, BaseUnit); "@; }@" default: throw new NotImplementedException($"Can not convert {Unit} to base units."); @@ -975,7 +976,8 @@ function GenerateConversionMethods([GeneratorArgs]$genArgs) if(Unit == unit) return _value; - var baseUnitValue = AsBaseUnit(); + var asBaseUnit = AsBaseUnit(); + var baseUnitValue = asBaseUnit._value; switch(unit) { diff --git a/UnitsNet/Scripts/Include-GenerateUnitConverterDefaultSourceCode.ps1 b/UnitsNet/Scripts/Include-GenerateUnitConverterDefaultSourceCode.ps1 new file mode 100644 index 0000000000..6cc0ff73d6 --- /dev/null +++ b/UnitsNet/Scripts/Include-GenerateUnitConverterDefaultSourceCode.ps1 @@ -0,0 +1,85 @@ +function GenerateUnitConverterDefaultSourceCode($quantities) +{ +@" +//------------------------------------------------------------------------------ +// +// This code was generated by \generate-code.bat. +// +// Changes to this file will be lost when the code is regenerated. +// The build server regenerates the code before each build and a pre-build +// step will regenerate the code on each local build. +// +// See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units. +// +// Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities. +// Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities. +// +// +//------------------------------------------------------------------------------ + +// Copyright (c) 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). +// https://github.com/angularsen/UnitsNet +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +using System; +using UnitsNet.Units; + +// ReSharper disable RedundantCommaInArrayInitializer +// ReSharper disable once CheckNamespace + +namespace UnitsNet +{ + public sealed partial class UnitConverter + { + public static void RegisterDefaultConversions(UnitConverter unitConverter) + { +#if !WINDOWS_UWP +"@; +foreach ($quantity in $quantities) +{ + $quantityName = $quantity.Name; + $unitEnumName = "$quantityName" + "Unit"; + + foreach ($unit in $quantity.Units) + { + $enumValue = $unit.SingularName; + + if( $quantity.BaseUnit -eq $enumValue ) + { +@" + unitConverter.SetConversionFunction<$quantityName>($quantityName.BaseUnit, $quantityName.BaseUnit, (q) => q); +"@; + } + else + { +@" + unitConverter.SetConversionFunction<$quantityName>($quantityName.BaseUnit, $unitEnumName.$enumValue, (q) => (($quantityName)q).ToUnit($unitEnumName.$enumValue)); + unitConverter.SetConversionFunction<$quantityName>($unitEnumName.$enumValue, $quantityName.BaseUnit, (q) => (($quantityName)q).AsBaseUnit()); +"@; + } + } +} +@" +#endif + } + } +} +"@; +} diff --git a/UnitsNet/UnitConverter.cs b/UnitsNet/UnitConverter.cs index 09365c7f8f..ffee9e1339 100644 --- a/UnitsNet/UnitConverter.cs +++ b/UnitsNet/UnitConverter.cs @@ -35,14 +35,14 @@ namespace UnitsNet { - using FromToPair = ValueTuple; + using ConversionFunctionLookup = ValueTuple; - public delegate IQuantity ConversionFunction( IQuantity value ); + public delegate IQuantity ConversionFunction( IQuantity inputValue ); /// /// Convert between units of a quantity, such as converting from meters to centimeters of a given length. /// - public sealed class UnitConverter + public sealed partial class UnitConverter { public static UnitConverter Default { get; } @@ -50,36 +50,57 @@ public sealed class UnitConverter private static readonly string UnitTypeNamespace = typeof(LengthUnit).Namespace; private static readonly Assembly UnitsNetAssembly = typeof(Length).GetAssembly(); - private Dictionary conversionFunctions; + private Dictionary conversionFunctions; + + static UnitConverter() + { + Default = new UnitConverter(); + + RegisterDefaultConversions(Default); + } public UnitConverter() { - conversionFunctions = new Dictionary(); + conversionFunctions = new Dictionary(); } - public void AddConversionFunction( Enum from, Enum to, ConversionFunction conversionFunction ) +#if !WINDOWS_UWP + + public void SetConversionFunction( Enum from, Enum to, ConversionFunction conversionFunction ) where T : IQuantity { - var fromTo = new FromToPair( from, to ); - conversionFunctions.Add( fromTo, conversionFunction ); + SetConversionFunction( typeof(T), from, typeof( T ), to, conversionFunction ); } - public ConversionFunction GetConversionFunction( Enum from, Enum to ) + public void SetConversionFunction( Type fromType, Enum from, Type toType, Enum to, ConversionFunction conversionFunction ) { - var fromTo = new FromToPair( from, to ); - return conversionFunctions[ fromTo ]; + var conversionLookup = new ConversionFunctionLookup( fromType, from, toType, to ); + conversionFunctions[ conversionLookup ] = conversionFunction; } - public bool TryGetConversionFunction( Enum from, Enum to, out ConversionFunction conversionFunction ) + public ConversionFunction GetConversionFunction( Enum from, Enum to ) where T : IQuantity { - var fromTo = new FromToPair( from, to ); - return conversionFunctions.TryGetValue( fromTo, out conversionFunction ); + return GetConversionFunction( typeof( T ), from, typeof( T ), to ); } - static UnitConverter() + public ConversionFunction GetConversionFunction( Type fromType, Enum from, Type toType, Enum to ) { - Default = new UnitConverter(); + var conversionLookup = new ConversionFunctionLookup( fromType, from, toType, to ); + return conversionFunctions[ conversionLookup ]; } + public bool TryGetConversionFunction( Enum from, Enum to, out ConversionFunction conversionFunction ) where T : IQuantity + { + return TryGetConversionFunction( typeof( T ), from, typeof( T ), to, out conversionFunction ); + } + + public bool TryGetConversionFunction( Type fromType, Enum from, Type toType, Enum to, out ConversionFunction conversionFunction ) + { + var conversionLookup = new ConversionFunctionLookup( fromType, from, toType, to ); + return conversionFunctions.TryGetValue( conversionLookup, out conversionFunction ); + } + +#endif + /// /// Convert between any two quantity units by their names, such as converting a "Length" of N "Meter" to "Centimeter". /// This is particularly useful for creating things like a generated unit conversion UI, From a9beb6eb4365606ac837b13659db956283041943 Mon Sep 17 00:00:00 2001 From: Tristan Milnthorp Date: Fri, 25 Jan 2019 13:43:07 -0500 Subject: [PATCH 03/21] Whitespace consistency --- UnitsNet.Tests/UnitConverterTest.cs | 20 ++++++++++---------- UnitsNet/UnitConverter.cs | 28 ++++++++++++++-------------- 2 files changed, 24 insertions(+), 24 deletions(-) diff --git a/UnitsNet.Tests/UnitConverterTest.cs b/UnitsNet.Tests/UnitConverterTest.cs index dad4a95ac9..4ee86fc73f 100644 --- a/UnitsNet.Tests/UnitConverterTest.cs +++ b/UnitsNet.Tests/UnitConverterTest.cs @@ -29,29 +29,29 @@ public class UnitConverterTest [Fact] public void CustomConversionFunctionWorks() { - ConversionFunction conversionFunction = ( from ) => Length.FromInches( 18 ); + ConversionFunction conversionFunction = (from) => Length.FromInches(18); var unitConverter = new UnitConverter(); - unitConverter.SetConversionFunction( LengthUnit.Meter, LengthUnit.Inch, conversionFunction ); + unitConverter.SetConversionFunction(LengthUnit.Meter, LengthUnit.Inch, conversionFunction); - var foundConversionFunction = unitConverter.GetConversionFunction( LengthUnit.Meter, LengthUnit.Inch ); - var converted = foundConversionFunction( Length.FromMeters( 1.0 ) ); + var foundConversionFunction = unitConverter.GetConversionFunction(LengthUnit.Meter, LengthUnit.Inch); + var converted = foundConversionFunction(Length.FromMeters(1.0)); - Assert.Equal( Length.FromInches( 18 ), converted ); + Assert.Equal(Length.FromInches(18), converted); } [Fact] public void TryCustomConversionForOilBarrelsToUsGallons() { - ConversionFunction conversionFunction = ( from ) => Volume.FromUsGallons( ((Volume)from).Value * 42 ); + ConversionFunction conversionFunction = (from) => Volume.FromUsGallons(((Volume)from).Value * 42); var unitConverter = new UnitConverter(); - unitConverter.SetConversionFunction( VolumeUnit.OilBarrel, VolumeUnit.UsGallon, conversionFunction ); + unitConverter.SetConversionFunction(VolumeUnit.OilBarrel, VolumeUnit.UsGallon, conversionFunction); - var foundConversionFunction = unitConverter.GetConversionFunction( VolumeUnit.OilBarrel, VolumeUnit.UsGallon ); - var converted = foundConversionFunction( Volume.FromOilBarrels( 1 ) ); + var foundConversionFunction = unitConverter.GetConversionFunction(VolumeUnit.OilBarrel, VolumeUnit.UsGallon); + var converted = foundConversionFunction(Volume.FromOilBarrels(1)); - Assert.Equal( Volume.FromUsGallons( 42 ), converted ); + Assert.Equal(Volume.FromUsGallons(42), converted); } [Theory] diff --git a/UnitsNet/UnitConverter.cs b/UnitsNet/UnitConverter.cs index ffee9e1339..70190a2d2e 100644 --- a/UnitsNet/UnitConverter.cs +++ b/UnitsNet/UnitConverter.cs @@ -37,7 +37,7 @@ namespace UnitsNet { using ConversionFunctionLookup = ValueTuple; - public delegate IQuantity ConversionFunction( IQuantity inputValue ); + public delegate IQuantity ConversionFunction(IQuantity inputValue); /// /// Convert between units of a quantity, such as converting from meters to centimeters of a given length. @@ -66,37 +66,37 @@ public UnitConverter() #if !WINDOWS_UWP - public void SetConversionFunction( Enum from, Enum to, ConversionFunction conversionFunction ) where T : IQuantity + public void SetConversionFunction(Enum from, Enum to, ConversionFunction conversionFunction) where T : IQuantity { - SetConversionFunction( typeof(T), from, typeof( T ), to, conversionFunction ); + SetConversionFunction(typeof(T), from, typeof(T), to, conversionFunction); } - public void SetConversionFunction( Type fromType, Enum from, Type toType, Enum to, ConversionFunction conversionFunction ) + public void SetConversionFunction(Type fromType, Enum from, Type toType, Enum to, ConversionFunction conversionFunction) { - var conversionLookup = new ConversionFunctionLookup( fromType, from, toType, to ); + var conversionLookup = new ConversionFunctionLookup(fromType, from, toType, to); conversionFunctions[ conversionLookup ] = conversionFunction; } - public ConversionFunction GetConversionFunction( Enum from, Enum to ) where T : IQuantity + public ConversionFunction GetConversionFunction(Enum from, Enum to) where T : IQuantity { - return GetConversionFunction( typeof( T ), from, typeof( T ), to ); + return GetConversionFunction(typeof(T), from, typeof(T), to); } - public ConversionFunction GetConversionFunction( Type fromType, Enum from, Type toType, Enum to ) + public ConversionFunction GetConversionFunction(Type fromType, Enum from, Type toType, Enum to) { - var conversionLookup = new ConversionFunctionLookup( fromType, from, toType, to ); + var conversionLookup = new ConversionFunctionLookup(fromType, from, toType, to); return conversionFunctions[ conversionLookup ]; } - public bool TryGetConversionFunction( Enum from, Enum to, out ConversionFunction conversionFunction ) where T : IQuantity + public bool TryGetConversionFunction(Enum from, Enum to, out ConversionFunction conversionFunction) where T : IQuantity { - return TryGetConversionFunction( typeof( T ), from, typeof( T ), to, out conversionFunction ); + return TryGetConversionFunction(typeof(T), from, typeof(T), to, out conversionFunction); } - public bool TryGetConversionFunction( Type fromType, Enum from, Type toType, Enum to, out ConversionFunction conversionFunction ) + public bool TryGetConversionFunction(Type fromType, Enum from, Type toType, Enum to, out ConversionFunction conversionFunction) { - var conversionLookup = new ConversionFunctionLookup( fromType, from, toType, to ); - return conversionFunctions.TryGetValue( conversionLookup, out conversionFunction ); + var conversionLookup = new ConversionFunctionLookup(fromType, from, toType, to); + return conversionFunctions.TryGetValue(conversionLookup, out conversionFunction); } #endif From b4a42777ba3f7d383c50a1c617c4c61fe875f99b Mon Sep 17 00:00:00 2001 From: Tristan Milnthorp Date: Fri, 25 Jan 2019 14:00:50 -0500 Subject: [PATCH 04/21] Add some overloads and allowing source/target quantities to be different --- UnitsNet.Tests/UnitConverterTest.cs | 16 +++++++++- UnitsNet/UnitConverter.cs | 45 ++++++++++++++++++++++++++--- 2 files changed, 56 insertions(+), 5 deletions(-) diff --git a/UnitsNet.Tests/UnitConverterTest.cs b/UnitsNet.Tests/UnitConverterTest.cs index 4ee86fc73f..476bdbba68 100644 --- a/UnitsNet.Tests/UnitConverterTest.cs +++ b/UnitsNet.Tests/UnitConverterTest.cs @@ -27,7 +27,7 @@ namespace UnitsNet.Tests public class UnitConverterTest { [Fact] - public void CustomConversionFunctionWorks() + public void CustomConversionWithSameQuantityType() { ConversionFunction conversionFunction = (from) => Length.FromInches(18); @@ -40,6 +40,20 @@ public void CustomConversionFunctionWorks() Assert.Equal(Length.FromInches(18), converted); } + [Fact] + public void CustomConversionWithDifferentQuantityTypes() + { + ConversionFunction conversionFunction = (from) => Length.FromInches(18); + + var unitConverter = new UnitConverter(); + unitConverter.SetConversionFunction(MassUnit.Grain, LengthUnit.Inch, conversionFunction); + + var foundConversionFunction = unitConverter.GetConversionFunction(MassUnit.Grain, LengthUnit.Inch); + var converted = foundConversionFunction(Mass.FromGrains(100)); + + Assert.Equal(Length.FromInches(18), converted); + } + [Fact] public void TryCustomConversionForOilBarrelsToUsGallons() { diff --git a/UnitsNet/UnitConverter.cs b/UnitsNet/UnitConverter.cs index 70190a2d2e..f071e82345 100644 --- a/UnitsNet/UnitConverter.cs +++ b/UnitsNet/UnitConverter.cs @@ -66,15 +66,28 @@ public UnitConverter() #if !WINDOWS_UWP - public void SetConversionFunction(Enum from, Enum to, ConversionFunction conversionFunction) where T : IQuantity + public void SetConversionFunction(Enum from, Enum to, ConversionFunction conversionFunction) + where QuantityType : IQuantity { - SetConversionFunction(typeof(T), from, typeof(T), to, conversionFunction); + SetConversionFunction(typeof(QuantityType), from, typeof(QuantityType), to, conversionFunction); + } + + public void SetConversionFunction(Enum from, Enum to, ConversionFunction conversionFunction) + where SourceQuantity : IQuantity + where TargetQuantity : IQuantity + { + SetConversionFunction(typeof(SourceQuantity), from, typeof(TargetQuantity), to, conversionFunction); } public void SetConversionFunction(Type fromType, Enum from, Type toType, Enum to, ConversionFunction conversionFunction) { var conversionLookup = new ConversionFunctionLookup(fromType, from, toType, to); - conversionFunctions[ conversionLookup ] = conversionFunction; + SetConversionFunction(conversionLookup, conversionFunction); + } + + public void SetConversionFunction(ConversionFunctionLookup conversionLookup, ConversionFunction conversionFunction) + { + conversionFunctions[conversionLookup] = conversionFunction; } public ConversionFunction GetConversionFunction(Enum from, Enum to) where T : IQuantity @@ -82,10 +95,22 @@ public ConversionFunction GetConversionFunction(Enum from, Enum to) where T : return GetConversionFunction(typeof(T), from, typeof(T), to); } + public ConversionFunction GetConversionFunction(Enum from, Enum to) + where SourceQuantity : IQuantity + where TargetQuantity : IQuantity + { + return GetConversionFunction(typeof(SourceQuantity), from, typeof(TargetQuantity), to); + } + public ConversionFunction GetConversionFunction(Type fromType, Enum from, Type toType, Enum to) { var conversionLookup = new ConversionFunctionLookup(fromType, from, toType, to); - return conversionFunctions[ conversionLookup ]; + return GetConversionFunction(conversionLookup); + } + + public ConversionFunction GetConversionFunction(ConversionFunctionLookup conversionLookup) + { + return conversionFunctions[conversionLookup]; } public bool TryGetConversionFunction(Enum from, Enum to, out ConversionFunction conversionFunction) where T : IQuantity @@ -93,9 +118,21 @@ public bool TryGetConversionFunction(Enum from, Enum to, out ConversionFuncti return TryGetConversionFunction(typeof(T), from, typeof(T), to, out conversionFunction); } + public bool TryGetConversionFunction(Enum from, Enum to, out ConversionFunction conversionFunction) + where SourceQuantity : IQuantity + where TargetQuantity : IQuantity + { + return TryGetConversionFunction(typeof(SourceQuantity), from, typeof(TargetQuantity), to, out conversionFunction); + } + public bool TryGetConversionFunction(Type fromType, Enum from, Type toType, Enum to, out ConversionFunction conversionFunction) { var conversionLookup = new ConversionFunctionLookup(fromType, from, toType, to); + return TryGetConversionFunction(conversionLookup, out conversionFunction); + } + + public bool TryGetConversionFunction(ConversionFunctionLookup conversionLookup, out ConversionFunction conversionFunction) + { return conversionFunctions.TryGetValue(conversionLookup, out conversionFunction); } From f552e8be706ab621f65b97dc389c82b0c0d17b7e Mon Sep 17 00:00:00 2001 From: Tristan Milnthorp Date: Mon, 28 Jan 2019 09:17:40 -0500 Subject: [PATCH 05/21] Inline initialization and style update for field --- UnitsNet/UnitConverter.cs | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/UnitsNet/UnitConverter.cs b/UnitsNet/UnitConverter.cs index f071e82345..0cb92c1b0a 100644 --- a/UnitsNet/UnitConverter.cs +++ b/UnitsNet/UnitConverter.cs @@ -50,7 +50,7 @@ public sealed partial class UnitConverter private static readonly string UnitTypeNamespace = typeof(LengthUnit).Namespace; private static readonly Assembly UnitsNetAssembly = typeof(Length).GetAssembly(); - private Dictionary conversionFunctions; + private readonly Dictionary _conversionFunctions = new Dictionary(); static UnitConverter() { @@ -61,7 +61,6 @@ static UnitConverter() public UnitConverter() { - conversionFunctions = new Dictionary(); } #if !WINDOWS_UWP @@ -87,7 +86,7 @@ public void SetConversionFunction(Type fromType, Enum from, Type toType, Enum to public void SetConversionFunction(ConversionFunctionLookup conversionLookup, ConversionFunction conversionFunction) { - conversionFunctions[conversionLookup] = conversionFunction; + _conversionFunctions[conversionLookup] = conversionFunction; } public ConversionFunction GetConversionFunction(Enum from, Enum to) where T : IQuantity @@ -110,7 +109,7 @@ public ConversionFunction GetConversionFunction(Type fromType, Enum from, Type t public ConversionFunction GetConversionFunction(ConversionFunctionLookup conversionLookup) { - return conversionFunctions[conversionLookup]; + return _conversionFunctions[conversionLookup]; } public bool TryGetConversionFunction(Enum from, Enum to, out ConversionFunction conversionFunction) where T : IQuantity @@ -133,7 +132,7 @@ public bool TryGetConversionFunction(Type fromType, Enum from, Type toType, Enum public bool TryGetConversionFunction(ConversionFunctionLookup conversionLookup, out ConversionFunction conversionFunction) { - return conversionFunctions.TryGetValue(conversionLookup, out conversionFunction); + return _conversionFunctions.TryGetValue(conversionLookup, out conversionFunction); } #endif From de56c47f207fa26cd40c08e9a30d19cdd430e517 Mon Sep 17 00:00:00 2001 From: Tristan Milnthorp Date: Mon, 28 Jan 2019 09:48:55 -0500 Subject: [PATCH 06/21] PR feedback updates --- .../Acceleration.WindowsRuntimeComponent.g.cs | 65 +- ...ntOfSubstance.WindowsRuntimeComponent.g.cs | 71 +- ...mplitudeRatio.WindowsRuntimeComponent.g.cs | 38 +- .../Angle.WindowsRuntimeComponent.g.cs | 68 +- ...pparentEnergy.WindowsRuntimeComponent.g.cs | 35 +- ...ApparentPower.WindowsRuntimeComponent.g.cs | 38 +- .../Area.WindowsRuntimeComponent.g.cs | 65 +- .../AreaDensity.WindowsRuntimeComponent.g.cs | 29 +- ...mentOfInertia.WindowsRuntimeComponent.g.cs | 44 +- .../BitRate.WindowsRuntimeComponent.g.cs | 104 +- ...elConsumption.WindowsRuntimeComponent.g.cs | 35 +- .../Capacitance.WindowsRuntimeComponent.g.cs | 47 +- ...rmalExpansion.WindowsRuntimeComponent.g.cs | 35 +- .../Density.WindowsRuntimeComponent.g.cs | 143 +- .../Duration.WindowsRuntimeComponent.g.cs | 56 +- ...amicViscosity.WindowsRuntimeComponent.g.cs | 44 +- ...ricAdmittance.WindowsRuntimeComponent.g.cs | 38 +- ...lectricCharge.WindowsRuntimeComponent.g.cs | 29 +- ...ChargeDensity.WindowsRuntimeComponent.g.cs | 29 +- ...icConductance.WindowsRuntimeComponent.g.cs | 35 +- ...cConductivity.WindowsRuntimeComponent.g.cs | 29 +- ...ectricCurrent.WindowsRuntimeComponent.g.cs | 50 +- ...urrentDensity.WindowsRuntimeComponent.g.cs | 29 +- ...rrentGradient.WindowsRuntimeComponent.g.cs | 29 +- ...ElectricField.WindowsRuntimeComponent.g.cs | 29 +- ...ricInductance.WindowsRuntimeComponent.g.cs | 38 +- ...tricPotential.WindowsRuntimeComponent.g.cs | 41 +- ...icPotentialAc.WindowsRuntimeComponent.g.cs | 41 +- ...icPotentialDc.WindowsRuntimeComponent.g.cs | 41 +- ...ricResistance.WindowsRuntimeComponent.g.cs | 41 +- ...icResistivity.WindowsRuntimeComponent.g.cs | 68 +- .../Energy.WindowsRuntimeComponent.g.cs | 92 +- .../Entropy.WindowsRuntimeComponent.g.cs | 47 +- .../Force.WindowsRuntimeComponent.g.cs | 65 +- ...rceChangeRate.WindowsRuntimeComponent.g.cs | 59 +- ...orcePerLength.WindowsRuntimeComponent.g.cs | 53 +- .../Frequency.WindowsRuntimeComponent.g.cs | 50 +- .../HeatFlux.WindowsRuntimeComponent.g.cs | 80 +- ...erCoefficient.WindowsRuntimeComponent.g.cs | 32 +- .../Illuminance.WindowsRuntimeComponent.g.cs | 38 +- .../Information.WindowsRuntimeComponent.g.cs | 104 +- .../Irradiance.WindowsRuntimeComponent.g.cs | 68 +- .../Irradiation.WindowsRuntimeComponent.g.cs | 38 +- ...aticViscosity.WindowsRuntimeComponent.g.cs | 50 +- .../LapseRate.WindowsRuntimeComponent.g.cs | 29 +- .../Length.WindowsRuntimeComponent.g.cs | 92 +- .../Level.WindowsRuntimeComponent.g.cs | 32 +- ...LinearDensity.WindowsRuntimeComponent.g.cs | 35 +- .../LuminousFlux.WindowsRuntimeComponent.g.cs | 29 +- ...nousIntensity.WindowsRuntimeComponent.g.cs | 29 +- ...MagneticField.WindowsRuntimeComponent.g.cs | 38 +- .../MagneticFlux.WindowsRuntimeComponent.g.cs | 29 +- ...Magnetization.WindowsRuntimeComponent.g.cs | 29 +- .../Mass.WindowsRuntimeComponent.g.cs | 95 +- .../MassFlow.WindowsRuntimeComponent.g.cs | 116 +- .../MassFlux.WindowsRuntimeComponent.g.cs | 32 +- ...mentOfInertia.WindowsRuntimeComponent.g.cs | 110 +- .../MolarEnergy.WindowsRuntimeComponent.g.cs | 35 +- .../MolarEntropy.WindowsRuntimeComponent.g.cs | 35 +- .../MolarMass.WindowsRuntimeComponent.g.cs | 62 +- .../Molarity.WindowsRuntimeComponent.g.cs | 50 +- .../Permeability.WindowsRuntimeComponent.g.cs | 29 +- .../Permittivity.WindowsRuntimeComponent.g.cs | 29 +- .../Power.WindowsRuntimeComponent.g.cs | 86 +- .../PowerDensity.WindowsRuntimeComponent.g.cs | 158 +- .../PowerRatio.WindowsRuntimeComponent.g.cs | 32 +- .../Pressure.WindowsRuntimeComponent.g.cs | 152 +- ...ureChangeRate.WindowsRuntimeComponent.g.cs | 47 +- .../Ratio.WindowsRuntimeComponent.g.cs | 44 +- ...eactiveEnergy.WindowsRuntimeComponent.g.cs | 35 +- ...ReactivePower.WindowsRuntimeComponent.g.cs | 38 +- ...lAcceleration.WindowsRuntimeComponent.g.cs | 35 +- ...tationalSpeed.WindowsRuntimeComponent.g.cs | 65 +- ...onalStiffness.WindowsRuntimeComponent.g.cs | 35 +- ...nessPerLength.WindowsRuntimeComponent.g.cs | 35 +- .../SolidAngle.WindowsRuntimeComponent.g.cs | 29 +- ...pecificEnergy.WindowsRuntimeComponent.g.cs | 53 +- ...ecificEntropy.WindowsRuntimeComponent.g.cs | 50 +- ...pecificVolume.WindowsRuntimeComponent.g.cs | 35 +- ...pecificWeight.WindowsRuntimeComponent.g.cs | 77 +- .../Speed.WindowsRuntimeComponent.g.cs | 122 +- .../Temperature.WindowsRuntimeComponent.g.cs | 50 +- ...ureChangeRate.WindowsRuntimeComponent.g.cs | 56 +- ...peratureDelta.WindowsRuntimeComponent.g.cs | 50 +- ...lConductivity.WindowsRuntimeComponent.g.cs | 32 +- ...malResistance.WindowsRuntimeComponent.g.cs | 41 +- .../Torque.WindowsRuntimeComponent.g.cs | 89 +- .../VitaminA.WindowsRuntimeComponent.g.cs | 29 +- .../Volume.WindowsRuntimeComponent.g.cs | 161 +- .../VolumeFlow.WindowsRuntimeComponent.g.cs | 170 +- .../Quantities/Acceleration.NetFramework.g.cs | 77 +- .../AmountOfSubstance.NetFramework.g.cs | 83 +- .../AmplitudeRatio.NetFramework.g.cs | 52 +- .../Quantities/Angle.NetFramework.g.cs | 80 +- .../ApparentEnergy.NetFramework.g.cs | 47 +- .../ApparentPower.NetFramework.g.cs | 50 +- .../Quantities/Area.NetFramework.g.cs | 77 +- .../Quantities/AreaDensity.NetFramework.g.cs | 41 +- .../AreaMomentOfInertia.NetFramework.g.cs | 56 +- .../Quantities/BitRate.NetFramework.g.cs | 116 +- ...eSpecificFuelConsumption.NetFramework.g.cs | 47 +- .../Quantities/Capacitance.NetFramework.g.cs | 59 +- ...icientOfThermalExpansion.NetFramework.g.cs | 47 +- .../Quantities/Density.NetFramework.g.cs | 155 +- .../Quantities/Duration.NetFramework.g.cs | 68 +- .../DynamicViscosity.NetFramework.g.cs | 56 +- .../ElectricAdmittance.NetFramework.g.cs | 50 +- .../ElectricCharge.NetFramework.g.cs | 41 +- .../ElectricChargeDensity.NetFramework.g.cs | 41 +- .../ElectricConductance.NetFramework.g.cs | 47 +- .../ElectricConductivity.NetFramework.g.cs | 41 +- .../ElectricCurrent.NetFramework.g.cs | 62 +- .../ElectricCurrentDensity.NetFramework.g.cs | 41 +- .../ElectricCurrentGradient.NetFramework.g.cs | 41 +- .../ElectricField.NetFramework.g.cs | 41 +- .../ElectricInductance.NetFramework.g.cs | 50 +- .../ElectricPotential.NetFramework.g.cs | 53 +- .../ElectricPotentialAc.NetFramework.g.cs | 53 +- .../ElectricPotentialDc.NetFramework.g.cs | 53 +- .../ElectricResistance.NetFramework.g.cs | 53 +- .../ElectricResistivity.NetFramework.g.cs | 80 +- .../Quantities/Energy.NetFramework.g.cs | 104 +- .../Quantities/Entropy.NetFramework.g.cs | 59 +- .../Quantities/Force.NetFramework.g.cs | 77 +- .../ForceChangeRate.NetFramework.g.cs | 71 +- .../ForcePerLength.NetFramework.g.cs | 65 +- .../Quantities/Frequency.NetFramework.g.cs | 62 +- .../Quantities/HeatFlux.NetFramework.g.cs | 92 +- .../HeatTransferCoefficient.NetFramework.g.cs | 44 +- .../Quantities/Illuminance.NetFramework.g.cs | 50 +- .../Quantities/Information.NetFramework.g.cs | 116 +- .../Quantities/Irradiance.NetFramework.g.cs | 80 +- .../Quantities/Irradiation.NetFramework.g.cs | 50 +- .../KinematicViscosity.NetFramework.g.cs | 62 +- .../Quantities/LapseRate.NetFramework.g.cs | 41 +- .../Quantities/Length.NetFramework.g.cs | 104 +- .../Quantities/Level.NetFramework.g.cs | 46 +- .../LinearDensity.NetFramework.g.cs | 47 +- .../Quantities/LuminousFlux.NetFramework.g.cs | 41 +- .../LuminousIntensity.NetFramework.g.cs | 41 +- .../MagneticField.NetFramework.g.cs | 50 +- .../Quantities/MagneticFlux.NetFramework.g.cs | 41 +- .../Magnetization.NetFramework.g.cs | 41 +- .../Quantities/Mass.NetFramework.g.cs | 107 +- .../Quantities/MassFlow.NetFramework.g.cs | 128 +- .../Quantities/MassFlux.NetFramework.g.cs | 44 +- .../MassMomentOfInertia.NetFramework.g.cs | 122 +- .../Quantities/MolarEnergy.NetFramework.g.cs | 47 +- .../Quantities/MolarEntropy.NetFramework.g.cs | 47 +- .../Quantities/MolarMass.NetFramework.g.cs | 74 +- .../Quantities/Molarity.NetFramework.g.cs | 62 +- .../Quantities/Permeability.NetFramework.g.cs | 41 +- .../Quantities/Permittivity.NetFramework.g.cs | 41 +- .../Quantities/Power.NetFramework.g.cs | 98 +- .../Quantities/PowerDensity.NetFramework.g.cs | 170 +- .../Quantities/PowerRatio.NetFramework.g.cs | 46 +- .../Quantities/Pressure.NetFramework.g.cs | 164 +- .../PressureChangeRate.NetFramework.g.cs | 59 +- .../Quantities/Ratio.NetFramework.g.cs | 56 +- .../ReactiveEnergy.NetFramework.g.cs | 47 +- .../ReactivePower.NetFramework.g.cs | 50 +- .../RotationalAcceleration.NetFramework.g.cs | 47 +- .../RotationalSpeed.NetFramework.g.cs | 77 +- .../RotationalStiffness.NetFramework.g.cs | 47 +- ...tionalStiffnessPerLength.NetFramework.g.cs | 47 +- .../Quantities/SolidAngle.NetFramework.g.cs | 41 +- .../SpecificEnergy.NetFramework.g.cs | 65 +- .../SpecificEntropy.NetFramework.g.cs | 62 +- .../SpecificVolume.NetFramework.g.cs | 47 +- .../SpecificWeight.NetFramework.g.cs | 89 +- .../Quantities/Speed.NetFramework.g.cs | 134 +- .../Quantities/Temperature.NetFramework.g.cs | 58 +- .../TemperatureChangeRate.NetFramework.g.cs | 68 +- .../TemperatureDelta.NetFramework.g.cs | 62 +- .../ThermalConductivity.NetFramework.g.cs | 44 +- .../ThermalResistance.NetFramework.g.cs | 53 +- .../Quantities/Torque.NetFramework.g.cs | 101 +- .../Quantities/VitaminA.NetFramework.g.cs | 41 +- .../Quantities/Volume.NetFramework.g.cs | 173 +- .../Quantities/VolumeFlow.NetFramework.g.cs | 182 +- UnitsNet/GeneratedCode/UnitConverter.g.cs | 1594 ++++++++--------- ...GenerateQuantitySourceCodeNetFramework.ps1 | 47 +- ...GenerateUnitConverterDefaultSourceCode.ps1 | 2 +- 183 files changed, 6381 insertions(+), 6346 deletions(-) diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Acceleration.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Acceleration.WindowsRuntimeComponent.g.cs index 4059b5623f..df0bb8b040 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Acceleration.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Acceleration.WindowsRuntimeComponent.g.cs @@ -562,7 +562,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Acceleration other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -576,7 +576,7 @@ public override bool Equals(object obj) public bool Equals(Acceleration other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -652,7 +652,7 @@ public double As(AccelerationUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -662,7 +662,7 @@ public double As(AccelerationUnit unit) /// A Acceleration with the specified unit. public Acceleration ToUnit(AccelerationUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Acceleration(convertedValue, unit); } @@ -671,48 +671,45 @@ public Acceleration ToUnit(AccelerationUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Acceleration AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case AccelerationUnit.CentimeterPerSecondSquared: - return new Acceleration((_value) * 1e-2d, BaseUnit); - case AccelerationUnit.DecimeterPerSecondSquared: - return new Acceleration((_value) * 1e-1d, BaseUnit); - case AccelerationUnit.FootPerSecondSquared: - return new Acceleration(_value*0.304800, BaseUnit); - case AccelerationUnit.InchPerSecondSquared: - return new Acceleration(_value*0.0254, BaseUnit); - case AccelerationUnit.KilometerPerSecondSquared: - return new Acceleration((_value) * 1e3d, BaseUnit); - case AccelerationUnit.KnotPerHour: - return new Acceleration(_value*0.5144444444444/3600, BaseUnit); - case AccelerationUnit.KnotPerMinute: - return new Acceleration(_value*0.5144444444444/60, BaseUnit); - case AccelerationUnit.KnotPerSecond: - return new Acceleration(_value*0.5144444444444, BaseUnit); - case AccelerationUnit.MeterPerSecondSquared: - return new Acceleration(_value, BaseUnit); - case AccelerationUnit.MicrometerPerSecondSquared: - return new Acceleration((_value) * 1e-6d, BaseUnit); - case AccelerationUnit.MillimeterPerSecondSquared: - return new Acceleration((_value) * 1e-3d, BaseUnit); - case AccelerationUnit.NanometerPerSecondSquared: - return new Acceleration((_value) * 1e-9d, BaseUnit); - case AccelerationUnit.StandardGravity: - return new Acceleration(_value*9.80665, BaseUnit); + case AccelerationUnit.CentimeterPerSecondSquared: return (_value) * 1e-2d; + case AccelerationUnit.DecimeterPerSecondSquared: return (_value) * 1e-1d; + case AccelerationUnit.FootPerSecondSquared: return _value*0.304800; + case AccelerationUnit.InchPerSecondSquared: return _value*0.0254; + case AccelerationUnit.KilometerPerSecondSquared: return (_value) * 1e3d; + case AccelerationUnit.KnotPerHour: return _value*0.5144444444444/3600; + case AccelerationUnit.KnotPerMinute: return _value*0.5144444444444/60; + case AccelerationUnit.KnotPerSecond: return _value*0.5144444444444; + case AccelerationUnit.MeterPerSecondSquared: return _value; + case AccelerationUnit.MicrometerPerSecondSquared: return (_value) * 1e-6d; + case AccelerationUnit.MillimeterPerSecondSquared: return (_value) * 1e-3d; + case AccelerationUnit.NanometerPerSecondSquared: return (_value) * 1e-9d; + case AccelerationUnit.StandardGravity: return _value*9.80665; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(AccelerationUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Acceleration ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Acceleration(baseUnitValue, BaseUnit); + } + + private double GetValueAs(AccelerationUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmountOfSubstance.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmountOfSubstance.WindowsRuntimeComponent.g.cs index 144c4af162..27b41c01df 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmountOfSubstance.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmountOfSubstance.WindowsRuntimeComponent.g.cs @@ -592,7 +592,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(AmountOfSubstance other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -606,7 +606,7 @@ public override bool Equals(object obj) public bool Equals(AmountOfSubstance other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -682,7 +682,7 @@ public double As(AmountOfSubstanceUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -692,7 +692,7 @@ public double As(AmountOfSubstanceUnit unit) /// A AmountOfSubstance with the specified unit. public AmountOfSubstance ToUnit(AmountOfSubstanceUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new AmountOfSubstance(convertedValue, unit); } @@ -701,52 +701,47 @@ public AmountOfSubstance ToUnit(AmountOfSubstanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal AmountOfSubstance AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case AmountOfSubstanceUnit.Centimole: - return new AmountOfSubstance((_value) * 1e-2d, BaseUnit); - case AmountOfSubstanceUnit.CentipoundMole: - return new AmountOfSubstance((_value*453.59237) * 1e-2d, BaseUnit); - case AmountOfSubstanceUnit.Decimole: - return new AmountOfSubstance((_value) * 1e-1d, BaseUnit); - case AmountOfSubstanceUnit.DecipoundMole: - return new AmountOfSubstance((_value*453.59237) * 1e-1d, BaseUnit); - case AmountOfSubstanceUnit.Kilomole: - return new AmountOfSubstance((_value) * 1e3d, BaseUnit); - case AmountOfSubstanceUnit.KilopoundMole: - return new AmountOfSubstance((_value*453.59237) * 1e3d, BaseUnit); - case AmountOfSubstanceUnit.Megamole: - return new AmountOfSubstance((_value) * 1e6d, BaseUnit); - case AmountOfSubstanceUnit.Micromole: - return new AmountOfSubstance((_value) * 1e-6d, BaseUnit); - case AmountOfSubstanceUnit.MicropoundMole: - return new AmountOfSubstance((_value*453.59237) * 1e-6d, BaseUnit); - case AmountOfSubstanceUnit.Millimole: - return new AmountOfSubstance((_value) * 1e-3d, BaseUnit); - case AmountOfSubstanceUnit.MillipoundMole: - return new AmountOfSubstance((_value*453.59237) * 1e-3d, BaseUnit); - case AmountOfSubstanceUnit.Mole: - return new AmountOfSubstance(_value, BaseUnit); - case AmountOfSubstanceUnit.Nanomole: - return new AmountOfSubstance((_value) * 1e-9d, BaseUnit); - case AmountOfSubstanceUnit.NanopoundMole: - return new AmountOfSubstance((_value*453.59237) * 1e-9d, BaseUnit); - case AmountOfSubstanceUnit.PoundMole: - return new AmountOfSubstance(_value*453.59237, BaseUnit); + case AmountOfSubstanceUnit.Centimole: return (_value) * 1e-2d; + case AmountOfSubstanceUnit.CentipoundMole: return (_value*453.59237) * 1e-2d; + case AmountOfSubstanceUnit.Decimole: return (_value) * 1e-1d; + case AmountOfSubstanceUnit.DecipoundMole: return (_value*453.59237) * 1e-1d; + case AmountOfSubstanceUnit.Kilomole: return (_value) * 1e3d; + case AmountOfSubstanceUnit.KilopoundMole: return (_value*453.59237) * 1e3d; + case AmountOfSubstanceUnit.Megamole: return (_value) * 1e6d; + case AmountOfSubstanceUnit.Micromole: return (_value) * 1e-6d; + case AmountOfSubstanceUnit.MicropoundMole: return (_value*453.59237) * 1e-6d; + case AmountOfSubstanceUnit.Millimole: return (_value) * 1e-3d; + case AmountOfSubstanceUnit.MillipoundMole: return (_value*453.59237) * 1e-3d; + case AmountOfSubstanceUnit.Mole: return _value; + case AmountOfSubstanceUnit.Nanomole: return (_value) * 1e-9d; + case AmountOfSubstanceUnit.NanopoundMole: return (_value*453.59237) * 1e-9d; + case AmountOfSubstanceUnit.PoundMole: return _value*453.59237; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(AmountOfSubstanceUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal AmountOfSubstance ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new AmountOfSubstance(baseUnitValue, BaseUnit); + } + + private double GetValueAs(AmountOfSubstanceUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmplitudeRatio.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmplitudeRatio.WindowsRuntimeComponent.g.cs index aff0608085..f9f51788e7 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmplitudeRatio.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmplitudeRatio.WindowsRuntimeComponent.g.cs @@ -427,7 +427,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(AmplitudeRatio other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -441,7 +441,7 @@ public override bool Equals(object obj) public bool Equals(AmplitudeRatio other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -517,7 +517,7 @@ public double As(AmplitudeRatioUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -527,7 +527,7 @@ public double As(AmplitudeRatioUnit unit) /// A AmplitudeRatio with the specified unit. public AmplitudeRatio ToUnit(AmplitudeRatioUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new AmplitudeRatio(convertedValue, unit); } @@ -536,30 +536,36 @@ public AmplitudeRatio ToUnit(AmplitudeRatioUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal AmplitudeRatio AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case AmplitudeRatioUnit.DecibelMicrovolt: - return new AmplitudeRatio(_value - 120, BaseUnit); - case AmplitudeRatioUnit.DecibelMillivolt: - return new AmplitudeRatio(_value - 60, BaseUnit); - case AmplitudeRatioUnit.DecibelUnloaded: - return new AmplitudeRatio(_value - 2.218487499, BaseUnit); - case AmplitudeRatioUnit.DecibelVolt: - return new AmplitudeRatio(_value, BaseUnit); + case AmplitudeRatioUnit.DecibelMicrovolt: return _value - 120; + case AmplitudeRatioUnit.DecibelMillivolt: return _value - 60; + case AmplitudeRatioUnit.DecibelUnloaded: return _value - 2.218487499; + case AmplitudeRatioUnit.DecibelVolt: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(AmplitudeRatioUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal AmplitudeRatio ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new AmplitudeRatio(baseUnitValue, BaseUnit); + } + + private double GetValueAs(AmplitudeRatioUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Angle.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Angle.WindowsRuntimeComponent.g.cs index 069674ecb8..6c967e0139 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Angle.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Angle.WindowsRuntimeComponent.g.cs @@ -577,7 +577,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Angle other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -591,7 +591,7 @@ public override bool Equals(object obj) public bool Equals(Angle other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -667,7 +667,7 @@ public double As(AngleUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -677,7 +677,7 @@ public double As(AngleUnit unit) /// A Angle with the specified unit. public Angle ToUnit(AngleUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Angle(convertedValue, unit); } @@ -686,50 +686,46 @@ public Angle ToUnit(AngleUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Angle AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case AngleUnit.Arcminute: - return new Angle(_value/60, BaseUnit); - case AngleUnit.Arcsecond: - return new Angle(_value/3600, BaseUnit); - case AngleUnit.Centiradian: - return new Angle((_value*180/Math.PI) * 1e-2d, BaseUnit); - case AngleUnit.Deciradian: - return new Angle((_value*180/Math.PI) * 1e-1d, BaseUnit); - case AngleUnit.Degree: - return new Angle(_value, BaseUnit); - case AngleUnit.Gradian: - return new Angle(_value*0.9, BaseUnit); - case AngleUnit.Microdegree: - return new Angle((_value) * 1e-6d, BaseUnit); - case AngleUnit.Microradian: - return new Angle((_value*180/Math.PI) * 1e-6d, BaseUnit); - case AngleUnit.Millidegree: - return new Angle((_value) * 1e-3d, BaseUnit); - case AngleUnit.Milliradian: - return new Angle((_value*180/Math.PI) * 1e-3d, BaseUnit); - case AngleUnit.Nanodegree: - return new Angle((_value) * 1e-9d, BaseUnit); - case AngleUnit.Nanoradian: - return new Angle((_value*180/Math.PI) * 1e-9d, BaseUnit); - case AngleUnit.Radian: - return new Angle(_value*180/Math.PI, BaseUnit); - case AngleUnit.Revolution: - return new Angle(_value*360, BaseUnit); + case AngleUnit.Arcminute: return _value/60; + case AngleUnit.Arcsecond: return _value/3600; + case AngleUnit.Centiradian: return (_value*180/Math.PI) * 1e-2d; + case AngleUnit.Deciradian: return (_value*180/Math.PI) * 1e-1d; + case AngleUnit.Degree: return _value; + case AngleUnit.Gradian: return _value*0.9; + case AngleUnit.Microdegree: return (_value) * 1e-6d; + case AngleUnit.Microradian: return (_value*180/Math.PI) * 1e-6d; + case AngleUnit.Millidegree: return (_value) * 1e-3d; + case AngleUnit.Milliradian: return (_value*180/Math.PI) * 1e-3d; + case AngleUnit.Nanodegree: return (_value) * 1e-9d; + case AngleUnit.Nanoradian: return (_value*180/Math.PI) * 1e-9d; + case AngleUnit.Radian: return _value*180/Math.PI; + case AngleUnit.Revolution: return _value*360; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(AngleUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Angle ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Angle(baseUnitValue, BaseUnit); + } + + private double GetValueAs(AngleUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentEnergy.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentEnergy.WindowsRuntimeComponent.g.cs index 02b6ad4070..53bb516506 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentEnergy.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentEnergy.WindowsRuntimeComponent.g.cs @@ -412,7 +412,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ApparentEnergy other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -426,7 +426,7 @@ public override bool Equals(object obj) public bool Equals(ApparentEnergy other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -502,7 +502,7 @@ public double As(ApparentEnergyUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -512,7 +512,7 @@ public double As(ApparentEnergyUnit unit) /// A ApparentEnergy with the specified unit. public ApparentEnergy ToUnit(ApparentEnergyUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ApparentEnergy(convertedValue, unit); } @@ -521,28 +521,35 @@ public ApparentEnergy ToUnit(ApparentEnergyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ApparentEnergy AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ApparentEnergyUnit.KilovoltampereHour: - return new ApparentEnergy((_value) * 1e3d, BaseUnit); - case ApparentEnergyUnit.MegavoltampereHour: - return new ApparentEnergy((_value) * 1e6d, BaseUnit); - case ApparentEnergyUnit.VoltampereHour: - return new ApparentEnergy(_value, BaseUnit); + case ApparentEnergyUnit.KilovoltampereHour: return (_value) * 1e3d; + case ApparentEnergyUnit.MegavoltampereHour: return (_value) * 1e6d; + case ApparentEnergyUnit.VoltampereHour: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ApparentEnergyUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ApparentEnergy ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ApparentEnergy(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ApparentEnergyUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentPower.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentPower.WindowsRuntimeComponent.g.cs index b8024b0ecc..46f4292da2 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentPower.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentPower.WindowsRuntimeComponent.g.cs @@ -427,7 +427,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ApparentPower other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -441,7 +441,7 @@ public override bool Equals(object obj) public bool Equals(ApparentPower other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -517,7 +517,7 @@ public double As(ApparentPowerUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -527,7 +527,7 @@ public double As(ApparentPowerUnit unit) /// A ApparentPower with the specified unit. public ApparentPower ToUnit(ApparentPowerUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ApparentPower(convertedValue, unit); } @@ -536,30 +536,36 @@ public ApparentPower ToUnit(ApparentPowerUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ApparentPower AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ApparentPowerUnit.Gigavoltampere: - return new ApparentPower((_value) * 1e9d, BaseUnit); - case ApparentPowerUnit.Kilovoltampere: - return new ApparentPower((_value) * 1e3d, BaseUnit); - case ApparentPowerUnit.Megavoltampere: - return new ApparentPower((_value) * 1e6d, BaseUnit); - case ApparentPowerUnit.Voltampere: - return new ApparentPower(_value, BaseUnit); + case ApparentPowerUnit.Gigavoltampere: return (_value) * 1e9d; + case ApparentPowerUnit.Kilovoltampere: return (_value) * 1e3d; + case ApparentPowerUnit.Megavoltampere: return (_value) * 1e6d; + case ApparentPowerUnit.Voltampere: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ApparentPowerUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ApparentPower ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ApparentPower(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ApparentPowerUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Area.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Area.WindowsRuntimeComponent.g.cs index 69b4108a96..36d210f508 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Area.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Area.WindowsRuntimeComponent.g.cs @@ -562,7 +562,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Area other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -576,7 +576,7 @@ public override bool Equals(object obj) public bool Equals(Area other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -652,7 +652,7 @@ public double As(AreaUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -662,7 +662,7 @@ public double As(AreaUnit unit) /// A Area with the specified unit. public Area ToUnit(AreaUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Area(convertedValue, unit); } @@ -671,48 +671,45 @@ public Area ToUnit(AreaUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Area AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case AreaUnit.Acre: - return new Area(_value*4046.85642, BaseUnit); - case AreaUnit.Hectare: - return new Area(_value*1e4, BaseUnit); - case AreaUnit.SquareCentimeter: - return new Area(_value*1e-4, BaseUnit); - case AreaUnit.SquareDecimeter: - return new Area(_value*1e-2, BaseUnit); - case AreaUnit.SquareFoot: - return new Area(_value*0.092903, BaseUnit); - case AreaUnit.SquareInch: - return new Area(_value*0.00064516, BaseUnit); - case AreaUnit.SquareKilometer: - return new Area(_value*1e6, BaseUnit); - case AreaUnit.SquareMeter: - return new Area(_value, BaseUnit); - case AreaUnit.SquareMicrometer: - return new Area(_value*1e-12, BaseUnit); - case AreaUnit.SquareMile: - return new Area(_value*2.59e6, BaseUnit); - case AreaUnit.SquareMillimeter: - return new Area(_value*1e-6, BaseUnit); - case AreaUnit.SquareYard: - return new Area(_value*0.836127, BaseUnit); - case AreaUnit.UsSurveySquareFoot: - return new Area(_value*0.09290341161, BaseUnit); + case AreaUnit.Acre: return _value*4046.85642; + case AreaUnit.Hectare: return _value*1e4; + case AreaUnit.SquareCentimeter: return _value*1e-4; + case AreaUnit.SquareDecimeter: return _value*1e-2; + case AreaUnit.SquareFoot: return _value*0.092903; + case AreaUnit.SquareInch: return _value*0.00064516; + case AreaUnit.SquareKilometer: return _value*1e6; + case AreaUnit.SquareMeter: return _value; + case AreaUnit.SquareMicrometer: return _value*1e-12; + case AreaUnit.SquareMile: return _value*2.59e6; + case AreaUnit.SquareMillimeter: return _value*1e-6; + case AreaUnit.SquareYard: return _value*0.836127; + case AreaUnit.UsSurveySquareFoot: return _value*0.09290341161; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(AreaUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Area ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Area(baseUnitValue, BaseUnit); + } + + private double GetValueAs(AreaUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaDensity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaDensity.WindowsRuntimeComponent.g.cs index 9b90626f1d..0b4ddbc18c 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaDensity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaDensity.WindowsRuntimeComponent.g.cs @@ -382,7 +382,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(AreaDensity other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -396,7 +396,7 @@ public override bool Equals(object obj) public bool Equals(AreaDensity other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -472,7 +472,7 @@ public double As(AreaDensityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -482,7 +482,7 @@ public double As(AreaDensityUnit unit) /// A AreaDensity with the specified unit. public AreaDensity ToUnit(AreaDensityUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new AreaDensity(convertedValue, unit); } @@ -491,24 +491,33 @@ public AreaDensity ToUnit(AreaDensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal AreaDensity AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case AreaDensityUnit.KilogramPerSquareMeter: - return new AreaDensity(_value, BaseUnit); + case AreaDensityUnit.KilogramPerSquareMeter: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(AreaDensityUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal AreaDensity ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new AreaDensity(baseUnitValue, BaseUnit); + } + + private double GetValueAs(AreaDensityUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaMomentOfInertia.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaMomentOfInertia.WindowsRuntimeComponent.g.cs index 9851e595f5..c6184505cd 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaMomentOfInertia.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaMomentOfInertia.WindowsRuntimeComponent.g.cs @@ -457,7 +457,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(AreaMomentOfInertia other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -471,7 +471,7 @@ public override bool Equals(object obj) public bool Equals(AreaMomentOfInertia other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -547,7 +547,7 @@ public double As(AreaMomentOfInertiaUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -557,7 +557,7 @@ public double As(AreaMomentOfInertiaUnit unit) /// A AreaMomentOfInertia with the specified unit. public AreaMomentOfInertia ToUnit(AreaMomentOfInertiaUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new AreaMomentOfInertia(convertedValue, unit); } @@ -566,34 +566,38 @@ public AreaMomentOfInertia ToUnit(AreaMomentOfInertiaUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal AreaMomentOfInertia AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case AreaMomentOfInertiaUnit.CentimeterToTheFourth: - return new AreaMomentOfInertia(_value/1e8, BaseUnit); - case AreaMomentOfInertiaUnit.DecimeterToTheFourth: - return new AreaMomentOfInertia(_value/1e4, BaseUnit); - case AreaMomentOfInertiaUnit.FootToTheFourth: - return new AreaMomentOfInertia(_value*Math.Pow(0.3048, 4), BaseUnit); - case AreaMomentOfInertiaUnit.InchToTheFourth: - return new AreaMomentOfInertia(_value*Math.Pow(2.54e-2, 4), BaseUnit); - case AreaMomentOfInertiaUnit.MeterToTheFourth: - return new AreaMomentOfInertia(_value, BaseUnit); - case AreaMomentOfInertiaUnit.MillimeterToTheFourth: - return new AreaMomentOfInertia(_value/1e12, BaseUnit); + case AreaMomentOfInertiaUnit.CentimeterToTheFourth: return _value/1e8; + case AreaMomentOfInertiaUnit.DecimeterToTheFourth: return _value/1e4; + case AreaMomentOfInertiaUnit.FootToTheFourth: return _value*Math.Pow(0.3048, 4); + case AreaMomentOfInertiaUnit.InchToTheFourth: return _value*Math.Pow(2.54e-2, 4); + case AreaMomentOfInertiaUnit.MeterToTheFourth: return _value; + case AreaMomentOfInertiaUnit.MillimeterToTheFourth: return _value/1e12; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(AreaMomentOfInertiaUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal AreaMomentOfInertia ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new AreaMomentOfInertia(baseUnitValue, BaseUnit); + } + + private double GetValueAs(AreaMomentOfInertiaUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BitRate.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BitRate.WindowsRuntimeComponent.g.cs index a083dd7b36..4206f97ed7 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BitRate.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BitRate.WindowsRuntimeComponent.g.cs @@ -760,7 +760,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(BitRate other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -774,7 +774,7 @@ public override bool Equals(object obj) public bool Equals(BitRate other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -850,7 +850,7 @@ public double As(BitRateUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -860,7 +860,7 @@ public double As(BitRateUnit unit) /// A BitRate with the specified unit. public BitRate ToUnit(BitRateUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new BitRate(convertedValue, unit); } @@ -869,74 +869,58 @@ public BitRate ToUnit(BitRateUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal BitRate AsBaseUnit() + private decimal GetValueInBaseUnit() { switch(Unit) { - case BitRateUnit.BitPerSecond: - return new BitRate(_value, BaseUnit); - case BitRateUnit.BytePerSecond: - return new BitRate(_value*8m, BaseUnit); - case BitRateUnit.ExabitPerSecond: - return new BitRate((_value) * 1e18m, BaseUnit); - case BitRateUnit.ExabytePerSecond: - return new BitRate((_value*8m) * 1e18m, BaseUnit); - case BitRateUnit.ExbibitPerSecond: - return new BitRate((_value) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024), BaseUnit); - case BitRateUnit.ExbibytePerSecond: - return new BitRate((_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024), BaseUnit); - case BitRateUnit.GibibitPerSecond: - return new BitRate((_value) * (1024m * 1024 * 1024), BaseUnit); - case BitRateUnit.GibibytePerSecond: - return new BitRate((_value*8m) * (1024m * 1024 * 1024), BaseUnit); - case BitRateUnit.GigabitPerSecond: - return new BitRate((_value) * 1e9m, BaseUnit); - case BitRateUnit.GigabytePerSecond: - return new BitRate((_value*8m) * 1e9m, BaseUnit); - case BitRateUnit.KibibitPerSecond: - return new BitRate((_value) * 1024m, BaseUnit); - case BitRateUnit.KibibytePerSecond: - return new BitRate((_value*8m) * 1024m, BaseUnit); - case BitRateUnit.KilobitPerSecond: - return new BitRate((_value) * 1e3m, BaseUnit); - case BitRateUnit.KilobytePerSecond: - return new BitRate((_value*8m) * 1e3m, BaseUnit); - case BitRateUnit.MebibitPerSecond: - return new BitRate((_value) * (1024m * 1024), BaseUnit); - case BitRateUnit.MebibytePerSecond: - return new BitRate((_value*8m) * (1024m * 1024), BaseUnit); - case BitRateUnit.MegabitPerSecond: - return new BitRate((_value) * 1e6m, BaseUnit); - case BitRateUnit.MegabytePerSecond: - return new BitRate((_value*8m) * 1e6m, BaseUnit); - case BitRateUnit.PebibitPerSecond: - return new BitRate((_value) * (1024m * 1024 * 1024 * 1024 * 1024), BaseUnit); - case BitRateUnit.PebibytePerSecond: - return new BitRate((_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024), BaseUnit); - case BitRateUnit.PetabitPerSecond: - return new BitRate((_value) * 1e15m, BaseUnit); - case BitRateUnit.PetabytePerSecond: - return new BitRate((_value*8m) * 1e15m, BaseUnit); - case BitRateUnit.TebibitPerSecond: - return new BitRate((_value) * (1024m * 1024 * 1024 * 1024), BaseUnit); - case BitRateUnit.TebibytePerSecond: - return new BitRate((_value*8m) * (1024m * 1024 * 1024 * 1024), BaseUnit); - case BitRateUnit.TerabitPerSecond: - return new BitRate((_value) * 1e12m, BaseUnit); - case BitRateUnit.TerabytePerSecond: - return new BitRate((_value*8m) * 1e12m, BaseUnit); + case BitRateUnit.BitPerSecond: return _value; + case BitRateUnit.BytePerSecond: return _value*8m; + case BitRateUnit.ExabitPerSecond: return (_value) * 1e18m; + case BitRateUnit.ExabytePerSecond: return (_value*8m) * 1e18m; + case BitRateUnit.ExbibitPerSecond: return (_value) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024); + case BitRateUnit.ExbibytePerSecond: return (_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024); + case BitRateUnit.GibibitPerSecond: return (_value) * (1024m * 1024 * 1024); + case BitRateUnit.GibibytePerSecond: return (_value*8m) * (1024m * 1024 * 1024); + case BitRateUnit.GigabitPerSecond: return (_value) * 1e9m; + case BitRateUnit.GigabytePerSecond: return (_value*8m) * 1e9m; + case BitRateUnit.KibibitPerSecond: return (_value) * 1024m; + case BitRateUnit.KibibytePerSecond: return (_value*8m) * 1024m; + case BitRateUnit.KilobitPerSecond: return (_value) * 1e3m; + case BitRateUnit.KilobytePerSecond: return (_value*8m) * 1e3m; + case BitRateUnit.MebibitPerSecond: return (_value) * (1024m * 1024); + case BitRateUnit.MebibytePerSecond: return (_value*8m) * (1024m * 1024); + case BitRateUnit.MegabitPerSecond: return (_value) * 1e6m; + case BitRateUnit.MegabytePerSecond: return (_value*8m) * 1e6m; + case BitRateUnit.PebibitPerSecond: return (_value) * (1024m * 1024 * 1024 * 1024 * 1024); + case BitRateUnit.PebibytePerSecond: return (_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024); + case BitRateUnit.PetabitPerSecond: return (_value) * 1e15m; + case BitRateUnit.PetabytePerSecond: return (_value*8m) * 1e15m; + case BitRateUnit.TebibitPerSecond: return (_value) * (1024m * 1024 * 1024 * 1024); + case BitRateUnit.TebibytePerSecond: return (_value*8m) * (1024m * 1024 * 1024 * 1024); + case BitRateUnit.TerabitPerSecond: return (_value) * 1e12m; + case BitRateUnit.TerabytePerSecond: return (_value*8m) * 1e12m; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private decimal AsBaseNumericType(BitRateUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal BitRate ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new BitRate(baseUnitValue, BaseUnit); + } + + private decimal GetValueAs(BitRateUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.WindowsRuntimeComponent.g.cs index 14e9fea1db..d41a87de3a 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.WindowsRuntimeComponent.g.cs @@ -412,7 +412,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(BrakeSpecificFuelConsumption other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -426,7 +426,7 @@ public override bool Equals(object obj) public bool Equals(BrakeSpecificFuelConsumption other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -502,7 +502,7 @@ public double As(BrakeSpecificFuelConsumptionUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -512,7 +512,7 @@ public double As(BrakeSpecificFuelConsumptionUnit unit) /// A BrakeSpecificFuelConsumption with the specified unit. public BrakeSpecificFuelConsumption ToUnit(BrakeSpecificFuelConsumptionUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new BrakeSpecificFuelConsumption(convertedValue, unit); } @@ -521,28 +521,35 @@ public BrakeSpecificFuelConsumption ToUnit(BrakeSpecificFuelConsumptionUnit unit /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal BrakeSpecificFuelConsumption AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour: - return new BrakeSpecificFuelConsumption(_value/3.6e9, BaseUnit); - case BrakeSpecificFuelConsumptionUnit.KilogramPerJoule: - return new BrakeSpecificFuelConsumption(_value, BaseUnit); - case BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour: - return new BrakeSpecificFuelConsumption(_value*1.689659410672e-7, BaseUnit); + case BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour: return _value/3.6e9; + case BrakeSpecificFuelConsumptionUnit.KilogramPerJoule: return _value; + case BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour: return _value*1.689659410672e-7; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(BrakeSpecificFuelConsumptionUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal BrakeSpecificFuelConsumption ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new BrakeSpecificFuelConsumption(baseUnitValue, BaseUnit); + } + + private double GetValueAs(BrakeSpecificFuelConsumptionUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Capacitance.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Capacitance.WindowsRuntimeComponent.g.cs index ab3653b750..97596f16fe 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Capacitance.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Capacitance.WindowsRuntimeComponent.g.cs @@ -475,7 +475,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Capacitance other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -489,7 +489,7 @@ public override bool Equals(object obj) public bool Equals(Capacitance other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -565,7 +565,7 @@ public double As(CapacitanceUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -575,7 +575,7 @@ public double As(CapacitanceUnit unit) /// A Capacitance with the specified unit. public Capacitance ToUnit(CapacitanceUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Capacitance(convertedValue, unit); } @@ -584,36 +584,39 @@ public Capacitance ToUnit(CapacitanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Capacitance AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case CapacitanceUnit.Farad: - return new Capacitance(_value, BaseUnit); - case CapacitanceUnit.Kilofarad: - return new Capacitance((_value) * 1e3d, BaseUnit); - case CapacitanceUnit.Megafarad: - return new Capacitance((_value) * 1e6d, BaseUnit); - case CapacitanceUnit.Microfarad: - return new Capacitance((_value) * 1e-6d, BaseUnit); - case CapacitanceUnit.Millifarad: - return new Capacitance((_value) * 1e-3d, BaseUnit); - case CapacitanceUnit.Nanofarad: - return new Capacitance((_value) * 1e-9d, BaseUnit); - case CapacitanceUnit.Picofarad: - return new Capacitance((_value) * 1e-12d, BaseUnit); + case CapacitanceUnit.Farad: return _value; + case CapacitanceUnit.Kilofarad: return (_value) * 1e3d; + case CapacitanceUnit.Megafarad: return (_value) * 1e6d; + case CapacitanceUnit.Microfarad: return (_value) * 1e-6d; + case CapacitanceUnit.Millifarad: return (_value) * 1e-3d; + case CapacitanceUnit.Nanofarad: return (_value) * 1e-9d; + case CapacitanceUnit.Picofarad: return (_value) * 1e-12d; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(CapacitanceUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Capacitance ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Capacitance(baseUnitValue, BaseUnit); + } + + private double GetValueAs(CapacitanceUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/CoefficientOfThermalExpansion.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/CoefficientOfThermalExpansion.WindowsRuntimeComponent.g.cs index 35ad844c76..e37f4d2ffe 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/CoefficientOfThermalExpansion.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/CoefficientOfThermalExpansion.WindowsRuntimeComponent.g.cs @@ -412,7 +412,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(CoefficientOfThermalExpansion other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -426,7 +426,7 @@ public override bool Equals(object obj) public bool Equals(CoefficientOfThermalExpansion other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -502,7 +502,7 @@ public double As(CoefficientOfThermalExpansionUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -512,7 +512,7 @@ public double As(CoefficientOfThermalExpansionUnit unit) /// A CoefficientOfThermalExpansion with the specified unit. public CoefficientOfThermalExpansion ToUnit(CoefficientOfThermalExpansionUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new CoefficientOfThermalExpansion(convertedValue, unit); } @@ -521,28 +521,35 @@ public CoefficientOfThermalExpansion ToUnit(CoefficientOfThermalExpansionUnit un /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal CoefficientOfThermalExpansion AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case CoefficientOfThermalExpansionUnit.InverseDegreeCelsius: - return new CoefficientOfThermalExpansion(_value, BaseUnit); - case CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit: - return new CoefficientOfThermalExpansion(_value*5/9, BaseUnit); - case CoefficientOfThermalExpansionUnit.InverseKelvin: - return new CoefficientOfThermalExpansion(_value, BaseUnit); + case CoefficientOfThermalExpansionUnit.InverseDegreeCelsius: return _value; + case CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit: return _value*5/9; + case CoefficientOfThermalExpansionUnit.InverseKelvin: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(CoefficientOfThermalExpansionUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal CoefficientOfThermalExpansion ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new CoefficientOfThermalExpansion(baseUnitValue, BaseUnit); + } + + private double GetValueAs(CoefficientOfThermalExpansionUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Density.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Density.WindowsRuntimeComponent.g.cs index 1488b6b381..3679e678d2 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Density.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Density.WindowsRuntimeComponent.g.cs @@ -955,7 +955,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Density other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -969,7 +969,7 @@ public override bool Equals(object obj) public bool Equals(Density other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -1045,7 +1045,7 @@ public double As(DensityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -1055,7 +1055,7 @@ public double As(DensityUnit unit) /// A Density with the specified unit. public Density ToUnit(DensityUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Density(convertedValue, unit); } @@ -1064,100 +1064,71 @@ public Density ToUnit(DensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Density AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case DensityUnit.CentigramPerDeciliter: - return new Density((_value/1e-1) * 1e-2d, BaseUnit); - case DensityUnit.CentigramPerLiter: - return new Density((_value/1) * 1e-2d, BaseUnit); - case DensityUnit.CentigramPerMilliliter: - return new Density((_value/1e-3) * 1e-2d, BaseUnit); - case DensityUnit.DecigramPerDeciliter: - return new Density((_value/1e-1) * 1e-1d, BaseUnit); - case DensityUnit.DecigramPerLiter: - return new Density((_value/1) * 1e-1d, BaseUnit); - case DensityUnit.DecigramPerMilliliter: - return new Density((_value/1e-3) * 1e-1d, BaseUnit); - case DensityUnit.GramPerCubicCentimeter: - return new Density(_value/1e-3, BaseUnit); - case DensityUnit.GramPerCubicMeter: - return new Density(_value/1e3, BaseUnit); - case DensityUnit.GramPerCubicMillimeter: - return new Density(_value/1e-6, BaseUnit); - case DensityUnit.GramPerDeciliter: - return new Density(_value/1e-1, BaseUnit); - case DensityUnit.GramPerLiter: - return new Density(_value/1, BaseUnit); - case DensityUnit.GramPerMilliliter: - return new Density(_value/1e-3, BaseUnit); - case DensityUnit.KilogramPerCubicCentimeter: - return new Density((_value/1e-3) * 1e3d, BaseUnit); - case DensityUnit.KilogramPerCubicMeter: - return new Density((_value/1e3) * 1e3d, BaseUnit); - case DensityUnit.KilogramPerCubicMillimeter: - return new Density((_value/1e-6) * 1e3d, BaseUnit); - case DensityUnit.KilopoundPerCubicFoot: - return new Density((_value/0.062427961) * 1e3d, BaseUnit); - case DensityUnit.KilopoundPerCubicInch: - return new Density((_value/3.6127298147753e-5) * 1e3d, BaseUnit); - case DensityUnit.MicrogramPerCubicMeter: - return new Density((_value/1e3) * 1e-6d, BaseUnit); - case DensityUnit.MicrogramPerDeciliter: - return new Density((_value/1e-1) * 1e-6d, BaseUnit); - case DensityUnit.MicrogramPerLiter: - return new Density((_value/1) * 1e-6d, BaseUnit); - case DensityUnit.MicrogramPerMilliliter: - return new Density((_value/1e-3) * 1e-6d, BaseUnit); - case DensityUnit.MilligramPerCubicMeter: - return new Density((_value/1e3) * 1e-3d, BaseUnit); - case DensityUnit.MilligramPerDeciliter: - return new Density((_value/1e-1) * 1e-3d, BaseUnit); - case DensityUnit.MilligramPerLiter: - return new Density((_value/1) * 1e-3d, BaseUnit); - case DensityUnit.MilligramPerMilliliter: - return new Density((_value/1e-3) * 1e-3d, BaseUnit); - case DensityUnit.NanogramPerDeciliter: - return new Density((_value/1e-1) * 1e-9d, BaseUnit); - case DensityUnit.NanogramPerLiter: - return new Density((_value/1) * 1e-9d, BaseUnit); - case DensityUnit.NanogramPerMilliliter: - return new Density((_value/1e-3) * 1e-9d, BaseUnit); - case DensityUnit.PicogramPerDeciliter: - return new Density((_value/1e-1) * 1e-12d, BaseUnit); - case DensityUnit.PicogramPerLiter: - return new Density((_value/1) * 1e-12d, BaseUnit); - case DensityUnit.PicogramPerMilliliter: - return new Density((_value/1e-3) * 1e-12d, BaseUnit); - case DensityUnit.PoundPerCubicFoot: - return new Density(_value/0.062427961, BaseUnit); - case DensityUnit.PoundPerCubicInch: - return new Density(_value/3.6127298147753e-5, BaseUnit); - case DensityUnit.PoundPerImperialGallon: - return new Density(_value*9.9776398e1, BaseUnit); - case DensityUnit.PoundPerUSGallon: - return new Density(_value*1.19826427e2, BaseUnit); - case DensityUnit.SlugPerCubicFoot: - return new Density(_value*515.378818, BaseUnit); - case DensityUnit.TonnePerCubicCentimeter: - return new Density(_value/1e-9, BaseUnit); - case DensityUnit.TonnePerCubicMeter: - return new Density(_value/0.001, BaseUnit); - case DensityUnit.TonnePerCubicMillimeter: - return new Density(_value/1e-12, BaseUnit); + case DensityUnit.CentigramPerDeciliter: return (_value/1e-1) * 1e-2d; + case DensityUnit.CentigramPerLiter: return (_value/1) * 1e-2d; + case DensityUnit.CentigramPerMilliliter: return (_value/1e-3) * 1e-2d; + case DensityUnit.DecigramPerDeciliter: return (_value/1e-1) * 1e-1d; + case DensityUnit.DecigramPerLiter: return (_value/1) * 1e-1d; + case DensityUnit.DecigramPerMilliliter: return (_value/1e-3) * 1e-1d; + case DensityUnit.GramPerCubicCentimeter: return _value/1e-3; + case DensityUnit.GramPerCubicMeter: return _value/1e3; + case DensityUnit.GramPerCubicMillimeter: return _value/1e-6; + case DensityUnit.GramPerDeciliter: return _value/1e-1; + case DensityUnit.GramPerLiter: return _value/1; + case DensityUnit.GramPerMilliliter: return _value/1e-3; + case DensityUnit.KilogramPerCubicCentimeter: return (_value/1e-3) * 1e3d; + case DensityUnit.KilogramPerCubicMeter: return (_value/1e3) * 1e3d; + case DensityUnit.KilogramPerCubicMillimeter: return (_value/1e-6) * 1e3d; + case DensityUnit.KilopoundPerCubicFoot: return (_value/0.062427961) * 1e3d; + case DensityUnit.KilopoundPerCubicInch: return (_value/3.6127298147753e-5) * 1e3d; + case DensityUnit.MicrogramPerCubicMeter: return (_value/1e3) * 1e-6d; + case DensityUnit.MicrogramPerDeciliter: return (_value/1e-1) * 1e-6d; + case DensityUnit.MicrogramPerLiter: return (_value/1) * 1e-6d; + case DensityUnit.MicrogramPerMilliliter: return (_value/1e-3) * 1e-6d; + case DensityUnit.MilligramPerCubicMeter: return (_value/1e3) * 1e-3d; + case DensityUnit.MilligramPerDeciliter: return (_value/1e-1) * 1e-3d; + case DensityUnit.MilligramPerLiter: return (_value/1) * 1e-3d; + case DensityUnit.MilligramPerMilliliter: return (_value/1e-3) * 1e-3d; + case DensityUnit.NanogramPerDeciliter: return (_value/1e-1) * 1e-9d; + case DensityUnit.NanogramPerLiter: return (_value/1) * 1e-9d; + case DensityUnit.NanogramPerMilliliter: return (_value/1e-3) * 1e-9d; + case DensityUnit.PicogramPerDeciliter: return (_value/1e-1) * 1e-12d; + case DensityUnit.PicogramPerLiter: return (_value/1) * 1e-12d; + case DensityUnit.PicogramPerMilliliter: return (_value/1e-3) * 1e-12d; + case DensityUnit.PoundPerCubicFoot: return _value/0.062427961; + case DensityUnit.PoundPerCubicInch: return _value/3.6127298147753e-5; + case DensityUnit.PoundPerImperialGallon: return _value*9.9776398e1; + case DensityUnit.PoundPerUSGallon: return _value*1.19826427e2; + case DensityUnit.SlugPerCubicFoot: return _value*515.378818; + case DensityUnit.TonnePerCubicCentimeter: return _value/1e-9; + case DensityUnit.TonnePerCubicMeter: return _value/0.001; + case DensityUnit.TonnePerCubicMillimeter: return _value/1e-12; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(DensityUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Density ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Density(baseUnitValue, BaseUnit); + } + + private double GetValueAs(DensityUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Duration.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Duration.WindowsRuntimeComponent.g.cs index 8cc701f276..c26343d55a 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Duration.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Duration.WindowsRuntimeComponent.g.cs @@ -517,7 +517,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Duration other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -531,7 +531,7 @@ public override bool Equals(object obj) public bool Equals(Duration other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -607,7 +607,7 @@ public double As(DurationUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -617,7 +617,7 @@ public double As(DurationUnit unit) /// A Duration with the specified unit. public Duration ToUnit(DurationUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Duration(convertedValue, unit); } @@ -626,42 +626,42 @@ public Duration ToUnit(DurationUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Duration AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case DurationUnit.Day: - return new Duration(_value*24*3600, BaseUnit); - case DurationUnit.Hour: - return new Duration(_value*3600, BaseUnit); - case DurationUnit.Microsecond: - return new Duration((_value) * 1e-6d, BaseUnit); - case DurationUnit.Millisecond: - return new Duration((_value) * 1e-3d, BaseUnit); - case DurationUnit.Minute: - return new Duration(_value*60, BaseUnit); - case DurationUnit.Month30: - return new Duration(_value*30*24*3600, BaseUnit); - case DurationUnit.Nanosecond: - return new Duration((_value) * 1e-9d, BaseUnit); - case DurationUnit.Second: - return new Duration(_value, BaseUnit); - case DurationUnit.Week: - return new Duration(_value*7*24*3600, BaseUnit); - case DurationUnit.Year365: - return new Duration(_value*365*24*3600, BaseUnit); + case DurationUnit.Day: return _value*24*3600; + case DurationUnit.Hour: return _value*3600; + case DurationUnit.Microsecond: return (_value) * 1e-6d; + case DurationUnit.Millisecond: return (_value) * 1e-3d; + case DurationUnit.Minute: return _value*60; + case DurationUnit.Month30: return _value*30*24*3600; + case DurationUnit.Nanosecond: return (_value) * 1e-9d; + case DurationUnit.Second: return _value; + case DurationUnit.Week: return _value*7*24*3600; + case DurationUnit.Year365: return _value*365*24*3600; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(DurationUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Duration ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Duration(baseUnitValue, BaseUnit); + } + + private double GetValueAs(DurationUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/DynamicViscosity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/DynamicViscosity.WindowsRuntimeComponent.g.cs index 53802949db..4f894dbca1 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/DynamicViscosity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/DynamicViscosity.WindowsRuntimeComponent.g.cs @@ -460,7 +460,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(DynamicViscosity other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -474,7 +474,7 @@ public override bool Equals(object obj) public bool Equals(DynamicViscosity other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -550,7 +550,7 @@ public double As(DynamicViscosityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -560,7 +560,7 @@ public double As(DynamicViscosityUnit unit) /// A DynamicViscosity with the specified unit. public DynamicViscosity ToUnit(DynamicViscosityUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new DynamicViscosity(convertedValue, unit); } @@ -569,34 +569,38 @@ public DynamicViscosity ToUnit(DynamicViscosityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal DynamicViscosity AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case DynamicViscosityUnit.Centipoise: - return new DynamicViscosity((_value/10) * 1e-2d, BaseUnit); - case DynamicViscosityUnit.MicropascalSecond: - return new DynamicViscosity((_value) * 1e-6d, BaseUnit); - case DynamicViscosityUnit.MillipascalSecond: - return new DynamicViscosity((_value) * 1e-3d, BaseUnit); - case DynamicViscosityUnit.NewtonSecondPerMeterSquared: - return new DynamicViscosity(_value, BaseUnit); - case DynamicViscosityUnit.PascalSecond: - return new DynamicViscosity(_value, BaseUnit); - case DynamicViscosityUnit.Poise: - return new DynamicViscosity(_value/10, BaseUnit); + case DynamicViscosityUnit.Centipoise: return (_value/10) * 1e-2d; + case DynamicViscosityUnit.MicropascalSecond: return (_value) * 1e-6d; + case DynamicViscosityUnit.MillipascalSecond: return (_value) * 1e-3d; + case DynamicViscosityUnit.NewtonSecondPerMeterSquared: return _value; + case DynamicViscosityUnit.PascalSecond: return _value; + case DynamicViscosityUnit.Poise: return _value/10; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(DynamicViscosityUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal DynamicViscosity ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new DynamicViscosity(baseUnitValue, BaseUnit); + } + + private double GetValueAs(DynamicViscosityUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricAdmittance.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricAdmittance.WindowsRuntimeComponent.g.cs index ae0bba44f1..df6388a05d 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricAdmittance.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricAdmittance.WindowsRuntimeComponent.g.cs @@ -427,7 +427,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ElectricAdmittance other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -441,7 +441,7 @@ public override bool Equals(object obj) public bool Equals(ElectricAdmittance other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -517,7 +517,7 @@ public double As(ElectricAdmittanceUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -527,7 +527,7 @@ public double As(ElectricAdmittanceUnit unit) /// A ElectricAdmittance with the specified unit. public ElectricAdmittance ToUnit(ElectricAdmittanceUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ElectricAdmittance(convertedValue, unit); } @@ -536,30 +536,36 @@ public ElectricAdmittance ToUnit(ElectricAdmittanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ElectricAdmittance AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ElectricAdmittanceUnit.Microsiemens: - return new ElectricAdmittance((_value) * 1e-6d, BaseUnit); - case ElectricAdmittanceUnit.Millisiemens: - return new ElectricAdmittance((_value) * 1e-3d, BaseUnit); - case ElectricAdmittanceUnit.Nanosiemens: - return new ElectricAdmittance((_value) * 1e-9d, BaseUnit); - case ElectricAdmittanceUnit.Siemens: - return new ElectricAdmittance(_value, BaseUnit); + case ElectricAdmittanceUnit.Microsiemens: return (_value) * 1e-6d; + case ElectricAdmittanceUnit.Millisiemens: return (_value) * 1e-3d; + case ElectricAdmittanceUnit.Nanosiemens: return (_value) * 1e-9d; + case ElectricAdmittanceUnit.Siemens: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ElectricAdmittanceUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ElectricAdmittance ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ElectricAdmittance(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ElectricAdmittanceUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCharge.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCharge.WindowsRuntimeComponent.g.cs index afe3e662e1..d344b33798 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCharge.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCharge.WindowsRuntimeComponent.g.cs @@ -385,7 +385,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ElectricCharge other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -399,7 +399,7 @@ public override bool Equals(object obj) public bool Equals(ElectricCharge other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -475,7 +475,7 @@ public double As(ElectricChargeUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -485,7 +485,7 @@ public double As(ElectricChargeUnit unit) /// A ElectricCharge with the specified unit. public ElectricCharge ToUnit(ElectricChargeUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ElectricCharge(convertedValue, unit); } @@ -494,24 +494,33 @@ public ElectricCharge ToUnit(ElectricChargeUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ElectricCharge AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ElectricChargeUnit.Coulomb: - return new ElectricCharge(_value, BaseUnit); + case ElectricChargeUnit.Coulomb: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ElectricChargeUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ElectricCharge ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ElectricCharge(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ElectricChargeUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricChargeDensity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricChargeDensity.WindowsRuntimeComponent.g.cs index d3d6c3b2e8..21ace9aef6 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricChargeDensity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricChargeDensity.WindowsRuntimeComponent.g.cs @@ -385,7 +385,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ElectricChargeDensity other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -399,7 +399,7 @@ public override bool Equals(object obj) public bool Equals(ElectricChargeDensity other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -475,7 +475,7 @@ public double As(ElectricChargeDensityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -485,7 +485,7 @@ public double As(ElectricChargeDensityUnit unit) /// A ElectricChargeDensity with the specified unit. public ElectricChargeDensity ToUnit(ElectricChargeDensityUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ElectricChargeDensity(convertedValue, unit); } @@ -494,24 +494,33 @@ public ElectricChargeDensity ToUnit(ElectricChargeDensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ElectricChargeDensity AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ElectricChargeDensityUnit.CoulombPerCubicMeter: - return new ElectricChargeDensity(_value, BaseUnit); + case ElectricChargeDensityUnit.CoulombPerCubicMeter: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ElectricChargeDensityUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ElectricChargeDensity ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ElectricChargeDensity(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ElectricChargeDensityUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductance.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductance.WindowsRuntimeComponent.g.cs index fdacb57502..8241aa7a22 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductance.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductance.WindowsRuntimeComponent.g.cs @@ -415,7 +415,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ElectricConductance other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -429,7 +429,7 @@ public override bool Equals(object obj) public bool Equals(ElectricConductance other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -505,7 +505,7 @@ public double As(ElectricConductanceUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -515,7 +515,7 @@ public double As(ElectricConductanceUnit unit) /// A ElectricConductance with the specified unit. public ElectricConductance ToUnit(ElectricConductanceUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ElectricConductance(convertedValue, unit); } @@ -524,28 +524,35 @@ public ElectricConductance ToUnit(ElectricConductanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ElectricConductance AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ElectricConductanceUnit.Microsiemens: - return new ElectricConductance((_value) * 1e-6d, BaseUnit); - case ElectricConductanceUnit.Millisiemens: - return new ElectricConductance((_value) * 1e-3d, BaseUnit); - case ElectricConductanceUnit.Siemens: - return new ElectricConductance(_value, BaseUnit); + case ElectricConductanceUnit.Microsiemens: return (_value) * 1e-6d; + case ElectricConductanceUnit.Millisiemens: return (_value) * 1e-3d; + case ElectricConductanceUnit.Siemens: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ElectricConductanceUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ElectricConductance ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ElectricConductance(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ElectricConductanceUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductivity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductivity.WindowsRuntimeComponent.g.cs index 882618e4bf..e1c383e963 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductivity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductivity.WindowsRuntimeComponent.g.cs @@ -385,7 +385,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ElectricConductivity other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -399,7 +399,7 @@ public override bool Equals(object obj) public bool Equals(ElectricConductivity other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -475,7 +475,7 @@ public double As(ElectricConductivityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -485,7 +485,7 @@ public double As(ElectricConductivityUnit unit) /// A ElectricConductivity with the specified unit. public ElectricConductivity ToUnit(ElectricConductivityUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ElectricConductivity(convertedValue, unit); } @@ -494,24 +494,33 @@ public ElectricConductivity ToUnit(ElectricConductivityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ElectricConductivity AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ElectricConductivityUnit.SiemensPerMeter: - return new ElectricConductivity(_value, BaseUnit); + case ElectricConductivityUnit.SiemensPerMeter: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ElectricConductivityUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ElectricConductivity ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ElectricConductivity(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ElectricConductivityUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrent.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrent.WindowsRuntimeComponent.g.cs index 7b9e4efde3..dfc6a0dd0d 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrent.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrent.WindowsRuntimeComponent.g.cs @@ -487,7 +487,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ElectricCurrent other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -501,7 +501,7 @@ public override bool Equals(object obj) public bool Equals(ElectricCurrent other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -577,7 +577,7 @@ public double As(ElectricCurrentUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -587,7 +587,7 @@ public double As(ElectricCurrentUnit unit) /// A ElectricCurrent with the specified unit. public ElectricCurrent ToUnit(ElectricCurrentUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ElectricCurrent(convertedValue, unit); } @@ -596,38 +596,40 @@ public ElectricCurrent ToUnit(ElectricCurrentUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ElectricCurrent AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ElectricCurrentUnit.Ampere: - return new ElectricCurrent(_value, BaseUnit); - case ElectricCurrentUnit.Centiampere: - return new ElectricCurrent((_value) * 1e-2d, BaseUnit); - case ElectricCurrentUnit.Kiloampere: - return new ElectricCurrent((_value) * 1e3d, BaseUnit); - case ElectricCurrentUnit.Megaampere: - return new ElectricCurrent((_value) * 1e6d, BaseUnit); - case ElectricCurrentUnit.Microampere: - return new ElectricCurrent((_value) * 1e-6d, BaseUnit); - case ElectricCurrentUnit.Milliampere: - return new ElectricCurrent((_value) * 1e-3d, BaseUnit); - case ElectricCurrentUnit.Nanoampere: - return new ElectricCurrent((_value) * 1e-9d, BaseUnit); - case ElectricCurrentUnit.Picoampere: - return new ElectricCurrent((_value) * 1e-12d, BaseUnit); + case ElectricCurrentUnit.Ampere: return _value; + case ElectricCurrentUnit.Centiampere: return (_value) * 1e-2d; + case ElectricCurrentUnit.Kiloampere: return (_value) * 1e3d; + case ElectricCurrentUnit.Megaampere: return (_value) * 1e6d; + case ElectricCurrentUnit.Microampere: return (_value) * 1e-6d; + case ElectricCurrentUnit.Milliampere: return (_value) * 1e-3d; + case ElectricCurrentUnit.Nanoampere: return (_value) * 1e-9d; + case ElectricCurrentUnit.Picoampere: return (_value) * 1e-12d; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ElectricCurrentUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ElectricCurrent ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ElectricCurrent(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ElectricCurrentUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentDensity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentDensity.WindowsRuntimeComponent.g.cs index b5d5af7b1c..b4dd57091b 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentDensity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentDensity.WindowsRuntimeComponent.g.cs @@ -385,7 +385,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ElectricCurrentDensity other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -399,7 +399,7 @@ public override bool Equals(object obj) public bool Equals(ElectricCurrentDensity other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -475,7 +475,7 @@ public double As(ElectricCurrentDensityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -485,7 +485,7 @@ public double As(ElectricCurrentDensityUnit unit) /// A ElectricCurrentDensity with the specified unit. public ElectricCurrentDensity ToUnit(ElectricCurrentDensityUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ElectricCurrentDensity(convertedValue, unit); } @@ -494,24 +494,33 @@ public ElectricCurrentDensity ToUnit(ElectricCurrentDensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ElectricCurrentDensity AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ElectricCurrentDensityUnit.AmperePerSquareMeter: - return new ElectricCurrentDensity(_value, BaseUnit); + case ElectricCurrentDensityUnit.AmperePerSquareMeter: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ElectricCurrentDensityUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ElectricCurrentDensity ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ElectricCurrentDensity(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ElectricCurrentDensityUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentGradient.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentGradient.WindowsRuntimeComponent.g.cs index 32f5a1fa01..56ac03e8b3 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentGradient.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentGradient.WindowsRuntimeComponent.g.cs @@ -382,7 +382,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ElectricCurrentGradient other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -396,7 +396,7 @@ public override bool Equals(object obj) public bool Equals(ElectricCurrentGradient other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -472,7 +472,7 @@ public double As(ElectricCurrentGradientUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -482,7 +482,7 @@ public double As(ElectricCurrentGradientUnit unit) /// A ElectricCurrentGradient with the specified unit. public ElectricCurrentGradient ToUnit(ElectricCurrentGradientUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ElectricCurrentGradient(convertedValue, unit); } @@ -491,24 +491,33 @@ public ElectricCurrentGradient ToUnit(ElectricCurrentGradientUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ElectricCurrentGradient AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ElectricCurrentGradientUnit.AmperePerSecond: - return new ElectricCurrentGradient(_value, BaseUnit); + case ElectricCurrentGradientUnit.AmperePerSecond: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ElectricCurrentGradientUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ElectricCurrentGradient ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ElectricCurrentGradient(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ElectricCurrentGradientUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricField.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricField.WindowsRuntimeComponent.g.cs index 9232262da4..5a4249bd1a 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricField.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricField.WindowsRuntimeComponent.g.cs @@ -385,7 +385,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ElectricField other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -399,7 +399,7 @@ public override bool Equals(object obj) public bool Equals(ElectricField other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -475,7 +475,7 @@ public double As(ElectricFieldUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -485,7 +485,7 @@ public double As(ElectricFieldUnit unit) /// A ElectricField with the specified unit. public ElectricField ToUnit(ElectricFieldUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ElectricField(convertedValue, unit); } @@ -494,24 +494,33 @@ public ElectricField ToUnit(ElectricFieldUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ElectricField AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ElectricFieldUnit.VoltPerMeter: - return new ElectricField(_value, BaseUnit); + case ElectricFieldUnit.VoltPerMeter: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ElectricFieldUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ElectricField ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ElectricField(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ElectricFieldUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricInductance.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricInductance.WindowsRuntimeComponent.g.cs index 85808f06f6..2f78398530 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricInductance.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricInductance.WindowsRuntimeComponent.g.cs @@ -430,7 +430,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ElectricInductance other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -444,7 +444,7 @@ public override bool Equals(object obj) public bool Equals(ElectricInductance other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -520,7 +520,7 @@ public double As(ElectricInductanceUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -530,7 +530,7 @@ public double As(ElectricInductanceUnit unit) /// A ElectricInductance with the specified unit. public ElectricInductance ToUnit(ElectricInductanceUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ElectricInductance(convertedValue, unit); } @@ -539,30 +539,36 @@ public ElectricInductance ToUnit(ElectricInductanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ElectricInductance AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ElectricInductanceUnit.Henry: - return new ElectricInductance(_value, BaseUnit); - case ElectricInductanceUnit.Microhenry: - return new ElectricInductance((_value) * 1e-6d, BaseUnit); - case ElectricInductanceUnit.Millihenry: - return new ElectricInductance((_value) * 1e-3d, BaseUnit); - case ElectricInductanceUnit.Nanohenry: - return new ElectricInductance((_value) * 1e-9d, BaseUnit); + case ElectricInductanceUnit.Henry: return _value; + case ElectricInductanceUnit.Microhenry: return (_value) * 1e-6d; + case ElectricInductanceUnit.Millihenry: return (_value) * 1e-3d; + case ElectricInductanceUnit.Nanohenry: return (_value) * 1e-9d; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ElectricInductanceUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ElectricInductance ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ElectricInductance(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ElectricInductanceUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotential.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotential.WindowsRuntimeComponent.g.cs index a75690004d..7ea4055b1c 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotential.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotential.WindowsRuntimeComponent.g.cs @@ -442,7 +442,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ElectricPotential other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -456,7 +456,7 @@ public override bool Equals(object obj) public bool Equals(ElectricPotential other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -532,7 +532,7 @@ public double As(ElectricPotentialUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -542,7 +542,7 @@ public double As(ElectricPotentialUnit unit) /// A ElectricPotential with the specified unit. public ElectricPotential ToUnit(ElectricPotentialUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ElectricPotential(convertedValue, unit); } @@ -551,32 +551,37 @@ public ElectricPotential ToUnit(ElectricPotentialUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ElectricPotential AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ElectricPotentialUnit.Kilovolt: - return new ElectricPotential((_value) * 1e3d, BaseUnit); - case ElectricPotentialUnit.Megavolt: - return new ElectricPotential((_value) * 1e6d, BaseUnit); - case ElectricPotentialUnit.Microvolt: - return new ElectricPotential((_value) * 1e-6d, BaseUnit); - case ElectricPotentialUnit.Millivolt: - return new ElectricPotential((_value) * 1e-3d, BaseUnit); - case ElectricPotentialUnit.Volt: - return new ElectricPotential(_value, BaseUnit); + case ElectricPotentialUnit.Kilovolt: return (_value) * 1e3d; + case ElectricPotentialUnit.Megavolt: return (_value) * 1e6d; + case ElectricPotentialUnit.Microvolt: return (_value) * 1e-6d; + case ElectricPotentialUnit.Millivolt: return (_value) * 1e-3d; + case ElectricPotentialUnit.Volt: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ElectricPotentialUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ElectricPotential ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ElectricPotential(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ElectricPotentialUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialAc.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialAc.WindowsRuntimeComponent.g.cs index cd672a8021..373cd48638 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialAc.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialAc.WindowsRuntimeComponent.g.cs @@ -442,7 +442,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ElectricPotentialAc other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -456,7 +456,7 @@ public override bool Equals(object obj) public bool Equals(ElectricPotentialAc other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -532,7 +532,7 @@ public double As(ElectricPotentialAcUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -542,7 +542,7 @@ public double As(ElectricPotentialAcUnit unit) /// A ElectricPotentialAc with the specified unit. public ElectricPotentialAc ToUnit(ElectricPotentialAcUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ElectricPotentialAc(convertedValue, unit); } @@ -551,32 +551,37 @@ public ElectricPotentialAc ToUnit(ElectricPotentialAcUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ElectricPotentialAc AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ElectricPotentialAcUnit.KilovoltAc: - return new ElectricPotentialAc((_value) * 1e3d, BaseUnit); - case ElectricPotentialAcUnit.MegavoltAc: - return new ElectricPotentialAc((_value) * 1e6d, BaseUnit); - case ElectricPotentialAcUnit.MicrovoltAc: - return new ElectricPotentialAc((_value) * 1e-6d, BaseUnit); - case ElectricPotentialAcUnit.MillivoltAc: - return new ElectricPotentialAc((_value) * 1e-3d, BaseUnit); - case ElectricPotentialAcUnit.VoltAc: - return new ElectricPotentialAc(_value, BaseUnit); + case ElectricPotentialAcUnit.KilovoltAc: return (_value) * 1e3d; + case ElectricPotentialAcUnit.MegavoltAc: return (_value) * 1e6d; + case ElectricPotentialAcUnit.MicrovoltAc: return (_value) * 1e-6d; + case ElectricPotentialAcUnit.MillivoltAc: return (_value) * 1e-3d; + case ElectricPotentialAcUnit.VoltAc: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ElectricPotentialAcUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ElectricPotentialAc ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ElectricPotentialAc(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ElectricPotentialAcUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialDc.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialDc.WindowsRuntimeComponent.g.cs index 75259bcb7d..efad2fd558 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialDc.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialDc.WindowsRuntimeComponent.g.cs @@ -442,7 +442,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ElectricPotentialDc other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -456,7 +456,7 @@ public override bool Equals(object obj) public bool Equals(ElectricPotentialDc other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -532,7 +532,7 @@ public double As(ElectricPotentialDcUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -542,7 +542,7 @@ public double As(ElectricPotentialDcUnit unit) /// A ElectricPotentialDc with the specified unit. public ElectricPotentialDc ToUnit(ElectricPotentialDcUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ElectricPotentialDc(convertedValue, unit); } @@ -551,32 +551,37 @@ public ElectricPotentialDc ToUnit(ElectricPotentialDcUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ElectricPotentialDc AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ElectricPotentialDcUnit.KilovoltDc: - return new ElectricPotentialDc((_value) * 1e3d, BaseUnit); - case ElectricPotentialDcUnit.MegavoltDc: - return new ElectricPotentialDc((_value) * 1e6d, BaseUnit); - case ElectricPotentialDcUnit.MicrovoltDc: - return new ElectricPotentialDc((_value) * 1e-6d, BaseUnit); - case ElectricPotentialDcUnit.MillivoltDc: - return new ElectricPotentialDc((_value) * 1e-3d, BaseUnit); - case ElectricPotentialDcUnit.VoltDc: - return new ElectricPotentialDc(_value, BaseUnit); + case ElectricPotentialDcUnit.KilovoltDc: return (_value) * 1e3d; + case ElectricPotentialDcUnit.MegavoltDc: return (_value) * 1e6d; + case ElectricPotentialDcUnit.MicrovoltDc: return (_value) * 1e-6d; + case ElectricPotentialDcUnit.MillivoltDc: return (_value) * 1e-3d; + case ElectricPotentialDcUnit.VoltDc: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ElectricPotentialDcUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ElectricPotentialDc ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ElectricPotentialDc(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ElectricPotentialDcUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistance.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistance.WindowsRuntimeComponent.g.cs index 87b43bf943..ed278ff705 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistance.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistance.WindowsRuntimeComponent.g.cs @@ -442,7 +442,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ElectricResistance other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -456,7 +456,7 @@ public override bool Equals(object obj) public bool Equals(ElectricResistance other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -532,7 +532,7 @@ public double As(ElectricResistanceUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -542,7 +542,7 @@ public double As(ElectricResistanceUnit unit) /// A ElectricResistance with the specified unit. public ElectricResistance ToUnit(ElectricResistanceUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ElectricResistance(convertedValue, unit); } @@ -551,32 +551,37 @@ public ElectricResistance ToUnit(ElectricResistanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ElectricResistance AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ElectricResistanceUnit.Gigaohm: - return new ElectricResistance((_value) * 1e9d, BaseUnit); - case ElectricResistanceUnit.Kiloohm: - return new ElectricResistance((_value) * 1e3d, BaseUnit); - case ElectricResistanceUnit.Megaohm: - return new ElectricResistance((_value) * 1e6d, BaseUnit); - case ElectricResistanceUnit.Milliohm: - return new ElectricResistance((_value) * 1e-3d, BaseUnit); - case ElectricResistanceUnit.Ohm: - return new ElectricResistance(_value, BaseUnit); + case ElectricResistanceUnit.Gigaohm: return (_value) * 1e9d; + case ElectricResistanceUnit.Kiloohm: return (_value) * 1e3d; + case ElectricResistanceUnit.Megaohm: return (_value) * 1e6d; + case ElectricResistanceUnit.Milliohm: return (_value) * 1e-3d; + case ElectricResistanceUnit.Ohm: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ElectricResistanceUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ElectricResistance ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ElectricResistance(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ElectricResistanceUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistivity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistivity.WindowsRuntimeComponent.g.cs index 4e13b4d07a..14a0a42421 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistivity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistivity.WindowsRuntimeComponent.g.cs @@ -580,7 +580,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ElectricResistivity other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -594,7 +594,7 @@ public override bool Equals(object obj) public bool Equals(ElectricResistivity other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -670,7 +670,7 @@ public double As(ElectricResistivityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -680,7 +680,7 @@ public double As(ElectricResistivityUnit unit) /// A ElectricResistivity with the specified unit. public ElectricResistivity ToUnit(ElectricResistivityUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ElectricResistivity(convertedValue, unit); } @@ -689,50 +689,46 @@ public ElectricResistivity ToUnit(ElectricResistivityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ElectricResistivity AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ElectricResistivityUnit.KiloohmCentimeter: - return new ElectricResistivity((_value/100) * 1e3d, BaseUnit); - case ElectricResistivityUnit.KiloohmMeter: - return new ElectricResistivity((_value) * 1e3d, BaseUnit); - case ElectricResistivityUnit.MegaohmCentimeter: - return new ElectricResistivity((_value/100) * 1e6d, BaseUnit); - case ElectricResistivityUnit.MegaohmMeter: - return new ElectricResistivity((_value) * 1e6d, BaseUnit); - case ElectricResistivityUnit.MicroohmCentimeter: - return new ElectricResistivity((_value/100) * 1e-6d, BaseUnit); - case ElectricResistivityUnit.MicroohmMeter: - return new ElectricResistivity((_value) * 1e-6d, BaseUnit); - case ElectricResistivityUnit.MilliohmCentimeter: - return new ElectricResistivity((_value/100) * 1e-3d, BaseUnit); - case ElectricResistivityUnit.MilliohmMeter: - return new ElectricResistivity((_value) * 1e-3d, BaseUnit); - case ElectricResistivityUnit.NanoohmCentimeter: - return new ElectricResistivity((_value/100) * 1e-9d, BaseUnit); - case ElectricResistivityUnit.NanoohmMeter: - return new ElectricResistivity((_value) * 1e-9d, BaseUnit); - case ElectricResistivityUnit.OhmCentimeter: - return new ElectricResistivity(_value/100, BaseUnit); - case ElectricResistivityUnit.OhmMeter: - return new ElectricResistivity(_value, BaseUnit); - case ElectricResistivityUnit.PicoohmCentimeter: - return new ElectricResistivity((_value/100) * 1e-12d, BaseUnit); - case ElectricResistivityUnit.PicoohmMeter: - return new ElectricResistivity((_value) * 1e-12d, BaseUnit); + case ElectricResistivityUnit.KiloohmCentimeter: return (_value/100) * 1e3d; + case ElectricResistivityUnit.KiloohmMeter: return (_value) * 1e3d; + case ElectricResistivityUnit.MegaohmCentimeter: return (_value/100) * 1e6d; + case ElectricResistivityUnit.MegaohmMeter: return (_value) * 1e6d; + case ElectricResistivityUnit.MicroohmCentimeter: return (_value/100) * 1e-6d; + case ElectricResistivityUnit.MicroohmMeter: return (_value) * 1e-6d; + case ElectricResistivityUnit.MilliohmCentimeter: return (_value/100) * 1e-3d; + case ElectricResistivityUnit.MilliohmMeter: return (_value) * 1e-3d; + case ElectricResistivityUnit.NanoohmCentimeter: return (_value/100) * 1e-9d; + case ElectricResistivityUnit.NanoohmMeter: return (_value) * 1e-9d; + case ElectricResistivityUnit.OhmCentimeter: return _value/100; + case ElectricResistivityUnit.OhmMeter: return _value; + case ElectricResistivityUnit.PicoohmCentimeter: return (_value/100) * 1e-12d; + case ElectricResistivityUnit.PicoohmMeter: return (_value) * 1e-12d; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ElectricResistivityUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ElectricResistivity ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ElectricResistivity(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ElectricResistivityUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Energy.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Energy.WindowsRuntimeComponent.g.cs index ae66713ee1..8f4285ec3e 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Energy.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Energy.WindowsRuntimeComponent.g.cs @@ -697,7 +697,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Energy other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -711,7 +711,7 @@ public override bool Equals(object obj) public bool Equals(Energy other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -787,7 +787,7 @@ public double As(EnergyUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -797,7 +797,7 @@ public double As(EnergyUnit unit) /// A Energy with the specified unit. public Energy ToUnit(EnergyUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Energy(convertedValue, unit); } @@ -806,66 +806,54 @@ public Energy ToUnit(EnergyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Energy AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case EnergyUnit.BritishThermalUnit: - return new Energy(_value*1055.05585262, BaseUnit); - case EnergyUnit.Calorie: - return new Energy(_value*4.184, BaseUnit); - case EnergyUnit.DecathermEc: - return new Energy((_value*1.05505585262e8) * 1e1d, BaseUnit); - case EnergyUnit.DecathermImperial: - return new Energy((_value*1.05505585257348e8) * 1e1d, BaseUnit); - case EnergyUnit.DecathermUs: - return new Energy((_value*1.054804e8) * 1e1d, BaseUnit); - case EnergyUnit.ElectronVolt: - return new Energy(_value*1.602176565e-19, BaseUnit); - case EnergyUnit.Erg: - return new Energy(_value*1e-7, BaseUnit); - case EnergyUnit.FootPound: - return new Energy(_value*1.355817948, BaseUnit); - case EnergyUnit.GigabritishThermalUnit: - return new Energy((_value*1055.05585262) * 1e9d, BaseUnit); - case EnergyUnit.GigawattHour: - return new Energy((_value*3600d) * 1e9d, BaseUnit); - case EnergyUnit.Joule: - return new Energy(_value, BaseUnit); - case EnergyUnit.KilobritishThermalUnit: - return new Energy((_value*1055.05585262) * 1e3d, BaseUnit); - case EnergyUnit.Kilocalorie: - return new Energy((_value*4.184) * 1e3d, BaseUnit); - case EnergyUnit.Kilojoule: - return new Energy((_value) * 1e3d, BaseUnit); - case EnergyUnit.KilowattHour: - return new Energy((_value*3600d) * 1e3d, BaseUnit); - case EnergyUnit.MegabritishThermalUnit: - return new Energy((_value*1055.05585262) * 1e6d, BaseUnit); - case EnergyUnit.Megajoule: - return new Energy((_value) * 1e6d, BaseUnit); - case EnergyUnit.MegawattHour: - return new Energy((_value*3600d) * 1e6d, BaseUnit); - case EnergyUnit.ThermEc: - return new Energy(_value*1.05505585262e8, BaseUnit); - case EnergyUnit.ThermImperial: - return new Energy(_value*1.05505585257348e8, BaseUnit); - case EnergyUnit.ThermUs: - return new Energy(_value*1.054804e8, BaseUnit); - case EnergyUnit.WattHour: - return new Energy(_value*3600d, BaseUnit); + case EnergyUnit.BritishThermalUnit: return _value*1055.05585262; + case EnergyUnit.Calorie: return _value*4.184; + case EnergyUnit.DecathermEc: return (_value*1.05505585262e8) * 1e1d; + case EnergyUnit.DecathermImperial: return (_value*1.05505585257348e8) * 1e1d; + case EnergyUnit.DecathermUs: return (_value*1.054804e8) * 1e1d; + case EnergyUnit.ElectronVolt: return _value*1.602176565e-19; + case EnergyUnit.Erg: return _value*1e-7; + case EnergyUnit.FootPound: return _value*1.355817948; + case EnergyUnit.GigabritishThermalUnit: return (_value*1055.05585262) * 1e9d; + case EnergyUnit.GigawattHour: return (_value*3600d) * 1e9d; + case EnergyUnit.Joule: return _value; + case EnergyUnit.KilobritishThermalUnit: return (_value*1055.05585262) * 1e3d; + case EnergyUnit.Kilocalorie: return (_value*4.184) * 1e3d; + case EnergyUnit.Kilojoule: return (_value) * 1e3d; + case EnergyUnit.KilowattHour: return (_value*3600d) * 1e3d; + case EnergyUnit.MegabritishThermalUnit: return (_value*1055.05585262) * 1e6d; + case EnergyUnit.Megajoule: return (_value) * 1e6d; + case EnergyUnit.MegawattHour: return (_value*3600d) * 1e6d; + case EnergyUnit.ThermEc: return _value*1.05505585262e8; + case EnergyUnit.ThermImperial: return _value*1.05505585257348e8; + case EnergyUnit.ThermUs: return _value*1.054804e8; + case EnergyUnit.WattHour: return _value*3600d; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(EnergyUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Energy ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Energy(baseUnitValue, BaseUnit); + } + + private double GetValueAs(EnergyUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Entropy.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Entropy.WindowsRuntimeComponent.g.cs index aa0393c7da..a0c3b9df03 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Entropy.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Entropy.WindowsRuntimeComponent.g.cs @@ -472,7 +472,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Entropy other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -486,7 +486,7 @@ public override bool Equals(object obj) public bool Equals(Entropy other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -562,7 +562,7 @@ public double As(EntropyUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -572,7 +572,7 @@ public double As(EntropyUnit unit) /// A Entropy with the specified unit. public Entropy ToUnit(EntropyUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Entropy(convertedValue, unit); } @@ -581,36 +581,39 @@ public Entropy ToUnit(EntropyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Entropy AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case EntropyUnit.CaloriePerKelvin: - return new Entropy(_value*4.184, BaseUnit); - case EntropyUnit.JoulePerDegreeCelsius: - return new Entropy(_value, BaseUnit); - case EntropyUnit.JoulePerKelvin: - return new Entropy(_value, BaseUnit); - case EntropyUnit.KilocaloriePerKelvin: - return new Entropy((_value*4.184) * 1e3d, BaseUnit); - case EntropyUnit.KilojoulePerDegreeCelsius: - return new Entropy((_value) * 1e3d, BaseUnit); - case EntropyUnit.KilojoulePerKelvin: - return new Entropy((_value) * 1e3d, BaseUnit); - case EntropyUnit.MegajoulePerKelvin: - return new Entropy((_value) * 1e6d, BaseUnit); + case EntropyUnit.CaloriePerKelvin: return _value*4.184; + case EntropyUnit.JoulePerDegreeCelsius: return _value; + case EntropyUnit.JoulePerKelvin: return _value; + case EntropyUnit.KilocaloriePerKelvin: return (_value*4.184) * 1e3d; + case EntropyUnit.KilojoulePerDegreeCelsius: return (_value) * 1e3d; + case EntropyUnit.KilojoulePerKelvin: return (_value) * 1e3d; + case EntropyUnit.MegajoulePerKelvin: return (_value) * 1e6d; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(EntropyUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Entropy ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Entropy(baseUnitValue, BaseUnit); + } + + private double GetValueAs(EntropyUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Force.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Force.WindowsRuntimeComponent.g.cs index 45c6b1065a..7975ddf12a 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Force.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Force.WindowsRuntimeComponent.g.cs @@ -562,7 +562,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Force other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -576,7 +576,7 @@ public override bool Equals(object obj) public bool Equals(Force other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -652,7 +652,7 @@ public double As(ForceUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -662,7 +662,7 @@ public double As(ForceUnit unit) /// A Force with the specified unit. public Force ToUnit(ForceUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Force(convertedValue, unit); } @@ -671,48 +671,45 @@ public Force ToUnit(ForceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Force AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ForceUnit.Decanewton: - return new Force((_value) * 1e1d, BaseUnit); - case ForceUnit.Dyn: - return new Force(_value/1e5, BaseUnit); - case ForceUnit.KilogramForce: - return new Force(_value*9.80665002864, BaseUnit); - case ForceUnit.Kilonewton: - return new Force((_value) * 1e3d, BaseUnit); - case ForceUnit.KiloPond: - return new Force(_value*9.80665002864, BaseUnit); - case ForceUnit.Meganewton: - return new Force((_value) * 1e6d, BaseUnit); - case ForceUnit.Micronewton: - return new Force((_value) * 1e-6d, BaseUnit); - case ForceUnit.Millinewton: - return new Force((_value) * 1e-3d, BaseUnit); - case ForceUnit.Newton: - return new Force(_value, BaseUnit); - case ForceUnit.OunceForce: - return new Force(_value*2.780138509537812e-1, BaseUnit); - case ForceUnit.Poundal: - return new Force(_value*0.13825502798973041652092282466083, BaseUnit); - case ForceUnit.PoundForce: - return new Force(_value*4.4482216152605095551842641431421, BaseUnit); - case ForceUnit.TonneForce: - return new Force(_value*9.80665002864e3, BaseUnit); + case ForceUnit.Decanewton: return (_value) * 1e1d; + case ForceUnit.Dyn: return _value/1e5; + case ForceUnit.KilogramForce: return _value*9.80665002864; + case ForceUnit.Kilonewton: return (_value) * 1e3d; + case ForceUnit.KiloPond: return _value*9.80665002864; + case ForceUnit.Meganewton: return (_value) * 1e6d; + case ForceUnit.Micronewton: return (_value) * 1e-6d; + case ForceUnit.Millinewton: return (_value) * 1e-3d; + case ForceUnit.Newton: return _value; + case ForceUnit.OunceForce: return _value*2.780138509537812e-1; + case ForceUnit.Poundal: return _value*0.13825502798973041652092282466083; + case ForceUnit.PoundForce: return _value*4.4482216152605095551842641431421; + case ForceUnit.TonneForce: return _value*9.80665002864e3; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ForceUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Force ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Force(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ForceUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForceChangeRate.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForceChangeRate.WindowsRuntimeComponent.g.cs index be431a94ef..9edd3481fc 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForceChangeRate.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForceChangeRate.WindowsRuntimeComponent.g.cs @@ -532,7 +532,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ForceChangeRate other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -546,7 +546,7 @@ public override bool Equals(object obj) public bool Equals(ForceChangeRate other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -622,7 +622,7 @@ public double As(ForceChangeRateUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -632,7 +632,7 @@ public double As(ForceChangeRateUnit unit) /// A ForceChangeRate with the specified unit. public ForceChangeRate ToUnit(ForceChangeRateUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ForceChangeRate(convertedValue, unit); } @@ -641,44 +641,43 @@ public ForceChangeRate ToUnit(ForceChangeRateUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ForceChangeRate AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ForceChangeRateUnit.CentinewtonPerSecond: - return new ForceChangeRate((_value) * 1e-2d, BaseUnit); - case ForceChangeRateUnit.DecanewtonPerMinute: - return new ForceChangeRate((_value/60) * 1e1d, BaseUnit); - case ForceChangeRateUnit.DecanewtonPerSecond: - return new ForceChangeRate((_value) * 1e1d, BaseUnit); - case ForceChangeRateUnit.DecinewtonPerSecond: - return new ForceChangeRate((_value) * 1e-1d, BaseUnit); - case ForceChangeRateUnit.KilonewtonPerMinute: - return new ForceChangeRate((_value/60) * 1e3d, BaseUnit); - case ForceChangeRateUnit.KilonewtonPerSecond: - return new ForceChangeRate((_value) * 1e3d, BaseUnit); - case ForceChangeRateUnit.MicronewtonPerSecond: - return new ForceChangeRate((_value) * 1e-6d, BaseUnit); - case ForceChangeRateUnit.MillinewtonPerSecond: - return new ForceChangeRate((_value) * 1e-3d, BaseUnit); - case ForceChangeRateUnit.NanonewtonPerSecond: - return new ForceChangeRate((_value) * 1e-9d, BaseUnit); - case ForceChangeRateUnit.NewtonPerMinute: - return new ForceChangeRate(_value/60, BaseUnit); - case ForceChangeRateUnit.NewtonPerSecond: - return new ForceChangeRate(_value, BaseUnit); + case ForceChangeRateUnit.CentinewtonPerSecond: return (_value) * 1e-2d; + case ForceChangeRateUnit.DecanewtonPerMinute: return (_value/60) * 1e1d; + case ForceChangeRateUnit.DecanewtonPerSecond: return (_value) * 1e1d; + case ForceChangeRateUnit.DecinewtonPerSecond: return (_value) * 1e-1d; + case ForceChangeRateUnit.KilonewtonPerMinute: return (_value/60) * 1e3d; + case ForceChangeRateUnit.KilonewtonPerSecond: return (_value) * 1e3d; + case ForceChangeRateUnit.MicronewtonPerSecond: return (_value) * 1e-6d; + case ForceChangeRateUnit.MillinewtonPerSecond: return (_value) * 1e-3d; + case ForceChangeRateUnit.NanonewtonPerSecond: return (_value) * 1e-9d; + case ForceChangeRateUnit.NewtonPerMinute: return _value/60; + case ForceChangeRateUnit.NewtonPerSecond: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ForceChangeRateUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ForceChangeRate ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ForceChangeRate(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ForceChangeRateUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForcePerLength.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForcePerLength.WindowsRuntimeComponent.g.cs index c26b0826b4..8644eace30 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForcePerLength.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForcePerLength.WindowsRuntimeComponent.g.cs @@ -502,7 +502,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ForcePerLength other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -516,7 +516,7 @@ public override bool Equals(object obj) public bool Equals(ForcePerLength other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -592,7 +592,7 @@ public double As(ForcePerLengthUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -602,7 +602,7 @@ public double As(ForcePerLengthUnit unit) /// A ForcePerLength with the specified unit. public ForcePerLength ToUnit(ForcePerLengthUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ForcePerLength(convertedValue, unit); } @@ -611,40 +611,41 @@ public ForcePerLength ToUnit(ForcePerLengthUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ForcePerLength AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ForcePerLengthUnit.CentinewtonPerMeter: - return new ForcePerLength((_value) * 1e-2d, BaseUnit); - case ForcePerLengthUnit.DecinewtonPerMeter: - return new ForcePerLength((_value) * 1e-1d, BaseUnit); - case ForcePerLengthUnit.KilogramForcePerMeter: - return new ForcePerLength(_value*9.80665002864, BaseUnit); - case ForcePerLengthUnit.KilonewtonPerMeter: - return new ForcePerLength((_value) * 1e3d, BaseUnit); - case ForcePerLengthUnit.MeganewtonPerMeter: - return new ForcePerLength((_value) * 1e6d, BaseUnit); - case ForcePerLengthUnit.MicronewtonPerMeter: - return new ForcePerLength((_value) * 1e-6d, BaseUnit); - case ForcePerLengthUnit.MillinewtonPerMeter: - return new ForcePerLength((_value) * 1e-3d, BaseUnit); - case ForcePerLengthUnit.NanonewtonPerMeter: - return new ForcePerLength((_value) * 1e-9d, BaseUnit); - case ForcePerLengthUnit.NewtonPerMeter: - return new ForcePerLength(_value, BaseUnit); + case ForcePerLengthUnit.CentinewtonPerMeter: return (_value) * 1e-2d; + case ForcePerLengthUnit.DecinewtonPerMeter: return (_value) * 1e-1d; + case ForcePerLengthUnit.KilogramForcePerMeter: return _value*9.80665002864; + case ForcePerLengthUnit.KilonewtonPerMeter: return (_value) * 1e3d; + case ForcePerLengthUnit.MeganewtonPerMeter: return (_value) * 1e6d; + case ForcePerLengthUnit.MicronewtonPerMeter: return (_value) * 1e-6d; + case ForcePerLengthUnit.MillinewtonPerMeter: return (_value) * 1e-3d; + case ForcePerLengthUnit.NanonewtonPerMeter: return (_value) * 1e-9d; + case ForcePerLengthUnit.NewtonPerMeter: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ForcePerLengthUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ForcePerLength ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ForcePerLength(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ForcePerLengthUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Frequency.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Frequency.WindowsRuntimeComponent.g.cs index 040699ac7f..c6f0aa9fbb 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Frequency.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Frequency.WindowsRuntimeComponent.g.cs @@ -487,7 +487,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Frequency other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -501,7 +501,7 @@ public override bool Equals(object obj) public bool Equals(Frequency other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -577,7 +577,7 @@ public double As(FrequencyUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -587,7 +587,7 @@ public double As(FrequencyUnit unit) /// A Frequency with the specified unit. public Frequency ToUnit(FrequencyUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Frequency(convertedValue, unit); } @@ -596,38 +596,40 @@ public Frequency ToUnit(FrequencyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Frequency AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case FrequencyUnit.CyclePerHour: - return new Frequency(_value/3600, BaseUnit); - case FrequencyUnit.CyclePerMinute: - return new Frequency(_value/60, BaseUnit); - case FrequencyUnit.Gigahertz: - return new Frequency((_value) * 1e9d, BaseUnit); - case FrequencyUnit.Hertz: - return new Frequency(_value, BaseUnit); - case FrequencyUnit.Kilohertz: - return new Frequency((_value) * 1e3d, BaseUnit); - case FrequencyUnit.Megahertz: - return new Frequency((_value) * 1e6d, BaseUnit); - case FrequencyUnit.RadianPerSecond: - return new Frequency(_value/6.2831853072, BaseUnit); - case FrequencyUnit.Terahertz: - return new Frequency((_value) * 1e12d, BaseUnit); + case FrequencyUnit.CyclePerHour: return _value/3600; + case FrequencyUnit.CyclePerMinute: return _value/60; + case FrequencyUnit.Gigahertz: return (_value) * 1e9d; + case FrequencyUnit.Hertz: return _value; + case FrequencyUnit.Kilohertz: return (_value) * 1e3d; + case FrequencyUnit.Megahertz: return (_value) * 1e6d; + case FrequencyUnit.RadianPerSecond: return _value/6.2831853072; + case FrequencyUnit.Terahertz: return (_value) * 1e12d; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(FrequencyUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Frequency ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Frequency(baseUnitValue, BaseUnit); + } + + private double GetValueAs(FrequencyUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatFlux.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatFlux.WindowsRuntimeComponent.g.cs index bd584ca3d6..5b9fc78b89 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatFlux.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatFlux.WindowsRuntimeComponent.g.cs @@ -637,7 +637,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(HeatFlux other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -651,7 +651,7 @@ public override bool Equals(object obj) public bool Equals(HeatFlux other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -727,7 +727,7 @@ public double As(HeatFluxUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -737,7 +737,7 @@ public double As(HeatFluxUnit unit) /// A HeatFlux with the specified unit. public HeatFlux ToUnit(HeatFluxUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new HeatFlux(convertedValue, unit); } @@ -746,58 +746,50 @@ public HeatFlux ToUnit(HeatFluxUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal HeatFlux AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case HeatFluxUnit.BtuPerHourSquareFoot: - return new HeatFlux(_value*3.15459075, BaseUnit); - case HeatFluxUnit.BtuPerMinuteSquareFoot: - return new HeatFlux(_value*1.89275445e2, BaseUnit); - case HeatFluxUnit.BtuPerSecondSquareFoot: - return new HeatFlux(_value*1.13565267e4, BaseUnit); - case HeatFluxUnit.BtuPerSecondSquareInch: - return new HeatFlux(_value*1.63533984e6, BaseUnit); - case HeatFluxUnit.CaloriePerSecondSquareCentimeter: - return new HeatFlux(_value*4.1868e4, BaseUnit); - case HeatFluxUnit.CentiwattPerSquareMeter: - return new HeatFlux((_value) * 1e-2d, BaseUnit); - case HeatFluxUnit.DeciwattPerSquareMeter: - return new HeatFlux((_value) * 1e-1d, BaseUnit); - case HeatFluxUnit.KilocaloriePerHourSquareMeter: - return new HeatFlux(_value*1.163, BaseUnit); - case HeatFluxUnit.KilocaloriePerSecondSquareCentimeter: - return new HeatFlux((_value*4.1868e4) * 1e3d, BaseUnit); - case HeatFluxUnit.KilowattPerSquareMeter: - return new HeatFlux((_value) * 1e3d, BaseUnit); - case HeatFluxUnit.MicrowattPerSquareMeter: - return new HeatFlux((_value) * 1e-6d, BaseUnit); - case HeatFluxUnit.MilliwattPerSquareMeter: - return new HeatFlux((_value) * 1e-3d, BaseUnit); - case HeatFluxUnit.NanowattPerSquareMeter: - return new HeatFlux((_value) * 1e-9d, BaseUnit); - case HeatFluxUnit.PoundForcePerFootSecond: - return new HeatFlux(_value*1.459390293720636e1, BaseUnit); - case HeatFluxUnit.PoundPerSecondCubed: - return new HeatFlux(_value*4.5359237e-1, BaseUnit); - case HeatFluxUnit.WattPerSquareFoot: - return new HeatFlux(_value*1.07639e1, BaseUnit); - case HeatFluxUnit.WattPerSquareInch: - return new HeatFlux(_value*1.5500031e3, BaseUnit); - case HeatFluxUnit.WattPerSquareMeter: - return new HeatFlux(_value, BaseUnit); + case HeatFluxUnit.BtuPerHourSquareFoot: return _value*3.15459075; + case HeatFluxUnit.BtuPerMinuteSquareFoot: return _value*1.89275445e2; + case HeatFluxUnit.BtuPerSecondSquareFoot: return _value*1.13565267e4; + case HeatFluxUnit.BtuPerSecondSquareInch: return _value*1.63533984e6; + case HeatFluxUnit.CaloriePerSecondSquareCentimeter: return _value*4.1868e4; + case HeatFluxUnit.CentiwattPerSquareMeter: return (_value) * 1e-2d; + case HeatFluxUnit.DeciwattPerSquareMeter: return (_value) * 1e-1d; + case HeatFluxUnit.KilocaloriePerHourSquareMeter: return _value*1.163; + case HeatFluxUnit.KilocaloriePerSecondSquareCentimeter: return (_value*4.1868e4) * 1e3d; + case HeatFluxUnit.KilowattPerSquareMeter: return (_value) * 1e3d; + case HeatFluxUnit.MicrowattPerSquareMeter: return (_value) * 1e-6d; + case HeatFluxUnit.MilliwattPerSquareMeter: return (_value) * 1e-3d; + case HeatFluxUnit.NanowattPerSquareMeter: return (_value) * 1e-9d; + case HeatFluxUnit.PoundForcePerFootSecond: return _value*1.459390293720636e1; + case HeatFluxUnit.PoundPerSecondCubed: return _value*4.5359237e-1; + case HeatFluxUnit.WattPerSquareFoot: return _value*1.07639e1; + case HeatFluxUnit.WattPerSquareInch: return _value*1.5500031e3; + case HeatFluxUnit.WattPerSquareMeter: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(HeatFluxUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal HeatFlux ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new HeatFlux(baseUnitValue, BaseUnit); + } + + private double GetValueAs(HeatFluxUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatTransferCoefficient.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatTransferCoefficient.WindowsRuntimeComponent.g.cs index 8312bcbd3f..16a0a50f22 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatTransferCoefficient.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatTransferCoefficient.WindowsRuntimeComponent.g.cs @@ -397,7 +397,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(HeatTransferCoefficient other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -411,7 +411,7 @@ public override bool Equals(object obj) public bool Equals(HeatTransferCoefficient other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -487,7 +487,7 @@ public double As(HeatTransferCoefficientUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -497,7 +497,7 @@ public double As(HeatTransferCoefficientUnit unit) /// A HeatTransferCoefficient with the specified unit. public HeatTransferCoefficient ToUnit(HeatTransferCoefficientUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new HeatTransferCoefficient(convertedValue, unit); } @@ -506,26 +506,34 @@ public HeatTransferCoefficient ToUnit(HeatTransferCoefficientUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal HeatTransferCoefficient AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case HeatTransferCoefficientUnit.WattPerSquareMeterCelsius: - return new HeatTransferCoefficient(_value, BaseUnit); - case HeatTransferCoefficientUnit.WattPerSquareMeterKelvin: - return new HeatTransferCoefficient(_value, BaseUnit); + case HeatTransferCoefficientUnit.WattPerSquareMeterCelsius: return _value; + case HeatTransferCoefficientUnit.WattPerSquareMeterKelvin: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(HeatTransferCoefficientUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal HeatTransferCoefficient ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new HeatTransferCoefficient(baseUnitValue, BaseUnit); + } + + private double GetValueAs(HeatTransferCoefficientUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Illuminance.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Illuminance.WindowsRuntimeComponent.g.cs index 37f1f261f6..1aacb82cf7 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Illuminance.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Illuminance.WindowsRuntimeComponent.g.cs @@ -430,7 +430,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Illuminance other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -444,7 +444,7 @@ public override bool Equals(object obj) public bool Equals(Illuminance other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -520,7 +520,7 @@ public double As(IlluminanceUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -530,7 +530,7 @@ public double As(IlluminanceUnit unit) /// A Illuminance with the specified unit. public Illuminance ToUnit(IlluminanceUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Illuminance(convertedValue, unit); } @@ -539,30 +539,36 @@ public Illuminance ToUnit(IlluminanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Illuminance AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case IlluminanceUnit.Kilolux: - return new Illuminance((_value) * 1e3d, BaseUnit); - case IlluminanceUnit.Lux: - return new Illuminance(_value, BaseUnit); - case IlluminanceUnit.Megalux: - return new Illuminance((_value) * 1e6d, BaseUnit); - case IlluminanceUnit.Millilux: - return new Illuminance((_value) * 1e-3d, BaseUnit); + case IlluminanceUnit.Kilolux: return (_value) * 1e3d; + case IlluminanceUnit.Lux: return _value; + case IlluminanceUnit.Megalux: return (_value) * 1e6d; + case IlluminanceUnit.Millilux: return (_value) * 1e-3d; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(IlluminanceUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Illuminance ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Illuminance(baseUnitValue, BaseUnit); + } + + private double GetValueAs(IlluminanceUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Information.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Information.WindowsRuntimeComponent.g.cs index 4f30d436f1..30335fc677 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Information.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Information.WindowsRuntimeComponent.g.cs @@ -757,7 +757,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Information other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -771,7 +771,7 @@ public override bool Equals(object obj) public bool Equals(Information other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -847,7 +847,7 @@ public double As(InformationUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -857,7 +857,7 @@ public double As(InformationUnit unit) /// A Information with the specified unit. public Information ToUnit(InformationUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Information(convertedValue, unit); } @@ -866,74 +866,58 @@ public Information ToUnit(InformationUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Information AsBaseUnit() + private decimal GetValueInBaseUnit() { switch(Unit) { - case InformationUnit.Bit: - return new Information(_value, BaseUnit); - case InformationUnit.Byte: - return new Information(_value*8m, BaseUnit); - case InformationUnit.Exabit: - return new Information((_value) * 1e18m, BaseUnit); - case InformationUnit.Exabyte: - return new Information((_value*8m) * 1e18m, BaseUnit); - case InformationUnit.Exbibit: - return new Information((_value) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024), BaseUnit); - case InformationUnit.Exbibyte: - return new Information((_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024), BaseUnit); - case InformationUnit.Gibibit: - return new Information((_value) * (1024m * 1024 * 1024), BaseUnit); - case InformationUnit.Gibibyte: - return new Information((_value*8m) * (1024m * 1024 * 1024), BaseUnit); - case InformationUnit.Gigabit: - return new Information((_value) * 1e9m, BaseUnit); - case InformationUnit.Gigabyte: - return new Information((_value*8m) * 1e9m, BaseUnit); - case InformationUnit.Kibibit: - return new Information((_value) * 1024m, BaseUnit); - case InformationUnit.Kibibyte: - return new Information((_value*8m) * 1024m, BaseUnit); - case InformationUnit.Kilobit: - return new Information((_value) * 1e3m, BaseUnit); - case InformationUnit.Kilobyte: - return new Information((_value*8m) * 1e3m, BaseUnit); - case InformationUnit.Mebibit: - return new Information((_value) * (1024m * 1024), BaseUnit); - case InformationUnit.Mebibyte: - return new Information((_value*8m) * (1024m * 1024), BaseUnit); - case InformationUnit.Megabit: - return new Information((_value) * 1e6m, BaseUnit); - case InformationUnit.Megabyte: - return new Information((_value*8m) * 1e6m, BaseUnit); - case InformationUnit.Pebibit: - return new Information((_value) * (1024m * 1024 * 1024 * 1024 * 1024), BaseUnit); - case InformationUnit.Pebibyte: - return new Information((_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024), BaseUnit); - case InformationUnit.Petabit: - return new Information((_value) * 1e15m, BaseUnit); - case InformationUnit.Petabyte: - return new Information((_value*8m) * 1e15m, BaseUnit); - case InformationUnit.Tebibit: - return new Information((_value) * (1024m * 1024 * 1024 * 1024), BaseUnit); - case InformationUnit.Tebibyte: - return new Information((_value*8m) * (1024m * 1024 * 1024 * 1024), BaseUnit); - case InformationUnit.Terabit: - return new Information((_value) * 1e12m, BaseUnit); - case InformationUnit.Terabyte: - return new Information((_value*8m) * 1e12m, BaseUnit); + case InformationUnit.Bit: return _value; + case InformationUnit.Byte: return _value*8m; + case InformationUnit.Exabit: return (_value) * 1e18m; + case InformationUnit.Exabyte: return (_value*8m) * 1e18m; + case InformationUnit.Exbibit: return (_value) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024); + case InformationUnit.Exbibyte: return (_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024); + case InformationUnit.Gibibit: return (_value) * (1024m * 1024 * 1024); + case InformationUnit.Gibibyte: return (_value*8m) * (1024m * 1024 * 1024); + case InformationUnit.Gigabit: return (_value) * 1e9m; + case InformationUnit.Gigabyte: return (_value*8m) * 1e9m; + case InformationUnit.Kibibit: return (_value) * 1024m; + case InformationUnit.Kibibyte: return (_value*8m) * 1024m; + case InformationUnit.Kilobit: return (_value) * 1e3m; + case InformationUnit.Kilobyte: return (_value*8m) * 1e3m; + case InformationUnit.Mebibit: return (_value) * (1024m * 1024); + case InformationUnit.Mebibyte: return (_value*8m) * (1024m * 1024); + case InformationUnit.Megabit: return (_value) * 1e6m; + case InformationUnit.Megabyte: return (_value*8m) * 1e6m; + case InformationUnit.Pebibit: return (_value) * (1024m * 1024 * 1024 * 1024 * 1024); + case InformationUnit.Pebibyte: return (_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024); + case InformationUnit.Petabit: return (_value) * 1e15m; + case InformationUnit.Petabyte: return (_value*8m) * 1e15m; + case InformationUnit.Tebibit: return (_value) * (1024m * 1024 * 1024 * 1024); + case InformationUnit.Tebibyte: return (_value*8m) * (1024m * 1024 * 1024 * 1024); + case InformationUnit.Terabit: return (_value) * 1e12m; + case InformationUnit.Terabyte: return (_value*8m) * 1e12m; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private decimal AsBaseNumericType(InformationUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Information ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Information(baseUnitValue, BaseUnit); + } + + private decimal GetValueAs(InformationUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiance.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiance.WindowsRuntimeComponent.g.cs index 426a6dfb8d..5fe973e4ab 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiance.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiance.WindowsRuntimeComponent.g.cs @@ -577,7 +577,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Irradiance other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -591,7 +591,7 @@ public override bool Equals(object obj) public bool Equals(Irradiance other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -667,7 +667,7 @@ public double As(IrradianceUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -677,7 +677,7 @@ public double As(IrradianceUnit unit) /// A Irradiance with the specified unit. public Irradiance ToUnit(IrradianceUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Irradiance(convertedValue, unit); } @@ -686,50 +686,46 @@ public Irradiance ToUnit(IrradianceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Irradiance AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case IrradianceUnit.KilowattPerSquareCentimeter: - return new Irradiance((_value*10000) * 1e3d, BaseUnit); - case IrradianceUnit.KilowattPerSquareMeter: - return new Irradiance((_value) * 1e3d, BaseUnit); - case IrradianceUnit.MegawattPerSquareCentimeter: - return new Irradiance((_value*10000) * 1e6d, BaseUnit); - case IrradianceUnit.MegawattPerSquareMeter: - return new Irradiance((_value) * 1e6d, BaseUnit); - case IrradianceUnit.MicrowattPerSquareCentimeter: - return new Irradiance((_value*10000) * 1e-6d, BaseUnit); - case IrradianceUnit.MicrowattPerSquareMeter: - return new Irradiance((_value) * 1e-6d, BaseUnit); - case IrradianceUnit.MilliwattPerSquareCentimeter: - return new Irradiance((_value*10000) * 1e-3d, BaseUnit); - case IrradianceUnit.MilliwattPerSquareMeter: - return new Irradiance((_value) * 1e-3d, BaseUnit); - case IrradianceUnit.NanowattPerSquareCentimeter: - return new Irradiance((_value*10000) * 1e-9d, BaseUnit); - case IrradianceUnit.NanowattPerSquareMeter: - return new Irradiance((_value) * 1e-9d, BaseUnit); - case IrradianceUnit.PicowattPerSquareCentimeter: - return new Irradiance((_value*10000) * 1e-12d, BaseUnit); - case IrradianceUnit.PicowattPerSquareMeter: - return new Irradiance((_value) * 1e-12d, BaseUnit); - case IrradianceUnit.WattPerSquareCentimeter: - return new Irradiance(_value*10000, BaseUnit); - case IrradianceUnit.WattPerSquareMeter: - return new Irradiance(_value, BaseUnit); + case IrradianceUnit.KilowattPerSquareCentimeter: return (_value*10000) * 1e3d; + case IrradianceUnit.KilowattPerSquareMeter: return (_value) * 1e3d; + case IrradianceUnit.MegawattPerSquareCentimeter: return (_value*10000) * 1e6d; + case IrradianceUnit.MegawattPerSquareMeter: return (_value) * 1e6d; + case IrradianceUnit.MicrowattPerSquareCentimeter: return (_value*10000) * 1e-6d; + case IrradianceUnit.MicrowattPerSquareMeter: return (_value) * 1e-6d; + case IrradianceUnit.MilliwattPerSquareCentimeter: return (_value*10000) * 1e-3d; + case IrradianceUnit.MilliwattPerSquareMeter: return (_value) * 1e-3d; + case IrradianceUnit.NanowattPerSquareCentimeter: return (_value*10000) * 1e-9d; + case IrradianceUnit.NanowattPerSquareMeter: return (_value) * 1e-9d; + case IrradianceUnit.PicowattPerSquareCentimeter: return (_value*10000) * 1e-12d; + case IrradianceUnit.PicowattPerSquareMeter: return (_value) * 1e-12d; + case IrradianceUnit.WattPerSquareCentimeter: return _value*10000; + case IrradianceUnit.WattPerSquareMeter: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(IrradianceUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Irradiance ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Irradiance(baseUnitValue, BaseUnit); + } + + private double GetValueAs(IrradianceUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiation.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiation.WindowsRuntimeComponent.g.cs index 08f07e0aa6..ab136ce48b 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiation.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiation.WindowsRuntimeComponent.g.cs @@ -430,7 +430,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Irradiation other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -444,7 +444,7 @@ public override bool Equals(object obj) public bool Equals(Irradiation other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -520,7 +520,7 @@ public double As(IrradiationUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -530,7 +530,7 @@ public double As(IrradiationUnit unit) /// A Irradiation with the specified unit. public Irradiation ToUnit(IrradiationUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Irradiation(convertedValue, unit); } @@ -539,30 +539,36 @@ public Irradiation ToUnit(IrradiationUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Irradiation AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case IrradiationUnit.JoulePerSquareMeter: - return new Irradiation(_value, BaseUnit); - case IrradiationUnit.JoulePerSquareMillimeter: - return new Irradiation(_value*1e6, BaseUnit); - case IrradiationUnit.KilowattHourPerSquareMeter: - return new Irradiation((_value*3600d) * 1e3d, BaseUnit); - case IrradiationUnit.WattHourPerSquareMeter: - return new Irradiation(_value*3600d, BaseUnit); + case IrradiationUnit.JoulePerSquareMeter: return _value; + case IrradiationUnit.JoulePerSquareMillimeter: return _value*1e6; + case IrradiationUnit.KilowattHourPerSquareMeter: return (_value*3600d) * 1e3d; + case IrradiationUnit.WattHourPerSquareMeter: return _value*3600d; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(IrradiationUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Irradiation ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Irradiation(baseUnitValue, BaseUnit); + } + + private double GetValueAs(IrradiationUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/KinematicViscosity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/KinematicViscosity.WindowsRuntimeComponent.g.cs index 4885d84abd..f79a3ed177 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/KinematicViscosity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/KinematicViscosity.WindowsRuntimeComponent.g.cs @@ -490,7 +490,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(KinematicViscosity other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -504,7 +504,7 @@ public override bool Equals(object obj) public bool Equals(KinematicViscosity other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -580,7 +580,7 @@ public double As(KinematicViscosityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -590,7 +590,7 @@ public double As(KinematicViscosityUnit unit) /// A KinematicViscosity with the specified unit. public KinematicViscosity ToUnit(KinematicViscosityUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new KinematicViscosity(convertedValue, unit); } @@ -599,38 +599,40 @@ public KinematicViscosity ToUnit(KinematicViscosityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal KinematicViscosity AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case KinematicViscosityUnit.Centistokes: - return new KinematicViscosity((_value/1e4) * 1e-2d, BaseUnit); - case KinematicViscosityUnit.Decistokes: - return new KinematicViscosity((_value/1e4) * 1e-1d, BaseUnit); - case KinematicViscosityUnit.Kilostokes: - return new KinematicViscosity((_value/1e4) * 1e3d, BaseUnit); - case KinematicViscosityUnit.Microstokes: - return new KinematicViscosity((_value/1e4) * 1e-6d, BaseUnit); - case KinematicViscosityUnit.Millistokes: - return new KinematicViscosity((_value/1e4) * 1e-3d, BaseUnit); - case KinematicViscosityUnit.Nanostokes: - return new KinematicViscosity((_value/1e4) * 1e-9d, BaseUnit); - case KinematicViscosityUnit.SquareMeterPerSecond: - return new KinematicViscosity(_value, BaseUnit); - case KinematicViscosityUnit.Stokes: - return new KinematicViscosity(_value/1e4, BaseUnit); + case KinematicViscosityUnit.Centistokes: return (_value/1e4) * 1e-2d; + case KinematicViscosityUnit.Decistokes: return (_value/1e4) * 1e-1d; + case KinematicViscosityUnit.Kilostokes: return (_value/1e4) * 1e3d; + case KinematicViscosityUnit.Microstokes: return (_value/1e4) * 1e-6d; + case KinematicViscosityUnit.Millistokes: return (_value/1e4) * 1e-3d; + case KinematicViscosityUnit.Nanostokes: return (_value/1e4) * 1e-9d; + case KinematicViscosityUnit.SquareMeterPerSecond: return _value; + case KinematicViscosityUnit.Stokes: return _value/1e4; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(KinematicViscosityUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal KinematicViscosity ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new KinematicViscosity(baseUnitValue, BaseUnit); + } + + private double GetValueAs(KinematicViscosityUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LapseRate.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LapseRate.WindowsRuntimeComponent.g.cs index 0d7ea852c4..9566e560b7 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LapseRate.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LapseRate.WindowsRuntimeComponent.g.cs @@ -382,7 +382,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(LapseRate other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -396,7 +396,7 @@ public override bool Equals(object obj) public bool Equals(LapseRate other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -472,7 +472,7 @@ public double As(LapseRateUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -482,7 +482,7 @@ public double As(LapseRateUnit unit) /// A LapseRate with the specified unit. public LapseRate ToUnit(LapseRateUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new LapseRate(convertedValue, unit); } @@ -491,24 +491,33 @@ public LapseRate ToUnit(LapseRateUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal LapseRate AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case LapseRateUnit.DegreeCelsiusPerKilometer: - return new LapseRate(_value, BaseUnit); + case LapseRateUnit.DegreeCelsiusPerKilometer: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(LapseRateUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal LapseRate ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new LapseRate(baseUnitValue, BaseUnit); + } + + private double GetValueAs(LapseRateUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Length.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Length.WindowsRuntimeComponent.g.cs index d88e505794..c387c6a483 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Length.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Length.WindowsRuntimeComponent.g.cs @@ -697,7 +697,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Length other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -711,7 +711,7 @@ public override bool Equals(object obj) public bool Equals(Length other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -787,7 +787,7 @@ public double As(LengthUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -797,7 +797,7 @@ public double As(LengthUnit unit) /// A Length with the specified unit. public Length ToUnit(LengthUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Length(convertedValue, unit); } @@ -806,66 +806,54 @@ public Length ToUnit(LengthUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Length AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case LengthUnit.Centimeter: - return new Length((_value) * 1e-2d, BaseUnit); - case LengthUnit.Decimeter: - return new Length((_value) * 1e-1d, BaseUnit); - case LengthUnit.DtpPica: - return new Length(_value/236.220472441, BaseUnit); - case LengthUnit.DtpPoint: - return new Length((_value/72)*2.54e-2, BaseUnit); - case LengthUnit.Fathom: - return new Length(_value*1.8288, BaseUnit); - case LengthUnit.Foot: - return new Length(_value*0.3048, BaseUnit); - case LengthUnit.Inch: - return new Length(_value*2.54e-2, BaseUnit); - case LengthUnit.Kilometer: - return new Length((_value) * 1e3d, BaseUnit); - case LengthUnit.Meter: - return new Length(_value, BaseUnit); - case LengthUnit.Microinch: - return new Length(_value*2.54e-8, BaseUnit); - case LengthUnit.Micrometer: - return new Length((_value) * 1e-6d, BaseUnit); - case LengthUnit.Mil: - return new Length(_value*2.54e-5, BaseUnit); - case LengthUnit.Mile: - return new Length(_value*1609.34, BaseUnit); - case LengthUnit.Millimeter: - return new Length((_value) * 1e-3d, BaseUnit); - case LengthUnit.Nanometer: - return new Length((_value) * 1e-9d, BaseUnit); - case LengthUnit.NauticalMile: - return new Length(_value*1852, BaseUnit); - case LengthUnit.PrinterPica: - return new Length(_value/237.106301584, BaseUnit); - case LengthUnit.PrinterPoint: - return new Length((_value/72.27)*2.54e-2, BaseUnit); - case LengthUnit.Shackle: - return new Length(_value*27.432, BaseUnit); - case LengthUnit.Twip: - return new Length(_value/56692.913385826, BaseUnit); - case LengthUnit.UsSurveyFoot: - return new Length(_value*1200/3937, BaseUnit); - case LengthUnit.Yard: - return new Length(_value*0.9144, BaseUnit); + case LengthUnit.Centimeter: return (_value) * 1e-2d; + case LengthUnit.Decimeter: return (_value) * 1e-1d; + case LengthUnit.DtpPica: return _value/236.220472441; + case LengthUnit.DtpPoint: return (_value/72)*2.54e-2; + case LengthUnit.Fathom: return _value*1.8288; + case LengthUnit.Foot: return _value*0.3048; + case LengthUnit.Inch: return _value*2.54e-2; + case LengthUnit.Kilometer: return (_value) * 1e3d; + case LengthUnit.Meter: return _value; + case LengthUnit.Microinch: return _value*2.54e-8; + case LengthUnit.Micrometer: return (_value) * 1e-6d; + case LengthUnit.Mil: return _value*2.54e-5; + case LengthUnit.Mile: return _value*1609.34; + case LengthUnit.Millimeter: return (_value) * 1e-3d; + case LengthUnit.Nanometer: return (_value) * 1e-9d; + case LengthUnit.NauticalMile: return _value*1852; + case LengthUnit.PrinterPica: return _value/237.106301584; + case LengthUnit.PrinterPoint: return (_value/72.27)*2.54e-2; + case LengthUnit.Shackle: return _value*27.432; + case LengthUnit.Twip: return _value/56692.913385826; + case LengthUnit.UsSurveyFoot: return _value*1200/3937; + case LengthUnit.Yard: return _value*0.9144; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(LengthUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Length ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Length(baseUnitValue, BaseUnit); + } + + private double GetValueAs(LengthUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Level.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Level.WindowsRuntimeComponent.g.cs index c8fef0f5f3..8b2e62ae1e 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Level.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Level.WindowsRuntimeComponent.g.cs @@ -397,7 +397,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Level other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -411,7 +411,7 @@ public override bool Equals(object obj) public bool Equals(Level other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -487,7 +487,7 @@ public double As(LevelUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -497,7 +497,7 @@ public double As(LevelUnit unit) /// A Level with the specified unit. public Level ToUnit(LevelUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Level(convertedValue, unit); } @@ -506,26 +506,34 @@ public Level ToUnit(LevelUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Level AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case LevelUnit.Decibel: - return new Level(_value, BaseUnit); - case LevelUnit.Neper: - return new Level((1/0.115129254)*_value, BaseUnit); + case LevelUnit.Decibel: return _value; + case LevelUnit.Neper: return (1/0.115129254)*_value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(LevelUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Level ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Level(baseUnitValue, BaseUnit); + } + + private double GetValueAs(LevelUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearDensity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearDensity.WindowsRuntimeComponent.g.cs index 4a22d323a1..481472bffc 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearDensity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearDensity.WindowsRuntimeComponent.g.cs @@ -415,7 +415,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(LinearDensity other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -429,7 +429,7 @@ public override bool Equals(object obj) public bool Equals(LinearDensity other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -505,7 +505,7 @@ public double As(LinearDensityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -515,7 +515,7 @@ public double As(LinearDensityUnit unit) /// A LinearDensity with the specified unit. public LinearDensity ToUnit(LinearDensityUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new LinearDensity(convertedValue, unit); } @@ -524,28 +524,35 @@ public LinearDensity ToUnit(LinearDensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal LinearDensity AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case LinearDensityUnit.GramPerMeter: - return new LinearDensity(_value*1e-3, BaseUnit); - case LinearDensityUnit.KilogramPerMeter: - return new LinearDensity((_value*1e-3) * 1e3d, BaseUnit); - case LinearDensityUnit.PoundPerFoot: - return new LinearDensity(_value*1.48816394, BaseUnit); + case LinearDensityUnit.GramPerMeter: return _value*1e-3; + case LinearDensityUnit.KilogramPerMeter: return (_value*1e-3) * 1e3d; + case LinearDensityUnit.PoundPerFoot: return _value*1.48816394; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(LinearDensityUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal LinearDensity ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new LinearDensity(baseUnitValue, BaseUnit); + } + + private double GetValueAs(LinearDensityUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousFlux.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousFlux.WindowsRuntimeComponent.g.cs index 1ece43509c..d34c54fbf3 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousFlux.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousFlux.WindowsRuntimeComponent.g.cs @@ -385,7 +385,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(LuminousFlux other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -399,7 +399,7 @@ public override bool Equals(object obj) public bool Equals(LuminousFlux other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -475,7 +475,7 @@ public double As(LuminousFluxUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -485,7 +485,7 @@ public double As(LuminousFluxUnit unit) /// A LuminousFlux with the specified unit. public LuminousFlux ToUnit(LuminousFluxUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new LuminousFlux(convertedValue, unit); } @@ -494,24 +494,33 @@ public LuminousFlux ToUnit(LuminousFluxUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal LuminousFlux AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case LuminousFluxUnit.Lumen: - return new LuminousFlux(_value, BaseUnit); + case LuminousFluxUnit.Lumen: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(LuminousFluxUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal LuminousFlux ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new LuminousFlux(baseUnitValue, BaseUnit); + } + + private double GetValueAs(LuminousFluxUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousIntensity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousIntensity.WindowsRuntimeComponent.g.cs index 14795c5db9..16c5b23316 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousIntensity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousIntensity.WindowsRuntimeComponent.g.cs @@ -385,7 +385,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(LuminousIntensity other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -399,7 +399,7 @@ public override bool Equals(object obj) public bool Equals(LuminousIntensity other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -475,7 +475,7 @@ public double As(LuminousIntensityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -485,7 +485,7 @@ public double As(LuminousIntensityUnit unit) /// A LuminousIntensity with the specified unit. public LuminousIntensity ToUnit(LuminousIntensityUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new LuminousIntensity(convertedValue, unit); } @@ -494,24 +494,33 @@ public LuminousIntensity ToUnit(LuminousIntensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal LuminousIntensity AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case LuminousIntensityUnit.Candela: - return new LuminousIntensity(_value, BaseUnit); + case LuminousIntensityUnit.Candela: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(LuminousIntensityUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal LuminousIntensity ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new LuminousIntensity(baseUnitValue, BaseUnit); + } + + private double GetValueAs(LuminousIntensityUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticField.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticField.WindowsRuntimeComponent.g.cs index 713eef1c8f..01aeddd625 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticField.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticField.WindowsRuntimeComponent.g.cs @@ -430,7 +430,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(MagneticField other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -444,7 +444,7 @@ public override bool Equals(object obj) public bool Equals(MagneticField other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -520,7 +520,7 @@ public double As(MagneticFieldUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -530,7 +530,7 @@ public double As(MagneticFieldUnit unit) /// A MagneticField with the specified unit. public MagneticField ToUnit(MagneticFieldUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new MagneticField(convertedValue, unit); } @@ -539,30 +539,36 @@ public MagneticField ToUnit(MagneticFieldUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal MagneticField AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case MagneticFieldUnit.Microtesla: - return new MagneticField((_value) * 1e-6d, BaseUnit); - case MagneticFieldUnit.Millitesla: - return new MagneticField((_value) * 1e-3d, BaseUnit); - case MagneticFieldUnit.Nanotesla: - return new MagneticField((_value) * 1e-9d, BaseUnit); - case MagneticFieldUnit.Tesla: - return new MagneticField(_value, BaseUnit); + case MagneticFieldUnit.Microtesla: return (_value) * 1e-6d; + case MagneticFieldUnit.Millitesla: return (_value) * 1e-3d; + case MagneticFieldUnit.Nanotesla: return (_value) * 1e-9d; + case MagneticFieldUnit.Tesla: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(MagneticFieldUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal MagneticField ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new MagneticField(baseUnitValue, BaseUnit); + } + + private double GetValueAs(MagneticFieldUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticFlux.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticFlux.WindowsRuntimeComponent.g.cs index ebf516c1e0..d3aa30768b 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticFlux.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticFlux.WindowsRuntimeComponent.g.cs @@ -385,7 +385,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(MagneticFlux other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -399,7 +399,7 @@ public override bool Equals(object obj) public bool Equals(MagneticFlux other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -475,7 +475,7 @@ public double As(MagneticFluxUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -485,7 +485,7 @@ public double As(MagneticFluxUnit unit) /// A MagneticFlux with the specified unit. public MagneticFlux ToUnit(MagneticFluxUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new MagneticFlux(convertedValue, unit); } @@ -494,24 +494,33 @@ public MagneticFlux ToUnit(MagneticFluxUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal MagneticFlux AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case MagneticFluxUnit.Weber: - return new MagneticFlux(_value, BaseUnit); + case MagneticFluxUnit.Weber: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(MagneticFluxUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal MagneticFlux ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new MagneticFlux(baseUnitValue, BaseUnit); + } + + private double GetValueAs(MagneticFluxUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Magnetization.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Magnetization.WindowsRuntimeComponent.g.cs index 9128f939f6..3dfe0671cd 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Magnetization.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Magnetization.WindowsRuntimeComponent.g.cs @@ -385,7 +385,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Magnetization other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -399,7 +399,7 @@ public override bool Equals(object obj) public bool Equals(Magnetization other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -475,7 +475,7 @@ public double As(MagnetizationUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -485,7 +485,7 @@ public double As(MagnetizationUnit unit) /// A Magnetization with the specified unit. public Magnetization ToUnit(MagnetizationUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Magnetization(convertedValue, unit); } @@ -494,24 +494,33 @@ public Magnetization ToUnit(MagnetizationUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Magnetization AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case MagnetizationUnit.AmperePerMeter: - return new Magnetization(_value, BaseUnit); + case MagnetizationUnit.AmperePerMeter: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(MagnetizationUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Magnetization ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Magnetization(baseUnitValue, BaseUnit); + } + + private double GetValueAs(MagnetizationUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Mass.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Mass.WindowsRuntimeComponent.g.cs index 1a560d134f..631a0c71e1 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Mass.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Mass.WindowsRuntimeComponent.g.cs @@ -712,7 +712,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Mass other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -726,7 +726,7 @@ public override bool Equals(object obj) public bool Equals(Mass other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -802,7 +802,7 @@ public double As(MassUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -812,7 +812,7 @@ public double As(MassUnit unit) /// A Mass with the specified unit. public Mass ToUnit(MassUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Mass(convertedValue, unit); } @@ -821,68 +821,55 @@ public Mass ToUnit(MassUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Mass AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case MassUnit.Centigram: - return new Mass((_value/1e3) * 1e-2d, BaseUnit); - case MassUnit.Decagram: - return new Mass((_value/1e3) * 1e1d, BaseUnit); - case MassUnit.Decigram: - return new Mass((_value/1e3) * 1e-1d, BaseUnit); - case MassUnit.Grain: - return new Mass(_value/15432.358352941431, BaseUnit); - case MassUnit.Gram: - return new Mass(_value/1e3, BaseUnit); - case MassUnit.Hectogram: - return new Mass((_value/1e3) * 1e2d, BaseUnit); - case MassUnit.Kilogram: - return new Mass((_value/1e3) * 1e3d, BaseUnit); - case MassUnit.Kilopound: - return new Mass((_value*0.45359237) * 1e3d, BaseUnit); - case MassUnit.Kilotonne: - return new Mass((_value*1e3) * 1e3d, BaseUnit); - case MassUnit.LongHundredweight: - return new Mass(_value/0.01968413055222121, BaseUnit); - case MassUnit.LongTon: - return new Mass(_value*1.0160469088e3, BaseUnit); - case MassUnit.Megapound: - return new Mass((_value*0.45359237) * 1e6d, BaseUnit); - case MassUnit.Megatonne: - return new Mass((_value*1e3) * 1e6d, BaseUnit); - case MassUnit.Microgram: - return new Mass((_value/1e3) * 1e-6d, BaseUnit); - case MassUnit.Milligram: - return new Mass((_value/1e3) * 1e-3d, BaseUnit); - case MassUnit.Nanogram: - return new Mass((_value/1e3) * 1e-9d, BaseUnit); - case MassUnit.Ounce: - return new Mass(_value/35.2739619, BaseUnit); - case MassUnit.Pound: - return new Mass(_value*0.45359237, BaseUnit); - case MassUnit.ShortHundredweight: - return new Mass(_value/0.022046226218487758, BaseUnit); - case MassUnit.ShortTon: - return new Mass(_value*9.0718474e2, BaseUnit); - case MassUnit.Slug: - return new Mass(_value/6.852176556196105e-2, BaseUnit); - case MassUnit.Stone: - return new Mass(_value/0.1574731728702698, BaseUnit); - case MassUnit.Tonne: - return new Mass(_value*1e3, BaseUnit); + case MassUnit.Centigram: return (_value/1e3) * 1e-2d; + case MassUnit.Decagram: return (_value/1e3) * 1e1d; + case MassUnit.Decigram: return (_value/1e3) * 1e-1d; + case MassUnit.Grain: return _value/15432.358352941431; + case MassUnit.Gram: return _value/1e3; + case MassUnit.Hectogram: return (_value/1e3) * 1e2d; + case MassUnit.Kilogram: return (_value/1e3) * 1e3d; + case MassUnit.Kilopound: return (_value*0.45359237) * 1e3d; + case MassUnit.Kilotonne: return (_value*1e3) * 1e3d; + case MassUnit.LongHundredweight: return _value/0.01968413055222121; + case MassUnit.LongTon: return _value*1.0160469088e3; + case MassUnit.Megapound: return (_value*0.45359237) * 1e6d; + case MassUnit.Megatonne: return (_value*1e3) * 1e6d; + case MassUnit.Microgram: return (_value/1e3) * 1e-6d; + case MassUnit.Milligram: return (_value/1e3) * 1e-3d; + case MassUnit.Nanogram: return (_value/1e3) * 1e-9d; + case MassUnit.Ounce: return _value/35.2739619; + case MassUnit.Pound: return _value*0.45359237; + case MassUnit.ShortHundredweight: return _value/0.022046226218487758; + case MassUnit.ShortTon: return _value*9.0718474e2; + case MassUnit.Slug: return _value/6.852176556196105e-2; + case MassUnit.Stone: return _value/0.1574731728702698; + case MassUnit.Tonne: return _value*1e3; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(MassUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Mass ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Mass(baseUnitValue, BaseUnit); + } + + private double GetValueAs(MassUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlow.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlow.WindowsRuntimeComponent.g.cs index 9c5e1f21db..e4f38ed203 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlow.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlow.WindowsRuntimeComponent.g.cs @@ -817,7 +817,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(MassFlow other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -831,7 +831,7 @@ public override bool Equals(object obj) public bool Equals(MassFlow other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -907,7 +907,7 @@ public double As(MassFlowUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -917,7 +917,7 @@ public double As(MassFlowUnit unit) /// A MassFlow with the specified unit. public MassFlow ToUnit(MassFlowUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new MassFlow(convertedValue, unit); } @@ -926,82 +926,62 @@ public MassFlow ToUnit(MassFlowUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal MassFlow AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case MassFlowUnit.CentigramPerDay: - return new MassFlow((_value/86400) * 1e-2d, BaseUnit); - case MassFlowUnit.CentigramPerSecond: - return new MassFlow((_value) * 1e-2d, BaseUnit); - case MassFlowUnit.DecagramPerDay: - return new MassFlow((_value/86400) * 1e1d, BaseUnit); - case MassFlowUnit.DecagramPerSecond: - return new MassFlow((_value) * 1e1d, BaseUnit); - case MassFlowUnit.DecigramPerDay: - return new MassFlow((_value/86400) * 1e-1d, BaseUnit); - case MassFlowUnit.DecigramPerSecond: - return new MassFlow((_value) * 1e-1d, BaseUnit); - case MassFlowUnit.GramPerDay: - return new MassFlow(_value/86400, BaseUnit); - case MassFlowUnit.GramPerSecond: - return new MassFlow(_value, BaseUnit); - case MassFlowUnit.HectogramPerDay: - return new MassFlow((_value/86400) * 1e2d, BaseUnit); - case MassFlowUnit.HectogramPerSecond: - return new MassFlow((_value) * 1e2d, BaseUnit); - case MassFlowUnit.KilogramPerDay: - return new MassFlow((_value/86400) * 1e3d, BaseUnit); - case MassFlowUnit.KilogramPerHour: - return new MassFlow(_value/3.6, BaseUnit); - case MassFlowUnit.KilogramPerMinute: - return new MassFlow(_value/0.06, BaseUnit); - case MassFlowUnit.KilogramPerSecond: - return new MassFlow((_value) * 1e3d, BaseUnit); - case MassFlowUnit.MegagramPerDay: - return new MassFlow((_value/86400) * 1e6d, BaseUnit); - case MassFlowUnit.MegapoundPerDay: - return new MassFlow((_value/190.47936) * 1e6d, BaseUnit); - case MassFlowUnit.MegapoundPerHour: - return new MassFlow((_value/7.93664) * 1e6d, BaseUnit); - case MassFlowUnit.MegapoundPerMinute: - return new MassFlow((_value/0.132277) * 1e6d, BaseUnit); - case MassFlowUnit.MicrogramPerDay: - return new MassFlow((_value/86400) * 1e-6d, BaseUnit); - case MassFlowUnit.MicrogramPerSecond: - return new MassFlow((_value) * 1e-6d, BaseUnit); - case MassFlowUnit.MilligramPerDay: - return new MassFlow((_value/86400) * 1e-3d, BaseUnit); - case MassFlowUnit.MilligramPerSecond: - return new MassFlow((_value) * 1e-3d, BaseUnit); - case MassFlowUnit.NanogramPerDay: - return new MassFlow((_value/86400) * 1e-9d, BaseUnit); - case MassFlowUnit.NanogramPerSecond: - return new MassFlow((_value) * 1e-9d, BaseUnit); - case MassFlowUnit.PoundPerDay: - return new MassFlow(_value/190.47936, BaseUnit); - case MassFlowUnit.PoundPerHour: - return new MassFlow(_value/7.93664, BaseUnit); - case MassFlowUnit.PoundPerMinute: - return new MassFlow(_value/0.132277, BaseUnit); - case MassFlowUnit.ShortTonPerHour: - return new MassFlow(_value*251.9957611, BaseUnit); - case MassFlowUnit.TonnePerDay: - return new MassFlow(_value/0.0864000, BaseUnit); - case MassFlowUnit.TonnePerHour: - return new MassFlow(1000*_value/3.6, BaseUnit); + case MassFlowUnit.CentigramPerDay: return (_value/86400) * 1e-2d; + case MassFlowUnit.CentigramPerSecond: return (_value) * 1e-2d; + case MassFlowUnit.DecagramPerDay: return (_value/86400) * 1e1d; + case MassFlowUnit.DecagramPerSecond: return (_value) * 1e1d; + case MassFlowUnit.DecigramPerDay: return (_value/86400) * 1e-1d; + case MassFlowUnit.DecigramPerSecond: return (_value) * 1e-1d; + case MassFlowUnit.GramPerDay: return _value/86400; + case MassFlowUnit.GramPerSecond: return _value; + case MassFlowUnit.HectogramPerDay: return (_value/86400) * 1e2d; + case MassFlowUnit.HectogramPerSecond: return (_value) * 1e2d; + case MassFlowUnit.KilogramPerDay: return (_value/86400) * 1e3d; + case MassFlowUnit.KilogramPerHour: return _value/3.6; + case MassFlowUnit.KilogramPerMinute: return _value/0.06; + case MassFlowUnit.KilogramPerSecond: return (_value) * 1e3d; + case MassFlowUnit.MegagramPerDay: return (_value/86400) * 1e6d; + case MassFlowUnit.MegapoundPerDay: return (_value/190.47936) * 1e6d; + case MassFlowUnit.MegapoundPerHour: return (_value/7.93664) * 1e6d; + case MassFlowUnit.MegapoundPerMinute: return (_value/0.132277) * 1e6d; + case MassFlowUnit.MicrogramPerDay: return (_value/86400) * 1e-6d; + case MassFlowUnit.MicrogramPerSecond: return (_value) * 1e-6d; + case MassFlowUnit.MilligramPerDay: return (_value/86400) * 1e-3d; + case MassFlowUnit.MilligramPerSecond: return (_value) * 1e-3d; + case MassFlowUnit.NanogramPerDay: return (_value/86400) * 1e-9d; + case MassFlowUnit.NanogramPerSecond: return (_value) * 1e-9d; + case MassFlowUnit.PoundPerDay: return _value/190.47936; + case MassFlowUnit.PoundPerHour: return _value/7.93664; + case MassFlowUnit.PoundPerMinute: return _value/0.132277; + case MassFlowUnit.ShortTonPerHour: return _value*251.9957611; + case MassFlowUnit.TonnePerDay: return _value/0.0864000; + case MassFlowUnit.TonnePerHour: return 1000*_value/3.6; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(MassFlowUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal MassFlow ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new MassFlow(baseUnitValue, BaseUnit); + } + + private double GetValueAs(MassFlowUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlux.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlux.WindowsRuntimeComponent.g.cs index b753e52f45..2d3b04b1e4 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlux.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlux.WindowsRuntimeComponent.g.cs @@ -397,7 +397,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(MassFlux other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -411,7 +411,7 @@ public override bool Equals(object obj) public bool Equals(MassFlux other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -487,7 +487,7 @@ public double As(MassFluxUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -497,7 +497,7 @@ public double As(MassFluxUnit unit) /// A MassFlux with the specified unit. public MassFlux ToUnit(MassFluxUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new MassFlux(convertedValue, unit); } @@ -506,26 +506,34 @@ public MassFlux ToUnit(MassFluxUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal MassFlux AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case MassFluxUnit.GramPerSecondPerSquareMeter: - return new MassFlux(_value/1e3, BaseUnit); - case MassFluxUnit.KilogramPerSecondPerSquareMeter: - return new MassFlux((_value/1e3) * 1e3d, BaseUnit); + case MassFluxUnit.GramPerSecondPerSquareMeter: return _value/1e3; + case MassFluxUnit.KilogramPerSecondPerSquareMeter: return (_value/1e3) * 1e3d; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(MassFluxUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal MassFlux ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new MassFlux(baseUnitValue, BaseUnit); + } + + private double GetValueAs(MassFluxUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassMomentOfInertia.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassMomentOfInertia.WindowsRuntimeComponent.g.cs index 597b24601c..8a480a317d 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassMomentOfInertia.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassMomentOfInertia.WindowsRuntimeComponent.g.cs @@ -787,7 +787,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(MassMomentOfInertia other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -801,7 +801,7 @@ public override bool Equals(object obj) public bool Equals(MassMomentOfInertia other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -877,7 +877,7 @@ public double As(MassMomentOfInertiaUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -887,7 +887,7 @@ public double As(MassMomentOfInertiaUnit unit) /// A MassMomentOfInertia with the specified unit. public MassMomentOfInertia ToUnit(MassMomentOfInertiaUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new MassMomentOfInertia(convertedValue, unit); } @@ -896,78 +896,60 @@ public MassMomentOfInertia ToUnit(MassMomentOfInertiaUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal MassMomentOfInertia AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case MassMomentOfInertiaUnit.GramSquareCentimeter: - return new MassMomentOfInertia(_value/1e7, BaseUnit); - case MassMomentOfInertiaUnit.GramSquareDecimeter: - return new MassMomentOfInertia(_value/1e5, BaseUnit); - case MassMomentOfInertiaUnit.GramSquareMeter: - return new MassMomentOfInertia(_value/1e3, BaseUnit); - case MassMomentOfInertiaUnit.GramSquareMillimeter: - return new MassMomentOfInertia(_value/1e9, BaseUnit); - case MassMomentOfInertiaUnit.KilogramSquareCentimeter: - return new MassMomentOfInertia((_value/1e7) * 1e3d, BaseUnit); - case MassMomentOfInertiaUnit.KilogramSquareDecimeter: - return new MassMomentOfInertia((_value/1e5) * 1e3d, BaseUnit); - case MassMomentOfInertiaUnit.KilogramSquareMeter: - return new MassMomentOfInertia((_value/1e3) * 1e3d, BaseUnit); - case MassMomentOfInertiaUnit.KilogramSquareMillimeter: - return new MassMomentOfInertia((_value/1e9) * 1e3d, BaseUnit); - case MassMomentOfInertiaUnit.KilotonneSquareCentimeter: - return new MassMomentOfInertia((_value/1e1) * 1e3d, BaseUnit); - case MassMomentOfInertiaUnit.KilotonneSquareDecimeter: - return new MassMomentOfInertia((_value/1e-1) * 1e3d, BaseUnit); - case MassMomentOfInertiaUnit.KilotonneSquareMeter: - return new MassMomentOfInertia((_value/1e-3) * 1e3d, BaseUnit); - case MassMomentOfInertiaUnit.KilotonneSquareMilimeter: - return new MassMomentOfInertia((_value/1e3) * 1e3d, BaseUnit); - case MassMomentOfInertiaUnit.MegatonneSquareCentimeter: - return new MassMomentOfInertia((_value/1e1) * 1e6d, BaseUnit); - case MassMomentOfInertiaUnit.MegatonneSquareDecimeter: - return new MassMomentOfInertia((_value/1e-1) * 1e6d, BaseUnit); - case MassMomentOfInertiaUnit.MegatonneSquareMeter: - return new MassMomentOfInertia((_value/1e-3) * 1e6d, BaseUnit); - case MassMomentOfInertiaUnit.MegatonneSquareMilimeter: - return new MassMomentOfInertia((_value/1e3) * 1e6d, BaseUnit); - case MassMomentOfInertiaUnit.MilligramSquareCentimeter: - return new MassMomentOfInertia((_value/1e7) * 1e-3d, BaseUnit); - case MassMomentOfInertiaUnit.MilligramSquareDecimeter: - return new MassMomentOfInertia((_value/1e5) * 1e-3d, BaseUnit); - case MassMomentOfInertiaUnit.MilligramSquareMeter: - return new MassMomentOfInertia((_value/1e3) * 1e-3d, BaseUnit); - case MassMomentOfInertiaUnit.MilligramSquareMillimeter: - return new MassMomentOfInertia((_value/1e9) * 1e-3d, BaseUnit); - case MassMomentOfInertiaUnit.PoundSquareFoot: - return new MassMomentOfInertia(_value*4.21401101e-2, BaseUnit); - case MassMomentOfInertiaUnit.PoundSquareInch: - return new MassMomentOfInertia(_value*2.9263965e-4, BaseUnit); - case MassMomentOfInertiaUnit.SlugSquareFoot: - return new MassMomentOfInertia(_value*1.3558179619, BaseUnit); - case MassMomentOfInertiaUnit.SlugSquareInch: - return new MassMomentOfInertia(_value*9.41540242e-3, BaseUnit); - case MassMomentOfInertiaUnit.TonneSquareCentimeter: - return new MassMomentOfInertia(_value/1e1, BaseUnit); - case MassMomentOfInertiaUnit.TonneSquareDecimeter: - return new MassMomentOfInertia(_value/1e-1, BaseUnit); - case MassMomentOfInertiaUnit.TonneSquareMeter: - return new MassMomentOfInertia(_value/1e-3, BaseUnit); - case MassMomentOfInertiaUnit.TonneSquareMilimeter: - return new MassMomentOfInertia(_value/1e3, BaseUnit); + case MassMomentOfInertiaUnit.GramSquareCentimeter: return _value/1e7; + case MassMomentOfInertiaUnit.GramSquareDecimeter: return _value/1e5; + case MassMomentOfInertiaUnit.GramSquareMeter: return _value/1e3; + case MassMomentOfInertiaUnit.GramSquareMillimeter: return _value/1e9; + case MassMomentOfInertiaUnit.KilogramSquareCentimeter: return (_value/1e7) * 1e3d; + case MassMomentOfInertiaUnit.KilogramSquareDecimeter: return (_value/1e5) * 1e3d; + case MassMomentOfInertiaUnit.KilogramSquareMeter: return (_value/1e3) * 1e3d; + case MassMomentOfInertiaUnit.KilogramSquareMillimeter: return (_value/1e9) * 1e3d; + case MassMomentOfInertiaUnit.KilotonneSquareCentimeter: return (_value/1e1) * 1e3d; + case MassMomentOfInertiaUnit.KilotonneSquareDecimeter: return (_value/1e-1) * 1e3d; + case MassMomentOfInertiaUnit.KilotonneSquareMeter: return (_value/1e-3) * 1e3d; + case MassMomentOfInertiaUnit.KilotonneSquareMilimeter: return (_value/1e3) * 1e3d; + case MassMomentOfInertiaUnit.MegatonneSquareCentimeter: return (_value/1e1) * 1e6d; + case MassMomentOfInertiaUnit.MegatonneSquareDecimeter: return (_value/1e-1) * 1e6d; + case MassMomentOfInertiaUnit.MegatonneSquareMeter: return (_value/1e-3) * 1e6d; + case MassMomentOfInertiaUnit.MegatonneSquareMilimeter: return (_value/1e3) * 1e6d; + case MassMomentOfInertiaUnit.MilligramSquareCentimeter: return (_value/1e7) * 1e-3d; + case MassMomentOfInertiaUnit.MilligramSquareDecimeter: return (_value/1e5) * 1e-3d; + case MassMomentOfInertiaUnit.MilligramSquareMeter: return (_value/1e3) * 1e-3d; + case MassMomentOfInertiaUnit.MilligramSquareMillimeter: return (_value/1e9) * 1e-3d; + case MassMomentOfInertiaUnit.PoundSquareFoot: return _value*4.21401101e-2; + case MassMomentOfInertiaUnit.PoundSquareInch: return _value*2.9263965e-4; + case MassMomentOfInertiaUnit.SlugSquareFoot: return _value*1.3558179619; + case MassMomentOfInertiaUnit.SlugSquareInch: return _value*9.41540242e-3; + case MassMomentOfInertiaUnit.TonneSquareCentimeter: return _value/1e1; + case MassMomentOfInertiaUnit.TonneSquareDecimeter: return _value/1e-1; + case MassMomentOfInertiaUnit.TonneSquareMeter: return _value/1e-3; + case MassMomentOfInertiaUnit.TonneSquareMilimeter: return _value/1e3; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(MassMomentOfInertiaUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal MassMomentOfInertia ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new MassMomentOfInertia(baseUnitValue, BaseUnit); + } + + private double GetValueAs(MassMomentOfInertiaUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEnergy.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEnergy.WindowsRuntimeComponent.g.cs index 39d421083d..09369c9001 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEnergy.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEnergy.WindowsRuntimeComponent.g.cs @@ -412,7 +412,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(MolarEnergy other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -426,7 +426,7 @@ public override bool Equals(object obj) public bool Equals(MolarEnergy other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -502,7 +502,7 @@ public double As(MolarEnergyUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -512,7 +512,7 @@ public double As(MolarEnergyUnit unit) /// A MolarEnergy with the specified unit. public MolarEnergy ToUnit(MolarEnergyUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new MolarEnergy(convertedValue, unit); } @@ -521,28 +521,35 @@ public MolarEnergy ToUnit(MolarEnergyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal MolarEnergy AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case MolarEnergyUnit.JoulePerMole: - return new MolarEnergy(_value, BaseUnit); - case MolarEnergyUnit.KilojoulePerMole: - return new MolarEnergy((_value) * 1e3d, BaseUnit); - case MolarEnergyUnit.MegajoulePerMole: - return new MolarEnergy((_value) * 1e6d, BaseUnit); + case MolarEnergyUnit.JoulePerMole: return _value; + case MolarEnergyUnit.KilojoulePerMole: return (_value) * 1e3d; + case MolarEnergyUnit.MegajoulePerMole: return (_value) * 1e6d; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(MolarEnergyUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal MolarEnergy ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new MolarEnergy(baseUnitValue, BaseUnit); + } + + private double GetValueAs(MolarEnergyUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEntropy.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEntropy.WindowsRuntimeComponent.g.cs index 829c1efbe7..97ca7dc2b3 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEntropy.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEntropy.WindowsRuntimeComponent.g.cs @@ -412,7 +412,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(MolarEntropy other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -426,7 +426,7 @@ public override bool Equals(object obj) public bool Equals(MolarEntropy other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -502,7 +502,7 @@ public double As(MolarEntropyUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -512,7 +512,7 @@ public double As(MolarEntropyUnit unit) /// A MolarEntropy with the specified unit. public MolarEntropy ToUnit(MolarEntropyUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new MolarEntropy(convertedValue, unit); } @@ -521,28 +521,35 @@ public MolarEntropy ToUnit(MolarEntropyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal MolarEntropy AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case MolarEntropyUnit.JoulePerMoleKelvin: - return new MolarEntropy(_value, BaseUnit); - case MolarEntropyUnit.KilojoulePerMoleKelvin: - return new MolarEntropy((_value) * 1e3d, BaseUnit); - case MolarEntropyUnit.MegajoulePerMoleKelvin: - return new MolarEntropy((_value) * 1e6d, BaseUnit); + case MolarEntropyUnit.JoulePerMoleKelvin: return _value; + case MolarEntropyUnit.KilojoulePerMoleKelvin: return (_value) * 1e3d; + case MolarEntropyUnit.MegajoulePerMoleKelvin: return (_value) * 1e6d; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(MolarEntropyUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal MolarEntropy ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new MolarEntropy(baseUnitValue, BaseUnit); + } + + private double GetValueAs(MolarEntropyUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarMass.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarMass.WindowsRuntimeComponent.g.cs index 4037f56d7e..10b9f086d3 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarMass.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarMass.WindowsRuntimeComponent.g.cs @@ -547,7 +547,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(MolarMass other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -561,7 +561,7 @@ public override bool Equals(object obj) public bool Equals(MolarMass other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -637,7 +637,7 @@ public double As(MolarMassUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -647,7 +647,7 @@ public double As(MolarMassUnit unit) /// A MolarMass with the specified unit. public MolarMass ToUnit(MolarMassUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new MolarMass(convertedValue, unit); } @@ -656,46 +656,44 @@ public MolarMass ToUnit(MolarMassUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal MolarMass AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case MolarMassUnit.CentigramPerMole: - return new MolarMass((_value/1e3) * 1e-2d, BaseUnit); - case MolarMassUnit.DecagramPerMole: - return new MolarMass((_value/1e3) * 1e1d, BaseUnit); - case MolarMassUnit.DecigramPerMole: - return new MolarMass((_value/1e3) * 1e-1d, BaseUnit); - case MolarMassUnit.GramPerMole: - return new MolarMass(_value/1e3, BaseUnit); - case MolarMassUnit.HectogramPerMole: - return new MolarMass((_value/1e3) * 1e2d, BaseUnit); - case MolarMassUnit.KilogramPerMole: - return new MolarMass((_value/1e3) * 1e3d, BaseUnit); - case MolarMassUnit.KilopoundPerMole: - return new MolarMass((_value*0.45359237) * 1e3d, BaseUnit); - case MolarMassUnit.MegapoundPerMole: - return new MolarMass((_value*0.45359237) * 1e6d, BaseUnit); - case MolarMassUnit.MicrogramPerMole: - return new MolarMass((_value/1e3) * 1e-6d, BaseUnit); - case MolarMassUnit.MilligramPerMole: - return new MolarMass((_value/1e3) * 1e-3d, BaseUnit); - case MolarMassUnit.NanogramPerMole: - return new MolarMass((_value/1e3) * 1e-9d, BaseUnit); - case MolarMassUnit.PoundPerMole: - return new MolarMass(_value*0.45359237, BaseUnit); + case MolarMassUnit.CentigramPerMole: return (_value/1e3) * 1e-2d; + case MolarMassUnit.DecagramPerMole: return (_value/1e3) * 1e1d; + case MolarMassUnit.DecigramPerMole: return (_value/1e3) * 1e-1d; + case MolarMassUnit.GramPerMole: return _value/1e3; + case MolarMassUnit.HectogramPerMole: return (_value/1e3) * 1e2d; + case MolarMassUnit.KilogramPerMole: return (_value/1e3) * 1e3d; + case MolarMassUnit.KilopoundPerMole: return (_value*0.45359237) * 1e3d; + case MolarMassUnit.MegapoundPerMole: return (_value*0.45359237) * 1e6d; + case MolarMassUnit.MicrogramPerMole: return (_value/1e3) * 1e-6d; + case MolarMassUnit.MilligramPerMole: return (_value/1e3) * 1e-3d; + case MolarMassUnit.NanogramPerMole: return (_value/1e3) * 1e-9d; + case MolarMassUnit.PoundPerMole: return _value*0.45359237; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(MolarMassUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal MolarMass ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new MolarMass(baseUnitValue, BaseUnit); + } + + private double GetValueAs(MolarMassUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Molarity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Molarity.WindowsRuntimeComponent.g.cs index 80b84cf43e..263bac288d 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Molarity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Molarity.WindowsRuntimeComponent.g.cs @@ -490,7 +490,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Molarity other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -504,7 +504,7 @@ public override bool Equals(object obj) public bool Equals(Molarity other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -580,7 +580,7 @@ public double As(MolarityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -590,7 +590,7 @@ public double As(MolarityUnit unit) /// A Molarity with the specified unit. public Molarity ToUnit(MolarityUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Molarity(convertedValue, unit); } @@ -599,38 +599,40 @@ public Molarity ToUnit(MolarityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Molarity AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case MolarityUnit.CentimolesPerLiter: - return new Molarity((_value/1e-3) * 1e-2d, BaseUnit); - case MolarityUnit.DecimolesPerLiter: - return new Molarity((_value/1e-3) * 1e-1d, BaseUnit); - case MolarityUnit.MicromolesPerLiter: - return new Molarity((_value/1e-3) * 1e-6d, BaseUnit); - case MolarityUnit.MillimolesPerLiter: - return new Molarity((_value/1e-3) * 1e-3d, BaseUnit); - case MolarityUnit.MolesPerCubicMeter: - return new Molarity(_value, BaseUnit); - case MolarityUnit.MolesPerLiter: - return new Molarity(_value/1e-3, BaseUnit); - case MolarityUnit.NanomolesPerLiter: - return new Molarity((_value/1e-3) * 1e-9d, BaseUnit); - case MolarityUnit.PicomolesPerLiter: - return new Molarity((_value/1e-3) * 1e-12d, BaseUnit); + case MolarityUnit.CentimolesPerLiter: return (_value/1e-3) * 1e-2d; + case MolarityUnit.DecimolesPerLiter: return (_value/1e-3) * 1e-1d; + case MolarityUnit.MicromolesPerLiter: return (_value/1e-3) * 1e-6d; + case MolarityUnit.MillimolesPerLiter: return (_value/1e-3) * 1e-3d; + case MolarityUnit.MolesPerCubicMeter: return _value; + case MolarityUnit.MolesPerLiter: return _value/1e-3; + case MolarityUnit.NanomolesPerLiter: return (_value/1e-3) * 1e-9d; + case MolarityUnit.PicomolesPerLiter: return (_value/1e-3) * 1e-12d; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(MolarityUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Molarity ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Molarity(baseUnitValue, BaseUnit); + } + + private double GetValueAs(MolarityUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permeability.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permeability.WindowsRuntimeComponent.g.cs index e133089875..984da62f0d 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permeability.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permeability.WindowsRuntimeComponent.g.cs @@ -385,7 +385,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Permeability other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -399,7 +399,7 @@ public override bool Equals(object obj) public bool Equals(Permeability other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -475,7 +475,7 @@ public double As(PermeabilityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -485,7 +485,7 @@ public double As(PermeabilityUnit unit) /// A Permeability with the specified unit. public Permeability ToUnit(PermeabilityUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Permeability(convertedValue, unit); } @@ -494,24 +494,33 @@ public Permeability ToUnit(PermeabilityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Permeability AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case PermeabilityUnit.HenryPerMeter: - return new Permeability(_value, BaseUnit); + case PermeabilityUnit.HenryPerMeter: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(PermeabilityUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Permeability ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Permeability(baseUnitValue, BaseUnit); + } + + private double GetValueAs(PermeabilityUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permittivity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permittivity.WindowsRuntimeComponent.g.cs index 902c682010..634c5e8bf4 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permittivity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permittivity.WindowsRuntimeComponent.g.cs @@ -385,7 +385,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Permittivity other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -399,7 +399,7 @@ public override bool Equals(object obj) public bool Equals(Permittivity other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -475,7 +475,7 @@ public double As(PermittivityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -485,7 +485,7 @@ public double As(PermittivityUnit unit) /// A Permittivity with the specified unit. public Permittivity ToUnit(PermittivityUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Permittivity(convertedValue, unit); } @@ -494,24 +494,33 @@ public Permittivity ToUnit(PermittivityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Permittivity AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case PermittivityUnit.FaradPerMeter: - return new Permittivity(_value, BaseUnit); + case PermittivityUnit.FaradPerMeter: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(PermittivityUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Permittivity ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Permittivity(baseUnitValue, BaseUnit); + } + + private double GetValueAs(PermittivityUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Power.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Power.WindowsRuntimeComponent.g.cs index 6c2aaab521..ea5d54403f 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Power.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Power.WindowsRuntimeComponent.g.cs @@ -667,7 +667,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Power other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -681,7 +681,7 @@ public override bool Equals(object obj) public bool Equals(Power other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -757,7 +757,7 @@ public double As(PowerUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -767,7 +767,7 @@ public double As(PowerUnit unit) /// A Power with the specified unit. public Power ToUnit(PowerUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Power(convertedValue, unit); } @@ -776,62 +776,52 @@ public Power ToUnit(PowerUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Power AsBaseUnit() + private decimal GetValueInBaseUnit() { switch(Unit) { - case PowerUnit.BoilerHorsepower: - return new Power(_value*9812.5m, BaseUnit); - case PowerUnit.BritishThermalUnitPerHour: - return new Power(_value*0.293071m, BaseUnit); - case PowerUnit.Decawatt: - return new Power((_value) * 1e1m, BaseUnit); - case PowerUnit.Deciwatt: - return new Power((_value) * 1e-1m, BaseUnit); - case PowerUnit.ElectricalHorsepower: - return new Power(_value*746m, BaseUnit); - case PowerUnit.Femtowatt: - return new Power((_value) * 1e-15m, BaseUnit); - case PowerUnit.Gigawatt: - return new Power((_value) * 1e9m, BaseUnit); - case PowerUnit.HydraulicHorsepower: - return new Power(_value*745.69988145m, BaseUnit); - case PowerUnit.KilobritishThermalUnitPerHour: - return new Power((_value*0.293071m) * 1e3m, BaseUnit); - case PowerUnit.Kilowatt: - return new Power((_value) * 1e3m, BaseUnit); - case PowerUnit.MechanicalHorsepower: - return new Power(_value*745.69m, BaseUnit); - case PowerUnit.Megawatt: - return new Power((_value) * 1e6m, BaseUnit); - case PowerUnit.MetricHorsepower: - return new Power(_value*735.49875m, BaseUnit); - case PowerUnit.Microwatt: - return new Power((_value) * 1e-6m, BaseUnit); - case PowerUnit.Milliwatt: - return new Power((_value) * 1e-3m, BaseUnit); - case PowerUnit.Nanowatt: - return new Power((_value) * 1e-9m, BaseUnit); - case PowerUnit.Petawatt: - return new Power((_value) * 1e15m, BaseUnit); - case PowerUnit.Picowatt: - return new Power((_value) * 1e-12m, BaseUnit); - case PowerUnit.Terawatt: - return new Power((_value) * 1e12m, BaseUnit); - case PowerUnit.Watt: - return new Power(_value, BaseUnit); + case PowerUnit.BoilerHorsepower: return _value*9812.5m; + case PowerUnit.BritishThermalUnitPerHour: return _value*0.293071m; + case PowerUnit.Decawatt: return (_value) * 1e1m; + case PowerUnit.Deciwatt: return (_value) * 1e-1m; + case PowerUnit.ElectricalHorsepower: return _value*746m; + case PowerUnit.Femtowatt: return (_value) * 1e-15m; + case PowerUnit.Gigawatt: return (_value) * 1e9m; + case PowerUnit.HydraulicHorsepower: return _value*745.69988145m; + case PowerUnit.KilobritishThermalUnitPerHour: return (_value*0.293071m) * 1e3m; + case PowerUnit.Kilowatt: return (_value) * 1e3m; + case PowerUnit.MechanicalHorsepower: return _value*745.69m; + case PowerUnit.Megawatt: return (_value) * 1e6m; + case PowerUnit.MetricHorsepower: return _value*735.49875m; + case PowerUnit.Microwatt: return (_value) * 1e-6m; + case PowerUnit.Milliwatt: return (_value) * 1e-3m; + case PowerUnit.Nanowatt: return (_value) * 1e-9m; + case PowerUnit.Petawatt: return (_value) * 1e15m; + case PowerUnit.Picowatt: return (_value) * 1e-12m; + case PowerUnit.Terawatt: return (_value) * 1e12m; + case PowerUnit.Watt: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private decimal AsBaseNumericType(PowerUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Power ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Power(baseUnitValue, BaseUnit); + } + + private decimal GetValueAs(PowerUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerDensity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerDensity.WindowsRuntimeComponent.g.cs index f59cc3c602..664b0b83eb 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerDensity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerDensity.WindowsRuntimeComponent.g.cs @@ -1027,7 +1027,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(PowerDensity other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -1041,7 +1041,7 @@ public override bool Equals(object obj) public bool Equals(PowerDensity other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -1117,7 +1117,7 @@ public double As(PowerDensityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -1127,7 +1127,7 @@ public double As(PowerDensityUnit unit) /// A PowerDensity with the specified unit. public PowerDensity ToUnit(PowerDensityUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new PowerDensity(convertedValue, unit); } @@ -1136,110 +1136,76 @@ public PowerDensity ToUnit(PowerDensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal PowerDensity AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case PowerDensityUnit.DecawattPerCubicFoot: - return new PowerDensity((_value*3.531466672148859e1) * 1e1d, BaseUnit); - case PowerDensityUnit.DecawattPerCubicInch: - return new PowerDensity((_value*6.102374409473228e4) * 1e1d, BaseUnit); - case PowerDensityUnit.DecawattPerCubicMeter: - return new PowerDensity((_value) * 1e1d, BaseUnit); - case PowerDensityUnit.DecawattPerLiter: - return new PowerDensity((_value*1.0e3) * 1e1d, BaseUnit); - case PowerDensityUnit.DeciwattPerCubicFoot: - return new PowerDensity((_value*3.531466672148859e1) * 1e-1d, BaseUnit); - case PowerDensityUnit.DeciwattPerCubicInch: - return new PowerDensity((_value*6.102374409473228e4) * 1e-1d, BaseUnit); - case PowerDensityUnit.DeciwattPerCubicMeter: - return new PowerDensity((_value) * 1e-1d, BaseUnit); - case PowerDensityUnit.DeciwattPerLiter: - return new PowerDensity((_value*1.0e3) * 1e-1d, BaseUnit); - case PowerDensityUnit.GigawattPerCubicFoot: - return new PowerDensity((_value*3.531466672148859e1) * 1e9d, BaseUnit); - case PowerDensityUnit.GigawattPerCubicInch: - return new PowerDensity((_value*6.102374409473228e4) * 1e9d, BaseUnit); - case PowerDensityUnit.GigawattPerCubicMeter: - return new PowerDensity((_value) * 1e9d, BaseUnit); - case PowerDensityUnit.GigawattPerLiter: - return new PowerDensity((_value*1.0e3) * 1e9d, BaseUnit); - case PowerDensityUnit.KilowattPerCubicFoot: - return new PowerDensity((_value*3.531466672148859e1) * 1e3d, BaseUnit); - case PowerDensityUnit.KilowattPerCubicInch: - return new PowerDensity((_value*6.102374409473228e4) * 1e3d, BaseUnit); - case PowerDensityUnit.KilowattPerCubicMeter: - return new PowerDensity((_value) * 1e3d, BaseUnit); - case PowerDensityUnit.KilowattPerLiter: - return new PowerDensity((_value*1.0e3) * 1e3d, BaseUnit); - case PowerDensityUnit.MegawattPerCubicFoot: - return new PowerDensity((_value*3.531466672148859e1) * 1e6d, BaseUnit); - case PowerDensityUnit.MegawattPerCubicInch: - return new PowerDensity((_value*6.102374409473228e4) * 1e6d, BaseUnit); - case PowerDensityUnit.MegawattPerCubicMeter: - return new PowerDensity((_value) * 1e6d, BaseUnit); - case PowerDensityUnit.MegawattPerLiter: - return new PowerDensity((_value*1.0e3) * 1e6d, BaseUnit); - case PowerDensityUnit.MicrowattPerCubicFoot: - return new PowerDensity((_value*3.531466672148859e1) * 1e-6d, BaseUnit); - case PowerDensityUnit.MicrowattPerCubicInch: - return new PowerDensity((_value*6.102374409473228e4) * 1e-6d, BaseUnit); - case PowerDensityUnit.MicrowattPerCubicMeter: - return new PowerDensity((_value) * 1e-6d, BaseUnit); - case PowerDensityUnit.MicrowattPerLiter: - return new PowerDensity((_value*1.0e3) * 1e-6d, BaseUnit); - case PowerDensityUnit.MilliwattPerCubicFoot: - return new PowerDensity((_value*3.531466672148859e1) * 1e-3d, BaseUnit); - case PowerDensityUnit.MilliwattPerCubicInch: - return new PowerDensity((_value*6.102374409473228e4) * 1e-3d, BaseUnit); - case PowerDensityUnit.MilliwattPerCubicMeter: - return new PowerDensity((_value) * 1e-3d, BaseUnit); - case PowerDensityUnit.MilliwattPerLiter: - return new PowerDensity((_value*1.0e3) * 1e-3d, BaseUnit); - case PowerDensityUnit.NanowattPerCubicFoot: - return new PowerDensity((_value*3.531466672148859e1) * 1e-9d, BaseUnit); - case PowerDensityUnit.NanowattPerCubicInch: - return new PowerDensity((_value*6.102374409473228e4) * 1e-9d, BaseUnit); - case PowerDensityUnit.NanowattPerCubicMeter: - return new PowerDensity((_value) * 1e-9d, BaseUnit); - case PowerDensityUnit.NanowattPerLiter: - return new PowerDensity((_value*1.0e3) * 1e-9d, BaseUnit); - case PowerDensityUnit.PicowattPerCubicFoot: - return new PowerDensity((_value*3.531466672148859e1) * 1e-12d, BaseUnit); - case PowerDensityUnit.PicowattPerCubicInch: - return new PowerDensity((_value*6.102374409473228e4) * 1e-12d, BaseUnit); - case PowerDensityUnit.PicowattPerCubicMeter: - return new PowerDensity((_value) * 1e-12d, BaseUnit); - case PowerDensityUnit.PicowattPerLiter: - return new PowerDensity((_value*1.0e3) * 1e-12d, BaseUnit); - case PowerDensityUnit.TerawattPerCubicFoot: - return new PowerDensity((_value*3.531466672148859e1) * 1e12d, BaseUnit); - case PowerDensityUnit.TerawattPerCubicInch: - return new PowerDensity((_value*6.102374409473228e4) * 1e12d, BaseUnit); - case PowerDensityUnit.TerawattPerCubicMeter: - return new PowerDensity((_value) * 1e12d, BaseUnit); - case PowerDensityUnit.TerawattPerLiter: - return new PowerDensity((_value*1.0e3) * 1e12d, BaseUnit); - case PowerDensityUnit.WattPerCubicFoot: - return new PowerDensity(_value*3.531466672148859e1, BaseUnit); - case PowerDensityUnit.WattPerCubicInch: - return new PowerDensity(_value*6.102374409473228e4, BaseUnit); - case PowerDensityUnit.WattPerCubicMeter: - return new PowerDensity(_value, BaseUnit); - case PowerDensityUnit.WattPerLiter: - return new PowerDensity(_value*1.0e3, BaseUnit); + case PowerDensityUnit.DecawattPerCubicFoot: return (_value*3.531466672148859e1) * 1e1d; + case PowerDensityUnit.DecawattPerCubicInch: return (_value*6.102374409473228e4) * 1e1d; + case PowerDensityUnit.DecawattPerCubicMeter: return (_value) * 1e1d; + case PowerDensityUnit.DecawattPerLiter: return (_value*1.0e3) * 1e1d; + case PowerDensityUnit.DeciwattPerCubicFoot: return (_value*3.531466672148859e1) * 1e-1d; + case PowerDensityUnit.DeciwattPerCubicInch: return (_value*6.102374409473228e4) * 1e-1d; + case PowerDensityUnit.DeciwattPerCubicMeter: return (_value) * 1e-1d; + case PowerDensityUnit.DeciwattPerLiter: return (_value*1.0e3) * 1e-1d; + case PowerDensityUnit.GigawattPerCubicFoot: return (_value*3.531466672148859e1) * 1e9d; + case PowerDensityUnit.GigawattPerCubicInch: return (_value*6.102374409473228e4) * 1e9d; + case PowerDensityUnit.GigawattPerCubicMeter: return (_value) * 1e9d; + case PowerDensityUnit.GigawattPerLiter: return (_value*1.0e3) * 1e9d; + case PowerDensityUnit.KilowattPerCubicFoot: return (_value*3.531466672148859e1) * 1e3d; + case PowerDensityUnit.KilowattPerCubicInch: return (_value*6.102374409473228e4) * 1e3d; + case PowerDensityUnit.KilowattPerCubicMeter: return (_value) * 1e3d; + case PowerDensityUnit.KilowattPerLiter: return (_value*1.0e3) * 1e3d; + case PowerDensityUnit.MegawattPerCubicFoot: return (_value*3.531466672148859e1) * 1e6d; + case PowerDensityUnit.MegawattPerCubicInch: return (_value*6.102374409473228e4) * 1e6d; + case PowerDensityUnit.MegawattPerCubicMeter: return (_value) * 1e6d; + case PowerDensityUnit.MegawattPerLiter: return (_value*1.0e3) * 1e6d; + case PowerDensityUnit.MicrowattPerCubicFoot: return (_value*3.531466672148859e1) * 1e-6d; + case PowerDensityUnit.MicrowattPerCubicInch: return (_value*6.102374409473228e4) * 1e-6d; + case PowerDensityUnit.MicrowattPerCubicMeter: return (_value) * 1e-6d; + case PowerDensityUnit.MicrowattPerLiter: return (_value*1.0e3) * 1e-6d; + case PowerDensityUnit.MilliwattPerCubicFoot: return (_value*3.531466672148859e1) * 1e-3d; + case PowerDensityUnit.MilliwattPerCubicInch: return (_value*6.102374409473228e4) * 1e-3d; + case PowerDensityUnit.MilliwattPerCubicMeter: return (_value) * 1e-3d; + case PowerDensityUnit.MilliwattPerLiter: return (_value*1.0e3) * 1e-3d; + case PowerDensityUnit.NanowattPerCubicFoot: return (_value*3.531466672148859e1) * 1e-9d; + case PowerDensityUnit.NanowattPerCubicInch: return (_value*6.102374409473228e4) * 1e-9d; + case PowerDensityUnit.NanowattPerCubicMeter: return (_value) * 1e-9d; + case PowerDensityUnit.NanowattPerLiter: return (_value*1.0e3) * 1e-9d; + case PowerDensityUnit.PicowattPerCubicFoot: return (_value*3.531466672148859e1) * 1e-12d; + case PowerDensityUnit.PicowattPerCubicInch: return (_value*6.102374409473228e4) * 1e-12d; + case PowerDensityUnit.PicowattPerCubicMeter: return (_value) * 1e-12d; + case PowerDensityUnit.PicowattPerLiter: return (_value*1.0e3) * 1e-12d; + case PowerDensityUnit.TerawattPerCubicFoot: return (_value*3.531466672148859e1) * 1e12d; + case PowerDensityUnit.TerawattPerCubicInch: return (_value*6.102374409473228e4) * 1e12d; + case PowerDensityUnit.TerawattPerCubicMeter: return (_value) * 1e12d; + case PowerDensityUnit.TerawattPerLiter: return (_value*1.0e3) * 1e12d; + case PowerDensityUnit.WattPerCubicFoot: return _value*3.531466672148859e1; + case PowerDensityUnit.WattPerCubicInch: return _value*6.102374409473228e4; + case PowerDensityUnit.WattPerCubicMeter: return _value; + case PowerDensityUnit.WattPerLiter: return _value*1.0e3; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(PowerDensityUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal PowerDensity ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new PowerDensity(baseUnitValue, BaseUnit); + } + + private double GetValueAs(PowerDensityUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerRatio.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerRatio.WindowsRuntimeComponent.g.cs index 3af29d9ba8..49f85be9f8 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerRatio.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerRatio.WindowsRuntimeComponent.g.cs @@ -397,7 +397,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(PowerRatio other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -411,7 +411,7 @@ public override bool Equals(object obj) public bool Equals(PowerRatio other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -487,7 +487,7 @@ public double As(PowerRatioUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -497,7 +497,7 @@ public double As(PowerRatioUnit unit) /// A PowerRatio with the specified unit. public PowerRatio ToUnit(PowerRatioUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new PowerRatio(convertedValue, unit); } @@ -506,26 +506,34 @@ public PowerRatio ToUnit(PowerRatioUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal PowerRatio AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case PowerRatioUnit.DecibelMilliwatt: - return new PowerRatio(_value - 30, BaseUnit); - case PowerRatioUnit.DecibelWatt: - return new PowerRatio(_value, BaseUnit); + case PowerRatioUnit.DecibelMilliwatt: return _value - 30; + case PowerRatioUnit.DecibelWatt: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(PowerRatioUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal PowerRatio ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new PowerRatio(baseUnitValue, BaseUnit); + } + + private double GetValueAs(PowerRatioUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Pressure.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Pressure.WindowsRuntimeComponent.g.cs index 6a8b9b8855..f7af02f2ea 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Pressure.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Pressure.WindowsRuntimeComponent.g.cs @@ -997,7 +997,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Pressure other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -1011,7 +1011,7 @@ public override bool Equals(object obj) public bool Equals(Pressure other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -1087,7 +1087,7 @@ public double As(PressureUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -1097,7 +1097,7 @@ public double As(PressureUnit unit) /// A Pressure with the specified unit. public Pressure ToUnit(PressureUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Pressure(convertedValue, unit); } @@ -1106,106 +1106,74 @@ public Pressure ToUnit(PressureUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Pressure AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case PressureUnit.Atmosphere: - return new Pressure(_value*1.01325*1e5, BaseUnit); - case PressureUnit.Bar: - return new Pressure(_value*1e5, BaseUnit); - case PressureUnit.Centibar: - return new Pressure((_value*1e5) * 1e-2d, BaseUnit); - case PressureUnit.Decapascal: - return new Pressure((_value) * 1e1d, BaseUnit); - case PressureUnit.Decibar: - return new Pressure((_value*1e5) * 1e-1d, BaseUnit); - case PressureUnit.DynePerSquareCentimeter: - return new Pressure(_value*1.0e-1, BaseUnit); - case PressureUnit.FootOfHead: - return new Pressure(_value*2989.0669, BaseUnit); - case PressureUnit.Gigapascal: - return new Pressure((_value) * 1e9d, BaseUnit); - case PressureUnit.Hectopascal: - return new Pressure((_value) * 1e2d, BaseUnit); - case PressureUnit.InchOfMercury: - return new Pressure(_value/2.95299830714159e-4, BaseUnit); - case PressureUnit.InchOfWaterColumn: - return new Pressure(_value*249.08890833333, BaseUnit); - case PressureUnit.Kilobar: - return new Pressure((_value*1e5) * 1e3d, BaseUnit); - case PressureUnit.KilogramForcePerSquareCentimeter: - return new Pressure(_value*9.80665e4, BaseUnit); - case PressureUnit.KilogramForcePerSquareMeter: - return new Pressure(_value*9.80665019960652, BaseUnit); - case PressureUnit.KilogramForcePerSquareMillimeter: - return new Pressure(_value*9.80665e6, BaseUnit); - case PressureUnit.KilonewtonPerSquareCentimeter: - return new Pressure((_value*1e4) * 1e3d, BaseUnit); - case PressureUnit.KilonewtonPerSquareMeter: - return new Pressure((_value) * 1e3d, BaseUnit); - case PressureUnit.KilonewtonPerSquareMillimeter: - return new Pressure((_value*1e6) * 1e3d, BaseUnit); - case PressureUnit.Kilopascal: - return new Pressure((_value) * 1e3d, BaseUnit); - case PressureUnit.KilopoundForcePerSquareFoot: - return new Pressure((_value*4.788025898033584e1) * 1e3d, BaseUnit); - case PressureUnit.KilopoundForcePerSquareInch: - return new Pressure((_value*6.894757293168361e3) * 1e3d, BaseUnit); - case PressureUnit.Megabar: - return new Pressure((_value*1e5) * 1e6d, BaseUnit); - case PressureUnit.MeganewtonPerSquareMeter: - return new Pressure((_value) * 1e6d, BaseUnit); - case PressureUnit.Megapascal: - return new Pressure((_value) * 1e6d, BaseUnit); - case PressureUnit.MeterOfHead: - return new Pressure(_value*9804.139432, BaseUnit); - case PressureUnit.Microbar: - return new Pressure((_value*1e5) * 1e-6d, BaseUnit); - case PressureUnit.Micropascal: - return new Pressure((_value) * 1e-6d, BaseUnit); - case PressureUnit.Millibar: - return new Pressure((_value*1e5) * 1e-3d, BaseUnit); - case PressureUnit.MillimeterOfMercury: - return new Pressure(_value/7.50061561302643e-3, BaseUnit); - case PressureUnit.Millipascal: - return new Pressure((_value) * 1e-3d, BaseUnit); - case PressureUnit.NewtonPerSquareCentimeter: - return new Pressure(_value*1e4, BaseUnit); - case PressureUnit.NewtonPerSquareMeter: - return new Pressure(_value, BaseUnit); - case PressureUnit.NewtonPerSquareMillimeter: - return new Pressure(_value*1e6, BaseUnit); - case PressureUnit.Pascal: - return new Pressure(_value, BaseUnit); - case PressureUnit.PoundForcePerSquareFoot: - return new Pressure(_value*4.788025898033584e1, BaseUnit); - case PressureUnit.PoundForcePerSquareInch: - return new Pressure(_value*6.894757293168361e3, BaseUnit); - case PressureUnit.PoundPerInchSecondSquared: - return new Pressure(_value*1.785796732283465e1, BaseUnit); - case PressureUnit.TechnicalAtmosphere: - return new Pressure(_value*9.80680592331*1e4, BaseUnit); - case PressureUnit.TonneForcePerSquareCentimeter: - return new Pressure(_value*9.80665e7, BaseUnit); - case PressureUnit.TonneForcePerSquareMeter: - return new Pressure(_value*9.80665e3, BaseUnit); - case PressureUnit.TonneForcePerSquareMillimeter: - return new Pressure(_value*9.80665e9, BaseUnit); - case PressureUnit.Torr: - return new Pressure(_value*1.3332266752*1e2, BaseUnit); + case PressureUnit.Atmosphere: return _value*1.01325*1e5; + case PressureUnit.Bar: return _value*1e5; + case PressureUnit.Centibar: return (_value*1e5) * 1e-2d; + case PressureUnit.Decapascal: return (_value) * 1e1d; + case PressureUnit.Decibar: return (_value*1e5) * 1e-1d; + case PressureUnit.DynePerSquareCentimeter: return _value*1.0e-1; + case PressureUnit.FootOfHead: return _value*2989.0669; + case PressureUnit.Gigapascal: return (_value) * 1e9d; + case PressureUnit.Hectopascal: return (_value) * 1e2d; + case PressureUnit.InchOfMercury: return _value/2.95299830714159e-4; + case PressureUnit.InchOfWaterColumn: return _value*249.08890833333; + case PressureUnit.Kilobar: return (_value*1e5) * 1e3d; + case PressureUnit.KilogramForcePerSquareCentimeter: return _value*9.80665e4; + case PressureUnit.KilogramForcePerSquareMeter: return _value*9.80665019960652; + case PressureUnit.KilogramForcePerSquareMillimeter: return _value*9.80665e6; + case PressureUnit.KilonewtonPerSquareCentimeter: return (_value*1e4) * 1e3d; + case PressureUnit.KilonewtonPerSquareMeter: return (_value) * 1e3d; + case PressureUnit.KilonewtonPerSquareMillimeter: return (_value*1e6) * 1e3d; + case PressureUnit.Kilopascal: return (_value) * 1e3d; + case PressureUnit.KilopoundForcePerSquareFoot: return (_value*4.788025898033584e1) * 1e3d; + case PressureUnit.KilopoundForcePerSquareInch: return (_value*6.894757293168361e3) * 1e3d; + case PressureUnit.Megabar: return (_value*1e5) * 1e6d; + case PressureUnit.MeganewtonPerSquareMeter: return (_value) * 1e6d; + case PressureUnit.Megapascal: return (_value) * 1e6d; + case PressureUnit.MeterOfHead: return _value*9804.139432; + case PressureUnit.Microbar: return (_value*1e5) * 1e-6d; + case PressureUnit.Micropascal: return (_value) * 1e-6d; + case PressureUnit.Millibar: return (_value*1e5) * 1e-3d; + case PressureUnit.MillimeterOfMercury: return _value/7.50061561302643e-3; + case PressureUnit.Millipascal: return (_value) * 1e-3d; + case PressureUnit.NewtonPerSquareCentimeter: return _value*1e4; + case PressureUnit.NewtonPerSquareMeter: return _value; + case PressureUnit.NewtonPerSquareMillimeter: return _value*1e6; + case PressureUnit.Pascal: return _value; + case PressureUnit.PoundForcePerSquareFoot: return _value*4.788025898033584e1; + case PressureUnit.PoundForcePerSquareInch: return _value*6.894757293168361e3; + case PressureUnit.PoundPerInchSecondSquared: return _value*1.785796732283465e1; + case PressureUnit.TechnicalAtmosphere: return _value*9.80680592331*1e4; + case PressureUnit.TonneForcePerSquareCentimeter: return _value*9.80665e7; + case PressureUnit.TonneForcePerSquareMeter: return _value*9.80665e3; + case PressureUnit.TonneForcePerSquareMillimeter: return _value*9.80665e9; + case PressureUnit.Torr: return _value*1.3332266752*1e2; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(PressureUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Pressure ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Pressure(baseUnitValue, BaseUnit); + } + + private double GetValueAs(PressureUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PressureChangeRate.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PressureChangeRate.WindowsRuntimeComponent.g.cs index 9fe78941e0..dc2c44501e 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PressureChangeRate.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PressureChangeRate.WindowsRuntimeComponent.g.cs @@ -472,7 +472,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(PressureChangeRate other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -486,7 +486,7 @@ public override bool Equals(object obj) public bool Equals(PressureChangeRate other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -562,7 +562,7 @@ public double As(PressureChangeRateUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -572,7 +572,7 @@ public double As(PressureChangeRateUnit unit) /// A PressureChangeRate with the specified unit. public PressureChangeRate ToUnit(PressureChangeRateUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new PressureChangeRate(convertedValue, unit); } @@ -581,36 +581,39 @@ public PressureChangeRate ToUnit(PressureChangeRateUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal PressureChangeRate AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case PressureChangeRateUnit.AtmospherePerSecond: - return new PressureChangeRate(_value * 1.01325*1e5, BaseUnit); - case PressureChangeRateUnit.KilopascalPerMinute: - return new PressureChangeRate((_value/60) * 1e3d, BaseUnit); - case PressureChangeRateUnit.KilopascalPerSecond: - return new PressureChangeRate((_value) * 1e3d, BaseUnit); - case PressureChangeRateUnit.MegapascalPerMinute: - return new PressureChangeRate((_value/60) * 1e6d, BaseUnit); - case PressureChangeRateUnit.MegapascalPerSecond: - return new PressureChangeRate((_value) * 1e6d, BaseUnit); - case PressureChangeRateUnit.PascalPerMinute: - return new PressureChangeRate(_value/60, BaseUnit); - case PressureChangeRateUnit.PascalPerSecond: - return new PressureChangeRate(_value, BaseUnit); + case PressureChangeRateUnit.AtmospherePerSecond: return _value * 1.01325*1e5; + case PressureChangeRateUnit.KilopascalPerMinute: return (_value/60) * 1e3d; + case PressureChangeRateUnit.KilopascalPerSecond: return (_value) * 1e3d; + case PressureChangeRateUnit.MegapascalPerMinute: return (_value/60) * 1e6d; + case PressureChangeRateUnit.MegapascalPerSecond: return (_value) * 1e6d; + case PressureChangeRateUnit.PascalPerMinute: return _value/60; + case PressureChangeRateUnit.PascalPerSecond: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(PressureChangeRateUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal PressureChangeRate ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new PressureChangeRate(baseUnitValue, BaseUnit); + } + + private double GetValueAs(PressureChangeRateUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Ratio.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Ratio.WindowsRuntimeComponent.g.cs index f20aa02e65..92183ed899 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Ratio.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Ratio.WindowsRuntimeComponent.g.cs @@ -457,7 +457,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Ratio other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -471,7 +471,7 @@ public override bool Equals(object obj) public bool Equals(Ratio other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -547,7 +547,7 @@ public double As(RatioUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -557,7 +557,7 @@ public double As(RatioUnit unit) /// A Ratio with the specified unit. public Ratio ToUnit(RatioUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Ratio(convertedValue, unit); } @@ -566,34 +566,38 @@ public Ratio ToUnit(RatioUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Ratio AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case RatioUnit.DecimalFraction: - return new Ratio(_value, BaseUnit); - case RatioUnit.PartPerBillion: - return new Ratio(_value/1e9, BaseUnit); - case RatioUnit.PartPerMillion: - return new Ratio(_value/1e6, BaseUnit); - case RatioUnit.PartPerThousand: - return new Ratio(_value/1e3, BaseUnit); - case RatioUnit.PartPerTrillion: - return new Ratio(_value/1e12, BaseUnit); - case RatioUnit.Percent: - return new Ratio(_value/1e2, BaseUnit); + case RatioUnit.DecimalFraction: return _value; + case RatioUnit.PartPerBillion: return _value/1e9; + case RatioUnit.PartPerMillion: return _value/1e6; + case RatioUnit.PartPerThousand: return _value/1e3; + case RatioUnit.PartPerTrillion: return _value/1e12; + case RatioUnit.Percent: return _value/1e2; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(RatioUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Ratio ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Ratio(baseUnitValue, BaseUnit); + } + + private double GetValueAs(RatioUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactiveEnergy.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactiveEnergy.WindowsRuntimeComponent.g.cs index 2e6129acb7..8f0ab983bf 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactiveEnergy.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactiveEnergy.WindowsRuntimeComponent.g.cs @@ -412,7 +412,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ReactiveEnergy other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -426,7 +426,7 @@ public override bool Equals(object obj) public bool Equals(ReactiveEnergy other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -502,7 +502,7 @@ public double As(ReactiveEnergyUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -512,7 +512,7 @@ public double As(ReactiveEnergyUnit unit) /// A ReactiveEnergy with the specified unit. public ReactiveEnergy ToUnit(ReactiveEnergyUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ReactiveEnergy(convertedValue, unit); } @@ -521,28 +521,35 @@ public ReactiveEnergy ToUnit(ReactiveEnergyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ReactiveEnergy AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ReactiveEnergyUnit.KilovoltampereReactiveHour: - return new ReactiveEnergy((_value) * 1e3d, BaseUnit); - case ReactiveEnergyUnit.MegavoltampereReactiveHour: - return new ReactiveEnergy((_value) * 1e6d, BaseUnit); - case ReactiveEnergyUnit.VoltampereReactiveHour: - return new ReactiveEnergy(_value, BaseUnit); + case ReactiveEnergyUnit.KilovoltampereReactiveHour: return (_value) * 1e3d; + case ReactiveEnergyUnit.MegavoltampereReactiveHour: return (_value) * 1e6d; + case ReactiveEnergyUnit.VoltampereReactiveHour: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ReactiveEnergyUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ReactiveEnergy ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ReactiveEnergy(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ReactiveEnergyUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactivePower.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactivePower.WindowsRuntimeComponent.g.cs index 5d06811450..c1d61700a5 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactivePower.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactivePower.WindowsRuntimeComponent.g.cs @@ -427,7 +427,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ReactivePower other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -441,7 +441,7 @@ public override bool Equals(object obj) public bool Equals(ReactivePower other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -517,7 +517,7 @@ public double As(ReactivePowerUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -527,7 +527,7 @@ public double As(ReactivePowerUnit unit) /// A ReactivePower with the specified unit. public ReactivePower ToUnit(ReactivePowerUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ReactivePower(convertedValue, unit); } @@ -536,30 +536,36 @@ public ReactivePower ToUnit(ReactivePowerUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ReactivePower AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ReactivePowerUnit.GigavoltampereReactive: - return new ReactivePower((_value) * 1e9d, BaseUnit); - case ReactivePowerUnit.KilovoltampereReactive: - return new ReactivePower((_value) * 1e3d, BaseUnit); - case ReactivePowerUnit.MegavoltampereReactive: - return new ReactivePower((_value) * 1e6d, BaseUnit); - case ReactivePowerUnit.VoltampereReactive: - return new ReactivePower(_value, BaseUnit); + case ReactivePowerUnit.GigavoltampereReactive: return (_value) * 1e9d; + case ReactivePowerUnit.KilovoltampereReactive: return (_value) * 1e3d; + case ReactivePowerUnit.MegavoltampereReactive: return (_value) * 1e6d; + case ReactivePowerUnit.VoltampereReactive: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ReactivePowerUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ReactivePower ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ReactivePower(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ReactivePowerUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalAcceleration.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalAcceleration.WindowsRuntimeComponent.g.cs index e42a3ba838..9c489da383 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalAcceleration.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalAcceleration.WindowsRuntimeComponent.g.cs @@ -412,7 +412,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(RotationalAcceleration other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -426,7 +426,7 @@ public override bool Equals(object obj) public bool Equals(RotationalAcceleration other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -502,7 +502,7 @@ public double As(RotationalAccelerationUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -512,7 +512,7 @@ public double As(RotationalAccelerationUnit unit) /// A RotationalAcceleration with the specified unit. public RotationalAcceleration ToUnit(RotationalAccelerationUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new RotationalAcceleration(convertedValue, unit); } @@ -521,28 +521,35 @@ public RotationalAcceleration ToUnit(RotationalAccelerationUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal RotationalAcceleration AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case RotationalAccelerationUnit.DegreePerSecondSquared: - return new RotationalAcceleration((Math.PI/180)*_value, BaseUnit); - case RotationalAccelerationUnit.RadianPerSecondSquared: - return new RotationalAcceleration(_value, BaseUnit); - case RotationalAccelerationUnit.RevolutionPerMinutePerSecond: - return new RotationalAcceleration(((2*Math.PI)/60)*_value, BaseUnit); + case RotationalAccelerationUnit.DegreePerSecondSquared: return (Math.PI/180)*_value; + case RotationalAccelerationUnit.RadianPerSecondSquared: return _value; + case RotationalAccelerationUnit.RevolutionPerMinutePerSecond: return ((2*Math.PI)/60)*_value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(RotationalAccelerationUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal RotationalAcceleration ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new RotationalAcceleration(baseUnitValue, BaseUnit); + } + + private double GetValueAs(RotationalAccelerationUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalSpeed.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalSpeed.WindowsRuntimeComponent.g.cs index f35c5a1f98..19567d058a 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalSpeed.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalSpeed.WindowsRuntimeComponent.g.cs @@ -562,7 +562,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(RotationalSpeed other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -576,7 +576,7 @@ public override bool Equals(object obj) public bool Equals(RotationalSpeed other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -652,7 +652,7 @@ public double As(RotationalSpeedUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -662,7 +662,7 @@ public double As(RotationalSpeedUnit unit) /// A RotationalSpeed with the specified unit. public RotationalSpeed ToUnit(RotationalSpeedUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new RotationalSpeed(convertedValue, unit); } @@ -671,48 +671,45 @@ public RotationalSpeed ToUnit(RotationalSpeedUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal RotationalSpeed AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case RotationalSpeedUnit.CentiradianPerSecond: - return new RotationalSpeed((_value) * 1e-2d, BaseUnit); - case RotationalSpeedUnit.DeciradianPerSecond: - return new RotationalSpeed((_value) * 1e-1d, BaseUnit); - case RotationalSpeedUnit.DegreePerMinute: - return new RotationalSpeed((Math.PI/(180*60))*_value, BaseUnit); - case RotationalSpeedUnit.DegreePerSecond: - return new RotationalSpeed((Math.PI/180)*_value, BaseUnit); - case RotationalSpeedUnit.MicrodegreePerSecond: - return new RotationalSpeed(((Math.PI/180)*_value) * 1e-6d, BaseUnit); - case RotationalSpeedUnit.MicroradianPerSecond: - return new RotationalSpeed((_value) * 1e-6d, BaseUnit); - case RotationalSpeedUnit.MillidegreePerSecond: - return new RotationalSpeed(((Math.PI/180)*_value) * 1e-3d, BaseUnit); - case RotationalSpeedUnit.MilliradianPerSecond: - return new RotationalSpeed((_value) * 1e-3d, BaseUnit); - case RotationalSpeedUnit.NanodegreePerSecond: - return new RotationalSpeed(((Math.PI/180)*_value) * 1e-9d, BaseUnit); - case RotationalSpeedUnit.NanoradianPerSecond: - return new RotationalSpeed((_value) * 1e-9d, BaseUnit); - case RotationalSpeedUnit.RadianPerSecond: - return new RotationalSpeed(_value, BaseUnit); - case RotationalSpeedUnit.RevolutionPerMinute: - return new RotationalSpeed((_value*6.2831853072)/60, BaseUnit); - case RotationalSpeedUnit.RevolutionPerSecond: - return new RotationalSpeed(_value*6.2831853072, BaseUnit); + case RotationalSpeedUnit.CentiradianPerSecond: return (_value) * 1e-2d; + case RotationalSpeedUnit.DeciradianPerSecond: return (_value) * 1e-1d; + case RotationalSpeedUnit.DegreePerMinute: return (Math.PI/(180*60))*_value; + case RotationalSpeedUnit.DegreePerSecond: return (Math.PI/180)*_value; + case RotationalSpeedUnit.MicrodegreePerSecond: return ((Math.PI/180)*_value) * 1e-6d; + case RotationalSpeedUnit.MicroradianPerSecond: return (_value) * 1e-6d; + case RotationalSpeedUnit.MillidegreePerSecond: return ((Math.PI/180)*_value) * 1e-3d; + case RotationalSpeedUnit.MilliradianPerSecond: return (_value) * 1e-3d; + case RotationalSpeedUnit.NanodegreePerSecond: return ((Math.PI/180)*_value) * 1e-9d; + case RotationalSpeedUnit.NanoradianPerSecond: return (_value) * 1e-9d; + case RotationalSpeedUnit.RadianPerSecond: return _value; + case RotationalSpeedUnit.RevolutionPerMinute: return (_value*6.2831853072)/60; + case RotationalSpeedUnit.RevolutionPerSecond: return _value*6.2831853072; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(RotationalSpeedUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal RotationalSpeed ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new RotationalSpeed(baseUnitValue, BaseUnit); + } + + private double GetValueAs(RotationalSpeedUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffness.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffness.WindowsRuntimeComponent.g.cs index fba6778aa5..bfe07a39ba 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffness.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffness.WindowsRuntimeComponent.g.cs @@ -412,7 +412,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(RotationalStiffness other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -426,7 +426,7 @@ public override bool Equals(object obj) public bool Equals(RotationalStiffness other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -502,7 +502,7 @@ public double As(RotationalStiffnessUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -512,7 +512,7 @@ public double As(RotationalStiffnessUnit unit) /// A RotationalStiffness with the specified unit. public RotationalStiffness ToUnit(RotationalStiffnessUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new RotationalStiffness(convertedValue, unit); } @@ -521,28 +521,35 @@ public RotationalStiffness ToUnit(RotationalStiffnessUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal RotationalStiffness AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case RotationalStiffnessUnit.KilonewtonMeterPerRadian: - return new RotationalStiffness((_value) * 1e3d, BaseUnit); - case RotationalStiffnessUnit.MeganewtonMeterPerRadian: - return new RotationalStiffness((_value) * 1e6d, BaseUnit); - case RotationalStiffnessUnit.NewtonMeterPerRadian: - return new RotationalStiffness(_value, BaseUnit); + case RotationalStiffnessUnit.KilonewtonMeterPerRadian: return (_value) * 1e3d; + case RotationalStiffnessUnit.MeganewtonMeterPerRadian: return (_value) * 1e6d; + case RotationalStiffnessUnit.NewtonMeterPerRadian: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(RotationalStiffnessUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal RotationalStiffness ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new RotationalStiffness(baseUnitValue, BaseUnit); + } + + private double GetValueAs(RotationalStiffnessUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffnessPerLength.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffnessPerLength.WindowsRuntimeComponent.g.cs index b286c55335..0714d17892 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffnessPerLength.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffnessPerLength.WindowsRuntimeComponent.g.cs @@ -412,7 +412,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(RotationalStiffnessPerLength other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -426,7 +426,7 @@ public override bool Equals(object obj) public bool Equals(RotationalStiffnessPerLength other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -502,7 +502,7 @@ public double As(RotationalStiffnessPerLengthUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -512,7 +512,7 @@ public double As(RotationalStiffnessPerLengthUnit unit) /// A RotationalStiffnessPerLength with the specified unit. public RotationalStiffnessPerLength ToUnit(RotationalStiffnessPerLengthUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new RotationalStiffnessPerLength(convertedValue, unit); } @@ -521,28 +521,35 @@ public RotationalStiffnessPerLength ToUnit(RotationalStiffnessPerLengthUnit unit /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal RotationalStiffnessPerLength AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter: - return new RotationalStiffnessPerLength((_value) * 1e3d, BaseUnit); - case RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter: - return new RotationalStiffnessPerLength((_value) * 1e6d, BaseUnit); - case RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter: - return new RotationalStiffnessPerLength(_value, BaseUnit); + case RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter: return (_value) * 1e3d; + case RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter: return (_value) * 1e6d; + case RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(RotationalStiffnessPerLengthUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal RotationalStiffnessPerLength ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new RotationalStiffnessPerLength(baseUnitValue, BaseUnit); + } + + private double GetValueAs(RotationalStiffnessPerLengthUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SolidAngle.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SolidAngle.WindowsRuntimeComponent.g.cs index a80553c73a..6e752b0ba5 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SolidAngle.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SolidAngle.WindowsRuntimeComponent.g.cs @@ -385,7 +385,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(SolidAngle other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -399,7 +399,7 @@ public override bool Equals(object obj) public bool Equals(SolidAngle other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -475,7 +475,7 @@ public double As(SolidAngleUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -485,7 +485,7 @@ public double As(SolidAngleUnit unit) /// A SolidAngle with the specified unit. public SolidAngle ToUnit(SolidAngleUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new SolidAngle(convertedValue, unit); } @@ -494,24 +494,33 @@ public SolidAngle ToUnit(SolidAngleUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal SolidAngle AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case SolidAngleUnit.Steradian: - return new SolidAngle(_value, BaseUnit); + case SolidAngleUnit.Steradian: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(SolidAngleUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal SolidAngle ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new SolidAngle(baseUnitValue, BaseUnit); + } + + private double GetValueAs(SolidAngleUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEnergy.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEnergy.WindowsRuntimeComponent.g.cs index 81cddac4a5..a5b06b2a63 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEnergy.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEnergy.WindowsRuntimeComponent.g.cs @@ -505,7 +505,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(SpecificEnergy other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -519,7 +519,7 @@ public override bool Equals(object obj) public bool Equals(SpecificEnergy other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -595,7 +595,7 @@ public double As(SpecificEnergyUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -605,7 +605,7 @@ public double As(SpecificEnergyUnit unit) /// A SpecificEnergy with the specified unit. public SpecificEnergy ToUnit(SpecificEnergyUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new SpecificEnergy(convertedValue, unit); } @@ -614,40 +614,41 @@ public SpecificEnergy ToUnit(SpecificEnergyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal SpecificEnergy AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case SpecificEnergyUnit.BtuPerPound: - return new SpecificEnergy(_value*2326.000075362, BaseUnit); - case SpecificEnergyUnit.CaloriePerGram: - return new SpecificEnergy(_value*4.184e3, BaseUnit); - case SpecificEnergyUnit.JoulePerKilogram: - return new SpecificEnergy(_value, BaseUnit); - case SpecificEnergyUnit.KilocaloriePerGram: - return new SpecificEnergy((_value*4.184e3) * 1e3d, BaseUnit); - case SpecificEnergyUnit.KilojoulePerKilogram: - return new SpecificEnergy((_value) * 1e3d, BaseUnit); - case SpecificEnergyUnit.KilowattHourPerKilogram: - return new SpecificEnergy((_value*3.6e3) * 1e3d, BaseUnit); - case SpecificEnergyUnit.MegajoulePerKilogram: - return new SpecificEnergy((_value) * 1e6d, BaseUnit); - case SpecificEnergyUnit.MegawattHourPerKilogram: - return new SpecificEnergy((_value*3.6e3) * 1e6d, BaseUnit); - case SpecificEnergyUnit.WattHourPerKilogram: - return new SpecificEnergy(_value*3.6e3, BaseUnit); + case SpecificEnergyUnit.BtuPerPound: return _value*2326.000075362; + case SpecificEnergyUnit.CaloriePerGram: return _value*4.184e3; + case SpecificEnergyUnit.JoulePerKilogram: return _value; + case SpecificEnergyUnit.KilocaloriePerGram: return (_value*4.184e3) * 1e3d; + case SpecificEnergyUnit.KilojoulePerKilogram: return (_value) * 1e3d; + case SpecificEnergyUnit.KilowattHourPerKilogram: return (_value*3.6e3) * 1e3d; + case SpecificEnergyUnit.MegajoulePerKilogram: return (_value) * 1e6d; + case SpecificEnergyUnit.MegawattHourPerKilogram: return (_value*3.6e3) * 1e6d; + case SpecificEnergyUnit.WattHourPerKilogram: return _value*3.6e3; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(SpecificEnergyUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal SpecificEnergy ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new SpecificEnergy(baseUnitValue, BaseUnit); + } + + private double GetValueAs(SpecificEnergyUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEntropy.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEntropy.WindowsRuntimeComponent.g.cs index f6a75b786a..810e6cd252 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEntropy.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEntropy.WindowsRuntimeComponent.g.cs @@ -487,7 +487,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(SpecificEntropy other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -501,7 +501,7 @@ public override bool Equals(object obj) public bool Equals(SpecificEntropy other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -577,7 +577,7 @@ public double As(SpecificEntropyUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -587,7 +587,7 @@ public double As(SpecificEntropyUnit unit) /// A SpecificEntropy with the specified unit. public SpecificEntropy ToUnit(SpecificEntropyUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new SpecificEntropy(convertedValue, unit); } @@ -596,38 +596,40 @@ public SpecificEntropy ToUnit(SpecificEntropyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal SpecificEntropy AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case SpecificEntropyUnit.CaloriePerGramKelvin: - return new SpecificEntropy(_value*4.184e3, BaseUnit); - case SpecificEntropyUnit.JoulePerKilogramDegreeCelsius: - return new SpecificEntropy(_value, BaseUnit); - case SpecificEntropyUnit.JoulePerKilogramKelvin: - return new SpecificEntropy(_value, BaseUnit); - case SpecificEntropyUnit.KilocaloriePerGramKelvin: - return new SpecificEntropy((_value*4.184e3) * 1e3d, BaseUnit); - case SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius: - return new SpecificEntropy((_value) * 1e3d, BaseUnit); - case SpecificEntropyUnit.KilojoulePerKilogramKelvin: - return new SpecificEntropy((_value) * 1e3d, BaseUnit); - case SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius: - return new SpecificEntropy((_value) * 1e6d, BaseUnit); - case SpecificEntropyUnit.MegajoulePerKilogramKelvin: - return new SpecificEntropy((_value) * 1e6d, BaseUnit); + case SpecificEntropyUnit.CaloriePerGramKelvin: return _value*4.184e3; + case SpecificEntropyUnit.JoulePerKilogramDegreeCelsius: return _value; + case SpecificEntropyUnit.JoulePerKilogramKelvin: return _value; + case SpecificEntropyUnit.KilocaloriePerGramKelvin: return (_value*4.184e3) * 1e3d; + case SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius: return (_value) * 1e3d; + case SpecificEntropyUnit.KilojoulePerKilogramKelvin: return (_value) * 1e3d; + case SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius: return (_value) * 1e6d; + case SpecificEntropyUnit.MegajoulePerKilogramKelvin: return (_value) * 1e6d; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(SpecificEntropyUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal SpecificEntropy ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new SpecificEntropy(baseUnitValue, BaseUnit); + } + + private double GetValueAs(SpecificEntropyUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificVolume.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificVolume.WindowsRuntimeComponent.g.cs index 993682e9bc..361b8fa1c1 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificVolume.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificVolume.WindowsRuntimeComponent.g.cs @@ -412,7 +412,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(SpecificVolume other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -426,7 +426,7 @@ public override bool Equals(object obj) public bool Equals(SpecificVolume other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -502,7 +502,7 @@ public double As(SpecificVolumeUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -512,7 +512,7 @@ public double As(SpecificVolumeUnit unit) /// A SpecificVolume with the specified unit. public SpecificVolume ToUnit(SpecificVolumeUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new SpecificVolume(convertedValue, unit); } @@ -521,28 +521,35 @@ public SpecificVolume ToUnit(SpecificVolumeUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal SpecificVolume AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case SpecificVolumeUnit.CubicFootPerPound: - return new SpecificVolume(_value/16.01846353, BaseUnit); - case SpecificVolumeUnit.CubicMeterPerKilogram: - return new SpecificVolume(_value, BaseUnit); - case SpecificVolumeUnit.MillicubicMeterPerKilogram: - return new SpecificVolume((_value) * 1e-3d, BaseUnit); + case SpecificVolumeUnit.CubicFootPerPound: return _value/16.01846353; + case SpecificVolumeUnit.CubicMeterPerKilogram: return _value; + case SpecificVolumeUnit.MillicubicMeterPerKilogram: return (_value) * 1e-3d; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(SpecificVolumeUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal SpecificVolume ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new SpecificVolume(baseUnitValue, BaseUnit); + } + + private double GetValueAs(SpecificVolumeUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificWeight.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificWeight.WindowsRuntimeComponent.g.cs index 30c51b3c39..80495bbc4e 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificWeight.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificWeight.WindowsRuntimeComponent.g.cs @@ -625,7 +625,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(SpecificWeight other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -639,7 +639,7 @@ public override bool Equals(object obj) public bool Equals(SpecificWeight other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -715,7 +715,7 @@ public double As(SpecificWeightUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -725,7 +725,7 @@ public double As(SpecificWeightUnit unit) /// A SpecificWeight with the specified unit. public SpecificWeight ToUnit(SpecificWeightUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new SpecificWeight(convertedValue, unit); } @@ -734,56 +734,49 @@ public SpecificWeight ToUnit(SpecificWeightUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal SpecificWeight AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case SpecificWeightUnit.KilogramForcePerCubicCentimeter: - return new SpecificWeight(_value*9.80665e6, BaseUnit); - case SpecificWeightUnit.KilogramForcePerCubicMeter: - return new SpecificWeight(_value*9.80665, BaseUnit); - case SpecificWeightUnit.KilogramForcePerCubicMillimeter: - return new SpecificWeight(_value*9.80665e9, BaseUnit); - case SpecificWeightUnit.KilonewtonPerCubicCentimeter: - return new SpecificWeight((_value*1000000) * 1e3d, BaseUnit); - case SpecificWeightUnit.KilonewtonPerCubicMeter: - return new SpecificWeight((_value) * 1e3d, BaseUnit); - case SpecificWeightUnit.KilonewtonPerCubicMillimeter: - return new SpecificWeight((_value*1000000000) * 1e3d, BaseUnit); - case SpecificWeightUnit.KilopoundForcePerCubicFoot: - return new SpecificWeight((_value*1.570874638462462e2) * 1e3d, BaseUnit); - case SpecificWeightUnit.KilopoundForcePerCubicInch: - return new SpecificWeight((_value*2.714471375263134e5) * 1e3d, BaseUnit); - case SpecificWeightUnit.MeganewtonPerCubicMeter: - return new SpecificWeight((_value) * 1e6d, BaseUnit); - case SpecificWeightUnit.NewtonPerCubicCentimeter: - return new SpecificWeight(_value*1000000, BaseUnit); - case SpecificWeightUnit.NewtonPerCubicMeter: - return new SpecificWeight(_value, BaseUnit); - case SpecificWeightUnit.NewtonPerCubicMillimeter: - return new SpecificWeight(_value*1000000000, BaseUnit); - case SpecificWeightUnit.PoundForcePerCubicFoot: - return new SpecificWeight(_value*1.570874638462462e2, BaseUnit); - case SpecificWeightUnit.PoundForcePerCubicInch: - return new SpecificWeight(_value*2.714471375263134e5, BaseUnit); - case SpecificWeightUnit.TonneForcePerCubicCentimeter: - return new SpecificWeight(_value*9.80665e9, BaseUnit); - case SpecificWeightUnit.TonneForcePerCubicMeter: - return new SpecificWeight(_value*9.80665e3, BaseUnit); - case SpecificWeightUnit.TonneForcePerCubicMillimeter: - return new SpecificWeight(_value*9.80665e12, BaseUnit); + case SpecificWeightUnit.KilogramForcePerCubicCentimeter: return _value*9.80665e6; + case SpecificWeightUnit.KilogramForcePerCubicMeter: return _value*9.80665; + case SpecificWeightUnit.KilogramForcePerCubicMillimeter: return _value*9.80665e9; + case SpecificWeightUnit.KilonewtonPerCubicCentimeter: return (_value*1000000) * 1e3d; + case SpecificWeightUnit.KilonewtonPerCubicMeter: return (_value) * 1e3d; + case SpecificWeightUnit.KilonewtonPerCubicMillimeter: return (_value*1000000000) * 1e3d; + case SpecificWeightUnit.KilopoundForcePerCubicFoot: return (_value*1.570874638462462e2) * 1e3d; + case SpecificWeightUnit.KilopoundForcePerCubicInch: return (_value*2.714471375263134e5) * 1e3d; + case SpecificWeightUnit.MeganewtonPerCubicMeter: return (_value) * 1e6d; + case SpecificWeightUnit.NewtonPerCubicCentimeter: return _value*1000000; + case SpecificWeightUnit.NewtonPerCubicMeter: return _value; + case SpecificWeightUnit.NewtonPerCubicMillimeter: return _value*1000000000; + case SpecificWeightUnit.PoundForcePerCubicFoot: return _value*1.570874638462462e2; + case SpecificWeightUnit.PoundForcePerCubicInch: return _value*2.714471375263134e5; + case SpecificWeightUnit.TonneForcePerCubicCentimeter: return _value*9.80665e9; + case SpecificWeightUnit.TonneForcePerCubicMeter: return _value*9.80665e3; + case SpecificWeightUnit.TonneForcePerCubicMillimeter: return _value*9.80665e12; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(SpecificWeightUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal SpecificWeight ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new SpecificWeight(baseUnitValue, BaseUnit); + } + + private double GetValueAs(SpecificWeightUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Speed.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Speed.WindowsRuntimeComponent.g.cs index 136612d29b..6afd6d5d7a 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Speed.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Speed.WindowsRuntimeComponent.g.cs @@ -847,7 +847,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Speed other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -861,7 +861,7 @@ public override bool Equals(object obj) public bool Equals(Speed other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -937,7 +937,7 @@ public double As(SpeedUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -947,7 +947,7 @@ public double As(SpeedUnit unit) /// A Speed with the specified unit. public Speed ToUnit(SpeedUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Speed(convertedValue, unit); } @@ -956,86 +956,64 @@ public Speed ToUnit(SpeedUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Speed AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case SpeedUnit.CentimeterPerHour: - return new Speed((_value/3600) * 1e-2d, BaseUnit); - case SpeedUnit.CentimeterPerMinute: - return new Speed((_value/60) * 1e-2d, BaseUnit); - case SpeedUnit.CentimeterPerSecond: - return new Speed((_value) * 1e-2d, BaseUnit); - case SpeedUnit.DecimeterPerMinute: - return new Speed((_value/60) * 1e-1d, BaseUnit); - case SpeedUnit.DecimeterPerSecond: - return new Speed((_value) * 1e-1d, BaseUnit); - case SpeedUnit.FootPerHour: - return new Speed(_value*0.3048/3600, BaseUnit); - case SpeedUnit.FootPerMinute: - return new Speed(_value*0.3048/60, BaseUnit); - case SpeedUnit.FootPerSecond: - return new Speed(_value*0.3048, BaseUnit); - case SpeedUnit.InchPerHour: - return new Speed((_value/3600)*2.54e-2, BaseUnit); - case SpeedUnit.InchPerMinute: - return new Speed((_value/60)*2.54e-2, BaseUnit); - case SpeedUnit.InchPerSecond: - return new Speed(_value*2.54e-2, BaseUnit); - case SpeedUnit.KilometerPerHour: - return new Speed((_value/3600) * 1e3d, BaseUnit); - case SpeedUnit.KilometerPerMinute: - return new Speed((_value/60) * 1e3d, BaseUnit); - case SpeedUnit.KilometerPerSecond: - return new Speed((_value) * 1e3d, BaseUnit); - case SpeedUnit.Knot: - return new Speed(_value*0.514444, BaseUnit); - case SpeedUnit.MeterPerHour: - return new Speed(_value/3600, BaseUnit); - case SpeedUnit.MeterPerMinute: - return new Speed(_value/60, BaseUnit); - case SpeedUnit.MeterPerSecond: - return new Speed(_value, BaseUnit); - case SpeedUnit.MicrometerPerMinute: - return new Speed((_value/60) * 1e-6d, BaseUnit); - case SpeedUnit.MicrometerPerSecond: - return new Speed((_value) * 1e-6d, BaseUnit); - case SpeedUnit.MilePerHour: - return new Speed(_value*0.44704, BaseUnit); - case SpeedUnit.MillimeterPerHour: - return new Speed((_value/3600) * 1e-3d, BaseUnit); - case SpeedUnit.MillimeterPerMinute: - return new Speed((_value/60) * 1e-3d, BaseUnit); - case SpeedUnit.MillimeterPerSecond: - return new Speed((_value) * 1e-3d, BaseUnit); - case SpeedUnit.NanometerPerMinute: - return new Speed((_value/60) * 1e-9d, BaseUnit); - case SpeedUnit.NanometerPerSecond: - return new Speed((_value) * 1e-9d, BaseUnit); - case SpeedUnit.UsSurveyFootPerHour: - return new Speed((_value*1200/3937)/3600, BaseUnit); - case SpeedUnit.UsSurveyFootPerMinute: - return new Speed((_value*1200/3937)/60, BaseUnit); - case SpeedUnit.UsSurveyFootPerSecond: - return new Speed(_value*1200/3937, BaseUnit); - case SpeedUnit.YardPerHour: - return new Speed(_value*0.9144/3600, BaseUnit); - case SpeedUnit.YardPerMinute: - return new Speed(_value*0.9144/60, BaseUnit); - case SpeedUnit.YardPerSecond: - return new Speed(_value*0.9144, BaseUnit); + case SpeedUnit.CentimeterPerHour: return (_value/3600) * 1e-2d; + case SpeedUnit.CentimeterPerMinute: return (_value/60) * 1e-2d; + case SpeedUnit.CentimeterPerSecond: return (_value) * 1e-2d; + case SpeedUnit.DecimeterPerMinute: return (_value/60) * 1e-1d; + case SpeedUnit.DecimeterPerSecond: return (_value) * 1e-1d; + case SpeedUnit.FootPerHour: return _value*0.3048/3600; + case SpeedUnit.FootPerMinute: return _value*0.3048/60; + case SpeedUnit.FootPerSecond: return _value*0.3048; + case SpeedUnit.InchPerHour: return (_value/3600)*2.54e-2; + case SpeedUnit.InchPerMinute: return (_value/60)*2.54e-2; + case SpeedUnit.InchPerSecond: return _value*2.54e-2; + case SpeedUnit.KilometerPerHour: return (_value/3600) * 1e3d; + case SpeedUnit.KilometerPerMinute: return (_value/60) * 1e3d; + case SpeedUnit.KilometerPerSecond: return (_value) * 1e3d; + case SpeedUnit.Knot: return _value*0.514444; + case SpeedUnit.MeterPerHour: return _value/3600; + case SpeedUnit.MeterPerMinute: return _value/60; + case SpeedUnit.MeterPerSecond: return _value; + case SpeedUnit.MicrometerPerMinute: return (_value/60) * 1e-6d; + case SpeedUnit.MicrometerPerSecond: return (_value) * 1e-6d; + case SpeedUnit.MilePerHour: return _value*0.44704; + case SpeedUnit.MillimeterPerHour: return (_value/3600) * 1e-3d; + case SpeedUnit.MillimeterPerMinute: return (_value/60) * 1e-3d; + case SpeedUnit.MillimeterPerSecond: return (_value) * 1e-3d; + case SpeedUnit.NanometerPerMinute: return (_value/60) * 1e-9d; + case SpeedUnit.NanometerPerSecond: return (_value) * 1e-9d; + case SpeedUnit.UsSurveyFootPerHour: return (_value*1200/3937)/3600; + case SpeedUnit.UsSurveyFootPerMinute: return (_value*1200/3937)/60; + case SpeedUnit.UsSurveyFootPerSecond: return _value*1200/3937; + case SpeedUnit.YardPerHour: return _value*0.9144/3600; + case SpeedUnit.YardPerMinute: return _value*0.9144/60; + case SpeedUnit.YardPerSecond: return _value*0.9144; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(SpeedUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Speed ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Speed(baseUnitValue, BaseUnit); + } + + private double GetValueAs(SpeedUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Temperature.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Temperature.WindowsRuntimeComponent.g.cs index ab26301ef8..334a218900 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Temperature.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Temperature.WindowsRuntimeComponent.g.cs @@ -487,7 +487,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Temperature other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -501,7 +501,7 @@ public override bool Equals(object obj) public bool Equals(Temperature other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -577,7 +577,7 @@ public double As(TemperatureUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -587,7 +587,7 @@ public double As(TemperatureUnit unit) /// A Temperature with the specified unit. public Temperature ToUnit(TemperatureUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Temperature(convertedValue, unit); } @@ -596,38 +596,40 @@ public Temperature ToUnit(TemperatureUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Temperature AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case TemperatureUnit.DegreeCelsius: - return new Temperature(_value + 273.15, BaseUnit); - case TemperatureUnit.DegreeDelisle: - return new Temperature(_value*-2/3 + 373.15, BaseUnit); - case TemperatureUnit.DegreeFahrenheit: - return new Temperature(_value*5/9 + 459.67*5/9, BaseUnit); - case TemperatureUnit.DegreeNewton: - return new Temperature(_value*100/33 + 273.15, BaseUnit); - case TemperatureUnit.DegreeRankine: - return new Temperature(_value*5/9, BaseUnit); - case TemperatureUnit.DegreeReaumur: - return new Temperature(_value*5/4 + 273.15, BaseUnit); - case TemperatureUnit.DegreeRoemer: - return new Temperature(_value*40/21 + 273.15 - 7.5*40d/21, BaseUnit); - case TemperatureUnit.Kelvin: - return new Temperature(_value, BaseUnit); + case TemperatureUnit.DegreeCelsius: return _value + 273.15; + case TemperatureUnit.DegreeDelisle: return _value*-2/3 + 373.15; + case TemperatureUnit.DegreeFahrenheit: return _value*5/9 + 459.67*5/9; + case TemperatureUnit.DegreeNewton: return _value*100/33 + 273.15; + case TemperatureUnit.DegreeRankine: return _value*5/9; + case TemperatureUnit.DegreeReaumur: return _value*5/4 + 273.15; + case TemperatureUnit.DegreeRoemer: return _value*40/21 + 273.15 - 7.5*40d/21; + case TemperatureUnit.Kelvin: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(TemperatureUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Temperature ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Temperature(baseUnitValue, BaseUnit); + } + + private double GetValueAs(TemperatureUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureChangeRate.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureChangeRate.WindowsRuntimeComponent.g.cs index eaf8d61cad..31cdd20f1a 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureChangeRate.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureChangeRate.WindowsRuntimeComponent.g.cs @@ -517,7 +517,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(TemperatureChangeRate other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -531,7 +531,7 @@ public override bool Equals(object obj) public bool Equals(TemperatureChangeRate other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -607,7 +607,7 @@ public double As(TemperatureChangeRateUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -617,7 +617,7 @@ public double As(TemperatureChangeRateUnit unit) /// A TemperatureChangeRate with the specified unit. public TemperatureChangeRate ToUnit(TemperatureChangeRateUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new TemperatureChangeRate(convertedValue, unit); } @@ -626,42 +626,42 @@ public TemperatureChangeRate ToUnit(TemperatureChangeRateUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal TemperatureChangeRate AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond: - return new TemperatureChangeRate((_value) * 1e-2d, BaseUnit); - case TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond: - return new TemperatureChangeRate((_value) * 1e1d, BaseUnit); - case TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond: - return new TemperatureChangeRate((_value) * 1e-1d, BaseUnit); - case TemperatureChangeRateUnit.DegreeCelsiusPerMinute: - return new TemperatureChangeRate(_value/60, BaseUnit); - case TemperatureChangeRateUnit.DegreeCelsiusPerSecond: - return new TemperatureChangeRate(_value, BaseUnit); - case TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond: - return new TemperatureChangeRate((_value) * 1e2d, BaseUnit); - case TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond: - return new TemperatureChangeRate((_value) * 1e3d, BaseUnit); - case TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond: - return new TemperatureChangeRate((_value) * 1e-6d, BaseUnit); - case TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond: - return new TemperatureChangeRate((_value) * 1e-3d, BaseUnit); - case TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond: - return new TemperatureChangeRate((_value) * 1e-9d, BaseUnit); + case TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond: return (_value) * 1e-2d; + case TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond: return (_value) * 1e1d; + case TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond: return (_value) * 1e-1d; + case TemperatureChangeRateUnit.DegreeCelsiusPerMinute: return _value/60; + case TemperatureChangeRateUnit.DegreeCelsiusPerSecond: return _value; + case TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond: return (_value) * 1e2d; + case TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond: return (_value) * 1e3d; + case TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond: return (_value) * 1e-6d; + case TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond: return (_value) * 1e-3d; + case TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond: return (_value) * 1e-9d; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(TemperatureChangeRateUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal TemperatureChangeRate ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new TemperatureChangeRate(baseUnitValue, BaseUnit); + } + + private double GetValueAs(TemperatureChangeRateUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureDelta.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureDelta.WindowsRuntimeComponent.g.cs index d91904a35d..575aad5ba7 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureDelta.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureDelta.WindowsRuntimeComponent.g.cs @@ -487,7 +487,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(TemperatureDelta other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -501,7 +501,7 @@ public override bool Equals(object obj) public bool Equals(TemperatureDelta other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -577,7 +577,7 @@ public double As(TemperatureDeltaUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -587,7 +587,7 @@ public double As(TemperatureDeltaUnit unit) /// A TemperatureDelta with the specified unit. public TemperatureDelta ToUnit(TemperatureDeltaUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new TemperatureDelta(convertedValue, unit); } @@ -596,38 +596,40 @@ public TemperatureDelta ToUnit(TemperatureDeltaUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal TemperatureDelta AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case TemperatureDeltaUnit.DegreeCelsius: - return new TemperatureDelta(_value, BaseUnit); - case TemperatureDeltaUnit.DegreeDelisle: - return new TemperatureDelta(_value*-2/3, BaseUnit); - case TemperatureDeltaUnit.DegreeFahrenheit: - return new TemperatureDelta(_value*5/9, BaseUnit); - case TemperatureDeltaUnit.DegreeNewton: - return new TemperatureDelta(_value*100/33, BaseUnit); - case TemperatureDeltaUnit.DegreeRankine: - return new TemperatureDelta(_value*5/9, BaseUnit); - case TemperatureDeltaUnit.DegreeReaumur: - return new TemperatureDelta(_value*5/4, BaseUnit); - case TemperatureDeltaUnit.DegreeRoemer: - return new TemperatureDelta(_value*40/21, BaseUnit); - case TemperatureDeltaUnit.Kelvin: - return new TemperatureDelta(_value, BaseUnit); + case TemperatureDeltaUnit.DegreeCelsius: return _value; + case TemperatureDeltaUnit.DegreeDelisle: return _value*-2/3; + case TemperatureDeltaUnit.DegreeFahrenheit: return _value*5/9; + case TemperatureDeltaUnit.DegreeNewton: return _value*100/33; + case TemperatureDeltaUnit.DegreeRankine: return _value*5/9; + case TemperatureDeltaUnit.DegreeReaumur: return _value*5/4; + case TemperatureDeltaUnit.DegreeRoemer: return _value*40/21; + case TemperatureDeltaUnit.Kelvin: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(TemperatureDeltaUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal TemperatureDelta ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new TemperatureDelta(baseUnitValue, BaseUnit); + } + + private double GetValueAs(TemperatureDeltaUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalConductivity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalConductivity.WindowsRuntimeComponent.g.cs index 88e4d76218..ad96399bce 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalConductivity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalConductivity.WindowsRuntimeComponent.g.cs @@ -400,7 +400,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ThermalConductivity other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -414,7 +414,7 @@ public override bool Equals(object obj) public bool Equals(ThermalConductivity other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -490,7 +490,7 @@ public double As(ThermalConductivityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -500,7 +500,7 @@ public double As(ThermalConductivityUnit unit) /// A ThermalConductivity with the specified unit. public ThermalConductivity ToUnit(ThermalConductivityUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ThermalConductivity(convertedValue, unit); } @@ -509,26 +509,34 @@ public ThermalConductivity ToUnit(ThermalConductivityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ThermalConductivity AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ThermalConductivityUnit.BtuPerHourFootFahrenheit: - return new ThermalConductivity(_value*1.73073467, BaseUnit); - case ThermalConductivityUnit.WattPerMeterKelvin: - return new ThermalConductivity(_value, BaseUnit); + case ThermalConductivityUnit.BtuPerHourFootFahrenheit: return _value*1.73073467; + case ThermalConductivityUnit.WattPerMeterKelvin: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ThermalConductivityUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ThermalConductivity ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ThermalConductivity(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ThermalConductivityUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalResistance.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalResistance.WindowsRuntimeComponent.g.cs index f38d1ae1e5..df0b786365 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalResistance.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalResistance.WindowsRuntimeComponent.g.cs @@ -442,7 +442,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ThermalResistance other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -456,7 +456,7 @@ public override bool Equals(object obj) public bool Equals(ThermalResistance other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -532,7 +532,7 @@ public double As(ThermalResistanceUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -542,7 +542,7 @@ public double As(ThermalResistanceUnit unit) /// A ThermalResistance with the specified unit. public ThermalResistance ToUnit(ThermalResistanceUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ThermalResistance(convertedValue, unit); } @@ -551,32 +551,37 @@ public ThermalResistance ToUnit(ThermalResistanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ThermalResistance AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu: - return new ThermalResistance(_value*176.1121482159839, BaseUnit); - case ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie: - return new ThermalResistance(_value*0.0859779507590433, BaseUnit); - case ThermalResistanceUnit.SquareCentimeterKelvinPerWatt: - return new ThermalResistance(_value*0.0999964777570357, BaseUnit); - case ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt: - return new ThermalResistance(_value*1000.088056074108, BaseUnit); - case ThermalResistanceUnit.SquareMeterKelvinPerKilowatt: - return new ThermalResistance(_value, BaseUnit); + case ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu: return _value*176.1121482159839; + case ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie: return _value*0.0859779507590433; + case ThermalResistanceUnit.SquareCentimeterKelvinPerWatt: return _value*0.0999964777570357; + case ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt: return _value*1000.088056074108; + case ThermalResistanceUnit.SquareMeterKelvinPerKilowatt: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ThermalResistanceUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ThermalResistance ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ThermalResistance(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ThermalResistanceUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Torque.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Torque.WindowsRuntimeComponent.g.cs index c3030710ed..01835d3f74 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Torque.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Torque.WindowsRuntimeComponent.g.cs @@ -682,7 +682,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Torque other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -696,7 +696,7 @@ public override bool Equals(object obj) public bool Equals(Torque other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -772,7 +772,7 @@ public double As(TorqueUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -782,7 +782,7 @@ public double As(TorqueUnit unit) /// A Torque with the specified unit. public Torque ToUnit(TorqueUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Torque(convertedValue, unit); } @@ -791,64 +791,53 @@ public Torque ToUnit(TorqueUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Torque AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case TorqueUnit.KilogramForceCentimeter: - return new Torque(_value*0.0980665019960652, BaseUnit); - case TorqueUnit.KilogramForceMeter: - return new Torque(_value*9.80665019960652, BaseUnit); - case TorqueUnit.KilogramForceMillimeter: - return new Torque(_value*0.00980665019960652, BaseUnit); - case TorqueUnit.KilonewtonCentimeter: - return new Torque((_value*0.01) * 1e3d, BaseUnit); - case TorqueUnit.KilonewtonMeter: - return new Torque((_value) * 1e3d, BaseUnit); - case TorqueUnit.KilonewtonMillimeter: - return new Torque((_value*0.001) * 1e3d, BaseUnit); - case TorqueUnit.KilopoundForceFoot: - return new Torque((_value*1.3558179483314) * 1e3d, BaseUnit); - case TorqueUnit.KilopoundForceInch: - return new Torque((_value*1.129848290276167e-1) * 1e3d, BaseUnit); - case TorqueUnit.MeganewtonCentimeter: - return new Torque((_value*0.01) * 1e6d, BaseUnit); - case TorqueUnit.MeganewtonMeter: - return new Torque((_value) * 1e6d, BaseUnit); - case TorqueUnit.MeganewtonMillimeter: - return new Torque((_value*0.001) * 1e6d, BaseUnit); - case TorqueUnit.MegapoundForceFoot: - return new Torque((_value*1.3558179483314) * 1e6d, BaseUnit); - case TorqueUnit.MegapoundForceInch: - return new Torque((_value*1.129848290276167e-1) * 1e6d, BaseUnit); - case TorqueUnit.NewtonCentimeter: - return new Torque(_value*0.01, BaseUnit); - case TorqueUnit.NewtonMeter: - return new Torque(_value, BaseUnit); - case TorqueUnit.NewtonMillimeter: - return new Torque(_value*0.001, BaseUnit); - case TorqueUnit.PoundForceFoot: - return new Torque(_value*1.3558179483314, BaseUnit); - case TorqueUnit.PoundForceInch: - return new Torque(_value*1.129848290276167e-1, BaseUnit); - case TorqueUnit.TonneForceCentimeter: - return new Torque(_value*98.0665019960652, BaseUnit); - case TorqueUnit.TonneForceMeter: - return new Torque(_value*9806.65019960653, BaseUnit); - case TorqueUnit.TonneForceMillimeter: - return new Torque(_value*9.80665019960652, BaseUnit); + case TorqueUnit.KilogramForceCentimeter: return _value*0.0980665019960652; + case TorqueUnit.KilogramForceMeter: return _value*9.80665019960652; + case TorqueUnit.KilogramForceMillimeter: return _value*0.00980665019960652; + case TorqueUnit.KilonewtonCentimeter: return (_value*0.01) * 1e3d; + case TorqueUnit.KilonewtonMeter: return (_value) * 1e3d; + case TorqueUnit.KilonewtonMillimeter: return (_value*0.001) * 1e3d; + case TorqueUnit.KilopoundForceFoot: return (_value*1.3558179483314) * 1e3d; + case TorqueUnit.KilopoundForceInch: return (_value*1.129848290276167e-1) * 1e3d; + case TorqueUnit.MeganewtonCentimeter: return (_value*0.01) * 1e6d; + case TorqueUnit.MeganewtonMeter: return (_value) * 1e6d; + case TorqueUnit.MeganewtonMillimeter: return (_value*0.001) * 1e6d; + case TorqueUnit.MegapoundForceFoot: return (_value*1.3558179483314) * 1e6d; + case TorqueUnit.MegapoundForceInch: return (_value*1.129848290276167e-1) * 1e6d; + case TorqueUnit.NewtonCentimeter: return _value*0.01; + case TorqueUnit.NewtonMeter: return _value; + case TorqueUnit.NewtonMillimeter: return _value*0.001; + case TorqueUnit.PoundForceFoot: return _value*1.3558179483314; + case TorqueUnit.PoundForceInch: return _value*1.129848290276167e-1; + case TorqueUnit.TonneForceCentimeter: return _value*98.0665019960652; + case TorqueUnit.TonneForceMeter: return _value*9806.65019960653; + case TorqueUnit.TonneForceMillimeter: return _value*9.80665019960652; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(TorqueUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Torque ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Torque(baseUnitValue, BaseUnit); + } + + private double GetValueAs(TorqueUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VitaminA.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VitaminA.WindowsRuntimeComponent.g.cs index 0357f107ba..b2905c8a0b 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VitaminA.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VitaminA.WindowsRuntimeComponent.g.cs @@ -382,7 +382,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(VitaminA other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -396,7 +396,7 @@ public override bool Equals(object obj) public bool Equals(VitaminA other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -472,7 +472,7 @@ public double As(VitaminAUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -482,7 +482,7 @@ public double As(VitaminAUnit unit) /// A VitaminA with the specified unit. public VitaminA ToUnit(VitaminAUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new VitaminA(convertedValue, unit); } @@ -491,24 +491,33 @@ public VitaminA ToUnit(VitaminAUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal VitaminA AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case VitaminAUnit.InternationalUnit: - return new VitaminA(_value, BaseUnit); + case VitaminAUnit.InternationalUnit: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(VitaminAUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal VitaminA ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new VitaminA(baseUnitValue, BaseUnit); + } + + private double GetValueAs(VitaminAUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Volume.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Volume.WindowsRuntimeComponent.g.cs index ac1b69a063..5b98c5a089 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Volume.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Volume.WindowsRuntimeComponent.g.cs @@ -1042,7 +1042,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Volume other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -1056,7 +1056,7 @@ public override bool Equals(object obj) public bool Equals(Volume other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -1132,7 +1132,7 @@ public double As(VolumeUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -1142,7 +1142,7 @@ public double As(VolumeUnit unit) /// A Volume with the specified unit. public Volume ToUnit(VolumeUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Volume(convertedValue, unit); } @@ -1151,112 +1151,77 @@ public Volume ToUnit(VolumeUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Volume AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case VolumeUnit.AcreFoot: - return new Volume(_value/0.000810714, BaseUnit); - case VolumeUnit.AuTablespoon: - return new Volume(_value*2e-5, BaseUnit); - case VolumeUnit.Centiliter: - return new Volume((_value/1e3) * 1e-2d, BaseUnit); - case VolumeUnit.CubicCentimeter: - return new Volume(_value/1e6, BaseUnit); - case VolumeUnit.CubicDecimeter: - return new Volume(_value/1e3, BaseUnit); - case VolumeUnit.CubicFoot: - return new Volume(_value*0.0283168, BaseUnit); - case VolumeUnit.CubicInch: - return new Volume(_value*1.6387*1e-5, BaseUnit); - case VolumeUnit.CubicKilometer: - return new Volume(_value*1e9, BaseUnit); - case VolumeUnit.CubicMeter: - return new Volume(_value, BaseUnit); - case VolumeUnit.CubicMicrometer: - return new Volume(_value/1e18, BaseUnit); - case VolumeUnit.CubicMile: - return new Volume(_value*4.16818182544058e9, BaseUnit); - case VolumeUnit.CubicMillimeter: - return new Volume(_value/1e9, BaseUnit); - case VolumeUnit.CubicYard: - return new Volume(_value*0.764554858, BaseUnit); - case VolumeUnit.Deciliter: - return new Volume((_value/1e3) * 1e-1d, BaseUnit); - case VolumeUnit.HectocubicFoot: - return new Volume((_value*0.0283168) * 1e2d, BaseUnit); - case VolumeUnit.HectocubicMeter: - return new Volume((_value) * 1e2d, BaseUnit); - case VolumeUnit.Hectoliter: - return new Volume((_value/1e3) * 1e2d, BaseUnit); - case VolumeUnit.ImperialBeerBarrel: - return new Volume(_value*0.16365924, BaseUnit); - case VolumeUnit.ImperialGallon: - return new Volume(_value*0.00454609000000181429905810072407, BaseUnit); - case VolumeUnit.ImperialOunce: - return new Volume(_value*2.8413062499962901241875439064617e-5, BaseUnit); - case VolumeUnit.KilocubicFoot: - return new Volume((_value*0.0283168) * 1e3d, BaseUnit); - case VolumeUnit.KilocubicMeter: - return new Volume((_value) * 1e3d, BaseUnit); - case VolumeUnit.KiloimperialGallon: - return new Volume((_value*0.00454609000000181429905810072407) * 1e3d, BaseUnit); - case VolumeUnit.Kiloliter: - return new Volume((_value/1e3) * 1e3d, BaseUnit); - case VolumeUnit.KilousGallon: - return new Volume((_value*0.00378541) * 1e3d, BaseUnit); - case VolumeUnit.Liter: - return new Volume(_value/1e3, BaseUnit); - case VolumeUnit.MegacubicFoot: - return new Volume((_value*0.0283168) * 1e6d, BaseUnit); - case VolumeUnit.MegaimperialGallon: - return new Volume((_value*0.00454609000000181429905810072407) * 1e6d, BaseUnit); - case VolumeUnit.Megaliter: - return new Volume((_value/1e3) * 1e6d, BaseUnit); - case VolumeUnit.MegausGallon: - return new Volume((_value*0.00378541) * 1e6d, BaseUnit); - case VolumeUnit.MetricCup: - return new Volume(_value*0.00025, BaseUnit); - case VolumeUnit.MetricTeaspoon: - return new Volume(_value*0.5e-5, BaseUnit); - case VolumeUnit.Microliter: - return new Volume((_value/1e3) * 1e-6d, BaseUnit); - case VolumeUnit.Milliliter: - return new Volume((_value/1e3) * 1e-3d, BaseUnit); - case VolumeUnit.OilBarrel: - return new Volume(_value*0.158987294928, BaseUnit); - case VolumeUnit.UkTablespoon: - return new Volume(_value*1.5e-5, BaseUnit); - case VolumeUnit.UsBeerBarrel: - return new Volume(_value*0.1173477658, BaseUnit); - case VolumeUnit.UsCustomaryCup: - return new Volume(_value*0.0002365882365, BaseUnit); - case VolumeUnit.UsGallon: - return new Volume(_value*0.00378541, BaseUnit); - case VolumeUnit.UsLegalCup: - return new Volume(_value*0.00024, BaseUnit); - case VolumeUnit.UsOunce: - return new Volume(_value*2.957352956253760505068307980135e-5, BaseUnit); - case VolumeUnit.UsPint: - return new Volume(_value*4.73176473e-4, BaseUnit); - case VolumeUnit.UsQuart: - return new Volume(_value*9.46352946e-4, BaseUnit); - case VolumeUnit.UsTablespoon: - return new Volume(_value*1.478676478125e-5, BaseUnit); - case VolumeUnit.UsTeaspoon: - return new Volume(_value*4.92892159375e-6, BaseUnit); + case VolumeUnit.AcreFoot: return _value/0.000810714; + case VolumeUnit.AuTablespoon: return _value*2e-5; + case VolumeUnit.Centiliter: return (_value/1e3) * 1e-2d; + case VolumeUnit.CubicCentimeter: return _value/1e6; + case VolumeUnit.CubicDecimeter: return _value/1e3; + case VolumeUnit.CubicFoot: return _value*0.0283168; + case VolumeUnit.CubicInch: return _value*1.6387*1e-5; + case VolumeUnit.CubicKilometer: return _value*1e9; + case VolumeUnit.CubicMeter: return _value; + case VolumeUnit.CubicMicrometer: return _value/1e18; + case VolumeUnit.CubicMile: return _value*4.16818182544058e9; + case VolumeUnit.CubicMillimeter: return _value/1e9; + case VolumeUnit.CubicYard: return _value*0.764554858; + case VolumeUnit.Deciliter: return (_value/1e3) * 1e-1d; + case VolumeUnit.HectocubicFoot: return (_value*0.0283168) * 1e2d; + case VolumeUnit.HectocubicMeter: return (_value) * 1e2d; + case VolumeUnit.Hectoliter: return (_value/1e3) * 1e2d; + case VolumeUnit.ImperialBeerBarrel: return _value*0.16365924; + case VolumeUnit.ImperialGallon: return _value*0.00454609000000181429905810072407; + case VolumeUnit.ImperialOunce: return _value*2.8413062499962901241875439064617e-5; + case VolumeUnit.KilocubicFoot: return (_value*0.0283168) * 1e3d; + case VolumeUnit.KilocubicMeter: return (_value) * 1e3d; + case VolumeUnit.KiloimperialGallon: return (_value*0.00454609000000181429905810072407) * 1e3d; + case VolumeUnit.Kiloliter: return (_value/1e3) * 1e3d; + case VolumeUnit.KilousGallon: return (_value*0.00378541) * 1e3d; + case VolumeUnit.Liter: return _value/1e3; + case VolumeUnit.MegacubicFoot: return (_value*0.0283168) * 1e6d; + case VolumeUnit.MegaimperialGallon: return (_value*0.00454609000000181429905810072407) * 1e6d; + case VolumeUnit.Megaliter: return (_value/1e3) * 1e6d; + case VolumeUnit.MegausGallon: return (_value*0.00378541) * 1e6d; + case VolumeUnit.MetricCup: return _value*0.00025; + case VolumeUnit.MetricTeaspoon: return _value*0.5e-5; + case VolumeUnit.Microliter: return (_value/1e3) * 1e-6d; + case VolumeUnit.Milliliter: return (_value/1e3) * 1e-3d; + case VolumeUnit.OilBarrel: return _value*0.158987294928; + case VolumeUnit.UkTablespoon: return _value*1.5e-5; + case VolumeUnit.UsBeerBarrel: return _value*0.1173477658; + case VolumeUnit.UsCustomaryCup: return _value*0.0002365882365; + case VolumeUnit.UsGallon: return _value*0.00378541; + case VolumeUnit.UsLegalCup: return _value*0.00024; + case VolumeUnit.UsOunce: return _value*2.957352956253760505068307980135e-5; + case VolumeUnit.UsPint: return _value*4.73176473e-4; + case VolumeUnit.UsQuart: return _value*9.46352946e-4; + case VolumeUnit.UsTablespoon: return _value*1.478676478125e-5; + case VolumeUnit.UsTeaspoon: return _value*4.92892159375e-6; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(VolumeUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Volume ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Volume(baseUnitValue, BaseUnit); + } + + private double GetValueAs(VolumeUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeFlow.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeFlow.WindowsRuntimeComponent.g.cs index 4d9053066e..afa28355e1 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeFlow.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeFlow.WindowsRuntimeComponent.g.cs @@ -1087,7 +1087,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(VolumeFlow other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -1101,7 +1101,7 @@ public override bool Equals(object obj) public bool Equals(VolumeFlow other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -1177,7 +1177,7 @@ public double As(VolumeFlowUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -1187,7 +1187,7 @@ public double As(VolumeFlowUnit unit) /// A VolumeFlow with the specified unit. public VolumeFlow ToUnit(VolumeFlowUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new VolumeFlow(convertedValue, unit); } @@ -1196,118 +1196,80 @@ public VolumeFlow ToUnit(VolumeFlowUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal VolumeFlow AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case VolumeFlowUnit.AcreFootPerDay: - return new VolumeFlow(_value/70.0457, BaseUnit); - case VolumeFlowUnit.AcreFootPerHour: - return new VolumeFlow(_value/2.91857, BaseUnit); - case VolumeFlowUnit.AcreFootPerMinute: - return new VolumeFlow(_value/0.0486427916, BaseUnit); - case VolumeFlowUnit.AcreFootPerSecond: - return new VolumeFlow(_value/0.000810713194, BaseUnit); - case VolumeFlowUnit.CentiliterPerDay: - return new VolumeFlow((_value/86400000) * 1e-2d, BaseUnit); - case VolumeFlowUnit.CentiliterPerMinute: - return new VolumeFlow((_value/60000.00000) * 1e-2d, BaseUnit); - case VolumeFlowUnit.CubicDecimeterPerMinute: - return new VolumeFlow(_value/60000.00000, BaseUnit); - case VolumeFlowUnit.CubicFootPerHour: - return new VolumeFlow(_value*7.8657907199999087346816086183876e-6, BaseUnit); - case VolumeFlowUnit.CubicFootPerMinute: - return new VolumeFlow(_value/2118.88000326, BaseUnit); - case VolumeFlowUnit.CubicFootPerSecond: - return new VolumeFlow(_value/35.314666721, BaseUnit); - case VolumeFlowUnit.CubicMeterPerDay: - return new VolumeFlow(_value/86400, BaseUnit); - case VolumeFlowUnit.CubicMeterPerHour: - return new VolumeFlow(_value/3600, BaseUnit); - case VolumeFlowUnit.CubicMeterPerMinute: - return new VolumeFlow(_value/60, BaseUnit); - case VolumeFlowUnit.CubicMeterPerSecond: - return new VolumeFlow(_value, BaseUnit); - case VolumeFlowUnit.CubicMillimeterPerSecond: - return new VolumeFlow(_value*1e-9, BaseUnit); - case VolumeFlowUnit.CubicYardPerDay: - return new VolumeFlow(_value/113007, BaseUnit); - case VolumeFlowUnit.CubicYardPerHour: - return new VolumeFlow(_value*2.1237634944E-4, BaseUnit); - case VolumeFlowUnit.CubicYardPerMinute: - return new VolumeFlow(_value*0.0127425809664, BaseUnit); - case VolumeFlowUnit.CubicYardPerSecond: - return new VolumeFlow(_value*0.764554857984, BaseUnit); - case VolumeFlowUnit.DeciliterPerDay: - return new VolumeFlow((_value/86400000) * 1e-1d, BaseUnit); - case VolumeFlowUnit.DeciliterPerMinute: - return new VolumeFlow((_value/60000.00000) * 1e-1d, BaseUnit); - case VolumeFlowUnit.KiloliterPerDay: - return new VolumeFlow((_value/86400000) * 1e3d, BaseUnit); - case VolumeFlowUnit.KiloliterPerMinute: - return new VolumeFlow((_value/60000.00000) * 1e3d, BaseUnit); - case VolumeFlowUnit.KilousGallonPerMinute: - return new VolumeFlow(_value/15.850323141489, BaseUnit); - case VolumeFlowUnit.LiterPerDay: - return new VolumeFlow(_value/86400000, BaseUnit); - case VolumeFlowUnit.LiterPerHour: - return new VolumeFlow(_value/3600000.000, BaseUnit); - case VolumeFlowUnit.LiterPerMinute: - return new VolumeFlow(_value/60000.00000, BaseUnit); - case VolumeFlowUnit.LiterPerSecond: - return new VolumeFlow(_value/1000, BaseUnit); - case VolumeFlowUnit.MegaliterPerDay: - return new VolumeFlow((_value/86400000) * 1e6d, BaseUnit); - case VolumeFlowUnit.MegaukGallonPerSecond: - return new VolumeFlow((_value/219.969) * 1e6d, BaseUnit); - case VolumeFlowUnit.MicroliterPerDay: - return new VolumeFlow((_value/86400000) * 1e-6d, BaseUnit); - case VolumeFlowUnit.MicroliterPerMinute: - return new VolumeFlow((_value/60000.00000) * 1e-6d, BaseUnit); - case VolumeFlowUnit.MilliliterPerDay: - return new VolumeFlow((_value/86400000) * 1e-3d, BaseUnit); - case VolumeFlowUnit.MilliliterPerMinute: - return new VolumeFlow((_value/60000.00000) * 1e-3d, BaseUnit); - case VolumeFlowUnit.MillionUsGallonsPerDay: - return new VolumeFlow(_value/22.824465227, BaseUnit); - case VolumeFlowUnit.NanoliterPerDay: - return new VolumeFlow((_value/86400000) * 1e-9d, BaseUnit); - case VolumeFlowUnit.NanoliterPerMinute: - return new VolumeFlow((_value/60000.00000) * 1e-9d, BaseUnit); - case VolumeFlowUnit.OilBarrelPerDay: - return new VolumeFlow(_value*1.8401307283333333333333333333333e-6, BaseUnit); - case VolumeFlowUnit.OilBarrelPerHour: - return new VolumeFlow(_value*4.41631375e-5, BaseUnit); - case VolumeFlowUnit.OilBarrelPerMinute: - return new VolumeFlow(_value*2.64978825e-3, BaseUnit); - case VolumeFlowUnit.OilBarrelPerSecond: - return new VolumeFlow(_value/6.28981, BaseUnit); - case VolumeFlowUnit.UkGallonPerDay: - return new VolumeFlow(_value/19005304, BaseUnit); - case VolumeFlowUnit.UkGallonPerMinute: - return new VolumeFlow(_value/13198.2, BaseUnit); - case VolumeFlowUnit.UkGallonPerSecond: - return new VolumeFlow(_value/219.969, BaseUnit); - case VolumeFlowUnit.UsGallonPerDay: - return new VolumeFlow(_value/22824465.227, BaseUnit); - case VolumeFlowUnit.UsGallonPerHour: - return new VolumeFlow(_value/951019.38848933424, BaseUnit); - case VolumeFlowUnit.UsGallonPerMinute: - return new VolumeFlow(_value/15850.323141489, BaseUnit); - case VolumeFlowUnit.UsGallonPerSecond: - return new VolumeFlow(_value/264.1720523581484, BaseUnit); + case VolumeFlowUnit.AcreFootPerDay: return _value/70.0457; + case VolumeFlowUnit.AcreFootPerHour: return _value/2.91857; + case VolumeFlowUnit.AcreFootPerMinute: return _value/0.0486427916; + case VolumeFlowUnit.AcreFootPerSecond: return _value/0.000810713194; + case VolumeFlowUnit.CentiliterPerDay: return (_value/86400000) * 1e-2d; + case VolumeFlowUnit.CentiliterPerMinute: return (_value/60000.00000) * 1e-2d; + case VolumeFlowUnit.CubicDecimeterPerMinute: return _value/60000.00000; + case VolumeFlowUnit.CubicFootPerHour: return _value*7.8657907199999087346816086183876e-6; + case VolumeFlowUnit.CubicFootPerMinute: return _value/2118.88000326; + case VolumeFlowUnit.CubicFootPerSecond: return _value/35.314666721; + case VolumeFlowUnit.CubicMeterPerDay: return _value/86400; + case VolumeFlowUnit.CubicMeterPerHour: return _value/3600; + case VolumeFlowUnit.CubicMeterPerMinute: return _value/60; + case VolumeFlowUnit.CubicMeterPerSecond: return _value; + case VolumeFlowUnit.CubicMillimeterPerSecond: return _value*1e-9; + case VolumeFlowUnit.CubicYardPerDay: return _value/113007; + case VolumeFlowUnit.CubicYardPerHour: return _value*2.1237634944E-4; + case VolumeFlowUnit.CubicYardPerMinute: return _value*0.0127425809664; + case VolumeFlowUnit.CubicYardPerSecond: return _value*0.764554857984; + case VolumeFlowUnit.DeciliterPerDay: return (_value/86400000) * 1e-1d; + case VolumeFlowUnit.DeciliterPerMinute: return (_value/60000.00000) * 1e-1d; + case VolumeFlowUnit.KiloliterPerDay: return (_value/86400000) * 1e3d; + case VolumeFlowUnit.KiloliterPerMinute: return (_value/60000.00000) * 1e3d; + case VolumeFlowUnit.KilousGallonPerMinute: return _value/15.850323141489; + case VolumeFlowUnit.LiterPerDay: return _value/86400000; + case VolumeFlowUnit.LiterPerHour: return _value/3600000.000; + case VolumeFlowUnit.LiterPerMinute: return _value/60000.00000; + case VolumeFlowUnit.LiterPerSecond: return _value/1000; + case VolumeFlowUnit.MegaliterPerDay: return (_value/86400000) * 1e6d; + case VolumeFlowUnit.MegaukGallonPerSecond: return (_value/219.969) * 1e6d; + case VolumeFlowUnit.MicroliterPerDay: return (_value/86400000) * 1e-6d; + case VolumeFlowUnit.MicroliterPerMinute: return (_value/60000.00000) * 1e-6d; + case VolumeFlowUnit.MilliliterPerDay: return (_value/86400000) * 1e-3d; + case VolumeFlowUnit.MilliliterPerMinute: return (_value/60000.00000) * 1e-3d; + case VolumeFlowUnit.MillionUsGallonsPerDay: return _value/22.824465227; + case VolumeFlowUnit.NanoliterPerDay: return (_value/86400000) * 1e-9d; + case VolumeFlowUnit.NanoliterPerMinute: return (_value/60000.00000) * 1e-9d; + case VolumeFlowUnit.OilBarrelPerDay: return _value*1.8401307283333333333333333333333e-6; + case VolumeFlowUnit.OilBarrelPerHour: return _value*4.41631375e-5; + case VolumeFlowUnit.OilBarrelPerMinute: return _value*2.64978825e-3; + case VolumeFlowUnit.OilBarrelPerSecond: return _value/6.28981; + case VolumeFlowUnit.UkGallonPerDay: return _value/19005304; + case VolumeFlowUnit.UkGallonPerMinute: return _value/13198.2; + case VolumeFlowUnit.UkGallonPerSecond: return _value/219.969; + case VolumeFlowUnit.UsGallonPerDay: return _value/22824465.227; + case VolumeFlowUnit.UsGallonPerHour: return _value/951019.38848933424; + case VolumeFlowUnit.UsGallonPerMinute: return _value/15850.323141489; + case VolumeFlowUnit.UsGallonPerSecond: return _value/264.1720523581484; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(VolumeFlowUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal VolumeFlow ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new VolumeFlow(baseUnitValue, BaseUnit); + } + + private double GetValueAs(VolumeFlowUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Acceleration.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Acceleration.NetFramework.g.cs index ff40fbc367..1feb3c8392 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 new Acceleration(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static Acceleration operator -(Acceleration left, Acceleration right) { - return new Acceleration(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new Acceleration(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static Acceleration operator *(double left, Acceleration right) @@ -558,22 +558,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Accele public static bool operator <=(Acceleration left, Acceleration right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(Acceleration left, Acceleration right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(Acceleration left, Acceleration right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(Acceleration left, Acceleration right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(Acceleration left, Acceleration right) @@ -597,7 +597,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(Acceleration other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -610,7 +610,7 @@ public override bool Equals(object obj) public bool Equals(Acceleration other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -686,7 +686,7 @@ public double As(AccelerationUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -696,7 +696,7 @@ public double As(AccelerationUnit unit) /// A Acceleration with the specified unit. public Acceleration ToUnit(AccelerationUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Acceleration(convertedValue, unit); } @@ -705,48 +705,45 @@ public Acceleration ToUnit(AccelerationUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Acceleration AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case AccelerationUnit.CentimeterPerSecondSquared: - return new Acceleration((_value) * 1e-2d, BaseUnit); - case AccelerationUnit.DecimeterPerSecondSquared: - return new Acceleration((_value) * 1e-1d, BaseUnit); - case AccelerationUnit.FootPerSecondSquared: - return new Acceleration(_value*0.304800, BaseUnit); - case AccelerationUnit.InchPerSecondSquared: - return new Acceleration(_value*0.0254, BaseUnit); - case AccelerationUnit.KilometerPerSecondSquared: - return new Acceleration((_value) * 1e3d, BaseUnit); - case AccelerationUnit.KnotPerHour: - return new Acceleration(_value*0.5144444444444/3600, BaseUnit); - case AccelerationUnit.KnotPerMinute: - return new Acceleration(_value*0.5144444444444/60, BaseUnit); - case AccelerationUnit.KnotPerSecond: - return new Acceleration(_value*0.5144444444444, BaseUnit); - case AccelerationUnit.MeterPerSecondSquared: - return new Acceleration(_value, BaseUnit); - case AccelerationUnit.MicrometerPerSecondSquared: - return new Acceleration((_value) * 1e-6d, BaseUnit); - case AccelerationUnit.MillimeterPerSecondSquared: - return new Acceleration((_value) * 1e-3d, BaseUnit); - case AccelerationUnit.NanometerPerSecondSquared: - return new Acceleration((_value) * 1e-9d, BaseUnit); - case AccelerationUnit.StandardGravity: - return new Acceleration(_value*9.80665, BaseUnit); + case AccelerationUnit.CentimeterPerSecondSquared: return (_value) * 1e-2d; + case AccelerationUnit.DecimeterPerSecondSquared: return (_value) * 1e-1d; + case AccelerationUnit.FootPerSecondSquared: return _value*0.304800; + case AccelerationUnit.InchPerSecondSquared: return _value*0.0254; + case AccelerationUnit.KilometerPerSecondSquared: return (_value) * 1e3d; + case AccelerationUnit.KnotPerHour: return _value*0.5144444444444/3600; + case AccelerationUnit.KnotPerMinute: return _value*0.5144444444444/60; + case AccelerationUnit.KnotPerSecond: return _value*0.5144444444444; + case AccelerationUnit.MeterPerSecondSquared: return _value; + case AccelerationUnit.MicrometerPerSecondSquared: return (_value) * 1e-6d; + case AccelerationUnit.MillimeterPerSecondSquared: return (_value) * 1e-3d; + case AccelerationUnit.NanometerPerSecondSquared: return (_value) * 1e-9d; + case AccelerationUnit.StandardGravity: return _value*9.80665; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(AccelerationUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Acceleration ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Acceleration(baseUnitValue, BaseUnit); + } + + private double GetValueAs(AccelerationUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.NetFramework.g.cs index a50e23a711..88f037d118 100644 --- a/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.NetFramework.g.cs @@ -552,12 +552,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 new AmountOfSubstance(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static AmountOfSubstance operator -(AmountOfSubstance left, AmountOfSubstance right) { - return new AmountOfSubstance(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new AmountOfSubstance(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static AmountOfSubstance operator *(double left, AmountOfSubstance right) @@ -586,22 +586,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Amount public static bool operator <=(AmountOfSubstance left, AmountOfSubstance right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(AmountOfSubstance left, AmountOfSubstance right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(AmountOfSubstance left, AmountOfSubstance right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(AmountOfSubstance left, AmountOfSubstance right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(AmountOfSubstance left, AmountOfSubstance right) @@ -625,7 +625,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(AmountOfSubstance other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -638,7 +638,7 @@ public override bool Equals(object obj) public bool Equals(AmountOfSubstance other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -714,7 +714,7 @@ public double As(AmountOfSubstanceUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -724,7 +724,7 @@ public double As(AmountOfSubstanceUnit unit) /// A AmountOfSubstance with the specified unit. public AmountOfSubstance ToUnit(AmountOfSubstanceUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new AmountOfSubstance(convertedValue, unit); } @@ -733,52 +733,47 @@ public AmountOfSubstance ToUnit(AmountOfSubstanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal AmountOfSubstance AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case AmountOfSubstanceUnit.Centimole: - return new AmountOfSubstance((_value) * 1e-2d, BaseUnit); - case AmountOfSubstanceUnit.CentipoundMole: - return new AmountOfSubstance((_value*453.59237) * 1e-2d, BaseUnit); - case AmountOfSubstanceUnit.Decimole: - return new AmountOfSubstance((_value) * 1e-1d, BaseUnit); - case AmountOfSubstanceUnit.DecipoundMole: - return new AmountOfSubstance((_value*453.59237) * 1e-1d, BaseUnit); - case AmountOfSubstanceUnit.Kilomole: - return new AmountOfSubstance((_value) * 1e3d, BaseUnit); - case AmountOfSubstanceUnit.KilopoundMole: - return new AmountOfSubstance((_value*453.59237) * 1e3d, BaseUnit); - case AmountOfSubstanceUnit.Megamole: - return new AmountOfSubstance((_value) * 1e6d, BaseUnit); - case AmountOfSubstanceUnit.Micromole: - return new AmountOfSubstance((_value) * 1e-6d, BaseUnit); - case AmountOfSubstanceUnit.MicropoundMole: - return new AmountOfSubstance((_value*453.59237) * 1e-6d, BaseUnit); - case AmountOfSubstanceUnit.Millimole: - return new AmountOfSubstance((_value) * 1e-3d, BaseUnit); - case AmountOfSubstanceUnit.MillipoundMole: - return new AmountOfSubstance((_value*453.59237) * 1e-3d, BaseUnit); - case AmountOfSubstanceUnit.Mole: - return new AmountOfSubstance(_value, BaseUnit); - case AmountOfSubstanceUnit.Nanomole: - return new AmountOfSubstance((_value) * 1e-9d, BaseUnit); - case AmountOfSubstanceUnit.NanopoundMole: - return new AmountOfSubstance((_value*453.59237) * 1e-9d, BaseUnit); - case AmountOfSubstanceUnit.PoundMole: - return new AmountOfSubstance(_value*453.59237, BaseUnit); + case AmountOfSubstanceUnit.Centimole: return (_value) * 1e-2d; + case AmountOfSubstanceUnit.CentipoundMole: return (_value*453.59237) * 1e-2d; + case AmountOfSubstanceUnit.Decimole: return (_value) * 1e-1d; + case AmountOfSubstanceUnit.DecipoundMole: return (_value*453.59237) * 1e-1d; + case AmountOfSubstanceUnit.Kilomole: return (_value) * 1e3d; + case AmountOfSubstanceUnit.KilopoundMole: return (_value*453.59237) * 1e3d; + case AmountOfSubstanceUnit.Megamole: return (_value) * 1e6d; + case AmountOfSubstanceUnit.Micromole: return (_value) * 1e-6d; + case AmountOfSubstanceUnit.MicropoundMole: return (_value*453.59237) * 1e-6d; + case AmountOfSubstanceUnit.Millimole: return (_value) * 1e-3d; + case AmountOfSubstanceUnit.MillipoundMole: return (_value*453.59237) * 1e-3d; + case AmountOfSubstanceUnit.Mole: return _value; + case AmountOfSubstanceUnit.Nanomole: return (_value) * 1e-9d; + case AmountOfSubstanceUnit.NanopoundMole: return (_value*453.59237) * 1e-9d; + case AmountOfSubstanceUnit.PoundMole: return _value*453.59237; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(AmountOfSubstanceUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal AmountOfSubstance ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new AmountOfSubstance(baseUnitValue, BaseUnit); + } + + private double GetValueAs(AmountOfSubstanceUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.NetFramework.g.cs index 3575a340af..d557410600 100644 --- a/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.NetFramework.g.cs @@ -400,14 +400,14 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Amplit { // Logarithmic addition // Formula: 20*log10(10^(x/20) + 10^(y/20)) - return new AmplitudeRatio(20*Math.Log10(Math.Pow(10, left.Value/20) + Math.Pow(10, right.AsBaseNumericType(left.Unit)/20)), left.Unit); + return new AmplitudeRatio(20*Math.Log10(Math.Pow(10, left.Value/20) + Math.Pow(10, right.GetValueAs(left.Unit)/20)), left.Unit); } public static AmplitudeRatio operator -(AmplitudeRatio left, AmplitudeRatio right) { // Logarithmic subtraction // Formula: 20*log10(10^(x/20) - 10^(y/20)) - return new AmplitudeRatio(20*Math.Log10(Math.Pow(10, left.Value/20) - Math.Pow(10, right.AsBaseNumericType(left.Unit)/20)), left.Unit); + return new AmplitudeRatio(20*Math.Log10(Math.Pow(10, left.Value/20) - Math.Pow(10, right.GetValueAs(left.Unit)/20)), left.Unit); } public static AmplitudeRatio operator *(double left, AmplitudeRatio right) @@ -431,7 +431,7 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Amplit public static double operator /(AmplitudeRatio left, AmplitudeRatio right) { // Logarithmic division = subtraction - return Convert.ToDouble(left.Value - right.AsBaseNumericType(left.Unit)); + return Convert.ToDouble(left.Value - right.GetValueAs(left.Unit)); } #endregion @@ -440,22 +440,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Amplit public static bool operator <=(AmplitudeRatio left, AmplitudeRatio right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(AmplitudeRatio left, AmplitudeRatio right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(AmplitudeRatio left, AmplitudeRatio right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(AmplitudeRatio left, AmplitudeRatio right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(AmplitudeRatio left, AmplitudeRatio right) @@ -479,7 +479,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(AmplitudeRatio other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -492,7 +492,7 @@ public override bool Equals(object obj) public bool Equals(AmplitudeRatio other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -568,7 +568,7 @@ public double As(AmplitudeRatioUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -578,7 +578,7 @@ public double As(AmplitudeRatioUnit unit) /// A AmplitudeRatio with the specified unit. public AmplitudeRatio ToUnit(AmplitudeRatioUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new AmplitudeRatio(convertedValue, unit); } @@ -587,30 +587,36 @@ public AmplitudeRatio ToUnit(AmplitudeRatioUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal AmplitudeRatio AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case AmplitudeRatioUnit.DecibelMicrovolt: - return new AmplitudeRatio(_value - 120, BaseUnit); - case AmplitudeRatioUnit.DecibelMillivolt: - return new AmplitudeRatio(_value - 60, BaseUnit); - case AmplitudeRatioUnit.DecibelUnloaded: - return new AmplitudeRatio(_value - 2.218487499, BaseUnit); - case AmplitudeRatioUnit.DecibelVolt: - return new AmplitudeRatio(_value, BaseUnit); + case AmplitudeRatioUnit.DecibelMicrovolt: return _value - 120; + case AmplitudeRatioUnit.DecibelMillivolt: return _value - 60; + case AmplitudeRatioUnit.DecibelUnloaded: return _value - 2.218487499; + case AmplitudeRatioUnit.DecibelVolt: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(AmplitudeRatioUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal AmplitudeRatio ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new AmplitudeRatio(baseUnitValue, BaseUnit); + } + + private double GetValueAs(AmplitudeRatioUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Angle.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Angle.NetFramework.g.cs index 97b2e5c248..0284154d05 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 new Angle(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static Angle operator -(Angle left, Angle right) { - return new Angle(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new Angle(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static Angle operator *(double left, Angle right) @@ -572,22 +572,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out AngleU public static bool operator <=(Angle left, Angle right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(Angle left, Angle right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(Angle left, Angle right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(Angle left, Angle right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(Angle left, Angle right) @@ -611,7 +611,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(Angle other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -624,7 +624,7 @@ public override bool Equals(object obj) public bool Equals(Angle other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -700,7 +700,7 @@ public double As(AngleUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -710,7 +710,7 @@ public double As(AngleUnit unit) /// A Angle with the specified unit. public Angle ToUnit(AngleUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Angle(convertedValue, unit); } @@ -719,50 +719,46 @@ public Angle ToUnit(AngleUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Angle AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case AngleUnit.Arcminute: - return new Angle(_value/60, BaseUnit); - case AngleUnit.Arcsecond: - return new Angle(_value/3600, BaseUnit); - case AngleUnit.Centiradian: - return new Angle((_value*180/Math.PI) * 1e-2d, BaseUnit); - case AngleUnit.Deciradian: - return new Angle((_value*180/Math.PI) * 1e-1d, BaseUnit); - case AngleUnit.Degree: - return new Angle(_value, BaseUnit); - case AngleUnit.Gradian: - return new Angle(_value*0.9, BaseUnit); - case AngleUnit.Microdegree: - return new Angle((_value) * 1e-6d, BaseUnit); - case AngleUnit.Microradian: - return new Angle((_value*180/Math.PI) * 1e-6d, BaseUnit); - case AngleUnit.Millidegree: - return new Angle((_value) * 1e-3d, BaseUnit); - case AngleUnit.Milliradian: - return new Angle((_value*180/Math.PI) * 1e-3d, BaseUnit); - case AngleUnit.Nanodegree: - return new Angle((_value) * 1e-9d, BaseUnit); - case AngleUnit.Nanoradian: - return new Angle((_value*180/Math.PI) * 1e-9d, BaseUnit); - case AngleUnit.Radian: - return new Angle(_value*180/Math.PI, BaseUnit); - case AngleUnit.Revolution: - return new Angle(_value*360, BaseUnit); + case AngleUnit.Arcminute: return _value/60; + case AngleUnit.Arcsecond: return _value/3600; + case AngleUnit.Centiradian: return (_value*180/Math.PI) * 1e-2d; + case AngleUnit.Deciradian: return (_value*180/Math.PI) * 1e-1d; + case AngleUnit.Degree: return _value; + case AngleUnit.Gradian: return _value*0.9; + case AngleUnit.Microdegree: return (_value) * 1e-6d; + case AngleUnit.Microradian: return (_value*180/Math.PI) * 1e-6d; + case AngleUnit.Millidegree: return (_value) * 1e-3d; + case AngleUnit.Milliradian: return (_value*180/Math.PI) * 1e-3d; + case AngleUnit.Nanodegree: return (_value) * 1e-9d; + case AngleUnit.Nanoradian: return (_value*180/Math.PI) * 1e-9d; + case AngleUnit.Radian: return _value*180/Math.PI; + case AngleUnit.Revolution: return _value*360; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(AngleUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Angle ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Angle(baseUnitValue, BaseUnit); + } + + private double GetValueAs(AngleUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ApparentEnergy.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ApparentEnergy.NetFramework.g.cs index 9dfdcb3dca..544a8999f9 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 new ApparentEnergy(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static ApparentEnergy operator -(ApparentEnergy left, ApparentEnergy right) { - return new ApparentEnergy(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new ApparentEnergy(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static ApparentEnergy operator *(double left, ApparentEnergy right) @@ -418,22 +418,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Appare public static bool operator <=(ApparentEnergy left, ApparentEnergy right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(ApparentEnergy left, ApparentEnergy right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(ApparentEnergy left, ApparentEnergy right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(ApparentEnergy left, ApparentEnergy right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(ApparentEnergy left, ApparentEnergy right) @@ -457,7 +457,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(ApparentEnergy other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -470,7 +470,7 @@ public override bool Equals(object obj) public bool Equals(ApparentEnergy other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -546,7 +546,7 @@ public double As(ApparentEnergyUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -556,7 +556,7 @@ public double As(ApparentEnergyUnit unit) /// A ApparentEnergy with the specified unit. public ApparentEnergy ToUnit(ApparentEnergyUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ApparentEnergy(convertedValue, unit); } @@ -565,28 +565,35 @@ public ApparentEnergy ToUnit(ApparentEnergyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ApparentEnergy AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ApparentEnergyUnit.KilovoltampereHour: - return new ApparentEnergy((_value) * 1e3d, BaseUnit); - case ApparentEnergyUnit.MegavoltampereHour: - return new ApparentEnergy((_value) * 1e6d, BaseUnit); - case ApparentEnergyUnit.VoltampereHour: - return new ApparentEnergy(_value, BaseUnit); + case ApparentEnergyUnit.KilovoltampereHour: return (_value) * 1e3d; + case ApparentEnergyUnit.MegavoltampereHour: return (_value) * 1e6d; + case ApparentEnergyUnit.VoltampereHour: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ApparentEnergyUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ApparentEnergy ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ApparentEnergy(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ApparentEnergyUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ApparentPower.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ApparentPower.NetFramework.g.cs index 6c98748c0f..e33f01c72f 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 new ApparentPower(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static ApparentPower operator -(ApparentPower left, ApparentPower right) { - return new ApparentPower(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new ApparentPower(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static ApparentPower operator *(double left, ApparentPower right) @@ -432,22 +432,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Appare public static bool operator <=(ApparentPower left, ApparentPower right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(ApparentPower left, ApparentPower right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(ApparentPower left, ApparentPower right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(ApparentPower left, ApparentPower right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(ApparentPower left, ApparentPower right) @@ -471,7 +471,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(ApparentPower other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -484,7 +484,7 @@ public override bool Equals(object obj) public bool Equals(ApparentPower other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -560,7 +560,7 @@ public double As(ApparentPowerUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -570,7 +570,7 @@ public double As(ApparentPowerUnit unit) /// A ApparentPower with the specified unit. public ApparentPower ToUnit(ApparentPowerUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ApparentPower(convertedValue, unit); } @@ -579,30 +579,36 @@ public ApparentPower ToUnit(ApparentPowerUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ApparentPower AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ApparentPowerUnit.Gigavoltampere: - return new ApparentPower((_value) * 1e9d, BaseUnit); - case ApparentPowerUnit.Kilovoltampere: - return new ApparentPower((_value) * 1e3d, BaseUnit); - case ApparentPowerUnit.Megavoltampere: - return new ApparentPower((_value) * 1e6d, BaseUnit); - case ApparentPowerUnit.Voltampere: - return new ApparentPower(_value, BaseUnit); + case ApparentPowerUnit.Gigavoltampere: return (_value) * 1e9d; + case ApparentPowerUnit.Kilovoltampere: return (_value) * 1e3d; + case ApparentPowerUnit.Megavoltampere: return (_value) * 1e6d; + case ApparentPowerUnit.Voltampere: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ApparentPowerUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ApparentPower ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ApparentPower(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ApparentPowerUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Area.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Area.NetFramework.g.cs index 46bc60c19f..591e6a9516 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 new Area(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static Area operator -(Area left, Area right) { - return new Area(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new Area(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static Area operator *(double left, Area right) @@ -558,22 +558,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out AreaUn public static bool operator <=(Area left, Area right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(Area left, Area right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(Area left, Area right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(Area left, Area right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(Area left, Area right) @@ -597,7 +597,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(Area other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -610,7 +610,7 @@ public override bool Equals(object obj) public bool Equals(Area other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -686,7 +686,7 @@ public double As(AreaUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -696,7 +696,7 @@ public double As(AreaUnit unit) /// A Area with the specified unit. public Area ToUnit(AreaUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Area(convertedValue, unit); } @@ -705,48 +705,45 @@ public Area ToUnit(AreaUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Area AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case AreaUnit.Acre: - return new Area(_value*4046.85642, BaseUnit); - case AreaUnit.Hectare: - return new Area(_value*1e4, BaseUnit); - case AreaUnit.SquareCentimeter: - return new Area(_value*1e-4, BaseUnit); - case AreaUnit.SquareDecimeter: - return new Area(_value*1e-2, BaseUnit); - case AreaUnit.SquareFoot: - return new Area(_value*0.092903, BaseUnit); - case AreaUnit.SquareInch: - return new Area(_value*0.00064516, BaseUnit); - case AreaUnit.SquareKilometer: - return new Area(_value*1e6, BaseUnit); - case AreaUnit.SquareMeter: - return new Area(_value, BaseUnit); - case AreaUnit.SquareMicrometer: - return new Area(_value*1e-12, BaseUnit); - case AreaUnit.SquareMile: - return new Area(_value*2.59e6, BaseUnit); - case AreaUnit.SquareMillimeter: - return new Area(_value*1e-6, BaseUnit); - case AreaUnit.SquareYard: - return new Area(_value*0.836127, BaseUnit); - case AreaUnit.UsSurveySquareFoot: - return new Area(_value*0.09290341161, BaseUnit); + case AreaUnit.Acre: return _value*4046.85642; + case AreaUnit.Hectare: return _value*1e4; + case AreaUnit.SquareCentimeter: return _value*1e-4; + case AreaUnit.SquareDecimeter: return _value*1e-2; + case AreaUnit.SquareFoot: return _value*0.092903; + case AreaUnit.SquareInch: return _value*0.00064516; + case AreaUnit.SquareKilometer: return _value*1e6; + case AreaUnit.SquareMeter: return _value; + case AreaUnit.SquareMicrometer: return _value*1e-12; + case AreaUnit.SquareMile: return _value*2.59e6; + case AreaUnit.SquareMillimeter: return _value*1e-6; + case AreaUnit.SquareYard: return _value*0.836127; + case AreaUnit.UsSurveySquareFoot: return _value*0.09290341161; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(AreaUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Area ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Area(baseUnitValue, BaseUnit); + } + + private double GetValueAs(AreaUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/AreaDensity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/AreaDensity.NetFramework.g.cs index bb47afbd42..c8f9828be0 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 new AreaDensity(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static AreaDensity operator -(AreaDensity left, AreaDensity right) { - return new AreaDensity(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new AreaDensity(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static AreaDensity operator *(double left, AreaDensity right) @@ -390,22 +390,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out AreaDe public static bool operator <=(AreaDensity left, AreaDensity right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(AreaDensity left, AreaDensity right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(AreaDensity left, AreaDensity right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(AreaDensity left, AreaDensity right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(AreaDensity left, AreaDensity right) @@ -429,7 +429,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(AreaDensity other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -442,7 +442,7 @@ public override bool Equals(object obj) public bool Equals(AreaDensity other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -518,7 +518,7 @@ public double As(AreaDensityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -528,7 +528,7 @@ public double As(AreaDensityUnit unit) /// A AreaDensity with the specified unit. public AreaDensity ToUnit(AreaDensityUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new AreaDensity(convertedValue, unit); } @@ -537,24 +537,33 @@ public AreaDensity ToUnit(AreaDensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal AreaDensity AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case AreaDensityUnit.KilogramPerSquareMeter: - return new AreaDensity(_value, BaseUnit); + case AreaDensityUnit.KilogramPerSquareMeter: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(AreaDensityUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal AreaDensity ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new AreaDensity(baseUnitValue, BaseUnit); + } + + private double GetValueAs(AreaDensityUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.NetFramework.g.cs index 3b3db57d79..df4f1da976 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 new AreaMomentOfInertia(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static AreaMomentOfInertia operator -(AreaMomentOfInertia left, AreaMomentOfInertia right) { - return new AreaMomentOfInertia(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new AreaMomentOfInertia(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static AreaMomentOfInertia operator *(double left, AreaMomentOfInertia right) @@ -460,22 +460,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out AreaMo public static bool operator <=(AreaMomentOfInertia left, AreaMomentOfInertia right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(AreaMomentOfInertia left, AreaMomentOfInertia right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(AreaMomentOfInertia left, AreaMomentOfInertia right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(AreaMomentOfInertia left, AreaMomentOfInertia right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(AreaMomentOfInertia left, AreaMomentOfInertia right) @@ -499,7 +499,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(AreaMomentOfInertia other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -512,7 +512,7 @@ public override bool Equals(object obj) public bool Equals(AreaMomentOfInertia other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -588,7 +588,7 @@ public double As(AreaMomentOfInertiaUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -598,7 +598,7 @@ public double As(AreaMomentOfInertiaUnit unit) /// A AreaMomentOfInertia with the specified unit. public AreaMomentOfInertia ToUnit(AreaMomentOfInertiaUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new AreaMomentOfInertia(convertedValue, unit); } @@ -607,34 +607,38 @@ public AreaMomentOfInertia ToUnit(AreaMomentOfInertiaUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal AreaMomentOfInertia AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case AreaMomentOfInertiaUnit.CentimeterToTheFourth: - return new AreaMomentOfInertia(_value/1e8, BaseUnit); - case AreaMomentOfInertiaUnit.DecimeterToTheFourth: - return new AreaMomentOfInertia(_value/1e4, BaseUnit); - case AreaMomentOfInertiaUnit.FootToTheFourth: - return new AreaMomentOfInertia(_value*Math.Pow(0.3048, 4), BaseUnit); - case AreaMomentOfInertiaUnit.InchToTheFourth: - return new AreaMomentOfInertia(_value*Math.Pow(2.54e-2, 4), BaseUnit); - case AreaMomentOfInertiaUnit.MeterToTheFourth: - return new AreaMomentOfInertia(_value, BaseUnit); - case AreaMomentOfInertiaUnit.MillimeterToTheFourth: - return new AreaMomentOfInertia(_value/1e12, BaseUnit); + case AreaMomentOfInertiaUnit.CentimeterToTheFourth: return _value/1e8; + case AreaMomentOfInertiaUnit.DecimeterToTheFourth: return _value/1e4; + case AreaMomentOfInertiaUnit.FootToTheFourth: return _value*Math.Pow(0.3048, 4); + case AreaMomentOfInertiaUnit.InchToTheFourth: return _value*Math.Pow(2.54e-2, 4); + case AreaMomentOfInertiaUnit.MeterToTheFourth: return _value; + case AreaMomentOfInertiaUnit.MillimeterToTheFourth: return _value/1e12; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(AreaMomentOfInertiaUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal AreaMomentOfInertia ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new AreaMomentOfInertia(baseUnitValue, BaseUnit); + } + + private double GetValueAs(AreaMomentOfInertiaUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/BitRate.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/BitRate.NetFramework.g.cs index 597dc04e30..bf32484a40 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 new BitRate(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static BitRate operator -(BitRate left, BitRate right) { - return new BitRate(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new BitRate(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static BitRate operator *(decimal left, BitRate right) @@ -743,22 +743,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out BitRat public static bool operator <=(BitRate left, BitRate right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(BitRate left, BitRate right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(BitRate left, BitRate right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(BitRate left, BitRate right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(BitRate left, BitRate right) @@ -782,7 +782,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(BitRate other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -795,7 +795,7 @@ public override bool Equals(object obj) public bool Equals(BitRate other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -871,7 +871,7 @@ public double As(BitRateUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -881,7 +881,7 @@ public double As(BitRateUnit unit) /// A BitRate with the specified unit. public BitRate ToUnit(BitRateUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new BitRate(convertedValue, unit); } @@ -890,74 +890,58 @@ public BitRate ToUnit(BitRateUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal BitRate AsBaseUnit() + private decimal GetValueInBaseUnit() { switch(Unit) { - case BitRateUnit.BitPerSecond: - return new BitRate(_value, BaseUnit); - case BitRateUnit.BytePerSecond: - return new BitRate(_value*8m, BaseUnit); - case BitRateUnit.ExabitPerSecond: - return new BitRate((_value) * 1e18m, BaseUnit); - case BitRateUnit.ExabytePerSecond: - return new BitRate((_value*8m) * 1e18m, BaseUnit); - case BitRateUnit.ExbibitPerSecond: - return new BitRate((_value) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024), BaseUnit); - case BitRateUnit.ExbibytePerSecond: - return new BitRate((_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024), BaseUnit); - case BitRateUnit.GibibitPerSecond: - return new BitRate((_value) * (1024m * 1024 * 1024), BaseUnit); - case BitRateUnit.GibibytePerSecond: - return new BitRate((_value*8m) * (1024m * 1024 * 1024), BaseUnit); - case BitRateUnit.GigabitPerSecond: - return new BitRate((_value) * 1e9m, BaseUnit); - case BitRateUnit.GigabytePerSecond: - return new BitRate((_value*8m) * 1e9m, BaseUnit); - case BitRateUnit.KibibitPerSecond: - return new BitRate((_value) * 1024m, BaseUnit); - case BitRateUnit.KibibytePerSecond: - return new BitRate((_value*8m) * 1024m, BaseUnit); - case BitRateUnit.KilobitPerSecond: - return new BitRate((_value) * 1e3m, BaseUnit); - case BitRateUnit.KilobytePerSecond: - return new BitRate((_value*8m) * 1e3m, BaseUnit); - case BitRateUnit.MebibitPerSecond: - return new BitRate((_value) * (1024m * 1024), BaseUnit); - case BitRateUnit.MebibytePerSecond: - return new BitRate((_value*8m) * (1024m * 1024), BaseUnit); - case BitRateUnit.MegabitPerSecond: - return new BitRate((_value) * 1e6m, BaseUnit); - case BitRateUnit.MegabytePerSecond: - return new BitRate((_value*8m) * 1e6m, BaseUnit); - case BitRateUnit.PebibitPerSecond: - return new BitRate((_value) * (1024m * 1024 * 1024 * 1024 * 1024), BaseUnit); - case BitRateUnit.PebibytePerSecond: - return new BitRate((_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024), BaseUnit); - case BitRateUnit.PetabitPerSecond: - return new BitRate((_value) * 1e15m, BaseUnit); - case BitRateUnit.PetabytePerSecond: - return new BitRate((_value*8m) * 1e15m, BaseUnit); - case BitRateUnit.TebibitPerSecond: - return new BitRate((_value) * (1024m * 1024 * 1024 * 1024), BaseUnit); - case BitRateUnit.TebibytePerSecond: - return new BitRate((_value*8m) * (1024m * 1024 * 1024 * 1024), BaseUnit); - case BitRateUnit.TerabitPerSecond: - return new BitRate((_value) * 1e12m, BaseUnit); - case BitRateUnit.TerabytePerSecond: - return new BitRate((_value*8m) * 1e12m, BaseUnit); + case BitRateUnit.BitPerSecond: return _value; + case BitRateUnit.BytePerSecond: return _value*8m; + case BitRateUnit.ExabitPerSecond: return (_value) * 1e18m; + case BitRateUnit.ExabytePerSecond: return (_value*8m) * 1e18m; + case BitRateUnit.ExbibitPerSecond: return (_value) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024); + case BitRateUnit.ExbibytePerSecond: return (_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024); + case BitRateUnit.GibibitPerSecond: return (_value) * (1024m * 1024 * 1024); + case BitRateUnit.GibibytePerSecond: return (_value*8m) * (1024m * 1024 * 1024); + case BitRateUnit.GigabitPerSecond: return (_value) * 1e9m; + case BitRateUnit.GigabytePerSecond: return (_value*8m) * 1e9m; + case BitRateUnit.KibibitPerSecond: return (_value) * 1024m; + case BitRateUnit.KibibytePerSecond: return (_value*8m) * 1024m; + case BitRateUnit.KilobitPerSecond: return (_value) * 1e3m; + case BitRateUnit.KilobytePerSecond: return (_value*8m) * 1e3m; + case BitRateUnit.MebibitPerSecond: return (_value) * (1024m * 1024); + case BitRateUnit.MebibytePerSecond: return (_value*8m) * (1024m * 1024); + case BitRateUnit.MegabitPerSecond: return (_value) * 1e6m; + case BitRateUnit.MegabytePerSecond: return (_value*8m) * 1e6m; + case BitRateUnit.PebibitPerSecond: return (_value) * (1024m * 1024 * 1024 * 1024 * 1024); + case BitRateUnit.PebibytePerSecond: return (_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024); + case BitRateUnit.PetabitPerSecond: return (_value) * 1e15m; + case BitRateUnit.PetabytePerSecond: return (_value*8m) * 1e15m; + case BitRateUnit.TebibitPerSecond: return (_value) * (1024m * 1024 * 1024 * 1024); + case BitRateUnit.TebibytePerSecond: return (_value*8m) * (1024m * 1024 * 1024 * 1024); + case BitRateUnit.TerabitPerSecond: return (_value) * 1e12m; + case BitRateUnit.TerabytePerSecond: return (_value*8m) * 1e12m; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private decimal AsBaseNumericType(BitRateUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal BitRate ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new BitRate(baseUnitValue, BaseUnit); + } + + private decimal GetValueAs(BitRateUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.NetFramework.g.cs index f716eaef0c..829c954fc6 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 new BrakeSpecificFuelConsumption(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static BrakeSpecificFuelConsumption operator -(BrakeSpecificFuelConsumption left, BrakeSpecificFuelConsumption right) { - return new BrakeSpecificFuelConsumption(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new BrakeSpecificFuelConsumption(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static BrakeSpecificFuelConsumption operator *(double left, BrakeSpecificFuelConsumption right) @@ -418,22 +418,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out BrakeS public static bool operator <=(BrakeSpecificFuelConsumption left, BrakeSpecificFuelConsumption right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(BrakeSpecificFuelConsumption left, BrakeSpecificFuelConsumption right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(BrakeSpecificFuelConsumption left, BrakeSpecificFuelConsumption right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(BrakeSpecificFuelConsumption left, BrakeSpecificFuelConsumption right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(BrakeSpecificFuelConsumption left, BrakeSpecificFuelConsumption right) @@ -457,7 +457,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(BrakeSpecificFuelConsumption other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -470,7 +470,7 @@ public override bool Equals(object obj) public bool Equals(BrakeSpecificFuelConsumption other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -546,7 +546,7 @@ public double As(BrakeSpecificFuelConsumptionUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -556,7 +556,7 @@ public double As(BrakeSpecificFuelConsumptionUnit unit) /// A BrakeSpecificFuelConsumption with the specified unit. public BrakeSpecificFuelConsumption ToUnit(BrakeSpecificFuelConsumptionUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new BrakeSpecificFuelConsumption(convertedValue, unit); } @@ -565,28 +565,35 @@ public BrakeSpecificFuelConsumption ToUnit(BrakeSpecificFuelConsumptionUnit unit /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal BrakeSpecificFuelConsumption AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour: - return new BrakeSpecificFuelConsumption(_value/3.6e9, BaseUnit); - case BrakeSpecificFuelConsumptionUnit.KilogramPerJoule: - return new BrakeSpecificFuelConsumption(_value, BaseUnit); - case BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour: - return new BrakeSpecificFuelConsumption(_value*1.689659410672e-7, BaseUnit); + case BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour: return _value/3.6e9; + case BrakeSpecificFuelConsumptionUnit.KilogramPerJoule: return _value; + case BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour: return _value*1.689659410672e-7; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(BrakeSpecificFuelConsumptionUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal BrakeSpecificFuelConsumption ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new BrakeSpecificFuelConsumption(baseUnitValue, BaseUnit); + } + + private double GetValueAs(BrakeSpecificFuelConsumptionUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Capacitance.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Capacitance.NetFramework.g.cs index bb4465fde5..4b92b4ca45 100644 --- a/UnitsNet/GeneratedCode/Quantities/Capacitance.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Capacitance.NetFramework.g.cs @@ -443,12 +443,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 new Capacitance(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static Capacitance operator -(Capacitance left, Capacitance right) { - return new Capacitance(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new Capacitance(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static Capacitance operator *(double left, Capacitance right) @@ -477,22 +477,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Capaci public static bool operator <=(Capacitance left, Capacitance right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(Capacitance left, Capacitance right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(Capacitance left, Capacitance right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(Capacitance left, Capacitance right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(Capacitance left, Capacitance right) @@ -516,7 +516,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(Capacitance other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -529,7 +529,7 @@ public override bool Equals(object obj) public bool Equals(Capacitance other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -605,7 +605,7 @@ public double As(CapacitanceUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -615,7 +615,7 @@ public double As(CapacitanceUnit unit) /// A Capacitance with the specified unit. public Capacitance ToUnit(CapacitanceUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Capacitance(convertedValue, unit); } @@ -624,36 +624,39 @@ public Capacitance ToUnit(CapacitanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Capacitance AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case CapacitanceUnit.Farad: - return new Capacitance(_value, BaseUnit); - case CapacitanceUnit.Kilofarad: - return new Capacitance((_value) * 1e3d, BaseUnit); - case CapacitanceUnit.Megafarad: - return new Capacitance((_value) * 1e6d, BaseUnit); - case CapacitanceUnit.Microfarad: - return new Capacitance((_value) * 1e-6d, BaseUnit); - case CapacitanceUnit.Millifarad: - return new Capacitance((_value) * 1e-3d, BaseUnit); - case CapacitanceUnit.Nanofarad: - return new Capacitance((_value) * 1e-9d, BaseUnit); - case CapacitanceUnit.Picofarad: - return new Capacitance((_value) * 1e-12d, BaseUnit); + case CapacitanceUnit.Farad: return _value; + case CapacitanceUnit.Kilofarad: return (_value) * 1e3d; + case CapacitanceUnit.Megafarad: return (_value) * 1e6d; + case CapacitanceUnit.Microfarad: return (_value) * 1e-6d; + case CapacitanceUnit.Millifarad: return (_value) * 1e-3d; + case CapacitanceUnit.Nanofarad: return (_value) * 1e-9d; + case CapacitanceUnit.Picofarad: return (_value) * 1e-12d; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(CapacitanceUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Capacitance ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Capacitance(baseUnitValue, BaseUnit); + } + + private double GetValueAs(CapacitanceUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.NetFramework.g.cs index c8b7c0e4a8..21fa71a964 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 new CoefficientOfThermalExpansion(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static CoefficientOfThermalExpansion operator -(CoefficientOfThermalExpansion left, CoefficientOfThermalExpansion right) { - return new CoefficientOfThermalExpansion(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new CoefficientOfThermalExpansion(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static CoefficientOfThermalExpansion operator *(double left, CoefficientOfThermalExpansion right) @@ -418,22 +418,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Coeffi public static bool operator <=(CoefficientOfThermalExpansion left, CoefficientOfThermalExpansion right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(CoefficientOfThermalExpansion left, CoefficientOfThermalExpansion right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(CoefficientOfThermalExpansion left, CoefficientOfThermalExpansion right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(CoefficientOfThermalExpansion left, CoefficientOfThermalExpansion right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(CoefficientOfThermalExpansion left, CoefficientOfThermalExpansion right) @@ -457,7 +457,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(CoefficientOfThermalExpansion other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -470,7 +470,7 @@ public override bool Equals(object obj) public bool Equals(CoefficientOfThermalExpansion other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -546,7 +546,7 @@ public double As(CoefficientOfThermalExpansionUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -556,7 +556,7 @@ public double As(CoefficientOfThermalExpansionUnit unit) /// A CoefficientOfThermalExpansion with the specified unit. public CoefficientOfThermalExpansion ToUnit(CoefficientOfThermalExpansionUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new CoefficientOfThermalExpansion(convertedValue, unit); } @@ -565,28 +565,35 @@ public CoefficientOfThermalExpansion ToUnit(CoefficientOfThermalExpansionUnit un /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal CoefficientOfThermalExpansion AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case CoefficientOfThermalExpansionUnit.InverseDegreeCelsius: - return new CoefficientOfThermalExpansion(_value, BaseUnit); - case CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit: - return new CoefficientOfThermalExpansion(_value*5/9, BaseUnit); - case CoefficientOfThermalExpansionUnit.InverseKelvin: - return new CoefficientOfThermalExpansion(_value, BaseUnit); + case CoefficientOfThermalExpansionUnit.InverseDegreeCelsius: return _value; + case CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit: return _value*5/9; + case CoefficientOfThermalExpansionUnit.InverseKelvin: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(CoefficientOfThermalExpansionUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal CoefficientOfThermalExpansion ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new CoefficientOfThermalExpansion(baseUnitValue, BaseUnit); + } + + private double GetValueAs(CoefficientOfThermalExpansionUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Density.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Density.NetFramework.g.cs index 82cfe28079..e7a6282b5a 100644 --- a/UnitsNet/GeneratedCode/Quantities/Density.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Density.NetFramework.g.cs @@ -891,12 +891,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 new Density(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static Density operator -(Density left, Density right) { - return new Density(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new Density(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static Density operator *(double left, Density right) @@ -925,22 +925,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Densit public static bool operator <=(Density left, Density right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(Density left, Density right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(Density left, Density right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(Density left, Density right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(Density left, Density right) @@ -964,7 +964,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(Density other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -977,7 +977,7 @@ public override bool Equals(object obj) public bool Equals(Density other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -1053,7 +1053,7 @@ public double As(DensityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -1063,7 +1063,7 @@ public double As(DensityUnit unit) /// A Density with the specified unit. public Density ToUnit(DensityUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Density(convertedValue, unit); } @@ -1072,100 +1072,71 @@ public Density ToUnit(DensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Density AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case DensityUnit.CentigramPerDeciliter: - return new Density((_value/1e-1) * 1e-2d, BaseUnit); - case DensityUnit.CentigramPerLiter: - return new Density((_value/1) * 1e-2d, BaseUnit); - case DensityUnit.CentigramPerMilliliter: - return new Density((_value/1e-3) * 1e-2d, BaseUnit); - case DensityUnit.DecigramPerDeciliter: - return new Density((_value/1e-1) * 1e-1d, BaseUnit); - case DensityUnit.DecigramPerLiter: - return new Density((_value/1) * 1e-1d, BaseUnit); - case DensityUnit.DecigramPerMilliliter: - return new Density((_value/1e-3) * 1e-1d, BaseUnit); - case DensityUnit.GramPerCubicCentimeter: - return new Density(_value/1e-3, BaseUnit); - case DensityUnit.GramPerCubicMeter: - return new Density(_value/1e3, BaseUnit); - case DensityUnit.GramPerCubicMillimeter: - return new Density(_value/1e-6, BaseUnit); - case DensityUnit.GramPerDeciliter: - return new Density(_value/1e-1, BaseUnit); - case DensityUnit.GramPerLiter: - return new Density(_value/1, BaseUnit); - case DensityUnit.GramPerMilliliter: - return new Density(_value/1e-3, BaseUnit); - case DensityUnit.KilogramPerCubicCentimeter: - return new Density((_value/1e-3) * 1e3d, BaseUnit); - case DensityUnit.KilogramPerCubicMeter: - return new Density((_value/1e3) * 1e3d, BaseUnit); - case DensityUnit.KilogramPerCubicMillimeter: - return new Density((_value/1e-6) * 1e3d, BaseUnit); - case DensityUnit.KilopoundPerCubicFoot: - return new Density((_value/0.062427961) * 1e3d, BaseUnit); - case DensityUnit.KilopoundPerCubicInch: - return new Density((_value/3.6127298147753e-5) * 1e3d, BaseUnit); - case DensityUnit.MicrogramPerCubicMeter: - return new Density((_value/1e3) * 1e-6d, BaseUnit); - case DensityUnit.MicrogramPerDeciliter: - return new Density((_value/1e-1) * 1e-6d, BaseUnit); - case DensityUnit.MicrogramPerLiter: - return new Density((_value/1) * 1e-6d, BaseUnit); - case DensityUnit.MicrogramPerMilliliter: - return new Density((_value/1e-3) * 1e-6d, BaseUnit); - case DensityUnit.MilligramPerCubicMeter: - return new Density((_value/1e3) * 1e-3d, BaseUnit); - case DensityUnit.MilligramPerDeciliter: - return new Density((_value/1e-1) * 1e-3d, BaseUnit); - case DensityUnit.MilligramPerLiter: - return new Density((_value/1) * 1e-3d, BaseUnit); - case DensityUnit.MilligramPerMilliliter: - return new Density((_value/1e-3) * 1e-3d, BaseUnit); - case DensityUnit.NanogramPerDeciliter: - return new Density((_value/1e-1) * 1e-9d, BaseUnit); - case DensityUnit.NanogramPerLiter: - return new Density((_value/1) * 1e-9d, BaseUnit); - case DensityUnit.NanogramPerMilliliter: - return new Density((_value/1e-3) * 1e-9d, BaseUnit); - case DensityUnit.PicogramPerDeciliter: - return new Density((_value/1e-1) * 1e-12d, BaseUnit); - case DensityUnit.PicogramPerLiter: - return new Density((_value/1) * 1e-12d, BaseUnit); - case DensityUnit.PicogramPerMilliliter: - return new Density((_value/1e-3) * 1e-12d, BaseUnit); - case DensityUnit.PoundPerCubicFoot: - return new Density(_value/0.062427961, BaseUnit); - case DensityUnit.PoundPerCubicInch: - return new Density(_value/3.6127298147753e-5, BaseUnit); - case DensityUnit.PoundPerImperialGallon: - return new Density(_value*9.9776398e1, BaseUnit); - case DensityUnit.PoundPerUSGallon: - return new Density(_value*1.19826427e2, BaseUnit); - case DensityUnit.SlugPerCubicFoot: - return new Density(_value*515.378818, BaseUnit); - case DensityUnit.TonnePerCubicCentimeter: - return new Density(_value/1e-9, BaseUnit); - case DensityUnit.TonnePerCubicMeter: - return new Density(_value/0.001, BaseUnit); - case DensityUnit.TonnePerCubicMillimeter: - return new Density(_value/1e-12, BaseUnit); + case DensityUnit.CentigramPerDeciliter: return (_value/1e-1) * 1e-2d; + case DensityUnit.CentigramPerLiter: return (_value/1) * 1e-2d; + case DensityUnit.CentigramPerMilliliter: return (_value/1e-3) * 1e-2d; + case DensityUnit.DecigramPerDeciliter: return (_value/1e-1) * 1e-1d; + case DensityUnit.DecigramPerLiter: return (_value/1) * 1e-1d; + case DensityUnit.DecigramPerMilliliter: return (_value/1e-3) * 1e-1d; + case DensityUnit.GramPerCubicCentimeter: return _value/1e-3; + case DensityUnit.GramPerCubicMeter: return _value/1e3; + case DensityUnit.GramPerCubicMillimeter: return _value/1e-6; + case DensityUnit.GramPerDeciliter: return _value/1e-1; + case DensityUnit.GramPerLiter: return _value/1; + case DensityUnit.GramPerMilliliter: return _value/1e-3; + case DensityUnit.KilogramPerCubicCentimeter: return (_value/1e-3) * 1e3d; + case DensityUnit.KilogramPerCubicMeter: return (_value/1e3) * 1e3d; + case DensityUnit.KilogramPerCubicMillimeter: return (_value/1e-6) * 1e3d; + case DensityUnit.KilopoundPerCubicFoot: return (_value/0.062427961) * 1e3d; + case DensityUnit.KilopoundPerCubicInch: return (_value/3.6127298147753e-5) * 1e3d; + case DensityUnit.MicrogramPerCubicMeter: return (_value/1e3) * 1e-6d; + case DensityUnit.MicrogramPerDeciliter: return (_value/1e-1) * 1e-6d; + case DensityUnit.MicrogramPerLiter: return (_value/1) * 1e-6d; + case DensityUnit.MicrogramPerMilliliter: return (_value/1e-3) * 1e-6d; + case DensityUnit.MilligramPerCubicMeter: return (_value/1e3) * 1e-3d; + case DensityUnit.MilligramPerDeciliter: return (_value/1e-1) * 1e-3d; + case DensityUnit.MilligramPerLiter: return (_value/1) * 1e-3d; + case DensityUnit.MilligramPerMilliliter: return (_value/1e-3) * 1e-3d; + case DensityUnit.NanogramPerDeciliter: return (_value/1e-1) * 1e-9d; + case DensityUnit.NanogramPerLiter: return (_value/1) * 1e-9d; + case DensityUnit.NanogramPerMilliliter: return (_value/1e-3) * 1e-9d; + case DensityUnit.PicogramPerDeciliter: return (_value/1e-1) * 1e-12d; + case DensityUnit.PicogramPerLiter: return (_value/1) * 1e-12d; + case DensityUnit.PicogramPerMilliliter: return (_value/1e-3) * 1e-12d; + case DensityUnit.PoundPerCubicFoot: return _value/0.062427961; + case DensityUnit.PoundPerCubicInch: return _value/3.6127298147753e-5; + case DensityUnit.PoundPerImperialGallon: return _value*9.9776398e1; + case DensityUnit.PoundPerUSGallon: return _value*1.19826427e2; + case DensityUnit.SlugPerCubicFoot: return _value*515.378818; + case DensityUnit.TonnePerCubicCentimeter: return _value/1e-9; + case DensityUnit.TonnePerCubicMeter: return _value/0.001; + case DensityUnit.TonnePerCubicMillimeter: return _value/1e-12; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(DensityUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Density ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Density(baseUnitValue, BaseUnit); + } + + private double GetValueAs(DensityUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Duration.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Duration.NetFramework.g.cs index af1c517f59..59f0a7b515 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 new Duration(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static Duration operator -(Duration left, Duration right) { - return new Duration(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new Duration(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static Duration operator *(double left, Duration right) @@ -516,22 +516,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Durati public static bool operator <=(Duration left, Duration right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(Duration left, Duration right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(Duration left, Duration right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(Duration left, Duration right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(Duration left, Duration right) @@ -555,7 +555,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(Duration other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -568,7 +568,7 @@ public override bool Equals(object obj) public bool Equals(Duration other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -644,7 +644,7 @@ public double As(DurationUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -654,7 +654,7 @@ public double As(DurationUnit unit) /// A Duration with the specified unit. public Duration ToUnit(DurationUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Duration(convertedValue, unit); } @@ -663,42 +663,42 @@ public Duration ToUnit(DurationUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Duration AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case DurationUnit.Day: - return new Duration(_value*24*3600, BaseUnit); - case DurationUnit.Hour: - return new Duration(_value*3600, BaseUnit); - case DurationUnit.Microsecond: - return new Duration((_value) * 1e-6d, BaseUnit); - case DurationUnit.Millisecond: - return new Duration((_value) * 1e-3d, BaseUnit); - case DurationUnit.Minute: - return new Duration(_value*60, BaseUnit); - case DurationUnit.Month30: - return new Duration(_value*30*24*3600, BaseUnit); - case DurationUnit.Nanosecond: - return new Duration((_value) * 1e-9d, BaseUnit); - case DurationUnit.Second: - return new Duration(_value, BaseUnit); - case DurationUnit.Week: - return new Duration(_value*7*24*3600, BaseUnit); - case DurationUnit.Year365: - return new Duration(_value*365*24*3600, BaseUnit); + case DurationUnit.Day: return _value*24*3600; + case DurationUnit.Hour: return _value*3600; + case DurationUnit.Microsecond: return (_value) * 1e-6d; + case DurationUnit.Millisecond: return (_value) * 1e-3d; + case DurationUnit.Minute: return _value*60; + case DurationUnit.Month30: return _value*30*24*3600; + case DurationUnit.Nanosecond: return (_value) * 1e-9d; + case DurationUnit.Second: return _value; + case DurationUnit.Week: return _value*7*24*3600; + case DurationUnit.Year365: return _value*365*24*3600; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(DurationUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Duration ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Duration(baseUnitValue, BaseUnit); + } + + private double GetValueAs(DurationUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.NetFramework.g.cs index c46c919958..1af7aed2f6 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 new DynamicViscosity(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static DynamicViscosity operator -(DynamicViscosity left, DynamicViscosity right) { - return new DynamicViscosity(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new DynamicViscosity(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static DynamicViscosity operator *(double left, DynamicViscosity right) @@ -463,22 +463,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Dynami public static bool operator <=(DynamicViscosity left, DynamicViscosity right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(DynamicViscosity left, DynamicViscosity right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(DynamicViscosity left, DynamicViscosity right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(DynamicViscosity left, DynamicViscosity right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(DynamicViscosity left, DynamicViscosity right) @@ -502,7 +502,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(DynamicViscosity other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -515,7 +515,7 @@ public override bool Equals(object obj) public bool Equals(DynamicViscosity other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -591,7 +591,7 @@ public double As(DynamicViscosityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -601,7 +601,7 @@ public double As(DynamicViscosityUnit unit) /// A DynamicViscosity with the specified unit. public DynamicViscosity ToUnit(DynamicViscosityUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new DynamicViscosity(convertedValue, unit); } @@ -610,34 +610,38 @@ public DynamicViscosity ToUnit(DynamicViscosityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal DynamicViscosity AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case DynamicViscosityUnit.Centipoise: - return new DynamicViscosity((_value/10) * 1e-2d, BaseUnit); - case DynamicViscosityUnit.MicropascalSecond: - return new DynamicViscosity((_value) * 1e-6d, BaseUnit); - case DynamicViscosityUnit.MillipascalSecond: - return new DynamicViscosity((_value) * 1e-3d, BaseUnit); - case DynamicViscosityUnit.NewtonSecondPerMeterSquared: - return new DynamicViscosity(_value, BaseUnit); - case DynamicViscosityUnit.PascalSecond: - return new DynamicViscosity(_value, BaseUnit); - case DynamicViscosityUnit.Poise: - return new DynamicViscosity(_value/10, BaseUnit); + case DynamicViscosityUnit.Centipoise: return (_value/10) * 1e-2d; + case DynamicViscosityUnit.MicropascalSecond: return (_value) * 1e-6d; + case DynamicViscosityUnit.MillipascalSecond: return (_value) * 1e-3d; + case DynamicViscosityUnit.NewtonSecondPerMeterSquared: return _value; + case DynamicViscosityUnit.PascalSecond: return _value; + case DynamicViscosityUnit.Poise: return _value/10; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(DynamicViscosityUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal DynamicViscosity ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new DynamicViscosity(baseUnitValue, BaseUnit); + } + + private double GetValueAs(DynamicViscosityUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.NetFramework.g.cs index 29591e11c9..01b81e679c 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 new ElectricAdmittance(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static ElectricAdmittance operator -(ElectricAdmittance left, ElectricAdmittance right) { - return new ElectricAdmittance(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new ElectricAdmittance(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static ElectricAdmittance operator *(double left, ElectricAdmittance right) @@ -432,22 +432,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr public static bool operator <=(ElectricAdmittance left, ElectricAdmittance right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(ElectricAdmittance left, ElectricAdmittance right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(ElectricAdmittance left, ElectricAdmittance right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(ElectricAdmittance left, ElectricAdmittance right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(ElectricAdmittance left, ElectricAdmittance right) @@ -471,7 +471,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(ElectricAdmittance other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -484,7 +484,7 @@ public override bool Equals(object obj) public bool Equals(ElectricAdmittance other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -560,7 +560,7 @@ public double As(ElectricAdmittanceUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -570,7 +570,7 @@ public double As(ElectricAdmittanceUnit unit) /// A ElectricAdmittance with the specified unit. public ElectricAdmittance ToUnit(ElectricAdmittanceUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ElectricAdmittance(convertedValue, unit); } @@ -579,30 +579,36 @@ public ElectricAdmittance ToUnit(ElectricAdmittanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ElectricAdmittance AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ElectricAdmittanceUnit.Microsiemens: - return new ElectricAdmittance((_value) * 1e-6d, BaseUnit); - case ElectricAdmittanceUnit.Millisiemens: - return new ElectricAdmittance((_value) * 1e-3d, BaseUnit); - case ElectricAdmittanceUnit.Nanosiemens: - return new ElectricAdmittance((_value) * 1e-9d, BaseUnit); - case ElectricAdmittanceUnit.Siemens: - return new ElectricAdmittance(_value, BaseUnit); + case ElectricAdmittanceUnit.Microsiemens: return (_value) * 1e-6d; + case ElectricAdmittanceUnit.Millisiemens: return (_value) * 1e-3d; + case ElectricAdmittanceUnit.Nanosiemens: return (_value) * 1e-9d; + case ElectricAdmittanceUnit.Siemens: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ElectricAdmittanceUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ElectricAdmittance ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ElectricAdmittance(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ElectricAdmittanceUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCharge.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCharge.NetFramework.g.cs index f59a06725a..8a5c39b198 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 new ElectricCharge(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static ElectricCharge operator -(ElectricCharge left, ElectricCharge right) { - return new ElectricCharge(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new ElectricCharge(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static ElectricCharge operator *(double left, ElectricCharge right) @@ -393,22 +393,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr public static bool operator <=(ElectricCharge left, ElectricCharge right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(ElectricCharge left, ElectricCharge right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(ElectricCharge left, ElectricCharge right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(ElectricCharge left, ElectricCharge right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(ElectricCharge left, ElectricCharge right) @@ -432,7 +432,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(ElectricCharge other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -445,7 +445,7 @@ public override bool Equals(object obj) public bool Equals(ElectricCharge other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -521,7 +521,7 @@ public double As(ElectricChargeUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -531,7 +531,7 @@ public double As(ElectricChargeUnit unit) /// A ElectricCharge with the specified unit. public ElectricCharge ToUnit(ElectricChargeUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ElectricCharge(convertedValue, unit); } @@ -540,24 +540,33 @@ public ElectricCharge ToUnit(ElectricChargeUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ElectricCharge AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ElectricChargeUnit.Coulomb: - return new ElectricCharge(_value, BaseUnit); + case ElectricChargeUnit.Coulomb: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ElectricChargeUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ElectricCharge ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ElectricCharge(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ElectricChargeUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.NetFramework.g.cs index 7345a01b8a..b6c75e6807 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 new ElectricChargeDensity(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static ElectricChargeDensity operator -(ElectricChargeDensity left, ElectricChargeDensity right) { - return new ElectricChargeDensity(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new ElectricChargeDensity(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static ElectricChargeDensity operator *(double left, ElectricChargeDensity right) @@ -393,22 +393,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr public static bool operator <=(ElectricChargeDensity left, ElectricChargeDensity right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(ElectricChargeDensity left, ElectricChargeDensity right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(ElectricChargeDensity left, ElectricChargeDensity right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(ElectricChargeDensity left, ElectricChargeDensity right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(ElectricChargeDensity left, ElectricChargeDensity right) @@ -432,7 +432,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(ElectricChargeDensity other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -445,7 +445,7 @@ public override bool Equals(object obj) public bool Equals(ElectricChargeDensity other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -521,7 +521,7 @@ public double As(ElectricChargeDensityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -531,7 +531,7 @@ public double As(ElectricChargeDensityUnit unit) /// A ElectricChargeDensity with the specified unit. public ElectricChargeDensity ToUnit(ElectricChargeDensityUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ElectricChargeDensity(convertedValue, unit); } @@ -540,24 +540,33 @@ public ElectricChargeDensity ToUnit(ElectricChargeDensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ElectricChargeDensity AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ElectricChargeDensityUnit.CoulombPerCubicMeter: - return new ElectricChargeDensity(_value, BaseUnit); + case ElectricChargeDensityUnit.CoulombPerCubicMeter: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ElectricChargeDensityUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ElectricChargeDensity ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ElectricChargeDensity(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ElectricChargeDensityUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricConductance.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricConductance.NetFramework.g.cs index 8b2052aefa..c6bdb0b8c6 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 new ElectricConductance(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static ElectricConductance operator -(ElectricConductance left, ElectricConductance right) { - return new ElectricConductance(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new ElectricConductance(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static ElectricConductance operator *(double left, ElectricConductance right) @@ -421,22 +421,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr public static bool operator <=(ElectricConductance left, ElectricConductance right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(ElectricConductance left, ElectricConductance right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(ElectricConductance left, ElectricConductance right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(ElectricConductance left, ElectricConductance right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(ElectricConductance left, ElectricConductance right) @@ -460,7 +460,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(ElectricConductance other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -473,7 +473,7 @@ public override bool Equals(object obj) public bool Equals(ElectricConductance other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -549,7 +549,7 @@ public double As(ElectricConductanceUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -559,7 +559,7 @@ public double As(ElectricConductanceUnit unit) /// A ElectricConductance with the specified unit. public ElectricConductance ToUnit(ElectricConductanceUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ElectricConductance(convertedValue, unit); } @@ -568,28 +568,35 @@ public ElectricConductance ToUnit(ElectricConductanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ElectricConductance AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ElectricConductanceUnit.Microsiemens: - return new ElectricConductance((_value) * 1e-6d, BaseUnit); - case ElectricConductanceUnit.Millisiemens: - return new ElectricConductance((_value) * 1e-3d, BaseUnit); - case ElectricConductanceUnit.Siemens: - return new ElectricConductance(_value, BaseUnit); + case ElectricConductanceUnit.Microsiemens: return (_value) * 1e-6d; + case ElectricConductanceUnit.Millisiemens: return (_value) * 1e-3d; + case ElectricConductanceUnit.Siemens: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ElectricConductanceUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ElectricConductance ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ElectricConductance(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ElectricConductanceUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.NetFramework.g.cs index cee6cf9bfb..88c9df0249 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 new ElectricConductivity(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static ElectricConductivity operator -(ElectricConductivity left, ElectricConductivity right) { - return new ElectricConductivity(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new ElectricConductivity(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static ElectricConductivity operator *(double left, ElectricConductivity right) @@ -393,22 +393,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr public static bool operator <=(ElectricConductivity left, ElectricConductivity right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(ElectricConductivity left, ElectricConductivity right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(ElectricConductivity left, ElectricConductivity right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(ElectricConductivity left, ElectricConductivity right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(ElectricConductivity left, ElectricConductivity right) @@ -432,7 +432,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(ElectricConductivity other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -445,7 +445,7 @@ public override bool Equals(object obj) public bool Equals(ElectricConductivity other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -521,7 +521,7 @@ public double As(ElectricConductivityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -531,7 +531,7 @@ public double As(ElectricConductivityUnit unit) /// A ElectricConductivity with the specified unit. public ElectricConductivity ToUnit(ElectricConductivityUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ElectricConductivity(convertedValue, unit); } @@ -540,24 +540,33 @@ public ElectricConductivity ToUnit(ElectricConductivityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ElectricConductivity AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ElectricConductivityUnit.SiemensPerMeter: - return new ElectricConductivity(_value, BaseUnit); + case ElectricConductivityUnit.SiemensPerMeter: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ElectricConductivityUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ElectricConductivity ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ElectricConductivity(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ElectricConductivityUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.NetFramework.g.cs index d3a7e4ecfd..796ffccff7 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 new ElectricCurrent(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static ElectricCurrent operator -(ElectricCurrent left, ElectricCurrent right) { - return new ElectricCurrent(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new ElectricCurrent(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static ElectricCurrent operator *(double left, ElectricCurrent right) @@ -488,22 +488,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr public static bool operator <=(ElectricCurrent left, ElectricCurrent right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(ElectricCurrent left, ElectricCurrent right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(ElectricCurrent left, ElectricCurrent right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(ElectricCurrent left, ElectricCurrent right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(ElectricCurrent left, ElectricCurrent right) @@ -527,7 +527,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(ElectricCurrent other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -540,7 +540,7 @@ public override bool Equals(object obj) public bool Equals(ElectricCurrent other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -616,7 +616,7 @@ public double As(ElectricCurrentUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -626,7 +626,7 @@ public double As(ElectricCurrentUnit unit) /// A ElectricCurrent with the specified unit. public ElectricCurrent ToUnit(ElectricCurrentUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ElectricCurrent(convertedValue, unit); } @@ -635,38 +635,40 @@ public ElectricCurrent ToUnit(ElectricCurrentUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ElectricCurrent AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ElectricCurrentUnit.Ampere: - return new ElectricCurrent(_value, BaseUnit); - case ElectricCurrentUnit.Centiampere: - return new ElectricCurrent((_value) * 1e-2d, BaseUnit); - case ElectricCurrentUnit.Kiloampere: - return new ElectricCurrent((_value) * 1e3d, BaseUnit); - case ElectricCurrentUnit.Megaampere: - return new ElectricCurrent((_value) * 1e6d, BaseUnit); - case ElectricCurrentUnit.Microampere: - return new ElectricCurrent((_value) * 1e-6d, BaseUnit); - case ElectricCurrentUnit.Milliampere: - return new ElectricCurrent((_value) * 1e-3d, BaseUnit); - case ElectricCurrentUnit.Nanoampere: - return new ElectricCurrent((_value) * 1e-9d, BaseUnit); - case ElectricCurrentUnit.Picoampere: - return new ElectricCurrent((_value) * 1e-12d, BaseUnit); + case ElectricCurrentUnit.Ampere: return _value; + case ElectricCurrentUnit.Centiampere: return (_value) * 1e-2d; + case ElectricCurrentUnit.Kiloampere: return (_value) * 1e3d; + case ElectricCurrentUnit.Megaampere: return (_value) * 1e6d; + case ElectricCurrentUnit.Microampere: return (_value) * 1e-6d; + case ElectricCurrentUnit.Milliampere: return (_value) * 1e-3d; + case ElectricCurrentUnit.Nanoampere: return (_value) * 1e-9d; + case ElectricCurrentUnit.Picoampere: return (_value) * 1e-12d; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ElectricCurrentUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ElectricCurrent ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ElectricCurrent(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ElectricCurrentUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.NetFramework.g.cs index fd6feda30d..abf689e12d 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 new ElectricCurrentDensity(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static ElectricCurrentDensity operator -(ElectricCurrentDensity left, ElectricCurrentDensity right) { - return new ElectricCurrentDensity(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new ElectricCurrentDensity(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static ElectricCurrentDensity operator *(double left, ElectricCurrentDensity right) @@ -393,22 +393,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr public static bool operator <=(ElectricCurrentDensity left, ElectricCurrentDensity right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(ElectricCurrentDensity left, ElectricCurrentDensity right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(ElectricCurrentDensity left, ElectricCurrentDensity right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(ElectricCurrentDensity left, ElectricCurrentDensity right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(ElectricCurrentDensity left, ElectricCurrentDensity right) @@ -432,7 +432,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(ElectricCurrentDensity other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -445,7 +445,7 @@ public override bool Equals(object obj) public bool Equals(ElectricCurrentDensity other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -521,7 +521,7 @@ public double As(ElectricCurrentDensityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -531,7 +531,7 @@ public double As(ElectricCurrentDensityUnit unit) /// A ElectricCurrentDensity with the specified unit. public ElectricCurrentDensity ToUnit(ElectricCurrentDensityUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ElectricCurrentDensity(convertedValue, unit); } @@ -540,24 +540,33 @@ public ElectricCurrentDensity ToUnit(ElectricCurrentDensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ElectricCurrentDensity AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ElectricCurrentDensityUnit.AmperePerSquareMeter: - return new ElectricCurrentDensity(_value, BaseUnit); + case ElectricCurrentDensityUnit.AmperePerSquareMeter: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ElectricCurrentDensityUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ElectricCurrentDensity ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ElectricCurrentDensity(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ElectricCurrentDensityUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.NetFramework.g.cs index 7c242f0df8..ac3d987473 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 new ElectricCurrentGradient(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static ElectricCurrentGradient operator -(ElectricCurrentGradient left, ElectricCurrentGradient right) { - return new ElectricCurrentGradient(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new ElectricCurrentGradient(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static ElectricCurrentGradient operator *(double left, ElectricCurrentGradient right) @@ -390,22 +390,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr public static bool operator <=(ElectricCurrentGradient left, ElectricCurrentGradient right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(ElectricCurrentGradient left, ElectricCurrentGradient right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(ElectricCurrentGradient left, ElectricCurrentGradient right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(ElectricCurrentGradient left, ElectricCurrentGradient right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(ElectricCurrentGradient left, ElectricCurrentGradient right) @@ -429,7 +429,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(ElectricCurrentGradient other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -442,7 +442,7 @@ public override bool Equals(object obj) public bool Equals(ElectricCurrentGradient other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -518,7 +518,7 @@ public double As(ElectricCurrentGradientUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -528,7 +528,7 @@ public double As(ElectricCurrentGradientUnit unit) /// A ElectricCurrentGradient with the specified unit. public ElectricCurrentGradient ToUnit(ElectricCurrentGradientUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ElectricCurrentGradient(convertedValue, unit); } @@ -537,24 +537,33 @@ public ElectricCurrentGradient ToUnit(ElectricCurrentGradientUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ElectricCurrentGradient AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ElectricCurrentGradientUnit.AmperePerSecond: - return new ElectricCurrentGradient(_value, BaseUnit); + case ElectricCurrentGradientUnit.AmperePerSecond: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ElectricCurrentGradientUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ElectricCurrentGradient ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ElectricCurrentGradient(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ElectricCurrentGradientUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricField.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricField.NetFramework.g.cs index 07882f9100..4cc9af872c 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 new ElectricField(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static ElectricField operator -(ElectricField left, ElectricField right) { - return new ElectricField(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new ElectricField(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static ElectricField operator *(double left, ElectricField right) @@ -393,22 +393,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr public static bool operator <=(ElectricField left, ElectricField right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(ElectricField left, ElectricField right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(ElectricField left, ElectricField right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(ElectricField left, ElectricField right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(ElectricField left, ElectricField right) @@ -432,7 +432,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(ElectricField other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -445,7 +445,7 @@ public override bool Equals(object obj) public bool Equals(ElectricField other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -521,7 +521,7 @@ public double As(ElectricFieldUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -531,7 +531,7 @@ public double As(ElectricFieldUnit unit) /// A ElectricField with the specified unit. public ElectricField ToUnit(ElectricFieldUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ElectricField(convertedValue, unit); } @@ -540,24 +540,33 @@ public ElectricField ToUnit(ElectricFieldUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ElectricField AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ElectricFieldUnit.VoltPerMeter: - return new ElectricField(_value, BaseUnit); + case ElectricFieldUnit.VoltPerMeter: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ElectricFieldUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ElectricField ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ElectricField(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ElectricFieldUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricInductance.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricInductance.NetFramework.g.cs index 5fef7cb7d6..e464a62c75 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricInductance.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricInductance.NetFramework.g.cs @@ -401,12 +401,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 new ElectricInductance(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static ElectricInductance operator -(ElectricInductance left, ElectricInductance right) { - return new ElectricInductance(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new ElectricInductance(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static ElectricInductance operator *(double left, ElectricInductance right) @@ -435,22 +435,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr public static bool operator <=(ElectricInductance left, ElectricInductance right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(ElectricInductance left, ElectricInductance right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(ElectricInductance left, ElectricInductance right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(ElectricInductance left, ElectricInductance right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(ElectricInductance left, ElectricInductance right) @@ -474,7 +474,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(ElectricInductance other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -487,7 +487,7 @@ public override bool Equals(object obj) public bool Equals(ElectricInductance other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -563,7 +563,7 @@ public double As(ElectricInductanceUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -573,7 +573,7 @@ public double As(ElectricInductanceUnit unit) /// A ElectricInductance with the specified unit. public ElectricInductance ToUnit(ElectricInductanceUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ElectricInductance(convertedValue, unit); } @@ -582,30 +582,36 @@ public ElectricInductance ToUnit(ElectricInductanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ElectricInductance AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ElectricInductanceUnit.Henry: - return new ElectricInductance(_value, BaseUnit); - case ElectricInductanceUnit.Microhenry: - return new ElectricInductance((_value) * 1e-6d, BaseUnit); - case ElectricInductanceUnit.Millihenry: - return new ElectricInductance((_value) * 1e-3d, BaseUnit); - case ElectricInductanceUnit.Nanohenry: - return new ElectricInductance((_value) * 1e-9d, BaseUnit); + case ElectricInductanceUnit.Henry: return _value; + case ElectricInductanceUnit.Microhenry: return (_value) * 1e-6d; + case ElectricInductanceUnit.Millihenry: return (_value) * 1e-3d; + case ElectricInductanceUnit.Nanohenry: return (_value) * 1e-9d; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ElectricInductanceUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ElectricInductance ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ElectricInductance(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ElectricInductanceUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotential.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotential.NetFramework.g.cs index 76858eb10b..a7c296721b 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 new ElectricPotential(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static ElectricPotential operator -(ElectricPotential left, ElectricPotential right) { - return new ElectricPotential(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new ElectricPotential(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static ElectricPotential operator *(double left, ElectricPotential right) @@ -446,22 +446,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr public static bool operator <=(ElectricPotential left, ElectricPotential right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(ElectricPotential left, ElectricPotential right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(ElectricPotential left, ElectricPotential right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(ElectricPotential left, ElectricPotential right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(ElectricPotential left, ElectricPotential right) @@ -485,7 +485,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(ElectricPotential other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -498,7 +498,7 @@ public override bool Equals(object obj) public bool Equals(ElectricPotential other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -574,7 +574,7 @@ public double As(ElectricPotentialUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -584,7 +584,7 @@ public double As(ElectricPotentialUnit unit) /// A ElectricPotential with the specified unit. public ElectricPotential ToUnit(ElectricPotentialUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ElectricPotential(convertedValue, unit); } @@ -593,32 +593,37 @@ public ElectricPotential ToUnit(ElectricPotentialUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ElectricPotential AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ElectricPotentialUnit.Kilovolt: - return new ElectricPotential((_value) * 1e3d, BaseUnit); - case ElectricPotentialUnit.Megavolt: - return new ElectricPotential((_value) * 1e6d, BaseUnit); - case ElectricPotentialUnit.Microvolt: - return new ElectricPotential((_value) * 1e-6d, BaseUnit); - case ElectricPotentialUnit.Millivolt: - return new ElectricPotential((_value) * 1e-3d, BaseUnit); - case ElectricPotentialUnit.Volt: - return new ElectricPotential(_value, BaseUnit); + case ElectricPotentialUnit.Kilovolt: return (_value) * 1e3d; + case ElectricPotentialUnit.Megavolt: return (_value) * 1e6d; + case ElectricPotentialUnit.Microvolt: return (_value) * 1e-6d; + case ElectricPotentialUnit.Millivolt: return (_value) * 1e-3d; + case ElectricPotentialUnit.Volt: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ElectricPotentialUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ElectricPotential ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ElectricPotential(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ElectricPotentialUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialAc.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialAc.NetFramework.g.cs index 307b7e25a1..27a7db6340 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 new ElectricPotentialAc(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static ElectricPotentialAc operator -(ElectricPotentialAc left, ElectricPotentialAc right) { - return new ElectricPotentialAc(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new ElectricPotentialAc(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static ElectricPotentialAc operator *(double left, ElectricPotentialAc right) @@ -446,22 +446,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr public static bool operator <=(ElectricPotentialAc left, ElectricPotentialAc right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(ElectricPotentialAc left, ElectricPotentialAc right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(ElectricPotentialAc left, ElectricPotentialAc right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(ElectricPotentialAc left, ElectricPotentialAc right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(ElectricPotentialAc left, ElectricPotentialAc right) @@ -485,7 +485,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(ElectricPotentialAc other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -498,7 +498,7 @@ public override bool Equals(object obj) public bool Equals(ElectricPotentialAc other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -574,7 +574,7 @@ public double As(ElectricPotentialAcUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -584,7 +584,7 @@ public double As(ElectricPotentialAcUnit unit) /// A ElectricPotentialAc with the specified unit. public ElectricPotentialAc ToUnit(ElectricPotentialAcUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ElectricPotentialAc(convertedValue, unit); } @@ -593,32 +593,37 @@ public ElectricPotentialAc ToUnit(ElectricPotentialAcUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ElectricPotentialAc AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ElectricPotentialAcUnit.KilovoltAc: - return new ElectricPotentialAc((_value) * 1e3d, BaseUnit); - case ElectricPotentialAcUnit.MegavoltAc: - return new ElectricPotentialAc((_value) * 1e6d, BaseUnit); - case ElectricPotentialAcUnit.MicrovoltAc: - return new ElectricPotentialAc((_value) * 1e-6d, BaseUnit); - case ElectricPotentialAcUnit.MillivoltAc: - return new ElectricPotentialAc((_value) * 1e-3d, BaseUnit); - case ElectricPotentialAcUnit.VoltAc: - return new ElectricPotentialAc(_value, BaseUnit); + case ElectricPotentialAcUnit.KilovoltAc: return (_value) * 1e3d; + case ElectricPotentialAcUnit.MegavoltAc: return (_value) * 1e6d; + case ElectricPotentialAcUnit.MicrovoltAc: return (_value) * 1e-6d; + case ElectricPotentialAcUnit.MillivoltAc: return (_value) * 1e-3d; + case ElectricPotentialAcUnit.VoltAc: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ElectricPotentialAcUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ElectricPotentialAc ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ElectricPotentialAc(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ElectricPotentialAcUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialDc.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialDc.NetFramework.g.cs index 4602de0391..29c64f3544 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 new ElectricPotentialDc(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static ElectricPotentialDc operator -(ElectricPotentialDc left, ElectricPotentialDc right) { - return new ElectricPotentialDc(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new ElectricPotentialDc(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static ElectricPotentialDc operator *(double left, ElectricPotentialDc right) @@ -446,22 +446,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr public static bool operator <=(ElectricPotentialDc left, ElectricPotentialDc right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(ElectricPotentialDc left, ElectricPotentialDc right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(ElectricPotentialDc left, ElectricPotentialDc right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(ElectricPotentialDc left, ElectricPotentialDc right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(ElectricPotentialDc left, ElectricPotentialDc right) @@ -485,7 +485,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(ElectricPotentialDc other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -498,7 +498,7 @@ public override bool Equals(object obj) public bool Equals(ElectricPotentialDc other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -574,7 +574,7 @@ public double As(ElectricPotentialDcUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -584,7 +584,7 @@ public double As(ElectricPotentialDcUnit unit) /// A ElectricPotentialDc with the specified unit. public ElectricPotentialDc ToUnit(ElectricPotentialDcUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ElectricPotentialDc(convertedValue, unit); } @@ -593,32 +593,37 @@ public ElectricPotentialDc ToUnit(ElectricPotentialDcUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ElectricPotentialDc AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ElectricPotentialDcUnit.KilovoltDc: - return new ElectricPotentialDc((_value) * 1e3d, BaseUnit); - case ElectricPotentialDcUnit.MegavoltDc: - return new ElectricPotentialDc((_value) * 1e6d, BaseUnit); - case ElectricPotentialDcUnit.MicrovoltDc: - return new ElectricPotentialDc((_value) * 1e-6d, BaseUnit); - case ElectricPotentialDcUnit.MillivoltDc: - return new ElectricPotentialDc((_value) * 1e-3d, BaseUnit); - case ElectricPotentialDcUnit.VoltDc: - return new ElectricPotentialDc(_value, BaseUnit); + case ElectricPotentialDcUnit.KilovoltDc: return (_value) * 1e3d; + case ElectricPotentialDcUnit.MegavoltDc: return (_value) * 1e6d; + case ElectricPotentialDcUnit.MicrovoltDc: return (_value) * 1e-6d; + case ElectricPotentialDcUnit.MillivoltDc: return (_value) * 1e-3d; + case ElectricPotentialDcUnit.VoltDc: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ElectricPotentialDcUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ElectricPotentialDc ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ElectricPotentialDc(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ElectricPotentialDcUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricResistance.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricResistance.NetFramework.g.cs index 31bb712fdb..91449fd4ce 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricResistance.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricResistance.NetFramework.g.cs @@ -412,12 +412,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 new ElectricResistance(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static ElectricResistance operator -(ElectricResistance left, ElectricResistance right) { - return new ElectricResistance(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new ElectricResistance(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static ElectricResistance operator *(double left, ElectricResistance right) @@ -446,22 +446,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr public static bool operator <=(ElectricResistance left, ElectricResistance right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(ElectricResistance left, ElectricResistance right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(ElectricResistance left, ElectricResistance right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(ElectricResistance left, ElectricResistance right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(ElectricResistance left, ElectricResistance right) @@ -485,7 +485,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(ElectricResistance other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -498,7 +498,7 @@ public override bool Equals(object obj) public bool Equals(ElectricResistance other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -574,7 +574,7 @@ public double As(ElectricResistanceUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -584,7 +584,7 @@ public double As(ElectricResistanceUnit unit) /// A ElectricResistance with the specified unit. public ElectricResistance ToUnit(ElectricResistanceUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ElectricResistance(convertedValue, unit); } @@ -593,32 +593,37 @@ public ElectricResistance ToUnit(ElectricResistanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ElectricResistance AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ElectricResistanceUnit.Gigaohm: - return new ElectricResistance((_value) * 1e9d, BaseUnit); - case ElectricResistanceUnit.Kiloohm: - return new ElectricResistance((_value) * 1e3d, BaseUnit); - case ElectricResistanceUnit.Megaohm: - return new ElectricResistance((_value) * 1e6d, BaseUnit); - case ElectricResistanceUnit.Milliohm: - return new ElectricResistance((_value) * 1e-3d, BaseUnit); - case ElectricResistanceUnit.Ohm: - return new ElectricResistance(_value, BaseUnit); + case ElectricResistanceUnit.Gigaohm: return (_value) * 1e9d; + case ElectricResistanceUnit.Kiloohm: return (_value) * 1e3d; + case ElectricResistanceUnit.Megaohm: return (_value) * 1e6d; + case ElectricResistanceUnit.Milliohm: return (_value) * 1e-3d; + case ElectricResistanceUnit.Ohm: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ElectricResistanceUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ElectricResistance ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ElectricResistance(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ElectricResistanceUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.NetFramework.g.cs index c4233349cb..eadc9b80c4 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.NetFramework.g.cs @@ -541,12 +541,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 new ElectricResistivity(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static ElectricResistivity operator -(ElectricResistivity left, ElectricResistivity right) { - return new ElectricResistivity(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new ElectricResistivity(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static ElectricResistivity operator *(double left, ElectricResistivity right) @@ -575,22 +575,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Electr public static bool operator <=(ElectricResistivity left, ElectricResistivity right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(ElectricResistivity left, ElectricResistivity right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(ElectricResistivity left, ElectricResistivity right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(ElectricResistivity left, ElectricResistivity right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(ElectricResistivity left, ElectricResistivity right) @@ -614,7 +614,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(ElectricResistivity other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -627,7 +627,7 @@ public override bool Equals(object obj) public bool Equals(ElectricResistivity other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -703,7 +703,7 @@ public double As(ElectricResistivityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -713,7 +713,7 @@ public double As(ElectricResistivityUnit unit) /// A ElectricResistivity with the specified unit. public ElectricResistivity ToUnit(ElectricResistivityUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ElectricResistivity(convertedValue, unit); } @@ -722,50 +722,46 @@ public ElectricResistivity ToUnit(ElectricResistivityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ElectricResistivity AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ElectricResistivityUnit.KiloohmCentimeter: - return new ElectricResistivity((_value/100) * 1e3d, BaseUnit); - case ElectricResistivityUnit.KiloohmMeter: - return new ElectricResistivity((_value) * 1e3d, BaseUnit); - case ElectricResistivityUnit.MegaohmCentimeter: - return new ElectricResistivity((_value/100) * 1e6d, BaseUnit); - case ElectricResistivityUnit.MegaohmMeter: - return new ElectricResistivity((_value) * 1e6d, BaseUnit); - case ElectricResistivityUnit.MicroohmCentimeter: - return new ElectricResistivity((_value/100) * 1e-6d, BaseUnit); - case ElectricResistivityUnit.MicroohmMeter: - return new ElectricResistivity((_value) * 1e-6d, BaseUnit); - case ElectricResistivityUnit.MilliohmCentimeter: - return new ElectricResistivity((_value/100) * 1e-3d, BaseUnit); - case ElectricResistivityUnit.MilliohmMeter: - return new ElectricResistivity((_value) * 1e-3d, BaseUnit); - case ElectricResistivityUnit.NanoohmCentimeter: - return new ElectricResistivity((_value/100) * 1e-9d, BaseUnit); - case ElectricResistivityUnit.NanoohmMeter: - return new ElectricResistivity((_value) * 1e-9d, BaseUnit); - case ElectricResistivityUnit.OhmCentimeter: - return new ElectricResistivity(_value/100, BaseUnit); - case ElectricResistivityUnit.OhmMeter: - return new ElectricResistivity(_value, BaseUnit); - case ElectricResistivityUnit.PicoohmCentimeter: - return new ElectricResistivity((_value/100) * 1e-12d, BaseUnit); - case ElectricResistivityUnit.PicoohmMeter: - return new ElectricResistivity((_value) * 1e-12d, BaseUnit); + case ElectricResistivityUnit.KiloohmCentimeter: return (_value/100) * 1e3d; + case ElectricResistivityUnit.KiloohmMeter: return (_value) * 1e3d; + case ElectricResistivityUnit.MegaohmCentimeter: return (_value/100) * 1e6d; + case ElectricResistivityUnit.MegaohmMeter: return (_value) * 1e6d; + case ElectricResistivityUnit.MicroohmCentimeter: return (_value/100) * 1e-6d; + case ElectricResistivityUnit.MicroohmMeter: return (_value) * 1e-6d; + case ElectricResistivityUnit.MilliohmCentimeter: return (_value/100) * 1e-3d; + case ElectricResistivityUnit.MilliohmMeter: return (_value) * 1e-3d; + case ElectricResistivityUnit.NanoohmCentimeter: return (_value/100) * 1e-9d; + case ElectricResistivityUnit.NanoohmMeter: return (_value) * 1e-9d; + case ElectricResistivityUnit.OhmCentimeter: return _value/100; + case ElectricResistivityUnit.OhmMeter: return _value; + case ElectricResistivityUnit.PicoohmCentimeter: return (_value/100) * 1e-12d; + case ElectricResistivityUnit.PicoohmMeter: return (_value) * 1e-12d; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ElectricResistivityUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ElectricResistivity ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ElectricResistivity(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ElectricResistivityUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Energy.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Energy.NetFramework.g.cs index f3a5850fa7..0ffebfabf5 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 new Energy(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static Energy operator -(Energy left, Energy right) { - return new Energy(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new Energy(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static Energy operator *(double left, Energy right) @@ -684,22 +684,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Energy public static bool operator <=(Energy left, Energy right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(Energy left, Energy right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(Energy left, Energy right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(Energy left, Energy right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(Energy left, Energy right) @@ -723,7 +723,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(Energy other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -736,7 +736,7 @@ public override bool Equals(object obj) public bool Equals(Energy other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -812,7 +812,7 @@ public double As(EnergyUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -822,7 +822,7 @@ public double As(EnergyUnit unit) /// A Energy with the specified unit. public Energy ToUnit(EnergyUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Energy(convertedValue, unit); } @@ -831,66 +831,54 @@ public Energy ToUnit(EnergyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Energy AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case EnergyUnit.BritishThermalUnit: - return new Energy(_value*1055.05585262, BaseUnit); - case EnergyUnit.Calorie: - return new Energy(_value*4.184, BaseUnit); - case EnergyUnit.DecathermEc: - return new Energy((_value*1.05505585262e8) * 1e1d, BaseUnit); - case EnergyUnit.DecathermImperial: - return new Energy((_value*1.05505585257348e8) * 1e1d, BaseUnit); - case EnergyUnit.DecathermUs: - return new Energy((_value*1.054804e8) * 1e1d, BaseUnit); - case EnergyUnit.ElectronVolt: - return new Energy(_value*1.602176565e-19, BaseUnit); - case EnergyUnit.Erg: - return new Energy(_value*1e-7, BaseUnit); - case EnergyUnit.FootPound: - return new Energy(_value*1.355817948, BaseUnit); - case EnergyUnit.GigabritishThermalUnit: - return new Energy((_value*1055.05585262) * 1e9d, BaseUnit); - case EnergyUnit.GigawattHour: - return new Energy((_value*3600d) * 1e9d, BaseUnit); - case EnergyUnit.Joule: - return new Energy(_value, BaseUnit); - case EnergyUnit.KilobritishThermalUnit: - return new Energy((_value*1055.05585262) * 1e3d, BaseUnit); - case EnergyUnit.Kilocalorie: - return new Energy((_value*4.184) * 1e3d, BaseUnit); - case EnergyUnit.Kilojoule: - return new Energy((_value) * 1e3d, BaseUnit); - case EnergyUnit.KilowattHour: - return new Energy((_value*3600d) * 1e3d, BaseUnit); - case EnergyUnit.MegabritishThermalUnit: - return new Energy((_value*1055.05585262) * 1e6d, BaseUnit); - case EnergyUnit.Megajoule: - return new Energy((_value) * 1e6d, BaseUnit); - case EnergyUnit.MegawattHour: - return new Energy((_value*3600d) * 1e6d, BaseUnit); - case EnergyUnit.ThermEc: - return new Energy(_value*1.05505585262e8, BaseUnit); - case EnergyUnit.ThermImperial: - return new Energy(_value*1.05505585257348e8, BaseUnit); - case EnergyUnit.ThermUs: - return new Energy(_value*1.054804e8, BaseUnit); - case EnergyUnit.WattHour: - return new Energy(_value*3600d, BaseUnit); + case EnergyUnit.BritishThermalUnit: return _value*1055.05585262; + case EnergyUnit.Calorie: return _value*4.184; + case EnergyUnit.DecathermEc: return (_value*1.05505585262e8) * 1e1d; + case EnergyUnit.DecathermImperial: return (_value*1.05505585257348e8) * 1e1d; + case EnergyUnit.DecathermUs: return (_value*1.054804e8) * 1e1d; + case EnergyUnit.ElectronVolt: return _value*1.602176565e-19; + case EnergyUnit.Erg: return _value*1e-7; + case EnergyUnit.FootPound: return _value*1.355817948; + case EnergyUnit.GigabritishThermalUnit: return (_value*1055.05585262) * 1e9d; + case EnergyUnit.GigawattHour: return (_value*3600d) * 1e9d; + case EnergyUnit.Joule: return _value; + case EnergyUnit.KilobritishThermalUnit: return (_value*1055.05585262) * 1e3d; + case EnergyUnit.Kilocalorie: return (_value*4.184) * 1e3d; + case EnergyUnit.Kilojoule: return (_value) * 1e3d; + case EnergyUnit.KilowattHour: return (_value*3600d) * 1e3d; + case EnergyUnit.MegabritishThermalUnit: return (_value*1055.05585262) * 1e6d; + case EnergyUnit.Megajoule: return (_value) * 1e6d; + case EnergyUnit.MegawattHour: return (_value*3600d) * 1e6d; + case EnergyUnit.ThermEc: return _value*1.05505585262e8; + case EnergyUnit.ThermImperial: return _value*1.05505585257348e8; + case EnergyUnit.ThermUs: return _value*1.054804e8; + case EnergyUnit.WattHour: return _value*3600d; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(EnergyUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Energy ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Energy(baseUnitValue, BaseUnit); + } + + private double GetValueAs(EnergyUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Entropy.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Entropy.NetFramework.g.cs index 6103be5357..13b6b99ed5 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 new Entropy(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static Entropy operator -(Entropy left, Entropy right) { - return new Entropy(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new Entropy(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static Entropy operator *(double left, Entropy right) @@ -474,22 +474,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Entrop public static bool operator <=(Entropy left, Entropy right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(Entropy left, Entropy right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(Entropy left, Entropy right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(Entropy left, Entropy right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(Entropy left, Entropy right) @@ -513,7 +513,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(Entropy other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -526,7 +526,7 @@ public override bool Equals(object obj) public bool Equals(Entropy other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -602,7 +602,7 @@ public double As(EntropyUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -612,7 +612,7 @@ public double As(EntropyUnit unit) /// A Entropy with the specified unit. public Entropy ToUnit(EntropyUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Entropy(convertedValue, unit); } @@ -621,36 +621,39 @@ public Entropy ToUnit(EntropyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Entropy AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case EntropyUnit.CaloriePerKelvin: - return new Entropy(_value*4.184, BaseUnit); - case EntropyUnit.JoulePerDegreeCelsius: - return new Entropy(_value, BaseUnit); - case EntropyUnit.JoulePerKelvin: - return new Entropy(_value, BaseUnit); - case EntropyUnit.KilocaloriePerKelvin: - return new Entropy((_value*4.184) * 1e3d, BaseUnit); - case EntropyUnit.KilojoulePerDegreeCelsius: - return new Entropy((_value) * 1e3d, BaseUnit); - case EntropyUnit.KilojoulePerKelvin: - return new Entropy((_value) * 1e3d, BaseUnit); - case EntropyUnit.MegajoulePerKelvin: - return new Entropy((_value) * 1e6d, BaseUnit); + case EntropyUnit.CaloriePerKelvin: return _value*4.184; + case EntropyUnit.JoulePerDegreeCelsius: return _value; + case EntropyUnit.JoulePerKelvin: return _value; + case EntropyUnit.KilocaloriePerKelvin: return (_value*4.184) * 1e3d; + case EntropyUnit.KilojoulePerDegreeCelsius: return (_value) * 1e3d; + case EntropyUnit.KilojoulePerKelvin: return (_value) * 1e3d; + case EntropyUnit.MegajoulePerKelvin: return (_value) * 1e6d; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(EntropyUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Entropy ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Entropy(baseUnitValue, BaseUnit); + } + + private double GetValueAs(EntropyUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Force.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Force.NetFramework.g.cs index 99a8c417e1..ad953bbd7f 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 new Force(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static Force operator -(Force left, Force right) { - return new Force(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new Force(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static Force operator *(double left, Force right) @@ -558,22 +558,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out ForceU public static bool operator <=(Force left, Force right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(Force left, Force right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(Force left, Force right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(Force left, Force right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(Force left, Force right) @@ -597,7 +597,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(Force other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -610,7 +610,7 @@ public override bool Equals(object obj) public bool Equals(Force other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -686,7 +686,7 @@ public double As(ForceUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -696,7 +696,7 @@ public double As(ForceUnit unit) /// A Force with the specified unit. public Force ToUnit(ForceUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Force(convertedValue, unit); } @@ -705,48 +705,45 @@ public Force ToUnit(ForceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Force AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ForceUnit.Decanewton: - return new Force((_value) * 1e1d, BaseUnit); - case ForceUnit.Dyn: - return new Force(_value/1e5, BaseUnit); - case ForceUnit.KilogramForce: - return new Force(_value*9.80665002864, BaseUnit); - case ForceUnit.Kilonewton: - return new Force((_value) * 1e3d, BaseUnit); - case ForceUnit.KiloPond: - return new Force(_value*9.80665002864, BaseUnit); - case ForceUnit.Meganewton: - return new Force((_value) * 1e6d, BaseUnit); - case ForceUnit.Micronewton: - return new Force((_value) * 1e-6d, BaseUnit); - case ForceUnit.Millinewton: - return new Force((_value) * 1e-3d, BaseUnit); - case ForceUnit.Newton: - return new Force(_value, BaseUnit); - case ForceUnit.OunceForce: - return new Force(_value*2.780138509537812e-1, BaseUnit); - case ForceUnit.Poundal: - return new Force(_value*0.13825502798973041652092282466083, BaseUnit); - case ForceUnit.PoundForce: - return new Force(_value*4.4482216152605095551842641431421, BaseUnit); - case ForceUnit.TonneForce: - return new Force(_value*9.80665002864e3, BaseUnit); + case ForceUnit.Decanewton: return (_value) * 1e1d; + case ForceUnit.Dyn: return _value/1e5; + case ForceUnit.KilogramForce: return _value*9.80665002864; + case ForceUnit.Kilonewton: return (_value) * 1e3d; + case ForceUnit.KiloPond: return _value*9.80665002864; + case ForceUnit.Meganewton: return (_value) * 1e6d; + case ForceUnit.Micronewton: return (_value) * 1e-6d; + case ForceUnit.Millinewton: return (_value) * 1e-3d; + case ForceUnit.Newton: return _value; + case ForceUnit.OunceForce: return _value*2.780138509537812e-1; + case ForceUnit.Poundal: return _value*0.13825502798973041652092282466083; + case ForceUnit.PoundForce: return _value*4.4482216152605095551842641431421; + case ForceUnit.TonneForce: return _value*9.80665002864e3; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ForceUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Force ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Force(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ForceUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.NetFramework.g.cs index 688a394d8b..6aed50bb22 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 new ForceChangeRate(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static ForceChangeRate operator -(ForceChangeRate left, ForceChangeRate right) { - return new ForceChangeRate(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new ForceChangeRate(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static ForceChangeRate operator *(double left, ForceChangeRate right) @@ -530,22 +530,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out ForceC public static bool operator <=(ForceChangeRate left, ForceChangeRate right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(ForceChangeRate left, ForceChangeRate right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(ForceChangeRate left, ForceChangeRate right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(ForceChangeRate left, ForceChangeRate right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(ForceChangeRate left, ForceChangeRate right) @@ -569,7 +569,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(ForceChangeRate other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -582,7 +582,7 @@ public override bool Equals(object obj) public bool Equals(ForceChangeRate other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -658,7 +658,7 @@ public double As(ForceChangeRateUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -668,7 +668,7 @@ public double As(ForceChangeRateUnit unit) /// A ForceChangeRate with the specified unit. public ForceChangeRate ToUnit(ForceChangeRateUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ForceChangeRate(convertedValue, unit); } @@ -677,44 +677,43 @@ public ForceChangeRate ToUnit(ForceChangeRateUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ForceChangeRate AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ForceChangeRateUnit.CentinewtonPerSecond: - return new ForceChangeRate((_value) * 1e-2d, BaseUnit); - case ForceChangeRateUnit.DecanewtonPerMinute: - return new ForceChangeRate((_value/60) * 1e1d, BaseUnit); - case ForceChangeRateUnit.DecanewtonPerSecond: - return new ForceChangeRate((_value) * 1e1d, BaseUnit); - case ForceChangeRateUnit.DecinewtonPerSecond: - return new ForceChangeRate((_value) * 1e-1d, BaseUnit); - case ForceChangeRateUnit.KilonewtonPerMinute: - return new ForceChangeRate((_value/60) * 1e3d, BaseUnit); - case ForceChangeRateUnit.KilonewtonPerSecond: - return new ForceChangeRate((_value) * 1e3d, BaseUnit); - case ForceChangeRateUnit.MicronewtonPerSecond: - return new ForceChangeRate((_value) * 1e-6d, BaseUnit); - case ForceChangeRateUnit.MillinewtonPerSecond: - return new ForceChangeRate((_value) * 1e-3d, BaseUnit); - case ForceChangeRateUnit.NanonewtonPerSecond: - return new ForceChangeRate((_value) * 1e-9d, BaseUnit); - case ForceChangeRateUnit.NewtonPerMinute: - return new ForceChangeRate(_value/60, BaseUnit); - case ForceChangeRateUnit.NewtonPerSecond: - return new ForceChangeRate(_value, BaseUnit); + case ForceChangeRateUnit.CentinewtonPerSecond: return (_value) * 1e-2d; + case ForceChangeRateUnit.DecanewtonPerMinute: return (_value/60) * 1e1d; + case ForceChangeRateUnit.DecanewtonPerSecond: return (_value) * 1e1d; + case ForceChangeRateUnit.DecinewtonPerSecond: return (_value) * 1e-1d; + case ForceChangeRateUnit.KilonewtonPerMinute: return (_value/60) * 1e3d; + case ForceChangeRateUnit.KilonewtonPerSecond: return (_value) * 1e3d; + case ForceChangeRateUnit.MicronewtonPerSecond: return (_value) * 1e-6d; + case ForceChangeRateUnit.MillinewtonPerSecond: return (_value) * 1e-3d; + case ForceChangeRateUnit.NanonewtonPerSecond: return (_value) * 1e-9d; + case ForceChangeRateUnit.NewtonPerMinute: return _value/60; + case ForceChangeRateUnit.NewtonPerSecond: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ForceChangeRateUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ForceChangeRate ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ForceChangeRate(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ForceChangeRateUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ForcePerLength.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ForcePerLength.NetFramework.g.cs index 6f34587c4b..93f6a4e877 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 new ForcePerLength(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static ForcePerLength operator -(ForcePerLength left, ForcePerLength right) { - return new ForcePerLength(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new ForcePerLength(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static ForcePerLength operator *(double left, ForcePerLength right) @@ -502,22 +502,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out ForceP public static bool operator <=(ForcePerLength left, ForcePerLength right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(ForcePerLength left, ForcePerLength right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(ForcePerLength left, ForcePerLength right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(ForcePerLength left, ForcePerLength right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(ForcePerLength left, ForcePerLength right) @@ -541,7 +541,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(ForcePerLength other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -554,7 +554,7 @@ public override bool Equals(object obj) public bool Equals(ForcePerLength other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -630,7 +630,7 @@ public double As(ForcePerLengthUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -640,7 +640,7 @@ public double As(ForcePerLengthUnit unit) /// A ForcePerLength with the specified unit. public ForcePerLength ToUnit(ForcePerLengthUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ForcePerLength(convertedValue, unit); } @@ -649,40 +649,41 @@ public ForcePerLength ToUnit(ForcePerLengthUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ForcePerLength AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ForcePerLengthUnit.CentinewtonPerMeter: - return new ForcePerLength((_value) * 1e-2d, BaseUnit); - case ForcePerLengthUnit.DecinewtonPerMeter: - return new ForcePerLength((_value) * 1e-1d, BaseUnit); - case ForcePerLengthUnit.KilogramForcePerMeter: - return new ForcePerLength(_value*9.80665002864, BaseUnit); - case ForcePerLengthUnit.KilonewtonPerMeter: - return new ForcePerLength((_value) * 1e3d, BaseUnit); - case ForcePerLengthUnit.MeganewtonPerMeter: - return new ForcePerLength((_value) * 1e6d, BaseUnit); - case ForcePerLengthUnit.MicronewtonPerMeter: - return new ForcePerLength((_value) * 1e-6d, BaseUnit); - case ForcePerLengthUnit.MillinewtonPerMeter: - return new ForcePerLength((_value) * 1e-3d, BaseUnit); - case ForcePerLengthUnit.NanonewtonPerMeter: - return new ForcePerLength((_value) * 1e-9d, BaseUnit); - case ForcePerLengthUnit.NewtonPerMeter: - return new ForcePerLength(_value, BaseUnit); + case ForcePerLengthUnit.CentinewtonPerMeter: return (_value) * 1e-2d; + case ForcePerLengthUnit.DecinewtonPerMeter: return (_value) * 1e-1d; + case ForcePerLengthUnit.KilogramForcePerMeter: return _value*9.80665002864; + case ForcePerLengthUnit.KilonewtonPerMeter: return (_value) * 1e3d; + case ForcePerLengthUnit.MeganewtonPerMeter: return (_value) * 1e6d; + case ForcePerLengthUnit.MicronewtonPerMeter: return (_value) * 1e-6d; + case ForcePerLengthUnit.MillinewtonPerMeter: return (_value) * 1e-3d; + case ForcePerLengthUnit.NanonewtonPerMeter: return (_value) * 1e-9d; + case ForcePerLengthUnit.NewtonPerMeter: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ForcePerLengthUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ForcePerLength ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ForcePerLength(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ForcePerLengthUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Frequency.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Frequency.NetFramework.g.cs index e8cd88dbf9..bd1cb29b50 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 new Frequency(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static Frequency operator -(Frequency left, Frequency right) { - return new Frequency(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new Frequency(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static Frequency operator *(double left, Frequency right) @@ -488,22 +488,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Freque public static bool operator <=(Frequency left, Frequency right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(Frequency left, Frequency right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(Frequency left, Frequency right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(Frequency left, Frequency right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(Frequency left, Frequency right) @@ -527,7 +527,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(Frequency other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -540,7 +540,7 @@ public override bool Equals(object obj) public bool Equals(Frequency other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -616,7 +616,7 @@ public double As(FrequencyUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -626,7 +626,7 @@ public double As(FrequencyUnit unit) /// A Frequency with the specified unit. public Frequency ToUnit(FrequencyUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Frequency(convertedValue, unit); } @@ -635,38 +635,40 @@ public Frequency ToUnit(FrequencyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Frequency AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case FrequencyUnit.CyclePerHour: - return new Frequency(_value/3600, BaseUnit); - case FrequencyUnit.CyclePerMinute: - return new Frequency(_value/60, BaseUnit); - case FrequencyUnit.Gigahertz: - return new Frequency((_value) * 1e9d, BaseUnit); - case FrequencyUnit.Hertz: - return new Frequency(_value, BaseUnit); - case FrequencyUnit.Kilohertz: - return new Frequency((_value) * 1e3d, BaseUnit); - case FrequencyUnit.Megahertz: - return new Frequency((_value) * 1e6d, BaseUnit); - case FrequencyUnit.RadianPerSecond: - return new Frequency(_value/6.2831853072, BaseUnit); - case FrequencyUnit.Terahertz: - return new Frequency((_value) * 1e12d, BaseUnit); + case FrequencyUnit.CyclePerHour: return _value/3600; + case FrequencyUnit.CyclePerMinute: return _value/60; + case FrequencyUnit.Gigahertz: return (_value) * 1e9d; + case FrequencyUnit.Hertz: return _value; + case FrequencyUnit.Kilohertz: return (_value) * 1e3d; + case FrequencyUnit.Megahertz: return (_value) * 1e6d; + case FrequencyUnit.RadianPerSecond: return _value/6.2831853072; + case FrequencyUnit.Terahertz: return (_value) * 1e12d; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(FrequencyUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Frequency ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Frequency(baseUnitValue, BaseUnit); + } + + private double GetValueAs(FrequencyUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/HeatFlux.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/HeatFlux.NetFramework.g.cs index ba83b69d86..5847cd0856 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 new HeatFlux(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static HeatFlux operator -(HeatFlux left, HeatFlux right) { - return new HeatFlux(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new HeatFlux(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static HeatFlux operator *(double left, HeatFlux right) @@ -628,22 +628,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out HeatFl public static bool operator <=(HeatFlux left, HeatFlux right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(HeatFlux left, HeatFlux right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(HeatFlux left, HeatFlux right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(HeatFlux left, HeatFlux right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(HeatFlux left, HeatFlux right) @@ -667,7 +667,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(HeatFlux other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -680,7 +680,7 @@ public override bool Equals(object obj) public bool Equals(HeatFlux other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -756,7 +756,7 @@ public double As(HeatFluxUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -766,7 +766,7 @@ public double As(HeatFluxUnit unit) /// A HeatFlux with the specified unit. public HeatFlux ToUnit(HeatFluxUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new HeatFlux(convertedValue, unit); } @@ -775,58 +775,50 @@ public HeatFlux ToUnit(HeatFluxUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal HeatFlux AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case HeatFluxUnit.BtuPerHourSquareFoot: - return new HeatFlux(_value*3.15459075, BaseUnit); - case HeatFluxUnit.BtuPerMinuteSquareFoot: - return new HeatFlux(_value*1.89275445e2, BaseUnit); - case HeatFluxUnit.BtuPerSecondSquareFoot: - return new HeatFlux(_value*1.13565267e4, BaseUnit); - case HeatFluxUnit.BtuPerSecondSquareInch: - return new HeatFlux(_value*1.63533984e6, BaseUnit); - case HeatFluxUnit.CaloriePerSecondSquareCentimeter: - return new HeatFlux(_value*4.1868e4, BaseUnit); - case HeatFluxUnit.CentiwattPerSquareMeter: - return new HeatFlux((_value) * 1e-2d, BaseUnit); - case HeatFluxUnit.DeciwattPerSquareMeter: - return new HeatFlux((_value) * 1e-1d, BaseUnit); - case HeatFluxUnit.KilocaloriePerHourSquareMeter: - return new HeatFlux(_value*1.163, BaseUnit); - case HeatFluxUnit.KilocaloriePerSecondSquareCentimeter: - return new HeatFlux((_value*4.1868e4) * 1e3d, BaseUnit); - case HeatFluxUnit.KilowattPerSquareMeter: - return new HeatFlux((_value) * 1e3d, BaseUnit); - case HeatFluxUnit.MicrowattPerSquareMeter: - return new HeatFlux((_value) * 1e-6d, BaseUnit); - case HeatFluxUnit.MilliwattPerSquareMeter: - return new HeatFlux((_value) * 1e-3d, BaseUnit); - case HeatFluxUnit.NanowattPerSquareMeter: - return new HeatFlux((_value) * 1e-9d, BaseUnit); - case HeatFluxUnit.PoundForcePerFootSecond: - return new HeatFlux(_value*1.459390293720636e1, BaseUnit); - case HeatFluxUnit.PoundPerSecondCubed: - return new HeatFlux(_value*4.5359237e-1, BaseUnit); - case HeatFluxUnit.WattPerSquareFoot: - return new HeatFlux(_value*1.07639e1, BaseUnit); - case HeatFluxUnit.WattPerSquareInch: - return new HeatFlux(_value*1.5500031e3, BaseUnit); - case HeatFluxUnit.WattPerSquareMeter: - return new HeatFlux(_value, BaseUnit); + case HeatFluxUnit.BtuPerHourSquareFoot: return _value*3.15459075; + case HeatFluxUnit.BtuPerMinuteSquareFoot: return _value*1.89275445e2; + case HeatFluxUnit.BtuPerSecondSquareFoot: return _value*1.13565267e4; + case HeatFluxUnit.BtuPerSecondSquareInch: return _value*1.63533984e6; + case HeatFluxUnit.CaloriePerSecondSquareCentimeter: return _value*4.1868e4; + case HeatFluxUnit.CentiwattPerSquareMeter: return (_value) * 1e-2d; + case HeatFluxUnit.DeciwattPerSquareMeter: return (_value) * 1e-1d; + case HeatFluxUnit.KilocaloriePerHourSquareMeter: return _value*1.163; + case HeatFluxUnit.KilocaloriePerSecondSquareCentimeter: return (_value*4.1868e4) * 1e3d; + case HeatFluxUnit.KilowattPerSquareMeter: return (_value) * 1e3d; + case HeatFluxUnit.MicrowattPerSquareMeter: return (_value) * 1e-6d; + case HeatFluxUnit.MilliwattPerSquareMeter: return (_value) * 1e-3d; + case HeatFluxUnit.NanowattPerSquareMeter: return (_value) * 1e-9d; + case HeatFluxUnit.PoundForcePerFootSecond: return _value*1.459390293720636e1; + case HeatFluxUnit.PoundPerSecondCubed: return _value*4.5359237e-1; + case HeatFluxUnit.WattPerSquareFoot: return _value*1.07639e1; + case HeatFluxUnit.WattPerSquareInch: return _value*1.5500031e3; + case HeatFluxUnit.WattPerSquareMeter: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(HeatFluxUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal HeatFlux ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new HeatFlux(baseUnitValue, BaseUnit); + } + + private double GetValueAs(HeatFluxUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.NetFramework.g.cs index ce5317406e..4854e82ab4 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 new HeatTransferCoefficient(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static HeatTransferCoefficient operator -(HeatTransferCoefficient left, HeatTransferCoefficient right) { - return new HeatTransferCoefficient(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new HeatTransferCoefficient(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static HeatTransferCoefficient operator *(double left, HeatTransferCoefficient right) @@ -404,22 +404,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out HeatTr public static bool operator <=(HeatTransferCoefficient left, HeatTransferCoefficient right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(HeatTransferCoefficient left, HeatTransferCoefficient right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(HeatTransferCoefficient left, HeatTransferCoefficient right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(HeatTransferCoefficient left, HeatTransferCoefficient right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(HeatTransferCoefficient left, HeatTransferCoefficient right) @@ -443,7 +443,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(HeatTransferCoefficient other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -456,7 +456,7 @@ public override bool Equals(object obj) public bool Equals(HeatTransferCoefficient other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -532,7 +532,7 @@ public double As(HeatTransferCoefficientUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -542,7 +542,7 @@ public double As(HeatTransferCoefficientUnit unit) /// A HeatTransferCoefficient with the specified unit. public HeatTransferCoefficient ToUnit(HeatTransferCoefficientUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new HeatTransferCoefficient(convertedValue, unit); } @@ -551,26 +551,34 @@ public HeatTransferCoefficient ToUnit(HeatTransferCoefficientUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal HeatTransferCoefficient AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case HeatTransferCoefficientUnit.WattPerSquareMeterCelsius: - return new HeatTransferCoefficient(_value, BaseUnit); - case HeatTransferCoefficientUnit.WattPerSquareMeterKelvin: - return new HeatTransferCoefficient(_value, BaseUnit); + case HeatTransferCoefficientUnit.WattPerSquareMeterCelsius: return _value; + case HeatTransferCoefficientUnit.WattPerSquareMeterKelvin: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(HeatTransferCoefficientUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal HeatTransferCoefficient ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new HeatTransferCoefficient(baseUnitValue, BaseUnit); + } + + private double GetValueAs(HeatTransferCoefficientUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Illuminance.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Illuminance.NetFramework.g.cs index 74abea1524..cde6bcbe01 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 new Illuminance(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static Illuminance operator -(Illuminance left, Illuminance right) { - return new Illuminance(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new Illuminance(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static Illuminance operator *(double left, Illuminance right) @@ -435,22 +435,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Illumi public static bool operator <=(Illuminance left, Illuminance right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(Illuminance left, Illuminance right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(Illuminance left, Illuminance right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(Illuminance left, Illuminance right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(Illuminance left, Illuminance right) @@ -474,7 +474,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(Illuminance other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -487,7 +487,7 @@ public override bool Equals(object obj) public bool Equals(Illuminance other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -563,7 +563,7 @@ public double As(IlluminanceUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -573,7 +573,7 @@ public double As(IlluminanceUnit unit) /// A Illuminance with the specified unit. public Illuminance ToUnit(IlluminanceUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Illuminance(convertedValue, unit); } @@ -582,30 +582,36 @@ public Illuminance ToUnit(IlluminanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Illuminance AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case IlluminanceUnit.Kilolux: - return new Illuminance((_value) * 1e3d, BaseUnit); - case IlluminanceUnit.Lux: - return new Illuminance(_value, BaseUnit); - case IlluminanceUnit.Megalux: - return new Illuminance((_value) * 1e6d, BaseUnit); - case IlluminanceUnit.Millilux: - return new Illuminance((_value) * 1e-3d, BaseUnit); + case IlluminanceUnit.Kilolux: return (_value) * 1e3d; + case IlluminanceUnit.Lux: return _value; + case IlluminanceUnit.Megalux: return (_value) * 1e6d; + case IlluminanceUnit.Millilux: return (_value) * 1e-3d; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(IlluminanceUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Illuminance ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Illuminance(baseUnitValue, BaseUnit); + } + + private double GetValueAs(IlluminanceUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Information.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Information.NetFramework.g.cs index b12a951e26..814bff05d6 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 new Information(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static Information operator -(Information left, Information right) { - return new Information(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new Information(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static Information operator *(decimal left, Information right) @@ -740,22 +740,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Inform public static bool operator <=(Information left, Information right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(Information left, Information right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(Information left, Information right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(Information left, Information right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(Information left, Information right) @@ -779,7 +779,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(Information other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -792,7 +792,7 @@ public override bool Equals(object obj) public bool Equals(Information other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -868,7 +868,7 @@ public double As(InformationUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -878,7 +878,7 @@ public double As(InformationUnit unit) /// A Information with the specified unit. public Information ToUnit(InformationUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Information(convertedValue, unit); } @@ -887,74 +887,58 @@ public Information ToUnit(InformationUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Information AsBaseUnit() + private decimal GetValueInBaseUnit() { switch(Unit) { - case InformationUnit.Bit: - return new Information(_value, BaseUnit); - case InformationUnit.Byte: - return new Information(_value*8m, BaseUnit); - case InformationUnit.Exabit: - return new Information((_value) * 1e18m, BaseUnit); - case InformationUnit.Exabyte: - return new Information((_value*8m) * 1e18m, BaseUnit); - case InformationUnit.Exbibit: - return new Information((_value) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024), BaseUnit); - case InformationUnit.Exbibyte: - return new Information((_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024), BaseUnit); - case InformationUnit.Gibibit: - return new Information((_value) * (1024m * 1024 * 1024), BaseUnit); - case InformationUnit.Gibibyte: - return new Information((_value*8m) * (1024m * 1024 * 1024), BaseUnit); - case InformationUnit.Gigabit: - return new Information((_value) * 1e9m, BaseUnit); - case InformationUnit.Gigabyte: - return new Information((_value*8m) * 1e9m, BaseUnit); - case InformationUnit.Kibibit: - return new Information((_value) * 1024m, BaseUnit); - case InformationUnit.Kibibyte: - return new Information((_value*8m) * 1024m, BaseUnit); - case InformationUnit.Kilobit: - return new Information((_value) * 1e3m, BaseUnit); - case InformationUnit.Kilobyte: - return new Information((_value*8m) * 1e3m, BaseUnit); - case InformationUnit.Mebibit: - return new Information((_value) * (1024m * 1024), BaseUnit); - case InformationUnit.Mebibyte: - return new Information((_value*8m) * (1024m * 1024), BaseUnit); - case InformationUnit.Megabit: - return new Information((_value) * 1e6m, BaseUnit); - case InformationUnit.Megabyte: - return new Information((_value*8m) * 1e6m, BaseUnit); - case InformationUnit.Pebibit: - return new Information((_value) * (1024m * 1024 * 1024 * 1024 * 1024), BaseUnit); - case InformationUnit.Pebibyte: - return new Information((_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024), BaseUnit); - case InformationUnit.Petabit: - return new Information((_value) * 1e15m, BaseUnit); - case InformationUnit.Petabyte: - return new Information((_value*8m) * 1e15m, BaseUnit); - case InformationUnit.Tebibit: - return new Information((_value) * (1024m * 1024 * 1024 * 1024), BaseUnit); - case InformationUnit.Tebibyte: - return new Information((_value*8m) * (1024m * 1024 * 1024 * 1024), BaseUnit); - case InformationUnit.Terabit: - return new Information((_value) * 1e12m, BaseUnit); - case InformationUnit.Terabyte: - return new Information((_value*8m) * 1e12m, BaseUnit); + case InformationUnit.Bit: return _value; + case InformationUnit.Byte: return _value*8m; + case InformationUnit.Exabit: return (_value) * 1e18m; + case InformationUnit.Exabyte: return (_value*8m) * 1e18m; + case InformationUnit.Exbibit: return (_value) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024); + case InformationUnit.Exbibyte: return (_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024); + case InformationUnit.Gibibit: return (_value) * (1024m * 1024 * 1024); + case InformationUnit.Gibibyte: return (_value*8m) * (1024m * 1024 * 1024); + case InformationUnit.Gigabit: return (_value) * 1e9m; + case InformationUnit.Gigabyte: return (_value*8m) * 1e9m; + case InformationUnit.Kibibit: return (_value) * 1024m; + case InformationUnit.Kibibyte: return (_value*8m) * 1024m; + case InformationUnit.Kilobit: return (_value) * 1e3m; + case InformationUnit.Kilobyte: return (_value*8m) * 1e3m; + case InformationUnit.Mebibit: return (_value) * (1024m * 1024); + case InformationUnit.Mebibyte: return (_value*8m) * (1024m * 1024); + case InformationUnit.Megabit: return (_value) * 1e6m; + case InformationUnit.Megabyte: return (_value*8m) * 1e6m; + case InformationUnit.Pebibit: return (_value) * (1024m * 1024 * 1024 * 1024 * 1024); + case InformationUnit.Pebibyte: return (_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024); + case InformationUnit.Petabit: return (_value) * 1e15m; + case InformationUnit.Petabyte: return (_value*8m) * 1e15m; + case InformationUnit.Tebibit: return (_value) * (1024m * 1024 * 1024 * 1024); + case InformationUnit.Tebibyte: return (_value*8m) * (1024m * 1024 * 1024 * 1024); + case InformationUnit.Terabit: return (_value) * 1e12m; + case InformationUnit.Terabyte: return (_value*8m) * 1e12m; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private decimal AsBaseNumericType(InformationUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Information ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Information(baseUnitValue, BaseUnit); + } + + private decimal GetValueAs(InformationUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Irradiance.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Irradiance.NetFramework.g.cs index f8a302ac4d..08e60922fe 100644 --- a/UnitsNet/GeneratedCode/Quantities/Irradiance.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Irradiance.NetFramework.g.cs @@ -538,12 +538,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 new Irradiance(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static Irradiance operator -(Irradiance left, Irradiance right) { - return new Irradiance(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new Irradiance(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static Irradiance operator *(double left, Irradiance right) @@ -572,22 +572,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Irradi public static bool operator <=(Irradiance left, Irradiance right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(Irradiance left, Irradiance right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(Irradiance left, Irradiance right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(Irradiance left, Irradiance right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(Irradiance left, Irradiance right) @@ -611,7 +611,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(Irradiance other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -624,7 +624,7 @@ public override bool Equals(object obj) public bool Equals(Irradiance other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -700,7 +700,7 @@ public double As(IrradianceUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -710,7 +710,7 @@ public double As(IrradianceUnit unit) /// A Irradiance with the specified unit. public Irradiance ToUnit(IrradianceUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Irradiance(convertedValue, unit); } @@ -719,50 +719,46 @@ public Irradiance ToUnit(IrradianceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Irradiance AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case IrradianceUnit.KilowattPerSquareCentimeter: - return new Irradiance((_value*10000) * 1e3d, BaseUnit); - case IrradianceUnit.KilowattPerSquareMeter: - return new Irradiance((_value) * 1e3d, BaseUnit); - case IrradianceUnit.MegawattPerSquareCentimeter: - return new Irradiance((_value*10000) * 1e6d, BaseUnit); - case IrradianceUnit.MegawattPerSquareMeter: - return new Irradiance((_value) * 1e6d, BaseUnit); - case IrradianceUnit.MicrowattPerSquareCentimeter: - return new Irradiance((_value*10000) * 1e-6d, BaseUnit); - case IrradianceUnit.MicrowattPerSquareMeter: - return new Irradiance((_value) * 1e-6d, BaseUnit); - case IrradianceUnit.MilliwattPerSquareCentimeter: - return new Irradiance((_value*10000) * 1e-3d, BaseUnit); - case IrradianceUnit.MilliwattPerSquareMeter: - return new Irradiance((_value) * 1e-3d, BaseUnit); - case IrradianceUnit.NanowattPerSquareCentimeter: - return new Irradiance((_value*10000) * 1e-9d, BaseUnit); - case IrradianceUnit.NanowattPerSquareMeter: - return new Irradiance((_value) * 1e-9d, BaseUnit); - case IrradianceUnit.PicowattPerSquareCentimeter: - return new Irradiance((_value*10000) * 1e-12d, BaseUnit); - case IrradianceUnit.PicowattPerSquareMeter: - return new Irradiance((_value) * 1e-12d, BaseUnit); - case IrradianceUnit.WattPerSquareCentimeter: - return new Irradiance(_value*10000, BaseUnit); - case IrradianceUnit.WattPerSquareMeter: - return new Irradiance(_value, BaseUnit); + case IrradianceUnit.KilowattPerSquareCentimeter: return (_value*10000) * 1e3d; + case IrradianceUnit.KilowattPerSquareMeter: return (_value) * 1e3d; + case IrradianceUnit.MegawattPerSquareCentimeter: return (_value*10000) * 1e6d; + case IrradianceUnit.MegawattPerSquareMeter: return (_value) * 1e6d; + case IrradianceUnit.MicrowattPerSquareCentimeter: return (_value*10000) * 1e-6d; + case IrradianceUnit.MicrowattPerSquareMeter: return (_value) * 1e-6d; + case IrradianceUnit.MilliwattPerSquareCentimeter: return (_value*10000) * 1e-3d; + case IrradianceUnit.MilliwattPerSquareMeter: return (_value) * 1e-3d; + case IrradianceUnit.NanowattPerSquareCentimeter: return (_value*10000) * 1e-9d; + case IrradianceUnit.NanowattPerSquareMeter: return (_value) * 1e-9d; + case IrradianceUnit.PicowattPerSquareCentimeter: return (_value*10000) * 1e-12d; + case IrradianceUnit.PicowattPerSquareMeter: return (_value) * 1e-12d; + case IrradianceUnit.WattPerSquareCentimeter: return _value*10000; + case IrradianceUnit.WattPerSquareMeter: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(IrradianceUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Irradiance ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Irradiance(baseUnitValue, BaseUnit); + } + + private double GetValueAs(IrradianceUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Irradiation.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Irradiation.NetFramework.g.cs index 9d6331f288..9454d2b055 100644 --- a/UnitsNet/GeneratedCode/Quantities/Irradiation.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Irradiation.NetFramework.g.cs @@ -401,12 +401,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 new Irradiation(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static Irradiation operator -(Irradiation left, Irradiation right) { - return new Irradiation(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new Irradiation(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static Irradiation operator *(double left, Irradiation right) @@ -435,22 +435,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Irradi public static bool operator <=(Irradiation left, Irradiation right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(Irradiation left, Irradiation right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(Irradiation left, Irradiation right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(Irradiation left, Irradiation right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(Irradiation left, Irradiation right) @@ -474,7 +474,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(Irradiation other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -487,7 +487,7 @@ public override bool Equals(object obj) public bool Equals(Irradiation other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -563,7 +563,7 @@ public double As(IrradiationUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -573,7 +573,7 @@ public double As(IrradiationUnit unit) /// A Irradiation with the specified unit. public Irradiation ToUnit(IrradiationUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Irradiation(convertedValue, unit); } @@ -582,30 +582,36 @@ public Irradiation ToUnit(IrradiationUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Irradiation AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case IrradiationUnit.JoulePerSquareMeter: - return new Irradiation(_value, BaseUnit); - case IrradiationUnit.JoulePerSquareMillimeter: - return new Irradiation(_value*1e6, BaseUnit); - case IrradiationUnit.KilowattHourPerSquareMeter: - return new Irradiation((_value*3600d) * 1e3d, BaseUnit); - case IrradiationUnit.WattHourPerSquareMeter: - return new Irradiation(_value*3600d, BaseUnit); + case IrradiationUnit.JoulePerSquareMeter: return _value; + case IrradiationUnit.JoulePerSquareMillimeter: return _value*1e6; + case IrradiationUnit.KilowattHourPerSquareMeter: return (_value*3600d) * 1e3d; + case IrradiationUnit.WattHourPerSquareMeter: return _value*3600d; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(IrradiationUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Irradiation ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Irradiation(baseUnitValue, BaseUnit); + } + + private double GetValueAs(IrradiationUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.NetFramework.g.cs index e7a89fc246..5402e0d3bd 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 new KinematicViscosity(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static KinematicViscosity operator -(KinematicViscosity left, KinematicViscosity right) { - return new KinematicViscosity(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new KinematicViscosity(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static KinematicViscosity operator *(double left, KinematicViscosity right) @@ -491,22 +491,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Kinema public static bool operator <=(KinematicViscosity left, KinematicViscosity right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(KinematicViscosity left, KinematicViscosity right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(KinematicViscosity left, KinematicViscosity right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(KinematicViscosity left, KinematicViscosity right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(KinematicViscosity left, KinematicViscosity right) @@ -530,7 +530,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(KinematicViscosity other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -543,7 +543,7 @@ public override bool Equals(object obj) public bool Equals(KinematicViscosity other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -619,7 +619,7 @@ public double As(KinematicViscosityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -629,7 +629,7 @@ public double As(KinematicViscosityUnit unit) /// A KinematicViscosity with the specified unit. public KinematicViscosity ToUnit(KinematicViscosityUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new KinematicViscosity(convertedValue, unit); } @@ -638,38 +638,40 @@ public KinematicViscosity ToUnit(KinematicViscosityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal KinematicViscosity AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case KinematicViscosityUnit.Centistokes: - return new KinematicViscosity((_value/1e4) * 1e-2d, BaseUnit); - case KinematicViscosityUnit.Decistokes: - return new KinematicViscosity((_value/1e4) * 1e-1d, BaseUnit); - case KinematicViscosityUnit.Kilostokes: - return new KinematicViscosity((_value/1e4) * 1e3d, BaseUnit); - case KinematicViscosityUnit.Microstokes: - return new KinematicViscosity((_value/1e4) * 1e-6d, BaseUnit); - case KinematicViscosityUnit.Millistokes: - return new KinematicViscosity((_value/1e4) * 1e-3d, BaseUnit); - case KinematicViscosityUnit.Nanostokes: - return new KinematicViscosity((_value/1e4) * 1e-9d, BaseUnit); - case KinematicViscosityUnit.SquareMeterPerSecond: - return new KinematicViscosity(_value, BaseUnit); - case KinematicViscosityUnit.Stokes: - return new KinematicViscosity(_value/1e4, BaseUnit); + case KinematicViscosityUnit.Centistokes: return (_value/1e4) * 1e-2d; + case KinematicViscosityUnit.Decistokes: return (_value/1e4) * 1e-1d; + case KinematicViscosityUnit.Kilostokes: return (_value/1e4) * 1e3d; + case KinematicViscosityUnit.Microstokes: return (_value/1e4) * 1e-6d; + case KinematicViscosityUnit.Millistokes: return (_value/1e4) * 1e-3d; + case KinematicViscosityUnit.Nanostokes: return (_value/1e4) * 1e-9d; + case KinematicViscosityUnit.SquareMeterPerSecond: return _value; + case KinematicViscosityUnit.Stokes: return _value/1e4; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(KinematicViscosityUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal KinematicViscosity ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new KinematicViscosity(baseUnitValue, BaseUnit); + } + + private double GetValueAs(KinematicViscosityUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/LapseRate.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/LapseRate.NetFramework.g.cs index a7b9f4b22d..0d70e6dc3a 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 new LapseRate(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static LapseRate operator -(LapseRate left, LapseRate right) { - return new LapseRate(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new LapseRate(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static LapseRate operator *(double left, LapseRate right) @@ -390,22 +390,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out LapseR public static bool operator <=(LapseRate left, LapseRate right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(LapseRate left, LapseRate right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(LapseRate left, LapseRate right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(LapseRate left, LapseRate right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(LapseRate left, LapseRate right) @@ -429,7 +429,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(LapseRate other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -442,7 +442,7 @@ public override bool Equals(object obj) public bool Equals(LapseRate other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -518,7 +518,7 @@ public double As(LapseRateUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -528,7 +528,7 @@ public double As(LapseRateUnit unit) /// A LapseRate with the specified unit. public LapseRate ToUnit(LapseRateUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new LapseRate(convertedValue, unit); } @@ -537,24 +537,33 @@ public LapseRate ToUnit(LapseRateUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal LapseRate AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case LapseRateUnit.DegreeCelsiusPerKilometer: - return new LapseRate(_value, BaseUnit); + case LapseRateUnit.DegreeCelsiusPerKilometer: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(LapseRateUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal LapseRate ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new LapseRate(baseUnitValue, BaseUnit); + } + + private double GetValueAs(LapseRateUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Length.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Length.NetFramework.g.cs index 8f2a6e34cf..d797388943 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 new Length(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static Length operator -(Length left, Length right) { - return new Length(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new Length(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static Length operator *(double left, Length right) @@ -684,22 +684,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Length public static bool operator <=(Length left, Length right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(Length left, Length right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(Length left, Length right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(Length left, Length right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(Length left, Length right) @@ -723,7 +723,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(Length other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -736,7 +736,7 @@ public override bool Equals(object obj) public bool Equals(Length other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -812,7 +812,7 @@ public double As(LengthUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -822,7 +822,7 @@ public double As(LengthUnit unit) /// A Length with the specified unit. public Length ToUnit(LengthUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Length(convertedValue, unit); } @@ -831,66 +831,54 @@ public Length ToUnit(LengthUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Length AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case LengthUnit.Centimeter: - return new Length((_value) * 1e-2d, BaseUnit); - case LengthUnit.Decimeter: - return new Length((_value) * 1e-1d, BaseUnit); - case LengthUnit.DtpPica: - return new Length(_value/236.220472441, BaseUnit); - case LengthUnit.DtpPoint: - return new Length((_value/72)*2.54e-2, BaseUnit); - case LengthUnit.Fathom: - return new Length(_value*1.8288, BaseUnit); - case LengthUnit.Foot: - return new Length(_value*0.3048, BaseUnit); - case LengthUnit.Inch: - return new Length(_value*2.54e-2, BaseUnit); - case LengthUnit.Kilometer: - return new Length((_value) * 1e3d, BaseUnit); - case LengthUnit.Meter: - return new Length(_value, BaseUnit); - case LengthUnit.Microinch: - return new Length(_value*2.54e-8, BaseUnit); - case LengthUnit.Micrometer: - return new Length((_value) * 1e-6d, BaseUnit); - case LengthUnit.Mil: - return new Length(_value*2.54e-5, BaseUnit); - case LengthUnit.Mile: - return new Length(_value*1609.34, BaseUnit); - case LengthUnit.Millimeter: - return new Length((_value) * 1e-3d, BaseUnit); - case LengthUnit.Nanometer: - return new Length((_value) * 1e-9d, BaseUnit); - case LengthUnit.NauticalMile: - return new Length(_value*1852, BaseUnit); - case LengthUnit.PrinterPica: - return new Length(_value/237.106301584, BaseUnit); - case LengthUnit.PrinterPoint: - return new Length((_value/72.27)*2.54e-2, BaseUnit); - case LengthUnit.Shackle: - return new Length(_value*27.432, BaseUnit); - case LengthUnit.Twip: - return new Length(_value/56692.913385826, BaseUnit); - case LengthUnit.UsSurveyFoot: - return new Length(_value*1200/3937, BaseUnit); - case LengthUnit.Yard: - return new Length(_value*0.9144, BaseUnit); + case LengthUnit.Centimeter: return (_value) * 1e-2d; + case LengthUnit.Decimeter: return (_value) * 1e-1d; + case LengthUnit.DtpPica: return _value/236.220472441; + case LengthUnit.DtpPoint: return (_value/72)*2.54e-2; + case LengthUnit.Fathom: return _value*1.8288; + case LengthUnit.Foot: return _value*0.3048; + case LengthUnit.Inch: return _value*2.54e-2; + case LengthUnit.Kilometer: return (_value) * 1e3d; + case LengthUnit.Meter: return _value; + case LengthUnit.Microinch: return _value*2.54e-8; + case LengthUnit.Micrometer: return (_value) * 1e-6d; + case LengthUnit.Mil: return _value*2.54e-5; + case LengthUnit.Mile: return _value*1609.34; + case LengthUnit.Millimeter: return (_value) * 1e-3d; + case LengthUnit.Nanometer: return (_value) * 1e-9d; + case LengthUnit.NauticalMile: return _value*1852; + case LengthUnit.PrinterPica: return _value/237.106301584; + case LengthUnit.PrinterPoint: return (_value/72.27)*2.54e-2; + case LengthUnit.Shackle: return _value*27.432; + case LengthUnit.Twip: return _value/56692.913385826; + case LengthUnit.UsSurveyFoot: return _value*1200/3937; + case LengthUnit.Yard: return _value*0.9144; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(LengthUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Length ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Length(baseUnitValue, BaseUnit); + } + + private double GetValueAs(LengthUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Level.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Level.NetFramework.g.cs index 70def151cd..429e255384 100644 --- a/UnitsNet/GeneratedCode/Quantities/Level.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Level.NetFramework.g.cs @@ -372,14 +372,14 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out LevelU { // Logarithmic addition // Formula: 10*log10(10^(x/10) + 10^(y/10)) - return new Level(10*Math.Log10(Math.Pow(10, left.Value/10) + Math.Pow(10, right.AsBaseNumericType(left.Unit)/10)), left.Unit); + return new Level(10*Math.Log10(Math.Pow(10, left.Value/10) + Math.Pow(10, right.GetValueAs(left.Unit)/10)), left.Unit); } public static Level operator -(Level left, Level right) { // Logarithmic subtraction // Formula: 10*log10(10^(x/10) - 10^(y/10)) - return new Level(10*Math.Log10(Math.Pow(10, left.Value/10) - Math.Pow(10, right.AsBaseNumericType(left.Unit)/10)), left.Unit); + return new Level(10*Math.Log10(Math.Pow(10, left.Value/10) - Math.Pow(10, right.GetValueAs(left.Unit)/10)), left.Unit); } public static Level operator *(double left, Level right) @@ -403,7 +403,7 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out LevelU public static double operator /(Level left, Level right) { // Logarithmic division = subtraction - return Convert.ToDouble(left.Value - right.AsBaseNumericType(left.Unit)); + return Convert.ToDouble(left.Value - right.GetValueAs(left.Unit)); } #endregion @@ -412,22 +412,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out LevelU public static bool operator <=(Level left, Level right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(Level left, Level right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(Level left, Level right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(Level left, Level right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(Level left, Level right) @@ -451,7 +451,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(Level other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -464,7 +464,7 @@ public override bool Equals(object obj) public bool Equals(Level other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -540,7 +540,7 @@ public double As(LevelUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -550,7 +550,7 @@ public double As(LevelUnit unit) /// A Level with the specified unit. public Level ToUnit(LevelUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Level(convertedValue, unit); } @@ -559,26 +559,34 @@ public Level ToUnit(LevelUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Level AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case LevelUnit.Decibel: - return new Level(_value, BaseUnit); - case LevelUnit.Neper: - return new Level((1/0.115129254)*_value, BaseUnit); + case LevelUnit.Decibel: return _value; + case LevelUnit.Neper: return (1/0.115129254)*_value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(LevelUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Level ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Level(baseUnitValue, BaseUnit); + } + + private double GetValueAs(LevelUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/LinearDensity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/LinearDensity.NetFramework.g.cs index c6a84b4ee9..21dbdc10d6 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 new LinearDensity(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static LinearDensity operator -(LinearDensity left, LinearDensity right) { - return new LinearDensity(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new LinearDensity(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static LinearDensity operator *(double left, LinearDensity right) @@ -421,22 +421,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Linear public static bool operator <=(LinearDensity left, LinearDensity right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(LinearDensity left, LinearDensity right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(LinearDensity left, LinearDensity right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(LinearDensity left, LinearDensity right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(LinearDensity left, LinearDensity right) @@ -460,7 +460,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(LinearDensity other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -473,7 +473,7 @@ public override bool Equals(object obj) public bool Equals(LinearDensity other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -549,7 +549,7 @@ public double As(LinearDensityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -559,7 +559,7 @@ public double As(LinearDensityUnit unit) /// A LinearDensity with the specified unit. public LinearDensity ToUnit(LinearDensityUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new LinearDensity(convertedValue, unit); } @@ -568,28 +568,35 @@ public LinearDensity ToUnit(LinearDensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal LinearDensity AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case LinearDensityUnit.GramPerMeter: - return new LinearDensity(_value*1e-3, BaseUnit); - case LinearDensityUnit.KilogramPerMeter: - return new LinearDensity((_value*1e-3) * 1e3d, BaseUnit); - case LinearDensityUnit.PoundPerFoot: - return new LinearDensity(_value*1.48816394, BaseUnit); + case LinearDensityUnit.GramPerMeter: return _value*1e-3; + case LinearDensityUnit.KilogramPerMeter: return (_value*1e-3) * 1e3d; + case LinearDensityUnit.PoundPerFoot: return _value*1.48816394; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(LinearDensityUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal LinearDensity ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new LinearDensity(baseUnitValue, BaseUnit); + } + + private double GetValueAs(LinearDensityUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/LuminousFlux.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/LuminousFlux.NetFramework.g.cs index 6f03dce364..6911671ce7 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 new LuminousFlux(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static LuminousFlux operator -(LuminousFlux left, LuminousFlux right) { - return new LuminousFlux(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new LuminousFlux(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static LuminousFlux operator *(double left, LuminousFlux right) @@ -393,22 +393,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Lumino public static bool operator <=(LuminousFlux left, LuminousFlux right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(LuminousFlux left, LuminousFlux right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(LuminousFlux left, LuminousFlux right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(LuminousFlux left, LuminousFlux right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(LuminousFlux left, LuminousFlux right) @@ -432,7 +432,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(LuminousFlux other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -445,7 +445,7 @@ public override bool Equals(object obj) public bool Equals(LuminousFlux other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -521,7 +521,7 @@ public double As(LuminousFluxUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -531,7 +531,7 @@ public double As(LuminousFluxUnit unit) /// A LuminousFlux with the specified unit. public LuminousFlux ToUnit(LuminousFluxUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new LuminousFlux(convertedValue, unit); } @@ -540,24 +540,33 @@ public LuminousFlux ToUnit(LuminousFluxUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal LuminousFlux AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case LuminousFluxUnit.Lumen: - return new LuminousFlux(_value, BaseUnit); + case LuminousFluxUnit.Lumen: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(LuminousFluxUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal LuminousFlux ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new LuminousFlux(baseUnitValue, BaseUnit); + } + + private double GetValueAs(LuminousFluxUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.NetFramework.g.cs index f3a6682791..e417d66172 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 new LuminousIntensity(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static LuminousIntensity operator -(LuminousIntensity left, LuminousIntensity right) { - return new LuminousIntensity(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new LuminousIntensity(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static LuminousIntensity operator *(double left, LuminousIntensity right) @@ -393,22 +393,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Lumino public static bool operator <=(LuminousIntensity left, LuminousIntensity right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(LuminousIntensity left, LuminousIntensity right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(LuminousIntensity left, LuminousIntensity right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(LuminousIntensity left, LuminousIntensity right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(LuminousIntensity left, LuminousIntensity right) @@ -432,7 +432,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(LuminousIntensity other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -445,7 +445,7 @@ public override bool Equals(object obj) public bool Equals(LuminousIntensity other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -521,7 +521,7 @@ public double As(LuminousIntensityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -531,7 +531,7 @@ public double As(LuminousIntensityUnit unit) /// A LuminousIntensity with the specified unit. public LuminousIntensity ToUnit(LuminousIntensityUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new LuminousIntensity(convertedValue, unit); } @@ -540,24 +540,33 @@ public LuminousIntensity ToUnit(LuminousIntensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal LuminousIntensity AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case LuminousIntensityUnit.Candela: - return new LuminousIntensity(_value, BaseUnit); + case LuminousIntensityUnit.Candela: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(LuminousIntensityUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal LuminousIntensity ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new LuminousIntensity(baseUnitValue, BaseUnit); + } + + private double GetValueAs(LuminousIntensityUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/MagneticField.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/MagneticField.NetFramework.g.cs index fde369e861..da374c97f1 100644 --- a/UnitsNet/GeneratedCode/Quantities/MagneticField.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MagneticField.NetFramework.g.cs @@ -401,12 +401,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 new MagneticField(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static MagneticField operator -(MagneticField left, MagneticField right) { - return new MagneticField(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new MagneticField(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static MagneticField operator *(double left, MagneticField right) @@ -435,22 +435,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Magnet public static bool operator <=(MagneticField left, MagneticField right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(MagneticField left, MagneticField right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(MagneticField left, MagneticField right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(MagneticField left, MagneticField right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(MagneticField left, MagneticField right) @@ -474,7 +474,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(MagneticField other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -487,7 +487,7 @@ public override bool Equals(object obj) public bool Equals(MagneticField other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -563,7 +563,7 @@ public double As(MagneticFieldUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -573,7 +573,7 @@ public double As(MagneticFieldUnit unit) /// A MagneticField with the specified unit. public MagneticField ToUnit(MagneticFieldUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new MagneticField(convertedValue, unit); } @@ -582,30 +582,36 @@ public MagneticField ToUnit(MagneticFieldUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal MagneticField AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case MagneticFieldUnit.Microtesla: - return new MagneticField((_value) * 1e-6d, BaseUnit); - case MagneticFieldUnit.Millitesla: - return new MagneticField((_value) * 1e-3d, BaseUnit); - case MagneticFieldUnit.Nanotesla: - return new MagneticField((_value) * 1e-9d, BaseUnit); - case MagneticFieldUnit.Tesla: - return new MagneticField(_value, BaseUnit); + case MagneticFieldUnit.Microtesla: return (_value) * 1e-6d; + case MagneticFieldUnit.Millitesla: return (_value) * 1e-3d; + case MagneticFieldUnit.Nanotesla: return (_value) * 1e-9d; + case MagneticFieldUnit.Tesla: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(MagneticFieldUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal MagneticField ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new MagneticField(baseUnitValue, BaseUnit); + } + + private double GetValueAs(MagneticFieldUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/MagneticFlux.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/MagneticFlux.NetFramework.g.cs index b637c79689..b5221cfe4b 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 new MagneticFlux(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static MagneticFlux operator -(MagneticFlux left, MagneticFlux right) { - return new MagneticFlux(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new MagneticFlux(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static MagneticFlux operator *(double left, MagneticFlux right) @@ -393,22 +393,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Magnet public static bool operator <=(MagneticFlux left, MagneticFlux right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(MagneticFlux left, MagneticFlux right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(MagneticFlux left, MagneticFlux right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(MagneticFlux left, MagneticFlux right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(MagneticFlux left, MagneticFlux right) @@ -432,7 +432,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(MagneticFlux other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -445,7 +445,7 @@ public override bool Equals(object obj) public bool Equals(MagneticFlux other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -521,7 +521,7 @@ public double As(MagneticFluxUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -531,7 +531,7 @@ public double As(MagneticFluxUnit unit) /// A MagneticFlux with the specified unit. public MagneticFlux ToUnit(MagneticFluxUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new MagneticFlux(convertedValue, unit); } @@ -540,24 +540,33 @@ public MagneticFlux ToUnit(MagneticFluxUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal MagneticFlux AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case MagneticFluxUnit.Weber: - return new MagneticFlux(_value, BaseUnit); + case MagneticFluxUnit.Weber: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(MagneticFluxUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal MagneticFlux ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new MagneticFlux(baseUnitValue, BaseUnit); + } + + private double GetValueAs(MagneticFluxUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Magnetization.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Magnetization.NetFramework.g.cs index a6d6dd54aa..faac6c77ad 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 new Magnetization(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static Magnetization operator -(Magnetization left, Magnetization right) { - return new Magnetization(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new Magnetization(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static Magnetization operator *(double left, Magnetization right) @@ -393,22 +393,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Magnet public static bool operator <=(Magnetization left, Magnetization right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(Magnetization left, Magnetization right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(Magnetization left, Magnetization right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(Magnetization left, Magnetization right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(Magnetization left, Magnetization right) @@ -432,7 +432,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(Magnetization other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -445,7 +445,7 @@ public override bool Equals(object obj) public bool Equals(Magnetization other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -521,7 +521,7 @@ public double As(MagnetizationUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -531,7 +531,7 @@ public double As(MagnetizationUnit unit) /// A Magnetization with the specified unit. public Magnetization ToUnit(MagnetizationUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Magnetization(convertedValue, unit); } @@ -540,24 +540,33 @@ public Magnetization ToUnit(MagnetizationUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Magnetization AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case MagnetizationUnit.AmperePerMeter: - return new Magnetization(_value, BaseUnit); + case MagnetizationUnit.AmperePerMeter: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(MagnetizationUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Magnetization ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Magnetization(baseUnitValue, BaseUnit); + } + + private double GetValueAs(MagnetizationUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Mass.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Mass.NetFramework.g.cs index 07cff60d18..e6970491ff 100644 --- a/UnitsNet/GeneratedCode/Quantities/Mass.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Mass.NetFramework.g.cs @@ -664,12 +664,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 new Mass(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static Mass operator -(Mass left, Mass right) { - return new Mass(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new Mass(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static Mass operator *(double left, Mass right) @@ -698,22 +698,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out MassUn public static bool operator <=(Mass left, Mass right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(Mass left, Mass right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(Mass left, Mass right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(Mass left, Mass right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(Mass left, Mass right) @@ -737,7 +737,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(Mass other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -750,7 +750,7 @@ public override bool Equals(object obj) public bool Equals(Mass other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -826,7 +826,7 @@ public double As(MassUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -836,7 +836,7 @@ public double As(MassUnit unit) /// A Mass with the specified unit. public Mass ToUnit(MassUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Mass(convertedValue, unit); } @@ -845,68 +845,55 @@ public Mass ToUnit(MassUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Mass AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case MassUnit.Centigram: - return new Mass((_value/1e3) * 1e-2d, BaseUnit); - case MassUnit.Decagram: - return new Mass((_value/1e3) * 1e1d, BaseUnit); - case MassUnit.Decigram: - return new Mass((_value/1e3) * 1e-1d, BaseUnit); - case MassUnit.Grain: - return new Mass(_value/15432.358352941431, BaseUnit); - case MassUnit.Gram: - return new Mass(_value/1e3, BaseUnit); - case MassUnit.Hectogram: - return new Mass((_value/1e3) * 1e2d, BaseUnit); - case MassUnit.Kilogram: - return new Mass((_value/1e3) * 1e3d, BaseUnit); - case MassUnit.Kilopound: - return new Mass((_value*0.45359237) * 1e3d, BaseUnit); - case MassUnit.Kilotonne: - return new Mass((_value*1e3) * 1e3d, BaseUnit); - case MassUnit.LongHundredweight: - return new Mass(_value/0.01968413055222121, BaseUnit); - case MassUnit.LongTon: - return new Mass(_value*1.0160469088e3, BaseUnit); - case MassUnit.Megapound: - return new Mass((_value*0.45359237) * 1e6d, BaseUnit); - case MassUnit.Megatonne: - return new Mass((_value*1e3) * 1e6d, BaseUnit); - case MassUnit.Microgram: - return new Mass((_value/1e3) * 1e-6d, BaseUnit); - case MassUnit.Milligram: - return new Mass((_value/1e3) * 1e-3d, BaseUnit); - case MassUnit.Nanogram: - return new Mass((_value/1e3) * 1e-9d, BaseUnit); - case MassUnit.Ounce: - return new Mass(_value/35.2739619, BaseUnit); - case MassUnit.Pound: - return new Mass(_value*0.45359237, BaseUnit); - case MassUnit.ShortHundredweight: - return new Mass(_value/0.022046226218487758, BaseUnit); - case MassUnit.ShortTon: - return new Mass(_value*9.0718474e2, BaseUnit); - case MassUnit.Slug: - return new Mass(_value/6.852176556196105e-2, BaseUnit); - case MassUnit.Stone: - return new Mass(_value/0.1574731728702698, BaseUnit); - case MassUnit.Tonne: - return new Mass(_value*1e3, BaseUnit); + case MassUnit.Centigram: return (_value/1e3) * 1e-2d; + case MassUnit.Decagram: return (_value/1e3) * 1e1d; + case MassUnit.Decigram: return (_value/1e3) * 1e-1d; + case MassUnit.Grain: return _value/15432.358352941431; + case MassUnit.Gram: return _value/1e3; + case MassUnit.Hectogram: return (_value/1e3) * 1e2d; + case MassUnit.Kilogram: return (_value/1e3) * 1e3d; + case MassUnit.Kilopound: return (_value*0.45359237) * 1e3d; + case MassUnit.Kilotonne: return (_value*1e3) * 1e3d; + case MassUnit.LongHundredweight: return _value/0.01968413055222121; + case MassUnit.LongTon: return _value*1.0160469088e3; + case MassUnit.Megapound: return (_value*0.45359237) * 1e6d; + case MassUnit.Megatonne: return (_value*1e3) * 1e6d; + case MassUnit.Microgram: return (_value/1e3) * 1e-6d; + case MassUnit.Milligram: return (_value/1e3) * 1e-3d; + case MassUnit.Nanogram: return (_value/1e3) * 1e-9d; + case MassUnit.Ounce: return _value/35.2739619; + case MassUnit.Pound: return _value*0.45359237; + case MassUnit.ShortHundredweight: return _value/0.022046226218487758; + case MassUnit.ShortTon: return _value*9.0718474e2; + case MassUnit.Slug: return _value/6.852176556196105e-2; + case MassUnit.Stone: return _value/0.1574731728702698; + case MassUnit.Tonne: return _value*1e3; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(MassUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Mass ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Mass(baseUnitValue, BaseUnit); + } + + private double GetValueAs(MassUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/MassFlow.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/MassFlow.NetFramework.g.cs index 8c57c9fe99..8a5eb1c31c 100644 --- a/UnitsNet/GeneratedCode/Quantities/MassFlow.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MassFlow.NetFramework.g.cs @@ -762,12 +762,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 new MassFlow(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static MassFlow operator -(MassFlow left, MassFlow right) { - return new MassFlow(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new MassFlow(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static MassFlow operator *(double left, MassFlow right) @@ -796,22 +796,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out MassFl public static bool operator <=(MassFlow left, MassFlow right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(MassFlow left, MassFlow right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(MassFlow left, MassFlow right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(MassFlow left, MassFlow right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(MassFlow left, MassFlow right) @@ -835,7 +835,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(MassFlow other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -848,7 +848,7 @@ public override bool Equals(object obj) public bool Equals(MassFlow other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -924,7 +924,7 @@ public double As(MassFlowUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -934,7 +934,7 @@ public double As(MassFlowUnit unit) /// A MassFlow with the specified unit. public MassFlow ToUnit(MassFlowUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new MassFlow(convertedValue, unit); } @@ -943,82 +943,62 @@ public MassFlow ToUnit(MassFlowUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal MassFlow AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case MassFlowUnit.CentigramPerDay: - return new MassFlow((_value/86400) * 1e-2d, BaseUnit); - case MassFlowUnit.CentigramPerSecond: - return new MassFlow((_value) * 1e-2d, BaseUnit); - case MassFlowUnit.DecagramPerDay: - return new MassFlow((_value/86400) * 1e1d, BaseUnit); - case MassFlowUnit.DecagramPerSecond: - return new MassFlow((_value) * 1e1d, BaseUnit); - case MassFlowUnit.DecigramPerDay: - return new MassFlow((_value/86400) * 1e-1d, BaseUnit); - case MassFlowUnit.DecigramPerSecond: - return new MassFlow((_value) * 1e-1d, BaseUnit); - case MassFlowUnit.GramPerDay: - return new MassFlow(_value/86400, BaseUnit); - case MassFlowUnit.GramPerSecond: - return new MassFlow(_value, BaseUnit); - case MassFlowUnit.HectogramPerDay: - return new MassFlow((_value/86400) * 1e2d, BaseUnit); - case MassFlowUnit.HectogramPerSecond: - return new MassFlow((_value) * 1e2d, BaseUnit); - case MassFlowUnit.KilogramPerDay: - return new MassFlow((_value/86400) * 1e3d, BaseUnit); - case MassFlowUnit.KilogramPerHour: - return new MassFlow(_value/3.6, BaseUnit); - case MassFlowUnit.KilogramPerMinute: - return new MassFlow(_value/0.06, BaseUnit); - case MassFlowUnit.KilogramPerSecond: - return new MassFlow((_value) * 1e3d, BaseUnit); - case MassFlowUnit.MegagramPerDay: - return new MassFlow((_value/86400) * 1e6d, BaseUnit); - case MassFlowUnit.MegapoundPerDay: - return new MassFlow((_value/190.47936) * 1e6d, BaseUnit); - case MassFlowUnit.MegapoundPerHour: - return new MassFlow((_value/7.93664) * 1e6d, BaseUnit); - case MassFlowUnit.MegapoundPerMinute: - return new MassFlow((_value/0.132277) * 1e6d, BaseUnit); - case MassFlowUnit.MicrogramPerDay: - return new MassFlow((_value/86400) * 1e-6d, BaseUnit); - case MassFlowUnit.MicrogramPerSecond: - return new MassFlow((_value) * 1e-6d, BaseUnit); - case MassFlowUnit.MilligramPerDay: - return new MassFlow((_value/86400) * 1e-3d, BaseUnit); - case MassFlowUnit.MilligramPerSecond: - return new MassFlow((_value) * 1e-3d, BaseUnit); - case MassFlowUnit.NanogramPerDay: - return new MassFlow((_value/86400) * 1e-9d, BaseUnit); - case MassFlowUnit.NanogramPerSecond: - return new MassFlow((_value) * 1e-9d, BaseUnit); - case MassFlowUnit.PoundPerDay: - return new MassFlow(_value/190.47936, BaseUnit); - case MassFlowUnit.PoundPerHour: - return new MassFlow(_value/7.93664, BaseUnit); - case MassFlowUnit.PoundPerMinute: - return new MassFlow(_value/0.132277, BaseUnit); - case MassFlowUnit.ShortTonPerHour: - return new MassFlow(_value*251.9957611, BaseUnit); - case MassFlowUnit.TonnePerDay: - return new MassFlow(_value/0.0864000, BaseUnit); - case MassFlowUnit.TonnePerHour: - return new MassFlow(1000*_value/3.6, BaseUnit); + case MassFlowUnit.CentigramPerDay: return (_value/86400) * 1e-2d; + case MassFlowUnit.CentigramPerSecond: return (_value) * 1e-2d; + case MassFlowUnit.DecagramPerDay: return (_value/86400) * 1e1d; + case MassFlowUnit.DecagramPerSecond: return (_value) * 1e1d; + case MassFlowUnit.DecigramPerDay: return (_value/86400) * 1e-1d; + case MassFlowUnit.DecigramPerSecond: return (_value) * 1e-1d; + case MassFlowUnit.GramPerDay: return _value/86400; + case MassFlowUnit.GramPerSecond: return _value; + case MassFlowUnit.HectogramPerDay: return (_value/86400) * 1e2d; + case MassFlowUnit.HectogramPerSecond: return (_value) * 1e2d; + case MassFlowUnit.KilogramPerDay: return (_value/86400) * 1e3d; + case MassFlowUnit.KilogramPerHour: return _value/3.6; + case MassFlowUnit.KilogramPerMinute: return _value/0.06; + case MassFlowUnit.KilogramPerSecond: return (_value) * 1e3d; + case MassFlowUnit.MegagramPerDay: return (_value/86400) * 1e6d; + case MassFlowUnit.MegapoundPerDay: return (_value/190.47936) * 1e6d; + case MassFlowUnit.MegapoundPerHour: return (_value/7.93664) * 1e6d; + case MassFlowUnit.MegapoundPerMinute: return (_value/0.132277) * 1e6d; + case MassFlowUnit.MicrogramPerDay: return (_value/86400) * 1e-6d; + case MassFlowUnit.MicrogramPerSecond: return (_value) * 1e-6d; + case MassFlowUnit.MilligramPerDay: return (_value/86400) * 1e-3d; + case MassFlowUnit.MilligramPerSecond: return (_value) * 1e-3d; + case MassFlowUnit.NanogramPerDay: return (_value/86400) * 1e-9d; + case MassFlowUnit.NanogramPerSecond: return (_value) * 1e-9d; + case MassFlowUnit.PoundPerDay: return _value/190.47936; + case MassFlowUnit.PoundPerHour: return _value/7.93664; + case MassFlowUnit.PoundPerMinute: return _value/0.132277; + case MassFlowUnit.ShortTonPerHour: return _value*251.9957611; + case MassFlowUnit.TonnePerDay: return _value/0.0864000; + case MassFlowUnit.TonnePerHour: return 1000*_value/3.6; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(MassFlowUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal MassFlow ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new MassFlow(baseUnitValue, BaseUnit); + } + + private double GetValueAs(MassFlowUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/MassFlux.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/MassFlux.NetFramework.g.cs index e21442f379..fb0431ce9a 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 new MassFlux(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static MassFlux operator -(MassFlux left, MassFlux right) { - return new MassFlux(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new MassFlux(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static MassFlux operator *(double left, MassFlux right) @@ -404,22 +404,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out MassFl public static bool operator <=(MassFlux left, MassFlux right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(MassFlux left, MassFlux right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(MassFlux left, MassFlux right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(MassFlux left, MassFlux right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(MassFlux left, MassFlux right) @@ -443,7 +443,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(MassFlux other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -456,7 +456,7 @@ public override bool Equals(object obj) public bool Equals(MassFlux other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -532,7 +532,7 @@ public double As(MassFluxUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -542,7 +542,7 @@ public double As(MassFluxUnit unit) /// A MassFlux with the specified unit. public MassFlux ToUnit(MassFluxUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new MassFlux(convertedValue, unit); } @@ -551,26 +551,34 @@ public MassFlux ToUnit(MassFluxUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal MassFlux AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case MassFluxUnit.GramPerSecondPerSquareMeter: - return new MassFlux(_value/1e3, BaseUnit); - case MassFluxUnit.KilogramPerSecondPerSquareMeter: - return new MassFlux((_value/1e3) * 1e3d, BaseUnit); + case MassFluxUnit.GramPerSecondPerSquareMeter: return _value/1e3; + case MassFluxUnit.KilogramPerSecondPerSquareMeter: return (_value/1e3) * 1e3d; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(MassFluxUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal MassFlux ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new MassFlux(baseUnitValue, BaseUnit); + } + + private double GetValueAs(MassFluxUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.NetFramework.g.cs index f506dac0eb..3898598bf4 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 new MassMomentOfInertia(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static MassMomentOfInertia operator -(MassMomentOfInertia left, MassMomentOfInertia right) { - return new MassMomentOfInertia(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new MassMomentOfInertia(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static MassMomentOfInertia operator *(double left, MassMomentOfInertia right) @@ -768,22 +768,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out MassMo public static bool operator <=(MassMomentOfInertia left, MassMomentOfInertia right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(MassMomentOfInertia left, MassMomentOfInertia right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(MassMomentOfInertia left, MassMomentOfInertia right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(MassMomentOfInertia left, MassMomentOfInertia right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(MassMomentOfInertia left, MassMomentOfInertia right) @@ -807,7 +807,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(MassMomentOfInertia other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -820,7 +820,7 @@ public override bool Equals(object obj) public bool Equals(MassMomentOfInertia other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -896,7 +896,7 @@ public double As(MassMomentOfInertiaUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -906,7 +906,7 @@ public double As(MassMomentOfInertiaUnit unit) /// A MassMomentOfInertia with the specified unit. public MassMomentOfInertia ToUnit(MassMomentOfInertiaUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new MassMomentOfInertia(convertedValue, unit); } @@ -915,78 +915,60 @@ public MassMomentOfInertia ToUnit(MassMomentOfInertiaUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal MassMomentOfInertia AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case MassMomentOfInertiaUnit.GramSquareCentimeter: - return new MassMomentOfInertia(_value/1e7, BaseUnit); - case MassMomentOfInertiaUnit.GramSquareDecimeter: - return new MassMomentOfInertia(_value/1e5, BaseUnit); - case MassMomentOfInertiaUnit.GramSquareMeter: - return new MassMomentOfInertia(_value/1e3, BaseUnit); - case MassMomentOfInertiaUnit.GramSquareMillimeter: - return new MassMomentOfInertia(_value/1e9, BaseUnit); - case MassMomentOfInertiaUnit.KilogramSquareCentimeter: - return new MassMomentOfInertia((_value/1e7) * 1e3d, BaseUnit); - case MassMomentOfInertiaUnit.KilogramSquareDecimeter: - return new MassMomentOfInertia((_value/1e5) * 1e3d, BaseUnit); - case MassMomentOfInertiaUnit.KilogramSquareMeter: - return new MassMomentOfInertia((_value/1e3) * 1e3d, BaseUnit); - case MassMomentOfInertiaUnit.KilogramSquareMillimeter: - return new MassMomentOfInertia((_value/1e9) * 1e3d, BaseUnit); - case MassMomentOfInertiaUnit.KilotonneSquareCentimeter: - return new MassMomentOfInertia((_value/1e1) * 1e3d, BaseUnit); - case MassMomentOfInertiaUnit.KilotonneSquareDecimeter: - return new MassMomentOfInertia((_value/1e-1) * 1e3d, BaseUnit); - case MassMomentOfInertiaUnit.KilotonneSquareMeter: - return new MassMomentOfInertia((_value/1e-3) * 1e3d, BaseUnit); - case MassMomentOfInertiaUnit.KilotonneSquareMilimeter: - return new MassMomentOfInertia((_value/1e3) * 1e3d, BaseUnit); - case MassMomentOfInertiaUnit.MegatonneSquareCentimeter: - return new MassMomentOfInertia((_value/1e1) * 1e6d, BaseUnit); - case MassMomentOfInertiaUnit.MegatonneSquareDecimeter: - return new MassMomentOfInertia((_value/1e-1) * 1e6d, BaseUnit); - case MassMomentOfInertiaUnit.MegatonneSquareMeter: - return new MassMomentOfInertia((_value/1e-3) * 1e6d, BaseUnit); - case MassMomentOfInertiaUnit.MegatonneSquareMilimeter: - return new MassMomentOfInertia((_value/1e3) * 1e6d, BaseUnit); - case MassMomentOfInertiaUnit.MilligramSquareCentimeter: - return new MassMomentOfInertia((_value/1e7) * 1e-3d, BaseUnit); - case MassMomentOfInertiaUnit.MilligramSquareDecimeter: - return new MassMomentOfInertia((_value/1e5) * 1e-3d, BaseUnit); - case MassMomentOfInertiaUnit.MilligramSquareMeter: - return new MassMomentOfInertia((_value/1e3) * 1e-3d, BaseUnit); - case MassMomentOfInertiaUnit.MilligramSquareMillimeter: - return new MassMomentOfInertia((_value/1e9) * 1e-3d, BaseUnit); - case MassMomentOfInertiaUnit.PoundSquareFoot: - return new MassMomentOfInertia(_value*4.21401101e-2, BaseUnit); - case MassMomentOfInertiaUnit.PoundSquareInch: - return new MassMomentOfInertia(_value*2.9263965e-4, BaseUnit); - case MassMomentOfInertiaUnit.SlugSquareFoot: - return new MassMomentOfInertia(_value*1.3558179619, BaseUnit); - case MassMomentOfInertiaUnit.SlugSquareInch: - return new MassMomentOfInertia(_value*9.41540242e-3, BaseUnit); - case MassMomentOfInertiaUnit.TonneSquareCentimeter: - return new MassMomentOfInertia(_value/1e1, BaseUnit); - case MassMomentOfInertiaUnit.TonneSquareDecimeter: - return new MassMomentOfInertia(_value/1e-1, BaseUnit); - case MassMomentOfInertiaUnit.TonneSquareMeter: - return new MassMomentOfInertia(_value/1e-3, BaseUnit); - case MassMomentOfInertiaUnit.TonneSquareMilimeter: - return new MassMomentOfInertia(_value/1e3, BaseUnit); + case MassMomentOfInertiaUnit.GramSquareCentimeter: return _value/1e7; + case MassMomentOfInertiaUnit.GramSquareDecimeter: return _value/1e5; + case MassMomentOfInertiaUnit.GramSquareMeter: return _value/1e3; + case MassMomentOfInertiaUnit.GramSquareMillimeter: return _value/1e9; + case MassMomentOfInertiaUnit.KilogramSquareCentimeter: return (_value/1e7) * 1e3d; + case MassMomentOfInertiaUnit.KilogramSquareDecimeter: return (_value/1e5) * 1e3d; + case MassMomentOfInertiaUnit.KilogramSquareMeter: return (_value/1e3) * 1e3d; + case MassMomentOfInertiaUnit.KilogramSquareMillimeter: return (_value/1e9) * 1e3d; + case MassMomentOfInertiaUnit.KilotonneSquareCentimeter: return (_value/1e1) * 1e3d; + case MassMomentOfInertiaUnit.KilotonneSquareDecimeter: return (_value/1e-1) * 1e3d; + case MassMomentOfInertiaUnit.KilotonneSquareMeter: return (_value/1e-3) * 1e3d; + case MassMomentOfInertiaUnit.KilotonneSquareMilimeter: return (_value/1e3) * 1e3d; + case MassMomentOfInertiaUnit.MegatonneSquareCentimeter: return (_value/1e1) * 1e6d; + case MassMomentOfInertiaUnit.MegatonneSquareDecimeter: return (_value/1e-1) * 1e6d; + case MassMomentOfInertiaUnit.MegatonneSquareMeter: return (_value/1e-3) * 1e6d; + case MassMomentOfInertiaUnit.MegatonneSquareMilimeter: return (_value/1e3) * 1e6d; + case MassMomentOfInertiaUnit.MilligramSquareCentimeter: return (_value/1e7) * 1e-3d; + case MassMomentOfInertiaUnit.MilligramSquareDecimeter: return (_value/1e5) * 1e-3d; + case MassMomentOfInertiaUnit.MilligramSquareMeter: return (_value/1e3) * 1e-3d; + case MassMomentOfInertiaUnit.MilligramSquareMillimeter: return (_value/1e9) * 1e-3d; + case MassMomentOfInertiaUnit.PoundSquareFoot: return _value*4.21401101e-2; + case MassMomentOfInertiaUnit.PoundSquareInch: return _value*2.9263965e-4; + case MassMomentOfInertiaUnit.SlugSquareFoot: return _value*1.3558179619; + case MassMomentOfInertiaUnit.SlugSquareInch: return _value*9.41540242e-3; + case MassMomentOfInertiaUnit.TonneSquareCentimeter: return _value/1e1; + case MassMomentOfInertiaUnit.TonneSquareDecimeter: return _value/1e-1; + case MassMomentOfInertiaUnit.TonneSquareMeter: return _value/1e-3; + case MassMomentOfInertiaUnit.TonneSquareMilimeter: return _value/1e3; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(MassMomentOfInertiaUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal MassMomentOfInertia ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new MassMomentOfInertia(baseUnitValue, BaseUnit); + } + + private double GetValueAs(MassMomentOfInertiaUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/MolarEnergy.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarEnergy.NetFramework.g.cs index a7ef49358d..1157b7897c 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 new MolarEnergy(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static MolarEnergy operator -(MolarEnergy left, MolarEnergy right) { - return new MolarEnergy(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new MolarEnergy(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static MolarEnergy operator *(double left, MolarEnergy right) @@ -418,22 +418,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out MolarE public static bool operator <=(MolarEnergy left, MolarEnergy right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(MolarEnergy left, MolarEnergy right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(MolarEnergy left, MolarEnergy right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(MolarEnergy left, MolarEnergy right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(MolarEnergy left, MolarEnergy right) @@ -457,7 +457,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(MolarEnergy other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -470,7 +470,7 @@ public override bool Equals(object obj) public bool Equals(MolarEnergy other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -546,7 +546,7 @@ public double As(MolarEnergyUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -556,7 +556,7 @@ public double As(MolarEnergyUnit unit) /// A MolarEnergy with the specified unit. public MolarEnergy ToUnit(MolarEnergyUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new MolarEnergy(convertedValue, unit); } @@ -565,28 +565,35 @@ public MolarEnergy ToUnit(MolarEnergyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal MolarEnergy AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case MolarEnergyUnit.JoulePerMole: - return new MolarEnergy(_value, BaseUnit); - case MolarEnergyUnit.KilojoulePerMole: - return new MolarEnergy((_value) * 1e3d, BaseUnit); - case MolarEnergyUnit.MegajoulePerMole: - return new MolarEnergy((_value) * 1e6d, BaseUnit); + case MolarEnergyUnit.JoulePerMole: return _value; + case MolarEnergyUnit.KilojoulePerMole: return (_value) * 1e3d; + case MolarEnergyUnit.MegajoulePerMole: return (_value) * 1e6d; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(MolarEnergyUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal MolarEnergy ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new MolarEnergy(baseUnitValue, BaseUnit); + } + + private double GetValueAs(MolarEnergyUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/MolarEntropy.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarEntropy.NetFramework.g.cs index 71b26c6201..062ec17556 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 new MolarEntropy(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static MolarEntropy operator -(MolarEntropy left, MolarEntropy right) { - return new MolarEntropy(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new MolarEntropy(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static MolarEntropy operator *(double left, MolarEntropy right) @@ -418,22 +418,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out MolarE public static bool operator <=(MolarEntropy left, MolarEntropy right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(MolarEntropy left, MolarEntropy right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(MolarEntropy left, MolarEntropy right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(MolarEntropy left, MolarEntropy right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(MolarEntropy left, MolarEntropy right) @@ -457,7 +457,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(MolarEntropy other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -470,7 +470,7 @@ public override bool Equals(object obj) public bool Equals(MolarEntropy other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -546,7 +546,7 @@ public double As(MolarEntropyUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -556,7 +556,7 @@ public double As(MolarEntropyUnit unit) /// A MolarEntropy with the specified unit. public MolarEntropy ToUnit(MolarEntropyUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new MolarEntropy(convertedValue, unit); } @@ -565,28 +565,35 @@ public MolarEntropy ToUnit(MolarEntropyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal MolarEntropy AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case MolarEntropyUnit.JoulePerMoleKelvin: - return new MolarEntropy(_value, BaseUnit); - case MolarEntropyUnit.KilojoulePerMoleKelvin: - return new MolarEntropy((_value) * 1e3d, BaseUnit); - case MolarEntropyUnit.MegajoulePerMoleKelvin: - return new MolarEntropy((_value) * 1e6d, BaseUnit); + case MolarEntropyUnit.JoulePerMoleKelvin: return _value; + case MolarEntropyUnit.KilojoulePerMoleKelvin: return (_value) * 1e3d; + case MolarEntropyUnit.MegajoulePerMoleKelvin: return (_value) * 1e6d; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(MolarEntropyUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal MolarEntropy ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new MolarEntropy(baseUnitValue, BaseUnit); + } + + private double GetValueAs(MolarEntropyUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/MolarMass.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarMass.NetFramework.g.cs index 79cb6b382c..b6198bb130 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 new MolarMass(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static MolarMass operator -(MolarMass left, MolarMass right) { - return new MolarMass(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new MolarMass(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static MolarMass operator *(double left, MolarMass right) @@ -544,22 +544,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out MolarM public static bool operator <=(MolarMass left, MolarMass right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(MolarMass left, MolarMass right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(MolarMass left, MolarMass right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(MolarMass left, MolarMass right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(MolarMass left, MolarMass right) @@ -583,7 +583,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(MolarMass other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -596,7 +596,7 @@ public override bool Equals(object obj) public bool Equals(MolarMass other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -672,7 +672,7 @@ public double As(MolarMassUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -682,7 +682,7 @@ public double As(MolarMassUnit unit) /// A MolarMass with the specified unit. public MolarMass ToUnit(MolarMassUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new MolarMass(convertedValue, unit); } @@ -691,46 +691,44 @@ public MolarMass ToUnit(MolarMassUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal MolarMass AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case MolarMassUnit.CentigramPerMole: - return new MolarMass((_value/1e3) * 1e-2d, BaseUnit); - case MolarMassUnit.DecagramPerMole: - return new MolarMass((_value/1e3) * 1e1d, BaseUnit); - case MolarMassUnit.DecigramPerMole: - return new MolarMass((_value/1e3) * 1e-1d, BaseUnit); - case MolarMassUnit.GramPerMole: - return new MolarMass(_value/1e3, BaseUnit); - case MolarMassUnit.HectogramPerMole: - return new MolarMass((_value/1e3) * 1e2d, BaseUnit); - case MolarMassUnit.KilogramPerMole: - return new MolarMass((_value/1e3) * 1e3d, BaseUnit); - case MolarMassUnit.KilopoundPerMole: - return new MolarMass((_value*0.45359237) * 1e3d, BaseUnit); - case MolarMassUnit.MegapoundPerMole: - return new MolarMass((_value*0.45359237) * 1e6d, BaseUnit); - case MolarMassUnit.MicrogramPerMole: - return new MolarMass((_value/1e3) * 1e-6d, BaseUnit); - case MolarMassUnit.MilligramPerMole: - return new MolarMass((_value/1e3) * 1e-3d, BaseUnit); - case MolarMassUnit.NanogramPerMole: - return new MolarMass((_value/1e3) * 1e-9d, BaseUnit); - case MolarMassUnit.PoundPerMole: - return new MolarMass(_value*0.45359237, BaseUnit); + case MolarMassUnit.CentigramPerMole: return (_value/1e3) * 1e-2d; + case MolarMassUnit.DecagramPerMole: return (_value/1e3) * 1e1d; + case MolarMassUnit.DecigramPerMole: return (_value/1e3) * 1e-1d; + case MolarMassUnit.GramPerMole: return _value/1e3; + case MolarMassUnit.HectogramPerMole: return (_value/1e3) * 1e2d; + case MolarMassUnit.KilogramPerMole: return (_value/1e3) * 1e3d; + case MolarMassUnit.KilopoundPerMole: return (_value*0.45359237) * 1e3d; + case MolarMassUnit.MegapoundPerMole: return (_value*0.45359237) * 1e6d; + case MolarMassUnit.MicrogramPerMole: return (_value/1e3) * 1e-6d; + case MolarMassUnit.MilligramPerMole: return (_value/1e3) * 1e-3d; + case MolarMassUnit.NanogramPerMole: return (_value/1e3) * 1e-9d; + case MolarMassUnit.PoundPerMole: return _value*0.45359237; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(MolarMassUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal MolarMass ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new MolarMass(baseUnitValue, BaseUnit); + } + + private double GetValueAs(MolarMassUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Molarity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Molarity.NetFramework.g.cs index f9c834028e..0daf63bab2 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 new Molarity(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static Molarity operator -(Molarity left, Molarity right) { - return new Molarity(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new Molarity(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static Molarity operator *(double left, Molarity right) @@ -491,22 +491,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Molari public static bool operator <=(Molarity left, Molarity right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(Molarity left, Molarity right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(Molarity left, Molarity right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(Molarity left, Molarity right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(Molarity left, Molarity right) @@ -530,7 +530,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(Molarity other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -543,7 +543,7 @@ public override bool Equals(object obj) public bool Equals(Molarity other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -619,7 +619,7 @@ public double As(MolarityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -629,7 +629,7 @@ public double As(MolarityUnit unit) /// A Molarity with the specified unit. public Molarity ToUnit(MolarityUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Molarity(convertedValue, unit); } @@ -638,38 +638,40 @@ public Molarity ToUnit(MolarityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Molarity AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case MolarityUnit.CentimolesPerLiter: - return new Molarity((_value/1e-3) * 1e-2d, BaseUnit); - case MolarityUnit.DecimolesPerLiter: - return new Molarity((_value/1e-3) * 1e-1d, BaseUnit); - case MolarityUnit.MicromolesPerLiter: - return new Molarity((_value/1e-3) * 1e-6d, BaseUnit); - case MolarityUnit.MillimolesPerLiter: - return new Molarity((_value/1e-3) * 1e-3d, BaseUnit); - case MolarityUnit.MolesPerCubicMeter: - return new Molarity(_value, BaseUnit); - case MolarityUnit.MolesPerLiter: - return new Molarity(_value/1e-3, BaseUnit); - case MolarityUnit.NanomolesPerLiter: - return new Molarity((_value/1e-3) * 1e-9d, BaseUnit); - case MolarityUnit.PicomolesPerLiter: - return new Molarity((_value/1e-3) * 1e-12d, BaseUnit); + case MolarityUnit.CentimolesPerLiter: return (_value/1e-3) * 1e-2d; + case MolarityUnit.DecimolesPerLiter: return (_value/1e-3) * 1e-1d; + case MolarityUnit.MicromolesPerLiter: return (_value/1e-3) * 1e-6d; + case MolarityUnit.MillimolesPerLiter: return (_value/1e-3) * 1e-3d; + case MolarityUnit.MolesPerCubicMeter: return _value; + case MolarityUnit.MolesPerLiter: return _value/1e-3; + case MolarityUnit.NanomolesPerLiter: return (_value/1e-3) * 1e-9d; + case MolarityUnit.PicomolesPerLiter: return (_value/1e-3) * 1e-12d; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(MolarityUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Molarity ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Molarity(baseUnitValue, BaseUnit); + } + + private double GetValueAs(MolarityUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Permeability.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Permeability.NetFramework.g.cs index 1137cb4036..14bc163f24 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 new Permeability(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static Permeability operator -(Permeability left, Permeability right) { - return new Permeability(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new Permeability(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static Permeability operator *(double left, Permeability right) @@ -393,22 +393,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Permea public static bool operator <=(Permeability left, Permeability right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(Permeability left, Permeability right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(Permeability left, Permeability right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(Permeability left, Permeability right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(Permeability left, Permeability right) @@ -432,7 +432,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(Permeability other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -445,7 +445,7 @@ public override bool Equals(object obj) public bool Equals(Permeability other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -521,7 +521,7 @@ public double As(PermeabilityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -531,7 +531,7 @@ public double As(PermeabilityUnit unit) /// A Permeability with the specified unit. public Permeability ToUnit(PermeabilityUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Permeability(convertedValue, unit); } @@ -540,24 +540,33 @@ public Permeability ToUnit(PermeabilityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Permeability AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case PermeabilityUnit.HenryPerMeter: - return new Permeability(_value, BaseUnit); + case PermeabilityUnit.HenryPerMeter: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(PermeabilityUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Permeability ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Permeability(baseUnitValue, BaseUnit); + } + + private double GetValueAs(PermeabilityUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Permittivity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Permittivity.NetFramework.g.cs index a361542ba9..246d72220c 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 new Permittivity(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static Permittivity operator -(Permittivity left, Permittivity right) { - return new Permittivity(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new Permittivity(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static Permittivity operator *(double left, Permittivity right) @@ -393,22 +393,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Permit public static bool operator <=(Permittivity left, Permittivity right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(Permittivity left, Permittivity right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(Permittivity left, Permittivity right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(Permittivity left, Permittivity right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(Permittivity left, Permittivity right) @@ -432,7 +432,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(Permittivity other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -445,7 +445,7 @@ public override bool Equals(object obj) public bool Equals(Permittivity other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -521,7 +521,7 @@ public double As(PermittivityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -531,7 +531,7 @@ public double As(PermittivityUnit unit) /// A Permittivity with the specified unit. public Permittivity ToUnit(PermittivityUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Permittivity(convertedValue, unit); } @@ -540,24 +540,33 @@ public Permittivity ToUnit(PermittivityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Permittivity AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case PermittivityUnit.FaradPerMeter: - return new Permittivity(_value, BaseUnit); + case PermittivityUnit.FaradPerMeter: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(PermittivityUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Permittivity ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Permittivity(baseUnitValue, BaseUnit); + } + + private double GetValueAs(PermittivityUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Power.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Power.NetFramework.g.cs index feecc630c3..0e8856b81b 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 new Power(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static Power operator -(Power left, Power right) { - return new Power(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new Power(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static Power operator *(decimal left, Power right) @@ -656,22 +656,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out PowerU public static bool operator <=(Power left, Power right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(Power left, Power right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(Power left, Power right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(Power left, Power right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(Power left, Power right) @@ -695,7 +695,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(Power other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -708,7 +708,7 @@ public override bool Equals(object obj) public bool Equals(Power other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -784,7 +784,7 @@ public double As(PowerUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -794,7 +794,7 @@ public double As(PowerUnit unit) /// A Power with the specified unit. public Power ToUnit(PowerUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Power(convertedValue, unit); } @@ -803,62 +803,52 @@ public Power ToUnit(PowerUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Power AsBaseUnit() + private decimal GetValueInBaseUnit() { switch(Unit) { - case PowerUnit.BoilerHorsepower: - return new Power(_value*9812.5m, BaseUnit); - case PowerUnit.BritishThermalUnitPerHour: - return new Power(_value*0.293071m, BaseUnit); - case PowerUnit.Decawatt: - return new Power((_value) * 1e1m, BaseUnit); - case PowerUnit.Deciwatt: - return new Power((_value) * 1e-1m, BaseUnit); - case PowerUnit.ElectricalHorsepower: - return new Power(_value*746m, BaseUnit); - case PowerUnit.Femtowatt: - return new Power((_value) * 1e-15m, BaseUnit); - case PowerUnit.Gigawatt: - return new Power((_value) * 1e9m, BaseUnit); - case PowerUnit.HydraulicHorsepower: - return new Power(_value*745.69988145m, BaseUnit); - case PowerUnit.KilobritishThermalUnitPerHour: - return new Power((_value*0.293071m) * 1e3m, BaseUnit); - case PowerUnit.Kilowatt: - return new Power((_value) * 1e3m, BaseUnit); - case PowerUnit.MechanicalHorsepower: - return new Power(_value*745.69m, BaseUnit); - case PowerUnit.Megawatt: - return new Power((_value) * 1e6m, BaseUnit); - case PowerUnit.MetricHorsepower: - return new Power(_value*735.49875m, BaseUnit); - case PowerUnit.Microwatt: - return new Power((_value) * 1e-6m, BaseUnit); - case PowerUnit.Milliwatt: - return new Power((_value) * 1e-3m, BaseUnit); - case PowerUnit.Nanowatt: - return new Power((_value) * 1e-9m, BaseUnit); - case PowerUnit.Petawatt: - return new Power((_value) * 1e15m, BaseUnit); - case PowerUnit.Picowatt: - return new Power((_value) * 1e-12m, BaseUnit); - case PowerUnit.Terawatt: - return new Power((_value) * 1e12m, BaseUnit); - case PowerUnit.Watt: - return new Power(_value, BaseUnit); + case PowerUnit.BoilerHorsepower: return _value*9812.5m; + case PowerUnit.BritishThermalUnitPerHour: return _value*0.293071m; + case PowerUnit.Decawatt: return (_value) * 1e1m; + case PowerUnit.Deciwatt: return (_value) * 1e-1m; + case PowerUnit.ElectricalHorsepower: return _value*746m; + case PowerUnit.Femtowatt: return (_value) * 1e-15m; + case PowerUnit.Gigawatt: return (_value) * 1e9m; + case PowerUnit.HydraulicHorsepower: return _value*745.69988145m; + case PowerUnit.KilobritishThermalUnitPerHour: return (_value*0.293071m) * 1e3m; + case PowerUnit.Kilowatt: return (_value) * 1e3m; + case PowerUnit.MechanicalHorsepower: return _value*745.69m; + case PowerUnit.Megawatt: return (_value) * 1e6m; + case PowerUnit.MetricHorsepower: return _value*735.49875m; + case PowerUnit.Microwatt: return (_value) * 1e-6m; + case PowerUnit.Milliwatt: return (_value) * 1e-3m; + case PowerUnit.Nanowatt: return (_value) * 1e-9m; + case PowerUnit.Petawatt: return (_value) * 1e15m; + case PowerUnit.Picowatt: return (_value) * 1e-12m; + case PowerUnit.Terawatt: return (_value) * 1e12m; + case PowerUnit.Watt: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private decimal AsBaseNumericType(PowerUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Power ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Power(baseUnitValue, BaseUnit); + } + + private decimal GetValueAs(PowerUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/PowerDensity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/PowerDensity.NetFramework.g.cs index 87f715d862..1ef3defe3e 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 new PowerDensity(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static PowerDensity operator -(PowerDensity left, PowerDensity right) { - return new PowerDensity(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new PowerDensity(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static PowerDensity operator *(double left, PowerDensity right) @@ -992,22 +992,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out PowerD public static bool operator <=(PowerDensity left, PowerDensity right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(PowerDensity left, PowerDensity right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(PowerDensity left, PowerDensity right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(PowerDensity left, PowerDensity right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(PowerDensity left, PowerDensity right) @@ -1031,7 +1031,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(PowerDensity other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -1044,7 +1044,7 @@ public override bool Equals(object obj) public bool Equals(PowerDensity other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -1120,7 +1120,7 @@ public double As(PowerDensityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -1130,7 +1130,7 @@ public double As(PowerDensityUnit unit) /// A PowerDensity with the specified unit. public PowerDensity ToUnit(PowerDensityUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new PowerDensity(convertedValue, unit); } @@ -1139,110 +1139,76 @@ public PowerDensity ToUnit(PowerDensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal PowerDensity AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case PowerDensityUnit.DecawattPerCubicFoot: - return new PowerDensity((_value*3.531466672148859e1) * 1e1d, BaseUnit); - case PowerDensityUnit.DecawattPerCubicInch: - return new PowerDensity((_value*6.102374409473228e4) * 1e1d, BaseUnit); - case PowerDensityUnit.DecawattPerCubicMeter: - return new PowerDensity((_value) * 1e1d, BaseUnit); - case PowerDensityUnit.DecawattPerLiter: - return new PowerDensity((_value*1.0e3) * 1e1d, BaseUnit); - case PowerDensityUnit.DeciwattPerCubicFoot: - return new PowerDensity((_value*3.531466672148859e1) * 1e-1d, BaseUnit); - case PowerDensityUnit.DeciwattPerCubicInch: - return new PowerDensity((_value*6.102374409473228e4) * 1e-1d, BaseUnit); - case PowerDensityUnit.DeciwattPerCubicMeter: - return new PowerDensity((_value) * 1e-1d, BaseUnit); - case PowerDensityUnit.DeciwattPerLiter: - return new PowerDensity((_value*1.0e3) * 1e-1d, BaseUnit); - case PowerDensityUnit.GigawattPerCubicFoot: - return new PowerDensity((_value*3.531466672148859e1) * 1e9d, BaseUnit); - case PowerDensityUnit.GigawattPerCubicInch: - return new PowerDensity((_value*6.102374409473228e4) * 1e9d, BaseUnit); - case PowerDensityUnit.GigawattPerCubicMeter: - return new PowerDensity((_value) * 1e9d, BaseUnit); - case PowerDensityUnit.GigawattPerLiter: - return new PowerDensity((_value*1.0e3) * 1e9d, BaseUnit); - case PowerDensityUnit.KilowattPerCubicFoot: - return new PowerDensity((_value*3.531466672148859e1) * 1e3d, BaseUnit); - case PowerDensityUnit.KilowattPerCubicInch: - return new PowerDensity((_value*6.102374409473228e4) * 1e3d, BaseUnit); - case PowerDensityUnit.KilowattPerCubicMeter: - return new PowerDensity((_value) * 1e3d, BaseUnit); - case PowerDensityUnit.KilowattPerLiter: - return new PowerDensity((_value*1.0e3) * 1e3d, BaseUnit); - case PowerDensityUnit.MegawattPerCubicFoot: - return new PowerDensity((_value*3.531466672148859e1) * 1e6d, BaseUnit); - case PowerDensityUnit.MegawattPerCubicInch: - return new PowerDensity((_value*6.102374409473228e4) * 1e6d, BaseUnit); - case PowerDensityUnit.MegawattPerCubicMeter: - return new PowerDensity((_value) * 1e6d, BaseUnit); - case PowerDensityUnit.MegawattPerLiter: - return new PowerDensity((_value*1.0e3) * 1e6d, BaseUnit); - case PowerDensityUnit.MicrowattPerCubicFoot: - return new PowerDensity((_value*3.531466672148859e1) * 1e-6d, BaseUnit); - case PowerDensityUnit.MicrowattPerCubicInch: - return new PowerDensity((_value*6.102374409473228e4) * 1e-6d, BaseUnit); - case PowerDensityUnit.MicrowattPerCubicMeter: - return new PowerDensity((_value) * 1e-6d, BaseUnit); - case PowerDensityUnit.MicrowattPerLiter: - return new PowerDensity((_value*1.0e3) * 1e-6d, BaseUnit); - case PowerDensityUnit.MilliwattPerCubicFoot: - return new PowerDensity((_value*3.531466672148859e1) * 1e-3d, BaseUnit); - case PowerDensityUnit.MilliwattPerCubicInch: - return new PowerDensity((_value*6.102374409473228e4) * 1e-3d, BaseUnit); - case PowerDensityUnit.MilliwattPerCubicMeter: - return new PowerDensity((_value) * 1e-3d, BaseUnit); - case PowerDensityUnit.MilliwattPerLiter: - return new PowerDensity((_value*1.0e3) * 1e-3d, BaseUnit); - case PowerDensityUnit.NanowattPerCubicFoot: - return new PowerDensity((_value*3.531466672148859e1) * 1e-9d, BaseUnit); - case PowerDensityUnit.NanowattPerCubicInch: - return new PowerDensity((_value*6.102374409473228e4) * 1e-9d, BaseUnit); - case PowerDensityUnit.NanowattPerCubicMeter: - return new PowerDensity((_value) * 1e-9d, BaseUnit); - case PowerDensityUnit.NanowattPerLiter: - return new PowerDensity((_value*1.0e3) * 1e-9d, BaseUnit); - case PowerDensityUnit.PicowattPerCubicFoot: - return new PowerDensity((_value*3.531466672148859e1) * 1e-12d, BaseUnit); - case PowerDensityUnit.PicowattPerCubicInch: - return new PowerDensity((_value*6.102374409473228e4) * 1e-12d, BaseUnit); - case PowerDensityUnit.PicowattPerCubicMeter: - return new PowerDensity((_value) * 1e-12d, BaseUnit); - case PowerDensityUnit.PicowattPerLiter: - return new PowerDensity((_value*1.0e3) * 1e-12d, BaseUnit); - case PowerDensityUnit.TerawattPerCubicFoot: - return new PowerDensity((_value*3.531466672148859e1) * 1e12d, BaseUnit); - case PowerDensityUnit.TerawattPerCubicInch: - return new PowerDensity((_value*6.102374409473228e4) * 1e12d, BaseUnit); - case PowerDensityUnit.TerawattPerCubicMeter: - return new PowerDensity((_value) * 1e12d, BaseUnit); - case PowerDensityUnit.TerawattPerLiter: - return new PowerDensity((_value*1.0e3) * 1e12d, BaseUnit); - case PowerDensityUnit.WattPerCubicFoot: - return new PowerDensity(_value*3.531466672148859e1, BaseUnit); - case PowerDensityUnit.WattPerCubicInch: - return new PowerDensity(_value*6.102374409473228e4, BaseUnit); - case PowerDensityUnit.WattPerCubicMeter: - return new PowerDensity(_value, BaseUnit); - case PowerDensityUnit.WattPerLiter: - return new PowerDensity(_value*1.0e3, BaseUnit); + case PowerDensityUnit.DecawattPerCubicFoot: return (_value*3.531466672148859e1) * 1e1d; + case PowerDensityUnit.DecawattPerCubicInch: return (_value*6.102374409473228e4) * 1e1d; + case PowerDensityUnit.DecawattPerCubicMeter: return (_value) * 1e1d; + case PowerDensityUnit.DecawattPerLiter: return (_value*1.0e3) * 1e1d; + case PowerDensityUnit.DeciwattPerCubicFoot: return (_value*3.531466672148859e1) * 1e-1d; + case PowerDensityUnit.DeciwattPerCubicInch: return (_value*6.102374409473228e4) * 1e-1d; + case PowerDensityUnit.DeciwattPerCubicMeter: return (_value) * 1e-1d; + case PowerDensityUnit.DeciwattPerLiter: return (_value*1.0e3) * 1e-1d; + case PowerDensityUnit.GigawattPerCubicFoot: return (_value*3.531466672148859e1) * 1e9d; + case PowerDensityUnit.GigawattPerCubicInch: return (_value*6.102374409473228e4) * 1e9d; + case PowerDensityUnit.GigawattPerCubicMeter: return (_value) * 1e9d; + case PowerDensityUnit.GigawattPerLiter: return (_value*1.0e3) * 1e9d; + case PowerDensityUnit.KilowattPerCubicFoot: return (_value*3.531466672148859e1) * 1e3d; + case PowerDensityUnit.KilowattPerCubicInch: return (_value*6.102374409473228e4) * 1e3d; + case PowerDensityUnit.KilowattPerCubicMeter: return (_value) * 1e3d; + case PowerDensityUnit.KilowattPerLiter: return (_value*1.0e3) * 1e3d; + case PowerDensityUnit.MegawattPerCubicFoot: return (_value*3.531466672148859e1) * 1e6d; + case PowerDensityUnit.MegawattPerCubicInch: return (_value*6.102374409473228e4) * 1e6d; + case PowerDensityUnit.MegawattPerCubicMeter: return (_value) * 1e6d; + case PowerDensityUnit.MegawattPerLiter: return (_value*1.0e3) * 1e6d; + case PowerDensityUnit.MicrowattPerCubicFoot: return (_value*3.531466672148859e1) * 1e-6d; + case PowerDensityUnit.MicrowattPerCubicInch: return (_value*6.102374409473228e4) * 1e-6d; + case PowerDensityUnit.MicrowattPerCubicMeter: return (_value) * 1e-6d; + case PowerDensityUnit.MicrowattPerLiter: return (_value*1.0e3) * 1e-6d; + case PowerDensityUnit.MilliwattPerCubicFoot: return (_value*3.531466672148859e1) * 1e-3d; + case PowerDensityUnit.MilliwattPerCubicInch: return (_value*6.102374409473228e4) * 1e-3d; + case PowerDensityUnit.MilliwattPerCubicMeter: return (_value) * 1e-3d; + case PowerDensityUnit.MilliwattPerLiter: return (_value*1.0e3) * 1e-3d; + case PowerDensityUnit.NanowattPerCubicFoot: return (_value*3.531466672148859e1) * 1e-9d; + case PowerDensityUnit.NanowattPerCubicInch: return (_value*6.102374409473228e4) * 1e-9d; + case PowerDensityUnit.NanowattPerCubicMeter: return (_value) * 1e-9d; + case PowerDensityUnit.NanowattPerLiter: return (_value*1.0e3) * 1e-9d; + case PowerDensityUnit.PicowattPerCubicFoot: return (_value*3.531466672148859e1) * 1e-12d; + case PowerDensityUnit.PicowattPerCubicInch: return (_value*6.102374409473228e4) * 1e-12d; + case PowerDensityUnit.PicowattPerCubicMeter: return (_value) * 1e-12d; + case PowerDensityUnit.PicowattPerLiter: return (_value*1.0e3) * 1e-12d; + case PowerDensityUnit.TerawattPerCubicFoot: return (_value*3.531466672148859e1) * 1e12d; + case PowerDensityUnit.TerawattPerCubicInch: return (_value*6.102374409473228e4) * 1e12d; + case PowerDensityUnit.TerawattPerCubicMeter: return (_value) * 1e12d; + case PowerDensityUnit.TerawattPerLiter: return (_value*1.0e3) * 1e12d; + case PowerDensityUnit.WattPerCubicFoot: return _value*3.531466672148859e1; + case PowerDensityUnit.WattPerCubicInch: return _value*6.102374409473228e4; + case PowerDensityUnit.WattPerCubicMeter: return _value; + case PowerDensityUnit.WattPerLiter: return _value*1.0e3; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(PowerDensityUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal PowerDensity ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new PowerDensity(baseUnitValue, BaseUnit); + } + + private double GetValueAs(PowerDensityUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/PowerRatio.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/PowerRatio.NetFramework.g.cs index 16386a24a2..e16526309a 100644 --- a/UnitsNet/GeneratedCode/Quantities/PowerRatio.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/PowerRatio.NetFramework.g.cs @@ -372,14 +372,14 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out PowerR { // Logarithmic addition // Formula: 10*log10(10^(x/10) + 10^(y/10)) - return new PowerRatio(10*Math.Log10(Math.Pow(10, left.Value/10) + Math.Pow(10, right.AsBaseNumericType(left.Unit)/10)), left.Unit); + return new PowerRatio(10*Math.Log10(Math.Pow(10, left.Value/10) + Math.Pow(10, right.GetValueAs(left.Unit)/10)), left.Unit); } public static PowerRatio operator -(PowerRatio left, PowerRatio right) { // Logarithmic subtraction // Formula: 10*log10(10^(x/10) - 10^(y/10)) - return new PowerRatio(10*Math.Log10(Math.Pow(10, left.Value/10) - Math.Pow(10, right.AsBaseNumericType(left.Unit)/10)), left.Unit); + return new PowerRatio(10*Math.Log10(Math.Pow(10, left.Value/10) - Math.Pow(10, right.GetValueAs(left.Unit)/10)), left.Unit); } public static PowerRatio operator *(double left, PowerRatio right) @@ -403,7 +403,7 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out PowerR public static double operator /(PowerRatio left, PowerRatio right) { // Logarithmic division = subtraction - return Convert.ToDouble(left.Value - right.AsBaseNumericType(left.Unit)); + return Convert.ToDouble(left.Value - right.GetValueAs(left.Unit)); } #endregion @@ -412,22 +412,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out PowerR public static bool operator <=(PowerRatio left, PowerRatio right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(PowerRatio left, PowerRatio right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(PowerRatio left, PowerRatio right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(PowerRatio left, PowerRatio right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(PowerRatio left, PowerRatio right) @@ -451,7 +451,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(PowerRatio other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -464,7 +464,7 @@ public override bool Equals(object obj) public bool Equals(PowerRatio other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -540,7 +540,7 @@ public double As(PowerRatioUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -550,7 +550,7 @@ public double As(PowerRatioUnit unit) /// A PowerRatio with the specified unit. public PowerRatio ToUnit(PowerRatioUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new PowerRatio(convertedValue, unit); } @@ -559,26 +559,34 @@ public PowerRatio ToUnit(PowerRatioUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal PowerRatio AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case PowerRatioUnit.DecibelMilliwatt: - return new PowerRatio(_value - 30, BaseUnit); - case PowerRatioUnit.DecibelWatt: - return new PowerRatio(_value, BaseUnit); + case PowerRatioUnit.DecibelMilliwatt: return _value - 30; + case PowerRatioUnit.DecibelWatt: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(PowerRatioUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal PowerRatio ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new PowerRatio(baseUnitValue, BaseUnit); + } + + private double GetValueAs(PowerRatioUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Pressure.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Pressure.NetFramework.g.cs index 503c39a007..87774da841 100644 --- a/UnitsNet/GeneratedCode/Quantities/Pressure.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Pressure.NetFramework.g.cs @@ -930,12 +930,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 new Pressure(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static Pressure operator -(Pressure left, Pressure right) { - return new Pressure(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new Pressure(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static Pressure operator *(double left, Pressure right) @@ -964,22 +964,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Pressu public static bool operator <=(Pressure left, Pressure right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(Pressure left, Pressure right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(Pressure left, Pressure right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(Pressure left, Pressure right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(Pressure left, Pressure right) @@ -1003,7 +1003,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(Pressure other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -1016,7 +1016,7 @@ public override bool Equals(object obj) public bool Equals(Pressure other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -1092,7 +1092,7 @@ public double As(PressureUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -1102,7 +1102,7 @@ public double As(PressureUnit unit) /// A Pressure with the specified unit. public Pressure ToUnit(PressureUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Pressure(convertedValue, unit); } @@ -1111,106 +1111,74 @@ public Pressure ToUnit(PressureUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Pressure AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case PressureUnit.Atmosphere: - return new Pressure(_value*1.01325*1e5, BaseUnit); - case PressureUnit.Bar: - return new Pressure(_value*1e5, BaseUnit); - case PressureUnit.Centibar: - return new Pressure((_value*1e5) * 1e-2d, BaseUnit); - case PressureUnit.Decapascal: - return new Pressure((_value) * 1e1d, BaseUnit); - case PressureUnit.Decibar: - return new Pressure((_value*1e5) * 1e-1d, BaseUnit); - case PressureUnit.DynePerSquareCentimeter: - return new Pressure(_value*1.0e-1, BaseUnit); - case PressureUnit.FootOfHead: - return new Pressure(_value*2989.0669, BaseUnit); - case PressureUnit.Gigapascal: - return new Pressure((_value) * 1e9d, BaseUnit); - case PressureUnit.Hectopascal: - return new Pressure((_value) * 1e2d, BaseUnit); - case PressureUnit.InchOfMercury: - return new Pressure(_value/2.95299830714159e-4, BaseUnit); - case PressureUnit.InchOfWaterColumn: - return new Pressure(_value*249.08890833333, BaseUnit); - case PressureUnit.Kilobar: - return new Pressure((_value*1e5) * 1e3d, BaseUnit); - case PressureUnit.KilogramForcePerSquareCentimeter: - return new Pressure(_value*9.80665e4, BaseUnit); - case PressureUnit.KilogramForcePerSquareMeter: - return new Pressure(_value*9.80665019960652, BaseUnit); - case PressureUnit.KilogramForcePerSquareMillimeter: - return new Pressure(_value*9.80665e6, BaseUnit); - case PressureUnit.KilonewtonPerSquareCentimeter: - return new Pressure((_value*1e4) * 1e3d, BaseUnit); - case PressureUnit.KilonewtonPerSquareMeter: - return new Pressure((_value) * 1e3d, BaseUnit); - case PressureUnit.KilonewtonPerSquareMillimeter: - return new Pressure((_value*1e6) * 1e3d, BaseUnit); - case PressureUnit.Kilopascal: - return new Pressure((_value) * 1e3d, BaseUnit); - case PressureUnit.KilopoundForcePerSquareFoot: - return new Pressure((_value*4.788025898033584e1) * 1e3d, BaseUnit); - case PressureUnit.KilopoundForcePerSquareInch: - return new Pressure((_value*6.894757293168361e3) * 1e3d, BaseUnit); - case PressureUnit.Megabar: - return new Pressure((_value*1e5) * 1e6d, BaseUnit); - case PressureUnit.MeganewtonPerSquareMeter: - return new Pressure((_value) * 1e6d, BaseUnit); - case PressureUnit.Megapascal: - return new Pressure((_value) * 1e6d, BaseUnit); - case PressureUnit.MeterOfHead: - return new Pressure(_value*9804.139432, BaseUnit); - case PressureUnit.Microbar: - return new Pressure((_value*1e5) * 1e-6d, BaseUnit); - case PressureUnit.Micropascal: - return new Pressure((_value) * 1e-6d, BaseUnit); - case PressureUnit.Millibar: - return new Pressure((_value*1e5) * 1e-3d, BaseUnit); - case PressureUnit.MillimeterOfMercury: - return new Pressure(_value/7.50061561302643e-3, BaseUnit); - case PressureUnit.Millipascal: - return new Pressure((_value) * 1e-3d, BaseUnit); - case PressureUnit.NewtonPerSquareCentimeter: - return new Pressure(_value*1e4, BaseUnit); - case PressureUnit.NewtonPerSquareMeter: - return new Pressure(_value, BaseUnit); - case PressureUnit.NewtonPerSquareMillimeter: - return new Pressure(_value*1e6, BaseUnit); - case PressureUnit.Pascal: - return new Pressure(_value, BaseUnit); - case PressureUnit.PoundForcePerSquareFoot: - return new Pressure(_value*4.788025898033584e1, BaseUnit); - case PressureUnit.PoundForcePerSquareInch: - return new Pressure(_value*6.894757293168361e3, BaseUnit); - case PressureUnit.PoundPerInchSecondSquared: - return new Pressure(_value*1.785796732283465e1, BaseUnit); - case PressureUnit.TechnicalAtmosphere: - return new Pressure(_value*9.80680592331*1e4, BaseUnit); - case PressureUnit.TonneForcePerSquareCentimeter: - return new Pressure(_value*9.80665e7, BaseUnit); - case PressureUnit.TonneForcePerSquareMeter: - return new Pressure(_value*9.80665e3, BaseUnit); - case PressureUnit.TonneForcePerSquareMillimeter: - return new Pressure(_value*9.80665e9, BaseUnit); - case PressureUnit.Torr: - return new Pressure(_value*1.3332266752*1e2, BaseUnit); + case PressureUnit.Atmosphere: return _value*1.01325*1e5; + case PressureUnit.Bar: return _value*1e5; + case PressureUnit.Centibar: return (_value*1e5) * 1e-2d; + case PressureUnit.Decapascal: return (_value) * 1e1d; + case PressureUnit.Decibar: return (_value*1e5) * 1e-1d; + case PressureUnit.DynePerSquareCentimeter: return _value*1.0e-1; + case PressureUnit.FootOfHead: return _value*2989.0669; + case PressureUnit.Gigapascal: return (_value) * 1e9d; + case PressureUnit.Hectopascal: return (_value) * 1e2d; + case PressureUnit.InchOfMercury: return _value/2.95299830714159e-4; + case PressureUnit.InchOfWaterColumn: return _value*249.08890833333; + case PressureUnit.Kilobar: return (_value*1e5) * 1e3d; + case PressureUnit.KilogramForcePerSquareCentimeter: return _value*9.80665e4; + case PressureUnit.KilogramForcePerSquareMeter: return _value*9.80665019960652; + case PressureUnit.KilogramForcePerSquareMillimeter: return _value*9.80665e6; + case PressureUnit.KilonewtonPerSquareCentimeter: return (_value*1e4) * 1e3d; + case PressureUnit.KilonewtonPerSquareMeter: return (_value) * 1e3d; + case PressureUnit.KilonewtonPerSquareMillimeter: return (_value*1e6) * 1e3d; + case PressureUnit.Kilopascal: return (_value) * 1e3d; + case PressureUnit.KilopoundForcePerSquareFoot: return (_value*4.788025898033584e1) * 1e3d; + case PressureUnit.KilopoundForcePerSquareInch: return (_value*6.894757293168361e3) * 1e3d; + case PressureUnit.Megabar: return (_value*1e5) * 1e6d; + case PressureUnit.MeganewtonPerSquareMeter: return (_value) * 1e6d; + case PressureUnit.Megapascal: return (_value) * 1e6d; + case PressureUnit.MeterOfHead: return _value*9804.139432; + case PressureUnit.Microbar: return (_value*1e5) * 1e-6d; + case PressureUnit.Micropascal: return (_value) * 1e-6d; + case PressureUnit.Millibar: return (_value*1e5) * 1e-3d; + case PressureUnit.MillimeterOfMercury: return _value/7.50061561302643e-3; + case PressureUnit.Millipascal: return (_value) * 1e-3d; + case PressureUnit.NewtonPerSquareCentimeter: return _value*1e4; + case PressureUnit.NewtonPerSquareMeter: return _value; + case PressureUnit.NewtonPerSquareMillimeter: return _value*1e6; + case PressureUnit.Pascal: return _value; + case PressureUnit.PoundForcePerSquareFoot: return _value*4.788025898033584e1; + case PressureUnit.PoundForcePerSquareInch: return _value*6.894757293168361e3; + case PressureUnit.PoundPerInchSecondSquared: return _value*1.785796732283465e1; + case PressureUnit.TechnicalAtmosphere: return _value*9.80680592331*1e4; + case PressureUnit.TonneForcePerSquareCentimeter: return _value*9.80665e7; + case PressureUnit.TonneForcePerSquareMeter: return _value*9.80665e3; + case PressureUnit.TonneForcePerSquareMillimeter: return _value*9.80665e9; + case PressureUnit.Torr: return _value*1.3332266752*1e2; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(PressureUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Pressure ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Pressure(baseUnitValue, BaseUnit); + } + + private double GetValueAs(PressureUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.NetFramework.g.cs index a238c9964f..e774a155cd 100644 --- a/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.NetFramework.g.cs @@ -440,12 +440,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 new PressureChangeRate(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static PressureChangeRate operator -(PressureChangeRate left, PressureChangeRate right) { - return new PressureChangeRate(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new PressureChangeRate(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static PressureChangeRate operator *(double left, PressureChangeRate right) @@ -474,22 +474,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Pressu public static bool operator <=(PressureChangeRate left, PressureChangeRate right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(PressureChangeRate left, PressureChangeRate right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(PressureChangeRate left, PressureChangeRate right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(PressureChangeRate left, PressureChangeRate right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(PressureChangeRate left, PressureChangeRate right) @@ -513,7 +513,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(PressureChangeRate other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -526,7 +526,7 @@ public override bool Equals(object obj) public bool Equals(PressureChangeRate other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -602,7 +602,7 @@ public double As(PressureChangeRateUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -612,7 +612,7 @@ public double As(PressureChangeRateUnit unit) /// A PressureChangeRate with the specified unit. public PressureChangeRate ToUnit(PressureChangeRateUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new PressureChangeRate(convertedValue, unit); } @@ -621,36 +621,39 @@ public PressureChangeRate ToUnit(PressureChangeRateUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal PressureChangeRate AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case PressureChangeRateUnit.AtmospherePerSecond: - return new PressureChangeRate(_value * 1.01325*1e5, BaseUnit); - case PressureChangeRateUnit.KilopascalPerMinute: - return new PressureChangeRate((_value/60) * 1e3d, BaseUnit); - case PressureChangeRateUnit.KilopascalPerSecond: - return new PressureChangeRate((_value) * 1e3d, BaseUnit); - case PressureChangeRateUnit.MegapascalPerMinute: - return new PressureChangeRate((_value/60) * 1e6d, BaseUnit); - case PressureChangeRateUnit.MegapascalPerSecond: - return new PressureChangeRate((_value) * 1e6d, BaseUnit); - case PressureChangeRateUnit.PascalPerMinute: - return new PressureChangeRate(_value/60, BaseUnit); - case PressureChangeRateUnit.PascalPerSecond: - return new PressureChangeRate(_value, BaseUnit); + case PressureChangeRateUnit.AtmospherePerSecond: return _value * 1.01325*1e5; + case PressureChangeRateUnit.KilopascalPerMinute: return (_value/60) * 1e3d; + case PressureChangeRateUnit.KilopascalPerSecond: return (_value) * 1e3d; + case PressureChangeRateUnit.MegapascalPerMinute: return (_value/60) * 1e6d; + case PressureChangeRateUnit.MegapascalPerSecond: return (_value) * 1e6d; + case PressureChangeRateUnit.PascalPerMinute: return _value/60; + case PressureChangeRateUnit.PascalPerSecond: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(PressureChangeRateUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal PressureChangeRate ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new PressureChangeRate(baseUnitValue, BaseUnit); + } + + private double GetValueAs(PressureChangeRateUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Ratio.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Ratio.NetFramework.g.cs index e4c3c35647..562f59eae8 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 new Ratio(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static Ratio operator -(Ratio left, Ratio right) { - return new Ratio(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new Ratio(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static Ratio operator *(double left, Ratio right) @@ -460,22 +460,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out RatioU public static bool operator <=(Ratio left, Ratio right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(Ratio left, Ratio right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(Ratio left, Ratio right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(Ratio left, Ratio right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(Ratio left, Ratio right) @@ -499,7 +499,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(Ratio other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -512,7 +512,7 @@ public override bool Equals(object obj) public bool Equals(Ratio other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -588,7 +588,7 @@ public double As(RatioUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -598,7 +598,7 @@ public double As(RatioUnit unit) /// A Ratio with the specified unit. public Ratio ToUnit(RatioUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Ratio(convertedValue, unit); } @@ -607,34 +607,38 @@ public Ratio ToUnit(RatioUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Ratio AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case RatioUnit.DecimalFraction: - return new Ratio(_value, BaseUnit); - case RatioUnit.PartPerBillion: - return new Ratio(_value/1e9, BaseUnit); - case RatioUnit.PartPerMillion: - return new Ratio(_value/1e6, BaseUnit); - case RatioUnit.PartPerThousand: - return new Ratio(_value/1e3, BaseUnit); - case RatioUnit.PartPerTrillion: - return new Ratio(_value/1e12, BaseUnit); - case RatioUnit.Percent: - return new Ratio(_value/1e2, BaseUnit); + case RatioUnit.DecimalFraction: return _value; + case RatioUnit.PartPerBillion: return _value/1e9; + case RatioUnit.PartPerMillion: return _value/1e6; + case RatioUnit.PartPerThousand: return _value/1e3; + case RatioUnit.PartPerTrillion: return _value/1e12; + case RatioUnit.Percent: return _value/1e2; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(RatioUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Ratio ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Ratio(baseUnitValue, BaseUnit); + } + + private double GetValueAs(RatioUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ReactiveEnergy.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ReactiveEnergy.NetFramework.g.cs index 4767c0ee5d..897c44fcf1 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 new ReactiveEnergy(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static ReactiveEnergy operator -(ReactiveEnergy left, ReactiveEnergy right) { - return new ReactiveEnergy(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new ReactiveEnergy(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static ReactiveEnergy operator *(double left, ReactiveEnergy right) @@ -418,22 +418,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Reacti public static bool operator <=(ReactiveEnergy left, ReactiveEnergy right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(ReactiveEnergy left, ReactiveEnergy right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(ReactiveEnergy left, ReactiveEnergy right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(ReactiveEnergy left, ReactiveEnergy right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(ReactiveEnergy left, ReactiveEnergy right) @@ -457,7 +457,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(ReactiveEnergy other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -470,7 +470,7 @@ public override bool Equals(object obj) public bool Equals(ReactiveEnergy other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -546,7 +546,7 @@ public double As(ReactiveEnergyUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -556,7 +556,7 @@ public double As(ReactiveEnergyUnit unit) /// A ReactiveEnergy with the specified unit. public ReactiveEnergy ToUnit(ReactiveEnergyUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ReactiveEnergy(convertedValue, unit); } @@ -565,28 +565,35 @@ public ReactiveEnergy ToUnit(ReactiveEnergyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ReactiveEnergy AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ReactiveEnergyUnit.KilovoltampereReactiveHour: - return new ReactiveEnergy((_value) * 1e3d, BaseUnit); - case ReactiveEnergyUnit.MegavoltampereReactiveHour: - return new ReactiveEnergy((_value) * 1e6d, BaseUnit); - case ReactiveEnergyUnit.VoltampereReactiveHour: - return new ReactiveEnergy(_value, BaseUnit); + case ReactiveEnergyUnit.KilovoltampereReactiveHour: return (_value) * 1e3d; + case ReactiveEnergyUnit.MegavoltampereReactiveHour: return (_value) * 1e6d; + case ReactiveEnergyUnit.VoltampereReactiveHour: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ReactiveEnergyUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ReactiveEnergy ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ReactiveEnergy(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ReactiveEnergyUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ReactivePower.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ReactivePower.NetFramework.g.cs index 26833d6150..47905ad1b5 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 new ReactivePower(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static ReactivePower operator -(ReactivePower left, ReactivePower right) { - return new ReactivePower(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new ReactivePower(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static ReactivePower operator *(double left, ReactivePower right) @@ -432,22 +432,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Reacti public static bool operator <=(ReactivePower left, ReactivePower right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(ReactivePower left, ReactivePower right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(ReactivePower left, ReactivePower right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(ReactivePower left, ReactivePower right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(ReactivePower left, ReactivePower right) @@ -471,7 +471,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(ReactivePower other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -484,7 +484,7 @@ public override bool Equals(object obj) public bool Equals(ReactivePower other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -560,7 +560,7 @@ public double As(ReactivePowerUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -570,7 +570,7 @@ public double As(ReactivePowerUnit unit) /// A ReactivePower with the specified unit. public ReactivePower ToUnit(ReactivePowerUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ReactivePower(convertedValue, unit); } @@ -579,30 +579,36 @@ public ReactivePower ToUnit(ReactivePowerUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ReactivePower AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ReactivePowerUnit.GigavoltampereReactive: - return new ReactivePower((_value) * 1e9d, BaseUnit); - case ReactivePowerUnit.KilovoltampereReactive: - return new ReactivePower((_value) * 1e3d, BaseUnit); - case ReactivePowerUnit.MegavoltampereReactive: - return new ReactivePower((_value) * 1e6d, BaseUnit); - case ReactivePowerUnit.VoltampereReactive: - return new ReactivePower(_value, BaseUnit); + case ReactivePowerUnit.GigavoltampereReactive: return (_value) * 1e9d; + case ReactivePowerUnit.KilovoltampereReactive: return (_value) * 1e3d; + case ReactivePowerUnit.MegavoltampereReactive: return (_value) * 1e6d; + case ReactivePowerUnit.VoltampereReactive: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ReactivePowerUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ReactivePower ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ReactivePower(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ReactivePowerUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.NetFramework.g.cs index 18dac3c34f..56b6d4516b 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 new RotationalAcceleration(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static RotationalAcceleration operator -(RotationalAcceleration left, RotationalAcceleration right) { - return new RotationalAcceleration(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new RotationalAcceleration(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static RotationalAcceleration operator *(double left, RotationalAcceleration right) @@ -418,22 +418,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Rotati public static bool operator <=(RotationalAcceleration left, RotationalAcceleration right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(RotationalAcceleration left, RotationalAcceleration right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(RotationalAcceleration left, RotationalAcceleration right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(RotationalAcceleration left, RotationalAcceleration right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(RotationalAcceleration left, RotationalAcceleration right) @@ -457,7 +457,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(RotationalAcceleration other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -470,7 +470,7 @@ public override bool Equals(object obj) public bool Equals(RotationalAcceleration other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -546,7 +546,7 @@ public double As(RotationalAccelerationUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -556,7 +556,7 @@ public double As(RotationalAccelerationUnit unit) /// A RotationalAcceleration with the specified unit. public RotationalAcceleration ToUnit(RotationalAccelerationUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new RotationalAcceleration(convertedValue, unit); } @@ -565,28 +565,35 @@ public RotationalAcceleration ToUnit(RotationalAccelerationUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal RotationalAcceleration AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case RotationalAccelerationUnit.DegreePerSecondSquared: - return new RotationalAcceleration((Math.PI/180)*_value, BaseUnit); - case RotationalAccelerationUnit.RadianPerSecondSquared: - return new RotationalAcceleration(_value, BaseUnit); - case RotationalAccelerationUnit.RevolutionPerMinutePerSecond: - return new RotationalAcceleration(((2*Math.PI)/60)*_value, BaseUnit); + case RotationalAccelerationUnit.DegreePerSecondSquared: return (Math.PI/180)*_value; + case RotationalAccelerationUnit.RadianPerSecondSquared: return _value; + case RotationalAccelerationUnit.RevolutionPerMinutePerSecond: return ((2*Math.PI)/60)*_value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(RotationalAccelerationUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal RotationalAcceleration ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new RotationalAcceleration(baseUnitValue, BaseUnit); + } + + private double GetValueAs(RotationalAccelerationUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.NetFramework.g.cs index bfa7453284..ecc941506f 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 new RotationalSpeed(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static RotationalSpeed operator -(RotationalSpeed left, RotationalSpeed right) { - return new RotationalSpeed(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new RotationalSpeed(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static RotationalSpeed operator *(double left, RotationalSpeed right) @@ -558,22 +558,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Rotati public static bool operator <=(RotationalSpeed left, RotationalSpeed right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(RotationalSpeed left, RotationalSpeed right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(RotationalSpeed left, RotationalSpeed right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(RotationalSpeed left, RotationalSpeed right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(RotationalSpeed left, RotationalSpeed right) @@ -597,7 +597,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(RotationalSpeed other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -610,7 +610,7 @@ public override bool Equals(object obj) public bool Equals(RotationalSpeed other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -686,7 +686,7 @@ public double As(RotationalSpeedUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -696,7 +696,7 @@ public double As(RotationalSpeedUnit unit) /// A RotationalSpeed with the specified unit. public RotationalSpeed ToUnit(RotationalSpeedUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new RotationalSpeed(convertedValue, unit); } @@ -705,48 +705,45 @@ public RotationalSpeed ToUnit(RotationalSpeedUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal RotationalSpeed AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case RotationalSpeedUnit.CentiradianPerSecond: - return new RotationalSpeed((_value) * 1e-2d, BaseUnit); - case RotationalSpeedUnit.DeciradianPerSecond: - return new RotationalSpeed((_value) * 1e-1d, BaseUnit); - case RotationalSpeedUnit.DegreePerMinute: - return new RotationalSpeed((Math.PI/(180*60))*_value, BaseUnit); - case RotationalSpeedUnit.DegreePerSecond: - return new RotationalSpeed((Math.PI/180)*_value, BaseUnit); - case RotationalSpeedUnit.MicrodegreePerSecond: - return new RotationalSpeed(((Math.PI/180)*_value) * 1e-6d, BaseUnit); - case RotationalSpeedUnit.MicroradianPerSecond: - return new RotationalSpeed((_value) * 1e-6d, BaseUnit); - case RotationalSpeedUnit.MillidegreePerSecond: - return new RotationalSpeed(((Math.PI/180)*_value) * 1e-3d, BaseUnit); - case RotationalSpeedUnit.MilliradianPerSecond: - return new RotationalSpeed((_value) * 1e-3d, BaseUnit); - case RotationalSpeedUnit.NanodegreePerSecond: - return new RotationalSpeed(((Math.PI/180)*_value) * 1e-9d, BaseUnit); - case RotationalSpeedUnit.NanoradianPerSecond: - return new RotationalSpeed((_value) * 1e-9d, BaseUnit); - case RotationalSpeedUnit.RadianPerSecond: - return new RotationalSpeed(_value, BaseUnit); - case RotationalSpeedUnit.RevolutionPerMinute: - return new RotationalSpeed((_value*6.2831853072)/60, BaseUnit); - case RotationalSpeedUnit.RevolutionPerSecond: - return new RotationalSpeed(_value*6.2831853072, BaseUnit); + case RotationalSpeedUnit.CentiradianPerSecond: return (_value) * 1e-2d; + case RotationalSpeedUnit.DeciradianPerSecond: return (_value) * 1e-1d; + case RotationalSpeedUnit.DegreePerMinute: return (Math.PI/(180*60))*_value; + case RotationalSpeedUnit.DegreePerSecond: return (Math.PI/180)*_value; + case RotationalSpeedUnit.MicrodegreePerSecond: return ((Math.PI/180)*_value) * 1e-6d; + case RotationalSpeedUnit.MicroradianPerSecond: return (_value) * 1e-6d; + case RotationalSpeedUnit.MillidegreePerSecond: return ((Math.PI/180)*_value) * 1e-3d; + case RotationalSpeedUnit.MilliradianPerSecond: return (_value) * 1e-3d; + case RotationalSpeedUnit.NanodegreePerSecond: return ((Math.PI/180)*_value) * 1e-9d; + case RotationalSpeedUnit.NanoradianPerSecond: return (_value) * 1e-9d; + case RotationalSpeedUnit.RadianPerSecond: return _value; + case RotationalSpeedUnit.RevolutionPerMinute: return (_value*6.2831853072)/60; + case RotationalSpeedUnit.RevolutionPerSecond: return _value*6.2831853072; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(RotationalSpeedUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal RotationalSpeed ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new RotationalSpeed(baseUnitValue, BaseUnit); + } + + private double GetValueAs(RotationalSpeedUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.NetFramework.g.cs index a0be432bf4..dd7b60bb58 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 new RotationalStiffness(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static RotationalStiffness operator -(RotationalStiffness left, RotationalStiffness right) { - return new RotationalStiffness(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new RotationalStiffness(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static RotationalStiffness operator *(double left, RotationalStiffness right) @@ -418,22 +418,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Rotati public static bool operator <=(RotationalStiffness left, RotationalStiffness right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(RotationalStiffness left, RotationalStiffness right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(RotationalStiffness left, RotationalStiffness right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(RotationalStiffness left, RotationalStiffness right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(RotationalStiffness left, RotationalStiffness right) @@ -457,7 +457,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(RotationalStiffness other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -470,7 +470,7 @@ public override bool Equals(object obj) public bool Equals(RotationalStiffness other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -546,7 +546,7 @@ public double As(RotationalStiffnessUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -556,7 +556,7 @@ public double As(RotationalStiffnessUnit unit) /// A RotationalStiffness with the specified unit. public RotationalStiffness ToUnit(RotationalStiffnessUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new RotationalStiffness(convertedValue, unit); } @@ -565,28 +565,35 @@ public RotationalStiffness ToUnit(RotationalStiffnessUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal RotationalStiffness AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case RotationalStiffnessUnit.KilonewtonMeterPerRadian: - return new RotationalStiffness((_value) * 1e3d, BaseUnit); - case RotationalStiffnessUnit.MeganewtonMeterPerRadian: - return new RotationalStiffness((_value) * 1e6d, BaseUnit); - case RotationalStiffnessUnit.NewtonMeterPerRadian: - return new RotationalStiffness(_value, BaseUnit); + case RotationalStiffnessUnit.KilonewtonMeterPerRadian: return (_value) * 1e3d; + case RotationalStiffnessUnit.MeganewtonMeterPerRadian: return (_value) * 1e6d; + case RotationalStiffnessUnit.NewtonMeterPerRadian: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(RotationalStiffnessUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal RotationalStiffness ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new RotationalStiffness(baseUnitValue, BaseUnit); + } + + private double GetValueAs(RotationalStiffnessUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.NetFramework.g.cs index 55cbcb0133..4451449e82 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 new RotationalStiffnessPerLength(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static RotationalStiffnessPerLength operator -(RotationalStiffnessPerLength left, RotationalStiffnessPerLength right) { - return new RotationalStiffnessPerLength(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new RotationalStiffnessPerLength(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static RotationalStiffnessPerLength operator *(double left, RotationalStiffnessPerLength right) @@ -418,22 +418,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Rotati public static bool operator <=(RotationalStiffnessPerLength left, RotationalStiffnessPerLength right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(RotationalStiffnessPerLength left, RotationalStiffnessPerLength right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(RotationalStiffnessPerLength left, RotationalStiffnessPerLength right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(RotationalStiffnessPerLength left, RotationalStiffnessPerLength right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(RotationalStiffnessPerLength left, RotationalStiffnessPerLength right) @@ -457,7 +457,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(RotationalStiffnessPerLength other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -470,7 +470,7 @@ public override bool Equals(object obj) public bool Equals(RotationalStiffnessPerLength other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -546,7 +546,7 @@ public double As(RotationalStiffnessPerLengthUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -556,7 +556,7 @@ public double As(RotationalStiffnessPerLengthUnit unit) /// A RotationalStiffnessPerLength with the specified unit. public RotationalStiffnessPerLength ToUnit(RotationalStiffnessPerLengthUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new RotationalStiffnessPerLength(convertedValue, unit); } @@ -565,28 +565,35 @@ public RotationalStiffnessPerLength ToUnit(RotationalStiffnessPerLengthUnit unit /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal RotationalStiffnessPerLength AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter: - return new RotationalStiffnessPerLength((_value) * 1e3d, BaseUnit); - case RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter: - return new RotationalStiffnessPerLength((_value) * 1e6d, BaseUnit); - case RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter: - return new RotationalStiffnessPerLength(_value, BaseUnit); + case RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter: return (_value) * 1e3d; + case RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter: return (_value) * 1e6d; + case RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(RotationalStiffnessPerLengthUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal RotationalStiffnessPerLength ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new RotationalStiffnessPerLength(baseUnitValue, BaseUnit); + } + + private double GetValueAs(RotationalStiffnessPerLengthUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/SolidAngle.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/SolidAngle.NetFramework.g.cs index 39a07e5e0a..eb39ac107c 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 new SolidAngle(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static SolidAngle operator -(SolidAngle left, SolidAngle right) { - return new SolidAngle(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new SolidAngle(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static SolidAngle operator *(double left, SolidAngle right) @@ -393,22 +393,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out SolidA public static bool operator <=(SolidAngle left, SolidAngle right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(SolidAngle left, SolidAngle right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(SolidAngle left, SolidAngle right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(SolidAngle left, SolidAngle right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(SolidAngle left, SolidAngle right) @@ -432,7 +432,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(SolidAngle other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -445,7 +445,7 @@ public override bool Equals(object obj) public bool Equals(SolidAngle other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -521,7 +521,7 @@ public double As(SolidAngleUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -531,7 +531,7 @@ public double As(SolidAngleUnit unit) /// A SolidAngle with the specified unit. public SolidAngle ToUnit(SolidAngleUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new SolidAngle(convertedValue, unit); } @@ -540,24 +540,33 @@ public SolidAngle ToUnit(SolidAngleUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal SolidAngle AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case SolidAngleUnit.Steradian: - return new SolidAngle(_value, BaseUnit); + case SolidAngleUnit.Steradian: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(SolidAngleUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal SolidAngle ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new SolidAngle(baseUnitValue, BaseUnit); + } + + private double GetValueAs(SolidAngleUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.NetFramework.g.cs index 63f468ddec..8ea50a45b3 100644 --- a/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.NetFramework.g.cs @@ -471,12 +471,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 new SpecificEnergy(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static SpecificEnergy operator -(SpecificEnergy left, SpecificEnergy right) { - return new SpecificEnergy(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new SpecificEnergy(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static SpecificEnergy operator *(double left, SpecificEnergy right) @@ -505,22 +505,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Specif public static bool operator <=(SpecificEnergy left, SpecificEnergy right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(SpecificEnergy left, SpecificEnergy right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(SpecificEnergy left, SpecificEnergy right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(SpecificEnergy left, SpecificEnergy right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(SpecificEnergy left, SpecificEnergy right) @@ -544,7 +544,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(SpecificEnergy other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -557,7 +557,7 @@ public override bool Equals(object obj) public bool Equals(SpecificEnergy other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -633,7 +633,7 @@ public double As(SpecificEnergyUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -643,7 +643,7 @@ public double As(SpecificEnergyUnit unit) /// A SpecificEnergy with the specified unit. public SpecificEnergy ToUnit(SpecificEnergyUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new SpecificEnergy(convertedValue, unit); } @@ -652,40 +652,41 @@ public SpecificEnergy ToUnit(SpecificEnergyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal SpecificEnergy AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case SpecificEnergyUnit.BtuPerPound: - return new SpecificEnergy(_value*2326.000075362, BaseUnit); - case SpecificEnergyUnit.CaloriePerGram: - return new SpecificEnergy(_value*4.184e3, BaseUnit); - case SpecificEnergyUnit.JoulePerKilogram: - return new SpecificEnergy(_value, BaseUnit); - case SpecificEnergyUnit.KilocaloriePerGram: - return new SpecificEnergy((_value*4.184e3) * 1e3d, BaseUnit); - case SpecificEnergyUnit.KilojoulePerKilogram: - return new SpecificEnergy((_value) * 1e3d, BaseUnit); - case SpecificEnergyUnit.KilowattHourPerKilogram: - return new SpecificEnergy((_value*3.6e3) * 1e3d, BaseUnit); - case SpecificEnergyUnit.MegajoulePerKilogram: - return new SpecificEnergy((_value) * 1e6d, BaseUnit); - case SpecificEnergyUnit.MegawattHourPerKilogram: - return new SpecificEnergy((_value*3.6e3) * 1e6d, BaseUnit); - case SpecificEnergyUnit.WattHourPerKilogram: - return new SpecificEnergy(_value*3.6e3, BaseUnit); + case SpecificEnergyUnit.BtuPerPound: return _value*2326.000075362; + case SpecificEnergyUnit.CaloriePerGram: return _value*4.184e3; + case SpecificEnergyUnit.JoulePerKilogram: return _value; + case SpecificEnergyUnit.KilocaloriePerGram: return (_value*4.184e3) * 1e3d; + case SpecificEnergyUnit.KilojoulePerKilogram: return (_value) * 1e3d; + case SpecificEnergyUnit.KilowattHourPerKilogram: return (_value*3.6e3) * 1e3d; + case SpecificEnergyUnit.MegajoulePerKilogram: return (_value) * 1e6d; + case SpecificEnergyUnit.MegawattHourPerKilogram: return (_value*3.6e3) * 1e6d; + case SpecificEnergyUnit.WattHourPerKilogram: return _value*3.6e3; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(SpecificEnergyUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal SpecificEnergy ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new SpecificEnergy(baseUnitValue, BaseUnit); + } + + private double GetValueAs(SpecificEnergyUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.NetFramework.g.cs index de4a009668..2442c38f7f 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 new SpecificEntropy(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static SpecificEntropy operator -(SpecificEntropy left, SpecificEntropy right) { - return new SpecificEntropy(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new SpecificEntropy(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static SpecificEntropy operator *(double left, SpecificEntropy right) @@ -488,22 +488,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Specif public static bool operator <=(SpecificEntropy left, SpecificEntropy right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(SpecificEntropy left, SpecificEntropy right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(SpecificEntropy left, SpecificEntropy right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(SpecificEntropy left, SpecificEntropy right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(SpecificEntropy left, SpecificEntropy right) @@ -527,7 +527,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(SpecificEntropy other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -540,7 +540,7 @@ public override bool Equals(object obj) public bool Equals(SpecificEntropy other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -616,7 +616,7 @@ public double As(SpecificEntropyUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -626,7 +626,7 @@ public double As(SpecificEntropyUnit unit) /// A SpecificEntropy with the specified unit. public SpecificEntropy ToUnit(SpecificEntropyUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new SpecificEntropy(convertedValue, unit); } @@ -635,38 +635,40 @@ public SpecificEntropy ToUnit(SpecificEntropyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal SpecificEntropy AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case SpecificEntropyUnit.CaloriePerGramKelvin: - return new SpecificEntropy(_value*4.184e3, BaseUnit); - case SpecificEntropyUnit.JoulePerKilogramDegreeCelsius: - return new SpecificEntropy(_value, BaseUnit); - case SpecificEntropyUnit.JoulePerKilogramKelvin: - return new SpecificEntropy(_value, BaseUnit); - case SpecificEntropyUnit.KilocaloriePerGramKelvin: - return new SpecificEntropy((_value*4.184e3) * 1e3d, BaseUnit); - case SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius: - return new SpecificEntropy((_value) * 1e3d, BaseUnit); - case SpecificEntropyUnit.KilojoulePerKilogramKelvin: - return new SpecificEntropy((_value) * 1e3d, BaseUnit); - case SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius: - return new SpecificEntropy((_value) * 1e6d, BaseUnit); - case SpecificEntropyUnit.MegajoulePerKilogramKelvin: - return new SpecificEntropy((_value) * 1e6d, BaseUnit); + case SpecificEntropyUnit.CaloriePerGramKelvin: return _value*4.184e3; + case SpecificEntropyUnit.JoulePerKilogramDegreeCelsius: return _value; + case SpecificEntropyUnit.JoulePerKilogramKelvin: return _value; + case SpecificEntropyUnit.KilocaloriePerGramKelvin: return (_value*4.184e3) * 1e3d; + case SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius: return (_value) * 1e3d; + case SpecificEntropyUnit.KilojoulePerKilogramKelvin: return (_value) * 1e3d; + case SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius: return (_value) * 1e6d; + case SpecificEntropyUnit.MegajoulePerKilogramKelvin: return (_value) * 1e6d; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(SpecificEntropyUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal SpecificEntropy ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new SpecificEntropy(baseUnitValue, BaseUnit); + } + + private double GetValueAs(SpecificEntropyUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificVolume.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificVolume.NetFramework.g.cs index 08184ebe7b..89a9e67055 100644 --- a/UnitsNet/GeneratedCode/Quantities/SpecificVolume.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/SpecificVolume.NetFramework.g.cs @@ -384,12 +384,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 new SpecificVolume(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static SpecificVolume operator -(SpecificVolume left, SpecificVolume right) { - return new SpecificVolume(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new SpecificVolume(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static SpecificVolume operator *(double left, SpecificVolume right) @@ -418,22 +418,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Specif public static bool operator <=(SpecificVolume left, SpecificVolume right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(SpecificVolume left, SpecificVolume right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(SpecificVolume left, SpecificVolume right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(SpecificVolume left, SpecificVolume right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(SpecificVolume left, SpecificVolume right) @@ -457,7 +457,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(SpecificVolume other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -470,7 +470,7 @@ public override bool Equals(object obj) public bool Equals(SpecificVolume other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -546,7 +546,7 @@ public double As(SpecificVolumeUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -556,7 +556,7 @@ public double As(SpecificVolumeUnit unit) /// A SpecificVolume with the specified unit. public SpecificVolume ToUnit(SpecificVolumeUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new SpecificVolume(convertedValue, unit); } @@ -565,28 +565,35 @@ public SpecificVolume ToUnit(SpecificVolumeUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal SpecificVolume AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case SpecificVolumeUnit.CubicFootPerPound: - return new SpecificVolume(_value/16.01846353, BaseUnit); - case SpecificVolumeUnit.CubicMeterPerKilogram: - return new SpecificVolume(_value, BaseUnit); - case SpecificVolumeUnit.MillicubicMeterPerKilogram: - return new SpecificVolume((_value) * 1e-3d, BaseUnit); + case SpecificVolumeUnit.CubicFootPerPound: return _value/16.01846353; + case SpecificVolumeUnit.CubicMeterPerKilogram: return _value; + case SpecificVolumeUnit.MillicubicMeterPerKilogram: return (_value) * 1e-3d; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(SpecificVolumeUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal SpecificVolume ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new SpecificVolume(baseUnitValue, BaseUnit); + } + + private double GetValueAs(SpecificVolumeUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificWeight.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificWeight.NetFramework.g.cs index ef193664d3..0d22b39293 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 new SpecificWeight(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static SpecificWeight operator -(SpecificWeight left, SpecificWeight right) { - return new SpecificWeight(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new SpecificWeight(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static SpecificWeight operator *(double left, SpecificWeight right) @@ -617,22 +617,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Specif public static bool operator <=(SpecificWeight left, SpecificWeight right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(SpecificWeight left, SpecificWeight right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(SpecificWeight left, SpecificWeight right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(SpecificWeight left, SpecificWeight right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(SpecificWeight left, SpecificWeight right) @@ -656,7 +656,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(SpecificWeight other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -669,7 +669,7 @@ public override bool Equals(object obj) public bool Equals(SpecificWeight other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -745,7 +745,7 @@ public double As(SpecificWeightUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -755,7 +755,7 @@ public double As(SpecificWeightUnit unit) /// A SpecificWeight with the specified unit. public SpecificWeight ToUnit(SpecificWeightUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new SpecificWeight(convertedValue, unit); } @@ -764,56 +764,49 @@ public SpecificWeight ToUnit(SpecificWeightUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal SpecificWeight AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case SpecificWeightUnit.KilogramForcePerCubicCentimeter: - return new SpecificWeight(_value*9.80665e6, BaseUnit); - case SpecificWeightUnit.KilogramForcePerCubicMeter: - return new SpecificWeight(_value*9.80665, BaseUnit); - case SpecificWeightUnit.KilogramForcePerCubicMillimeter: - return new SpecificWeight(_value*9.80665e9, BaseUnit); - case SpecificWeightUnit.KilonewtonPerCubicCentimeter: - return new SpecificWeight((_value*1000000) * 1e3d, BaseUnit); - case SpecificWeightUnit.KilonewtonPerCubicMeter: - return new SpecificWeight((_value) * 1e3d, BaseUnit); - case SpecificWeightUnit.KilonewtonPerCubicMillimeter: - return new SpecificWeight((_value*1000000000) * 1e3d, BaseUnit); - case SpecificWeightUnit.KilopoundForcePerCubicFoot: - return new SpecificWeight((_value*1.570874638462462e2) * 1e3d, BaseUnit); - case SpecificWeightUnit.KilopoundForcePerCubicInch: - return new SpecificWeight((_value*2.714471375263134e5) * 1e3d, BaseUnit); - case SpecificWeightUnit.MeganewtonPerCubicMeter: - return new SpecificWeight((_value) * 1e6d, BaseUnit); - case SpecificWeightUnit.NewtonPerCubicCentimeter: - return new SpecificWeight(_value*1000000, BaseUnit); - case SpecificWeightUnit.NewtonPerCubicMeter: - return new SpecificWeight(_value, BaseUnit); - case SpecificWeightUnit.NewtonPerCubicMillimeter: - return new SpecificWeight(_value*1000000000, BaseUnit); - case SpecificWeightUnit.PoundForcePerCubicFoot: - return new SpecificWeight(_value*1.570874638462462e2, BaseUnit); - case SpecificWeightUnit.PoundForcePerCubicInch: - return new SpecificWeight(_value*2.714471375263134e5, BaseUnit); - case SpecificWeightUnit.TonneForcePerCubicCentimeter: - return new SpecificWeight(_value*9.80665e9, BaseUnit); - case SpecificWeightUnit.TonneForcePerCubicMeter: - return new SpecificWeight(_value*9.80665e3, BaseUnit); - case SpecificWeightUnit.TonneForcePerCubicMillimeter: - return new SpecificWeight(_value*9.80665e12, BaseUnit); + case SpecificWeightUnit.KilogramForcePerCubicCentimeter: return _value*9.80665e6; + case SpecificWeightUnit.KilogramForcePerCubicMeter: return _value*9.80665; + case SpecificWeightUnit.KilogramForcePerCubicMillimeter: return _value*9.80665e9; + case SpecificWeightUnit.KilonewtonPerCubicCentimeter: return (_value*1000000) * 1e3d; + case SpecificWeightUnit.KilonewtonPerCubicMeter: return (_value) * 1e3d; + case SpecificWeightUnit.KilonewtonPerCubicMillimeter: return (_value*1000000000) * 1e3d; + case SpecificWeightUnit.KilopoundForcePerCubicFoot: return (_value*1.570874638462462e2) * 1e3d; + case SpecificWeightUnit.KilopoundForcePerCubicInch: return (_value*2.714471375263134e5) * 1e3d; + case SpecificWeightUnit.MeganewtonPerCubicMeter: return (_value) * 1e6d; + case SpecificWeightUnit.NewtonPerCubicCentimeter: return _value*1000000; + case SpecificWeightUnit.NewtonPerCubicMeter: return _value; + case SpecificWeightUnit.NewtonPerCubicMillimeter: return _value*1000000000; + case SpecificWeightUnit.PoundForcePerCubicFoot: return _value*1.570874638462462e2; + case SpecificWeightUnit.PoundForcePerCubicInch: return _value*2.714471375263134e5; + case SpecificWeightUnit.TonneForcePerCubicCentimeter: return _value*9.80665e9; + case SpecificWeightUnit.TonneForcePerCubicMeter: return _value*9.80665e3; + case SpecificWeightUnit.TonneForcePerCubicMillimeter: return _value*9.80665e12; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(SpecificWeightUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal SpecificWeight ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new SpecificWeight(baseUnitValue, BaseUnit); + } + + private double GetValueAs(SpecificWeightUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Speed.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Speed.NetFramework.g.cs index a18e19fcb8..656a396980 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 new Speed(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static Speed operator -(Speed left, Speed right) { - return new Speed(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new Speed(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static Speed operator *(double left, Speed right) @@ -824,22 +824,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out SpeedU public static bool operator <=(Speed left, Speed right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(Speed left, Speed right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(Speed left, Speed right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(Speed left, Speed right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(Speed left, Speed right) @@ -863,7 +863,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(Speed other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -876,7 +876,7 @@ public override bool Equals(object obj) public bool Equals(Speed other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -952,7 +952,7 @@ public double As(SpeedUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -962,7 +962,7 @@ public double As(SpeedUnit unit) /// A Speed with the specified unit. public Speed ToUnit(SpeedUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Speed(convertedValue, unit); } @@ -971,86 +971,64 @@ public Speed ToUnit(SpeedUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Speed AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case SpeedUnit.CentimeterPerHour: - return new Speed((_value/3600) * 1e-2d, BaseUnit); - case SpeedUnit.CentimeterPerMinute: - return new Speed((_value/60) * 1e-2d, BaseUnit); - case SpeedUnit.CentimeterPerSecond: - return new Speed((_value) * 1e-2d, BaseUnit); - case SpeedUnit.DecimeterPerMinute: - return new Speed((_value/60) * 1e-1d, BaseUnit); - case SpeedUnit.DecimeterPerSecond: - return new Speed((_value) * 1e-1d, BaseUnit); - case SpeedUnit.FootPerHour: - return new Speed(_value*0.3048/3600, BaseUnit); - case SpeedUnit.FootPerMinute: - return new Speed(_value*0.3048/60, BaseUnit); - case SpeedUnit.FootPerSecond: - return new Speed(_value*0.3048, BaseUnit); - case SpeedUnit.InchPerHour: - return new Speed((_value/3600)*2.54e-2, BaseUnit); - case SpeedUnit.InchPerMinute: - return new Speed((_value/60)*2.54e-2, BaseUnit); - case SpeedUnit.InchPerSecond: - return new Speed(_value*2.54e-2, BaseUnit); - case SpeedUnit.KilometerPerHour: - return new Speed((_value/3600) * 1e3d, BaseUnit); - case SpeedUnit.KilometerPerMinute: - return new Speed((_value/60) * 1e3d, BaseUnit); - case SpeedUnit.KilometerPerSecond: - return new Speed((_value) * 1e3d, BaseUnit); - case SpeedUnit.Knot: - return new Speed(_value*0.514444, BaseUnit); - case SpeedUnit.MeterPerHour: - return new Speed(_value/3600, BaseUnit); - case SpeedUnit.MeterPerMinute: - return new Speed(_value/60, BaseUnit); - case SpeedUnit.MeterPerSecond: - return new Speed(_value, BaseUnit); - case SpeedUnit.MicrometerPerMinute: - return new Speed((_value/60) * 1e-6d, BaseUnit); - case SpeedUnit.MicrometerPerSecond: - return new Speed((_value) * 1e-6d, BaseUnit); - case SpeedUnit.MilePerHour: - return new Speed(_value*0.44704, BaseUnit); - case SpeedUnit.MillimeterPerHour: - return new Speed((_value/3600) * 1e-3d, BaseUnit); - case SpeedUnit.MillimeterPerMinute: - return new Speed((_value/60) * 1e-3d, BaseUnit); - case SpeedUnit.MillimeterPerSecond: - return new Speed((_value) * 1e-3d, BaseUnit); - case SpeedUnit.NanometerPerMinute: - return new Speed((_value/60) * 1e-9d, BaseUnit); - case SpeedUnit.NanometerPerSecond: - return new Speed((_value) * 1e-9d, BaseUnit); - case SpeedUnit.UsSurveyFootPerHour: - return new Speed((_value*1200/3937)/3600, BaseUnit); - case SpeedUnit.UsSurveyFootPerMinute: - return new Speed((_value*1200/3937)/60, BaseUnit); - case SpeedUnit.UsSurveyFootPerSecond: - return new Speed(_value*1200/3937, BaseUnit); - case SpeedUnit.YardPerHour: - return new Speed(_value*0.9144/3600, BaseUnit); - case SpeedUnit.YardPerMinute: - return new Speed(_value*0.9144/60, BaseUnit); - case SpeedUnit.YardPerSecond: - return new Speed(_value*0.9144, BaseUnit); + case SpeedUnit.CentimeterPerHour: return (_value/3600) * 1e-2d; + case SpeedUnit.CentimeterPerMinute: return (_value/60) * 1e-2d; + case SpeedUnit.CentimeterPerSecond: return (_value) * 1e-2d; + case SpeedUnit.DecimeterPerMinute: return (_value/60) * 1e-1d; + case SpeedUnit.DecimeterPerSecond: return (_value) * 1e-1d; + case SpeedUnit.FootPerHour: return _value*0.3048/3600; + case SpeedUnit.FootPerMinute: return _value*0.3048/60; + case SpeedUnit.FootPerSecond: return _value*0.3048; + case SpeedUnit.InchPerHour: return (_value/3600)*2.54e-2; + case SpeedUnit.InchPerMinute: return (_value/60)*2.54e-2; + case SpeedUnit.InchPerSecond: return _value*2.54e-2; + case SpeedUnit.KilometerPerHour: return (_value/3600) * 1e3d; + case SpeedUnit.KilometerPerMinute: return (_value/60) * 1e3d; + case SpeedUnit.KilometerPerSecond: return (_value) * 1e3d; + case SpeedUnit.Knot: return _value*0.514444; + case SpeedUnit.MeterPerHour: return _value/3600; + case SpeedUnit.MeterPerMinute: return _value/60; + case SpeedUnit.MeterPerSecond: return _value; + case SpeedUnit.MicrometerPerMinute: return (_value/60) * 1e-6d; + case SpeedUnit.MicrometerPerSecond: return (_value) * 1e-6d; + case SpeedUnit.MilePerHour: return _value*0.44704; + case SpeedUnit.MillimeterPerHour: return (_value/3600) * 1e-3d; + case SpeedUnit.MillimeterPerMinute: return (_value/60) * 1e-3d; + case SpeedUnit.MillimeterPerSecond: return (_value) * 1e-3d; + case SpeedUnit.NanometerPerMinute: return (_value/60) * 1e-9d; + case SpeedUnit.NanometerPerSecond: return (_value) * 1e-9d; + case SpeedUnit.UsSurveyFootPerHour: return (_value*1200/3937)/3600; + case SpeedUnit.UsSurveyFootPerMinute: return (_value*1200/3937)/60; + case SpeedUnit.UsSurveyFootPerSecond: return _value*1200/3937; + case SpeedUnit.YardPerHour: return _value*0.9144/3600; + case SpeedUnit.YardPerMinute: return _value*0.9144/60; + case SpeedUnit.YardPerSecond: return _value*0.9144; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(SpeedUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Speed ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Speed(baseUnitValue, BaseUnit); + } + + private double GetValueAs(SpeedUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Temperature.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Temperature.NetFramework.g.cs index a65075d8f9..93f6f49b9a 100644 --- a/UnitsNet/GeneratedCode/Quantities/Temperature.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Temperature.NetFramework.g.cs @@ -449,22 +449,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Temper public static bool operator <=(Temperature left, Temperature right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(Temperature left, Temperature right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(Temperature left, Temperature right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(Temperature left, Temperature right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(Temperature left, Temperature right) @@ -488,7 +488,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(Temperature other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -501,7 +501,7 @@ public override bool Equals(object obj) public bool Equals(Temperature other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -577,7 +577,7 @@ public double As(TemperatureUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -587,7 +587,7 @@ public double As(TemperatureUnit unit) /// A Temperature with the specified unit. public Temperature ToUnit(TemperatureUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Temperature(convertedValue, unit); } @@ -596,38 +596,40 @@ public Temperature ToUnit(TemperatureUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Temperature AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case TemperatureUnit.DegreeCelsius: - return new Temperature(_value + 273.15, BaseUnit); - case TemperatureUnit.DegreeDelisle: - return new Temperature(_value*-2/3 + 373.15, BaseUnit); - case TemperatureUnit.DegreeFahrenheit: - return new Temperature(_value*5/9 + 459.67*5/9, BaseUnit); - case TemperatureUnit.DegreeNewton: - return new Temperature(_value*100/33 + 273.15, BaseUnit); - case TemperatureUnit.DegreeRankine: - return new Temperature(_value*5/9, BaseUnit); - case TemperatureUnit.DegreeReaumur: - return new Temperature(_value*5/4 + 273.15, BaseUnit); - case TemperatureUnit.DegreeRoemer: - return new Temperature(_value*40/21 + 273.15 - 7.5*40d/21, BaseUnit); - case TemperatureUnit.Kelvin: - return new Temperature(_value, BaseUnit); + case TemperatureUnit.DegreeCelsius: return _value + 273.15; + case TemperatureUnit.DegreeDelisle: return _value*-2/3 + 373.15; + case TemperatureUnit.DegreeFahrenheit: return _value*5/9 + 459.67*5/9; + case TemperatureUnit.DegreeNewton: return _value*100/33 + 273.15; + case TemperatureUnit.DegreeRankine: return _value*5/9; + case TemperatureUnit.DegreeReaumur: return _value*5/4 + 273.15; + case TemperatureUnit.DegreeRoemer: return _value*40/21 + 273.15 - 7.5*40d/21; + case TemperatureUnit.Kelvin: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(TemperatureUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Temperature ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Temperature(baseUnitValue, BaseUnit); + } + + private double GetValueAs(TemperatureUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.NetFramework.g.cs index d1b6077e89..dd929f55fc 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 new TemperatureChangeRate(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static TemperatureChangeRate operator -(TemperatureChangeRate left, TemperatureChangeRate right) { - return new TemperatureChangeRate(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new TemperatureChangeRate(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static TemperatureChangeRate operator *(double left, TemperatureChangeRate right) @@ -516,22 +516,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Temper public static bool operator <=(TemperatureChangeRate left, TemperatureChangeRate right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(TemperatureChangeRate left, TemperatureChangeRate right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(TemperatureChangeRate left, TemperatureChangeRate right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(TemperatureChangeRate left, TemperatureChangeRate right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(TemperatureChangeRate left, TemperatureChangeRate right) @@ -555,7 +555,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(TemperatureChangeRate other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -568,7 +568,7 @@ public override bool Equals(object obj) public bool Equals(TemperatureChangeRate other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -644,7 +644,7 @@ public double As(TemperatureChangeRateUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -654,7 +654,7 @@ public double As(TemperatureChangeRateUnit unit) /// A TemperatureChangeRate with the specified unit. public TemperatureChangeRate ToUnit(TemperatureChangeRateUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new TemperatureChangeRate(convertedValue, unit); } @@ -663,42 +663,42 @@ public TemperatureChangeRate ToUnit(TemperatureChangeRateUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal TemperatureChangeRate AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond: - return new TemperatureChangeRate((_value) * 1e-2d, BaseUnit); - case TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond: - return new TemperatureChangeRate((_value) * 1e1d, BaseUnit); - case TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond: - return new TemperatureChangeRate((_value) * 1e-1d, BaseUnit); - case TemperatureChangeRateUnit.DegreeCelsiusPerMinute: - return new TemperatureChangeRate(_value/60, BaseUnit); - case TemperatureChangeRateUnit.DegreeCelsiusPerSecond: - return new TemperatureChangeRate(_value, BaseUnit); - case TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond: - return new TemperatureChangeRate((_value) * 1e2d, BaseUnit); - case TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond: - return new TemperatureChangeRate((_value) * 1e3d, BaseUnit); - case TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond: - return new TemperatureChangeRate((_value) * 1e-6d, BaseUnit); - case TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond: - return new TemperatureChangeRate((_value) * 1e-3d, BaseUnit); - case TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond: - return new TemperatureChangeRate((_value) * 1e-9d, BaseUnit); + case TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond: return (_value) * 1e-2d; + case TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond: return (_value) * 1e1d; + case TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond: return (_value) * 1e-1d; + case TemperatureChangeRateUnit.DegreeCelsiusPerMinute: return _value/60; + case TemperatureChangeRateUnit.DegreeCelsiusPerSecond: return _value; + case TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond: return (_value) * 1e2d; + case TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond: return (_value) * 1e3d; + case TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond: return (_value) * 1e-6d; + case TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond: return (_value) * 1e-3d; + case TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond: return (_value) * 1e-9d; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(TemperatureChangeRateUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal TemperatureChangeRate ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new TemperatureChangeRate(baseUnitValue, BaseUnit); + } + + private double GetValueAs(TemperatureChangeRateUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.NetFramework.g.cs index 0606013fce..44db33605f 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 new TemperatureDelta(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static TemperatureDelta operator -(TemperatureDelta left, TemperatureDelta right) { - return new TemperatureDelta(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new TemperatureDelta(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static TemperatureDelta operator *(double left, TemperatureDelta right) @@ -488,22 +488,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Temper public static bool operator <=(TemperatureDelta left, TemperatureDelta right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(TemperatureDelta left, TemperatureDelta right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(TemperatureDelta left, TemperatureDelta right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(TemperatureDelta left, TemperatureDelta right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(TemperatureDelta left, TemperatureDelta right) @@ -527,7 +527,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(TemperatureDelta other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -540,7 +540,7 @@ public override bool Equals(object obj) public bool Equals(TemperatureDelta other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -616,7 +616,7 @@ public double As(TemperatureDeltaUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -626,7 +626,7 @@ public double As(TemperatureDeltaUnit unit) /// A TemperatureDelta with the specified unit. public TemperatureDelta ToUnit(TemperatureDeltaUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new TemperatureDelta(convertedValue, unit); } @@ -635,38 +635,40 @@ public TemperatureDelta ToUnit(TemperatureDeltaUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal TemperatureDelta AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case TemperatureDeltaUnit.DegreeCelsius: - return new TemperatureDelta(_value, BaseUnit); - case TemperatureDeltaUnit.DegreeDelisle: - return new TemperatureDelta(_value*-2/3, BaseUnit); - case TemperatureDeltaUnit.DegreeFahrenheit: - return new TemperatureDelta(_value*5/9, BaseUnit); - case TemperatureDeltaUnit.DegreeNewton: - return new TemperatureDelta(_value*100/33, BaseUnit); - case TemperatureDeltaUnit.DegreeRankine: - return new TemperatureDelta(_value*5/9, BaseUnit); - case TemperatureDeltaUnit.DegreeReaumur: - return new TemperatureDelta(_value*5/4, BaseUnit); - case TemperatureDeltaUnit.DegreeRoemer: - return new TemperatureDelta(_value*40/21, BaseUnit); - case TemperatureDeltaUnit.Kelvin: - return new TemperatureDelta(_value, BaseUnit); + case TemperatureDeltaUnit.DegreeCelsius: return _value; + case TemperatureDeltaUnit.DegreeDelisle: return _value*-2/3; + case TemperatureDeltaUnit.DegreeFahrenheit: return _value*5/9; + case TemperatureDeltaUnit.DegreeNewton: return _value*100/33; + case TemperatureDeltaUnit.DegreeRankine: return _value*5/9; + case TemperatureDeltaUnit.DegreeReaumur: return _value*5/4; + case TemperatureDeltaUnit.DegreeRoemer: return _value*40/21; + case TemperatureDeltaUnit.Kelvin: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(TemperatureDeltaUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal TemperatureDelta ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new TemperatureDelta(baseUnitValue, BaseUnit); + } + + private double GetValueAs(TemperatureDeltaUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.NetFramework.g.cs index e28192aeb3..be3935097f 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 new ThermalConductivity(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static ThermalConductivity operator -(ThermalConductivity left, ThermalConductivity right) { - return new ThermalConductivity(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new ThermalConductivity(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static ThermalConductivity operator *(double left, ThermalConductivity right) @@ -407,22 +407,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Therma public static bool operator <=(ThermalConductivity left, ThermalConductivity right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(ThermalConductivity left, ThermalConductivity right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(ThermalConductivity left, ThermalConductivity right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(ThermalConductivity left, ThermalConductivity right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(ThermalConductivity left, ThermalConductivity right) @@ -446,7 +446,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(ThermalConductivity other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -459,7 +459,7 @@ public override bool Equals(object obj) public bool Equals(ThermalConductivity other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -535,7 +535,7 @@ public double As(ThermalConductivityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -545,7 +545,7 @@ public double As(ThermalConductivityUnit unit) /// A ThermalConductivity with the specified unit. public ThermalConductivity ToUnit(ThermalConductivityUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ThermalConductivity(convertedValue, unit); } @@ -554,26 +554,34 @@ public ThermalConductivity ToUnit(ThermalConductivityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ThermalConductivity AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ThermalConductivityUnit.BtuPerHourFootFahrenheit: - return new ThermalConductivity(_value*1.73073467, BaseUnit); - case ThermalConductivityUnit.WattPerMeterKelvin: - return new ThermalConductivity(_value, BaseUnit); + case ThermalConductivityUnit.BtuPerHourFootFahrenheit: return _value*1.73073467; + case ThermalConductivityUnit.WattPerMeterKelvin: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ThermalConductivityUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ThermalConductivity ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ThermalConductivity(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ThermalConductivityUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/ThermalResistance.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/ThermalResistance.NetFramework.g.cs index f8591ee250..9f9fe26916 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 new ThermalResistance(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static ThermalResistance operator -(ThermalResistance left, ThermalResistance right) { - return new ThermalResistance(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new ThermalResistance(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static ThermalResistance operator *(double left, ThermalResistance right) @@ -446,22 +446,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Therma public static bool operator <=(ThermalResistance left, ThermalResistance right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(ThermalResistance left, ThermalResistance right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(ThermalResistance left, ThermalResistance right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(ThermalResistance left, ThermalResistance right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(ThermalResistance left, ThermalResistance right) @@ -485,7 +485,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(ThermalResistance other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -498,7 +498,7 @@ public override bool Equals(object obj) public bool Equals(ThermalResistance other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -574,7 +574,7 @@ public double As(ThermalResistanceUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -584,7 +584,7 @@ public double As(ThermalResistanceUnit unit) /// A ThermalResistance with the specified unit. public ThermalResistance ToUnit(ThermalResistanceUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new ThermalResistance(convertedValue, unit); } @@ -593,32 +593,37 @@ public ThermalResistance ToUnit(ThermalResistanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal ThermalResistance AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu: - return new ThermalResistance(_value*176.1121482159839, BaseUnit); - case ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie: - return new ThermalResistance(_value*0.0859779507590433, BaseUnit); - case ThermalResistanceUnit.SquareCentimeterKelvinPerWatt: - return new ThermalResistance(_value*0.0999964777570357, BaseUnit); - case ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt: - return new ThermalResistance(_value*1000.088056074108, BaseUnit); - case ThermalResistanceUnit.SquareMeterKelvinPerKilowatt: - return new ThermalResistance(_value, BaseUnit); + case ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu: return _value*176.1121482159839; + case ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie: return _value*0.0859779507590433; + case ThermalResistanceUnit.SquareCentimeterKelvinPerWatt: return _value*0.0999964777570357; + case ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt: return _value*1000.088056074108; + case ThermalResistanceUnit.SquareMeterKelvinPerKilowatt: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(ThermalResistanceUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal ThermalResistance ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ThermalResistance(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ThermalResistanceUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Torque.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Torque.NetFramework.g.cs index b317b46ab0..c944ff67af 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 new Torque(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static Torque operator -(Torque left, Torque right) { - return new Torque(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new Torque(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static Torque operator *(double left, Torque right) @@ -670,22 +670,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Torque public static bool operator <=(Torque left, Torque right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(Torque left, Torque right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(Torque left, Torque right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(Torque left, Torque right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(Torque left, Torque right) @@ -709,7 +709,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(Torque other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -722,7 +722,7 @@ public override bool Equals(object obj) public bool Equals(Torque other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -798,7 +798,7 @@ public double As(TorqueUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -808,7 +808,7 @@ public double As(TorqueUnit unit) /// A Torque with the specified unit. public Torque ToUnit(TorqueUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Torque(convertedValue, unit); } @@ -817,64 +817,53 @@ public Torque ToUnit(TorqueUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Torque AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case TorqueUnit.KilogramForceCentimeter: - return new Torque(_value*0.0980665019960652, BaseUnit); - case TorqueUnit.KilogramForceMeter: - return new Torque(_value*9.80665019960652, BaseUnit); - case TorqueUnit.KilogramForceMillimeter: - return new Torque(_value*0.00980665019960652, BaseUnit); - case TorqueUnit.KilonewtonCentimeter: - return new Torque((_value*0.01) * 1e3d, BaseUnit); - case TorqueUnit.KilonewtonMeter: - return new Torque((_value) * 1e3d, BaseUnit); - case TorqueUnit.KilonewtonMillimeter: - return new Torque((_value*0.001) * 1e3d, BaseUnit); - case TorqueUnit.KilopoundForceFoot: - return new Torque((_value*1.3558179483314) * 1e3d, BaseUnit); - case TorqueUnit.KilopoundForceInch: - return new Torque((_value*1.129848290276167e-1) * 1e3d, BaseUnit); - case TorqueUnit.MeganewtonCentimeter: - return new Torque((_value*0.01) * 1e6d, BaseUnit); - case TorqueUnit.MeganewtonMeter: - return new Torque((_value) * 1e6d, BaseUnit); - case TorqueUnit.MeganewtonMillimeter: - return new Torque((_value*0.001) * 1e6d, BaseUnit); - case TorqueUnit.MegapoundForceFoot: - return new Torque((_value*1.3558179483314) * 1e6d, BaseUnit); - case TorqueUnit.MegapoundForceInch: - return new Torque((_value*1.129848290276167e-1) * 1e6d, BaseUnit); - case TorqueUnit.NewtonCentimeter: - return new Torque(_value*0.01, BaseUnit); - case TorqueUnit.NewtonMeter: - return new Torque(_value, BaseUnit); - case TorqueUnit.NewtonMillimeter: - return new Torque(_value*0.001, BaseUnit); - case TorqueUnit.PoundForceFoot: - return new Torque(_value*1.3558179483314, BaseUnit); - case TorqueUnit.PoundForceInch: - return new Torque(_value*1.129848290276167e-1, BaseUnit); - case TorqueUnit.TonneForceCentimeter: - return new Torque(_value*98.0665019960652, BaseUnit); - case TorqueUnit.TonneForceMeter: - return new Torque(_value*9806.65019960653, BaseUnit); - case TorqueUnit.TonneForceMillimeter: - return new Torque(_value*9.80665019960652, BaseUnit); + case TorqueUnit.KilogramForceCentimeter: return _value*0.0980665019960652; + case TorqueUnit.KilogramForceMeter: return _value*9.80665019960652; + case TorqueUnit.KilogramForceMillimeter: return _value*0.00980665019960652; + case TorqueUnit.KilonewtonCentimeter: return (_value*0.01) * 1e3d; + case TorqueUnit.KilonewtonMeter: return (_value) * 1e3d; + case TorqueUnit.KilonewtonMillimeter: return (_value*0.001) * 1e3d; + case TorqueUnit.KilopoundForceFoot: return (_value*1.3558179483314) * 1e3d; + case TorqueUnit.KilopoundForceInch: return (_value*1.129848290276167e-1) * 1e3d; + case TorqueUnit.MeganewtonCentimeter: return (_value*0.01) * 1e6d; + case TorqueUnit.MeganewtonMeter: return (_value) * 1e6d; + case TorqueUnit.MeganewtonMillimeter: return (_value*0.001) * 1e6d; + case TorqueUnit.MegapoundForceFoot: return (_value*1.3558179483314) * 1e6d; + case TorqueUnit.MegapoundForceInch: return (_value*1.129848290276167e-1) * 1e6d; + case TorqueUnit.NewtonCentimeter: return _value*0.01; + case TorqueUnit.NewtonMeter: return _value; + case TorqueUnit.NewtonMillimeter: return _value*0.001; + case TorqueUnit.PoundForceFoot: return _value*1.3558179483314; + case TorqueUnit.PoundForceInch: return _value*1.129848290276167e-1; + case TorqueUnit.TonneForceCentimeter: return _value*98.0665019960652; + case TorqueUnit.TonneForceMeter: return _value*9806.65019960653; + case TorqueUnit.TonneForceMillimeter: return _value*9.80665019960652; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(TorqueUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Torque ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Torque(baseUnitValue, BaseUnit); + } + + private double GetValueAs(TorqueUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/VitaminA.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/VitaminA.NetFramework.g.cs index 7283b0e7c2..4a58ceccfb 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 new VitaminA(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static VitaminA operator -(VitaminA left, VitaminA right) { - return new VitaminA(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new VitaminA(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static VitaminA operator *(double left, VitaminA right) @@ -390,22 +390,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Vitami public static bool operator <=(VitaminA left, VitaminA right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(VitaminA left, VitaminA right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(VitaminA left, VitaminA right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(VitaminA left, VitaminA right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(VitaminA left, VitaminA right) @@ -429,7 +429,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(VitaminA other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -442,7 +442,7 @@ public override bool Equals(object obj) public bool Equals(VitaminA other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -518,7 +518,7 @@ public double As(VitaminAUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -528,7 +528,7 @@ public double As(VitaminAUnit unit) /// A VitaminA with the specified unit. public VitaminA ToUnit(VitaminAUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new VitaminA(convertedValue, unit); } @@ -537,24 +537,33 @@ public VitaminA ToUnit(VitaminAUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal VitaminA AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case VitaminAUnit.InternationalUnit: - return new VitaminA(_value, BaseUnit); + case VitaminAUnit.InternationalUnit: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(VitaminAUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal VitaminA ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new VitaminA(baseUnitValue, BaseUnit); + } + + private double GetValueAs(VitaminAUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/Volume.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Volume.NetFramework.g.cs index 922e4ca8fa..2eee234d34 100644 --- a/UnitsNet/GeneratedCode/Quantities/Volume.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Volume.NetFramework.g.cs @@ -972,12 +972,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 new Volume(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static Volume operator -(Volume left, Volume right) { - return new Volume(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new Volume(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static Volume operator *(double left, Volume right) @@ -1006,22 +1006,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Volume public static bool operator <=(Volume left, Volume right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(Volume left, Volume right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(Volume left, Volume right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(Volume left, Volume right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(Volume left, Volume right) @@ -1045,7 +1045,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(Volume other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -1058,7 +1058,7 @@ public override bool Equals(object obj) public bool Equals(Volume other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -1134,7 +1134,7 @@ public double As(VolumeUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -1144,7 +1144,7 @@ public double As(VolumeUnit unit) /// A Volume with the specified unit. public Volume ToUnit(VolumeUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new Volume(convertedValue, unit); } @@ -1153,112 +1153,77 @@ public Volume ToUnit(VolumeUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal Volume AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case VolumeUnit.AcreFoot: - return new Volume(_value/0.000810714, BaseUnit); - case VolumeUnit.AuTablespoon: - return new Volume(_value*2e-5, BaseUnit); - case VolumeUnit.Centiliter: - return new Volume((_value/1e3) * 1e-2d, BaseUnit); - case VolumeUnit.CubicCentimeter: - return new Volume(_value/1e6, BaseUnit); - case VolumeUnit.CubicDecimeter: - return new Volume(_value/1e3, BaseUnit); - case VolumeUnit.CubicFoot: - return new Volume(_value*0.0283168, BaseUnit); - case VolumeUnit.CubicInch: - return new Volume(_value*1.6387*1e-5, BaseUnit); - case VolumeUnit.CubicKilometer: - return new Volume(_value*1e9, BaseUnit); - case VolumeUnit.CubicMeter: - return new Volume(_value, BaseUnit); - case VolumeUnit.CubicMicrometer: - return new Volume(_value/1e18, BaseUnit); - case VolumeUnit.CubicMile: - return new Volume(_value*4.16818182544058e9, BaseUnit); - case VolumeUnit.CubicMillimeter: - return new Volume(_value/1e9, BaseUnit); - case VolumeUnit.CubicYard: - return new Volume(_value*0.764554858, BaseUnit); - case VolumeUnit.Deciliter: - return new Volume((_value/1e3) * 1e-1d, BaseUnit); - case VolumeUnit.HectocubicFoot: - return new Volume((_value*0.0283168) * 1e2d, BaseUnit); - case VolumeUnit.HectocubicMeter: - return new Volume((_value) * 1e2d, BaseUnit); - case VolumeUnit.Hectoliter: - return new Volume((_value/1e3) * 1e2d, BaseUnit); - case VolumeUnit.ImperialBeerBarrel: - return new Volume(_value*0.16365924, BaseUnit); - case VolumeUnit.ImperialGallon: - return new Volume(_value*0.00454609000000181429905810072407, BaseUnit); - case VolumeUnit.ImperialOunce: - return new Volume(_value*2.8413062499962901241875439064617e-5, BaseUnit); - case VolumeUnit.KilocubicFoot: - return new Volume((_value*0.0283168) * 1e3d, BaseUnit); - case VolumeUnit.KilocubicMeter: - return new Volume((_value) * 1e3d, BaseUnit); - case VolumeUnit.KiloimperialGallon: - return new Volume((_value*0.00454609000000181429905810072407) * 1e3d, BaseUnit); - case VolumeUnit.Kiloliter: - return new Volume((_value/1e3) * 1e3d, BaseUnit); - case VolumeUnit.KilousGallon: - return new Volume((_value*0.00378541) * 1e3d, BaseUnit); - case VolumeUnit.Liter: - return new Volume(_value/1e3, BaseUnit); - case VolumeUnit.MegacubicFoot: - return new Volume((_value*0.0283168) * 1e6d, BaseUnit); - case VolumeUnit.MegaimperialGallon: - return new Volume((_value*0.00454609000000181429905810072407) * 1e6d, BaseUnit); - case VolumeUnit.Megaliter: - return new Volume((_value/1e3) * 1e6d, BaseUnit); - case VolumeUnit.MegausGallon: - return new Volume((_value*0.00378541) * 1e6d, BaseUnit); - case VolumeUnit.MetricCup: - return new Volume(_value*0.00025, BaseUnit); - case VolumeUnit.MetricTeaspoon: - return new Volume(_value*0.5e-5, BaseUnit); - case VolumeUnit.Microliter: - return new Volume((_value/1e3) * 1e-6d, BaseUnit); - case VolumeUnit.Milliliter: - return new Volume((_value/1e3) * 1e-3d, BaseUnit); - case VolumeUnit.OilBarrel: - return new Volume(_value*0.158987294928, BaseUnit); - case VolumeUnit.UkTablespoon: - return new Volume(_value*1.5e-5, BaseUnit); - case VolumeUnit.UsBeerBarrel: - return new Volume(_value*0.1173477658, BaseUnit); - case VolumeUnit.UsCustomaryCup: - return new Volume(_value*0.0002365882365, BaseUnit); - case VolumeUnit.UsGallon: - return new Volume(_value*0.00378541, BaseUnit); - case VolumeUnit.UsLegalCup: - return new Volume(_value*0.00024, BaseUnit); - case VolumeUnit.UsOunce: - return new Volume(_value*2.957352956253760505068307980135e-5, BaseUnit); - case VolumeUnit.UsPint: - return new Volume(_value*4.73176473e-4, BaseUnit); - case VolumeUnit.UsQuart: - return new Volume(_value*9.46352946e-4, BaseUnit); - case VolumeUnit.UsTablespoon: - return new Volume(_value*1.478676478125e-5, BaseUnit); - case VolumeUnit.UsTeaspoon: - return new Volume(_value*4.92892159375e-6, BaseUnit); + case VolumeUnit.AcreFoot: return _value/0.000810714; + case VolumeUnit.AuTablespoon: return _value*2e-5; + case VolumeUnit.Centiliter: return (_value/1e3) * 1e-2d; + case VolumeUnit.CubicCentimeter: return _value/1e6; + case VolumeUnit.CubicDecimeter: return _value/1e3; + case VolumeUnit.CubicFoot: return _value*0.0283168; + case VolumeUnit.CubicInch: return _value*1.6387*1e-5; + case VolumeUnit.CubicKilometer: return _value*1e9; + case VolumeUnit.CubicMeter: return _value; + case VolumeUnit.CubicMicrometer: return _value/1e18; + case VolumeUnit.CubicMile: return _value*4.16818182544058e9; + case VolumeUnit.CubicMillimeter: return _value/1e9; + case VolumeUnit.CubicYard: return _value*0.764554858; + case VolumeUnit.Deciliter: return (_value/1e3) * 1e-1d; + case VolumeUnit.HectocubicFoot: return (_value*0.0283168) * 1e2d; + case VolumeUnit.HectocubicMeter: return (_value) * 1e2d; + case VolumeUnit.Hectoliter: return (_value/1e3) * 1e2d; + case VolumeUnit.ImperialBeerBarrel: return _value*0.16365924; + case VolumeUnit.ImperialGallon: return _value*0.00454609000000181429905810072407; + case VolumeUnit.ImperialOunce: return _value*2.8413062499962901241875439064617e-5; + case VolumeUnit.KilocubicFoot: return (_value*0.0283168) * 1e3d; + case VolumeUnit.KilocubicMeter: return (_value) * 1e3d; + case VolumeUnit.KiloimperialGallon: return (_value*0.00454609000000181429905810072407) * 1e3d; + case VolumeUnit.Kiloliter: return (_value/1e3) * 1e3d; + case VolumeUnit.KilousGallon: return (_value*0.00378541) * 1e3d; + case VolumeUnit.Liter: return _value/1e3; + case VolumeUnit.MegacubicFoot: return (_value*0.0283168) * 1e6d; + case VolumeUnit.MegaimperialGallon: return (_value*0.00454609000000181429905810072407) * 1e6d; + case VolumeUnit.Megaliter: return (_value/1e3) * 1e6d; + case VolumeUnit.MegausGallon: return (_value*0.00378541) * 1e6d; + case VolumeUnit.MetricCup: return _value*0.00025; + case VolumeUnit.MetricTeaspoon: return _value*0.5e-5; + case VolumeUnit.Microliter: return (_value/1e3) * 1e-6d; + case VolumeUnit.Milliliter: return (_value/1e3) * 1e-3d; + case VolumeUnit.OilBarrel: return _value*0.158987294928; + case VolumeUnit.UkTablespoon: return _value*1.5e-5; + case VolumeUnit.UsBeerBarrel: return _value*0.1173477658; + case VolumeUnit.UsCustomaryCup: return _value*0.0002365882365; + case VolumeUnit.UsGallon: return _value*0.00378541; + case VolumeUnit.UsLegalCup: return _value*0.00024; + case VolumeUnit.UsOunce: return _value*2.957352956253760505068307980135e-5; + case VolumeUnit.UsPint: return _value*4.73176473e-4; + case VolumeUnit.UsQuart: return _value*9.46352946e-4; + case VolumeUnit.UsTablespoon: return _value*1.478676478125e-5; + case VolumeUnit.UsTeaspoon: return _value*4.92892159375e-6; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(VolumeUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal Volume ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new Volume(baseUnitValue, BaseUnit); + } + + private double GetValueAs(VolumeUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/Quantities/VolumeFlow.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumeFlow.NetFramework.g.cs index d1feae1fb3..ce290409a4 100644 --- a/UnitsNet/GeneratedCode/Quantities/VolumeFlow.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/VolumeFlow.NetFramework.g.cs @@ -1014,12 +1014,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 new VolumeFlow(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static VolumeFlow operator -(VolumeFlow left, VolumeFlow right) { - return new VolumeFlow(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new VolumeFlow(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static VolumeFlow operator *(double left, VolumeFlow right) @@ -1048,22 +1048,22 @@ public static bool TryParseUnit(string str, IFormatProvider provider, out Volume public static bool operator <=(VolumeFlow left, VolumeFlow right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=(VolumeFlow left, VolumeFlow right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <(VolumeFlow left, VolumeFlow right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >(VolumeFlow left, VolumeFlow right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==(VolumeFlow left, VolumeFlow right) @@ -1087,7 +1087,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods public int CompareTo(VolumeFlow other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } public override bool Equals(object obj) @@ -1100,7 +1100,7 @@ public override bool Equals(object obj) public bool Equals(VolumeFlow other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -1176,7 +1176,7 @@ public double As(VolumeFlowUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -1186,7 +1186,7 @@ public double As(VolumeFlowUnit unit) /// A VolumeFlow with the specified unit. public VolumeFlow ToUnit(VolumeFlowUnit unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new VolumeFlow(convertedValue, unit); } @@ -1195,118 +1195,80 @@ public VolumeFlow ToUnit(VolumeFlowUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal VolumeFlow AsBaseUnit() + private double GetValueInBaseUnit() { switch(Unit) { - case VolumeFlowUnit.AcreFootPerDay: - return new VolumeFlow(_value/70.0457, BaseUnit); - case VolumeFlowUnit.AcreFootPerHour: - return new VolumeFlow(_value/2.91857, BaseUnit); - case VolumeFlowUnit.AcreFootPerMinute: - return new VolumeFlow(_value/0.0486427916, BaseUnit); - case VolumeFlowUnit.AcreFootPerSecond: - return new VolumeFlow(_value/0.000810713194, BaseUnit); - case VolumeFlowUnit.CentiliterPerDay: - return new VolumeFlow((_value/86400000) * 1e-2d, BaseUnit); - case VolumeFlowUnit.CentiliterPerMinute: - return new VolumeFlow((_value/60000.00000) * 1e-2d, BaseUnit); - case VolumeFlowUnit.CubicDecimeterPerMinute: - return new VolumeFlow(_value/60000.00000, BaseUnit); - case VolumeFlowUnit.CubicFootPerHour: - return new VolumeFlow(_value*7.8657907199999087346816086183876e-6, BaseUnit); - case VolumeFlowUnit.CubicFootPerMinute: - return new VolumeFlow(_value/2118.88000326, BaseUnit); - case VolumeFlowUnit.CubicFootPerSecond: - return new VolumeFlow(_value/35.314666721, BaseUnit); - case VolumeFlowUnit.CubicMeterPerDay: - return new VolumeFlow(_value/86400, BaseUnit); - case VolumeFlowUnit.CubicMeterPerHour: - return new VolumeFlow(_value/3600, BaseUnit); - case VolumeFlowUnit.CubicMeterPerMinute: - return new VolumeFlow(_value/60, BaseUnit); - case VolumeFlowUnit.CubicMeterPerSecond: - return new VolumeFlow(_value, BaseUnit); - case VolumeFlowUnit.CubicMillimeterPerSecond: - return new VolumeFlow(_value*1e-9, BaseUnit); - case VolumeFlowUnit.CubicYardPerDay: - return new VolumeFlow(_value/113007, BaseUnit); - case VolumeFlowUnit.CubicYardPerHour: - return new VolumeFlow(_value*2.1237634944E-4, BaseUnit); - case VolumeFlowUnit.CubicYardPerMinute: - return new VolumeFlow(_value*0.0127425809664, BaseUnit); - case VolumeFlowUnit.CubicYardPerSecond: - return new VolumeFlow(_value*0.764554857984, BaseUnit); - case VolumeFlowUnit.DeciliterPerDay: - return new VolumeFlow((_value/86400000) * 1e-1d, BaseUnit); - case VolumeFlowUnit.DeciliterPerMinute: - return new VolumeFlow((_value/60000.00000) * 1e-1d, BaseUnit); - case VolumeFlowUnit.KiloliterPerDay: - return new VolumeFlow((_value/86400000) * 1e3d, BaseUnit); - case VolumeFlowUnit.KiloliterPerMinute: - return new VolumeFlow((_value/60000.00000) * 1e3d, BaseUnit); - case VolumeFlowUnit.KilousGallonPerMinute: - return new VolumeFlow(_value/15.850323141489, BaseUnit); - case VolumeFlowUnit.LiterPerDay: - return new VolumeFlow(_value/86400000, BaseUnit); - case VolumeFlowUnit.LiterPerHour: - return new VolumeFlow(_value/3600000.000, BaseUnit); - case VolumeFlowUnit.LiterPerMinute: - return new VolumeFlow(_value/60000.00000, BaseUnit); - case VolumeFlowUnit.LiterPerSecond: - return new VolumeFlow(_value/1000, BaseUnit); - case VolumeFlowUnit.MegaliterPerDay: - return new VolumeFlow((_value/86400000) * 1e6d, BaseUnit); - case VolumeFlowUnit.MegaukGallonPerSecond: - return new VolumeFlow((_value/219.969) * 1e6d, BaseUnit); - case VolumeFlowUnit.MicroliterPerDay: - return new VolumeFlow((_value/86400000) * 1e-6d, BaseUnit); - case VolumeFlowUnit.MicroliterPerMinute: - return new VolumeFlow((_value/60000.00000) * 1e-6d, BaseUnit); - case VolumeFlowUnit.MilliliterPerDay: - return new VolumeFlow((_value/86400000) * 1e-3d, BaseUnit); - case VolumeFlowUnit.MilliliterPerMinute: - return new VolumeFlow((_value/60000.00000) * 1e-3d, BaseUnit); - case VolumeFlowUnit.MillionUsGallonsPerDay: - return new VolumeFlow(_value/22.824465227, BaseUnit); - case VolumeFlowUnit.NanoliterPerDay: - return new VolumeFlow((_value/86400000) * 1e-9d, BaseUnit); - case VolumeFlowUnit.NanoliterPerMinute: - return new VolumeFlow((_value/60000.00000) * 1e-9d, BaseUnit); - case VolumeFlowUnit.OilBarrelPerDay: - return new VolumeFlow(_value*1.8401307283333333333333333333333e-6, BaseUnit); - case VolumeFlowUnit.OilBarrelPerHour: - return new VolumeFlow(_value*4.41631375e-5, BaseUnit); - case VolumeFlowUnit.OilBarrelPerMinute: - return new VolumeFlow(_value*2.64978825e-3, BaseUnit); - case VolumeFlowUnit.OilBarrelPerSecond: - return new VolumeFlow(_value/6.28981, BaseUnit); - case VolumeFlowUnit.UkGallonPerDay: - return new VolumeFlow(_value/19005304, BaseUnit); - case VolumeFlowUnit.UkGallonPerMinute: - return new VolumeFlow(_value/13198.2, BaseUnit); - case VolumeFlowUnit.UkGallonPerSecond: - return new VolumeFlow(_value/219.969, BaseUnit); - case VolumeFlowUnit.UsGallonPerDay: - return new VolumeFlow(_value/22824465.227, BaseUnit); - case VolumeFlowUnit.UsGallonPerHour: - return new VolumeFlow(_value/951019.38848933424, BaseUnit); - case VolumeFlowUnit.UsGallonPerMinute: - return new VolumeFlow(_value/15850.323141489, BaseUnit); - case VolumeFlowUnit.UsGallonPerSecond: - return new VolumeFlow(_value/264.1720523581484, BaseUnit); + case VolumeFlowUnit.AcreFootPerDay: return _value/70.0457; + case VolumeFlowUnit.AcreFootPerHour: return _value/2.91857; + case VolumeFlowUnit.AcreFootPerMinute: return _value/0.0486427916; + case VolumeFlowUnit.AcreFootPerSecond: return _value/0.000810713194; + case VolumeFlowUnit.CentiliterPerDay: return (_value/86400000) * 1e-2d; + case VolumeFlowUnit.CentiliterPerMinute: return (_value/60000.00000) * 1e-2d; + case VolumeFlowUnit.CubicDecimeterPerMinute: return _value/60000.00000; + case VolumeFlowUnit.CubicFootPerHour: return _value*7.8657907199999087346816086183876e-6; + case VolumeFlowUnit.CubicFootPerMinute: return _value/2118.88000326; + case VolumeFlowUnit.CubicFootPerSecond: return _value/35.314666721; + case VolumeFlowUnit.CubicMeterPerDay: return _value/86400; + case VolumeFlowUnit.CubicMeterPerHour: return _value/3600; + case VolumeFlowUnit.CubicMeterPerMinute: return _value/60; + case VolumeFlowUnit.CubicMeterPerSecond: return _value; + case VolumeFlowUnit.CubicMillimeterPerSecond: return _value*1e-9; + case VolumeFlowUnit.CubicYardPerDay: return _value/113007; + case VolumeFlowUnit.CubicYardPerHour: return _value*2.1237634944E-4; + case VolumeFlowUnit.CubicYardPerMinute: return _value*0.0127425809664; + case VolumeFlowUnit.CubicYardPerSecond: return _value*0.764554857984; + case VolumeFlowUnit.DeciliterPerDay: return (_value/86400000) * 1e-1d; + case VolumeFlowUnit.DeciliterPerMinute: return (_value/60000.00000) * 1e-1d; + case VolumeFlowUnit.KiloliterPerDay: return (_value/86400000) * 1e3d; + case VolumeFlowUnit.KiloliterPerMinute: return (_value/60000.00000) * 1e3d; + case VolumeFlowUnit.KilousGallonPerMinute: return _value/15.850323141489; + case VolumeFlowUnit.LiterPerDay: return _value/86400000; + case VolumeFlowUnit.LiterPerHour: return _value/3600000.000; + case VolumeFlowUnit.LiterPerMinute: return _value/60000.00000; + case VolumeFlowUnit.LiterPerSecond: return _value/1000; + case VolumeFlowUnit.MegaliterPerDay: return (_value/86400000) * 1e6d; + case VolumeFlowUnit.MegaukGallonPerSecond: return (_value/219.969) * 1e6d; + case VolumeFlowUnit.MicroliterPerDay: return (_value/86400000) * 1e-6d; + case VolumeFlowUnit.MicroliterPerMinute: return (_value/60000.00000) * 1e-6d; + case VolumeFlowUnit.MilliliterPerDay: return (_value/86400000) * 1e-3d; + case VolumeFlowUnit.MilliliterPerMinute: return (_value/60000.00000) * 1e-3d; + case VolumeFlowUnit.MillionUsGallonsPerDay: return _value/22.824465227; + case VolumeFlowUnit.NanoliterPerDay: return (_value/86400000) * 1e-9d; + case VolumeFlowUnit.NanoliterPerMinute: return (_value/60000.00000) * 1e-9d; + case VolumeFlowUnit.OilBarrelPerDay: return _value*1.8401307283333333333333333333333e-6; + case VolumeFlowUnit.OilBarrelPerHour: return _value*4.41631375e-5; + case VolumeFlowUnit.OilBarrelPerMinute: return _value*2.64978825e-3; + case VolumeFlowUnit.OilBarrelPerSecond: return _value/6.28981; + case VolumeFlowUnit.UkGallonPerDay: return _value/19005304; + case VolumeFlowUnit.UkGallonPerMinute: return _value/13198.2; + case VolumeFlowUnit.UkGallonPerSecond: return _value/219.969; + case VolumeFlowUnit.UsGallonPerDay: return _value/22824465.227; + case VolumeFlowUnit.UsGallonPerHour: return _value/951019.38848933424; + case VolumeFlowUnit.UsGallonPerMinute: return _value/15850.323141489; + case VolumeFlowUnit.UsGallonPerSecond: return _value/264.1720523581484; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private double AsBaseNumericType(VolumeFlowUnit unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal VolumeFlow ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new VolumeFlow(baseUnitValue, BaseUnit); + } + + private double GetValueAs(VolumeFlowUnit unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/GeneratedCode/UnitConverter.g.cs b/UnitsNet/GeneratedCode/UnitConverter.g.cs index 293f55b55e..825f6ff6b1 100644 --- a/UnitsNet/GeneratedCode/UnitConverter.g.cs +++ b/UnitsNet/GeneratedCode/UnitConverter.g.cs @@ -49,1689 +49,1689 @@ public static void RegisterDefaultConversions(UnitConverter unitConverter) { #if !WINDOWS_UWP unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.CentimeterPerSecondSquared, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.CentimeterPerSecondSquared)); - unitConverter.SetConversionFunction(AccelerationUnit.CentimeterPerSecondSquared, Acceleration.BaseUnit, (q) => ((Acceleration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AccelerationUnit.CentimeterPerSecondSquared, Acceleration.BaseUnit, (q) => ((Acceleration)q).ToBaseUnit()); unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.DecimeterPerSecondSquared, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.DecimeterPerSecondSquared)); - unitConverter.SetConversionFunction(AccelerationUnit.DecimeterPerSecondSquared, Acceleration.BaseUnit, (q) => ((Acceleration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AccelerationUnit.DecimeterPerSecondSquared, Acceleration.BaseUnit, (q) => ((Acceleration)q).ToBaseUnit()); unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.FootPerSecondSquared, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.FootPerSecondSquared)); - unitConverter.SetConversionFunction(AccelerationUnit.FootPerSecondSquared, Acceleration.BaseUnit, (q) => ((Acceleration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AccelerationUnit.FootPerSecondSquared, Acceleration.BaseUnit, (q) => ((Acceleration)q).ToBaseUnit()); unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.InchPerSecondSquared, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.InchPerSecondSquared)); - unitConverter.SetConversionFunction(AccelerationUnit.InchPerSecondSquared, Acceleration.BaseUnit, (q) => ((Acceleration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AccelerationUnit.InchPerSecondSquared, Acceleration.BaseUnit, (q) => ((Acceleration)q).ToBaseUnit()); unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.KilometerPerSecondSquared, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.KilometerPerSecondSquared)); - unitConverter.SetConversionFunction(AccelerationUnit.KilometerPerSecondSquared, Acceleration.BaseUnit, (q) => ((Acceleration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AccelerationUnit.KilometerPerSecondSquared, Acceleration.BaseUnit, (q) => ((Acceleration)q).ToBaseUnit()); unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.KnotPerHour, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.KnotPerHour)); - unitConverter.SetConversionFunction(AccelerationUnit.KnotPerHour, Acceleration.BaseUnit, (q) => ((Acceleration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AccelerationUnit.KnotPerHour, Acceleration.BaseUnit, (q) => ((Acceleration)q).ToBaseUnit()); unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.KnotPerMinute, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.KnotPerMinute)); - unitConverter.SetConversionFunction(AccelerationUnit.KnotPerMinute, Acceleration.BaseUnit, (q) => ((Acceleration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AccelerationUnit.KnotPerMinute, Acceleration.BaseUnit, (q) => ((Acceleration)q).ToBaseUnit()); unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.KnotPerSecond, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.KnotPerSecond)); - unitConverter.SetConversionFunction(AccelerationUnit.KnotPerSecond, Acceleration.BaseUnit, (q) => ((Acceleration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AccelerationUnit.KnotPerSecond, Acceleration.BaseUnit, (q) => ((Acceleration)q).ToBaseUnit()); unitConverter.SetConversionFunction(Acceleration.BaseUnit, Acceleration.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.MicrometerPerSecondSquared, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.MicrometerPerSecondSquared)); - unitConverter.SetConversionFunction(AccelerationUnit.MicrometerPerSecondSquared, Acceleration.BaseUnit, (q) => ((Acceleration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AccelerationUnit.MicrometerPerSecondSquared, Acceleration.BaseUnit, (q) => ((Acceleration)q).ToBaseUnit()); unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.MillimeterPerSecondSquared, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.MillimeterPerSecondSquared)); - unitConverter.SetConversionFunction(AccelerationUnit.MillimeterPerSecondSquared, Acceleration.BaseUnit, (q) => ((Acceleration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AccelerationUnit.MillimeterPerSecondSquared, Acceleration.BaseUnit, (q) => ((Acceleration)q).ToBaseUnit()); unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.NanometerPerSecondSquared, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.NanometerPerSecondSquared)); - unitConverter.SetConversionFunction(AccelerationUnit.NanometerPerSecondSquared, Acceleration.BaseUnit, (q) => ((Acceleration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AccelerationUnit.NanometerPerSecondSquared, Acceleration.BaseUnit, (q) => ((Acceleration)q).ToBaseUnit()); unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.StandardGravity, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.StandardGravity)); - unitConverter.SetConversionFunction(AccelerationUnit.StandardGravity, Acceleration.BaseUnit, (q) => ((Acceleration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AccelerationUnit.StandardGravity, Acceleration.BaseUnit, (q) => ((Acceleration)q).ToBaseUnit()); unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Centimole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.Centimole)); - unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Centimole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Centimole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).ToBaseUnit()); unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.CentipoundMole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.CentipoundMole)); - unitConverter.SetConversionFunction(AmountOfSubstanceUnit.CentipoundMole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.CentipoundMole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).ToBaseUnit()); unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Decimole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.Decimole)); - unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Decimole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Decimole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).ToBaseUnit()); unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.DecipoundMole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.DecipoundMole)); - unitConverter.SetConversionFunction(AmountOfSubstanceUnit.DecipoundMole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.DecipoundMole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).ToBaseUnit()); unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Kilomole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.Kilomole)); - unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Kilomole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Kilomole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).ToBaseUnit()); unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.KilopoundMole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.KilopoundMole)); - unitConverter.SetConversionFunction(AmountOfSubstanceUnit.KilopoundMole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.KilopoundMole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).ToBaseUnit()); unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Megamole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.Megamole)); - unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Megamole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Megamole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).ToBaseUnit()); unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Micromole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.Micromole)); - unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Micromole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Micromole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).ToBaseUnit()); unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.MicropoundMole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.MicropoundMole)); - unitConverter.SetConversionFunction(AmountOfSubstanceUnit.MicropoundMole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.MicropoundMole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).ToBaseUnit()); unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Millimole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.Millimole)); - unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Millimole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Millimole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).ToBaseUnit()); unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.MillipoundMole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.MillipoundMole)); - unitConverter.SetConversionFunction(AmountOfSubstanceUnit.MillipoundMole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.MillipoundMole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).ToBaseUnit()); unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstance.BaseUnit, (q) => q); unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Nanomole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.Nanomole)); - unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Nanomole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Nanomole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).ToBaseUnit()); unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.NanopoundMole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.NanopoundMole)); - unitConverter.SetConversionFunction(AmountOfSubstanceUnit.NanopoundMole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.NanopoundMole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).ToBaseUnit()); unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.PoundMole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.PoundMole)); - unitConverter.SetConversionFunction(AmountOfSubstanceUnit.PoundMole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.PoundMole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).ToBaseUnit()); unitConverter.SetConversionFunction(AmplitudeRatio.BaseUnit, AmplitudeRatioUnit.DecibelMicrovolt, (q) => ((AmplitudeRatio)q).ToUnit(AmplitudeRatioUnit.DecibelMicrovolt)); - unitConverter.SetConversionFunction(AmplitudeRatioUnit.DecibelMicrovolt, AmplitudeRatio.BaseUnit, (q) => ((AmplitudeRatio)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmplitudeRatioUnit.DecibelMicrovolt, AmplitudeRatio.BaseUnit, (q) => ((AmplitudeRatio)q).ToBaseUnit()); unitConverter.SetConversionFunction(AmplitudeRatio.BaseUnit, AmplitudeRatioUnit.DecibelMillivolt, (q) => ((AmplitudeRatio)q).ToUnit(AmplitudeRatioUnit.DecibelMillivolt)); - unitConverter.SetConversionFunction(AmplitudeRatioUnit.DecibelMillivolt, AmplitudeRatio.BaseUnit, (q) => ((AmplitudeRatio)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmplitudeRatioUnit.DecibelMillivolt, AmplitudeRatio.BaseUnit, (q) => ((AmplitudeRatio)q).ToBaseUnit()); unitConverter.SetConversionFunction(AmplitudeRatio.BaseUnit, AmplitudeRatioUnit.DecibelUnloaded, (q) => ((AmplitudeRatio)q).ToUnit(AmplitudeRatioUnit.DecibelUnloaded)); - unitConverter.SetConversionFunction(AmplitudeRatioUnit.DecibelUnloaded, AmplitudeRatio.BaseUnit, (q) => ((AmplitudeRatio)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AmplitudeRatioUnit.DecibelUnloaded, AmplitudeRatio.BaseUnit, (q) => ((AmplitudeRatio)q).ToBaseUnit()); unitConverter.SetConversionFunction(AmplitudeRatio.BaseUnit, AmplitudeRatio.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Arcminute, (q) => ((Angle)q).ToUnit(AngleUnit.Arcminute)); - unitConverter.SetConversionFunction(AngleUnit.Arcminute, Angle.BaseUnit, (q) => ((Angle)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AngleUnit.Arcminute, Angle.BaseUnit, (q) => ((Angle)q).ToBaseUnit()); unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Arcsecond, (q) => ((Angle)q).ToUnit(AngleUnit.Arcsecond)); - unitConverter.SetConversionFunction(AngleUnit.Arcsecond, Angle.BaseUnit, (q) => ((Angle)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AngleUnit.Arcsecond, Angle.BaseUnit, (q) => ((Angle)q).ToBaseUnit()); unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Centiradian, (q) => ((Angle)q).ToUnit(AngleUnit.Centiradian)); - unitConverter.SetConversionFunction(AngleUnit.Centiradian, Angle.BaseUnit, (q) => ((Angle)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AngleUnit.Centiradian, Angle.BaseUnit, (q) => ((Angle)q).ToBaseUnit()); unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Deciradian, (q) => ((Angle)q).ToUnit(AngleUnit.Deciradian)); - unitConverter.SetConversionFunction(AngleUnit.Deciradian, Angle.BaseUnit, (q) => ((Angle)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AngleUnit.Deciradian, Angle.BaseUnit, (q) => ((Angle)q).ToBaseUnit()); unitConverter.SetConversionFunction(Angle.BaseUnit, Angle.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Gradian, (q) => ((Angle)q).ToUnit(AngleUnit.Gradian)); - unitConverter.SetConversionFunction(AngleUnit.Gradian, Angle.BaseUnit, (q) => ((Angle)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AngleUnit.Gradian, Angle.BaseUnit, (q) => ((Angle)q).ToBaseUnit()); unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Microdegree, (q) => ((Angle)q).ToUnit(AngleUnit.Microdegree)); - unitConverter.SetConversionFunction(AngleUnit.Microdegree, Angle.BaseUnit, (q) => ((Angle)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AngleUnit.Microdegree, Angle.BaseUnit, (q) => ((Angle)q).ToBaseUnit()); unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Microradian, (q) => ((Angle)q).ToUnit(AngleUnit.Microradian)); - unitConverter.SetConversionFunction(AngleUnit.Microradian, Angle.BaseUnit, (q) => ((Angle)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AngleUnit.Microradian, Angle.BaseUnit, (q) => ((Angle)q).ToBaseUnit()); unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Millidegree, (q) => ((Angle)q).ToUnit(AngleUnit.Millidegree)); - unitConverter.SetConversionFunction(AngleUnit.Millidegree, Angle.BaseUnit, (q) => ((Angle)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AngleUnit.Millidegree, Angle.BaseUnit, (q) => ((Angle)q).ToBaseUnit()); unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Milliradian, (q) => ((Angle)q).ToUnit(AngleUnit.Milliradian)); - unitConverter.SetConversionFunction(AngleUnit.Milliradian, Angle.BaseUnit, (q) => ((Angle)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AngleUnit.Milliradian, Angle.BaseUnit, (q) => ((Angle)q).ToBaseUnit()); unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Nanodegree, (q) => ((Angle)q).ToUnit(AngleUnit.Nanodegree)); - unitConverter.SetConversionFunction(AngleUnit.Nanodegree, Angle.BaseUnit, (q) => ((Angle)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AngleUnit.Nanodegree, Angle.BaseUnit, (q) => ((Angle)q).ToBaseUnit()); unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Nanoradian, (q) => ((Angle)q).ToUnit(AngleUnit.Nanoradian)); - unitConverter.SetConversionFunction(AngleUnit.Nanoradian, Angle.BaseUnit, (q) => ((Angle)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AngleUnit.Nanoradian, Angle.BaseUnit, (q) => ((Angle)q).ToBaseUnit()); unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Radian, (q) => ((Angle)q).ToUnit(AngleUnit.Radian)); - unitConverter.SetConversionFunction(AngleUnit.Radian, Angle.BaseUnit, (q) => ((Angle)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AngleUnit.Radian, Angle.BaseUnit, (q) => ((Angle)q).ToBaseUnit()); unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Revolution, (q) => ((Angle)q).ToUnit(AngleUnit.Revolution)); - unitConverter.SetConversionFunction(AngleUnit.Revolution, Angle.BaseUnit, (q) => ((Angle)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AngleUnit.Revolution, Angle.BaseUnit, (q) => ((Angle)q).ToBaseUnit()); unitConverter.SetConversionFunction(ApparentEnergy.BaseUnit, ApparentEnergyUnit.KilovoltampereHour, (q) => ((ApparentEnergy)q).ToUnit(ApparentEnergyUnit.KilovoltampereHour)); - unitConverter.SetConversionFunction(ApparentEnergyUnit.KilovoltampereHour, ApparentEnergy.BaseUnit, (q) => ((ApparentEnergy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ApparentEnergyUnit.KilovoltampereHour, ApparentEnergy.BaseUnit, (q) => ((ApparentEnergy)q).ToBaseUnit()); unitConverter.SetConversionFunction(ApparentEnergy.BaseUnit, ApparentEnergyUnit.MegavoltampereHour, (q) => ((ApparentEnergy)q).ToUnit(ApparentEnergyUnit.MegavoltampereHour)); - unitConverter.SetConversionFunction(ApparentEnergyUnit.MegavoltampereHour, ApparentEnergy.BaseUnit, (q) => ((ApparentEnergy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ApparentEnergyUnit.MegavoltampereHour, ApparentEnergy.BaseUnit, (q) => ((ApparentEnergy)q).ToBaseUnit()); unitConverter.SetConversionFunction(ApparentEnergy.BaseUnit, ApparentEnergy.BaseUnit, (q) => q); unitConverter.SetConversionFunction(ApparentPower.BaseUnit, ApparentPowerUnit.Gigavoltampere, (q) => ((ApparentPower)q).ToUnit(ApparentPowerUnit.Gigavoltampere)); - unitConverter.SetConversionFunction(ApparentPowerUnit.Gigavoltampere, ApparentPower.BaseUnit, (q) => ((ApparentPower)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ApparentPowerUnit.Gigavoltampere, ApparentPower.BaseUnit, (q) => ((ApparentPower)q).ToBaseUnit()); unitConverter.SetConversionFunction(ApparentPower.BaseUnit, ApparentPowerUnit.Kilovoltampere, (q) => ((ApparentPower)q).ToUnit(ApparentPowerUnit.Kilovoltampere)); - unitConverter.SetConversionFunction(ApparentPowerUnit.Kilovoltampere, ApparentPower.BaseUnit, (q) => ((ApparentPower)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ApparentPowerUnit.Kilovoltampere, ApparentPower.BaseUnit, (q) => ((ApparentPower)q).ToBaseUnit()); unitConverter.SetConversionFunction(ApparentPower.BaseUnit, ApparentPowerUnit.Megavoltampere, (q) => ((ApparentPower)q).ToUnit(ApparentPowerUnit.Megavoltampere)); - unitConverter.SetConversionFunction(ApparentPowerUnit.Megavoltampere, ApparentPower.BaseUnit, (q) => ((ApparentPower)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ApparentPowerUnit.Megavoltampere, ApparentPower.BaseUnit, (q) => ((ApparentPower)q).ToBaseUnit()); unitConverter.SetConversionFunction(ApparentPower.BaseUnit, ApparentPower.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.Acre, (q) => ((Area)q).ToUnit(AreaUnit.Acre)); - unitConverter.SetConversionFunction(AreaUnit.Acre, Area.BaseUnit, (q) => ((Area)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AreaUnit.Acre, Area.BaseUnit, (q) => ((Area)q).ToBaseUnit()); unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.Hectare, (q) => ((Area)q).ToUnit(AreaUnit.Hectare)); - unitConverter.SetConversionFunction(AreaUnit.Hectare, Area.BaseUnit, (q) => ((Area)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AreaUnit.Hectare, Area.BaseUnit, (q) => ((Area)q).ToBaseUnit()); unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareCentimeter, (q) => ((Area)q).ToUnit(AreaUnit.SquareCentimeter)); - unitConverter.SetConversionFunction(AreaUnit.SquareCentimeter, Area.BaseUnit, (q) => ((Area)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AreaUnit.SquareCentimeter, Area.BaseUnit, (q) => ((Area)q).ToBaseUnit()); unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareDecimeter, (q) => ((Area)q).ToUnit(AreaUnit.SquareDecimeter)); - unitConverter.SetConversionFunction(AreaUnit.SquareDecimeter, Area.BaseUnit, (q) => ((Area)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AreaUnit.SquareDecimeter, Area.BaseUnit, (q) => ((Area)q).ToBaseUnit()); unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareFoot, (q) => ((Area)q).ToUnit(AreaUnit.SquareFoot)); - unitConverter.SetConversionFunction(AreaUnit.SquareFoot, Area.BaseUnit, (q) => ((Area)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AreaUnit.SquareFoot, Area.BaseUnit, (q) => ((Area)q).ToBaseUnit()); unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareInch, (q) => ((Area)q).ToUnit(AreaUnit.SquareInch)); - unitConverter.SetConversionFunction(AreaUnit.SquareInch, Area.BaseUnit, (q) => ((Area)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AreaUnit.SquareInch, Area.BaseUnit, (q) => ((Area)q).ToBaseUnit()); unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareKilometer, (q) => ((Area)q).ToUnit(AreaUnit.SquareKilometer)); - unitConverter.SetConversionFunction(AreaUnit.SquareKilometer, Area.BaseUnit, (q) => ((Area)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AreaUnit.SquareKilometer, Area.BaseUnit, (q) => ((Area)q).ToBaseUnit()); unitConverter.SetConversionFunction(Area.BaseUnit, Area.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareMicrometer, (q) => ((Area)q).ToUnit(AreaUnit.SquareMicrometer)); - unitConverter.SetConversionFunction(AreaUnit.SquareMicrometer, Area.BaseUnit, (q) => ((Area)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AreaUnit.SquareMicrometer, Area.BaseUnit, (q) => ((Area)q).ToBaseUnit()); unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareMile, (q) => ((Area)q).ToUnit(AreaUnit.SquareMile)); - unitConverter.SetConversionFunction(AreaUnit.SquareMile, Area.BaseUnit, (q) => ((Area)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AreaUnit.SquareMile, Area.BaseUnit, (q) => ((Area)q).ToBaseUnit()); unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareMillimeter, (q) => ((Area)q).ToUnit(AreaUnit.SquareMillimeter)); - unitConverter.SetConversionFunction(AreaUnit.SquareMillimeter, Area.BaseUnit, (q) => ((Area)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AreaUnit.SquareMillimeter, Area.BaseUnit, (q) => ((Area)q).ToBaseUnit()); unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareYard, (q) => ((Area)q).ToUnit(AreaUnit.SquareYard)); - unitConverter.SetConversionFunction(AreaUnit.SquareYard, Area.BaseUnit, (q) => ((Area)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AreaUnit.SquareYard, Area.BaseUnit, (q) => ((Area)q).ToBaseUnit()); unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.UsSurveySquareFoot, (q) => ((Area)q).ToUnit(AreaUnit.UsSurveySquareFoot)); - unitConverter.SetConversionFunction(AreaUnit.UsSurveySquareFoot, Area.BaseUnit, (q) => ((Area)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AreaUnit.UsSurveySquareFoot, Area.BaseUnit, (q) => ((Area)q).ToBaseUnit()); unitConverter.SetConversionFunction(AreaDensity.BaseUnit, AreaDensity.BaseUnit, (q) => q); unitConverter.SetConversionFunction(AreaMomentOfInertia.BaseUnit, AreaMomentOfInertiaUnit.CentimeterToTheFourth, (q) => ((AreaMomentOfInertia)q).ToUnit(AreaMomentOfInertiaUnit.CentimeterToTheFourth)); - unitConverter.SetConversionFunction(AreaMomentOfInertiaUnit.CentimeterToTheFourth, AreaMomentOfInertia.BaseUnit, (q) => ((AreaMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AreaMomentOfInertiaUnit.CentimeterToTheFourth, AreaMomentOfInertia.BaseUnit, (q) => ((AreaMomentOfInertia)q).ToBaseUnit()); unitConverter.SetConversionFunction(AreaMomentOfInertia.BaseUnit, AreaMomentOfInertiaUnit.DecimeterToTheFourth, (q) => ((AreaMomentOfInertia)q).ToUnit(AreaMomentOfInertiaUnit.DecimeterToTheFourth)); - unitConverter.SetConversionFunction(AreaMomentOfInertiaUnit.DecimeterToTheFourth, AreaMomentOfInertia.BaseUnit, (q) => ((AreaMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AreaMomentOfInertiaUnit.DecimeterToTheFourth, AreaMomentOfInertia.BaseUnit, (q) => ((AreaMomentOfInertia)q).ToBaseUnit()); unitConverter.SetConversionFunction(AreaMomentOfInertia.BaseUnit, AreaMomentOfInertiaUnit.FootToTheFourth, (q) => ((AreaMomentOfInertia)q).ToUnit(AreaMomentOfInertiaUnit.FootToTheFourth)); - unitConverter.SetConversionFunction(AreaMomentOfInertiaUnit.FootToTheFourth, AreaMomentOfInertia.BaseUnit, (q) => ((AreaMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AreaMomentOfInertiaUnit.FootToTheFourth, AreaMomentOfInertia.BaseUnit, (q) => ((AreaMomentOfInertia)q).ToBaseUnit()); unitConverter.SetConversionFunction(AreaMomentOfInertia.BaseUnit, AreaMomentOfInertiaUnit.InchToTheFourth, (q) => ((AreaMomentOfInertia)q).ToUnit(AreaMomentOfInertiaUnit.InchToTheFourth)); - unitConverter.SetConversionFunction(AreaMomentOfInertiaUnit.InchToTheFourth, AreaMomentOfInertia.BaseUnit, (q) => ((AreaMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AreaMomentOfInertiaUnit.InchToTheFourth, AreaMomentOfInertia.BaseUnit, (q) => ((AreaMomentOfInertia)q).ToBaseUnit()); unitConverter.SetConversionFunction(AreaMomentOfInertia.BaseUnit, AreaMomentOfInertia.BaseUnit, (q) => q); unitConverter.SetConversionFunction(AreaMomentOfInertia.BaseUnit, AreaMomentOfInertiaUnit.MillimeterToTheFourth, (q) => ((AreaMomentOfInertia)q).ToUnit(AreaMomentOfInertiaUnit.MillimeterToTheFourth)); - unitConverter.SetConversionFunction(AreaMomentOfInertiaUnit.MillimeterToTheFourth, AreaMomentOfInertia.BaseUnit, (q) => ((AreaMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(AreaMomentOfInertiaUnit.MillimeterToTheFourth, AreaMomentOfInertia.BaseUnit, (q) => ((AreaMomentOfInertia)q).ToBaseUnit()); unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRate.BaseUnit, (q) => q); unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.BytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.BytePerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.BytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRateUnit.BytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.ExabitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.ExabitPerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.ExabitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRateUnit.ExabitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.ExabytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.ExabytePerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.ExabytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRateUnit.ExabytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.ExbibitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.ExbibitPerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.ExbibitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRateUnit.ExbibitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.ExbibytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.ExbibytePerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.ExbibytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRateUnit.ExbibytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.GibibitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.GibibitPerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.GibibitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRateUnit.GibibitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.GibibytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.GibibytePerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.GibibytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRateUnit.GibibytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.GigabitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.GigabitPerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.GigabitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRateUnit.GigabitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.GigabytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.GigabytePerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.GigabytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRateUnit.GigabytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.KibibitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.KibibitPerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.KibibitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRateUnit.KibibitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.KibibytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.KibibytePerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.KibibytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRateUnit.KibibytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.KilobitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.KilobitPerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.KilobitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRateUnit.KilobitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.KilobytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.KilobytePerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.KilobytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRateUnit.KilobytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.MebibitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.MebibitPerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.MebibitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRateUnit.MebibitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.MebibytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.MebibytePerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.MebibytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRateUnit.MebibytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.MegabitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.MegabitPerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.MegabitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRateUnit.MegabitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.MegabytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.MegabytePerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.MegabytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRateUnit.MegabytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.PebibitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.PebibitPerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.PebibitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRateUnit.PebibitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.PebibytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.PebibytePerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.PebibytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRateUnit.PebibytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.PetabitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.PetabitPerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.PetabitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRateUnit.PetabitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.PetabytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.PetabytePerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.PetabytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRateUnit.PetabytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.TebibitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.TebibitPerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.TebibitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRateUnit.TebibitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.TebibytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.TebibytePerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.TebibytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRateUnit.TebibytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.TerabitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.TerabitPerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.TerabitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRateUnit.TerabitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.TerabytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.TerabytePerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.TerabytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BitRateUnit.TerabytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(BrakeSpecificFuelConsumption.BaseUnit, BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour, (q) => ((BrakeSpecificFuelConsumption)q).ToUnit(BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour)); - unitConverter.SetConversionFunction(BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour, BrakeSpecificFuelConsumption.BaseUnit, (q) => ((BrakeSpecificFuelConsumption)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour, BrakeSpecificFuelConsumption.BaseUnit, (q) => ((BrakeSpecificFuelConsumption)q).ToBaseUnit()); unitConverter.SetConversionFunction(BrakeSpecificFuelConsumption.BaseUnit, BrakeSpecificFuelConsumption.BaseUnit, (q) => q); unitConverter.SetConversionFunction(BrakeSpecificFuelConsumption.BaseUnit, BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour, (q) => ((BrakeSpecificFuelConsumption)q).ToUnit(BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour)); - unitConverter.SetConversionFunction(BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour, BrakeSpecificFuelConsumption.BaseUnit, (q) => ((BrakeSpecificFuelConsumption)q).AsBaseUnit()); + unitConverter.SetConversionFunction(BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour, BrakeSpecificFuelConsumption.BaseUnit, (q) => ((BrakeSpecificFuelConsumption)q).ToBaseUnit()); unitConverter.SetConversionFunction(Capacitance.BaseUnit, Capacitance.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Capacitance.BaseUnit, CapacitanceUnit.Kilofarad, (q) => ((Capacitance)q).ToUnit(CapacitanceUnit.Kilofarad)); - unitConverter.SetConversionFunction(CapacitanceUnit.Kilofarad, Capacitance.BaseUnit, (q) => ((Capacitance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(CapacitanceUnit.Kilofarad, Capacitance.BaseUnit, (q) => ((Capacitance)q).ToBaseUnit()); unitConverter.SetConversionFunction(Capacitance.BaseUnit, CapacitanceUnit.Megafarad, (q) => ((Capacitance)q).ToUnit(CapacitanceUnit.Megafarad)); - unitConverter.SetConversionFunction(CapacitanceUnit.Megafarad, Capacitance.BaseUnit, (q) => ((Capacitance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(CapacitanceUnit.Megafarad, Capacitance.BaseUnit, (q) => ((Capacitance)q).ToBaseUnit()); unitConverter.SetConversionFunction(Capacitance.BaseUnit, CapacitanceUnit.Microfarad, (q) => ((Capacitance)q).ToUnit(CapacitanceUnit.Microfarad)); - unitConverter.SetConversionFunction(CapacitanceUnit.Microfarad, Capacitance.BaseUnit, (q) => ((Capacitance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(CapacitanceUnit.Microfarad, Capacitance.BaseUnit, (q) => ((Capacitance)q).ToBaseUnit()); unitConverter.SetConversionFunction(Capacitance.BaseUnit, CapacitanceUnit.Millifarad, (q) => ((Capacitance)q).ToUnit(CapacitanceUnit.Millifarad)); - unitConverter.SetConversionFunction(CapacitanceUnit.Millifarad, Capacitance.BaseUnit, (q) => ((Capacitance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(CapacitanceUnit.Millifarad, Capacitance.BaseUnit, (q) => ((Capacitance)q).ToBaseUnit()); unitConverter.SetConversionFunction(Capacitance.BaseUnit, CapacitanceUnit.Nanofarad, (q) => ((Capacitance)q).ToUnit(CapacitanceUnit.Nanofarad)); - unitConverter.SetConversionFunction(CapacitanceUnit.Nanofarad, Capacitance.BaseUnit, (q) => ((Capacitance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(CapacitanceUnit.Nanofarad, Capacitance.BaseUnit, (q) => ((Capacitance)q).ToBaseUnit()); unitConverter.SetConversionFunction(Capacitance.BaseUnit, CapacitanceUnit.Picofarad, (q) => ((Capacitance)q).ToUnit(CapacitanceUnit.Picofarad)); - unitConverter.SetConversionFunction(CapacitanceUnit.Picofarad, Capacitance.BaseUnit, (q) => ((Capacitance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(CapacitanceUnit.Picofarad, Capacitance.BaseUnit, (q) => ((Capacitance)q).ToBaseUnit()); unitConverter.SetConversionFunction(CoefficientOfThermalExpansion.BaseUnit, CoefficientOfThermalExpansionUnit.InverseDegreeCelsius, (q) => ((CoefficientOfThermalExpansion)q).ToUnit(CoefficientOfThermalExpansionUnit.InverseDegreeCelsius)); - unitConverter.SetConversionFunction(CoefficientOfThermalExpansionUnit.InverseDegreeCelsius, CoefficientOfThermalExpansion.BaseUnit, (q) => ((CoefficientOfThermalExpansion)q).AsBaseUnit()); + unitConverter.SetConversionFunction(CoefficientOfThermalExpansionUnit.InverseDegreeCelsius, CoefficientOfThermalExpansion.BaseUnit, (q) => ((CoefficientOfThermalExpansion)q).ToBaseUnit()); unitConverter.SetConversionFunction(CoefficientOfThermalExpansion.BaseUnit, CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit, (q) => ((CoefficientOfThermalExpansion)q).ToUnit(CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit)); - unitConverter.SetConversionFunction(CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit, CoefficientOfThermalExpansion.BaseUnit, (q) => ((CoefficientOfThermalExpansion)q).AsBaseUnit()); + unitConverter.SetConversionFunction(CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit, CoefficientOfThermalExpansion.BaseUnit, (q) => ((CoefficientOfThermalExpansion)q).ToBaseUnit()); unitConverter.SetConversionFunction(CoefficientOfThermalExpansion.BaseUnit, CoefficientOfThermalExpansion.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.CentigramPerDeciliter, (q) => ((Density)q).ToUnit(DensityUnit.CentigramPerDeciliter)); - unitConverter.SetConversionFunction(DensityUnit.CentigramPerDeciliter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.CentigramPerDeciliter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.CentigramPerLiter, (q) => ((Density)q).ToUnit(DensityUnit.CentigramPerLiter)); - unitConverter.SetConversionFunction(DensityUnit.CentigramPerLiter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.CentigramPerLiter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.CentigramPerMilliliter, (q) => ((Density)q).ToUnit(DensityUnit.CentigramPerMilliliter)); - unitConverter.SetConversionFunction(DensityUnit.CentigramPerMilliliter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.CentigramPerMilliliter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.DecigramPerDeciliter, (q) => ((Density)q).ToUnit(DensityUnit.DecigramPerDeciliter)); - unitConverter.SetConversionFunction(DensityUnit.DecigramPerDeciliter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.DecigramPerDeciliter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.DecigramPerLiter, (q) => ((Density)q).ToUnit(DensityUnit.DecigramPerLiter)); - unitConverter.SetConversionFunction(DensityUnit.DecigramPerLiter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.DecigramPerLiter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.DecigramPerMilliliter, (q) => ((Density)q).ToUnit(DensityUnit.DecigramPerMilliliter)); - unitConverter.SetConversionFunction(DensityUnit.DecigramPerMilliliter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.DecigramPerMilliliter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.GramPerCubicCentimeter, (q) => ((Density)q).ToUnit(DensityUnit.GramPerCubicCentimeter)); - unitConverter.SetConversionFunction(DensityUnit.GramPerCubicCentimeter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.GramPerCubicCentimeter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.GramPerCubicMeter, (q) => ((Density)q).ToUnit(DensityUnit.GramPerCubicMeter)); - unitConverter.SetConversionFunction(DensityUnit.GramPerCubicMeter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.GramPerCubicMeter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.GramPerCubicMillimeter, (q) => ((Density)q).ToUnit(DensityUnit.GramPerCubicMillimeter)); - unitConverter.SetConversionFunction(DensityUnit.GramPerCubicMillimeter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.GramPerCubicMillimeter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.GramPerDeciliter, (q) => ((Density)q).ToUnit(DensityUnit.GramPerDeciliter)); - unitConverter.SetConversionFunction(DensityUnit.GramPerDeciliter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.GramPerDeciliter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.GramPerLiter, (q) => ((Density)q).ToUnit(DensityUnit.GramPerLiter)); - unitConverter.SetConversionFunction(DensityUnit.GramPerLiter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.GramPerLiter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.GramPerMilliliter, (q) => ((Density)q).ToUnit(DensityUnit.GramPerMilliliter)); - unitConverter.SetConversionFunction(DensityUnit.GramPerMilliliter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.GramPerMilliliter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.KilogramPerCubicCentimeter, (q) => ((Density)q).ToUnit(DensityUnit.KilogramPerCubicCentimeter)); - unitConverter.SetConversionFunction(DensityUnit.KilogramPerCubicCentimeter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.KilogramPerCubicCentimeter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, Density.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.KilogramPerCubicMillimeter, (q) => ((Density)q).ToUnit(DensityUnit.KilogramPerCubicMillimeter)); - unitConverter.SetConversionFunction(DensityUnit.KilogramPerCubicMillimeter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.KilogramPerCubicMillimeter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.KilopoundPerCubicFoot, (q) => ((Density)q).ToUnit(DensityUnit.KilopoundPerCubicFoot)); - unitConverter.SetConversionFunction(DensityUnit.KilopoundPerCubicFoot, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.KilopoundPerCubicFoot, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.KilopoundPerCubicInch, (q) => ((Density)q).ToUnit(DensityUnit.KilopoundPerCubicInch)); - unitConverter.SetConversionFunction(DensityUnit.KilopoundPerCubicInch, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.KilopoundPerCubicInch, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.MicrogramPerCubicMeter, (q) => ((Density)q).ToUnit(DensityUnit.MicrogramPerCubicMeter)); - unitConverter.SetConversionFunction(DensityUnit.MicrogramPerCubicMeter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.MicrogramPerCubicMeter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.MicrogramPerDeciliter, (q) => ((Density)q).ToUnit(DensityUnit.MicrogramPerDeciliter)); - unitConverter.SetConversionFunction(DensityUnit.MicrogramPerDeciliter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.MicrogramPerDeciliter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.MicrogramPerLiter, (q) => ((Density)q).ToUnit(DensityUnit.MicrogramPerLiter)); - unitConverter.SetConversionFunction(DensityUnit.MicrogramPerLiter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.MicrogramPerLiter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.MicrogramPerMilliliter, (q) => ((Density)q).ToUnit(DensityUnit.MicrogramPerMilliliter)); - unitConverter.SetConversionFunction(DensityUnit.MicrogramPerMilliliter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.MicrogramPerMilliliter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.MilligramPerCubicMeter, (q) => ((Density)q).ToUnit(DensityUnit.MilligramPerCubicMeter)); - unitConverter.SetConversionFunction(DensityUnit.MilligramPerCubicMeter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.MilligramPerCubicMeter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.MilligramPerDeciliter, (q) => ((Density)q).ToUnit(DensityUnit.MilligramPerDeciliter)); - unitConverter.SetConversionFunction(DensityUnit.MilligramPerDeciliter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.MilligramPerDeciliter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.MilligramPerLiter, (q) => ((Density)q).ToUnit(DensityUnit.MilligramPerLiter)); - unitConverter.SetConversionFunction(DensityUnit.MilligramPerLiter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.MilligramPerLiter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.MilligramPerMilliliter, (q) => ((Density)q).ToUnit(DensityUnit.MilligramPerMilliliter)); - unitConverter.SetConversionFunction(DensityUnit.MilligramPerMilliliter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.MilligramPerMilliliter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.NanogramPerDeciliter, (q) => ((Density)q).ToUnit(DensityUnit.NanogramPerDeciliter)); - unitConverter.SetConversionFunction(DensityUnit.NanogramPerDeciliter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.NanogramPerDeciliter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.NanogramPerLiter, (q) => ((Density)q).ToUnit(DensityUnit.NanogramPerLiter)); - unitConverter.SetConversionFunction(DensityUnit.NanogramPerLiter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.NanogramPerLiter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.NanogramPerMilliliter, (q) => ((Density)q).ToUnit(DensityUnit.NanogramPerMilliliter)); - unitConverter.SetConversionFunction(DensityUnit.NanogramPerMilliliter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.NanogramPerMilliliter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PicogramPerDeciliter, (q) => ((Density)q).ToUnit(DensityUnit.PicogramPerDeciliter)); - unitConverter.SetConversionFunction(DensityUnit.PicogramPerDeciliter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.PicogramPerDeciliter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PicogramPerLiter, (q) => ((Density)q).ToUnit(DensityUnit.PicogramPerLiter)); - unitConverter.SetConversionFunction(DensityUnit.PicogramPerLiter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.PicogramPerLiter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PicogramPerMilliliter, (q) => ((Density)q).ToUnit(DensityUnit.PicogramPerMilliliter)); - unitConverter.SetConversionFunction(DensityUnit.PicogramPerMilliliter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.PicogramPerMilliliter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PoundPerCubicFoot, (q) => ((Density)q).ToUnit(DensityUnit.PoundPerCubicFoot)); - unitConverter.SetConversionFunction(DensityUnit.PoundPerCubicFoot, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.PoundPerCubicFoot, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PoundPerCubicInch, (q) => ((Density)q).ToUnit(DensityUnit.PoundPerCubicInch)); - unitConverter.SetConversionFunction(DensityUnit.PoundPerCubicInch, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.PoundPerCubicInch, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PoundPerImperialGallon, (q) => ((Density)q).ToUnit(DensityUnit.PoundPerImperialGallon)); - unitConverter.SetConversionFunction(DensityUnit.PoundPerImperialGallon, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.PoundPerImperialGallon, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PoundPerUSGallon, (q) => ((Density)q).ToUnit(DensityUnit.PoundPerUSGallon)); - unitConverter.SetConversionFunction(DensityUnit.PoundPerUSGallon, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.PoundPerUSGallon, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.SlugPerCubicFoot, (q) => ((Density)q).ToUnit(DensityUnit.SlugPerCubicFoot)); - unitConverter.SetConversionFunction(DensityUnit.SlugPerCubicFoot, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.SlugPerCubicFoot, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.TonnePerCubicCentimeter, (q) => ((Density)q).ToUnit(DensityUnit.TonnePerCubicCentimeter)); - unitConverter.SetConversionFunction(DensityUnit.TonnePerCubicCentimeter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.TonnePerCubicCentimeter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.TonnePerCubicMeter, (q) => ((Density)q).ToUnit(DensityUnit.TonnePerCubicMeter)); - unitConverter.SetConversionFunction(DensityUnit.TonnePerCubicMeter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.TonnePerCubicMeter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.TonnePerCubicMillimeter, (q) => ((Density)q).ToUnit(DensityUnit.TonnePerCubicMillimeter)); - unitConverter.SetConversionFunction(DensityUnit.TonnePerCubicMillimeter, Density.BaseUnit, (q) => ((Density)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DensityUnit.TonnePerCubicMillimeter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Day, (q) => ((Duration)q).ToUnit(DurationUnit.Day)); - unitConverter.SetConversionFunction(DurationUnit.Day, Duration.BaseUnit, (q) => ((Duration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DurationUnit.Day, Duration.BaseUnit, (q) => ((Duration)q).ToBaseUnit()); unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Hour, (q) => ((Duration)q).ToUnit(DurationUnit.Hour)); - unitConverter.SetConversionFunction(DurationUnit.Hour, Duration.BaseUnit, (q) => ((Duration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DurationUnit.Hour, Duration.BaseUnit, (q) => ((Duration)q).ToBaseUnit()); unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Microsecond, (q) => ((Duration)q).ToUnit(DurationUnit.Microsecond)); - unitConverter.SetConversionFunction(DurationUnit.Microsecond, Duration.BaseUnit, (q) => ((Duration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DurationUnit.Microsecond, Duration.BaseUnit, (q) => ((Duration)q).ToBaseUnit()); unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Millisecond, (q) => ((Duration)q).ToUnit(DurationUnit.Millisecond)); - unitConverter.SetConversionFunction(DurationUnit.Millisecond, Duration.BaseUnit, (q) => ((Duration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DurationUnit.Millisecond, Duration.BaseUnit, (q) => ((Duration)q).ToBaseUnit()); unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Minute, (q) => ((Duration)q).ToUnit(DurationUnit.Minute)); - unitConverter.SetConversionFunction(DurationUnit.Minute, Duration.BaseUnit, (q) => ((Duration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DurationUnit.Minute, Duration.BaseUnit, (q) => ((Duration)q).ToBaseUnit()); unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Month30, (q) => ((Duration)q).ToUnit(DurationUnit.Month30)); - unitConverter.SetConversionFunction(DurationUnit.Month30, Duration.BaseUnit, (q) => ((Duration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DurationUnit.Month30, Duration.BaseUnit, (q) => ((Duration)q).ToBaseUnit()); unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Nanosecond, (q) => ((Duration)q).ToUnit(DurationUnit.Nanosecond)); - unitConverter.SetConversionFunction(DurationUnit.Nanosecond, Duration.BaseUnit, (q) => ((Duration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DurationUnit.Nanosecond, Duration.BaseUnit, (q) => ((Duration)q).ToBaseUnit()); unitConverter.SetConversionFunction(Duration.BaseUnit, Duration.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Week, (q) => ((Duration)q).ToUnit(DurationUnit.Week)); - unitConverter.SetConversionFunction(DurationUnit.Week, Duration.BaseUnit, (q) => ((Duration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DurationUnit.Week, Duration.BaseUnit, (q) => ((Duration)q).ToBaseUnit()); unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Year365, (q) => ((Duration)q).ToUnit(DurationUnit.Year365)); - unitConverter.SetConversionFunction(DurationUnit.Year365, Duration.BaseUnit, (q) => ((Duration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DurationUnit.Year365, Duration.BaseUnit, (q) => ((Duration)q).ToBaseUnit()); unitConverter.SetConversionFunction(DynamicViscosity.BaseUnit, DynamicViscosityUnit.Centipoise, (q) => ((DynamicViscosity)q).ToUnit(DynamicViscosityUnit.Centipoise)); - unitConverter.SetConversionFunction(DynamicViscosityUnit.Centipoise, DynamicViscosity.BaseUnit, (q) => ((DynamicViscosity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DynamicViscosityUnit.Centipoise, DynamicViscosity.BaseUnit, (q) => ((DynamicViscosity)q).ToBaseUnit()); unitConverter.SetConversionFunction(DynamicViscosity.BaseUnit, DynamicViscosityUnit.MicropascalSecond, (q) => ((DynamicViscosity)q).ToUnit(DynamicViscosityUnit.MicropascalSecond)); - unitConverter.SetConversionFunction(DynamicViscosityUnit.MicropascalSecond, DynamicViscosity.BaseUnit, (q) => ((DynamicViscosity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DynamicViscosityUnit.MicropascalSecond, DynamicViscosity.BaseUnit, (q) => ((DynamicViscosity)q).ToBaseUnit()); unitConverter.SetConversionFunction(DynamicViscosity.BaseUnit, DynamicViscosityUnit.MillipascalSecond, (q) => ((DynamicViscosity)q).ToUnit(DynamicViscosityUnit.MillipascalSecond)); - unitConverter.SetConversionFunction(DynamicViscosityUnit.MillipascalSecond, DynamicViscosity.BaseUnit, (q) => ((DynamicViscosity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DynamicViscosityUnit.MillipascalSecond, DynamicViscosity.BaseUnit, (q) => ((DynamicViscosity)q).ToBaseUnit()); unitConverter.SetConversionFunction(DynamicViscosity.BaseUnit, DynamicViscosity.BaseUnit, (q) => q); unitConverter.SetConversionFunction(DynamicViscosity.BaseUnit, DynamicViscosityUnit.PascalSecond, (q) => ((DynamicViscosity)q).ToUnit(DynamicViscosityUnit.PascalSecond)); - unitConverter.SetConversionFunction(DynamicViscosityUnit.PascalSecond, DynamicViscosity.BaseUnit, (q) => ((DynamicViscosity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DynamicViscosityUnit.PascalSecond, DynamicViscosity.BaseUnit, (q) => ((DynamicViscosity)q).ToBaseUnit()); unitConverter.SetConversionFunction(DynamicViscosity.BaseUnit, DynamicViscosityUnit.Poise, (q) => ((DynamicViscosity)q).ToUnit(DynamicViscosityUnit.Poise)); - unitConverter.SetConversionFunction(DynamicViscosityUnit.Poise, DynamicViscosity.BaseUnit, (q) => ((DynamicViscosity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(DynamicViscosityUnit.Poise, DynamicViscosity.BaseUnit, (q) => ((DynamicViscosity)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricAdmittance.BaseUnit, ElectricAdmittanceUnit.Microsiemens, (q) => ((ElectricAdmittance)q).ToUnit(ElectricAdmittanceUnit.Microsiemens)); - unitConverter.SetConversionFunction(ElectricAdmittanceUnit.Microsiemens, ElectricAdmittance.BaseUnit, (q) => ((ElectricAdmittance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricAdmittanceUnit.Microsiemens, ElectricAdmittance.BaseUnit, (q) => ((ElectricAdmittance)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricAdmittance.BaseUnit, ElectricAdmittanceUnit.Millisiemens, (q) => ((ElectricAdmittance)q).ToUnit(ElectricAdmittanceUnit.Millisiemens)); - unitConverter.SetConversionFunction(ElectricAdmittanceUnit.Millisiemens, ElectricAdmittance.BaseUnit, (q) => ((ElectricAdmittance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricAdmittanceUnit.Millisiemens, ElectricAdmittance.BaseUnit, (q) => ((ElectricAdmittance)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricAdmittance.BaseUnit, ElectricAdmittanceUnit.Nanosiemens, (q) => ((ElectricAdmittance)q).ToUnit(ElectricAdmittanceUnit.Nanosiemens)); - unitConverter.SetConversionFunction(ElectricAdmittanceUnit.Nanosiemens, ElectricAdmittance.BaseUnit, (q) => ((ElectricAdmittance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricAdmittanceUnit.Nanosiemens, ElectricAdmittance.BaseUnit, (q) => ((ElectricAdmittance)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricAdmittance.BaseUnit, ElectricAdmittance.BaseUnit, (q) => q); unitConverter.SetConversionFunction(ElectricCharge.BaseUnit, ElectricCharge.BaseUnit, (q) => q); unitConverter.SetConversionFunction(ElectricChargeDensity.BaseUnit, ElectricChargeDensity.BaseUnit, (q) => q); unitConverter.SetConversionFunction(ElectricConductance.BaseUnit, ElectricConductanceUnit.Microsiemens, (q) => ((ElectricConductance)q).ToUnit(ElectricConductanceUnit.Microsiemens)); - unitConverter.SetConversionFunction(ElectricConductanceUnit.Microsiemens, ElectricConductance.BaseUnit, (q) => ((ElectricConductance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricConductanceUnit.Microsiemens, ElectricConductance.BaseUnit, (q) => ((ElectricConductance)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricConductance.BaseUnit, ElectricConductanceUnit.Millisiemens, (q) => ((ElectricConductance)q).ToUnit(ElectricConductanceUnit.Millisiemens)); - unitConverter.SetConversionFunction(ElectricConductanceUnit.Millisiemens, ElectricConductance.BaseUnit, (q) => ((ElectricConductance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricConductanceUnit.Millisiemens, ElectricConductance.BaseUnit, (q) => ((ElectricConductance)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricConductance.BaseUnit, ElectricConductance.BaseUnit, (q) => q); unitConverter.SetConversionFunction(ElectricConductivity.BaseUnit, ElectricConductivity.BaseUnit, (q) => q); unitConverter.SetConversionFunction(ElectricCurrent.BaseUnit, ElectricCurrent.BaseUnit, (q) => q); unitConverter.SetConversionFunction(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Centiampere, (q) => ((ElectricCurrent)q).ToUnit(ElectricCurrentUnit.Centiampere)); - unitConverter.SetConversionFunction(ElectricCurrentUnit.Centiampere, ElectricCurrent.BaseUnit, (q) => ((ElectricCurrent)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricCurrentUnit.Centiampere, ElectricCurrent.BaseUnit, (q) => ((ElectricCurrent)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Kiloampere, (q) => ((ElectricCurrent)q).ToUnit(ElectricCurrentUnit.Kiloampere)); - unitConverter.SetConversionFunction(ElectricCurrentUnit.Kiloampere, ElectricCurrent.BaseUnit, (q) => ((ElectricCurrent)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricCurrentUnit.Kiloampere, ElectricCurrent.BaseUnit, (q) => ((ElectricCurrent)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Megaampere, (q) => ((ElectricCurrent)q).ToUnit(ElectricCurrentUnit.Megaampere)); - unitConverter.SetConversionFunction(ElectricCurrentUnit.Megaampere, ElectricCurrent.BaseUnit, (q) => ((ElectricCurrent)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricCurrentUnit.Megaampere, ElectricCurrent.BaseUnit, (q) => ((ElectricCurrent)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Microampere, (q) => ((ElectricCurrent)q).ToUnit(ElectricCurrentUnit.Microampere)); - unitConverter.SetConversionFunction(ElectricCurrentUnit.Microampere, ElectricCurrent.BaseUnit, (q) => ((ElectricCurrent)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricCurrentUnit.Microampere, ElectricCurrent.BaseUnit, (q) => ((ElectricCurrent)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Milliampere, (q) => ((ElectricCurrent)q).ToUnit(ElectricCurrentUnit.Milliampere)); - unitConverter.SetConversionFunction(ElectricCurrentUnit.Milliampere, ElectricCurrent.BaseUnit, (q) => ((ElectricCurrent)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricCurrentUnit.Milliampere, ElectricCurrent.BaseUnit, (q) => ((ElectricCurrent)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Nanoampere, (q) => ((ElectricCurrent)q).ToUnit(ElectricCurrentUnit.Nanoampere)); - unitConverter.SetConversionFunction(ElectricCurrentUnit.Nanoampere, ElectricCurrent.BaseUnit, (q) => ((ElectricCurrent)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricCurrentUnit.Nanoampere, ElectricCurrent.BaseUnit, (q) => ((ElectricCurrent)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Picoampere, (q) => ((ElectricCurrent)q).ToUnit(ElectricCurrentUnit.Picoampere)); - unitConverter.SetConversionFunction(ElectricCurrentUnit.Picoampere, ElectricCurrent.BaseUnit, (q) => ((ElectricCurrent)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricCurrentUnit.Picoampere, ElectricCurrent.BaseUnit, (q) => ((ElectricCurrent)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricCurrentDensity.BaseUnit, ElectricCurrentDensity.BaseUnit, (q) => q); unitConverter.SetConversionFunction(ElectricCurrentGradient.BaseUnit, ElectricCurrentGradient.BaseUnit, (q) => q); unitConverter.SetConversionFunction(ElectricField.BaseUnit, ElectricField.BaseUnit, (q) => q); unitConverter.SetConversionFunction(ElectricInductance.BaseUnit, ElectricInductance.BaseUnit, (q) => q); unitConverter.SetConversionFunction(ElectricInductance.BaseUnit, ElectricInductanceUnit.Microhenry, (q) => ((ElectricInductance)q).ToUnit(ElectricInductanceUnit.Microhenry)); - unitConverter.SetConversionFunction(ElectricInductanceUnit.Microhenry, ElectricInductance.BaseUnit, (q) => ((ElectricInductance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricInductanceUnit.Microhenry, ElectricInductance.BaseUnit, (q) => ((ElectricInductance)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricInductance.BaseUnit, ElectricInductanceUnit.Millihenry, (q) => ((ElectricInductance)q).ToUnit(ElectricInductanceUnit.Millihenry)); - unitConverter.SetConversionFunction(ElectricInductanceUnit.Millihenry, ElectricInductance.BaseUnit, (q) => ((ElectricInductance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricInductanceUnit.Millihenry, ElectricInductance.BaseUnit, (q) => ((ElectricInductance)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricInductance.BaseUnit, ElectricInductanceUnit.Nanohenry, (q) => ((ElectricInductance)q).ToUnit(ElectricInductanceUnit.Nanohenry)); - unitConverter.SetConversionFunction(ElectricInductanceUnit.Nanohenry, ElectricInductance.BaseUnit, (q) => ((ElectricInductance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricInductanceUnit.Nanohenry, ElectricInductance.BaseUnit, (q) => ((ElectricInductance)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricPotential.BaseUnit, ElectricPotentialUnit.Kilovolt, (q) => ((ElectricPotential)q).ToUnit(ElectricPotentialUnit.Kilovolt)); - unitConverter.SetConversionFunction(ElectricPotentialUnit.Kilovolt, ElectricPotential.BaseUnit, (q) => ((ElectricPotential)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotentialUnit.Kilovolt, ElectricPotential.BaseUnit, (q) => ((ElectricPotential)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricPotential.BaseUnit, ElectricPotentialUnit.Megavolt, (q) => ((ElectricPotential)q).ToUnit(ElectricPotentialUnit.Megavolt)); - unitConverter.SetConversionFunction(ElectricPotentialUnit.Megavolt, ElectricPotential.BaseUnit, (q) => ((ElectricPotential)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotentialUnit.Megavolt, ElectricPotential.BaseUnit, (q) => ((ElectricPotential)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricPotential.BaseUnit, ElectricPotentialUnit.Microvolt, (q) => ((ElectricPotential)q).ToUnit(ElectricPotentialUnit.Microvolt)); - unitConverter.SetConversionFunction(ElectricPotentialUnit.Microvolt, ElectricPotential.BaseUnit, (q) => ((ElectricPotential)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotentialUnit.Microvolt, ElectricPotential.BaseUnit, (q) => ((ElectricPotential)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricPotential.BaseUnit, ElectricPotentialUnit.Millivolt, (q) => ((ElectricPotential)q).ToUnit(ElectricPotentialUnit.Millivolt)); - unitConverter.SetConversionFunction(ElectricPotentialUnit.Millivolt, ElectricPotential.BaseUnit, (q) => ((ElectricPotential)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotentialUnit.Millivolt, ElectricPotential.BaseUnit, (q) => ((ElectricPotential)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricPotential.BaseUnit, ElectricPotential.BaseUnit, (q) => q); unitConverter.SetConversionFunction(ElectricPotentialAc.BaseUnit, ElectricPotentialAcUnit.KilovoltAc, (q) => ((ElectricPotentialAc)q).ToUnit(ElectricPotentialAcUnit.KilovoltAc)); - unitConverter.SetConversionFunction(ElectricPotentialAcUnit.KilovoltAc, ElectricPotentialAc.BaseUnit, (q) => ((ElectricPotentialAc)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotentialAcUnit.KilovoltAc, ElectricPotentialAc.BaseUnit, (q) => ((ElectricPotentialAc)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricPotentialAc.BaseUnit, ElectricPotentialAcUnit.MegavoltAc, (q) => ((ElectricPotentialAc)q).ToUnit(ElectricPotentialAcUnit.MegavoltAc)); - unitConverter.SetConversionFunction(ElectricPotentialAcUnit.MegavoltAc, ElectricPotentialAc.BaseUnit, (q) => ((ElectricPotentialAc)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotentialAcUnit.MegavoltAc, ElectricPotentialAc.BaseUnit, (q) => ((ElectricPotentialAc)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricPotentialAc.BaseUnit, ElectricPotentialAcUnit.MicrovoltAc, (q) => ((ElectricPotentialAc)q).ToUnit(ElectricPotentialAcUnit.MicrovoltAc)); - unitConverter.SetConversionFunction(ElectricPotentialAcUnit.MicrovoltAc, ElectricPotentialAc.BaseUnit, (q) => ((ElectricPotentialAc)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotentialAcUnit.MicrovoltAc, ElectricPotentialAc.BaseUnit, (q) => ((ElectricPotentialAc)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricPotentialAc.BaseUnit, ElectricPotentialAcUnit.MillivoltAc, (q) => ((ElectricPotentialAc)q).ToUnit(ElectricPotentialAcUnit.MillivoltAc)); - unitConverter.SetConversionFunction(ElectricPotentialAcUnit.MillivoltAc, ElectricPotentialAc.BaseUnit, (q) => ((ElectricPotentialAc)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotentialAcUnit.MillivoltAc, ElectricPotentialAc.BaseUnit, (q) => ((ElectricPotentialAc)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricPotentialAc.BaseUnit, ElectricPotentialAc.BaseUnit, (q) => q); unitConverter.SetConversionFunction(ElectricPotentialDc.BaseUnit, ElectricPotentialDcUnit.KilovoltDc, (q) => ((ElectricPotentialDc)q).ToUnit(ElectricPotentialDcUnit.KilovoltDc)); - unitConverter.SetConversionFunction(ElectricPotentialDcUnit.KilovoltDc, ElectricPotentialDc.BaseUnit, (q) => ((ElectricPotentialDc)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotentialDcUnit.KilovoltDc, ElectricPotentialDc.BaseUnit, (q) => ((ElectricPotentialDc)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricPotentialDc.BaseUnit, ElectricPotentialDcUnit.MegavoltDc, (q) => ((ElectricPotentialDc)q).ToUnit(ElectricPotentialDcUnit.MegavoltDc)); - unitConverter.SetConversionFunction(ElectricPotentialDcUnit.MegavoltDc, ElectricPotentialDc.BaseUnit, (q) => ((ElectricPotentialDc)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotentialDcUnit.MegavoltDc, ElectricPotentialDc.BaseUnit, (q) => ((ElectricPotentialDc)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricPotentialDc.BaseUnit, ElectricPotentialDcUnit.MicrovoltDc, (q) => ((ElectricPotentialDc)q).ToUnit(ElectricPotentialDcUnit.MicrovoltDc)); - unitConverter.SetConversionFunction(ElectricPotentialDcUnit.MicrovoltDc, ElectricPotentialDc.BaseUnit, (q) => ((ElectricPotentialDc)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotentialDcUnit.MicrovoltDc, ElectricPotentialDc.BaseUnit, (q) => ((ElectricPotentialDc)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricPotentialDc.BaseUnit, ElectricPotentialDcUnit.MillivoltDc, (q) => ((ElectricPotentialDc)q).ToUnit(ElectricPotentialDcUnit.MillivoltDc)); - unitConverter.SetConversionFunction(ElectricPotentialDcUnit.MillivoltDc, ElectricPotentialDc.BaseUnit, (q) => ((ElectricPotentialDc)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotentialDcUnit.MillivoltDc, ElectricPotentialDc.BaseUnit, (q) => ((ElectricPotentialDc)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricPotentialDc.BaseUnit, ElectricPotentialDc.BaseUnit, (q) => q); unitConverter.SetConversionFunction(ElectricResistance.BaseUnit, ElectricResistanceUnit.Gigaohm, (q) => ((ElectricResistance)q).ToUnit(ElectricResistanceUnit.Gigaohm)); - unitConverter.SetConversionFunction(ElectricResistanceUnit.Gigaohm, ElectricResistance.BaseUnit, (q) => ((ElectricResistance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistanceUnit.Gigaohm, ElectricResistance.BaseUnit, (q) => ((ElectricResistance)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricResistance.BaseUnit, ElectricResistanceUnit.Kiloohm, (q) => ((ElectricResistance)q).ToUnit(ElectricResistanceUnit.Kiloohm)); - unitConverter.SetConversionFunction(ElectricResistanceUnit.Kiloohm, ElectricResistance.BaseUnit, (q) => ((ElectricResistance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistanceUnit.Kiloohm, ElectricResistance.BaseUnit, (q) => ((ElectricResistance)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricResistance.BaseUnit, ElectricResistanceUnit.Megaohm, (q) => ((ElectricResistance)q).ToUnit(ElectricResistanceUnit.Megaohm)); - unitConverter.SetConversionFunction(ElectricResistanceUnit.Megaohm, ElectricResistance.BaseUnit, (q) => ((ElectricResistance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistanceUnit.Megaohm, ElectricResistance.BaseUnit, (q) => ((ElectricResistance)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricResistance.BaseUnit, ElectricResistanceUnit.Milliohm, (q) => ((ElectricResistance)q).ToUnit(ElectricResistanceUnit.Milliohm)); - unitConverter.SetConversionFunction(ElectricResistanceUnit.Milliohm, ElectricResistance.BaseUnit, (q) => ((ElectricResistance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistanceUnit.Milliohm, ElectricResistance.BaseUnit, (q) => ((ElectricResistance)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricResistance.BaseUnit, ElectricResistance.BaseUnit, (q) => q); unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.KiloohmCentimeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.KiloohmCentimeter)); - unitConverter.SetConversionFunction(ElectricResistivityUnit.KiloohmCentimeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivityUnit.KiloohmCentimeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.KiloohmMeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.KiloohmMeter)); - unitConverter.SetConversionFunction(ElectricResistivityUnit.KiloohmMeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivityUnit.KiloohmMeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.MegaohmCentimeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.MegaohmCentimeter)); - unitConverter.SetConversionFunction(ElectricResistivityUnit.MegaohmCentimeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivityUnit.MegaohmCentimeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.MegaohmMeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.MegaohmMeter)); - unitConverter.SetConversionFunction(ElectricResistivityUnit.MegaohmMeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivityUnit.MegaohmMeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.MicroohmCentimeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.MicroohmCentimeter)); - unitConverter.SetConversionFunction(ElectricResistivityUnit.MicroohmCentimeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivityUnit.MicroohmCentimeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.MicroohmMeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.MicroohmMeter)); - unitConverter.SetConversionFunction(ElectricResistivityUnit.MicroohmMeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivityUnit.MicroohmMeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.MilliohmCentimeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.MilliohmCentimeter)); - unitConverter.SetConversionFunction(ElectricResistivityUnit.MilliohmCentimeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivityUnit.MilliohmCentimeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.MilliohmMeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.MilliohmMeter)); - unitConverter.SetConversionFunction(ElectricResistivityUnit.MilliohmMeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivityUnit.MilliohmMeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.NanoohmCentimeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.NanoohmCentimeter)); - unitConverter.SetConversionFunction(ElectricResistivityUnit.NanoohmCentimeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivityUnit.NanoohmCentimeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.NanoohmMeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.NanoohmMeter)); - unitConverter.SetConversionFunction(ElectricResistivityUnit.NanoohmMeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivityUnit.NanoohmMeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.OhmCentimeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.OhmCentimeter)); - unitConverter.SetConversionFunction(ElectricResistivityUnit.OhmCentimeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivityUnit.OhmCentimeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivity.BaseUnit, (q) => q); unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.PicoohmCentimeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.PicoohmCentimeter)); - unitConverter.SetConversionFunction(ElectricResistivityUnit.PicoohmCentimeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivityUnit.PicoohmCentimeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).ToBaseUnit()); unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.PicoohmMeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.PicoohmMeter)); - unitConverter.SetConversionFunction(ElectricResistivityUnit.PicoohmMeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivityUnit.PicoohmMeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.BritishThermalUnit, (q) => ((Energy)q).ToUnit(EnergyUnit.BritishThermalUnit)); - unitConverter.SetConversionFunction(EnergyUnit.BritishThermalUnit, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(EnergyUnit.BritishThermalUnit, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.Calorie, (q) => ((Energy)q).ToUnit(EnergyUnit.Calorie)); - unitConverter.SetConversionFunction(EnergyUnit.Calorie, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(EnergyUnit.Calorie, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.DecathermEc, (q) => ((Energy)q).ToUnit(EnergyUnit.DecathermEc)); - unitConverter.SetConversionFunction(EnergyUnit.DecathermEc, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(EnergyUnit.DecathermEc, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.DecathermImperial, (q) => ((Energy)q).ToUnit(EnergyUnit.DecathermImperial)); - unitConverter.SetConversionFunction(EnergyUnit.DecathermImperial, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(EnergyUnit.DecathermImperial, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.DecathermUs, (q) => ((Energy)q).ToUnit(EnergyUnit.DecathermUs)); - unitConverter.SetConversionFunction(EnergyUnit.DecathermUs, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(EnergyUnit.DecathermUs, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.ElectronVolt, (q) => ((Energy)q).ToUnit(EnergyUnit.ElectronVolt)); - unitConverter.SetConversionFunction(EnergyUnit.ElectronVolt, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(EnergyUnit.ElectronVolt, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.Erg, (q) => ((Energy)q).ToUnit(EnergyUnit.Erg)); - unitConverter.SetConversionFunction(EnergyUnit.Erg, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(EnergyUnit.Erg, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.FootPound, (q) => ((Energy)q).ToUnit(EnergyUnit.FootPound)); - unitConverter.SetConversionFunction(EnergyUnit.FootPound, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(EnergyUnit.FootPound, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.GigabritishThermalUnit, (q) => ((Energy)q).ToUnit(EnergyUnit.GigabritishThermalUnit)); - unitConverter.SetConversionFunction(EnergyUnit.GigabritishThermalUnit, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(EnergyUnit.GigabritishThermalUnit, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.GigawattHour, (q) => ((Energy)q).ToUnit(EnergyUnit.GigawattHour)); - unitConverter.SetConversionFunction(EnergyUnit.GigawattHour, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(EnergyUnit.GigawattHour, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, Energy.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.KilobritishThermalUnit, (q) => ((Energy)q).ToUnit(EnergyUnit.KilobritishThermalUnit)); - unitConverter.SetConversionFunction(EnergyUnit.KilobritishThermalUnit, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(EnergyUnit.KilobritishThermalUnit, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.Kilocalorie, (q) => ((Energy)q).ToUnit(EnergyUnit.Kilocalorie)); - unitConverter.SetConversionFunction(EnergyUnit.Kilocalorie, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(EnergyUnit.Kilocalorie, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.Kilojoule, (q) => ((Energy)q).ToUnit(EnergyUnit.Kilojoule)); - unitConverter.SetConversionFunction(EnergyUnit.Kilojoule, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(EnergyUnit.Kilojoule, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.KilowattHour, (q) => ((Energy)q).ToUnit(EnergyUnit.KilowattHour)); - unitConverter.SetConversionFunction(EnergyUnit.KilowattHour, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(EnergyUnit.KilowattHour, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.MegabritishThermalUnit, (q) => ((Energy)q).ToUnit(EnergyUnit.MegabritishThermalUnit)); - unitConverter.SetConversionFunction(EnergyUnit.MegabritishThermalUnit, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(EnergyUnit.MegabritishThermalUnit, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.Megajoule, (q) => ((Energy)q).ToUnit(EnergyUnit.Megajoule)); - unitConverter.SetConversionFunction(EnergyUnit.Megajoule, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(EnergyUnit.Megajoule, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.MegawattHour, (q) => ((Energy)q).ToUnit(EnergyUnit.MegawattHour)); - unitConverter.SetConversionFunction(EnergyUnit.MegawattHour, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(EnergyUnit.MegawattHour, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.ThermEc, (q) => ((Energy)q).ToUnit(EnergyUnit.ThermEc)); - unitConverter.SetConversionFunction(EnergyUnit.ThermEc, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(EnergyUnit.ThermEc, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.ThermImperial, (q) => ((Energy)q).ToUnit(EnergyUnit.ThermImperial)); - unitConverter.SetConversionFunction(EnergyUnit.ThermImperial, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(EnergyUnit.ThermImperial, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.ThermUs, (q) => ((Energy)q).ToUnit(EnergyUnit.ThermUs)); - unitConverter.SetConversionFunction(EnergyUnit.ThermUs, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(EnergyUnit.ThermUs, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.WattHour, (q) => ((Energy)q).ToUnit(EnergyUnit.WattHour)); - unitConverter.SetConversionFunction(EnergyUnit.WattHour, Energy.BaseUnit, (q) => ((Energy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(EnergyUnit.WattHour, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); unitConverter.SetConversionFunction(Entropy.BaseUnit, EntropyUnit.CaloriePerKelvin, (q) => ((Entropy)q).ToUnit(EntropyUnit.CaloriePerKelvin)); - unitConverter.SetConversionFunction(EntropyUnit.CaloriePerKelvin, Entropy.BaseUnit, (q) => ((Entropy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(EntropyUnit.CaloriePerKelvin, Entropy.BaseUnit, (q) => ((Entropy)q).ToBaseUnit()); unitConverter.SetConversionFunction(Entropy.BaseUnit, EntropyUnit.JoulePerDegreeCelsius, (q) => ((Entropy)q).ToUnit(EntropyUnit.JoulePerDegreeCelsius)); - unitConverter.SetConversionFunction(EntropyUnit.JoulePerDegreeCelsius, Entropy.BaseUnit, (q) => ((Entropy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(EntropyUnit.JoulePerDegreeCelsius, Entropy.BaseUnit, (q) => ((Entropy)q).ToBaseUnit()); unitConverter.SetConversionFunction(Entropy.BaseUnit, Entropy.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Entropy.BaseUnit, EntropyUnit.KilocaloriePerKelvin, (q) => ((Entropy)q).ToUnit(EntropyUnit.KilocaloriePerKelvin)); - unitConverter.SetConversionFunction(EntropyUnit.KilocaloriePerKelvin, Entropy.BaseUnit, (q) => ((Entropy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(EntropyUnit.KilocaloriePerKelvin, Entropy.BaseUnit, (q) => ((Entropy)q).ToBaseUnit()); unitConverter.SetConversionFunction(Entropy.BaseUnit, EntropyUnit.KilojoulePerDegreeCelsius, (q) => ((Entropy)q).ToUnit(EntropyUnit.KilojoulePerDegreeCelsius)); - unitConverter.SetConversionFunction(EntropyUnit.KilojoulePerDegreeCelsius, Entropy.BaseUnit, (q) => ((Entropy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(EntropyUnit.KilojoulePerDegreeCelsius, Entropy.BaseUnit, (q) => ((Entropy)q).ToBaseUnit()); unitConverter.SetConversionFunction(Entropy.BaseUnit, EntropyUnit.KilojoulePerKelvin, (q) => ((Entropy)q).ToUnit(EntropyUnit.KilojoulePerKelvin)); - unitConverter.SetConversionFunction(EntropyUnit.KilojoulePerKelvin, Entropy.BaseUnit, (q) => ((Entropy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(EntropyUnit.KilojoulePerKelvin, Entropy.BaseUnit, (q) => ((Entropy)q).ToBaseUnit()); unitConverter.SetConversionFunction(Entropy.BaseUnit, EntropyUnit.MegajoulePerKelvin, (q) => ((Entropy)q).ToUnit(EntropyUnit.MegajoulePerKelvin)); - unitConverter.SetConversionFunction(EntropyUnit.MegajoulePerKelvin, Entropy.BaseUnit, (q) => ((Entropy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(EntropyUnit.MegajoulePerKelvin, Entropy.BaseUnit, (q) => ((Entropy)q).ToBaseUnit()); unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.Decanewton, (q) => ((Force)q).ToUnit(ForceUnit.Decanewton)); - unitConverter.SetConversionFunction(ForceUnit.Decanewton, Force.BaseUnit, (q) => ((Force)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForceUnit.Decanewton, Force.BaseUnit, (q) => ((Force)q).ToBaseUnit()); unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.Dyn, (q) => ((Force)q).ToUnit(ForceUnit.Dyn)); - unitConverter.SetConversionFunction(ForceUnit.Dyn, Force.BaseUnit, (q) => ((Force)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForceUnit.Dyn, Force.BaseUnit, (q) => ((Force)q).ToBaseUnit()); unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.KilogramForce, (q) => ((Force)q).ToUnit(ForceUnit.KilogramForce)); - unitConverter.SetConversionFunction(ForceUnit.KilogramForce, Force.BaseUnit, (q) => ((Force)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForceUnit.KilogramForce, Force.BaseUnit, (q) => ((Force)q).ToBaseUnit()); unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.Kilonewton, (q) => ((Force)q).ToUnit(ForceUnit.Kilonewton)); - unitConverter.SetConversionFunction(ForceUnit.Kilonewton, Force.BaseUnit, (q) => ((Force)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForceUnit.Kilonewton, Force.BaseUnit, (q) => ((Force)q).ToBaseUnit()); unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.KiloPond, (q) => ((Force)q).ToUnit(ForceUnit.KiloPond)); - unitConverter.SetConversionFunction(ForceUnit.KiloPond, Force.BaseUnit, (q) => ((Force)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForceUnit.KiloPond, Force.BaseUnit, (q) => ((Force)q).ToBaseUnit()); unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.Meganewton, (q) => ((Force)q).ToUnit(ForceUnit.Meganewton)); - unitConverter.SetConversionFunction(ForceUnit.Meganewton, Force.BaseUnit, (q) => ((Force)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForceUnit.Meganewton, Force.BaseUnit, (q) => ((Force)q).ToBaseUnit()); unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.Micronewton, (q) => ((Force)q).ToUnit(ForceUnit.Micronewton)); - unitConverter.SetConversionFunction(ForceUnit.Micronewton, Force.BaseUnit, (q) => ((Force)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForceUnit.Micronewton, Force.BaseUnit, (q) => ((Force)q).ToBaseUnit()); unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.Millinewton, (q) => ((Force)q).ToUnit(ForceUnit.Millinewton)); - unitConverter.SetConversionFunction(ForceUnit.Millinewton, Force.BaseUnit, (q) => ((Force)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForceUnit.Millinewton, Force.BaseUnit, (q) => ((Force)q).ToBaseUnit()); unitConverter.SetConversionFunction(Force.BaseUnit, Force.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.OunceForce, (q) => ((Force)q).ToUnit(ForceUnit.OunceForce)); - unitConverter.SetConversionFunction(ForceUnit.OunceForce, Force.BaseUnit, (q) => ((Force)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForceUnit.OunceForce, Force.BaseUnit, (q) => ((Force)q).ToBaseUnit()); unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.Poundal, (q) => ((Force)q).ToUnit(ForceUnit.Poundal)); - unitConverter.SetConversionFunction(ForceUnit.Poundal, Force.BaseUnit, (q) => ((Force)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForceUnit.Poundal, Force.BaseUnit, (q) => ((Force)q).ToBaseUnit()); unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.PoundForce, (q) => ((Force)q).ToUnit(ForceUnit.PoundForce)); - unitConverter.SetConversionFunction(ForceUnit.PoundForce, Force.BaseUnit, (q) => ((Force)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForceUnit.PoundForce, Force.BaseUnit, (q) => ((Force)q).ToBaseUnit()); unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.TonneForce, (q) => ((Force)q).ToUnit(ForceUnit.TonneForce)); - unitConverter.SetConversionFunction(ForceUnit.TonneForce, Force.BaseUnit, (q) => ((Force)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForceUnit.TonneForce, Force.BaseUnit, (q) => ((Force)q).ToBaseUnit()); unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.CentinewtonPerSecond, (q) => ((ForceChangeRate)q).ToUnit(ForceChangeRateUnit.CentinewtonPerSecond)); - unitConverter.SetConversionFunction(ForceChangeRateUnit.CentinewtonPerSecond, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRateUnit.CentinewtonPerSecond, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.DecanewtonPerMinute, (q) => ((ForceChangeRate)q).ToUnit(ForceChangeRateUnit.DecanewtonPerMinute)); - unitConverter.SetConversionFunction(ForceChangeRateUnit.DecanewtonPerMinute, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRateUnit.DecanewtonPerMinute, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.DecanewtonPerSecond, (q) => ((ForceChangeRate)q).ToUnit(ForceChangeRateUnit.DecanewtonPerSecond)); - unitConverter.SetConversionFunction(ForceChangeRateUnit.DecanewtonPerSecond, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRateUnit.DecanewtonPerSecond, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.DecinewtonPerSecond, (q) => ((ForceChangeRate)q).ToUnit(ForceChangeRateUnit.DecinewtonPerSecond)); - unitConverter.SetConversionFunction(ForceChangeRateUnit.DecinewtonPerSecond, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRateUnit.DecinewtonPerSecond, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.KilonewtonPerMinute, (q) => ((ForceChangeRate)q).ToUnit(ForceChangeRateUnit.KilonewtonPerMinute)); - unitConverter.SetConversionFunction(ForceChangeRateUnit.KilonewtonPerMinute, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRateUnit.KilonewtonPerMinute, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.KilonewtonPerSecond, (q) => ((ForceChangeRate)q).ToUnit(ForceChangeRateUnit.KilonewtonPerSecond)); - unitConverter.SetConversionFunction(ForceChangeRateUnit.KilonewtonPerSecond, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRateUnit.KilonewtonPerSecond, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.MicronewtonPerSecond, (q) => ((ForceChangeRate)q).ToUnit(ForceChangeRateUnit.MicronewtonPerSecond)); - unitConverter.SetConversionFunction(ForceChangeRateUnit.MicronewtonPerSecond, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRateUnit.MicronewtonPerSecond, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.MillinewtonPerSecond, (q) => ((ForceChangeRate)q).ToUnit(ForceChangeRateUnit.MillinewtonPerSecond)); - unitConverter.SetConversionFunction(ForceChangeRateUnit.MillinewtonPerSecond, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRateUnit.MillinewtonPerSecond, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.NanonewtonPerSecond, (q) => ((ForceChangeRate)q).ToUnit(ForceChangeRateUnit.NanonewtonPerSecond)); - unitConverter.SetConversionFunction(ForceChangeRateUnit.NanonewtonPerSecond, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRateUnit.NanonewtonPerSecond, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.NewtonPerMinute, (q) => ((ForceChangeRate)q).ToUnit(ForceChangeRateUnit.NewtonPerMinute)); - unitConverter.SetConversionFunction(ForceChangeRateUnit.NewtonPerMinute, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRateUnit.NewtonPerMinute, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRate.BaseUnit, (q) => q); unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.CentinewtonPerMeter, (q) => ((ForcePerLength)q).ToUnit(ForcePerLengthUnit.CentinewtonPerMeter)); - unitConverter.SetConversionFunction(ForcePerLengthUnit.CentinewtonPerMeter, ForcePerLength.BaseUnit, (q) => ((ForcePerLength)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForcePerLengthUnit.CentinewtonPerMeter, ForcePerLength.BaseUnit, (q) => ((ForcePerLength)q).ToBaseUnit()); unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.DecinewtonPerMeter, (q) => ((ForcePerLength)q).ToUnit(ForcePerLengthUnit.DecinewtonPerMeter)); - unitConverter.SetConversionFunction(ForcePerLengthUnit.DecinewtonPerMeter, ForcePerLength.BaseUnit, (q) => ((ForcePerLength)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForcePerLengthUnit.DecinewtonPerMeter, ForcePerLength.BaseUnit, (q) => ((ForcePerLength)q).ToBaseUnit()); unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.KilogramForcePerMeter, (q) => ((ForcePerLength)q).ToUnit(ForcePerLengthUnit.KilogramForcePerMeter)); - unitConverter.SetConversionFunction(ForcePerLengthUnit.KilogramForcePerMeter, ForcePerLength.BaseUnit, (q) => ((ForcePerLength)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForcePerLengthUnit.KilogramForcePerMeter, ForcePerLength.BaseUnit, (q) => ((ForcePerLength)q).ToBaseUnit()); unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.KilonewtonPerMeter, (q) => ((ForcePerLength)q).ToUnit(ForcePerLengthUnit.KilonewtonPerMeter)); - unitConverter.SetConversionFunction(ForcePerLengthUnit.KilonewtonPerMeter, ForcePerLength.BaseUnit, (q) => ((ForcePerLength)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForcePerLengthUnit.KilonewtonPerMeter, ForcePerLength.BaseUnit, (q) => ((ForcePerLength)q).ToBaseUnit()); unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.MeganewtonPerMeter, (q) => ((ForcePerLength)q).ToUnit(ForcePerLengthUnit.MeganewtonPerMeter)); - unitConverter.SetConversionFunction(ForcePerLengthUnit.MeganewtonPerMeter, ForcePerLength.BaseUnit, (q) => ((ForcePerLength)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForcePerLengthUnit.MeganewtonPerMeter, ForcePerLength.BaseUnit, (q) => ((ForcePerLength)q).ToBaseUnit()); unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.MicronewtonPerMeter, (q) => ((ForcePerLength)q).ToUnit(ForcePerLengthUnit.MicronewtonPerMeter)); - unitConverter.SetConversionFunction(ForcePerLengthUnit.MicronewtonPerMeter, ForcePerLength.BaseUnit, (q) => ((ForcePerLength)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForcePerLengthUnit.MicronewtonPerMeter, ForcePerLength.BaseUnit, (q) => ((ForcePerLength)q).ToBaseUnit()); unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.MillinewtonPerMeter, (q) => ((ForcePerLength)q).ToUnit(ForcePerLengthUnit.MillinewtonPerMeter)); - unitConverter.SetConversionFunction(ForcePerLengthUnit.MillinewtonPerMeter, ForcePerLength.BaseUnit, (q) => ((ForcePerLength)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForcePerLengthUnit.MillinewtonPerMeter, ForcePerLength.BaseUnit, (q) => ((ForcePerLength)q).ToBaseUnit()); unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.NanonewtonPerMeter, (q) => ((ForcePerLength)q).ToUnit(ForcePerLengthUnit.NanonewtonPerMeter)); - unitConverter.SetConversionFunction(ForcePerLengthUnit.NanonewtonPerMeter, ForcePerLength.BaseUnit, (q) => ((ForcePerLength)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ForcePerLengthUnit.NanonewtonPerMeter, ForcePerLength.BaseUnit, (q) => ((ForcePerLength)q).ToBaseUnit()); unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLength.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Frequency.BaseUnit, FrequencyUnit.CyclePerHour, (q) => ((Frequency)q).ToUnit(FrequencyUnit.CyclePerHour)); - unitConverter.SetConversionFunction(FrequencyUnit.CyclePerHour, Frequency.BaseUnit, (q) => ((Frequency)q).AsBaseUnit()); + unitConverter.SetConversionFunction(FrequencyUnit.CyclePerHour, Frequency.BaseUnit, (q) => ((Frequency)q).ToBaseUnit()); unitConverter.SetConversionFunction(Frequency.BaseUnit, FrequencyUnit.CyclePerMinute, (q) => ((Frequency)q).ToUnit(FrequencyUnit.CyclePerMinute)); - unitConverter.SetConversionFunction(FrequencyUnit.CyclePerMinute, Frequency.BaseUnit, (q) => ((Frequency)q).AsBaseUnit()); + unitConverter.SetConversionFunction(FrequencyUnit.CyclePerMinute, Frequency.BaseUnit, (q) => ((Frequency)q).ToBaseUnit()); unitConverter.SetConversionFunction(Frequency.BaseUnit, FrequencyUnit.Gigahertz, (q) => ((Frequency)q).ToUnit(FrequencyUnit.Gigahertz)); - unitConverter.SetConversionFunction(FrequencyUnit.Gigahertz, Frequency.BaseUnit, (q) => ((Frequency)q).AsBaseUnit()); + unitConverter.SetConversionFunction(FrequencyUnit.Gigahertz, Frequency.BaseUnit, (q) => ((Frequency)q).ToBaseUnit()); unitConverter.SetConversionFunction(Frequency.BaseUnit, Frequency.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Frequency.BaseUnit, FrequencyUnit.Kilohertz, (q) => ((Frequency)q).ToUnit(FrequencyUnit.Kilohertz)); - unitConverter.SetConversionFunction(FrequencyUnit.Kilohertz, Frequency.BaseUnit, (q) => ((Frequency)q).AsBaseUnit()); + unitConverter.SetConversionFunction(FrequencyUnit.Kilohertz, Frequency.BaseUnit, (q) => ((Frequency)q).ToBaseUnit()); unitConverter.SetConversionFunction(Frequency.BaseUnit, FrequencyUnit.Megahertz, (q) => ((Frequency)q).ToUnit(FrequencyUnit.Megahertz)); - unitConverter.SetConversionFunction(FrequencyUnit.Megahertz, Frequency.BaseUnit, (q) => ((Frequency)q).AsBaseUnit()); + unitConverter.SetConversionFunction(FrequencyUnit.Megahertz, Frequency.BaseUnit, (q) => ((Frequency)q).ToBaseUnit()); unitConverter.SetConversionFunction(Frequency.BaseUnit, FrequencyUnit.RadianPerSecond, (q) => ((Frequency)q).ToUnit(FrequencyUnit.RadianPerSecond)); - unitConverter.SetConversionFunction(FrequencyUnit.RadianPerSecond, Frequency.BaseUnit, (q) => ((Frequency)q).AsBaseUnit()); + unitConverter.SetConversionFunction(FrequencyUnit.RadianPerSecond, Frequency.BaseUnit, (q) => ((Frequency)q).ToBaseUnit()); unitConverter.SetConversionFunction(Frequency.BaseUnit, FrequencyUnit.Terahertz, (q) => ((Frequency)q).ToUnit(FrequencyUnit.Terahertz)); - unitConverter.SetConversionFunction(FrequencyUnit.Terahertz, Frequency.BaseUnit, (q) => ((Frequency)q).AsBaseUnit()); + unitConverter.SetConversionFunction(FrequencyUnit.Terahertz, Frequency.BaseUnit, (q) => ((Frequency)q).ToBaseUnit()); unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.BtuPerHourSquareFoot, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.BtuPerHourSquareFoot)); - unitConverter.SetConversionFunction(HeatFluxUnit.BtuPerHourSquareFoot, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFluxUnit.BtuPerHourSquareFoot, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).ToBaseUnit()); unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.BtuPerMinuteSquareFoot, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.BtuPerMinuteSquareFoot)); - unitConverter.SetConversionFunction(HeatFluxUnit.BtuPerMinuteSquareFoot, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFluxUnit.BtuPerMinuteSquareFoot, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).ToBaseUnit()); unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.BtuPerSecondSquareFoot, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.BtuPerSecondSquareFoot)); - unitConverter.SetConversionFunction(HeatFluxUnit.BtuPerSecondSquareFoot, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFluxUnit.BtuPerSecondSquareFoot, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).ToBaseUnit()); unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.BtuPerSecondSquareInch, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.BtuPerSecondSquareInch)); - unitConverter.SetConversionFunction(HeatFluxUnit.BtuPerSecondSquareInch, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFluxUnit.BtuPerSecondSquareInch, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).ToBaseUnit()); unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.CaloriePerSecondSquareCentimeter, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.CaloriePerSecondSquareCentimeter)); - unitConverter.SetConversionFunction(HeatFluxUnit.CaloriePerSecondSquareCentimeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFluxUnit.CaloriePerSecondSquareCentimeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).ToBaseUnit()); unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.CentiwattPerSquareMeter, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.CentiwattPerSquareMeter)); - unitConverter.SetConversionFunction(HeatFluxUnit.CentiwattPerSquareMeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFluxUnit.CentiwattPerSquareMeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).ToBaseUnit()); unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.DeciwattPerSquareMeter, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.DeciwattPerSquareMeter)); - unitConverter.SetConversionFunction(HeatFluxUnit.DeciwattPerSquareMeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFluxUnit.DeciwattPerSquareMeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).ToBaseUnit()); unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.KilocaloriePerHourSquareMeter, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.KilocaloriePerHourSquareMeter)); - unitConverter.SetConversionFunction(HeatFluxUnit.KilocaloriePerHourSquareMeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFluxUnit.KilocaloriePerHourSquareMeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).ToBaseUnit()); unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.KilocaloriePerSecondSquareCentimeter, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.KilocaloriePerSecondSquareCentimeter)); - unitConverter.SetConversionFunction(HeatFluxUnit.KilocaloriePerSecondSquareCentimeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFluxUnit.KilocaloriePerSecondSquareCentimeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).ToBaseUnit()); unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.KilowattPerSquareMeter, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.KilowattPerSquareMeter)); - unitConverter.SetConversionFunction(HeatFluxUnit.KilowattPerSquareMeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFluxUnit.KilowattPerSquareMeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).ToBaseUnit()); unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.MicrowattPerSquareMeter, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.MicrowattPerSquareMeter)); - unitConverter.SetConversionFunction(HeatFluxUnit.MicrowattPerSquareMeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFluxUnit.MicrowattPerSquareMeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).ToBaseUnit()); unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.MilliwattPerSquareMeter, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.MilliwattPerSquareMeter)); - unitConverter.SetConversionFunction(HeatFluxUnit.MilliwattPerSquareMeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFluxUnit.MilliwattPerSquareMeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).ToBaseUnit()); unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.NanowattPerSquareMeter, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.NanowattPerSquareMeter)); - unitConverter.SetConversionFunction(HeatFluxUnit.NanowattPerSquareMeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFluxUnit.NanowattPerSquareMeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).ToBaseUnit()); unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.PoundForcePerFootSecond, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.PoundForcePerFootSecond)); - unitConverter.SetConversionFunction(HeatFluxUnit.PoundForcePerFootSecond, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFluxUnit.PoundForcePerFootSecond, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).ToBaseUnit()); unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.PoundPerSecondCubed, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.PoundPerSecondCubed)); - unitConverter.SetConversionFunction(HeatFluxUnit.PoundPerSecondCubed, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFluxUnit.PoundPerSecondCubed, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).ToBaseUnit()); unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.WattPerSquareFoot, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.WattPerSquareFoot)); - unitConverter.SetConversionFunction(HeatFluxUnit.WattPerSquareFoot, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFluxUnit.WattPerSquareFoot, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).ToBaseUnit()); unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.WattPerSquareInch, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.WattPerSquareInch)); - unitConverter.SetConversionFunction(HeatFluxUnit.WattPerSquareInch, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatFluxUnit.WattPerSquareInch, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).ToBaseUnit()); unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFlux.BaseUnit, (q) => q); unitConverter.SetConversionFunction(HeatTransferCoefficient.BaseUnit, HeatTransferCoefficientUnit.WattPerSquareMeterCelsius, (q) => ((HeatTransferCoefficient)q).ToUnit(HeatTransferCoefficientUnit.WattPerSquareMeterCelsius)); - unitConverter.SetConversionFunction(HeatTransferCoefficientUnit.WattPerSquareMeterCelsius, HeatTransferCoefficient.BaseUnit, (q) => ((HeatTransferCoefficient)q).AsBaseUnit()); + unitConverter.SetConversionFunction(HeatTransferCoefficientUnit.WattPerSquareMeterCelsius, HeatTransferCoefficient.BaseUnit, (q) => ((HeatTransferCoefficient)q).ToBaseUnit()); unitConverter.SetConversionFunction(HeatTransferCoefficient.BaseUnit, HeatTransferCoefficient.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Illuminance.BaseUnit, IlluminanceUnit.Kilolux, (q) => ((Illuminance)q).ToUnit(IlluminanceUnit.Kilolux)); - unitConverter.SetConversionFunction(IlluminanceUnit.Kilolux, Illuminance.BaseUnit, (q) => ((Illuminance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(IlluminanceUnit.Kilolux, Illuminance.BaseUnit, (q) => ((Illuminance)q).ToBaseUnit()); unitConverter.SetConversionFunction(Illuminance.BaseUnit, Illuminance.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Illuminance.BaseUnit, IlluminanceUnit.Megalux, (q) => ((Illuminance)q).ToUnit(IlluminanceUnit.Megalux)); - unitConverter.SetConversionFunction(IlluminanceUnit.Megalux, Illuminance.BaseUnit, (q) => ((Illuminance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(IlluminanceUnit.Megalux, Illuminance.BaseUnit, (q) => ((Illuminance)q).ToBaseUnit()); unitConverter.SetConversionFunction(Illuminance.BaseUnit, IlluminanceUnit.Millilux, (q) => ((Illuminance)q).ToUnit(IlluminanceUnit.Millilux)); - unitConverter.SetConversionFunction(IlluminanceUnit.Millilux, Illuminance.BaseUnit, (q) => ((Illuminance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(IlluminanceUnit.Millilux, Illuminance.BaseUnit, (q) => ((Illuminance)q).ToBaseUnit()); unitConverter.SetConversionFunction(Information.BaseUnit, Information.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Byte, (q) => ((Information)q).ToUnit(InformationUnit.Byte)); - unitConverter.SetConversionFunction(InformationUnit.Byte, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(InformationUnit.Byte, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Exabit, (q) => ((Information)q).ToUnit(InformationUnit.Exabit)); - unitConverter.SetConversionFunction(InformationUnit.Exabit, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(InformationUnit.Exabit, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Exabyte, (q) => ((Information)q).ToUnit(InformationUnit.Exabyte)); - unitConverter.SetConversionFunction(InformationUnit.Exabyte, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(InformationUnit.Exabyte, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Exbibit, (q) => ((Information)q).ToUnit(InformationUnit.Exbibit)); - unitConverter.SetConversionFunction(InformationUnit.Exbibit, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(InformationUnit.Exbibit, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Exbibyte, (q) => ((Information)q).ToUnit(InformationUnit.Exbibyte)); - unitConverter.SetConversionFunction(InformationUnit.Exbibyte, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(InformationUnit.Exbibyte, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Gibibit, (q) => ((Information)q).ToUnit(InformationUnit.Gibibit)); - unitConverter.SetConversionFunction(InformationUnit.Gibibit, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(InformationUnit.Gibibit, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Gibibyte, (q) => ((Information)q).ToUnit(InformationUnit.Gibibyte)); - unitConverter.SetConversionFunction(InformationUnit.Gibibyte, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(InformationUnit.Gibibyte, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Gigabit, (q) => ((Information)q).ToUnit(InformationUnit.Gigabit)); - unitConverter.SetConversionFunction(InformationUnit.Gigabit, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(InformationUnit.Gigabit, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Gigabyte, (q) => ((Information)q).ToUnit(InformationUnit.Gigabyte)); - unitConverter.SetConversionFunction(InformationUnit.Gigabyte, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(InformationUnit.Gigabyte, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Kibibit, (q) => ((Information)q).ToUnit(InformationUnit.Kibibit)); - unitConverter.SetConversionFunction(InformationUnit.Kibibit, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(InformationUnit.Kibibit, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Kibibyte, (q) => ((Information)q).ToUnit(InformationUnit.Kibibyte)); - unitConverter.SetConversionFunction(InformationUnit.Kibibyte, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(InformationUnit.Kibibyte, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Kilobit, (q) => ((Information)q).ToUnit(InformationUnit.Kilobit)); - unitConverter.SetConversionFunction(InformationUnit.Kilobit, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(InformationUnit.Kilobit, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Kilobyte, (q) => ((Information)q).ToUnit(InformationUnit.Kilobyte)); - unitConverter.SetConversionFunction(InformationUnit.Kilobyte, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(InformationUnit.Kilobyte, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Mebibit, (q) => ((Information)q).ToUnit(InformationUnit.Mebibit)); - unitConverter.SetConversionFunction(InformationUnit.Mebibit, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(InformationUnit.Mebibit, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Mebibyte, (q) => ((Information)q).ToUnit(InformationUnit.Mebibyte)); - unitConverter.SetConversionFunction(InformationUnit.Mebibyte, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(InformationUnit.Mebibyte, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Megabit, (q) => ((Information)q).ToUnit(InformationUnit.Megabit)); - unitConverter.SetConversionFunction(InformationUnit.Megabit, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(InformationUnit.Megabit, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Megabyte, (q) => ((Information)q).ToUnit(InformationUnit.Megabyte)); - unitConverter.SetConversionFunction(InformationUnit.Megabyte, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(InformationUnit.Megabyte, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Pebibit, (q) => ((Information)q).ToUnit(InformationUnit.Pebibit)); - unitConverter.SetConversionFunction(InformationUnit.Pebibit, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(InformationUnit.Pebibit, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Pebibyte, (q) => ((Information)q).ToUnit(InformationUnit.Pebibyte)); - unitConverter.SetConversionFunction(InformationUnit.Pebibyte, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(InformationUnit.Pebibyte, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Petabit, (q) => ((Information)q).ToUnit(InformationUnit.Petabit)); - unitConverter.SetConversionFunction(InformationUnit.Petabit, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(InformationUnit.Petabit, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Petabyte, (q) => ((Information)q).ToUnit(InformationUnit.Petabyte)); - unitConverter.SetConversionFunction(InformationUnit.Petabyte, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(InformationUnit.Petabyte, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Tebibit, (q) => ((Information)q).ToUnit(InformationUnit.Tebibit)); - unitConverter.SetConversionFunction(InformationUnit.Tebibit, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(InformationUnit.Tebibit, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Tebibyte, (q) => ((Information)q).ToUnit(InformationUnit.Tebibyte)); - unitConverter.SetConversionFunction(InformationUnit.Tebibyte, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(InformationUnit.Tebibyte, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Terabit, (q) => ((Information)q).ToUnit(InformationUnit.Terabit)); - unitConverter.SetConversionFunction(InformationUnit.Terabit, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(InformationUnit.Terabit, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Terabyte, (q) => ((Information)q).ToUnit(InformationUnit.Terabyte)); - unitConverter.SetConversionFunction(InformationUnit.Terabyte, Information.BaseUnit, (q) => ((Information)q).AsBaseUnit()); + unitConverter.SetConversionFunction(InformationUnit.Terabyte, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.KilowattPerSquareCentimeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.KilowattPerSquareCentimeter)); - unitConverter.SetConversionFunction(IrradianceUnit.KilowattPerSquareCentimeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(IrradianceUnit.KilowattPerSquareCentimeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).ToBaseUnit()); unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.KilowattPerSquareMeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.KilowattPerSquareMeter)); - unitConverter.SetConversionFunction(IrradianceUnit.KilowattPerSquareMeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(IrradianceUnit.KilowattPerSquareMeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).ToBaseUnit()); unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.MegawattPerSquareCentimeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.MegawattPerSquareCentimeter)); - unitConverter.SetConversionFunction(IrradianceUnit.MegawattPerSquareCentimeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(IrradianceUnit.MegawattPerSquareCentimeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).ToBaseUnit()); unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.MegawattPerSquareMeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.MegawattPerSquareMeter)); - unitConverter.SetConversionFunction(IrradianceUnit.MegawattPerSquareMeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(IrradianceUnit.MegawattPerSquareMeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).ToBaseUnit()); unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.MicrowattPerSquareCentimeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.MicrowattPerSquareCentimeter)); - unitConverter.SetConversionFunction(IrradianceUnit.MicrowattPerSquareCentimeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(IrradianceUnit.MicrowattPerSquareCentimeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).ToBaseUnit()); unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.MicrowattPerSquareMeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.MicrowattPerSquareMeter)); - unitConverter.SetConversionFunction(IrradianceUnit.MicrowattPerSquareMeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(IrradianceUnit.MicrowattPerSquareMeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).ToBaseUnit()); unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.MilliwattPerSquareCentimeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.MilliwattPerSquareCentimeter)); - unitConverter.SetConversionFunction(IrradianceUnit.MilliwattPerSquareCentimeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(IrradianceUnit.MilliwattPerSquareCentimeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).ToBaseUnit()); unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.MilliwattPerSquareMeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.MilliwattPerSquareMeter)); - unitConverter.SetConversionFunction(IrradianceUnit.MilliwattPerSquareMeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(IrradianceUnit.MilliwattPerSquareMeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).ToBaseUnit()); unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.NanowattPerSquareCentimeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.NanowattPerSquareCentimeter)); - unitConverter.SetConversionFunction(IrradianceUnit.NanowattPerSquareCentimeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(IrradianceUnit.NanowattPerSquareCentimeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).ToBaseUnit()); unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.NanowattPerSquareMeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.NanowattPerSquareMeter)); - unitConverter.SetConversionFunction(IrradianceUnit.NanowattPerSquareMeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(IrradianceUnit.NanowattPerSquareMeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).ToBaseUnit()); unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.PicowattPerSquareCentimeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.PicowattPerSquareCentimeter)); - unitConverter.SetConversionFunction(IrradianceUnit.PicowattPerSquareCentimeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(IrradianceUnit.PicowattPerSquareCentimeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).ToBaseUnit()); unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.PicowattPerSquareMeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.PicowattPerSquareMeter)); - unitConverter.SetConversionFunction(IrradianceUnit.PicowattPerSquareMeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(IrradianceUnit.PicowattPerSquareMeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).ToBaseUnit()); unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.WattPerSquareCentimeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.WattPerSquareCentimeter)); - unitConverter.SetConversionFunction(IrradianceUnit.WattPerSquareCentimeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(IrradianceUnit.WattPerSquareCentimeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).ToBaseUnit()); unitConverter.SetConversionFunction(Irradiance.BaseUnit, Irradiance.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Irradiation.BaseUnit, Irradiation.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Irradiation.BaseUnit, IrradiationUnit.JoulePerSquareMillimeter, (q) => ((Irradiation)q).ToUnit(IrradiationUnit.JoulePerSquareMillimeter)); - unitConverter.SetConversionFunction(IrradiationUnit.JoulePerSquareMillimeter, Irradiation.BaseUnit, (q) => ((Irradiation)q).AsBaseUnit()); + unitConverter.SetConversionFunction(IrradiationUnit.JoulePerSquareMillimeter, Irradiation.BaseUnit, (q) => ((Irradiation)q).ToBaseUnit()); unitConverter.SetConversionFunction(Irradiation.BaseUnit, IrradiationUnit.KilowattHourPerSquareMeter, (q) => ((Irradiation)q).ToUnit(IrradiationUnit.KilowattHourPerSquareMeter)); - unitConverter.SetConversionFunction(IrradiationUnit.KilowattHourPerSquareMeter, Irradiation.BaseUnit, (q) => ((Irradiation)q).AsBaseUnit()); + unitConverter.SetConversionFunction(IrradiationUnit.KilowattHourPerSquareMeter, Irradiation.BaseUnit, (q) => ((Irradiation)q).ToBaseUnit()); unitConverter.SetConversionFunction(Irradiation.BaseUnit, IrradiationUnit.WattHourPerSquareMeter, (q) => ((Irradiation)q).ToUnit(IrradiationUnit.WattHourPerSquareMeter)); - unitConverter.SetConversionFunction(IrradiationUnit.WattHourPerSquareMeter, Irradiation.BaseUnit, (q) => ((Irradiation)q).AsBaseUnit()); + unitConverter.SetConversionFunction(IrradiationUnit.WattHourPerSquareMeter, Irradiation.BaseUnit, (q) => ((Irradiation)q).ToBaseUnit()); unitConverter.SetConversionFunction(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Centistokes, (q) => ((KinematicViscosity)q).ToUnit(KinematicViscosityUnit.Centistokes)); - unitConverter.SetConversionFunction(KinematicViscosityUnit.Centistokes, KinematicViscosity.BaseUnit, (q) => ((KinematicViscosity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(KinematicViscosityUnit.Centistokes, KinematicViscosity.BaseUnit, (q) => ((KinematicViscosity)q).ToBaseUnit()); unitConverter.SetConversionFunction(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Decistokes, (q) => ((KinematicViscosity)q).ToUnit(KinematicViscosityUnit.Decistokes)); - unitConverter.SetConversionFunction(KinematicViscosityUnit.Decistokes, KinematicViscosity.BaseUnit, (q) => ((KinematicViscosity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(KinematicViscosityUnit.Decistokes, KinematicViscosity.BaseUnit, (q) => ((KinematicViscosity)q).ToBaseUnit()); unitConverter.SetConversionFunction(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Kilostokes, (q) => ((KinematicViscosity)q).ToUnit(KinematicViscosityUnit.Kilostokes)); - unitConverter.SetConversionFunction(KinematicViscosityUnit.Kilostokes, KinematicViscosity.BaseUnit, (q) => ((KinematicViscosity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(KinematicViscosityUnit.Kilostokes, KinematicViscosity.BaseUnit, (q) => ((KinematicViscosity)q).ToBaseUnit()); unitConverter.SetConversionFunction(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Microstokes, (q) => ((KinematicViscosity)q).ToUnit(KinematicViscosityUnit.Microstokes)); - unitConverter.SetConversionFunction(KinematicViscosityUnit.Microstokes, KinematicViscosity.BaseUnit, (q) => ((KinematicViscosity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(KinematicViscosityUnit.Microstokes, KinematicViscosity.BaseUnit, (q) => ((KinematicViscosity)q).ToBaseUnit()); unitConverter.SetConversionFunction(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Millistokes, (q) => ((KinematicViscosity)q).ToUnit(KinematicViscosityUnit.Millistokes)); - unitConverter.SetConversionFunction(KinematicViscosityUnit.Millistokes, KinematicViscosity.BaseUnit, (q) => ((KinematicViscosity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(KinematicViscosityUnit.Millistokes, KinematicViscosity.BaseUnit, (q) => ((KinematicViscosity)q).ToBaseUnit()); unitConverter.SetConversionFunction(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Nanostokes, (q) => ((KinematicViscosity)q).ToUnit(KinematicViscosityUnit.Nanostokes)); - unitConverter.SetConversionFunction(KinematicViscosityUnit.Nanostokes, KinematicViscosity.BaseUnit, (q) => ((KinematicViscosity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(KinematicViscosityUnit.Nanostokes, KinematicViscosity.BaseUnit, (q) => ((KinematicViscosity)q).ToBaseUnit()); unitConverter.SetConversionFunction(KinematicViscosity.BaseUnit, KinematicViscosity.BaseUnit, (q) => q); unitConverter.SetConversionFunction(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Stokes, (q) => ((KinematicViscosity)q).ToUnit(KinematicViscosityUnit.Stokes)); - unitConverter.SetConversionFunction(KinematicViscosityUnit.Stokes, KinematicViscosity.BaseUnit, (q) => ((KinematicViscosity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(KinematicViscosityUnit.Stokes, KinematicViscosity.BaseUnit, (q) => ((KinematicViscosity)q).ToBaseUnit()); unitConverter.SetConversionFunction(LapseRate.BaseUnit, LapseRate.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Centimeter, (q) => ((Length)q).ToUnit(LengthUnit.Centimeter)); - unitConverter.SetConversionFunction(LengthUnit.Centimeter, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(LengthUnit.Centimeter, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Decimeter, (q) => ((Length)q).ToUnit(LengthUnit.Decimeter)); - unitConverter.SetConversionFunction(LengthUnit.Decimeter, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(LengthUnit.Decimeter, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.DtpPica, (q) => ((Length)q).ToUnit(LengthUnit.DtpPica)); - unitConverter.SetConversionFunction(LengthUnit.DtpPica, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(LengthUnit.DtpPica, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.DtpPoint, (q) => ((Length)q).ToUnit(LengthUnit.DtpPoint)); - unitConverter.SetConversionFunction(LengthUnit.DtpPoint, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(LengthUnit.DtpPoint, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Fathom, (q) => ((Length)q).ToUnit(LengthUnit.Fathom)); - unitConverter.SetConversionFunction(LengthUnit.Fathom, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(LengthUnit.Fathom, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Foot, (q) => ((Length)q).ToUnit(LengthUnit.Foot)); - unitConverter.SetConversionFunction(LengthUnit.Foot, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(LengthUnit.Foot, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Inch, (q) => ((Length)q).ToUnit(LengthUnit.Inch)); - unitConverter.SetConversionFunction(LengthUnit.Inch, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(LengthUnit.Inch, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Kilometer, (q) => ((Length)q).ToUnit(LengthUnit.Kilometer)); - unitConverter.SetConversionFunction(LengthUnit.Kilometer, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(LengthUnit.Kilometer, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); unitConverter.SetConversionFunction(Length.BaseUnit, Length.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Microinch, (q) => ((Length)q).ToUnit(LengthUnit.Microinch)); - unitConverter.SetConversionFunction(LengthUnit.Microinch, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(LengthUnit.Microinch, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Micrometer, (q) => ((Length)q).ToUnit(LengthUnit.Micrometer)); - unitConverter.SetConversionFunction(LengthUnit.Micrometer, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(LengthUnit.Micrometer, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Mil, (q) => ((Length)q).ToUnit(LengthUnit.Mil)); - unitConverter.SetConversionFunction(LengthUnit.Mil, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(LengthUnit.Mil, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Mile, (q) => ((Length)q).ToUnit(LengthUnit.Mile)); - unitConverter.SetConversionFunction(LengthUnit.Mile, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(LengthUnit.Mile, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Millimeter, (q) => ((Length)q).ToUnit(LengthUnit.Millimeter)); - unitConverter.SetConversionFunction(LengthUnit.Millimeter, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(LengthUnit.Millimeter, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Nanometer, (q) => ((Length)q).ToUnit(LengthUnit.Nanometer)); - unitConverter.SetConversionFunction(LengthUnit.Nanometer, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(LengthUnit.Nanometer, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.NauticalMile, (q) => ((Length)q).ToUnit(LengthUnit.NauticalMile)); - unitConverter.SetConversionFunction(LengthUnit.NauticalMile, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(LengthUnit.NauticalMile, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.PrinterPica, (q) => ((Length)q).ToUnit(LengthUnit.PrinterPica)); - unitConverter.SetConversionFunction(LengthUnit.PrinterPica, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(LengthUnit.PrinterPica, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.PrinterPoint, (q) => ((Length)q).ToUnit(LengthUnit.PrinterPoint)); - unitConverter.SetConversionFunction(LengthUnit.PrinterPoint, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(LengthUnit.PrinterPoint, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Shackle, (q) => ((Length)q).ToUnit(LengthUnit.Shackle)); - unitConverter.SetConversionFunction(LengthUnit.Shackle, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(LengthUnit.Shackle, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Twip, (q) => ((Length)q).ToUnit(LengthUnit.Twip)); - unitConverter.SetConversionFunction(LengthUnit.Twip, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(LengthUnit.Twip, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.UsSurveyFoot, (q) => ((Length)q).ToUnit(LengthUnit.UsSurveyFoot)); - unitConverter.SetConversionFunction(LengthUnit.UsSurveyFoot, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(LengthUnit.UsSurveyFoot, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Yard, (q) => ((Length)q).ToUnit(LengthUnit.Yard)); - unitConverter.SetConversionFunction(LengthUnit.Yard, Length.BaseUnit, (q) => ((Length)q).AsBaseUnit()); + unitConverter.SetConversionFunction(LengthUnit.Yard, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); unitConverter.SetConversionFunction(Level.BaseUnit, Level.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Level.BaseUnit, LevelUnit.Neper, (q) => ((Level)q).ToUnit(LevelUnit.Neper)); - unitConverter.SetConversionFunction(LevelUnit.Neper, Level.BaseUnit, (q) => ((Level)q).AsBaseUnit()); + unitConverter.SetConversionFunction(LevelUnit.Neper, Level.BaseUnit, (q) => ((Level)q).ToBaseUnit()); unitConverter.SetConversionFunction(LinearDensity.BaseUnit, LinearDensityUnit.GramPerMeter, (q) => ((LinearDensity)q).ToUnit(LinearDensityUnit.GramPerMeter)); - unitConverter.SetConversionFunction(LinearDensityUnit.GramPerMeter, LinearDensity.BaseUnit, (q) => ((LinearDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(LinearDensityUnit.GramPerMeter, LinearDensity.BaseUnit, (q) => ((LinearDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(LinearDensity.BaseUnit, LinearDensity.BaseUnit, (q) => q); unitConverter.SetConversionFunction(LinearDensity.BaseUnit, LinearDensityUnit.PoundPerFoot, (q) => ((LinearDensity)q).ToUnit(LinearDensityUnit.PoundPerFoot)); - unitConverter.SetConversionFunction(LinearDensityUnit.PoundPerFoot, LinearDensity.BaseUnit, (q) => ((LinearDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(LinearDensityUnit.PoundPerFoot, LinearDensity.BaseUnit, (q) => ((LinearDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(LuminousFlux.BaseUnit, LuminousFlux.BaseUnit, (q) => q); unitConverter.SetConversionFunction(LuminousIntensity.BaseUnit, LuminousIntensity.BaseUnit, (q) => q); unitConverter.SetConversionFunction(MagneticField.BaseUnit, MagneticFieldUnit.Microtesla, (q) => ((MagneticField)q).ToUnit(MagneticFieldUnit.Microtesla)); - unitConverter.SetConversionFunction(MagneticFieldUnit.Microtesla, MagneticField.BaseUnit, (q) => ((MagneticField)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MagneticFieldUnit.Microtesla, MagneticField.BaseUnit, (q) => ((MagneticField)q).ToBaseUnit()); unitConverter.SetConversionFunction(MagneticField.BaseUnit, MagneticFieldUnit.Millitesla, (q) => ((MagneticField)q).ToUnit(MagneticFieldUnit.Millitesla)); - unitConverter.SetConversionFunction(MagneticFieldUnit.Millitesla, MagneticField.BaseUnit, (q) => ((MagneticField)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MagneticFieldUnit.Millitesla, MagneticField.BaseUnit, (q) => ((MagneticField)q).ToBaseUnit()); unitConverter.SetConversionFunction(MagneticField.BaseUnit, MagneticFieldUnit.Nanotesla, (q) => ((MagneticField)q).ToUnit(MagneticFieldUnit.Nanotesla)); - unitConverter.SetConversionFunction(MagneticFieldUnit.Nanotesla, MagneticField.BaseUnit, (q) => ((MagneticField)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MagneticFieldUnit.Nanotesla, MagneticField.BaseUnit, (q) => ((MagneticField)q).ToBaseUnit()); unitConverter.SetConversionFunction(MagneticField.BaseUnit, MagneticField.BaseUnit, (q) => q); unitConverter.SetConversionFunction(MagneticFlux.BaseUnit, MagneticFlux.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Magnetization.BaseUnit, Magnetization.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Centigram, (q) => ((Mass)q).ToUnit(MassUnit.Centigram)); - unitConverter.SetConversionFunction(MassUnit.Centigram, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassUnit.Centigram, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Decagram, (q) => ((Mass)q).ToUnit(MassUnit.Decagram)); - unitConverter.SetConversionFunction(MassUnit.Decagram, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassUnit.Decagram, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Decigram, (q) => ((Mass)q).ToUnit(MassUnit.Decigram)); - unitConverter.SetConversionFunction(MassUnit.Decigram, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassUnit.Decigram, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Grain, (q) => ((Mass)q).ToUnit(MassUnit.Grain)); - unitConverter.SetConversionFunction(MassUnit.Grain, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassUnit.Grain, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Gram, (q) => ((Mass)q).ToUnit(MassUnit.Gram)); - unitConverter.SetConversionFunction(MassUnit.Gram, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassUnit.Gram, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Hectogram, (q) => ((Mass)q).ToUnit(MassUnit.Hectogram)); - unitConverter.SetConversionFunction(MassUnit.Hectogram, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassUnit.Hectogram, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); unitConverter.SetConversionFunction(Mass.BaseUnit, Mass.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Kilopound, (q) => ((Mass)q).ToUnit(MassUnit.Kilopound)); - unitConverter.SetConversionFunction(MassUnit.Kilopound, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassUnit.Kilopound, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Kilotonne, (q) => ((Mass)q).ToUnit(MassUnit.Kilotonne)); - unitConverter.SetConversionFunction(MassUnit.Kilotonne, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassUnit.Kilotonne, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.LongHundredweight, (q) => ((Mass)q).ToUnit(MassUnit.LongHundredweight)); - unitConverter.SetConversionFunction(MassUnit.LongHundredweight, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassUnit.LongHundredweight, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.LongTon, (q) => ((Mass)q).ToUnit(MassUnit.LongTon)); - unitConverter.SetConversionFunction(MassUnit.LongTon, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassUnit.LongTon, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Megapound, (q) => ((Mass)q).ToUnit(MassUnit.Megapound)); - unitConverter.SetConversionFunction(MassUnit.Megapound, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassUnit.Megapound, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Megatonne, (q) => ((Mass)q).ToUnit(MassUnit.Megatonne)); - unitConverter.SetConversionFunction(MassUnit.Megatonne, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassUnit.Megatonne, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Microgram, (q) => ((Mass)q).ToUnit(MassUnit.Microgram)); - unitConverter.SetConversionFunction(MassUnit.Microgram, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassUnit.Microgram, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Milligram, (q) => ((Mass)q).ToUnit(MassUnit.Milligram)); - unitConverter.SetConversionFunction(MassUnit.Milligram, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassUnit.Milligram, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Nanogram, (q) => ((Mass)q).ToUnit(MassUnit.Nanogram)); - unitConverter.SetConversionFunction(MassUnit.Nanogram, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassUnit.Nanogram, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Ounce, (q) => ((Mass)q).ToUnit(MassUnit.Ounce)); - unitConverter.SetConversionFunction(MassUnit.Ounce, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassUnit.Ounce, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Pound, (q) => ((Mass)q).ToUnit(MassUnit.Pound)); - unitConverter.SetConversionFunction(MassUnit.Pound, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassUnit.Pound, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.ShortHundredweight, (q) => ((Mass)q).ToUnit(MassUnit.ShortHundredweight)); - unitConverter.SetConversionFunction(MassUnit.ShortHundredweight, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassUnit.ShortHundredweight, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.ShortTon, (q) => ((Mass)q).ToUnit(MassUnit.ShortTon)); - unitConverter.SetConversionFunction(MassUnit.ShortTon, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassUnit.ShortTon, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Slug, (q) => ((Mass)q).ToUnit(MassUnit.Slug)); - unitConverter.SetConversionFunction(MassUnit.Slug, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassUnit.Slug, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Stone, (q) => ((Mass)q).ToUnit(MassUnit.Stone)); - unitConverter.SetConversionFunction(MassUnit.Stone, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassUnit.Stone, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Tonne, (q) => ((Mass)q).ToUnit(MassUnit.Tonne)); - unitConverter.SetConversionFunction(MassUnit.Tonne, Mass.BaseUnit, (q) => ((Mass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassUnit.Tonne, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.CentigramPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.CentigramPerDay)); - unitConverter.SetConversionFunction(MassFlowUnit.CentigramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlowUnit.CentigramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.CentigramPerSecond, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.CentigramPerSecond)); - unitConverter.SetConversionFunction(MassFlowUnit.CentigramPerSecond, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlowUnit.CentigramPerSecond, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.DecagramPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.DecagramPerDay)); - unitConverter.SetConversionFunction(MassFlowUnit.DecagramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlowUnit.DecagramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.DecagramPerSecond, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.DecagramPerSecond)); - unitConverter.SetConversionFunction(MassFlowUnit.DecagramPerSecond, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlowUnit.DecagramPerSecond, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.DecigramPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.DecigramPerDay)); - unitConverter.SetConversionFunction(MassFlowUnit.DecigramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlowUnit.DecigramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.DecigramPerSecond, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.DecigramPerSecond)); - unitConverter.SetConversionFunction(MassFlowUnit.DecigramPerSecond, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlowUnit.DecigramPerSecond, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.GramPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.GramPerDay)); - unitConverter.SetConversionFunction(MassFlowUnit.GramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlowUnit.GramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlow.BaseUnit, (q) => q); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.HectogramPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.HectogramPerDay)); - unitConverter.SetConversionFunction(MassFlowUnit.HectogramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlowUnit.HectogramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.HectogramPerSecond, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.HectogramPerSecond)); - unitConverter.SetConversionFunction(MassFlowUnit.HectogramPerSecond, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlowUnit.HectogramPerSecond, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.KilogramPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.KilogramPerDay)); - unitConverter.SetConversionFunction(MassFlowUnit.KilogramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlowUnit.KilogramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.KilogramPerHour, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.KilogramPerHour)); - unitConverter.SetConversionFunction(MassFlowUnit.KilogramPerHour, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlowUnit.KilogramPerHour, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.KilogramPerMinute, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.KilogramPerMinute)); - unitConverter.SetConversionFunction(MassFlowUnit.KilogramPerMinute, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlowUnit.KilogramPerMinute, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.KilogramPerSecond, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.KilogramPerSecond)); - unitConverter.SetConversionFunction(MassFlowUnit.KilogramPerSecond, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlowUnit.KilogramPerSecond, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MegagramPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.MegagramPerDay)); - unitConverter.SetConversionFunction(MassFlowUnit.MegagramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlowUnit.MegagramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MegapoundPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.MegapoundPerDay)); - unitConverter.SetConversionFunction(MassFlowUnit.MegapoundPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlowUnit.MegapoundPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MegapoundPerHour, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.MegapoundPerHour)); - unitConverter.SetConversionFunction(MassFlowUnit.MegapoundPerHour, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlowUnit.MegapoundPerHour, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MegapoundPerMinute, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.MegapoundPerMinute)); - unitConverter.SetConversionFunction(MassFlowUnit.MegapoundPerMinute, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlowUnit.MegapoundPerMinute, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MicrogramPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.MicrogramPerDay)); - unitConverter.SetConversionFunction(MassFlowUnit.MicrogramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlowUnit.MicrogramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MicrogramPerSecond, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.MicrogramPerSecond)); - unitConverter.SetConversionFunction(MassFlowUnit.MicrogramPerSecond, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlowUnit.MicrogramPerSecond, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MilligramPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.MilligramPerDay)); - unitConverter.SetConversionFunction(MassFlowUnit.MilligramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlowUnit.MilligramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MilligramPerSecond, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.MilligramPerSecond)); - unitConverter.SetConversionFunction(MassFlowUnit.MilligramPerSecond, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlowUnit.MilligramPerSecond, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.NanogramPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.NanogramPerDay)); - unitConverter.SetConversionFunction(MassFlowUnit.NanogramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlowUnit.NanogramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.NanogramPerSecond, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.NanogramPerSecond)); - unitConverter.SetConversionFunction(MassFlowUnit.NanogramPerSecond, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlowUnit.NanogramPerSecond, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.PoundPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.PoundPerDay)); - unitConverter.SetConversionFunction(MassFlowUnit.PoundPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlowUnit.PoundPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.PoundPerHour, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.PoundPerHour)); - unitConverter.SetConversionFunction(MassFlowUnit.PoundPerHour, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlowUnit.PoundPerHour, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.PoundPerMinute, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.PoundPerMinute)); - unitConverter.SetConversionFunction(MassFlowUnit.PoundPerMinute, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlowUnit.PoundPerMinute, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.ShortTonPerHour, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.ShortTonPerHour)); - unitConverter.SetConversionFunction(MassFlowUnit.ShortTonPerHour, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlowUnit.ShortTonPerHour, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.TonnePerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.TonnePerDay)); - unitConverter.SetConversionFunction(MassFlowUnit.TonnePerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlowUnit.TonnePerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.TonnePerHour, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.TonnePerHour)); - unitConverter.SetConversionFunction(MassFlowUnit.TonnePerHour, MassFlow.BaseUnit, (q) => ((MassFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFlowUnit.TonnePerHour, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassFlux.BaseUnit, MassFluxUnit.GramPerSecondPerSquareMeter, (q) => ((MassFlux)q).ToUnit(MassFluxUnit.GramPerSecondPerSquareMeter)); - unitConverter.SetConversionFunction(MassFluxUnit.GramPerSecondPerSquareMeter, MassFlux.BaseUnit, (q) => ((MassFlux)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassFluxUnit.GramPerSecondPerSquareMeter, MassFlux.BaseUnit, (q) => ((MassFlux)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassFlux.BaseUnit, MassFlux.BaseUnit, (q) => q); unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.GramSquareCentimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.GramSquareCentimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.GramSquareCentimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.GramSquareCentimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.GramSquareDecimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.GramSquareDecimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.GramSquareDecimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.GramSquareDecimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.GramSquareMeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.GramSquareMeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.GramSquareMeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.GramSquareMeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.GramSquareMillimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.GramSquareMillimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.GramSquareMillimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.GramSquareMillimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilogramSquareCentimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.KilogramSquareCentimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilogramSquareCentimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilogramSquareCentimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilogramSquareDecimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.KilogramSquareDecimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilogramSquareDecimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilogramSquareDecimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertia.BaseUnit, (q) => q); unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilogramSquareMillimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.KilogramSquareMillimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilogramSquareMillimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilogramSquareMillimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilotonneSquareCentimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.KilotonneSquareCentimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilotonneSquareCentimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilotonneSquareCentimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilotonneSquareDecimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.KilotonneSquareDecimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilotonneSquareDecimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilotonneSquareDecimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilotonneSquareMeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.KilotonneSquareMeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilotonneSquareMeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilotonneSquareMeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilotonneSquareMilimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.KilotonneSquareMilimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilotonneSquareMilimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilotonneSquareMilimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MegatonneSquareCentimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.MegatonneSquareCentimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MegatonneSquareCentimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MegatonneSquareCentimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MegatonneSquareDecimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.MegatonneSquareDecimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MegatonneSquareDecimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MegatonneSquareDecimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MegatonneSquareMeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.MegatonneSquareMeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MegatonneSquareMeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MegatonneSquareMeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MegatonneSquareMilimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.MegatonneSquareMilimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MegatonneSquareMilimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MegatonneSquareMilimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MilligramSquareCentimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.MilligramSquareCentimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MilligramSquareCentimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MilligramSquareCentimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MilligramSquareDecimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.MilligramSquareDecimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MilligramSquareDecimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MilligramSquareDecimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MilligramSquareMeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.MilligramSquareMeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MilligramSquareMeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MilligramSquareMeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MilligramSquareMillimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.MilligramSquareMillimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MilligramSquareMillimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MilligramSquareMillimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.PoundSquareFoot, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.PoundSquareFoot)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.PoundSquareFoot, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.PoundSquareFoot, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.PoundSquareInch, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.PoundSquareInch)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.PoundSquareInch, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.PoundSquareInch, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.SlugSquareFoot, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.SlugSquareFoot)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.SlugSquareFoot, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.SlugSquareFoot, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.SlugSquareInch, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.SlugSquareInch)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.SlugSquareInch, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.SlugSquareInch, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.TonneSquareCentimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.TonneSquareCentimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.TonneSquareCentimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.TonneSquareCentimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.TonneSquareDecimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.TonneSquareDecimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.TonneSquareDecimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.TonneSquareDecimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.TonneSquareMeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.TonneSquareMeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.TonneSquareMeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.TonneSquareMeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.TonneSquareMilimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.TonneSquareMilimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.TonneSquareMilimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.TonneSquareMilimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); unitConverter.SetConversionFunction(MolarEnergy.BaseUnit, MolarEnergy.BaseUnit, (q) => q); unitConverter.SetConversionFunction(MolarEnergy.BaseUnit, MolarEnergyUnit.KilojoulePerMole, (q) => ((MolarEnergy)q).ToUnit(MolarEnergyUnit.KilojoulePerMole)); - unitConverter.SetConversionFunction(MolarEnergyUnit.KilojoulePerMole, MolarEnergy.BaseUnit, (q) => ((MolarEnergy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarEnergyUnit.KilojoulePerMole, MolarEnergy.BaseUnit, (q) => ((MolarEnergy)q).ToBaseUnit()); unitConverter.SetConversionFunction(MolarEnergy.BaseUnit, MolarEnergyUnit.MegajoulePerMole, (q) => ((MolarEnergy)q).ToUnit(MolarEnergyUnit.MegajoulePerMole)); - unitConverter.SetConversionFunction(MolarEnergyUnit.MegajoulePerMole, MolarEnergy.BaseUnit, (q) => ((MolarEnergy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarEnergyUnit.MegajoulePerMole, MolarEnergy.BaseUnit, (q) => ((MolarEnergy)q).ToBaseUnit()); unitConverter.SetConversionFunction(MolarEntropy.BaseUnit, MolarEntropy.BaseUnit, (q) => q); unitConverter.SetConversionFunction(MolarEntropy.BaseUnit, MolarEntropyUnit.KilojoulePerMoleKelvin, (q) => ((MolarEntropy)q).ToUnit(MolarEntropyUnit.KilojoulePerMoleKelvin)); - unitConverter.SetConversionFunction(MolarEntropyUnit.KilojoulePerMoleKelvin, MolarEntropy.BaseUnit, (q) => ((MolarEntropy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarEntropyUnit.KilojoulePerMoleKelvin, MolarEntropy.BaseUnit, (q) => ((MolarEntropy)q).ToBaseUnit()); unitConverter.SetConversionFunction(MolarEntropy.BaseUnit, MolarEntropyUnit.MegajoulePerMoleKelvin, (q) => ((MolarEntropy)q).ToUnit(MolarEntropyUnit.MegajoulePerMoleKelvin)); - unitConverter.SetConversionFunction(MolarEntropyUnit.MegajoulePerMoleKelvin, MolarEntropy.BaseUnit, (q) => ((MolarEntropy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarEntropyUnit.MegajoulePerMoleKelvin, MolarEntropy.BaseUnit, (q) => ((MolarEntropy)q).ToBaseUnit()); unitConverter.SetConversionFunction(Molarity.BaseUnit, MolarityUnit.CentimolesPerLiter, (q) => ((Molarity)q).ToUnit(MolarityUnit.CentimolesPerLiter)); - unitConverter.SetConversionFunction(MolarityUnit.CentimolesPerLiter, Molarity.BaseUnit, (q) => ((Molarity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarityUnit.CentimolesPerLiter, Molarity.BaseUnit, (q) => ((Molarity)q).ToBaseUnit()); unitConverter.SetConversionFunction(Molarity.BaseUnit, MolarityUnit.DecimolesPerLiter, (q) => ((Molarity)q).ToUnit(MolarityUnit.DecimolesPerLiter)); - unitConverter.SetConversionFunction(MolarityUnit.DecimolesPerLiter, Molarity.BaseUnit, (q) => ((Molarity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarityUnit.DecimolesPerLiter, Molarity.BaseUnit, (q) => ((Molarity)q).ToBaseUnit()); unitConverter.SetConversionFunction(Molarity.BaseUnit, MolarityUnit.MicromolesPerLiter, (q) => ((Molarity)q).ToUnit(MolarityUnit.MicromolesPerLiter)); - unitConverter.SetConversionFunction(MolarityUnit.MicromolesPerLiter, Molarity.BaseUnit, (q) => ((Molarity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarityUnit.MicromolesPerLiter, Molarity.BaseUnit, (q) => ((Molarity)q).ToBaseUnit()); unitConverter.SetConversionFunction(Molarity.BaseUnit, MolarityUnit.MillimolesPerLiter, (q) => ((Molarity)q).ToUnit(MolarityUnit.MillimolesPerLiter)); - unitConverter.SetConversionFunction(MolarityUnit.MillimolesPerLiter, Molarity.BaseUnit, (q) => ((Molarity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarityUnit.MillimolesPerLiter, Molarity.BaseUnit, (q) => ((Molarity)q).ToBaseUnit()); unitConverter.SetConversionFunction(Molarity.BaseUnit, Molarity.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Molarity.BaseUnit, MolarityUnit.MolesPerLiter, (q) => ((Molarity)q).ToUnit(MolarityUnit.MolesPerLiter)); - unitConverter.SetConversionFunction(MolarityUnit.MolesPerLiter, Molarity.BaseUnit, (q) => ((Molarity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarityUnit.MolesPerLiter, Molarity.BaseUnit, (q) => ((Molarity)q).ToBaseUnit()); unitConverter.SetConversionFunction(Molarity.BaseUnit, MolarityUnit.NanomolesPerLiter, (q) => ((Molarity)q).ToUnit(MolarityUnit.NanomolesPerLiter)); - unitConverter.SetConversionFunction(MolarityUnit.NanomolesPerLiter, Molarity.BaseUnit, (q) => ((Molarity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarityUnit.NanomolesPerLiter, Molarity.BaseUnit, (q) => ((Molarity)q).ToBaseUnit()); unitConverter.SetConversionFunction(Molarity.BaseUnit, MolarityUnit.PicomolesPerLiter, (q) => ((Molarity)q).ToUnit(MolarityUnit.PicomolesPerLiter)); - unitConverter.SetConversionFunction(MolarityUnit.PicomolesPerLiter, Molarity.BaseUnit, (q) => ((Molarity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarityUnit.PicomolesPerLiter, Molarity.BaseUnit, (q) => ((Molarity)q).ToBaseUnit()); unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.CentigramPerMole, (q) => ((MolarMass)q).ToUnit(MolarMassUnit.CentigramPerMole)); - unitConverter.SetConversionFunction(MolarMassUnit.CentigramPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarMassUnit.CentigramPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).ToBaseUnit()); unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.DecagramPerMole, (q) => ((MolarMass)q).ToUnit(MolarMassUnit.DecagramPerMole)); - unitConverter.SetConversionFunction(MolarMassUnit.DecagramPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarMassUnit.DecagramPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).ToBaseUnit()); unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.DecigramPerMole, (q) => ((MolarMass)q).ToUnit(MolarMassUnit.DecigramPerMole)); - unitConverter.SetConversionFunction(MolarMassUnit.DecigramPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarMassUnit.DecigramPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).ToBaseUnit()); unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.GramPerMole, (q) => ((MolarMass)q).ToUnit(MolarMassUnit.GramPerMole)); - unitConverter.SetConversionFunction(MolarMassUnit.GramPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarMassUnit.GramPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).ToBaseUnit()); unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.HectogramPerMole, (q) => ((MolarMass)q).ToUnit(MolarMassUnit.HectogramPerMole)); - unitConverter.SetConversionFunction(MolarMassUnit.HectogramPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarMassUnit.HectogramPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).ToBaseUnit()); unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMass.BaseUnit, (q) => q); unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.KilopoundPerMole, (q) => ((MolarMass)q).ToUnit(MolarMassUnit.KilopoundPerMole)); - unitConverter.SetConversionFunction(MolarMassUnit.KilopoundPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarMassUnit.KilopoundPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).ToBaseUnit()); unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.MegapoundPerMole, (q) => ((MolarMass)q).ToUnit(MolarMassUnit.MegapoundPerMole)); - unitConverter.SetConversionFunction(MolarMassUnit.MegapoundPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarMassUnit.MegapoundPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).ToBaseUnit()); unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.MicrogramPerMole, (q) => ((MolarMass)q).ToUnit(MolarMassUnit.MicrogramPerMole)); - unitConverter.SetConversionFunction(MolarMassUnit.MicrogramPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarMassUnit.MicrogramPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).ToBaseUnit()); unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.MilligramPerMole, (q) => ((MolarMass)q).ToUnit(MolarMassUnit.MilligramPerMole)); - unitConverter.SetConversionFunction(MolarMassUnit.MilligramPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarMassUnit.MilligramPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).ToBaseUnit()); unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.NanogramPerMole, (q) => ((MolarMass)q).ToUnit(MolarMassUnit.NanogramPerMole)); - unitConverter.SetConversionFunction(MolarMassUnit.NanogramPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarMassUnit.NanogramPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).ToBaseUnit()); unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.PoundPerMole, (q) => ((MolarMass)q).ToUnit(MolarMassUnit.PoundPerMole)); - unitConverter.SetConversionFunction(MolarMassUnit.PoundPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).AsBaseUnit()); + unitConverter.SetConversionFunction(MolarMassUnit.PoundPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).ToBaseUnit()); unitConverter.SetConversionFunction(Permeability.BaseUnit, Permeability.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Permittivity.BaseUnit, Permittivity.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.BoilerHorsepower, (q) => ((Power)q).ToUnit(PowerUnit.BoilerHorsepower)); - unitConverter.SetConversionFunction(PowerUnit.BoilerHorsepower, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerUnit.BoilerHorsepower, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.BritishThermalUnitPerHour, (q) => ((Power)q).ToUnit(PowerUnit.BritishThermalUnitPerHour)); - unitConverter.SetConversionFunction(PowerUnit.BritishThermalUnitPerHour, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerUnit.BritishThermalUnitPerHour, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Decawatt, (q) => ((Power)q).ToUnit(PowerUnit.Decawatt)); - unitConverter.SetConversionFunction(PowerUnit.Decawatt, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerUnit.Decawatt, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Deciwatt, (q) => ((Power)q).ToUnit(PowerUnit.Deciwatt)); - unitConverter.SetConversionFunction(PowerUnit.Deciwatt, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerUnit.Deciwatt, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.ElectricalHorsepower, (q) => ((Power)q).ToUnit(PowerUnit.ElectricalHorsepower)); - unitConverter.SetConversionFunction(PowerUnit.ElectricalHorsepower, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerUnit.ElectricalHorsepower, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Femtowatt, (q) => ((Power)q).ToUnit(PowerUnit.Femtowatt)); - unitConverter.SetConversionFunction(PowerUnit.Femtowatt, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerUnit.Femtowatt, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Gigawatt, (q) => ((Power)q).ToUnit(PowerUnit.Gigawatt)); - unitConverter.SetConversionFunction(PowerUnit.Gigawatt, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerUnit.Gigawatt, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.HydraulicHorsepower, (q) => ((Power)q).ToUnit(PowerUnit.HydraulicHorsepower)); - unitConverter.SetConversionFunction(PowerUnit.HydraulicHorsepower, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerUnit.HydraulicHorsepower, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.KilobritishThermalUnitPerHour, (q) => ((Power)q).ToUnit(PowerUnit.KilobritishThermalUnitPerHour)); - unitConverter.SetConversionFunction(PowerUnit.KilobritishThermalUnitPerHour, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerUnit.KilobritishThermalUnitPerHour, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Kilowatt, (q) => ((Power)q).ToUnit(PowerUnit.Kilowatt)); - unitConverter.SetConversionFunction(PowerUnit.Kilowatt, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerUnit.Kilowatt, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.MechanicalHorsepower, (q) => ((Power)q).ToUnit(PowerUnit.MechanicalHorsepower)); - unitConverter.SetConversionFunction(PowerUnit.MechanicalHorsepower, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerUnit.MechanicalHorsepower, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Megawatt, (q) => ((Power)q).ToUnit(PowerUnit.Megawatt)); - unitConverter.SetConversionFunction(PowerUnit.Megawatt, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerUnit.Megawatt, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.MetricHorsepower, (q) => ((Power)q).ToUnit(PowerUnit.MetricHorsepower)); - unitConverter.SetConversionFunction(PowerUnit.MetricHorsepower, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerUnit.MetricHorsepower, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Microwatt, (q) => ((Power)q).ToUnit(PowerUnit.Microwatt)); - unitConverter.SetConversionFunction(PowerUnit.Microwatt, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerUnit.Microwatt, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Milliwatt, (q) => ((Power)q).ToUnit(PowerUnit.Milliwatt)); - unitConverter.SetConversionFunction(PowerUnit.Milliwatt, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerUnit.Milliwatt, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Nanowatt, (q) => ((Power)q).ToUnit(PowerUnit.Nanowatt)); - unitConverter.SetConversionFunction(PowerUnit.Nanowatt, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerUnit.Nanowatt, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Petawatt, (q) => ((Power)q).ToUnit(PowerUnit.Petawatt)); - unitConverter.SetConversionFunction(PowerUnit.Petawatt, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerUnit.Petawatt, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Picowatt, (q) => ((Power)q).ToUnit(PowerUnit.Picowatt)); - unitConverter.SetConversionFunction(PowerUnit.Picowatt, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerUnit.Picowatt, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Terawatt, (q) => ((Power)q).ToUnit(PowerUnit.Terawatt)); - unitConverter.SetConversionFunction(PowerUnit.Terawatt, Power.BaseUnit, (q) => ((Power)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerUnit.Terawatt, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); unitConverter.SetConversionFunction(Power.BaseUnit, Power.BaseUnit, (q) => q); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.DecawattPerCubicFoot, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.DecawattPerCubicFoot)); - unitConverter.SetConversionFunction(PowerDensityUnit.DecawattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.DecawattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.DecawattPerCubicInch, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.DecawattPerCubicInch)); - unitConverter.SetConversionFunction(PowerDensityUnit.DecawattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.DecawattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.DecawattPerCubicMeter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.DecawattPerCubicMeter)); - unitConverter.SetConversionFunction(PowerDensityUnit.DecawattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.DecawattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.DecawattPerLiter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.DecawattPerLiter)); - unitConverter.SetConversionFunction(PowerDensityUnit.DecawattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.DecawattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.DeciwattPerCubicFoot, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.DeciwattPerCubicFoot)); - unitConverter.SetConversionFunction(PowerDensityUnit.DeciwattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.DeciwattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.DeciwattPerCubicInch, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.DeciwattPerCubicInch)); - unitConverter.SetConversionFunction(PowerDensityUnit.DeciwattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.DeciwattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.DeciwattPerCubicMeter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.DeciwattPerCubicMeter)); - unitConverter.SetConversionFunction(PowerDensityUnit.DeciwattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.DeciwattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.DeciwattPerLiter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.DeciwattPerLiter)); - unitConverter.SetConversionFunction(PowerDensityUnit.DeciwattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.DeciwattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.GigawattPerCubicFoot, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.GigawattPerCubicFoot)); - unitConverter.SetConversionFunction(PowerDensityUnit.GigawattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.GigawattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.GigawattPerCubicInch, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.GigawattPerCubicInch)); - unitConverter.SetConversionFunction(PowerDensityUnit.GigawattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.GigawattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.GigawattPerCubicMeter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.GigawattPerCubicMeter)); - unitConverter.SetConversionFunction(PowerDensityUnit.GigawattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.GigawattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.GigawattPerLiter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.GigawattPerLiter)); - unitConverter.SetConversionFunction(PowerDensityUnit.GigawattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.GigawattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.KilowattPerCubicFoot, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.KilowattPerCubicFoot)); - unitConverter.SetConversionFunction(PowerDensityUnit.KilowattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.KilowattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.KilowattPerCubicInch, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.KilowattPerCubicInch)); - unitConverter.SetConversionFunction(PowerDensityUnit.KilowattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.KilowattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.KilowattPerCubicMeter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.KilowattPerCubicMeter)); - unitConverter.SetConversionFunction(PowerDensityUnit.KilowattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.KilowattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.KilowattPerLiter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.KilowattPerLiter)); - unitConverter.SetConversionFunction(PowerDensityUnit.KilowattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.KilowattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MegawattPerCubicFoot, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MegawattPerCubicFoot)); - unitConverter.SetConversionFunction(PowerDensityUnit.MegawattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.MegawattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MegawattPerCubicInch, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MegawattPerCubicInch)); - unitConverter.SetConversionFunction(PowerDensityUnit.MegawattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.MegawattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MegawattPerCubicMeter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MegawattPerCubicMeter)); - unitConverter.SetConversionFunction(PowerDensityUnit.MegawattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.MegawattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MegawattPerLiter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MegawattPerLiter)); - unitConverter.SetConversionFunction(PowerDensityUnit.MegawattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.MegawattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MicrowattPerCubicFoot, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MicrowattPerCubicFoot)); - unitConverter.SetConversionFunction(PowerDensityUnit.MicrowattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.MicrowattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MicrowattPerCubicInch, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MicrowattPerCubicInch)); - unitConverter.SetConversionFunction(PowerDensityUnit.MicrowattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.MicrowattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MicrowattPerCubicMeter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MicrowattPerCubicMeter)); - unitConverter.SetConversionFunction(PowerDensityUnit.MicrowattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.MicrowattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MicrowattPerLiter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MicrowattPerLiter)); - unitConverter.SetConversionFunction(PowerDensityUnit.MicrowattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.MicrowattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MilliwattPerCubicFoot, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MilliwattPerCubicFoot)); - unitConverter.SetConversionFunction(PowerDensityUnit.MilliwattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.MilliwattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MilliwattPerCubicInch, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MilliwattPerCubicInch)); - unitConverter.SetConversionFunction(PowerDensityUnit.MilliwattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.MilliwattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MilliwattPerCubicMeter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MilliwattPerCubicMeter)); - unitConverter.SetConversionFunction(PowerDensityUnit.MilliwattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.MilliwattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MilliwattPerLiter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MilliwattPerLiter)); - unitConverter.SetConversionFunction(PowerDensityUnit.MilliwattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.MilliwattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.NanowattPerCubicFoot, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.NanowattPerCubicFoot)); - unitConverter.SetConversionFunction(PowerDensityUnit.NanowattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.NanowattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.NanowattPerCubicInch, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.NanowattPerCubicInch)); - unitConverter.SetConversionFunction(PowerDensityUnit.NanowattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.NanowattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.NanowattPerCubicMeter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.NanowattPerCubicMeter)); - unitConverter.SetConversionFunction(PowerDensityUnit.NanowattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.NanowattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.NanowattPerLiter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.NanowattPerLiter)); - unitConverter.SetConversionFunction(PowerDensityUnit.NanowattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.NanowattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.PicowattPerCubicFoot, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.PicowattPerCubicFoot)); - unitConverter.SetConversionFunction(PowerDensityUnit.PicowattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.PicowattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.PicowattPerCubicInch, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.PicowattPerCubicInch)); - unitConverter.SetConversionFunction(PowerDensityUnit.PicowattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.PicowattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.PicowattPerCubicMeter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.PicowattPerCubicMeter)); - unitConverter.SetConversionFunction(PowerDensityUnit.PicowattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.PicowattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.PicowattPerLiter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.PicowattPerLiter)); - unitConverter.SetConversionFunction(PowerDensityUnit.PicowattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.PicowattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.TerawattPerCubicFoot, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.TerawattPerCubicFoot)); - unitConverter.SetConversionFunction(PowerDensityUnit.TerawattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.TerawattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.TerawattPerCubicInch, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.TerawattPerCubicInch)); - unitConverter.SetConversionFunction(PowerDensityUnit.TerawattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.TerawattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.TerawattPerCubicMeter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.TerawattPerCubicMeter)); - unitConverter.SetConversionFunction(PowerDensityUnit.TerawattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.TerawattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.TerawattPerLiter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.TerawattPerLiter)); - unitConverter.SetConversionFunction(PowerDensityUnit.TerawattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.TerawattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.WattPerCubicFoot, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.WattPerCubicFoot)); - unitConverter.SetConversionFunction(PowerDensityUnit.WattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.WattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.WattPerCubicInch, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.WattPerCubicInch)); - unitConverter.SetConversionFunction(PowerDensityUnit.WattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.WattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensity.BaseUnit, (q) => q); unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.WattPerLiter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.WattPerLiter)); - unitConverter.SetConversionFunction(PowerDensityUnit.WattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerDensityUnit.WattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerRatio.BaseUnit, PowerRatioUnit.DecibelMilliwatt, (q) => ((PowerRatio)q).ToUnit(PowerRatioUnit.DecibelMilliwatt)); - unitConverter.SetConversionFunction(PowerRatioUnit.DecibelMilliwatt, PowerRatio.BaseUnit, (q) => ((PowerRatio)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PowerRatioUnit.DecibelMilliwatt, PowerRatio.BaseUnit, (q) => ((PowerRatio)q).ToBaseUnit()); unitConverter.SetConversionFunction(PowerRatio.BaseUnit, PowerRatio.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Atmosphere, (q) => ((Pressure)q).ToUnit(PressureUnit.Atmosphere)); - unitConverter.SetConversionFunction(PressureUnit.Atmosphere, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.Atmosphere, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Bar, (q) => ((Pressure)q).ToUnit(PressureUnit.Bar)); - unitConverter.SetConversionFunction(PressureUnit.Bar, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.Bar, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Centibar, (q) => ((Pressure)q).ToUnit(PressureUnit.Centibar)); - unitConverter.SetConversionFunction(PressureUnit.Centibar, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.Centibar, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Decapascal, (q) => ((Pressure)q).ToUnit(PressureUnit.Decapascal)); - unitConverter.SetConversionFunction(PressureUnit.Decapascal, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.Decapascal, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Decibar, (q) => ((Pressure)q).ToUnit(PressureUnit.Decibar)); - unitConverter.SetConversionFunction(PressureUnit.Decibar, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.Decibar, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.DynePerSquareCentimeter, (q) => ((Pressure)q).ToUnit(PressureUnit.DynePerSquareCentimeter)); - unitConverter.SetConversionFunction(PressureUnit.DynePerSquareCentimeter, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.DynePerSquareCentimeter, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.FootOfHead, (q) => ((Pressure)q).ToUnit(PressureUnit.FootOfHead)); - unitConverter.SetConversionFunction(PressureUnit.FootOfHead, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.FootOfHead, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Gigapascal, (q) => ((Pressure)q).ToUnit(PressureUnit.Gigapascal)); - unitConverter.SetConversionFunction(PressureUnit.Gigapascal, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.Gigapascal, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Hectopascal, (q) => ((Pressure)q).ToUnit(PressureUnit.Hectopascal)); - unitConverter.SetConversionFunction(PressureUnit.Hectopascal, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.Hectopascal, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.InchOfMercury, (q) => ((Pressure)q).ToUnit(PressureUnit.InchOfMercury)); - unitConverter.SetConversionFunction(PressureUnit.InchOfMercury, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.InchOfMercury, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.InchOfWaterColumn, (q) => ((Pressure)q).ToUnit(PressureUnit.InchOfWaterColumn)); - unitConverter.SetConversionFunction(PressureUnit.InchOfWaterColumn, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.InchOfWaterColumn, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Kilobar, (q) => ((Pressure)q).ToUnit(PressureUnit.Kilobar)); - unitConverter.SetConversionFunction(PressureUnit.Kilobar, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.Kilobar, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.KilogramForcePerSquareCentimeter, (q) => ((Pressure)q).ToUnit(PressureUnit.KilogramForcePerSquareCentimeter)); - unitConverter.SetConversionFunction(PressureUnit.KilogramForcePerSquareCentimeter, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.KilogramForcePerSquareCentimeter, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.KilogramForcePerSquareMeter, (q) => ((Pressure)q).ToUnit(PressureUnit.KilogramForcePerSquareMeter)); - unitConverter.SetConversionFunction(PressureUnit.KilogramForcePerSquareMeter, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.KilogramForcePerSquareMeter, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.KilogramForcePerSquareMillimeter, (q) => ((Pressure)q).ToUnit(PressureUnit.KilogramForcePerSquareMillimeter)); - unitConverter.SetConversionFunction(PressureUnit.KilogramForcePerSquareMillimeter, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.KilogramForcePerSquareMillimeter, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.KilonewtonPerSquareCentimeter, (q) => ((Pressure)q).ToUnit(PressureUnit.KilonewtonPerSquareCentimeter)); - unitConverter.SetConversionFunction(PressureUnit.KilonewtonPerSquareCentimeter, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.KilonewtonPerSquareCentimeter, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.KilonewtonPerSquareMeter, (q) => ((Pressure)q).ToUnit(PressureUnit.KilonewtonPerSquareMeter)); - unitConverter.SetConversionFunction(PressureUnit.KilonewtonPerSquareMeter, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.KilonewtonPerSquareMeter, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.KilonewtonPerSquareMillimeter, (q) => ((Pressure)q).ToUnit(PressureUnit.KilonewtonPerSquareMillimeter)); - unitConverter.SetConversionFunction(PressureUnit.KilonewtonPerSquareMillimeter, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.KilonewtonPerSquareMillimeter, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Kilopascal, (q) => ((Pressure)q).ToUnit(PressureUnit.Kilopascal)); - unitConverter.SetConversionFunction(PressureUnit.Kilopascal, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.Kilopascal, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.KilopoundForcePerSquareFoot, (q) => ((Pressure)q).ToUnit(PressureUnit.KilopoundForcePerSquareFoot)); - unitConverter.SetConversionFunction(PressureUnit.KilopoundForcePerSquareFoot, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.KilopoundForcePerSquareFoot, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.KilopoundForcePerSquareInch, (q) => ((Pressure)q).ToUnit(PressureUnit.KilopoundForcePerSquareInch)); - unitConverter.SetConversionFunction(PressureUnit.KilopoundForcePerSquareInch, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.KilopoundForcePerSquareInch, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Megabar, (q) => ((Pressure)q).ToUnit(PressureUnit.Megabar)); - unitConverter.SetConversionFunction(PressureUnit.Megabar, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.Megabar, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.MeganewtonPerSquareMeter, (q) => ((Pressure)q).ToUnit(PressureUnit.MeganewtonPerSquareMeter)); - unitConverter.SetConversionFunction(PressureUnit.MeganewtonPerSquareMeter, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.MeganewtonPerSquareMeter, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Megapascal, (q) => ((Pressure)q).ToUnit(PressureUnit.Megapascal)); - unitConverter.SetConversionFunction(PressureUnit.Megapascal, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.Megapascal, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.MeterOfHead, (q) => ((Pressure)q).ToUnit(PressureUnit.MeterOfHead)); - unitConverter.SetConversionFunction(PressureUnit.MeterOfHead, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.MeterOfHead, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Microbar, (q) => ((Pressure)q).ToUnit(PressureUnit.Microbar)); - unitConverter.SetConversionFunction(PressureUnit.Microbar, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.Microbar, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Micropascal, (q) => ((Pressure)q).ToUnit(PressureUnit.Micropascal)); - unitConverter.SetConversionFunction(PressureUnit.Micropascal, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.Micropascal, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Millibar, (q) => ((Pressure)q).ToUnit(PressureUnit.Millibar)); - unitConverter.SetConversionFunction(PressureUnit.Millibar, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.Millibar, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.MillimeterOfMercury, (q) => ((Pressure)q).ToUnit(PressureUnit.MillimeterOfMercury)); - unitConverter.SetConversionFunction(PressureUnit.MillimeterOfMercury, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.MillimeterOfMercury, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Millipascal, (q) => ((Pressure)q).ToUnit(PressureUnit.Millipascal)); - unitConverter.SetConversionFunction(PressureUnit.Millipascal, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.Millipascal, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.NewtonPerSquareCentimeter, (q) => ((Pressure)q).ToUnit(PressureUnit.NewtonPerSquareCentimeter)); - unitConverter.SetConversionFunction(PressureUnit.NewtonPerSquareCentimeter, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.NewtonPerSquareCentimeter, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.NewtonPerSquareMeter, (q) => ((Pressure)q).ToUnit(PressureUnit.NewtonPerSquareMeter)); - unitConverter.SetConversionFunction(PressureUnit.NewtonPerSquareMeter, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.NewtonPerSquareMeter, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.NewtonPerSquareMillimeter, (q) => ((Pressure)q).ToUnit(PressureUnit.NewtonPerSquareMillimeter)); - unitConverter.SetConversionFunction(PressureUnit.NewtonPerSquareMillimeter, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.NewtonPerSquareMillimeter, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, Pressure.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.PoundForcePerSquareFoot, (q) => ((Pressure)q).ToUnit(PressureUnit.PoundForcePerSquareFoot)); - unitConverter.SetConversionFunction(PressureUnit.PoundForcePerSquareFoot, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.PoundForcePerSquareFoot, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.PoundForcePerSquareInch, (q) => ((Pressure)q).ToUnit(PressureUnit.PoundForcePerSquareInch)); - unitConverter.SetConversionFunction(PressureUnit.PoundForcePerSquareInch, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.PoundForcePerSquareInch, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.PoundPerInchSecondSquared, (q) => ((Pressure)q).ToUnit(PressureUnit.PoundPerInchSecondSquared)); - unitConverter.SetConversionFunction(PressureUnit.PoundPerInchSecondSquared, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.PoundPerInchSecondSquared, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.TechnicalAtmosphere, (q) => ((Pressure)q).ToUnit(PressureUnit.TechnicalAtmosphere)); - unitConverter.SetConversionFunction(PressureUnit.TechnicalAtmosphere, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.TechnicalAtmosphere, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.TonneForcePerSquareCentimeter, (q) => ((Pressure)q).ToUnit(PressureUnit.TonneForcePerSquareCentimeter)); - unitConverter.SetConversionFunction(PressureUnit.TonneForcePerSquareCentimeter, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.TonneForcePerSquareCentimeter, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.TonneForcePerSquareMeter, (q) => ((Pressure)q).ToUnit(PressureUnit.TonneForcePerSquareMeter)); - unitConverter.SetConversionFunction(PressureUnit.TonneForcePerSquareMeter, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.TonneForcePerSquareMeter, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.TonneForcePerSquareMillimeter, (q) => ((Pressure)q).ToUnit(PressureUnit.TonneForcePerSquareMillimeter)); - unitConverter.SetConversionFunction(PressureUnit.TonneForcePerSquareMillimeter, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.TonneForcePerSquareMillimeter, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Torr, (q) => ((Pressure)q).ToUnit(PressureUnit.Torr)); - unitConverter.SetConversionFunction(PressureUnit.Torr, Pressure.BaseUnit, (q) => ((Pressure)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureUnit.Torr, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.AtmospherePerSecond, (q) => ((PressureChangeRate)q).ToUnit(PressureChangeRateUnit.AtmospherePerSecond)); - unitConverter.SetConversionFunction(PressureChangeRateUnit.AtmospherePerSecond, PressureChangeRate.BaseUnit, (q) => ((PressureChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureChangeRateUnit.AtmospherePerSecond, PressureChangeRate.BaseUnit, (q) => ((PressureChangeRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.KilopascalPerMinute, (q) => ((PressureChangeRate)q).ToUnit(PressureChangeRateUnit.KilopascalPerMinute)); - unitConverter.SetConversionFunction(PressureChangeRateUnit.KilopascalPerMinute, PressureChangeRate.BaseUnit, (q) => ((PressureChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureChangeRateUnit.KilopascalPerMinute, PressureChangeRate.BaseUnit, (q) => ((PressureChangeRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.KilopascalPerSecond, (q) => ((PressureChangeRate)q).ToUnit(PressureChangeRateUnit.KilopascalPerSecond)); - unitConverter.SetConversionFunction(PressureChangeRateUnit.KilopascalPerSecond, PressureChangeRate.BaseUnit, (q) => ((PressureChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureChangeRateUnit.KilopascalPerSecond, PressureChangeRate.BaseUnit, (q) => ((PressureChangeRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.MegapascalPerMinute, (q) => ((PressureChangeRate)q).ToUnit(PressureChangeRateUnit.MegapascalPerMinute)); - unitConverter.SetConversionFunction(PressureChangeRateUnit.MegapascalPerMinute, PressureChangeRate.BaseUnit, (q) => ((PressureChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureChangeRateUnit.MegapascalPerMinute, PressureChangeRate.BaseUnit, (q) => ((PressureChangeRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.MegapascalPerSecond, (q) => ((PressureChangeRate)q).ToUnit(PressureChangeRateUnit.MegapascalPerSecond)); - unitConverter.SetConversionFunction(PressureChangeRateUnit.MegapascalPerSecond, PressureChangeRate.BaseUnit, (q) => ((PressureChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureChangeRateUnit.MegapascalPerSecond, PressureChangeRate.BaseUnit, (q) => ((PressureChangeRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.PascalPerMinute, (q) => ((PressureChangeRate)q).ToUnit(PressureChangeRateUnit.PascalPerMinute)); - unitConverter.SetConversionFunction(PressureChangeRateUnit.PascalPerMinute, PressureChangeRate.BaseUnit, (q) => ((PressureChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(PressureChangeRateUnit.PascalPerMinute, PressureChangeRate.BaseUnit, (q) => ((PressureChangeRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRate.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Ratio.BaseUnit, Ratio.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Ratio.BaseUnit, RatioUnit.PartPerBillion, (q) => ((Ratio)q).ToUnit(RatioUnit.PartPerBillion)); - unitConverter.SetConversionFunction(RatioUnit.PartPerBillion, Ratio.BaseUnit, (q) => ((Ratio)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RatioUnit.PartPerBillion, Ratio.BaseUnit, (q) => ((Ratio)q).ToBaseUnit()); unitConverter.SetConversionFunction(Ratio.BaseUnit, RatioUnit.PartPerMillion, (q) => ((Ratio)q).ToUnit(RatioUnit.PartPerMillion)); - unitConverter.SetConversionFunction(RatioUnit.PartPerMillion, Ratio.BaseUnit, (q) => ((Ratio)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RatioUnit.PartPerMillion, Ratio.BaseUnit, (q) => ((Ratio)q).ToBaseUnit()); unitConverter.SetConversionFunction(Ratio.BaseUnit, RatioUnit.PartPerThousand, (q) => ((Ratio)q).ToUnit(RatioUnit.PartPerThousand)); - unitConverter.SetConversionFunction(RatioUnit.PartPerThousand, Ratio.BaseUnit, (q) => ((Ratio)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RatioUnit.PartPerThousand, Ratio.BaseUnit, (q) => ((Ratio)q).ToBaseUnit()); unitConverter.SetConversionFunction(Ratio.BaseUnit, RatioUnit.PartPerTrillion, (q) => ((Ratio)q).ToUnit(RatioUnit.PartPerTrillion)); - unitConverter.SetConversionFunction(RatioUnit.PartPerTrillion, Ratio.BaseUnit, (q) => ((Ratio)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RatioUnit.PartPerTrillion, Ratio.BaseUnit, (q) => ((Ratio)q).ToBaseUnit()); unitConverter.SetConversionFunction(Ratio.BaseUnit, RatioUnit.Percent, (q) => ((Ratio)q).ToUnit(RatioUnit.Percent)); - unitConverter.SetConversionFunction(RatioUnit.Percent, Ratio.BaseUnit, (q) => ((Ratio)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RatioUnit.Percent, Ratio.BaseUnit, (q) => ((Ratio)q).ToBaseUnit()); unitConverter.SetConversionFunction(ReactiveEnergy.BaseUnit, ReactiveEnergyUnit.KilovoltampereReactiveHour, (q) => ((ReactiveEnergy)q).ToUnit(ReactiveEnergyUnit.KilovoltampereReactiveHour)); - unitConverter.SetConversionFunction(ReactiveEnergyUnit.KilovoltampereReactiveHour, ReactiveEnergy.BaseUnit, (q) => ((ReactiveEnergy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ReactiveEnergyUnit.KilovoltampereReactiveHour, ReactiveEnergy.BaseUnit, (q) => ((ReactiveEnergy)q).ToBaseUnit()); unitConverter.SetConversionFunction(ReactiveEnergy.BaseUnit, ReactiveEnergyUnit.MegavoltampereReactiveHour, (q) => ((ReactiveEnergy)q).ToUnit(ReactiveEnergyUnit.MegavoltampereReactiveHour)); - unitConverter.SetConversionFunction(ReactiveEnergyUnit.MegavoltampereReactiveHour, ReactiveEnergy.BaseUnit, (q) => ((ReactiveEnergy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ReactiveEnergyUnit.MegavoltampereReactiveHour, ReactiveEnergy.BaseUnit, (q) => ((ReactiveEnergy)q).ToBaseUnit()); unitConverter.SetConversionFunction(ReactiveEnergy.BaseUnit, ReactiveEnergy.BaseUnit, (q) => q); unitConverter.SetConversionFunction(ReactivePower.BaseUnit, ReactivePowerUnit.GigavoltampereReactive, (q) => ((ReactivePower)q).ToUnit(ReactivePowerUnit.GigavoltampereReactive)); - unitConverter.SetConversionFunction(ReactivePowerUnit.GigavoltampereReactive, ReactivePower.BaseUnit, (q) => ((ReactivePower)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ReactivePowerUnit.GigavoltampereReactive, ReactivePower.BaseUnit, (q) => ((ReactivePower)q).ToBaseUnit()); unitConverter.SetConversionFunction(ReactivePower.BaseUnit, ReactivePowerUnit.KilovoltampereReactive, (q) => ((ReactivePower)q).ToUnit(ReactivePowerUnit.KilovoltampereReactive)); - unitConverter.SetConversionFunction(ReactivePowerUnit.KilovoltampereReactive, ReactivePower.BaseUnit, (q) => ((ReactivePower)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ReactivePowerUnit.KilovoltampereReactive, ReactivePower.BaseUnit, (q) => ((ReactivePower)q).ToBaseUnit()); unitConverter.SetConversionFunction(ReactivePower.BaseUnit, ReactivePowerUnit.MegavoltampereReactive, (q) => ((ReactivePower)q).ToUnit(ReactivePowerUnit.MegavoltampereReactive)); - unitConverter.SetConversionFunction(ReactivePowerUnit.MegavoltampereReactive, ReactivePower.BaseUnit, (q) => ((ReactivePower)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ReactivePowerUnit.MegavoltampereReactive, ReactivePower.BaseUnit, (q) => ((ReactivePower)q).ToBaseUnit()); unitConverter.SetConversionFunction(ReactivePower.BaseUnit, ReactivePower.BaseUnit, (q) => q); unitConverter.SetConversionFunction(RotationalAcceleration.BaseUnit, RotationalAccelerationUnit.DegreePerSecondSquared, (q) => ((RotationalAcceleration)q).ToUnit(RotationalAccelerationUnit.DegreePerSecondSquared)); - unitConverter.SetConversionFunction(RotationalAccelerationUnit.DegreePerSecondSquared, RotationalAcceleration.BaseUnit, (q) => ((RotationalAcceleration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalAccelerationUnit.DegreePerSecondSquared, RotationalAcceleration.BaseUnit, (q) => ((RotationalAcceleration)q).ToBaseUnit()); unitConverter.SetConversionFunction(RotationalAcceleration.BaseUnit, RotationalAcceleration.BaseUnit, (q) => q); unitConverter.SetConversionFunction(RotationalAcceleration.BaseUnit, RotationalAccelerationUnit.RevolutionPerMinutePerSecond, (q) => ((RotationalAcceleration)q).ToUnit(RotationalAccelerationUnit.RevolutionPerMinutePerSecond)); - unitConverter.SetConversionFunction(RotationalAccelerationUnit.RevolutionPerMinutePerSecond, RotationalAcceleration.BaseUnit, (q) => ((RotationalAcceleration)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalAccelerationUnit.RevolutionPerMinutePerSecond, RotationalAcceleration.BaseUnit, (q) => ((RotationalAcceleration)q).ToBaseUnit()); unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.CentiradianPerSecond, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.CentiradianPerSecond)); - unitConverter.SetConversionFunction(RotationalSpeedUnit.CentiradianPerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeedUnit.CentiradianPerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).ToBaseUnit()); unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.DeciradianPerSecond, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.DeciradianPerSecond)); - unitConverter.SetConversionFunction(RotationalSpeedUnit.DeciradianPerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeedUnit.DeciradianPerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).ToBaseUnit()); unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.DegreePerMinute, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.DegreePerMinute)); - unitConverter.SetConversionFunction(RotationalSpeedUnit.DegreePerMinute, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeedUnit.DegreePerMinute, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).ToBaseUnit()); unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.DegreePerSecond, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.DegreePerSecond)); - unitConverter.SetConversionFunction(RotationalSpeedUnit.DegreePerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeedUnit.DegreePerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).ToBaseUnit()); unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.MicrodegreePerSecond, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.MicrodegreePerSecond)); - unitConverter.SetConversionFunction(RotationalSpeedUnit.MicrodegreePerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeedUnit.MicrodegreePerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).ToBaseUnit()); unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.MicroradianPerSecond, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.MicroradianPerSecond)); - unitConverter.SetConversionFunction(RotationalSpeedUnit.MicroradianPerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeedUnit.MicroradianPerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).ToBaseUnit()); unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.MillidegreePerSecond, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.MillidegreePerSecond)); - unitConverter.SetConversionFunction(RotationalSpeedUnit.MillidegreePerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeedUnit.MillidegreePerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).ToBaseUnit()); unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.MilliradianPerSecond, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.MilliradianPerSecond)); - unitConverter.SetConversionFunction(RotationalSpeedUnit.MilliradianPerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeedUnit.MilliradianPerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).ToBaseUnit()); unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.NanodegreePerSecond, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.NanodegreePerSecond)); - unitConverter.SetConversionFunction(RotationalSpeedUnit.NanodegreePerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeedUnit.NanodegreePerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).ToBaseUnit()); unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.NanoradianPerSecond, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.NanoradianPerSecond)); - unitConverter.SetConversionFunction(RotationalSpeedUnit.NanoradianPerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeedUnit.NanoradianPerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).ToBaseUnit()); unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeed.BaseUnit, (q) => q); unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.RevolutionPerMinute, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.RevolutionPerMinute)); - unitConverter.SetConversionFunction(RotationalSpeedUnit.RevolutionPerMinute, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeedUnit.RevolutionPerMinute, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).ToBaseUnit()); unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.RevolutionPerSecond, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.RevolutionPerSecond)); - unitConverter.SetConversionFunction(RotationalSpeedUnit.RevolutionPerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeedUnit.RevolutionPerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).ToBaseUnit()); unitConverter.SetConversionFunction(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.KilonewtonMeterPerRadian, (q) => ((RotationalStiffness)q).ToUnit(RotationalStiffnessUnit.KilonewtonMeterPerRadian)); - unitConverter.SetConversionFunction(RotationalStiffnessUnit.KilonewtonMeterPerRadian, RotationalStiffness.BaseUnit, (q) => ((RotationalStiffness)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalStiffnessUnit.KilonewtonMeterPerRadian, RotationalStiffness.BaseUnit, (q) => ((RotationalStiffness)q).ToBaseUnit()); unitConverter.SetConversionFunction(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.MeganewtonMeterPerRadian, (q) => ((RotationalStiffness)q).ToUnit(RotationalStiffnessUnit.MeganewtonMeterPerRadian)); - unitConverter.SetConversionFunction(RotationalStiffnessUnit.MeganewtonMeterPerRadian, RotationalStiffness.BaseUnit, (q) => ((RotationalStiffness)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalStiffnessUnit.MeganewtonMeterPerRadian, RotationalStiffness.BaseUnit, (q) => ((RotationalStiffness)q).ToBaseUnit()); unitConverter.SetConversionFunction(RotationalStiffness.BaseUnit, RotationalStiffness.BaseUnit, (q) => q); unitConverter.SetConversionFunction(RotationalStiffnessPerLength.BaseUnit, RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter, (q) => ((RotationalStiffnessPerLength)q).ToUnit(RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter)); - unitConverter.SetConversionFunction(RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter, RotationalStiffnessPerLength.BaseUnit, (q) => ((RotationalStiffnessPerLength)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter, RotationalStiffnessPerLength.BaseUnit, (q) => ((RotationalStiffnessPerLength)q).ToBaseUnit()); unitConverter.SetConversionFunction(RotationalStiffnessPerLength.BaseUnit, RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter, (q) => ((RotationalStiffnessPerLength)q).ToUnit(RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter)); - unitConverter.SetConversionFunction(RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter, RotationalStiffnessPerLength.BaseUnit, (q) => ((RotationalStiffnessPerLength)q).AsBaseUnit()); + unitConverter.SetConversionFunction(RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter, RotationalStiffnessPerLength.BaseUnit, (q) => ((RotationalStiffnessPerLength)q).ToBaseUnit()); unitConverter.SetConversionFunction(RotationalStiffnessPerLength.BaseUnit, RotationalStiffnessPerLength.BaseUnit, (q) => q); unitConverter.SetConversionFunction(SolidAngle.BaseUnit, SolidAngle.BaseUnit, (q) => q); unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergyUnit.BtuPerPound, (q) => ((SpecificEnergy)q).ToUnit(SpecificEnergyUnit.BtuPerPound)); - unitConverter.SetConversionFunction(SpecificEnergyUnit.BtuPerPound, SpecificEnergy.BaseUnit, (q) => ((SpecificEnergy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificEnergyUnit.BtuPerPound, SpecificEnergy.BaseUnit, (q) => ((SpecificEnergy)q).ToBaseUnit()); unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergyUnit.CaloriePerGram, (q) => ((SpecificEnergy)q).ToUnit(SpecificEnergyUnit.CaloriePerGram)); - unitConverter.SetConversionFunction(SpecificEnergyUnit.CaloriePerGram, SpecificEnergy.BaseUnit, (q) => ((SpecificEnergy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificEnergyUnit.CaloriePerGram, SpecificEnergy.BaseUnit, (q) => ((SpecificEnergy)q).ToBaseUnit()); unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergy.BaseUnit, (q) => q); unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergyUnit.KilocaloriePerGram, (q) => ((SpecificEnergy)q).ToUnit(SpecificEnergyUnit.KilocaloriePerGram)); - unitConverter.SetConversionFunction(SpecificEnergyUnit.KilocaloriePerGram, SpecificEnergy.BaseUnit, (q) => ((SpecificEnergy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificEnergyUnit.KilocaloriePerGram, SpecificEnergy.BaseUnit, (q) => ((SpecificEnergy)q).ToBaseUnit()); unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergyUnit.KilojoulePerKilogram, (q) => ((SpecificEnergy)q).ToUnit(SpecificEnergyUnit.KilojoulePerKilogram)); - unitConverter.SetConversionFunction(SpecificEnergyUnit.KilojoulePerKilogram, SpecificEnergy.BaseUnit, (q) => ((SpecificEnergy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificEnergyUnit.KilojoulePerKilogram, SpecificEnergy.BaseUnit, (q) => ((SpecificEnergy)q).ToBaseUnit()); unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergyUnit.KilowattHourPerKilogram, (q) => ((SpecificEnergy)q).ToUnit(SpecificEnergyUnit.KilowattHourPerKilogram)); - unitConverter.SetConversionFunction(SpecificEnergyUnit.KilowattHourPerKilogram, SpecificEnergy.BaseUnit, (q) => ((SpecificEnergy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificEnergyUnit.KilowattHourPerKilogram, SpecificEnergy.BaseUnit, (q) => ((SpecificEnergy)q).ToBaseUnit()); unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergyUnit.MegajoulePerKilogram, (q) => ((SpecificEnergy)q).ToUnit(SpecificEnergyUnit.MegajoulePerKilogram)); - unitConverter.SetConversionFunction(SpecificEnergyUnit.MegajoulePerKilogram, SpecificEnergy.BaseUnit, (q) => ((SpecificEnergy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificEnergyUnit.MegajoulePerKilogram, SpecificEnergy.BaseUnit, (q) => ((SpecificEnergy)q).ToBaseUnit()); unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergyUnit.MegawattHourPerKilogram, (q) => ((SpecificEnergy)q).ToUnit(SpecificEnergyUnit.MegawattHourPerKilogram)); - unitConverter.SetConversionFunction(SpecificEnergyUnit.MegawattHourPerKilogram, SpecificEnergy.BaseUnit, (q) => ((SpecificEnergy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificEnergyUnit.MegawattHourPerKilogram, SpecificEnergy.BaseUnit, (q) => ((SpecificEnergy)q).ToBaseUnit()); unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergyUnit.WattHourPerKilogram, (q) => ((SpecificEnergy)q).ToUnit(SpecificEnergyUnit.WattHourPerKilogram)); - unitConverter.SetConversionFunction(SpecificEnergyUnit.WattHourPerKilogram, SpecificEnergy.BaseUnit, (q) => ((SpecificEnergy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificEnergyUnit.WattHourPerKilogram, SpecificEnergy.BaseUnit, (q) => ((SpecificEnergy)q).ToBaseUnit()); unitConverter.SetConversionFunction(SpecificEntropy.BaseUnit, SpecificEntropyUnit.CaloriePerGramKelvin, (q) => ((SpecificEntropy)q).ToUnit(SpecificEntropyUnit.CaloriePerGramKelvin)); - unitConverter.SetConversionFunction(SpecificEntropyUnit.CaloriePerGramKelvin, SpecificEntropy.BaseUnit, (q) => ((SpecificEntropy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificEntropyUnit.CaloriePerGramKelvin, SpecificEntropy.BaseUnit, (q) => ((SpecificEntropy)q).ToBaseUnit()); unitConverter.SetConversionFunction(SpecificEntropy.BaseUnit, SpecificEntropyUnit.JoulePerKilogramDegreeCelsius, (q) => ((SpecificEntropy)q).ToUnit(SpecificEntropyUnit.JoulePerKilogramDegreeCelsius)); - unitConverter.SetConversionFunction(SpecificEntropyUnit.JoulePerKilogramDegreeCelsius, SpecificEntropy.BaseUnit, (q) => ((SpecificEntropy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificEntropyUnit.JoulePerKilogramDegreeCelsius, SpecificEntropy.BaseUnit, (q) => ((SpecificEntropy)q).ToBaseUnit()); unitConverter.SetConversionFunction(SpecificEntropy.BaseUnit, SpecificEntropy.BaseUnit, (q) => q); unitConverter.SetConversionFunction(SpecificEntropy.BaseUnit, SpecificEntropyUnit.KilocaloriePerGramKelvin, (q) => ((SpecificEntropy)q).ToUnit(SpecificEntropyUnit.KilocaloriePerGramKelvin)); - unitConverter.SetConversionFunction(SpecificEntropyUnit.KilocaloriePerGramKelvin, SpecificEntropy.BaseUnit, (q) => ((SpecificEntropy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificEntropyUnit.KilocaloriePerGramKelvin, SpecificEntropy.BaseUnit, (q) => ((SpecificEntropy)q).ToBaseUnit()); unitConverter.SetConversionFunction(SpecificEntropy.BaseUnit, SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius, (q) => ((SpecificEntropy)q).ToUnit(SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius)); - unitConverter.SetConversionFunction(SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius, SpecificEntropy.BaseUnit, (q) => ((SpecificEntropy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius, SpecificEntropy.BaseUnit, (q) => ((SpecificEntropy)q).ToBaseUnit()); unitConverter.SetConversionFunction(SpecificEntropy.BaseUnit, SpecificEntropyUnit.KilojoulePerKilogramKelvin, (q) => ((SpecificEntropy)q).ToUnit(SpecificEntropyUnit.KilojoulePerKilogramKelvin)); - unitConverter.SetConversionFunction(SpecificEntropyUnit.KilojoulePerKilogramKelvin, SpecificEntropy.BaseUnit, (q) => ((SpecificEntropy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificEntropyUnit.KilojoulePerKilogramKelvin, SpecificEntropy.BaseUnit, (q) => ((SpecificEntropy)q).ToBaseUnit()); unitConverter.SetConversionFunction(SpecificEntropy.BaseUnit, SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius, (q) => ((SpecificEntropy)q).ToUnit(SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius)); - unitConverter.SetConversionFunction(SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius, SpecificEntropy.BaseUnit, (q) => ((SpecificEntropy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius, SpecificEntropy.BaseUnit, (q) => ((SpecificEntropy)q).ToBaseUnit()); unitConverter.SetConversionFunction(SpecificEntropy.BaseUnit, SpecificEntropyUnit.MegajoulePerKilogramKelvin, (q) => ((SpecificEntropy)q).ToUnit(SpecificEntropyUnit.MegajoulePerKilogramKelvin)); - unitConverter.SetConversionFunction(SpecificEntropyUnit.MegajoulePerKilogramKelvin, SpecificEntropy.BaseUnit, (q) => ((SpecificEntropy)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificEntropyUnit.MegajoulePerKilogramKelvin, SpecificEntropy.BaseUnit, (q) => ((SpecificEntropy)q).ToBaseUnit()); unitConverter.SetConversionFunction(SpecificVolume.BaseUnit, SpecificVolumeUnit.CubicFootPerPound, (q) => ((SpecificVolume)q).ToUnit(SpecificVolumeUnit.CubicFootPerPound)); - unitConverter.SetConversionFunction(SpecificVolumeUnit.CubicFootPerPound, SpecificVolume.BaseUnit, (q) => ((SpecificVolume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificVolumeUnit.CubicFootPerPound, SpecificVolume.BaseUnit, (q) => ((SpecificVolume)q).ToBaseUnit()); unitConverter.SetConversionFunction(SpecificVolume.BaseUnit, SpecificVolume.BaseUnit, (q) => q); unitConverter.SetConversionFunction(SpecificVolume.BaseUnit, SpecificVolumeUnit.MillicubicMeterPerKilogram, (q) => ((SpecificVolume)q).ToUnit(SpecificVolumeUnit.MillicubicMeterPerKilogram)); - unitConverter.SetConversionFunction(SpecificVolumeUnit.MillicubicMeterPerKilogram, SpecificVolume.BaseUnit, (q) => ((SpecificVolume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificVolumeUnit.MillicubicMeterPerKilogram, SpecificVolume.BaseUnit, (q) => ((SpecificVolume)q).ToBaseUnit()); unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.KilogramForcePerCubicCentimeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.KilogramForcePerCubicCentimeter)); - unitConverter.SetConversionFunction(SpecificWeightUnit.KilogramForcePerCubicCentimeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeightUnit.KilogramForcePerCubicCentimeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).ToBaseUnit()); unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.KilogramForcePerCubicMeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.KilogramForcePerCubicMeter)); - unitConverter.SetConversionFunction(SpecificWeightUnit.KilogramForcePerCubicMeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeightUnit.KilogramForcePerCubicMeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).ToBaseUnit()); unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.KilogramForcePerCubicMillimeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.KilogramForcePerCubicMillimeter)); - unitConverter.SetConversionFunction(SpecificWeightUnit.KilogramForcePerCubicMillimeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeightUnit.KilogramForcePerCubicMillimeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).ToBaseUnit()); unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.KilonewtonPerCubicCentimeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.KilonewtonPerCubicCentimeter)); - unitConverter.SetConversionFunction(SpecificWeightUnit.KilonewtonPerCubicCentimeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeightUnit.KilonewtonPerCubicCentimeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).ToBaseUnit()); unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.KilonewtonPerCubicMeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.KilonewtonPerCubicMeter)); - unitConverter.SetConversionFunction(SpecificWeightUnit.KilonewtonPerCubicMeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeightUnit.KilonewtonPerCubicMeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).ToBaseUnit()); unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.KilonewtonPerCubicMillimeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.KilonewtonPerCubicMillimeter)); - unitConverter.SetConversionFunction(SpecificWeightUnit.KilonewtonPerCubicMillimeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeightUnit.KilonewtonPerCubicMillimeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).ToBaseUnit()); unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.KilopoundForcePerCubicFoot, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.KilopoundForcePerCubicFoot)); - unitConverter.SetConversionFunction(SpecificWeightUnit.KilopoundForcePerCubicFoot, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeightUnit.KilopoundForcePerCubicFoot, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).ToBaseUnit()); unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.KilopoundForcePerCubicInch, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.KilopoundForcePerCubicInch)); - unitConverter.SetConversionFunction(SpecificWeightUnit.KilopoundForcePerCubicInch, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeightUnit.KilopoundForcePerCubicInch, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).ToBaseUnit()); unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.MeganewtonPerCubicMeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.MeganewtonPerCubicMeter)); - unitConverter.SetConversionFunction(SpecificWeightUnit.MeganewtonPerCubicMeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeightUnit.MeganewtonPerCubicMeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).ToBaseUnit()); unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.NewtonPerCubicCentimeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.NewtonPerCubicCentimeter)); - unitConverter.SetConversionFunction(SpecificWeightUnit.NewtonPerCubicCentimeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeightUnit.NewtonPerCubicCentimeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).ToBaseUnit()); unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeight.BaseUnit, (q) => q); unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.NewtonPerCubicMillimeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.NewtonPerCubicMillimeter)); - unitConverter.SetConversionFunction(SpecificWeightUnit.NewtonPerCubicMillimeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeightUnit.NewtonPerCubicMillimeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).ToBaseUnit()); unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.PoundForcePerCubicFoot, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.PoundForcePerCubicFoot)); - unitConverter.SetConversionFunction(SpecificWeightUnit.PoundForcePerCubicFoot, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeightUnit.PoundForcePerCubicFoot, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).ToBaseUnit()); unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.PoundForcePerCubicInch, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.PoundForcePerCubicInch)); - unitConverter.SetConversionFunction(SpecificWeightUnit.PoundForcePerCubicInch, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeightUnit.PoundForcePerCubicInch, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).ToBaseUnit()); unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.TonneForcePerCubicCentimeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.TonneForcePerCubicCentimeter)); - unitConverter.SetConversionFunction(SpecificWeightUnit.TonneForcePerCubicCentimeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeightUnit.TonneForcePerCubicCentimeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).ToBaseUnit()); unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.TonneForcePerCubicMeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.TonneForcePerCubicMeter)); - unitConverter.SetConversionFunction(SpecificWeightUnit.TonneForcePerCubicMeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeightUnit.TonneForcePerCubicMeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).ToBaseUnit()); unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.TonneForcePerCubicMillimeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.TonneForcePerCubicMillimeter)); - unitConverter.SetConversionFunction(SpecificWeightUnit.TonneForcePerCubicMillimeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeightUnit.TonneForcePerCubicMillimeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).ToBaseUnit()); unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.CentimeterPerHour, (q) => ((Speed)q).ToUnit(SpeedUnit.CentimeterPerHour)); - unitConverter.SetConversionFunction(SpeedUnit.CentimeterPerHour, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpeedUnit.CentimeterPerHour, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.CentimeterPerMinute, (q) => ((Speed)q).ToUnit(SpeedUnit.CentimeterPerMinute)); - unitConverter.SetConversionFunction(SpeedUnit.CentimeterPerMinute, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpeedUnit.CentimeterPerMinute, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.CentimeterPerSecond, (q) => ((Speed)q).ToUnit(SpeedUnit.CentimeterPerSecond)); - unitConverter.SetConversionFunction(SpeedUnit.CentimeterPerSecond, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpeedUnit.CentimeterPerSecond, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.DecimeterPerMinute, (q) => ((Speed)q).ToUnit(SpeedUnit.DecimeterPerMinute)); - unitConverter.SetConversionFunction(SpeedUnit.DecimeterPerMinute, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpeedUnit.DecimeterPerMinute, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.DecimeterPerSecond, (q) => ((Speed)q).ToUnit(SpeedUnit.DecimeterPerSecond)); - unitConverter.SetConversionFunction(SpeedUnit.DecimeterPerSecond, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpeedUnit.DecimeterPerSecond, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.FootPerHour, (q) => ((Speed)q).ToUnit(SpeedUnit.FootPerHour)); - unitConverter.SetConversionFunction(SpeedUnit.FootPerHour, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpeedUnit.FootPerHour, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.FootPerMinute, (q) => ((Speed)q).ToUnit(SpeedUnit.FootPerMinute)); - unitConverter.SetConversionFunction(SpeedUnit.FootPerMinute, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpeedUnit.FootPerMinute, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.FootPerSecond, (q) => ((Speed)q).ToUnit(SpeedUnit.FootPerSecond)); - unitConverter.SetConversionFunction(SpeedUnit.FootPerSecond, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpeedUnit.FootPerSecond, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.InchPerHour, (q) => ((Speed)q).ToUnit(SpeedUnit.InchPerHour)); - unitConverter.SetConversionFunction(SpeedUnit.InchPerHour, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpeedUnit.InchPerHour, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.InchPerMinute, (q) => ((Speed)q).ToUnit(SpeedUnit.InchPerMinute)); - unitConverter.SetConversionFunction(SpeedUnit.InchPerMinute, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpeedUnit.InchPerMinute, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.InchPerSecond, (q) => ((Speed)q).ToUnit(SpeedUnit.InchPerSecond)); - unitConverter.SetConversionFunction(SpeedUnit.InchPerSecond, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpeedUnit.InchPerSecond, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.KilometerPerHour, (q) => ((Speed)q).ToUnit(SpeedUnit.KilometerPerHour)); - unitConverter.SetConversionFunction(SpeedUnit.KilometerPerHour, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpeedUnit.KilometerPerHour, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.KilometerPerMinute, (q) => ((Speed)q).ToUnit(SpeedUnit.KilometerPerMinute)); - unitConverter.SetConversionFunction(SpeedUnit.KilometerPerMinute, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpeedUnit.KilometerPerMinute, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.KilometerPerSecond, (q) => ((Speed)q).ToUnit(SpeedUnit.KilometerPerSecond)); - unitConverter.SetConversionFunction(SpeedUnit.KilometerPerSecond, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpeedUnit.KilometerPerSecond, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.Knot, (q) => ((Speed)q).ToUnit(SpeedUnit.Knot)); - unitConverter.SetConversionFunction(SpeedUnit.Knot, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpeedUnit.Knot, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.MeterPerHour, (q) => ((Speed)q).ToUnit(SpeedUnit.MeterPerHour)); - unitConverter.SetConversionFunction(SpeedUnit.MeterPerHour, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpeedUnit.MeterPerHour, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.MeterPerMinute, (q) => ((Speed)q).ToUnit(SpeedUnit.MeterPerMinute)); - unitConverter.SetConversionFunction(SpeedUnit.MeterPerMinute, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpeedUnit.MeterPerMinute, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); unitConverter.SetConversionFunction(Speed.BaseUnit, Speed.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.MicrometerPerMinute, (q) => ((Speed)q).ToUnit(SpeedUnit.MicrometerPerMinute)); - unitConverter.SetConversionFunction(SpeedUnit.MicrometerPerMinute, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpeedUnit.MicrometerPerMinute, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.MicrometerPerSecond, (q) => ((Speed)q).ToUnit(SpeedUnit.MicrometerPerSecond)); - unitConverter.SetConversionFunction(SpeedUnit.MicrometerPerSecond, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpeedUnit.MicrometerPerSecond, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.MilePerHour, (q) => ((Speed)q).ToUnit(SpeedUnit.MilePerHour)); - unitConverter.SetConversionFunction(SpeedUnit.MilePerHour, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpeedUnit.MilePerHour, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.MillimeterPerHour, (q) => ((Speed)q).ToUnit(SpeedUnit.MillimeterPerHour)); - unitConverter.SetConversionFunction(SpeedUnit.MillimeterPerHour, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpeedUnit.MillimeterPerHour, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.MillimeterPerMinute, (q) => ((Speed)q).ToUnit(SpeedUnit.MillimeterPerMinute)); - unitConverter.SetConversionFunction(SpeedUnit.MillimeterPerMinute, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpeedUnit.MillimeterPerMinute, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.MillimeterPerSecond, (q) => ((Speed)q).ToUnit(SpeedUnit.MillimeterPerSecond)); - unitConverter.SetConversionFunction(SpeedUnit.MillimeterPerSecond, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpeedUnit.MillimeterPerSecond, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.NanometerPerMinute, (q) => ((Speed)q).ToUnit(SpeedUnit.NanometerPerMinute)); - unitConverter.SetConversionFunction(SpeedUnit.NanometerPerMinute, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpeedUnit.NanometerPerMinute, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.NanometerPerSecond, (q) => ((Speed)q).ToUnit(SpeedUnit.NanometerPerSecond)); - unitConverter.SetConversionFunction(SpeedUnit.NanometerPerSecond, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpeedUnit.NanometerPerSecond, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.UsSurveyFootPerHour, (q) => ((Speed)q).ToUnit(SpeedUnit.UsSurveyFootPerHour)); - unitConverter.SetConversionFunction(SpeedUnit.UsSurveyFootPerHour, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpeedUnit.UsSurveyFootPerHour, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.UsSurveyFootPerMinute, (q) => ((Speed)q).ToUnit(SpeedUnit.UsSurveyFootPerMinute)); - unitConverter.SetConversionFunction(SpeedUnit.UsSurveyFootPerMinute, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpeedUnit.UsSurveyFootPerMinute, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.UsSurveyFootPerSecond, (q) => ((Speed)q).ToUnit(SpeedUnit.UsSurveyFootPerSecond)); - unitConverter.SetConversionFunction(SpeedUnit.UsSurveyFootPerSecond, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpeedUnit.UsSurveyFootPerSecond, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.YardPerHour, (q) => ((Speed)q).ToUnit(SpeedUnit.YardPerHour)); - unitConverter.SetConversionFunction(SpeedUnit.YardPerHour, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpeedUnit.YardPerHour, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.YardPerMinute, (q) => ((Speed)q).ToUnit(SpeedUnit.YardPerMinute)); - unitConverter.SetConversionFunction(SpeedUnit.YardPerMinute, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpeedUnit.YardPerMinute, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.YardPerSecond, (q) => ((Speed)q).ToUnit(SpeedUnit.YardPerSecond)); - unitConverter.SetConversionFunction(SpeedUnit.YardPerSecond, Speed.BaseUnit, (q) => ((Speed)q).AsBaseUnit()); + unitConverter.SetConversionFunction(SpeedUnit.YardPerSecond, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); unitConverter.SetConversionFunction(Temperature.BaseUnit, TemperatureUnit.DegreeCelsius, (q) => ((Temperature)q).ToUnit(TemperatureUnit.DegreeCelsius)); - unitConverter.SetConversionFunction(TemperatureUnit.DegreeCelsius, Temperature.BaseUnit, (q) => ((Temperature)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureUnit.DegreeCelsius, Temperature.BaseUnit, (q) => ((Temperature)q).ToBaseUnit()); unitConverter.SetConversionFunction(Temperature.BaseUnit, TemperatureUnit.DegreeDelisle, (q) => ((Temperature)q).ToUnit(TemperatureUnit.DegreeDelisle)); - unitConverter.SetConversionFunction(TemperatureUnit.DegreeDelisle, Temperature.BaseUnit, (q) => ((Temperature)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureUnit.DegreeDelisle, Temperature.BaseUnit, (q) => ((Temperature)q).ToBaseUnit()); unitConverter.SetConversionFunction(Temperature.BaseUnit, TemperatureUnit.DegreeFahrenheit, (q) => ((Temperature)q).ToUnit(TemperatureUnit.DegreeFahrenheit)); - unitConverter.SetConversionFunction(TemperatureUnit.DegreeFahrenheit, Temperature.BaseUnit, (q) => ((Temperature)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureUnit.DegreeFahrenheit, Temperature.BaseUnit, (q) => ((Temperature)q).ToBaseUnit()); unitConverter.SetConversionFunction(Temperature.BaseUnit, TemperatureUnit.DegreeNewton, (q) => ((Temperature)q).ToUnit(TemperatureUnit.DegreeNewton)); - unitConverter.SetConversionFunction(TemperatureUnit.DegreeNewton, Temperature.BaseUnit, (q) => ((Temperature)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureUnit.DegreeNewton, Temperature.BaseUnit, (q) => ((Temperature)q).ToBaseUnit()); unitConverter.SetConversionFunction(Temperature.BaseUnit, TemperatureUnit.DegreeRankine, (q) => ((Temperature)q).ToUnit(TemperatureUnit.DegreeRankine)); - unitConverter.SetConversionFunction(TemperatureUnit.DegreeRankine, Temperature.BaseUnit, (q) => ((Temperature)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureUnit.DegreeRankine, Temperature.BaseUnit, (q) => ((Temperature)q).ToBaseUnit()); unitConverter.SetConversionFunction(Temperature.BaseUnit, TemperatureUnit.DegreeReaumur, (q) => ((Temperature)q).ToUnit(TemperatureUnit.DegreeReaumur)); - unitConverter.SetConversionFunction(TemperatureUnit.DegreeReaumur, Temperature.BaseUnit, (q) => ((Temperature)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureUnit.DegreeReaumur, Temperature.BaseUnit, (q) => ((Temperature)q).ToBaseUnit()); unitConverter.SetConversionFunction(Temperature.BaseUnit, TemperatureUnit.DegreeRoemer, (q) => ((Temperature)q).ToUnit(TemperatureUnit.DegreeRoemer)); - unitConverter.SetConversionFunction(TemperatureUnit.DegreeRoemer, Temperature.BaseUnit, (q) => ((Temperature)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureUnit.DegreeRoemer, Temperature.BaseUnit, (q) => ((Temperature)q).ToBaseUnit()); unitConverter.SetConversionFunction(Temperature.BaseUnit, Temperature.BaseUnit, (q) => q); unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond, (q) => ((TemperatureChangeRate)q).ToUnit(TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond)); - unitConverter.SetConversionFunction(TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond, (q) => ((TemperatureChangeRate)q).ToUnit(TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond)); - unitConverter.SetConversionFunction(TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond, (q) => ((TemperatureChangeRate)q).ToUnit(TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond)); - unitConverter.SetConversionFunction(TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.DegreeCelsiusPerMinute, (q) => ((TemperatureChangeRate)q).ToUnit(TemperatureChangeRateUnit.DegreeCelsiusPerMinute)); - unitConverter.SetConversionFunction(TemperatureChangeRateUnit.DegreeCelsiusPerMinute, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureChangeRateUnit.DegreeCelsiusPerMinute, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRate.BaseUnit, (q) => q); unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond, (q) => ((TemperatureChangeRate)q).ToUnit(TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond)); - unitConverter.SetConversionFunction(TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond, (q) => ((TemperatureChangeRate)q).ToUnit(TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond)); - unitConverter.SetConversionFunction(TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond, (q) => ((TemperatureChangeRate)q).ToUnit(TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond)); - unitConverter.SetConversionFunction(TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond, (q) => ((TemperatureChangeRate)q).ToUnit(TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond)); - unitConverter.SetConversionFunction(TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond, (q) => ((TemperatureChangeRate)q).ToUnit(TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond)); - unitConverter.SetConversionFunction(TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).ToBaseUnit()); unitConverter.SetConversionFunction(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeCelsius, (q) => ((TemperatureDelta)q).ToUnit(TemperatureDeltaUnit.DegreeCelsius)); - unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeCelsius, TemperatureDelta.BaseUnit, (q) => ((TemperatureDelta)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeCelsius, TemperatureDelta.BaseUnit, (q) => ((TemperatureDelta)q).ToBaseUnit()); unitConverter.SetConversionFunction(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeDelisle, (q) => ((TemperatureDelta)q).ToUnit(TemperatureDeltaUnit.DegreeDelisle)); - unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeDelisle, TemperatureDelta.BaseUnit, (q) => ((TemperatureDelta)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeDelisle, TemperatureDelta.BaseUnit, (q) => ((TemperatureDelta)q).ToBaseUnit()); unitConverter.SetConversionFunction(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeFahrenheit, (q) => ((TemperatureDelta)q).ToUnit(TemperatureDeltaUnit.DegreeFahrenheit)); - unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeFahrenheit, TemperatureDelta.BaseUnit, (q) => ((TemperatureDelta)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeFahrenheit, TemperatureDelta.BaseUnit, (q) => ((TemperatureDelta)q).ToBaseUnit()); unitConverter.SetConversionFunction(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeNewton, (q) => ((TemperatureDelta)q).ToUnit(TemperatureDeltaUnit.DegreeNewton)); - unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeNewton, TemperatureDelta.BaseUnit, (q) => ((TemperatureDelta)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeNewton, TemperatureDelta.BaseUnit, (q) => ((TemperatureDelta)q).ToBaseUnit()); unitConverter.SetConversionFunction(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeRankine, (q) => ((TemperatureDelta)q).ToUnit(TemperatureDeltaUnit.DegreeRankine)); - unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeRankine, TemperatureDelta.BaseUnit, (q) => ((TemperatureDelta)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeRankine, TemperatureDelta.BaseUnit, (q) => ((TemperatureDelta)q).ToBaseUnit()); unitConverter.SetConversionFunction(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeReaumur, (q) => ((TemperatureDelta)q).ToUnit(TemperatureDeltaUnit.DegreeReaumur)); - unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeReaumur, TemperatureDelta.BaseUnit, (q) => ((TemperatureDelta)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeReaumur, TemperatureDelta.BaseUnit, (q) => ((TemperatureDelta)q).ToBaseUnit()); unitConverter.SetConversionFunction(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeRoemer, (q) => ((TemperatureDelta)q).ToUnit(TemperatureDeltaUnit.DegreeRoemer)); - unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeRoemer, TemperatureDelta.BaseUnit, (q) => ((TemperatureDelta)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeRoemer, TemperatureDelta.BaseUnit, (q) => ((TemperatureDelta)q).ToBaseUnit()); unitConverter.SetConversionFunction(TemperatureDelta.BaseUnit, TemperatureDelta.BaseUnit, (q) => q); unitConverter.SetConversionFunction(ThermalConductivity.BaseUnit, ThermalConductivityUnit.BtuPerHourFootFahrenheit, (q) => ((ThermalConductivity)q).ToUnit(ThermalConductivityUnit.BtuPerHourFootFahrenheit)); - unitConverter.SetConversionFunction(ThermalConductivityUnit.BtuPerHourFootFahrenheit, ThermalConductivity.BaseUnit, (q) => ((ThermalConductivity)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ThermalConductivityUnit.BtuPerHourFootFahrenheit, ThermalConductivity.BaseUnit, (q) => ((ThermalConductivity)q).ToBaseUnit()); unitConverter.SetConversionFunction(ThermalConductivity.BaseUnit, ThermalConductivity.BaseUnit, (q) => q); unitConverter.SetConversionFunction(ThermalResistance.BaseUnit, ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu, (q) => ((ThermalResistance)q).ToUnit(ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu)); - unitConverter.SetConversionFunction(ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu, ThermalResistance.BaseUnit, (q) => ((ThermalResistance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu, ThermalResistance.BaseUnit, (q) => ((ThermalResistance)q).ToBaseUnit()); unitConverter.SetConversionFunction(ThermalResistance.BaseUnit, ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie, (q) => ((ThermalResistance)q).ToUnit(ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie)); - unitConverter.SetConversionFunction(ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie, ThermalResistance.BaseUnit, (q) => ((ThermalResistance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie, ThermalResistance.BaseUnit, (q) => ((ThermalResistance)q).ToBaseUnit()); unitConverter.SetConversionFunction(ThermalResistance.BaseUnit, ThermalResistanceUnit.SquareCentimeterKelvinPerWatt, (q) => ((ThermalResistance)q).ToUnit(ThermalResistanceUnit.SquareCentimeterKelvinPerWatt)); - unitConverter.SetConversionFunction(ThermalResistanceUnit.SquareCentimeterKelvinPerWatt, ThermalResistance.BaseUnit, (q) => ((ThermalResistance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ThermalResistanceUnit.SquareCentimeterKelvinPerWatt, ThermalResistance.BaseUnit, (q) => ((ThermalResistance)q).ToBaseUnit()); unitConverter.SetConversionFunction(ThermalResistance.BaseUnit, ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt, (q) => ((ThermalResistance)q).ToUnit(ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt)); - unitConverter.SetConversionFunction(ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt, ThermalResistance.BaseUnit, (q) => ((ThermalResistance)q).AsBaseUnit()); + unitConverter.SetConversionFunction(ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt, ThermalResistance.BaseUnit, (q) => ((ThermalResistance)q).ToBaseUnit()); unitConverter.SetConversionFunction(ThermalResistance.BaseUnit, ThermalResistance.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.KilogramForceCentimeter, (q) => ((Torque)q).ToUnit(TorqueUnit.KilogramForceCentimeter)); - unitConverter.SetConversionFunction(TorqueUnit.KilogramForceCentimeter, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TorqueUnit.KilogramForceCentimeter, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.KilogramForceMeter, (q) => ((Torque)q).ToUnit(TorqueUnit.KilogramForceMeter)); - unitConverter.SetConversionFunction(TorqueUnit.KilogramForceMeter, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TorqueUnit.KilogramForceMeter, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.KilogramForceMillimeter, (q) => ((Torque)q).ToUnit(TorqueUnit.KilogramForceMillimeter)); - unitConverter.SetConversionFunction(TorqueUnit.KilogramForceMillimeter, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TorqueUnit.KilogramForceMillimeter, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.KilonewtonCentimeter, (q) => ((Torque)q).ToUnit(TorqueUnit.KilonewtonCentimeter)); - unitConverter.SetConversionFunction(TorqueUnit.KilonewtonCentimeter, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TorqueUnit.KilonewtonCentimeter, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.KilonewtonMeter, (q) => ((Torque)q).ToUnit(TorqueUnit.KilonewtonMeter)); - unitConverter.SetConversionFunction(TorqueUnit.KilonewtonMeter, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TorqueUnit.KilonewtonMeter, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.KilonewtonMillimeter, (q) => ((Torque)q).ToUnit(TorqueUnit.KilonewtonMillimeter)); - unitConverter.SetConversionFunction(TorqueUnit.KilonewtonMillimeter, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TorqueUnit.KilonewtonMillimeter, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.KilopoundForceFoot, (q) => ((Torque)q).ToUnit(TorqueUnit.KilopoundForceFoot)); - unitConverter.SetConversionFunction(TorqueUnit.KilopoundForceFoot, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TorqueUnit.KilopoundForceFoot, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.KilopoundForceInch, (q) => ((Torque)q).ToUnit(TorqueUnit.KilopoundForceInch)); - unitConverter.SetConversionFunction(TorqueUnit.KilopoundForceInch, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TorqueUnit.KilopoundForceInch, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.MeganewtonCentimeter, (q) => ((Torque)q).ToUnit(TorqueUnit.MeganewtonCentimeter)); - unitConverter.SetConversionFunction(TorqueUnit.MeganewtonCentimeter, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TorqueUnit.MeganewtonCentimeter, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.MeganewtonMeter, (q) => ((Torque)q).ToUnit(TorqueUnit.MeganewtonMeter)); - unitConverter.SetConversionFunction(TorqueUnit.MeganewtonMeter, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TorqueUnit.MeganewtonMeter, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.MeganewtonMillimeter, (q) => ((Torque)q).ToUnit(TorqueUnit.MeganewtonMillimeter)); - unitConverter.SetConversionFunction(TorqueUnit.MeganewtonMillimeter, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TorqueUnit.MeganewtonMillimeter, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.MegapoundForceFoot, (q) => ((Torque)q).ToUnit(TorqueUnit.MegapoundForceFoot)); - unitConverter.SetConversionFunction(TorqueUnit.MegapoundForceFoot, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TorqueUnit.MegapoundForceFoot, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.MegapoundForceInch, (q) => ((Torque)q).ToUnit(TorqueUnit.MegapoundForceInch)); - unitConverter.SetConversionFunction(TorqueUnit.MegapoundForceInch, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TorqueUnit.MegapoundForceInch, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.NewtonCentimeter, (q) => ((Torque)q).ToUnit(TorqueUnit.NewtonCentimeter)); - unitConverter.SetConversionFunction(TorqueUnit.NewtonCentimeter, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TorqueUnit.NewtonCentimeter, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); unitConverter.SetConversionFunction(Torque.BaseUnit, Torque.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.NewtonMillimeter, (q) => ((Torque)q).ToUnit(TorqueUnit.NewtonMillimeter)); - unitConverter.SetConversionFunction(TorqueUnit.NewtonMillimeter, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TorqueUnit.NewtonMillimeter, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.PoundForceFoot, (q) => ((Torque)q).ToUnit(TorqueUnit.PoundForceFoot)); - unitConverter.SetConversionFunction(TorqueUnit.PoundForceFoot, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TorqueUnit.PoundForceFoot, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.PoundForceInch, (q) => ((Torque)q).ToUnit(TorqueUnit.PoundForceInch)); - unitConverter.SetConversionFunction(TorqueUnit.PoundForceInch, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TorqueUnit.PoundForceInch, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.TonneForceCentimeter, (q) => ((Torque)q).ToUnit(TorqueUnit.TonneForceCentimeter)); - unitConverter.SetConversionFunction(TorqueUnit.TonneForceCentimeter, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TorqueUnit.TonneForceCentimeter, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.TonneForceMeter, (q) => ((Torque)q).ToUnit(TorqueUnit.TonneForceMeter)); - unitConverter.SetConversionFunction(TorqueUnit.TonneForceMeter, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TorqueUnit.TonneForceMeter, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.TonneForceMillimeter, (q) => ((Torque)q).ToUnit(TorqueUnit.TonneForceMillimeter)); - unitConverter.SetConversionFunction(TorqueUnit.TonneForceMillimeter, Torque.BaseUnit, (q) => ((Torque)q).AsBaseUnit()); + unitConverter.SetConversionFunction(TorqueUnit.TonneForceMillimeter, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); unitConverter.SetConversionFunction(VitaminA.BaseUnit, VitaminA.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.AcreFoot, (q) => ((Volume)q).ToUnit(VolumeUnit.AcreFoot)); - unitConverter.SetConversionFunction(VolumeUnit.AcreFoot, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.AcreFoot, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.AuTablespoon, (q) => ((Volume)q).ToUnit(VolumeUnit.AuTablespoon)); - unitConverter.SetConversionFunction(VolumeUnit.AuTablespoon, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.AuTablespoon, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.Centiliter, (q) => ((Volume)q).ToUnit(VolumeUnit.Centiliter)); - unitConverter.SetConversionFunction(VolumeUnit.Centiliter, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.Centiliter, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicCentimeter, (q) => ((Volume)q).ToUnit(VolumeUnit.CubicCentimeter)); - unitConverter.SetConversionFunction(VolumeUnit.CubicCentimeter, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.CubicCentimeter, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicDecimeter, (q) => ((Volume)q).ToUnit(VolumeUnit.CubicDecimeter)); - unitConverter.SetConversionFunction(VolumeUnit.CubicDecimeter, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.CubicDecimeter, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicFoot, (q) => ((Volume)q).ToUnit(VolumeUnit.CubicFoot)); - unitConverter.SetConversionFunction(VolumeUnit.CubicFoot, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.CubicFoot, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicInch, (q) => ((Volume)q).ToUnit(VolumeUnit.CubicInch)); - unitConverter.SetConversionFunction(VolumeUnit.CubicInch, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.CubicInch, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicKilometer, (q) => ((Volume)q).ToUnit(VolumeUnit.CubicKilometer)); - unitConverter.SetConversionFunction(VolumeUnit.CubicKilometer, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.CubicKilometer, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, Volume.BaseUnit, (q) => q); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicMicrometer, (q) => ((Volume)q).ToUnit(VolumeUnit.CubicMicrometer)); - unitConverter.SetConversionFunction(VolumeUnit.CubicMicrometer, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.CubicMicrometer, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicMile, (q) => ((Volume)q).ToUnit(VolumeUnit.CubicMile)); - unitConverter.SetConversionFunction(VolumeUnit.CubicMile, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.CubicMile, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicMillimeter, (q) => ((Volume)q).ToUnit(VolumeUnit.CubicMillimeter)); - unitConverter.SetConversionFunction(VolumeUnit.CubicMillimeter, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.CubicMillimeter, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicYard, (q) => ((Volume)q).ToUnit(VolumeUnit.CubicYard)); - unitConverter.SetConversionFunction(VolumeUnit.CubicYard, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.CubicYard, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.Deciliter, (q) => ((Volume)q).ToUnit(VolumeUnit.Deciliter)); - unitConverter.SetConversionFunction(VolumeUnit.Deciliter, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.Deciliter, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.HectocubicFoot, (q) => ((Volume)q).ToUnit(VolumeUnit.HectocubicFoot)); - unitConverter.SetConversionFunction(VolumeUnit.HectocubicFoot, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.HectocubicFoot, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.HectocubicMeter, (q) => ((Volume)q).ToUnit(VolumeUnit.HectocubicMeter)); - unitConverter.SetConversionFunction(VolumeUnit.HectocubicMeter, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.HectocubicMeter, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.Hectoliter, (q) => ((Volume)q).ToUnit(VolumeUnit.Hectoliter)); - unitConverter.SetConversionFunction(VolumeUnit.Hectoliter, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.Hectoliter, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.ImperialBeerBarrel, (q) => ((Volume)q).ToUnit(VolumeUnit.ImperialBeerBarrel)); - unitConverter.SetConversionFunction(VolumeUnit.ImperialBeerBarrel, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.ImperialBeerBarrel, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.ImperialGallon, (q) => ((Volume)q).ToUnit(VolumeUnit.ImperialGallon)); - unitConverter.SetConversionFunction(VolumeUnit.ImperialGallon, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.ImperialGallon, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.ImperialOunce, (q) => ((Volume)q).ToUnit(VolumeUnit.ImperialOunce)); - unitConverter.SetConversionFunction(VolumeUnit.ImperialOunce, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.ImperialOunce, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.KilocubicFoot, (q) => ((Volume)q).ToUnit(VolumeUnit.KilocubicFoot)); - unitConverter.SetConversionFunction(VolumeUnit.KilocubicFoot, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.KilocubicFoot, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.KilocubicMeter, (q) => ((Volume)q).ToUnit(VolumeUnit.KilocubicMeter)); - unitConverter.SetConversionFunction(VolumeUnit.KilocubicMeter, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.KilocubicMeter, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.KiloimperialGallon, (q) => ((Volume)q).ToUnit(VolumeUnit.KiloimperialGallon)); - unitConverter.SetConversionFunction(VolumeUnit.KiloimperialGallon, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.KiloimperialGallon, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.Kiloliter, (q) => ((Volume)q).ToUnit(VolumeUnit.Kiloliter)); - unitConverter.SetConversionFunction(VolumeUnit.Kiloliter, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.Kiloliter, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.KilousGallon, (q) => ((Volume)q).ToUnit(VolumeUnit.KilousGallon)); - unitConverter.SetConversionFunction(VolumeUnit.KilousGallon, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.KilousGallon, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.Liter, (q) => ((Volume)q).ToUnit(VolumeUnit.Liter)); - unitConverter.SetConversionFunction(VolumeUnit.Liter, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.Liter, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.MegacubicFoot, (q) => ((Volume)q).ToUnit(VolumeUnit.MegacubicFoot)); - unitConverter.SetConversionFunction(VolumeUnit.MegacubicFoot, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.MegacubicFoot, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.MegaimperialGallon, (q) => ((Volume)q).ToUnit(VolumeUnit.MegaimperialGallon)); - unitConverter.SetConversionFunction(VolumeUnit.MegaimperialGallon, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.MegaimperialGallon, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.Megaliter, (q) => ((Volume)q).ToUnit(VolumeUnit.Megaliter)); - unitConverter.SetConversionFunction(VolumeUnit.Megaliter, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.Megaliter, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.MegausGallon, (q) => ((Volume)q).ToUnit(VolumeUnit.MegausGallon)); - unitConverter.SetConversionFunction(VolumeUnit.MegausGallon, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.MegausGallon, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.MetricCup, (q) => ((Volume)q).ToUnit(VolumeUnit.MetricCup)); - unitConverter.SetConversionFunction(VolumeUnit.MetricCup, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.MetricCup, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.MetricTeaspoon, (q) => ((Volume)q).ToUnit(VolumeUnit.MetricTeaspoon)); - unitConverter.SetConversionFunction(VolumeUnit.MetricTeaspoon, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.MetricTeaspoon, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.Microliter, (q) => ((Volume)q).ToUnit(VolumeUnit.Microliter)); - unitConverter.SetConversionFunction(VolumeUnit.Microliter, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.Microliter, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.Milliliter, (q) => ((Volume)q).ToUnit(VolumeUnit.Milliliter)); - unitConverter.SetConversionFunction(VolumeUnit.Milliliter, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.Milliliter, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.OilBarrel, (q) => ((Volume)q).ToUnit(VolumeUnit.OilBarrel)); - unitConverter.SetConversionFunction(VolumeUnit.OilBarrel, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.OilBarrel, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UkTablespoon, (q) => ((Volume)q).ToUnit(VolumeUnit.UkTablespoon)); - unitConverter.SetConversionFunction(VolumeUnit.UkTablespoon, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.UkTablespoon, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsBeerBarrel, (q) => ((Volume)q).ToUnit(VolumeUnit.UsBeerBarrel)); - unitConverter.SetConversionFunction(VolumeUnit.UsBeerBarrel, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.UsBeerBarrel, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsCustomaryCup, (q) => ((Volume)q).ToUnit(VolumeUnit.UsCustomaryCup)); - unitConverter.SetConversionFunction(VolumeUnit.UsCustomaryCup, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.UsCustomaryCup, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsGallon, (q) => ((Volume)q).ToUnit(VolumeUnit.UsGallon)); - unitConverter.SetConversionFunction(VolumeUnit.UsGallon, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.UsGallon, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsLegalCup, (q) => ((Volume)q).ToUnit(VolumeUnit.UsLegalCup)); - unitConverter.SetConversionFunction(VolumeUnit.UsLegalCup, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.UsLegalCup, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsOunce, (q) => ((Volume)q).ToUnit(VolumeUnit.UsOunce)); - unitConverter.SetConversionFunction(VolumeUnit.UsOunce, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.UsOunce, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsPint, (q) => ((Volume)q).ToUnit(VolumeUnit.UsPint)); - unitConverter.SetConversionFunction(VolumeUnit.UsPint, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.UsPint, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsQuart, (q) => ((Volume)q).ToUnit(VolumeUnit.UsQuart)); - unitConverter.SetConversionFunction(VolumeUnit.UsQuart, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.UsQuart, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsTablespoon, (q) => ((Volume)q).ToUnit(VolumeUnit.UsTablespoon)); - unitConverter.SetConversionFunction(VolumeUnit.UsTablespoon, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.UsTablespoon, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsTeaspoon, (q) => ((Volume)q).ToUnit(VolumeUnit.UsTeaspoon)); - unitConverter.SetConversionFunction(VolumeUnit.UsTeaspoon, Volume.BaseUnit, (q) => ((Volume)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeUnit.UsTeaspoon, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.AcreFootPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.AcreFootPerDay)); - unitConverter.SetConversionFunction(VolumeFlowUnit.AcreFootPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.AcreFootPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.AcreFootPerHour, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.AcreFootPerHour)); - unitConverter.SetConversionFunction(VolumeFlowUnit.AcreFootPerHour, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.AcreFootPerHour, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.AcreFootPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.AcreFootPerMinute)); - unitConverter.SetConversionFunction(VolumeFlowUnit.AcreFootPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.AcreFootPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.AcreFootPerSecond, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.AcreFootPerSecond)); - unitConverter.SetConversionFunction(VolumeFlowUnit.AcreFootPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.AcreFootPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CentiliterPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CentiliterPerDay)); - unitConverter.SetConversionFunction(VolumeFlowUnit.CentiliterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.CentiliterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CentiliterPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CentiliterPerMinute)); - unitConverter.SetConversionFunction(VolumeFlowUnit.CentiliterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.CentiliterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicDecimeterPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicDecimeterPerMinute)); - unitConverter.SetConversionFunction(VolumeFlowUnit.CubicDecimeterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicDecimeterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicFootPerHour, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicFootPerHour)); - unitConverter.SetConversionFunction(VolumeFlowUnit.CubicFootPerHour, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicFootPerHour, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicFootPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicFootPerMinute)); - unitConverter.SetConversionFunction(VolumeFlowUnit.CubicFootPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicFootPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicFootPerSecond, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicFootPerSecond)); - unitConverter.SetConversionFunction(VolumeFlowUnit.CubicFootPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicFootPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicMeterPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicMeterPerDay)); - unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMeterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMeterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicMeterPerHour, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicMeterPerHour)); - unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMeterPerHour, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMeterPerHour, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicMeterPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicMeterPerMinute)); - unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMeterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMeterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlow.BaseUnit, (q) => q); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicMillimeterPerSecond, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicMillimeterPerSecond)); - unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMillimeterPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMillimeterPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicYardPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicYardPerDay)); - unitConverter.SetConversionFunction(VolumeFlowUnit.CubicYardPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicYardPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicYardPerHour, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicYardPerHour)); - unitConverter.SetConversionFunction(VolumeFlowUnit.CubicYardPerHour, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicYardPerHour, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicYardPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicYardPerMinute)); - unitConverter.SetConversionFunction(VolumeFlowUnit.CubicYardPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicYardPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicYardPerSecond, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicYardPerSecond)); - unitConverter.SetConversionFunction(VolumeFlowUnit.CubicYardPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicYardPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.DeciliterPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.DeciliterPerDay)); - unitConverter.SetConversionFunction(VolumeFlowUnit.DeciliterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.DeciliterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.DeciliterPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.DeciliterPerMinute)); - unitConverter.SetConversionFunction(VolumeFlowUnit.DeciliterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.DeciliterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.KiloliterPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.KiloliterPerDay)); - unitConverter.SetConversionFunction(VolumeFlowUnit.KiloliterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.KiloliterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.KiloliterPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.KiloliterPerMinute)); - unitConverter.SetConversionFunction(VolumeFlowUnit.KiloliterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.KiloliterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.KilousGallonPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.KilousGallonPerMinute)); - unitConverter.SetConversionFunction(VolumeFlowUnit.KilousGallonPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.KilousGallonPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.LiterPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.LiterPerDay)); - unitConverter.SetConversionFunction(VolumeFlowUnit.LiterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.LiterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.LiterPerHour, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.LiterPerHour)); - unitConverter.SetConversionFunction(VolumeFlowUnit.LiterPerHour, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.LiterPerHour, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.LiterPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.LiterPerMinute)); - unitConverter.SetConversionFunction(VolumeFlowUnit.LiterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.LiterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.LiterPerSecond, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.LiterPerSecond)); - unitConverter.SetConversionFunction(VolumeFlowUnit.LiterPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.LiterPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.MegaliterPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.MegaliterPerDay)); - unitConverter.SetConversionFunction(VolumeFlowUnit.MegaliterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.MegaliterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.MegaukGallonPerSecond, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.MegaukGallonPerSecond)); - unitConverter.SetConversionFunction(VolumeFlowUnit.MegaukGallonPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.MegaukGallonPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.MicroliterPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.MicroliterPerDay)); - unitConverter.SetConversionFunction(VolumeFlowUnit.MicroliterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.MicroliterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.MicroliterPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.MicroliterPerMinute)); - unitConverter.SetConversionFunction(VolumeFlowUnit.MicroliterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.MicroliterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.MilliliterPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.MilliliterPerDay)); - unitConverter.SetConversionFunction(VolumeFlowUnit.MilliliterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.MilliliterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.MilliliterPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.MilliliterPerMinute)); - unitConverter.SetConversionFunction(VolumeFlowUnit.MilliliterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.MilliliterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.MillionUsGallonsPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.MillionUsGallonsPerDay)); - unitConverter.SetConversionFunction(VolumeFlowUnit.MillionUsGallonsPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.MillionUsGallonsPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.NanoliterPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.NanoliterPerDay)); - unitConverter.SetConversionFunction(VolumeFlowUnit.NanoliterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.NanoliterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.NanoliterPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.NanoliterPerMinute)); - unitConverter.SetConversionFunction(VolumeFlowUnit.NanoliterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.NanoliterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.OilBarrelPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.OilBarrelPerDay)); - unitConverter.SetConversionFunction(VolumeFlowUnit.OilBarrelPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.OilBarrelPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.OilBarrelPerHour, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.OilBarrelPerHour)); - unitConverter.SetConversionFunction(VolumeFlowUnit.OilBarrelPerHour, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.OilBarrelPerHour, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.OilBarrelPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.OilBarrelPerMinute)); - unitConverter.SetConversionFunction(VolumeFlowUnit.OilBarrelPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.OilBarrelPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.OilBarrelPerSecond, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.OilBarrelPerSecond)); - unitConverter.SetConversionFunction(VolumeFlowUnit.OilBarrelPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.OilBarrelPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.UkGallonPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.UkGallonPerDay)); - unitConverter.SetConversionFunction(VolumeFlowUnit.UkGallonPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.UkGallonPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.UkGallonPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.UkGallonPerMinute)); - unitConverter.SetConversionFunction(VolumeFlowUnit.UkGallonPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.UkGallonPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.UkGallonPerSecond, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.UkGallonPerSecond)); - unitConverter.SetConversionFunction(VolumeFlowUnit.UkGallonPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.UkGallonPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.UsGallonPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.UsGallonPerDay)); - unitConverter.SetConversionFunction(VolumeFlowUnit.UsGallonPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.UsGallonPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.UsGallonPerHour, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.UsGallonPerHour)); - unitConverter.SetConversionFunction(VolumeFlowUnit.UsGallonPerHour, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.UsGallonPerHour, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.UsGallonPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.UsGallonPerMinute)); - unitConverter.SetConversionFunction(VolumeFlowUnit.UsGallonPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.UsGallonPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.UsGallonPerSecond, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.UsGallonPerSecond)); - unitConverter.SetConversionFunction(VolumeFlowUnit.UsGallonPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).AsBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlowUnit.UsGallonPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); #endif } } diff --git a/UnitsNet/Scripts/Include-GenerateQuantitySourceCodeNetFramework.ps1 b/UnitsNet/Scripts/Include-GenerateQuantitySourceCodeNetFramework.ps1 index 799e99f592..abe62c5f4a 100644 --- a/UnitsNet/Scripts/Include-GenerateQuantitySourceCodeNetFramework.ps1 +++ b/UnitsNet/Scripts/Include-GenerateQuantitySourceCodeNetFramework.ps1 @@ -687,14 +687,14 @@ function GenerateLogarithmicArithmeticOperators([GeneratorArgs]$genArgs) { // Logarithmic addition // Formula: $x*log10(10^(x/$x) + 10^(y/$x)) - return new $quantityName($x*Math.Log10(Math.Pow(10, left.Value/$x) + Math.Pow(10, right.AsBaseNumericType(left.Unit)/$x)), left.Unit); + return new $quantityName($x*Math.Log10(Math.Pow(10, left.Value/$x) + Math.Pow(10, right.GetValueAs(left.Unit)/$x)), left.Unit); } public static $quantityName operator -($quantityName left, $quantityName right) { // Logarithmic subtraction // Formula: $x*log10(10^(x/$x) - 10^(y/$x)) - return new $quantityName($x*Math.Log10(Math.Pow(10, left.Value/$x) - Math.Pow(10, right.AsBaseNumericType(left.Unit)/$x)), left.Unit); + return new $quantityName($x*Math.Log10(Math.Pow(10, left.Value/$x) - Math.Pow(10, right.GetValueAs(left.Unit)/$x)), left.Unit); } public static $quantityName operator *($valueType left, $quantityName right) @@ -718,7 +718,7 @@ function GenerateLogarithmicArithmeticOperators([GeneratorArgs]$genArgs) public static double operator /($quantityName left, $quantityName right) { // Logarithmic division = subtraction - return Convert.ToDouble(left.Value - right.AsBaseNumericType(left.Unit)); + return Convert.ToDouble(left.Value - right.GetValueAs(left.Unit)); } #endregion @@ -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 new $quantityName(left.Value + right.GetValueAs(left.Unit), left.Unit); } public static $quantityName operator -($quantityName left, $quantityName right) { - return new $quantityName(left.Value - right.AsBaseNumericType(left.Unit), left.Unit); + return new $quantityName(left.Value - right.GetValueAs(left.Unit), left.Unit); } public static $quantityName operator *($valueType left, $quantityName right) @@ -794,22 +794,22 @@ function GenerateEqualityAndComparison([GeneratorArgs]$genArgs) if (-not $wrc) {@" public static bool operator <=($quantityName left, $quantityName right) { - return left.Value <= right.AsBaseNumericType(left.Unit); + return left.Value <= right.GetValueAs(left.Unit); } public static bool operator >=($quantityName left, $quantityName right) { - return left.Value >= right.AsBaseNumericType(left.Unit); + return left.Value >= right.GetValueAs(left.Unit); } public static bool operator <($quantityName left, $quantityName right) { - return left.Value < right.AsBaseNumericType(left.Unit); + return left.Value < right.GetValueAs(left.Unit); } public static bool operator >($quantityName left, $quantityName right) { - return left.Value > right.AsBaseNumericType(left.Unit); + return left.Value > right.GetValueAs(left.Unit); } public static bool operator ==($quantityName left, $quantityName right) @@ -836,7 +836,7 @@ $accessModifier = if ($wrc) { "internal" } else { "public" } @" // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods $accessModifier int CompareTo($quantityName other) { - return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + return _value.CompareTo(other.GetValueAs(this.Unit)); } "@; @@ -853,7 +853,7 @@ $accessModifier = if ($wrc) { "internal" } else { "public" } @" public bool Equals($quantityName other) { - return _value.Equals(other.AsBaseNumericType(this.Unit)); + return _value.Equals(other.GetValueAs(this.Unit)); } /// @@ -938,7 +938,7 @@ function GenerateConversionMethods([GeneratorArgs]$genArgs) if(Unit == unit) return Convert.ToDouble(Value); - var converted = AsBaseNumericType(unit); + var converted = GetValueAs(unit); return Convert.ToDouble(converted); } @@ -948,7 +948,7 @@ function GenerateConversionMethods([GeneratorArgs]$genArgs) /// A $quantityName with the specified unit. public $quantityName ToUnit($unitEnumName unit) { - var convertedValue = AsBaseNumericType(unit); + var convertedValue = GetValueAs(unit); return new $quantityName(convertedValue, unit); } @@ -957,27 +957,36 @@ function GenerateConversionMethods([GeneratorArgs]$genArgs) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - internal $quantityName AsBaseUnit() + private $valueType GetValueInBaseUnit() { switch(Unit) { "@; foreach ($unit in $units) { $func = $unit.FromUnitToBaseFunc.Replace("x", "_value");@" - case $unitEnumName.$($unit.SingularName): - return new $quantityName($func, BaseUnit); + case $unitEnumName.$($unit.SingularName): return $func; "@; }@" default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } } - private $valueType AsBaseNumericType($unitEnumName unit) + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal $quantityName ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new $quantityName(baseUnitValue, BaseUnit); + } + + private $valueType GetValueAs($unitEnumName unit) { if(Unit == unit) return _value; - var asBaseUnit = AsBaseUnit(); - var baseUnitValue = asBaseUnit._value; + var baseUnitValue = GetValueInBaseUnit(); switch(unit) { diff --git a/UnitsNet/Scripts/Include-GenerateUnitConverterDefaultSourceCode.ps1 b/UnitsNet/Scripts/Include-GenerateUnitConverterDefaultSourceCode.ps1 index 6cc0ff73d6..ab2520fd8c 100644 --- a/UnitsNet/Scripts/Include-GenerateUnitConverterDefaultSourceCode.ps1 +++ b/UnitsNet/Scripts/Include-GenerateUnitConverterDefaultSourceCode.ps1 @@ -71,7 +71,7 @@ foreach ($quantity in $quantities) { @" unitConverter.SetConversionFunction<$quantityName>($quantityName.BaseUnit, $unitEnumName.$enumValue, (q) => (($quantityName)q).ToUnit($unitEnumName.$enumValue)); - unitConverter.SetConversionFunction<$quantityName>($unitEnumName.$enumValue, $quantityName.BaseUnit, (q) => (($quantityName)q).AsBaseUnit()); + unitConverter.SetConversionFunction<$quantityName>($unitEnumName.$enumValue, $quantityName.BaseUnit, (q) => (($quantityName)q).ToBaseUnit()); "@; } } From ad313fac01a1957b16ebf147659cd5f193af1bdb Mon Sep 17 00:00:00 2001 From: Tristan Milnthorp Date: Tue, 19 Feb 2019 11:49:23 -0500 Subject: [PATCH 07/21] Regen WRC --- .../Acceleration.WindowsRuntimeComponent.g.cs | 25 +++----- ...ntOfSubstance.WindowsRuntimeComponent.g.cs | 25 +++----- ...mplitudeRatio.WindowsRuntimeComponent.g.cs | 25 +++----- .../Angle.WindowsRuntimeComponent.g.cs | 25 +++----- ...pparentEnergy.WindowsRuntimeComponent.g.cs | 25 +++----- ...ApparentPower.WindowsRuntimeComponent.g.cs | 25 +++----- .../Area.WindowsRuntimeComponent.g.cs | 25 +++----- .../AreaDensity.WindowsRuntimeComponent.g.cs | 25 +++----- ...mentOfInertia.WindowsRuntimeComponent.g.cs | 25 +++----- .../BitRate.WindowsRuntimeComponent.g.cs | 25 +++----- ...elConsumption.WindowsRuntimeComponent.g.cs | 25 +++----- .../Capacitance.WindowsRuntimeComponent.g.cs | 25 +++----- ...rmalExpansion.WindowsRuntimeComponent.g.cs | 25 +++----- .../Density.WindowsRuntimeComponent.g.cs | 25 +++----- .../Duration.WindowsRuntimeComponent.g.cs | 25 +++----- ...amicViscosity.WindowsRuntimeComponent.g.cs | 25 +++----- ...ricAdmittance.WindowsRuntimeComponent.g.cs | 25 +++----- ...lectricCharge.WindowsRuntimeComponent.g.cs | 25 +++----- ...ChargeDensity.WindowsRuntimeComponent.g.cs | 25 +++----- ...icConductance.WindowsRuntimeComponent.g.cs | 25 +++----- ...cConductivity.WindowsRuntimeComponent.g.cs | 25 +++----- ...ectricCurrent.WindowsRuntimeComponent.g.cs | 25 +++----- ...urrentDensity.WindowsRuntimeComponent.g.cs | 25 +++----- ...rrentGradient.WindowsRuntimeComponent.g.cs | 25 +++----- ...ElectricField.WindowsRuntimeComponent.g.cs | 25 +++----- ...ricInductance.WindowsRuntimeComponent.g.cs | 25 +++----- ...tricPotential.WindowsRuntimeComponent.g.cs | 25 +++----- ...icPotentialAc.WindowsRuntimeComponent.g.cs | 25 +++----- ...icPotentialDc.WindowsRuntimeComponent.g.cs | 25 +++----- ...ricResistance.WindowsRuntimeComponent.g.cs | 25 +++----- ...icResistivity.WindowsRuntimeComponent.g.cs | 25 +++----- .../Energy.WindowsRuntimeComponent.g.cs | 25 +++----- .../Entropy.WindowsRuntimeComponent.g.cs | 25 +++----- .../Force.WindowsRuntimeComponent.g.cs | 25 +++----- ...rceChangeRate.WindowsRuntimeComponent.g.cs | 25 +++----- ...orcePerLength.WindowsRuntimeComponent.g.cs | 25 +++----- .../Frequency.WindowsRuntimeComponent.g.cs | 25 +++----- .../HeatFlux.WindowsRuntimeComponent.g.cs | 25 +++----- ...erCoefficient.WindowsRuntimeComponent.g.cs | 25 +++----- .../Illuminance.WindowsRuntimeComponent.g.cs | 25 +++----- .../Information.WindowsRuntimeComponent.g.cs | 25 +++----- .../Irradiance.WindowsRuntimeComponent.g.cs | 25 +++----- .../Irradiation.WindowsRuntimeComponent.g.cs | 59 +++++++++++++------ ...aticViscosity.WindowsRuntimeComponent.g.cs | 25 +++----- .../LapseRate.WindowsRuntimeComponent.g.cs | 25 +++----- .../Length.WindowsRuntimeComponent.g.cs | 25 +++----- .../Level.WindowsRuntimeComponent.g.cs | 25 +++----- ...LinearDensity.WindowsRuntimeComponent.g.cs | 25 +++----- .../LuminousFlux.WindowsRuntimeComponent.g.cs | 25 +++----- ...nousIntensity.WindowsRuntimeComponent.g.cs | 25 +++----- ...MagneticField.WindowsRuntimeComponent.g.cs | 25 +++----- .../MagneticFlux.WindowsRuntimeComponent.g.cs | 25 +++----- ...Magnetization.WindowsRuntimeComponent.g.cs | 25 +++----- .../Mass.WindowsRuntimeComponent.g.cs | 25 +++----- .../MassFlow.WindowsRuntimeComponent.g.cs | 25 +++----- .../MassFlux.WindowsRuntimeComponent.g.cs | 25 +++----- ...mentOfInertia.WindowsRuntimeComponent.g.cs | 25 +++----- .../MolarEnergy.WindowsRuntimeComponent.g.cs | 25 +++----- .../MolarEntropy.WindowsRuntimeComponent.g.cs | 25 +++----- .../MolarMass.WindowsRuntimeComponent.g.cs | 25 +++----- .../Molarity.WindowsRuntimeComponent.g.cs | 25 +++----- .../Permeability.WindowsRuntimeComponent.g.cs | 25 +++----- .../Permittivity.WindowsRuntimeComponent.g.cs | 25 +++----- .../Power.WindowsRuntimeComponent.g.cs | 25 +++----- .../PowerDensity.WindowsRuntimeComponent.g.cs | 25 +++----- .../PowerRatio.WindowsRuntimeComponent.g.cs | 25 +++----- .../Pressure.WindowsRuntimeComponent.g.cs | 25 +++----- ...ureChangeRate.WindowsRuntimeComponent.g.cs | 25 +++----- .../Ratio.WindowsRuntimeComponent.g.cs | 25 +++----- ...eactiveEnergy.WindowsRuntimeComponent.g.cs | 25 +++----- ...ReactivePower.WindowsRuntimeComponent.g.cs | 25 +++----- ...lAcceleration.WindowsRuntimeComponent.g.cs | 25 +++----- ...tationalSpeed.WindowsRuntimeComponent.g.cs | 25 +++----- ...onalStiffness.WindowsRuntimeComponent.g.cs | 25 +++----- ...nessPerLength.WindowsRuntimeComponent.g.cs | 25 +++----- .../SolidAngle.WindowsRuntimeComponent.g.cs | 25 +++----- ...pecificEnergy.WindowsRuntimeComponent.g.cs | 25 +++----- ...ecificEntropy.WindowsRuntimeComponent.g.cs | 25 +++----- ...pecificVolume.WindowsRuntimeComponent.g.cs | 25 +++----- ...pecificWeight.WindowsRuntimeComponent.g.cs | 25 +++----- .../Speed.WindowsRuntimeComponent.g.cs | 25 +++----- .../Temperature.WindowsRuntimeComponent.g.cs | 25 +++----- ...ureChangeRate.WindowsRuntimeComponent.g.cs | 25 +++----- ...peratureDelta.WindowsRuntimeComponent.g.cs | 25 +++----- ...lConductivity.WindowsRuntimeComponent.g.cs | 25 +++----- ...malResistance.WindowsRuntimeComponent.g.cs | 25 +++----- .../Torque.WindowsRuntimeComponent.g.cs | 25 +++----- .../VitaminA.WindowsRuntimeComponent.g.cs | 25 +++----- .../Volume.WindowsRuntimeComponent.g.cs | 25 +++----- .../VolumeFlow.WindowsRuntimeComponent.g.cs | 25 +++----- .../GeneratedCode/UnitAbbreviationsCache.g.cs | 2 + .../GeneratedCode/Units/IrradiationUnit.g.cs | 2 + 92 files changed, 668 insertions(+), 1620 deletions(-) diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Acceleration.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Acceleration.WindowsRuntimeComponent.g.cs index 09b2ee617c..5a24b4703d 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Acceleration.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Acceleration.WindowsRuntimeComponent.g.cs @@ -574,7 +574,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Acceleration other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -588,7 +588,7 @@ public override bool Equals(object obj) public bool Equals(Acceleration other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -666,7 +666,7 @@ public double As(AccelerationUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -676,7 +676,7 @@ public double As(AccelerationUnit unit) /// A Acceleration with the specified unit. public Acceleration ToUnit(AccelerationUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new Acceleration(convertedValue, unit); } @@ -685,7 +685,7 @@ public Acceleration ToUnit(AccelerationUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -707,23 +707,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal Acceleration ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new Acceleration(baseUnitValue, BaseUnit); - } - - private double GetValueAs(AccelerationUnit unit) + private double AsBaseNumericType(AccelerationUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmountOfSubstance.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmountOfSubstance.WindowsRuntimeComponent.g.cs index fb2cdd5174..74eaf49233 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmountOfSubstance.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmountOfSubstance.WindowsRuntimeComponent.g.cs @@ -604,7 +604,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(AmountOfSubstance other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -618,7 +618,7 @@ public override bool Equals(object obj) public bool Equals(AmountOfSubstance other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -696,7 +696,7 @@ public double As(AmountOfSubstanceUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -706,7 +706,7 @@ public double As(AmountOfSubstanceUnit unit) /// A AmountOfSubstance with the specified unit. public AmountOfSubstance ToUnit(AmountOfSubstanceUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new AmountOfSubstance(convertedValue, unit); } @@ -715,7 +715,7 @@ public AmountOfSubstance ToUnit(AmountOfSubstanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -739,23 +739,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal AmountOfSubstance ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new AmountOfSubstance(baseUnitValue, BaseUnit); - } - - private double GetValueAs(AmountOfSubstanceUnit unit) + private double AsBaseNumericType(AmountOfSubstanceUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmplitudeRatio.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmplitudeRatio.WindowsRuntimeComponent.g.cs index d301c88173..6fedad2667 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmplitudeRatio.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmplitudeRatio.WindowsRuntimeComponent.g.cs @@ -439,7 +439,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(AmplitudeRatio other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -453,7 +453,7 @@ public override bool Equals(object obj) public bool Equals(AmplitudeRatio other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -531,7 +531,7 @@ public double As(AmplitudeRatioUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -541,7 +541,7 @@ public double As(AmplitudeRatioUnit unit) /// A AmplitudeRatio with the specified unit. public AmplitudeRatio ToUnit(AmplitudeRatioUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new AmplitudeRatio(convertedValue, unit); } @@ -550,7 +550,7 @@ public AmplitudeRatio ToUnit(AmplitudeRatioUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -563,23 +563,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal AmplitudeRatio ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new AmplitudeRatio(baseUnitValue, BaseUnit); - } - - private double GetValueAs(AmplitudeRatioUnit unit) + private double AsBaseNumericType(AmplitudeRatioUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Angle.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Angle.WindowsRuntimeComponent.g.cs index a62dc42add..0a7b132b6a 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Angle.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Angle.WindowsRuntimeComponent.g.cs @@ -589,7 +589,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Angle other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -603,7 +603,7 @@ public override bool Equals(object obj) public bool Equals(Angle other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -681,7 +681,7 @@ public double As(AngleUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -691,7 +691,7 @@ public double As(AngleUnit unit) /// A Angle with the specified unit. public Angle ToUnit(AngleUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new Angle(convertedValue, unit); } @@ -700,7 +700,7 @@ public Angle ToUnit(AngleUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -723,23 +723,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal Angle ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new Angle(baseUnitValue, BaseUnit); - } - - private double GetValueAs(AngleUnit unit) + private double AsBaseNumericType(AngleUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentEnergy.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentEnergy.WindowsRuntimeComponent.g.cs index dc2310526a..02491d430c 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentEnergy.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentEnergy.WindowsRuntimeComponent.g.cs @@ -424,7 +424,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ApparentEnergy other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -438,7 +438,7 @@ public override bool Equals(object obj) public bool Equals(ApparentEnergy other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -516,7 +516,7 @@ public double As(ApparentEnergyUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -526,7 +526,7 @@ public double As(ApparentEnergyUnit unit) /// A ApparentEnergy with the specified unit. public ApparentEnergy ToUnit(ApparentEnergyUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new ApparentEnergy(convertedValue, unit); } @@ -535,7 +535,7 @@ public ApparentEnergy ToUnit(ApparentEnergyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -547,23 +547,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal ApparentEnergy ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new ApparentEnergy(baseUnitValue, BaseUnit); - } - - private double GetValueAs(ApparentEnergyUnit unit) + private double AsBaseNumericType(ApparentEnergyUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentPower.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentPower.WindowsRuntimeComponent.g.cs index 2e0e24582c..736c4a799a 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentPower.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentPower.WindowsRuntimeComponent.g.cs @@ -439,7 +439,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ApparentPower other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -453,7 +453,7 @@ public override bool Equals(object obj) public bool Equals(ApparentPower other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -531,7 +531,7 @@ public double As(ApparentPowerUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -541,7 +541,7 @@ public double As(ApparentPowerUnit unit) /// A ApparentPower with the specified unit. public ApparentPower ToUnit(ApparentPowerUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new ApparentPower(convertedValue, unit); } @@ -550,7 +550,7 @@ public ApparentPower ToUnit(ApparentPowerUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -563,23 +563,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal ApparentPower ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new ApparentPower(baseUnitValue, BaseUnit); - } - - private double GetValueAs(ApparentPowerUnit unit) + private double AsBaseNumericType(ApparentPowerUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Area.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Area.WindowsRuntimeComponent.g.cs index f22f214d87..5ea87fb206 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Area.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Area.WindowsRuntimeComponent.g.cs @@ -574,7 +574,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Area other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -588,7 +588,7 @@ public override bool Equals(object obj) public bool Equals(Area other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -666,7 +666,7 @@ public double As(AreaUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -676,7 +676,7 @@ public double As(AreaUnit unit) /// A Area with the specified unit. public Area ToUnit(AreaUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new Area(convertedValue, unit); } @@ -685,7 +685,7 @@ public Area ToUnit(AreaUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -707,23 +707,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal Area ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new Area(baseUnitValue, BaseUnit); - } - - private double GetValueAs(AreaUnit unit) + private double AsBaseNumericType(AreaUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaDensity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaDensity.WindowsRuntimeComponent.g.cs index 20dc51e586..3614a5d136 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaDensity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaDensity.WindowsRuntimeComponent.g.cs @@ -394,7 +394,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(AreaDensity other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -408,7 +408,7 @@ public override bool Equals(object obj) public bool Equals(AreaDensity other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -486,7 +486,7 @@ public double As(AreaDensityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -496,7 +496,7 @@ public double As(AreaDensityUnit unit) /// A AreaDensity with the specified unit. public AreaDensity ToUnit(AreaDensityUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new AreaDensity(convertedValue, unit); } @@ -505,7 +505,7 @@ public AreaDensity ToUnit(AreaDensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -515,23 +515,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal AreaDensity ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new AreaDensity(baseUnitValue, BaseUnit); - } - - private double GetValueAs(AreaDensityUnit unit) + private double AsBaseNumericType(AreaDensityUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaMomentOfInertia.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaMomentOfInertia.WindowsRuntimeComponent.g.cs index 2261fd677e..88d37ff555 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaMomentOfInertia.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaMomentOfInertia.WindowsRuntimeComponent.g.cs @@ -469,7 +469,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(AreaMomentOfInertia other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -483,7 +483,7 @@ public override bool Equals(object obj) public bool Equals(AreaMomentOfInertia other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -561,7 +561,7 @@ public double As(AreaMomentOfInertiaUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -571,7 +571,7 @@ public double As(AreaMomentOfInertiaUnit unit) /// A AreaMomentOfInertia with the specified unit. public AreaMomentOfInertia ToUnit(AreaMomentOfInertiaUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new AreaMomentOfInertia(convertedValue, unit); } @@ -580,7 +580,7 @@ public AreaMomentOfInertia ToUnit(AreaMomentOfInertiaUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -595,23 +595,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal AreaMomentOfInertia ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new AreaMomentOfInertia(baseUnitValue, BaseUnit); - } - - private double GetValueAs(AreaMomentOfInertiaUnit unit) + private double AsBaseNumericType(AreaMomentOfInertiaUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BitRate.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BitRate.WindowsRuntimeComponent.g.cs index d4d3af10ab..34257f37d1 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BitRate.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BitRate.WindowsRuntimeComponent.g.cs @@ -772,7 +772,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(BitRate other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -786,7 +786,7 @@ public override bool Equals(object obj) public bool Equals(BitRate other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -864,7 +864,7 @@ public double As(BitRateUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -874,7 +874,7 @@ public double As(BitRateUnit unit) /// A BitRate with the specified unit. public BitRate ToUnit(BitRateUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new BitRate(convertedValue, unit); } @@ -883,7 +883,7 @@ public BitRate ToUnit(BitRateUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private decimal GetValueInBaseUnit() + private decimal AsBaseUnit() { switch(Unit) { @@ -918,23 +918,12 @@ private decimal GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal BitRate ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new BitRate(baseUnitValue, BaseUnit); - } - - private decimal GetValueAs(BitRateUnit unit) + private decimal AsBaseNumericType(BitRateUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.WindowsRuntimeComponent.g.cs index 9c72509017..3dbfb0e34f 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.WindowsRuntimeComponent.g.cs @@ -424,7 +424,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(BrakeSpecificFuelConsumption other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -438,7 +438,7 @@ public override bool Equals(object obj) public bool Equals(BrakeSpecificFuelConsumption other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -516,7 +516,7 @@ public double As(BrakeSpecificFuelConsumptionUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -526,7 +526,7 @@ public double As(BrakeSpecificFuelConsumptionUnit unit) /// A BrakeSpecificFuelConsumption with the specified unit. public BrakeSpecificFuelConsumption ToUnit(BrakeSpecificFuelConsumptionUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new BrakeSpecificFuelConsumption(convertedValue, unit); } @@ -535,7 +535,7 @@ public BrakeSpecificFuelConsumption ToUnit(BrakeSpecificFuelConsumptionUnit unit /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -547,23 +547,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal BrakeSpecificFuelConsumption ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new BrakeSpecificFuelConsumption(baseUnitValue, BaseUnit); - } - - private double GetValueAs(BrakeSpecificFuelConsumptionUnit unit) + private double AsBaseNumericType(BrakeSpecificFuelConsumptionUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Capacitance.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Capacitance.WindowsRuntimeComponent.g.cs index e9df44c0e1..6117f22269 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Capacitance.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Capacitance.WindowsRuntimeComponent.g.cs @@ -487,7 +487,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Capacitance other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -501,7 +501,7 @@ public override bool Equals(object obj) public bool Equals(Capacitance other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -579,7 +579,7 @@ public double As(CapacitanceUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -589,7 +589,7 @@ public double As(CapacitanceUnit unit) /// A Capacitance with the specified unit. public Capacitance ToUnit(CapacitanceUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new Capacitance(convertedValue, unit); } @@ -598,7 +598,7 @@ public Capacitance ToUnit(CapacitanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -614,23 +614,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal Capacitance ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new Capacitance(baseUnitValue, BaseUnit); - } - - private double GetValueAs(CapacitanceUnit unit) + private double AsBaseNumericType(CapacitanceUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/CoefficientOfThermalExpansion.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/CoefficientOfThermalExpansion.WindowsRuntimeComponent.g.cs index 17cf82bbbf..1c20fbc596 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/CoefficientOfThermalExpansion.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/CoefficientOfThermalExpansion.WindowsRuntimeComponent.g.cs @@ -424,7 +424,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(CoefficientOfThermalExpansion other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -438,7 +438,7 @@ public override bool Equals(object obj) public bool Equals(CoefficientOfThermalExpansion other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -516,7 +516,7 @@ public double As(CoefficientOfThermalExpansionUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -526,7 +526,7 @@ public double As(CoefficientOfThermalExpansionUnit unit) /// A CoefficientOfThermalExpansion with the specified unit. public CoefficientOfThermalExpansion ToUnit(CoefficientOfThermalExpansionUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new CoefficientOfThermalExpansion(convertedValue, unit); } @@ -535,7 +535,7 @@ public CoefficientOfThermalExpansion ToUnit(CoefficientOfThermalExpansionUnit un /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -547,23 +547,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal CoefficientOfThermalExpansion ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new CoefficientOfThermalExpansion(baseUnitValue, BaseUnit); - } - - private double GetValueAs(CoefficientOfThermalExpansionUnit unit) + private double AsBaseNumericType(CoefficientOfThermalExpansionUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Density.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Density.WindowsRuntimeComponent.g.cs index cf95036907..77734f6274 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Density.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Density.WindowsRuntimeComponent.g.cs @@ -967,7 +967,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Density other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -981,7 +981,7 @@ public override bool Equals(object obj) public bool Equals(Density other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -1059,7 +1059,7 @@ public double As(DensityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -1069,7 +1069,7 @@ public double As(DensityUnit unit) /// A Density with the specified unit. public Density ToUnit(DensityUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new Density(convertedValue, unit); } @@ -1078,7 +1078,7 @@ public Density ToUnit(DensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -1126,23 +1126,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal Density ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new Density(baseUnitValue, BaseUnit); - } - - private double GetValueAs(DensityUnit unit) + private double AsBaseNumericType(DensityUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Duration.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Duration.WindowsRuntimeComponent.g.cs index a536406e43..8a314fcdaa 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Duration.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Duration.WindowsRuntimeComponent.g.cs @@ -529,7 +529,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Duration other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -543,7 +543,7 @@ public override bool Equals(object obj) public bool Equals(Duration other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -621,7 +621,7 @@ public double As(DurationUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -631,7 +631,7 @@ public double As(DurationUnit unit) /// A Duration with the specified unit. public Duration ToUnit(DurationUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new Duration(convertedValue, unit); } @@ -640,7 +640,7 @@ public Duration ToUnit(DurationUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -659,23 +659,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal Duration ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new Duration(baseUnitValue, BaseUnit); - } - - private double GetValueAs(DurationUnit unit) + private double AsBaseNumericType(DurationUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/DynamicViscosity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/DynamicViscosity.WindowsRuntimeComponent.g.cs index 9410a4a403..a1c3056e66 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/DynamicViscosity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/DynamicViscosity.WindowsRuntimeComponent.g.cs @@ -472,7 +472,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(DynamicViscosity other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -486,7 +486,7 @@ public override bool Equals(object obj) public bool Equals(DynamicViscosity other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -564,7 +564,7 @@ public double As(DynamicViscosityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -574,7 +574,7 @@ public double As(DynamicViscosityUnit unit) /// A DynamicViscosity with the specified unit. public DynamicViscosity ToUnit(DynamicViscosityUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new DynamicViscosity(convertedValue, unit); } @@ -583,7 +583,7 @@ public DynamicViscosity ToUnit(DynamicViscosityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -598,23 +598,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal DynamicViscosity ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new DynamicViscosity(baseUnitValue, BaseUnit); - } - - private double GetValueAs(DynamicViscosityUnit unit) + private double AsBaseNumericType(DynamicViscosityUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricAdmittance.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricAdmittance.WindowsRuntimeComponent.g.cs index 2dc8b564ee..d9450f3c66 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricAdmittance.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricAdmittance.WindowsRuntimeComponent.g.cs @@ -439,7 +439,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ElectricAdmittance other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -453,7 +453,7 @@ public override bool Equals(object obj) public bool Equals(ElectricAdmittance other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -531,7 +531,7 @@ public double As(ElectricAdmittanceUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -541,7 +541,7 @@ public double As(ElectricAdmittanceUnit unit) /// A ElectricAdmittance with the specified unit. public ElectricAdmittance ToUnit(ElectricAdmittanceUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new ElectricAdmittance(convertedValue, unit); } @@ -550,7 +550,7 @@ public ElectricAdmittance ToUnit(ElectricAdmittanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -563,23 +563,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal ElectricAdmittance ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new ElectricAdmittance(baseUnitValue, BaseUnit); - } - - private double GetValueAs(ElectricAdmittanceUnit unit) + private double AsBaseNumericType(ElectricAdmittanceUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCharge.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCharge.WindowsRuntimeComponent.g.cs index abad655097..dac584fb59 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCharge.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCharge.WindowsRuntimeComponent.g.cs @@ -397,7 +397,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ElectricCharge other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -411,7 +411,7 @@ public override bool Equals(object obj) public bool Equals(ElectricCharge other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -489,7 +489,7 @@ public double As(ElectricChargeUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -499,7 +499,7 @@ public double As(ElectricChargeUnit unit) /// A ElectricCharge with the specified unit. public ElectricCharge ToUnit(ElectricChargeUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new ElectricCharge(convertedValue, unit); } @@ -508,7 +508,7 @@ public ElectricCharge ToUnit(ElectricChargeUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -518,23 +518,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal ElectricCharge ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new ElectricCharge(baseUnitValue, BaseUnit); - } - - private double GetValueAs(ElectricChargeUnit unit) + private double AsBaseNumericType(ElectricChargeUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricChargeDensity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricChargeDensity.WindowsRuntimeComponent.g.cs index ee4a8629e1..8ec2b6148b 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricChargeDensity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricChargeDensity.WindowsRuntimeComponent.g.cs @@ -397,7 +397,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ElectricChargeDensity other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -411,7 +411,7 @@ public override bool Equals(object obj) public bool Equals(ElectricChargeDensity other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -489,7 +489,7 @@ public double As(ElectricChargeDensityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -499,7 +499,7 @@ public double As(ElectricChargeDensityUnit unit) /// A ElectricChargeDensity with the specified unit. public ElectricChargeDensity ToUnit(ElectricChargeDensityUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new ElectricChargeDensity(convertedValue, unit); } @@ -508,7 +508,7 @@ public ElectricChargeDensity ToUnit(ElectricChargeDensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -518,23 +518,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal ElectricChargeDensity ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new ElectricChargeDensity(baseUnitValue, BaseUnit); - } - - private double GetValueAs(ElectricChargeDensityUnit unit) + private double AsBaseNumericType(ElectricChargeDensityUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductance.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductance.WindowsRuntimeComponent.g.cs index 7fd0008b90..3b7cb40c27 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductance.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductance.WindowsRuntimeComponent.g.cs @@ -427,7 +427,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ElectricConductance other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -441,7 +441,7 @@ public override bool Equals(object obj) public bool Equals(ElectricConductance other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -519,7 +519,7 @@ public double As(ElectricConductanceUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -529,7 +529,7 @@ public double As(ElectricConductanceUnit unit) /// A ElectricConductance with the specified unit. public ElectricConductance ToUnit(ElectricConductanceUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new ElectricConductance(convertedValue, unit); } @@ -538,7 +538,7 @@ public ElectricConductance ToUnit(ElectricConductanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -550,23 +550,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal ElectricConductance ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new ElectricConductance(baseUnitValue, BaseUnit); - } - - private double GetValueAs(ElectricConductanceUnit unit) + private double AsBaseNumericType(ElectricConductanceUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductivity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductivity.WindowsRuntimeComponent.g.cs index 3fb073a303..cb1b3d25c0 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductivity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductivity.WindowsRuntimeComponent.g.cs @@ -397,7 +397,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ElectricConductivity other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -411,7 +411,7 @@ public override bool Equals(object obj) public bool Equals(ElectricConductivity other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -489,7 +489,7 @@ public double As(ElectricConductivityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -499,7 +499,7 @@ public double As(ElectricConductivityUnit unit) /// A ElectricConductivity with the specified unit. public ElectricConductivity ToUnit(ElectricConductivityUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new ElectricConductivity(convertedValue, unit); } @@ -508,7 +508,7 @@ public ElectricConductivity ToUnit(ElectricConductivityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -518,23 +518,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal ElectricConductivity ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new ElectricConductivity(baseUnitValue, BaseUnit); - } - - private double GetValueAs(ElectricConductivityUnit unit) + private double AsBaseNumericType(ElectricConductivityUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrent.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrent.WindowsRuntimeComponent.g.cs index 890c95689b..81a13b19de 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrent.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrent.WindowsRuntimeComponent.g.cs @@ -499,7 +499,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ElectricCurrent other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -513,7 +513,7 @@ public override bool Equals(object obj) public bool Equals(ElectricCurrent other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -591,7 +591,7 @@ public double As(ElectricCurrentUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -601,7 +601,7 @@ public double As(ElectricCurrentUnit unit) /// A ElectricCurrent with the specified unit. public ElectricCurrent ToUnit(ElectricCurrentUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new ElectricCurrent(convertedValue, unit); } @@ -610,7 +610,7 @@ public ElectricCurrent ToUnit(ElectricCurrentUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -627,23 +627,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal ElectricCurrent ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new ElectricCurrent(baseUnitValue, BaseUnit); - } - - private double GetValueAs(ElectricCurrentUnit unit) + private double AsBaseNumericType(ElectricCurrentUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentDensity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentDensity.WindowsRuntimeComponent.g.cs index d47d3e216f..29294a8f7d 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentDensity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentDensity.WindowsRuntimeComponent.g.cs @@ -397,7 +397,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ElectricCurrentDensity other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -411,7 +411,7 @@ public override bool Equals(object obj) public bool Equals(ElectricCurrentDensity other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -489,7 +489,7 @@ public double As(ElectricCurrentDensityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -499,7 +499,7 @@ public double As(ElectricCurrentDensityUnit unit) /// A ElectricCurrentDensity with the specified unit. public ElectricCurrentDensity ToUnit(ElectricCurrentDensityUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new ElectricCurrentDensity(convertedValue, unit); } @@ -508,7 +508,7 @@ public ElectricCurrentDensity ToUnit(ElectricCurrentDensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -518,23 +518,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal ElectricCurrentDensity ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new ElectricCurrentDensity(baseUnitValue, BaseUnit); - } - - private double GetValueAs(ElectricCurrentDensityUnit unit) + private double AsBaseNumericType(ElectricCurrentDensityUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentGradient.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentGradient.WindowsRuntimeComponent.g.cs index 9dabbb447d..1c3272bf3e 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentGradient.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentGradient.WindowsRuntimeComponent.g.cs @@ -394,7 +394,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ElectricCurrentGradient other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -408,7 +408,7 @@ public override bool Equals(object obj) public bool Equals(ElectricCurrentGradient other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -486,7 +486,7 @@ public double As(ElectricCurrentGradientUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -496,7 +496,7 @@ public double As(ElectricCurrentGradientUnit unit) /// A ElectricCurrentGradient with the specified unit. public ElectricCurrentGradient ToUnit(ElectricCurrentGradientUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new ElectricCurrentGradient(convertedValue, unit); } @@ -505,7 +505,7 @@ public ElectricCurrentGradient ToUnit(ElectricCurrentGradientUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -515,23 +515,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal ElectricCurrentGradient ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new ElectricCurrentGradient(baseUnitValue, BaseUnit); - } - - private double GetValueAs(ElectricCurrentGradientUnit unit) + private double AsBaseNumericType(ElectricCurrentGradientUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricField.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricField.WindowsRuntimeComponent.g.cs index 296636a19e..e9ab0ab2d3 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricField.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricField.WindowsRuntimeComponent.g.cs @@ -397,7 +397,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ElectricField other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -411,7 +411,7 @@ public override bool Equals(object obj) public bool Equals(ElectricField other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -489,7 +489,7 @@ public double As(ElectricFieldUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -499,7 +499,7 @@ public double As(ElectricFieldUnit unit) /// A ElectricField with the specified unit. public ElectricField ToUnit(ElectricFieldUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new ElectricField(convertedValue, unit); } @@ -508,7 +508,7 @@ public ElectricField ToUnit(ElectricFieldUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -518,23 +518,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal ElectricField ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new ElectricField(baseUnitValue, BaseUnit); - } - - private double GetValueAs(ElectricFieldUnit unit) + private double AsBaseNumericType(ElectricFieldUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricInductance.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricInductance.WindowsRuntimeComponent.g.cs index c5a5711909..54098c0ef0 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricInductance.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricInductance.WindowsRuntimeComponent.g.cs @@ -442,7 +442,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ElectricInductance other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -456,7 +456,7 @@ public override bool Equals(object obj) public bool Equals(ElectricInductance other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -534,7 +534,7 @@ public double As(ElectricInductanceUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -544,7 +544,7 @@ public double As(ElectricInductanceUnit unit) /// A ElectricInductance with the specified unit. public ElectricInductance ToUnit(ElectricInductanceUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new ElectricInductance(convertedValue, unit); } @@ -553,7 +553,7 @@ public ElectricInductance ToUnit(ElectricInductanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -566,23 +566,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal ElectricInductance ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new ElectricInductance(baseUnitValue, BaseUnit); - } - - private double GetValueAs(ElectricInductanceUnit unit) + private double AsBaseNumericType(ElectricInductanceUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotential.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotential.WindowsRuntimeComponent.g.cs index 85db3fc02b..415273724a 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotential.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotential.WindowsRuntimeComponent.g.cs @@ -454,7 +454,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ElectricPotential other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -468,7 +468,7 @@ public override bool Equals(object obj) public bool Equals(ElectricPotential other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -546,7 +546,7 @@ public double As(ElectricPotentialUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -556,7 +556,7 @@ public double As(ElectricPotentialUnit unit) /// A ElectricPotential with the specified unit. public ElectricPotential ToUnit(ElectricPotentialUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new ElectricPotential(convertedValue, unit); } @@ -565,7 +565,7 @@ public ElectricPotential ToUnit(ElectricPotentialUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -579,23 +579,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal ElectricPotential ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new ElectricPotential(baseUnitValue, BaseUnit); - } - - private double GetValueAs(ElectricPotentialUnit unit) + private double AsBaseNumericType(ElectricPotentialUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialAc.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialAc.WindowsRuntimeComponent.g.cs index 56a0e23217..752a911dde 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialAc.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialAc.WindowsRuntimeComponent.g.cs @@ -454,7 +454,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ElectricPotentialAc other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -468,7 +468,7 @@ public override bool Equals(object obj) public bool Equals(ElectricPotentialAc other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -546,7 +546,7 @@ public double As(ElectricPotentialAcUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -556,7 +556,7 @@ public double As(ElectricPotentialAcUnit unit) /// A ElectricPotentialAc with the specified unit. public ElectricPotentialAc ToUnit(ElectricPotentialAcUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new ElectricPotentialAc(convertedValue, unit); } @@ -565,7 +565,7 @@ public ElectricPotentialAc ToUnit(ElectricPotentialAcUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -579,23 +579,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal ElectricPotentialAc ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new ElectricPotentialAc(baseUnitValue, BaseUnit); - } - - private double GetValueAs(ElectricPotentialAcUnit unit) + private double AsBaseNumericType(ElectricPotentialAcUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialDc.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialDc.WindowsRuntimeComponent.g.cs index a9c522f7cb..4d65a756af 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialDc.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialDc.WindowsRuntimeComponent.g.cs @@ -454,7 +454,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ElectricPotentialDc other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -468,7 +468,7 @@ public override bool Equals(object obj) public bool Equals(ElectricPotentialDc other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -546,7 +546,7 @@ public double As(ElectricPotentialDcUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -556,7 +556,7 @@ public double As(ElectricPotentialDcUnit unit) /// A ElectricPotentialDc with the specified unit. public ElectricPotentialDc ToUnit(ElectricPotentialDcUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new ElectricPotentialDc(convertedValue, unit); } @@ -565,7 +565,7 @@ public ElectricPotentialDc ToUnit(ElectricPotentialDcUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -579,23 +579,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal ElectricPotentialDc ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new ElectricPotentialDc(baseUnitValue, BaseUnit); - } - - private double GetValueAs(ElectricPotentialDcUnit unit) + private double AsBaseNumericType(ElectricPotentialDcUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistance.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistance.WindowsRuntimeComponent.g.cs index 41ba1d13c9..50cabb6dc6 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistance.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistance.WindowsRuntimeComponent.g.cs @@ -454,7 +454,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ElectricResistance other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -468,7 +468,7 @@ public override bool Equals(object obj) public bool Equals(ElectricResistance other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -546,7 +546,7 @@ public double As(ElectricResistanceUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -556,7 +556,7 @@ public double As(ElectricResistanceUnit unit) /// A ElectricResistance with the specified unit. public ElectricResistance ToUnit(ElectricResistanceUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new ElectricResistance(convertedValue, unit); } @@ -565,7 +565,7 @@ public ElectricResistance ToUnit(ElectricResistanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -579,23 +579,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal ElectricResistance ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new ElectricResistance(baseUnitValue, BaseUnit); - } - - private double GetValueAs(ElectricResistanceUnit unit) + private double AsBaseNumericType(ElectricResistanceUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistivity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistivity.WindowsRuntimeComponent.g.cs index 3213aa3527..3f0fe305d9 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistivity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistivity.WindowsRuntimeComponent.g.cs @@ -592,7 +592,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ElectricResistivity other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -606,7 +606,7 @@ public override bool Equals(object obj) public bool Equals(ElectricResistivity other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -684,7 +684,7 @@ public double As(ElectricResistivityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -694,7 +694,7 @@ public double As(ElectricResistivityUnit unit) /// A ElectricResistivity with the specified unit. public ElectricResistivity ToUnit(ElectricResistivityUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new ElectricResistivity(convertedValue, unit); } @@ -703,7 +703,7 @@ public ElectricResistivity ToUnit(ElectricResistivityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -726,23 +726,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal ElectricResistivity ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new ElectricResistivity(baseUnitValue, BaseUnit); - } - - private double GetValueAs(ElectricResistivityUnit unit) + private double AsBaseNumericType(ElectricResistivityUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Energy.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Energy.WindowsRuntimeComponent.g.cs index 8fb10afb7d..d38f87ac85 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Energy.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Energy.WindowsRuntimeComponent.g.cs @@ -709,7 +709,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Energy other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -723,7 +723,7 @@ public override bool Equals(object obj) public bool Equals(Energy other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -801,7 +801,7 @@ public double As(EnergyUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -811,7 +811,7 @@ public double As(EnergyUnit unit) /// A Energy with the specified unit. public Energy ToUnit(EnergyUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new Energy(convertedValue, unit); } @@ -820,7 +820,7 @@ public Energy ToUnit(EnergyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -851,23 +851,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal Energy ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new Energy(baseUnitValue, BaseUnit); - } - - private double GetValueAs(EnergyUnit unit) + private double AsBaseNumericType(EnergyUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Entropy.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Entropy.WindowsRuntimeComponent.g.cs index 262b4a6d13..e8dd884929 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Entropy.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Entropy.WindowsRuntimeComponent.g.cs @@ -484,7 +484,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Entropy other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -498,7 +498,7 @@ public override bool Equals(object obj) public bool Equals(Entropy other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -576,7 +576,7 @@ public double As(EntropyUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -586,7 +586,7 @@ public double As(EntropyUnit unit) /// A Entropy with the specified unit. public Entropy ToUnit(EntropyUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new Entropy(convertedValue, unit); } @@ -595,7 +595,7 @@ public Entropy ToUnit(EntropyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -611,23 +611,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal Entropy ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new Entropy(baseUnitValue, BaseUnit); - } - - private double GetValueAs(EntropyUnit unit) + private double AsBaseNumericType(EntropyUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Force.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Force.WindowsRuntimeComponent.g.cs index d76f2aef2c..5d50e9b6a2 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Force.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Force.WindowsRuntimeComponent.g.cs @@ -574,7 +574,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Force other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -588,7 +588,7 @@ public override bool Equals(object obj) public bool Equals(Force other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -666,7 +666,7 @@ public double As(ForceUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -676,7 +676,7 @@ public double As(ForceUnit unit) /// A Force with the specified unit. public Force ToUnit(ForceUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new Force(convertedValue, unit); } @@ -685,7 +685,7 @@ public Force ToUnit(ForceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -707,23 +707,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal Force ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new Force(baseUnitValue, BaseUnit); - } - - private double GetValueAs(ForceUnit unit) + private double AsBaseNumericType(ForceUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForceChangeRate.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForceChangeRate.WindowsRuntimeComponent.g.cs index 2da904554e..5e12e1bceb 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForceChangeRate.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForceChangeRate.WindowsRuntimeComponent.g.cs @@ -544,7 +544,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ForceChangeRate other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -558,7 +558,7 @@ public override bool Equals(object obj) public bool Equals(ForceChangeRate other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -636,7 +636,7 @@ public double As(ForceChangeRateUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -646,7 +646,7 @@ public double As(ForceChangeRateUnit unit) /// A ForceChangeRate with the specified unit. public ForceChangeRate ToUnit(ForceChangeRateUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new ForceChangeRate(convertedValue, unit); } @@ -655,7 +655,7 @@ public ForceChangeRate ToUnit(ForceChangeRateUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -675,23 +675,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal ForceChangeRate ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new ForceChangeRate(baseUnitValue, BaseUnit); - } - - private double GetValueAs(ForceChangeRateUnit unit) + private double AsBaseNumericType(ForceChangeRateUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForcePerLength.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForcePerLength.WindowsRuntimeComponent.g.cs index 63eccbc324..7034620f92 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForcePerLength.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForcePerLength.WindowsRuntimeComponent.g.cs @@ -514,7 +514,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ForcePerLength other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -528,7 +528,7 @@ public override bool Equals(object obj) public bool Equals(ForcePerLength other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -606,7 +606,7 @@ public double As(ForcePerLengthUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -616,7 +616,7 @@ public double As(ForcePerLengthUnit unit) /// A ForcePerLength with the specified unit. public ForcePerLength ToUnit(ForcePerLengthUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new ForcePerLength(convertedValue, unit); } @@ -625,7 +625,7 @@ public ForcePerLength ToUnit(ForcePerLengthUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -643,23 +643,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal ForcePerLength ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new ForcePerLength(baseUnitValue, BaseUnit); - } - - private double GetValueAs(ForcePerLengthUnit unit) + private double AsBaseNumericType(ForcePerLengthUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Frequency.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Frequency.WindowsRuntimeComponent.g.cs index dc11e97b35..7e3dfa3d5d 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Frequency.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Frequency.WindowsRuntimeComponent.g.cs @@ -499,7 +499,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Frequency other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -513,7 +513,7 @@ public override bool Equals(object obj) public bool Equals(Frequency other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -591,7 +591,7 @@ public double As(FrequencyUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -601,7 +601,7 @@ public double As(FrequencyUnit unit) /// A Frequency with the specified unit. public Frequency ToUnit(FrequencyUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new Frequency(convertedValue, unit); } @@ -610,7 +610,7 @@ public Frequency ToUnit(FrequencyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -627,23 +627,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal Frequency ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new Frequency(baseUnitValue, BaseUnit); - } - - private double GetValueAs(FrequencyUnit unit) + private double AsBaseNumericType(FrequencyUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatFlux.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatFlux.WindowsRuntimeComponent.g.cs index 5dac165756..1ba40d0a98 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatFlux.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatFlux.WindowsRuntimeComponent.g.cs @@ -649,7 +649,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(HeatFlux other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -663,7 +663,7 @@ public override bool Equals(object obj) public bool Equals(HeatFlux other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -741,7 +741,7 @@ public double As(HeatFluxUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -751,7 +751,7 @@ public double As(HeatFluxUnit unit) /// A HeatFlux with the specified unit. public HeatFlux ToUnit(HeatFluxUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new HeatFlux(convertedValue, unit); } @@ -760,7 +760,7 @@ public HeatFlux ToUnit(HeatFluxUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -787,23 +787,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal HeatFlux ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new HeatFlux(baseUnitValue, BaseUnit); - } - - private double GetValueAs(HeatFluxUnit unit) + private double AsBaseNumericType(HeatFluxUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatTransferCoefficient.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatTransferCoefficient.WindowsRuntimeComponent.g.cs index 41f60d2b02..ce2d7b1062 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatTransferCoefficient.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatTransferCoefficient.WindowsRuntimeComponent.g.cs @@ -409,7 +409,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(HeatTransferCoefficient other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -423,7 +423,7 @@ public override bool Equals(object obj) public bool Equals(HeatTransferCoefficient other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -501,7 +501,7 @@ public double As(HeatTransferCoefficientUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -511,7 +511,7 @@ public double As(HeatTransferCoefficientUnit unit) /// A HeatTransferCoefficient with the specified unit. public HeatTransferCoefficient ToUnit(HeatTransferCoefficientUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new HeatTransferCoefficient(convertedValue, unit); } @@ -520,7 +520,7 @@ public HeatTransferCoefficient ToUnit(HeatTransferCoefficientUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -531,23 +531,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal HeatTransferCoefficient ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new HeatTransferCoefficient(baseUnitValue, BaseUnit); - } - - private double GetValueAs(HeatTransferCoefficientUnit unit) + private double AsBaseNumericType(HeatTransferCoefficientUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Illuminance.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Illuminance.WindowsRuntimeComponent.g.cs index 818192a247..2d348c5a85 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Illuminance.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Illuminance.WindowsRuntimeComponent.g.cs @@ -442,7 +442,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Illuminance other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -456,7 +456,7 @@ public override bool Equals(object obj) public bool Equals(Illuminance other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -534,7 +534,7 @@ public double As(IlluminanceUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -544,7 +544,7 @@ public double As(IlluminanceUnit unit) /// A Illuminance with the specified unit. public Illuminance ToUnit(IlluminanceUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new Illuminance(convertedValue, unit); } @@ -553,7 +553,7 @@ public Illuminance ToUnit(IlluminanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -566,23 +566,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal Illuminance ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new Illuminance(baseUnitValue, BaseUnit); - } - - private double GetValueAs(IlluminanceUnit unit) + private double AsBaseNumericType(IlluminanceUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Information.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Information.WindowsRuntimeComponent.g.cs index a583c53a93..b126d0a891 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Information.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Information.WindowsRuntimeComponent.g.cs @@ -769,7 +769,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Information other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -783,7 +783,7 @@ public override bool Equals(object obj) public bool Equals(Information other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -861,7 +861,7 @@ public double As(InformationUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -871,7 +871,7 @@ public double As(InformationUnit unit) /// A Information with the specified unit. public Information ToUnit(InformationUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new Information(convertedValue, unit); } @@ -880,7 +880,7 @@ public Information ToUnit(InformationUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private decimal GetValueInBaseUnit() + private decimal AsBaseUnit() { switch(Unit) { @@ -915,23 +915,12 @@ private decimal GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal Information ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new Information(baseUnitValue, BaseUnit); - } - - private decimal GetValueAs(InformationUnit unit) + private decimal AsBaseNumericType(InformationUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiance.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiance.WindowsRuntimeComponent.g.cs index d05fbe024a..7979bab277 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiance.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiance.WindowsRuntimeComponent.g.cs @@ -589,7 +589,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Irradiance other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -603,7 +603,7 @@ public override bool Equals(object obj) public bool Equals(Irradiance other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -681,7 +681,7 @@ public double As(IrradianceUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -691,7 +691,7 @@ public double As(IrradianceUnit unit) /// A Irradiance with the specified unit. public Irradiance ToUnit(IrradianceUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new Irradiance(convertedValue, unit); } @@ -700,7 +700,7 @@ public Irradiance ToUnit(IrradianceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -723,23 +723,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal Irradiance ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new Irradiance(baseUnitValue, BaseUnit); - } - - private double GetValueAs(IrradianceUnit unit) + private double AsBaseNumericType(IrradianceUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiation.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiation.WindowsRuntimeComponent.g.cs index 377ab1f591..38a4ed9e7d 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiation.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiation.WindowsRuntimeComponent.g.cs @@ -176,6 +176,11 @@ private Irradiation(double numericValue, IrradiationUnit unit) #region Conversion Properties + /// + /// Get Irradiation in JoulesPerSquareCentimeter. + /// + public double JoulesPerSquareCentimeter => As(IrradiationUnit.JoulePerSquareCentimeter); + /// /// Get Irradiation in JoulesPerSquareMeter. /// @@ -186,6 +191,11 @@ private Irradiation(double numericValue, IrradiationUnit unit) /// public double JoulesPerSquareMillimeter => As(IrradiationUnit.JoulePerSquareMillimeter); + /// + /// Get Irradiation in KilojoulesPerSquareMeter. + /// + public double KilojoulesPerSquareMeter => As(IrradiationUnit.KilojoulePerSquareMeter); + /// /// Get Irradiation in KilowattHoursPerSquareMeter. /// @@ -226,6 +236,16 @@ public static string GetAbbreviation(IrradiationUnit unit, [CanBeNull] string cu #region Static Factory Methods + /// + /// Get Irradiation from JoulesPerSquareCentimeter. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static Irradiation FromJoulesPerSquareCentimeter(double joulespersquarecentimeter) + { + double value = (double) joulespersquarecentimeter; + return new Irradiation(value, IrradiationUnit.JoulePerSquareCentimeter); + } /// /// Get Irradiation from JoulesPerSquareMeter. /// @@ -247,6 +267,16 @@ public static Irradiation FromJoulesPerSquareMillimeter(double joulespersquaremi return new Irradiation(value, IrradiationUnit.JoulePerSquareMillimeter); } /// + /// Get Irradiation from KilojoulesPerSquareMeter. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static Irradiation FromKilojoulesPerSquareMeter(double kilojoulespersquaremeter) + { + double value = (double) kilojoulespersquaremeter; + return new Irradiation(value, IrradiationUnit.KilojoulePerSquareMeter); + } + /// /// Get Irradiation from KilowattHoursPerSquareMeter. /// /// If value is NaN or Infinity. @@ -442,7 +472,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Irradiation other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -456,7 +486,7 @@ public override bool Equals(object obj) public bool Equals(Irradiation other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -534,7 +564,7 @@ public double As(IrradiationUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -544,7 +574,7 @@ public double As(IrradiationUnit unit) /// A Irradiation with the specified unit. public Irradiation ToUnit(IrradiationUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new Irradiation(convertedValue, unit); } @@ -553,12 +583,14 @@ public Irradiation ToUnit(IrradiationUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { + case IrradiationUnit.JoulePerSquareCentimeter: return _value*1e4; case IrradiationUnit.JoulePerSquareMeter: return _value; case IrradiationUnit.JoulePerSquareMillimeter: return _value*1e6; + case IrradiationUnit.KilojoulePerSquareMeter: return (_value) * 1e3d; case IrradiationUnit.KilowattHourPerSquareMeter: return (_value*3600d) * 1e3d; case IrradiationUnit.WattHourPerSquareMeter: return _value*3600d; default: @@ -566,28 +598,19 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal Irradiation ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new Irradiation(baseUnitValue, BaseUnit); - } - - private double GetValueAs(IrradiationUnit unit) + private double AsBaseNumericType(IrradiationUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { + case IrradiationUnit.JoulePerSquareCentimeter: return baseUnitValue/1e4; case IrradiationUnit.JoulePerSquareMeter: return baseUnitValue; case IrradiationUnit.JoulePerSquareMillimeter: return baseUnitValue/1e6; + case IrradiationUnit.KilojoulePerSquareMeter: return (baseUnitValue) / 1e3d; case IrradiationUnit.KilowattHourPerSquareMeter: return (baseUnitValue/3600d) / 1e3d; case IrradiationUnit.WattHourPerSquareMeter: return baseUnitValue/3600d; default: diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/KinematicViscosity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/KinematicViscosity.WindowsRuntimeComponent.g.cs index aeb85c1bd2..47eb862708 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/KinematicViscosity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/KinematicViscosity.WindowsRuntimeComponent.g.cs @@ -502,7 +502,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(KinematicViscosity other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -516,7 +516,7 @@ public override bool Equals(object obj) public bool Equals(KinematicViscosity other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -594,7 +594,7 @@ public double As(KinematicViscosityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -604,7 +604,7 @@ public double As(KinematicViscosityUnit unit) /// A KinematicViscosity with the specified unit. public KinematicViscosity ToUnit(KinematicViscosityUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new KinematicViscosity(convertedValue, unit); } @@ -613,7 +613,7 @@ public KinematicViscosity ToUnit(KinematicViscosityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -630,23 +630,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal KinematicViscosity ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new KinematicViscosity(baseUnitValue, BaseUnit); - } - - private double GetValueAs(KinematicViscosityUnit unit) + private double AsBaseNumericType(KinematicViscosityUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LapseRate.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LapseRate.WindowsRuntimeComponent.g.cs index d97915b19e..e648c2f4b9 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LapseRate.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LapseRate.WindowsRuntimeComponent.g.cs @@ -394,7 +394,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(LapseRate other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -408,7 +408,7 @@ public override bool Equals(object obj) public bool Equals(LapseRate other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -486,7 +486,7 @@ public double As(LapseRateUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -496,7 +496,7 @@ public double As(LapseRateUnit unit) /// A LapseRate with the specified unit. public LapseRate ToUnit(LapseRateUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new LapseRate(convertedValue, unit); } @@ -505,7 +505,7 @@ public LapseRate ToUnit(LapseRateUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -515,23 +515,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal LapseRate ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new LapseRate(baseUnitValue, BaseUnit); - } - - private double GetValueAs(LapseRateUnit unit) + private double AsBaseNumericType(LapseRateUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Length.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Length.WindowsRuntimeComponent.g.cs index d009ff2130..bbd0efe6d5 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Length.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Length.WindowsRuntimeComponent.g.cs @@ -709,7 +709,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Length other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -723,7 +723,7 @@ public override bool Equals(object obj) public bool Equals(Length other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -801,7 +801,7 @@ public double As(LengthUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -811,7 +811,7 @@ public double As(LengthUnit unit) /// A Length with the specified unit. public Length ToUnit(LengthUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new Length(convertedValue, unit); } @@ -820,7 +820,7 @@ public Length ToUnit(LengthUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -851,23 +851,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal Length ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new Length(baseUnitValue, BaseUnit); - } - - private double GetValueAs(LengthUnit unit) + private double AsBaseNumericType(LengthUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Level.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Level.WindowsRuntimeComponent.g.cs index 14974d1768..9a40f7bd34 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Level.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Level.WindowsRuntimeComponent.g.cs @@ -409,7 +409,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Level other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -423,7 +423,7 @@ public override bool Equals(object obj) public bool Equals(Level other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -501,7 +501,7 @@ public double As(LevelUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -511,7 +511,7 @@ public double As(LevelUnit unit) /// A Level with the specified unit. public Level ToUnit(LevelUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new Level(convertedValue, unit); } @@ -520,7 +520,7 @@ public Level ToUnit(LevelUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -531,23 +531,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal Level ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new Level(baseUnitValue, BaseUnit); - } - - private double GetValueAs(LevelUnit unit) + private double AsBaseNumericType(LevelUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearDensity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearDensity.WindowsRuntimeComponent.g.cs index 498f682624..370733f4d1 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearDensity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearDensity.WindowsRuntimeComponent.g.cs @@ -427,7 +427,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(LinearDensity other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -441,7 +441,7 @@ public override bool Equals(object obj) public bool Equals(LinearDensity other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -519,7 +519,7 @@ public double As(LinearDensityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -529,7 +529,7 @@ public double As(LinearDensityUnit unit) /// A LinearDensity with the specified unit. public LinearDensity ToUnit(LinearDensityUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new LinearDensity(convertedValue, unit); } @@ -538,7 +538,7 @@ public LinearDensity ToUnit(LinearDensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -550,23 +550,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal LinearDensity ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new LinearDensity(baseUnitValue, BaseUnit); - } - - private double GetValueAs(LinearDensityUnit unit) + private double AsBaseNumericType(LinearDensityUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousFlux.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousFlux.WindowsRuntimeComponent.g.cs index d1edb8425c..551ebd8d77 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousFlux.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousFlux.WindowsRuntimeComponent.g.cs @@ -397,7 +397,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(LuminousFlux other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -411,7 +411,7 @@ public override bool Equals(object obj) public bool Equals(LuminousFlux other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -489,7 +489,7 @@ public double As(LuminousFluxUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -499,7 +499,7 @@ public double As(LuminousFluxUnit unit) /// A LuminousFlux with the specified unit. public LuminousFlux ToUnit(LuminousFluxUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new LuminousFlux(convertedValue, unit); } @@ -508,7 +508,7 @@ public LuminousFlux ToUnit(LuminousFluxUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -518,23 +518,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal LuminousFlux ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new LuminousFlux(baseUnitValue, BaseUnit); - } - - private double GetValueAs(LuminousFluxUnit unit) + private double AsBaseNumericType(LuminousFluxUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousIntensity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousIntensity.WindowsRuntimeComponent.g.cs index df676ce9f3..d19b219fd6 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousIntensity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousIntensity.WindowsRuntimeComponent.g.cs @@ -397,7 +397,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(LuminousIntensity other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -411,7 +411,7 @@ public override bool Equals(object obj) public bool Equals(LuminousIntensity other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -489,7 +489,7 @@ public double As(LuminousIntensityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -499,7 +499,7 @@ public double As(LuminousIntensityUnit unit) /// A LuminousIntensity with the specified unit. public LuminousIntensity ToUnit(LuminousIntensityUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new LuminousIntensity(convertedValue, unit); } @@ -508,7 +508,7 @@ public LuminousIntensity ToUnit(LuminousIntensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -518,23 +518,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal LuminousIntensity ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new LuminousIntensity(baseUnitValue, BaseUnit); - } - - private double GetValueAs(LuminousIntensityUnit unit) + private double AsBaseNumericType(LuminousIntensityUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticField.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticField.WindowsRuntimeComponent.g.cs index 7b8fa9819b..09052e2e29 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticField.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticField.WindowsRuntimeComponent.g.cs @@ -442,7 +442,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(MagneticField other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -456,7 +456,7 @@ public override bool Equals(object obj) public bool Equals(MagneticField other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -534,7 +534,7 @@ public double As(MagneticFieldUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -544,7 +544,7 @@ public double As(MagneticFieldUnit unit) /// A MagneticField with the specified unit. public MagneticField ToUnit(MagneticFieldUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new MagneticField(convertedValue, unit); } @@ -553,7 +553,7 @@ public MagneticField ToUnit(MagneticFieldUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -566,23 +566,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal MagneticField ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new MagneticField(baseUnitValue, BaseUnit); - } - - private double GetValueAs(MagneticFieldUnit unit) + private double AsBaseNumericType(MagneticFieldUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticFlux.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticFlux.WindowsRuntimeComponent.g.cs index 8fe3948b71..4372595051 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticFlux.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticFlux.WindowsRuntimeComponent.g.cs @@ -397,7 +397,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(MagneticFlux other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -411,7 +411,7 @@ public override bool Equals(object obj) public bool Equals(MagneticFlux other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -489,7 +489,7 @@ public double As(MagneticFluxUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -499,7 +499,7 @@ public double As(MagneticFluxUnit unit) /// A MagneticFlux with the specified unit. public MagneticFlux ToUnit(MagneticFluxUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new MagneticFlux(convertedValue, unit); } @@ -508,7 +508,7 @@ public MagneticFlux ToUnit(MagneticFluxUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -518,23 +518,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal MagneticFlux ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new MagneticFlux(baseUnitValue, BaseUnit); - } - - private double GetValueAs(MagneticFluxUnit unit) + private double AsBaseNumericType(MagneticFluxUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Magnetization.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Magnetization.WindowsRuntimeComponent.g.cs index a944e448c1..078e302592 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Magnetization.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Magnetization.WindowsRuntimeComponent.g.cs @@ -397,7 +397,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Magnetization other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -411,7 +411,7 @@ public override bool Equals(object obj) public bool Equals(Magnetization other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -489,7 +489,7 @@ public double As(MagnetizationUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -499,7 +499,7 @@ public double As(MagnetizationUnit unit) /// A Magnetization with the specified unit. public Magnetization ToUnit(MagnetizationUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new Magnetization(convertedValue, unit); } @@ -508,7 +508,7 @@ public Magnetization ToUnit(MagnetizationUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -518,23 +518,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal Magnetization ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new Magnetization(baseUnitValue, BaseUnit); - } - - private double GetValueAs(MagnetizationUnit unit) + private double AsBaseNumericType(MagnetizationUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Mass.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Mass.WindowsRuntimeComponent.g.cs index e8569ce870..8e295f87b6 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Mass.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Mass.WindowsRuntimeComponent.g.cs @@ -724,7 +724,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Mass other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -738,7 +738,7 @@ public override bool Equals(object obj) public bool Equals(Mass other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -816,7 +816,7 @@ public double As(MassUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -826,7 +826,7 @@ public double As(MassUnit unit) /// A Mass with the specified unit. public Mass ToUnit(MassUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new Mass(convertedValue, unit); } @@ -835,7 +835,7 @@ public Mass ToUnit(MassUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -867,23 +867,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal Mass ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new Mass(baseUnitValue, BaseUnit); - } - - private double GetValueAs(MassUnit unit) + private double AsBaseNumericType(MassUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlow.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlow.WindowsRuntimeComponent.g.cs index 59ff584fdb..3b48009c6a 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlow.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlow.WindowsRuntimeComponent.g.cs @@ -844,7 +844,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(MassFlow other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -858,7 +858,7 @@ public override bool Equals(object obj) public bool Equals(MassFlow other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -936,7 +936,7 @@ public double As(MassFlowUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -946,7 +946,7 @@ public double As(MassFlowUnit unit) /// A MassFlow with the specified unit. public MassFlow ToUnit(MassFlowUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new MassFlow(convertedValue, unit); } @@ -955,7 +955,7 @@ public MassFlow ToUnit(MassFlowUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -995,23 +995,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal MassFlow ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new MassFlow(baseUnitValue, BaseUnit); - } - - private double GetValueAs(MassFlowUnit unit) + private double AsBaseNumericType(MassFlowUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlux.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlux.WindowsRuntimeComponent.g.cs index ef2990588c..1caa1bc475 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlux.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlux.WindowsRuntimeComponent.g.cs @@ -409,7 +409,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(MassFlux other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -423,7 +423,7 @@ public override bool Equals(object obj) public bool Equals(MassFlux other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -501,7 +501,7 @@ public double As(MassFluxUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -511,7 +511,7 @@ public double As(MassFluxUnit unit) /// A MassFlux with the specified unit. public MassFlux ToUnit(MassFluxUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new MassFlux(convertedValue, unit); } @@ -520,7 +520,7 @@ public MassFlux ToUnit(MassFluxUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -531,23 +531,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal MassFlux ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new MassFlux(baseUnitValue, BaseUnit); - } - - private double GetValueAs(MassFluxUnit unit) + private double AsBaseNumericType(MassFluxUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassMomentOfInertia.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassMomentOfInertia.WindowsRuntimeComponent.g.cs index 8bc8e911f0..7ec0e91b52 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassMomentOfInertia.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassMomentOfInertia.WindowsRuntimeComponent.g.cs @@ -799,7 +799,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(MassMomentOfInertia other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -813,7 +813,7 @@ public override bool Equals(object obj) public bool Equals(MassMomentOfInertia other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -891,7 +891,7 @@ public double As(MassMomentOfInertiaUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -901,7 +901,7 @@ public double As(MassMomentOfInertiaUnit unit) /// A MassMomentOfInertia with the specified unit. public MassMomentOfInertia ToUnit(MassMomentOfInertiaUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new MassMomentOfInertia(convertedValue, unit); } @@ -910,7 +910,7 @@ public MassMomentOfInertia ToUnit(MassMomentOfInertiaUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -947,23 +947,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal MassMomentOfInertia ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new MassMomentOfInertia(baseUnitValue, BaseUnit); - } - - private double GetValueAs(MassMomentOfInertiaUnit unit) + private double AsBaseNumericType(MassMomentOfInertiaUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEnergy.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEnergy.WindowsRuntimeComponent.g.cs index 306c0e034a..8641fcb30d 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEnergy.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEnergy.WindowsRuntimeComponent.g.cs @@ -424,7 +424,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(MolarEnergy other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -438,7 +438,7 @@ public override bool Equals(object obj) public bool Equals(MolarEnergy other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -516,7 +516,7 @@ public double As(MolarEnergyUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -526,7 +526,7 @@ public double As(MolarEnergyUnit unit) /// A MolarEnergy with the specified unit. public MolarEnergy ToUnit(MolarEnergyUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new MolarEnergy(convertedValue, unit); } @@ -535,7 +535,7 @@ public MolarEnergy ToUnit(MolarEnergyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -547,23 +547,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal MolarEnergy ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new MolarEnergy(baseUnitValue, BaseUnit); - } - - private double GetValueAs(MolarEnergyUnit unit) + private double AsBaseNumericType(MolarEnergyUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEntropy.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEntropy.WindowsRuntimeComponent.g.cs index 747eea3cba..434a0e5a3b 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEntropy.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEntropy.WindowsRuntimeComponent.g.cs @@ -424,7 +424,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(MolarEntropy other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -438,7 +438,7 @@ public override bool Equals(object obj) public bool Equals(MolarEntropy other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -516,7 +516,7 @@ public double As(MolarEntropyUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -526,7 +526,7 @@ public double As(MolarEntropyUnit unit) /// A MolarEntropy with the specified unit. public MolarEntropy ToUnit(MolarEntropyUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new MolarEntropy(convertedValue, unit); } @@ -535,7 +535,7 @@ public MolarEntropy ToUnit(MolarEntropyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -547,23 +547,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal MolarEntropy ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new MolarEntropy(baseUnitValue, BaseUnit); - } - - private double GetValueAs(MolarEntropyUnit unit) + private double AsBaseNumericType(MolarEntropyUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarMass.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarMass.WindowsRuntimeComponent.g.cs index 374adeee36..5cc8d75f8c 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarMass.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarMass.WindowsRuntimeComponent.g.cs @@ -559,7 +559,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(MolarMass other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -573,7 +573,7 @@ public override bool Equals(object obj) public bool Equals(MolarMass other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -651,7 +651,7 @@ public double As(MolarMassUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -661,7 +661,7 @@ public double As(MolarMassUnit unit) /// A MolarMass with the specified unit. public MolarMass ToUnit(MolarMassUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new MolarMass(convertedValue, unit); } @@ -670,7 +670,7 @@ public MolarMass ToUnit(MolarMassUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -691,23 +691,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal MolarMass ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new MolarMass(baseUnitValue, BaseUnit); - } - - private double GetValueAs(MolarMassUnit unit) + private double AsBaseNumericType(MolarMassUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Molarity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Molarity.WindowsRuntimeComponent.g.cs index 24182af0cd..108a8baa44 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Molarity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Molarity.WindowsRuntimeComponent.g.cs @@ -502,7 +502,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Molarity other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -516,7 +516,7 @@ public override bool Equals(object obj) public bool Equals(Molarity other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -594,7 +594,7 @@ public double As(MolarityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -604,7 +604,7 @@ public double As(MolarityUnit unit) /// A Molarity with the specified unit. public Molarity ToUnit(MolarityUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new Molarity(convertedValue, unit); } @@ -613,7 +613,7 @@ public Molarity ToUnit(MolarityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -630,23 +630,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal Molarity ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new Molarity(baseUnitValue, BaseUnit); - } - - private double GetValueAs(MolarityUnit unit) + private double AsBaseNumericType(MolarityUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permeability.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permeability.WindowsRuntimeComponent.g.cs index 6a2e1cafea..56507756de 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permeability.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permeability.WindowsRuntimeComponent.g.cs @@ -397,7 +397,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Permeability other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -411,7 +411,7 @@ public override bool Equals(object obj) public bool Equals(Permeability other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -489,7 +489,7 @@ public double As(PermeabilityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -499,7 +499,7 @@ public double As(PermeabilityUnit unit) /// A Permeability with the specified unit. public Permeability ToUnit(PermeabilityUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new Permeability(convertedValue, unit); } @@ -508,7 +508,7 @@ public Permeability ToUnit(PermeabilityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -518,23 +518,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal Permeability ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new Permeability(baseUnitValue, BaseUnit); - } - - private double GetValueAs(PermeabilityUnit unit) + private double AsBaseNumericType(PermeabilityUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permittivity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permittivity.WindowsRuntimeComponent.g.cs index 903ed53bb9..2e361a2ad3 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permittivity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permittivity.WindowsRuntimeComponent.g.cs @@ -397,7 +397,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Permittivity other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -411,7 +411,7 @@ public override bool Equals(object obj) public bool Equals(Permittivity other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -489,7 +489,7 @@ public double As(PermittivityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -499,7 +499,7 @@ public double As(PermittivityUnit unit) /// A Permittivity with the specified unit. public Permittivity ToUnit(PermittivityUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new Permittivity(convertedValue, unit); } @@ -508,7 +508,7 @@ public Permittivity ToUnit(PermittivityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -518,23 +518,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal Permittivity ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new Permittivity(baseUnitValue, BaseUnit); - } - - private double GetValueAs(PermittivityUnit unit) + private double AsBaseNumericType(PermittivityUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Power.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Power.WindowsRuntimeComponent.g.cs index 9f1824e42e..50313b5782 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Power.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Power.WindowsRuntimeComponent.g.cs @@ -679,7 +679,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Power other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -693,7 +693,7 @@ public override bool Equals(object obj) public bool Equals(Power other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -771,7 +771,7 @@ public double As(PowerUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -781,7 +781,7 @@ public double As(PowerUnit unit) /// A Power with the specified unit. public Power ToUnit(PowerUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new Power(convertedValue, unit); } @@ -790,7 +790,7 @@ public Power ToUnit(PowerUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private decimal GetValueInBaseUnit() + private decimal AsBaseUnit() { switch(Unit) { @@ -819,23 +819,12 @@ private decimal GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal Power ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new Power(baseUnitValue, BaseUnit); - } - - private decimal GetValueAs(PowerUnit unit) + private decimal AsBaseNumericType(PowerUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerDensity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerDensity.WindowsRuntimeComponent.g.cs index 3c96c832bf..358deae752 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerDensity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerDensity.WindowsRuntimeComponent.g.cs @@ -1039,7 +1039,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(PowerDensity other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -1053,7 +1053,7 @@ public override bool Equals(object obj) public bool Equals(PowerDensity other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -1131,7 +1131,7 @@ public double As(PowerDensityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -1141,7 +1141,7 @@ public double As(PowerDensityUnit unit) /// A PowerDensity with the specified unit. public PowerDensity ToUnit(PowerDensityUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new PowerDensity(convertedValue, unit); } @@ -1150,7 +1150,7 @@ public PowerDensity ToUnit(PowerDensityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -1203,23 +1203,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal PowerDensity ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new PowerDensity(baseUnitValue, BaseUnit); - } - - private double GetValueAs(PowerDensityUnit unit) + private double AsBaseNumericType(PowerDensityUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerRatio.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerRatio.WindowsRuntimeComponent.g.cs index d11a0b48a7..ed0be5510a 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerRatio.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerRatio.WindowsRuntimeComponent.g.cs @@ -409,7 +409,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(PowerRatio other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -423,7 +423,7 @@ public override bool Equals(object obj) public bool Equals(PowerRatio other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -501,7 +501,7 @@ public double As(PowerRatioUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -511,7 +511,7 @@ public double As(PowerRatioUnit unit) /// A PowerRatio with the specified unit. public PowerRatio ToUnit(PowerRatioUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new PowerRatio(convertedValue, unit); } @@ -520,7 +520,7 @@ public PowerRatio ToUnit(PowerRatioUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -531,23 +531,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal PowerRatio ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new PowerRatio(baseUnitValue, BaseUnit); - } - - private double GetValueAs(PowerRatioUnit unit) + private double AsBaseNumericType(PowerRatioUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Pressure.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Pressure.WindowsRuntimeComponent.g.cs index cee77d1ec3..6dbddf414a 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Pressure.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Pressure.WindowsRuntimeComponent.g.cs @@ -1009,7 +1009,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Pressure other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -1023,7 +1023,7 @@ public override bool Equals(object obj) public bool Equals(Pressure other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -1101,7 +1101,7 @@ public double As(PressureUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -1111,7 +1111,7 @@ public double As(PressureUnit unit) /// A Pressure with the specified unit. public Pressure ToUnit(PressureUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new Pressure(convertedValue, unit); } @@ -1120,7 +1120,7 @@ public Pressure ToUnit(PressureUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -1171,23 +1171,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal Pressure ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new Pressure(baseUnitValue, BaseUnit); - } - - private double GetValueAs(PressureUnit unit) + private double AsBaseNumericType(PressureUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PressureChangeRate.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PressureChangeRate.WindowsRuntimeComponent.g.cs index 854e034dbd..9c4fba55e7 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PressureChangeRate.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PressureChangeRate.WindowsRuntimeComponent.g.cs @@ -484,7 +484,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(PressureChangeRate other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -498,7 +498,7 @@ public override bool Equals(object obj) public bool Equals(PressureChangeRate other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -576,7 +576,7 @@ public double As(PressureChangeRateUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -586,7 +586,7 @@ public double As(PressureChangeRateUnit unit) /// A PressureChangeRate with the specified unit. public PressureChangeRate ToUnit(PressureChangeRateUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new PressureChangeRate(convertedValue, unit); } @@ -595,7 +595,7 @@ public PressureChangeRate ToUnit(PressureChangeRateUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -611,23 +611,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal PressureChangeRate ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new PressureChangeRate(baseUnitValue, BaseUnit); - } - - private double GetValueAs(PressureChangeRateUnit unit) + private double AsBaseNumericType(PressureChangeRateUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Ratio.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Ratio.WindowsRuntimeComponent.g.cs index 172f8a13bc..480a34149a 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Ratio.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Ratio.WindowsRuntimeComponent.g.cs @@ -469,7 +469,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Ratio other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -483,7 +483,7 @@ public override bool Equals(object obj) public bool Equals(Ratio other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -561,7 +561,7 @@ public double As(RatioUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -571,7 +571,7 @@ public double As(RatioUnit unit) /// A Ratio with the specified unit. public Ratio ToUnit(RatioUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new Ratio(convertedValue, unit); } @@ -580,7 +580,7 @@ public Ratio ToUnit(RatioUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -595,23 +595,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal Ratio ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new Ratio(baseUnitValue, BaseUnit); - } - - private double GetValueAs(RatioUnit unit) + private double AsBaseNumericType(RatioUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactiveEnergy.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactiveEnergy.WindowsRuntimeComponent.g.cs index 6dccbae407..efcfef5915 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactiveEnergy.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactiveEnergy.WindowsRuntimeComponent.g.cs @@ -424,7 +424,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ReactiveEnergy other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -438,7 +438,7 @@ public override bool Equals(object obj) public bool Equals(ReactiveEnergy other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -516,7 +516,7 @@ public double As(ReactiveEnergyUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -526,7 +526,7 @@ public double As(ReactiveEnergyUnit unit) /// A ReactiveEnergy with the specified unit. public ReactiveEnergy ToUnit(ReactiveEnergyUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new ReactiveEnergy(convertedValue, unit); } @@ -535,7 +535,7 @@ public ReactiveEnergy ToUnit(ReactiveEnergyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -547,23 +547,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal ReactiveEnergy ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new ReactiveEnergy(baseUnitValue, BaseUnit); - } - - private double GetValueAs(ReactiveEnergyUnit unit) + private double AsBaseNumericType(ReactiveEnergyUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactivePower.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactivePower.WindowsRuntimeComponent.g.cs index 920320a653..803808fa59 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactivePower.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactivePower.WindowsRuntimeComponent.g.cs @@ -439,7 +439,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ReactivePower other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -453,7 +453,7 @@ public override bool Equals(object obj) public bool Equals(ReactivePower other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -531,7 +531,7 @@ public double As(ReactivePowerUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -541,7 +541,7 @@ public double As(ReactivePowerUnit unit) /// A ReactivePower with the specified unit. public ReactivePower ToUnit(ReactivePowerUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new ReactivePower(convertedValue, unit); } @@ -550,7 +550,7 @@ public ReactivePower ToUnit(ReactivePowerUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -563,23 +563,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal ReactivePower ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new ReactivePower(baseUnitValue, BaseUnit); - } - - private double GetValueAs(ReactivePowerUnit unit) + private double AsBaseNumericType(ReactivePowerUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalAcceleration.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalAcceleration.WindowsRuntimeComponent.g.cs index 199b83d502..bb92fc4740 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalAcceleration.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalAcceleration.WindowsRuntimeComponent.g.cs @@ -424,7 +424,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(RotationalAcceleration other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -438,7 +438,7 @@ public override bool Equals(object obj) public bool Equals(RotationalAcceleration other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -516,7 +516,7 @@ public double As(RotationalAccelerationUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -526,7 +526,7 @@ public double As(RotationalAccelerationUnit unit) /// A RotationalAcceleration with the specified unit. public RotationalAcceleration ToUnit(RotationalAccelerationUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new RotationalAcceleration(convertedValue, unit); } @@ -535,7 +535,7 @@ public RotationalAcceleration ToUnit(RotationalAccelerationUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -547,23 +547,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal RotationalAcceleration ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new RotationalAcceleration(baseUnitValue, BaseUnit); - } - - private double GetValueAs(RotationalAccelerationUnit unit) + private double AsBaseNumericType(RotationalAccelerationUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalSpeed.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalSpeed.WindowsRuntimeComponent.g.cs index 3c941e8aa4..0865dfdc24 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalSpeed.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalSpeed.WindowsRuntimeComponent.g.cs @@ -574,7 +574,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(RotationalSpeed other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -588,7 +588,7 @@ public override bool Equals(object obj) public bool Equals(RotationalSpeed other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -666,7 +666,7 @@ public double As(RotationalSpeedUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -676,7 +676,7 @@ public double As(RotationalSpeedUnit unit) /// A RotationalSpeed with the specified unit. public RotationalSpeed ToUnit(RotationalSpeedUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new RotationalSpeed(convertedValue, unit); } @@ -685,7 +685,7 @@ public RotationalSpeed ToUnit(RotationalSpeedUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -707,23 +707,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal RotationalSpeed ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new RotationalSpeed(baseUnitValue, BaseUnit); - } - - private double GetValueAs(RotationalSpeedUnit unit) + private double AsBaseNumericType(RotationalSpeedUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffness.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffness.WindowsRuntimeComponent.g.cs index 9d45f1dba0..cc66f37871 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffness.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffness.WindowsRuntimeComponent.g.cs @@ -424,7 +424,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(RotationalStiffness other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -438,7 +438,7 @@ public override bool Equals(object obj) public bool Equals(RotationalStiffness other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -516,7 +516,7 @@ public double As(RotationalStiffnessUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -526,7 +526,7 @@ public double As(RotationalStiffnessUnit unit) /// A RotationalStiffness with the specified unit. public RotationalStiffness ToUnit(RotationalStiffnessUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new RotationalStiffness(convertedValue, unit); } @@ -535,7 +535,7 @@ public RotationalStiffness ToUnit(RotationalStiffnessUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -547,23 +547,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal RotationalStiffness ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new RotationalStiffness(baseUnitValue, BaseUnit); - } - - private double GetValueAs(RotationalStiffnessUnit unit) + private double AsBaseNumericType(RotationalStiffnessUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffnessPerLength.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffnessPerLength.WindowsRuntimeComponent.g.cs index 8239088316..d4aaa2b1e4 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffnessPerLength.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffnessPerLength.WindowsRuntimeComponent.g.cs @@ -424,7 +424,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(RotationalStiffnessPerLength other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -438,7 +438,7 @@ public override bool Equals(object obj) public bool Equals(RotationalStiffnessPerLength other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -516,7 +516,7 @@ public double As(RotationalStiffnessPerLengthUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -526,7 +526,7 @@ public double As(RotationalStiffnessPerLengthUnit unit) /// A RotationalStiffnessPerLength with the specified unit. public RotationalStiffnessPerLength ToUnit(RotationalStiffnessPerLengthUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new RotationalStiffnessPerLength(convertedValue, unit); } @@ -535,7 +535,7 @@ public RotationalStiffnessPerLength ToUnit(RotationalStiffnessPerLengthUnit unit /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -547,23 +547,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal RotationalStiffnessPerLength ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new RotationalStiffnessPerLength(baseUnitValue, BaseUnit); - } - - private double GetValueAs(RotationalStiffnessPerLengthUnit unit) + private double AsBaseNumericType(RotationalStiffnessPerLengthUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SolidAngle.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SolidAngle.WindowsRuntimeComponent.g.cs index 9e742ad92e..c51d3bbcdb 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SolidAngle.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SolidAngle.WindowsRuntimeComponent.g.cs @@ -397,7 +397,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(SolidAngle other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -411,7 +411,7 @@ public override bool Equals(object obj) public bool Equals(SolidAngle other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -489,7 +489,7 @@ public double As(SolidAngleUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -499,7 +499,7 @@ public double As(SolidAngleUnit unit) /// A SolidAngle with the specified unit. public SolidAngle ToUnit(SolidAngleUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new SolidAngle(convertedValue, unit); } @@ -508,7 +508,7 @@ public SolidAngle ToUnit(SolidAngleUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -518,23 +518,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal SolidAngle ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new SolidAngle(baseUnitValue, BaseUnit); - } - - private double GetValueAs(SolidAngleUnit unit) + private double AsBaseNumericType(SolidAngleUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEnergy.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEnergy.WindowsRuntimeComponent.g.cs index 4bc887171a..81f010a799 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEnergy.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEnergy.WindowsRuntimeComponent.g.cs @@ -517,7 +517,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(SpecificEnergy other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -531,7 +531,7 @@ public override bool Equals(object obj) public bool Equals(SpecificEnergy other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -609,7 +609,7 @@ public double As(SpecificEnergyUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -619,7 +619,7 @@ public double As(SpecificEnergyUnit unit) /// A SpecificEnergy with the specified unit. public SpecificEnergy ToUnit(SpecificEnergyUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new SpecificEnergy(convertedValue, unit); } @@ -628,7 +628,7 @@ public SpecificEnergy ToUnit(SpecificEnergyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -646,23 +646,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal SpecificEnergy ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new SpecificEnergy(baseUnitValue, BaseUnit); - } - - private double GetValueAs(SpecificEnergyUnit unit) + private double AsBaseNumericType(SpecificEnergyUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEntropy.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEntropy.WindowsRuntimeComponent.g.cs index 69ef9abc5c..2205433759 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEntropy.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEntropy.WindowsRuntimeComponent.g.cs @@ -499,7 +499,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(SpecificEntropy other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -513,7 +513,7 @@ public override bool Equals(object obj) public bool Equals(SpecificEntropy other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -591,7 +591,7 @@ public double As(SpecificEntropyUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -601,7 +601,7 @@ public double As(SpecificEntropyUnit unit) /// A SpecificEntropy with the specified unit. public SpecificEntropy ToUnit(SpecificEntropyUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new SpecificEntropy(convertedValue, unit); } @@ -610,7 +610,7 @@ public SpecificEntropy ToUnit(SpecificEntropyUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -627,23 +627,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal SpecificEntropy ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new SpecificEntropy(baseUnitValue, BaseUnit); - } - - private double GetValueAs(SpecificEntropyUnit unit) + private double AsBaseNumericType(SpecificEntropyUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificVolume.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificVolume.WindowsRuntimeComponent.g.cs index 5ad6ad7ada..c85bffa702 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificVolume.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificVolume.WindowsRuntimeComponent.g.cs @@ -424,7 +424,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(SpecificVolume other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -438,7 +438,7 @@ public override bool Equals(object obj) public bool Equals(SpecificVolume other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -516,7 +516,7 @@ public double As(SpecificVolumeUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -526,7 +526,7 @@ public double As(SpecificVolumeUnit unit) /// A SpecificVolume with the specified unit. public SpecificVolume ToUnit(SpecificVolumeUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new SpecificVolume(convertedValue, unit); } @@ -535,7 +535,7 @@ public SpecificVolume ToUnit(SpecificVolumeUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -547,23 +547,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal SpecificVolume ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new SpecificVolume(baseUnitValue, BaseUnit); - } - - private double GetValueAs(SpecificVolumeUnit unit) + private double AsBaseNumericType(SpecificVolumeUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificWeight.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificWeight.WindowsRuntimeComponent.g.cs index 8c029b9192..9b57b4fbb3 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificWeight.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificWeight.WindowsRuntimeComponent.g.cs @@ -637,7 +637,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(SpecificWeight other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -651,7 +651,7 @@ public override bool Equals(object obj) public bool Equals(SpecificWeight other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -729,7 +729,7 @@ public double As(SpecificWeightUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -739,7 +739,7 @@ public double As(SpecificWeightUnit unit) /// A SpecificWeight with the specified unit. public SpecificWeight ToUnit(SpecificWeightUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new SpecificWeight(convertedValue, unit); } @@ -748,7 +748,7 @@ public SpecificWeight ToUnit(SpecificWeightUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -774,23 +774,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal SpecificWeight ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new SpecificWeight(baseUnitValue, BaseUnit); - } - - private double GetValueAs(SpecificWeightUnit unit) + private double AsBaseNumericType(SpecificWeightUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Speed.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Speed.WindowsRuntimeComponent.g.cs index 791a27b617..8c898e219a 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Speed.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Speed.WindowsRuntimeComponent.g.cs @@ -859,7 +859,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Speed other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -873,7 +873,7 @@ public override bool Equals(object obj) public bool Equals(Speed other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -951,7 +951,7 @@ public double As(SpeedUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -961,7 +961,7 @@ public double As(SpeedUnit unit) /// A Speed with the specified unit. public Speed ToUnit(SpeedUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new Speed(convertedValue, unit); } @@ -970,7 +970,7 @@ public Speed ToUnit(SpeedUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -1011,23 +1011,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal Speed ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new Speed(baseUnitValue, BaseUnit); - } - - private double GetValueAs(SpeedUnit unit) + private double AsBaseNumericType(SpeedUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Temperature.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Temperature.WindowsRuntimeComponent.g.cs index c9cc0686a2..5440295b68 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Temperature.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Temperature.WindowsRuntimeComponent.g.cs @@ -499,7 +499,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Temperature other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -513,7 +513,7 @@ public override bool Equals(object obj) public bool Equals(Temperature other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -591,7 +591,7 @@ public double As(TemperatureUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -601,7 +601,7 @@ public double As(TemperatureUnit unit) /// A Temperature with the specified unit. public Temperature ToUnit(TemperatureUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new Temperature(convertedValue, unit); } @@ -610,7 +610,7 @@ public Temperature ToUnit(TemperatureUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -627,23 +627,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal Temperature ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new Temperature(baseUnitValue, BaseUnit); - } - - private double GetValueAs(TemperatureUnit unit) + private double AsBaseNumericType(TemperatureUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureChangeRate.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureChangeRate.WindowsRuntimeComponent.g.cs index f500a16dc6..ce7658ea09 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureChangeRate.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureChangeRate.WindowsRuntimeComponent.g.cs @@ -529,7 +529,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(TemperatureChangeRate other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -543,7 +543,7 @@ public override bool Equals(object obj) public bool Equals(TemperatureChangeRate other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -621,7 +621,7 @@ public double As(TemperatureChangeRateUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -631,7 +631,7 @@ public double As(TemperatureChangeRateUnit unit) /// A TemperatureChangeRate with the specified unit. public TemperatureChangeRate ToUnit(TemperatureChangeRateUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new TemperatureChangeRate(convertedValue, unit); } @@ -640,7 +640,7 @@ public TemperatureChangeRate ToUnit(TemperatureChangeRateUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -659,23 +659,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal TemperatureChangeRate ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new TemperatureChangeRate(baseUnitValue, BaseUnit); - } - - private double GetValueAs(TemperatureChangeRateUnit unit) + private double AsBaseNumericType(TemperatureChangeRateUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureDelta.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureDelta.WindowsRuntimeComponent.g.cs index ba30a1ae68..edee17d7c2 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureDelta.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureDelta.WindowsRuntimeComponent.g.cs @@ -499,7 +499,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(TemperatureDelta other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -513,7 +513,7 @@ public override bool Equals(object obj) public bool Equals(TemperatureDelta other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -591,7 +591,7 @@ public double As(TemperatureDeltaUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -601,7 +601,7 @@ public double As(TemperatureDeltaUnit unit) /// A TemperatureDelta with the specified unit. public TemperatureDelta ToUnit(TemperatureDeltaUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new TemperatureDelta(convertedValue, unit); } @@ -610,7 +610,7 @@ public TemperatureDelta ToUnit(TemperatureDeltaUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -627,23 +627,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal TemperatureDelta ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new TemperatureDelta(baseUnitValue, BaseUnit); - } - - private double GetValueAs(TemperatureDeltaUnit unit) + private double AsBaseNumericType(TemperatureDeltaUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalConductivity.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalConductivity.WindowsRuntimeComponent.g.cs index ecf0c5f8c3..4c48dd1fba 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalConductivity.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalConductivity.WindowsRuntimeComponent.g.cs @@ -412,7 +412,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ThermalConductivity other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -426,7 +426,7 @@ public override bool Equals(object obj) public bool Equals(ThermalConductivity other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -504,7 +504,7 @@ public double As(ThermalConductivityUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -514,7 +514,7 @@ public double As(ThermalConductivityUnit unit) /// A ThermalConductivity with the specified unit. public ThermalConductivity ToUnit(ThermalConductivityUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new ThermalConductivity(convertedValue, unit); } @@ -523,7 +523,7 @@ public ThermalConductivity ToUnit(ThermalConductivityUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -534,23 +534,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal ThermalConductivity ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new ThermalConductivity(baseUnitValue, BaseUnit); - } - - private double GetValueAs(ThermalConductivityUnit unit) + private double AsBaseNumericType(ThermalConductivityUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalResistance.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalResistance.WindowsRuntimeComponent.g.cs index 2869765753..899966dbf7 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalResistance.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalResistance.WindowsRuntimeComponent.g.cs @@ -454,7 +454,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(ThermalResistance other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -468,7 +468,7 @@ public override bool Equals(object obj) public bool Equals(ThermalResistance other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -546,7 +546,7 @@ public double As(ThermalResistanceUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -556,7 +556,7 @@ public double As(ThermalResistanceUnit unit) /// A ThermalResistance with the specified unit. public ThermalResistance ToUnit(ThermalResistanceUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new ThermalResistance(convertedValue, unit); } @@ -565,7 +565,7 @@ public ThermalResistance ToUnit(ThermalResistanceUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -579,23 +579,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal ThermalResistance ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new ThermalResistance(baseUnitValue, BaseUnit); - } - - private double GetValueAs(ThermalResistanceUnit unit) + private double AsBaseNumericType(ThermalResistanceUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Torque.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Torque.WindowsRuntimeComponent.g.cs index 8f3a743984..5aeab4ed37 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Torque.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Torque.WindowsRuntimeComponent.g.cs @@ -694,7 +694,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Torque other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -708,7 +708,7 @@ public override bool Equals(object obj) public bool Equals(Torque other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -786,7 +786,7 @@ public double As(TorqueUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -796,7 +796,7 @@ public double As(TorqueUnit unit) /// A Torque with the specified unit. public Torque ToUnit(TorqueUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new Torque(convertedValue, unit); } @@ -805,7 +805,7 @@ public Torque ToUnit(TorqueUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -835,23 +835,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal Torque ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new Torque(baseUnitValue, BaseUnit); - } - - private double GetValueAs(TorqueUnit unit) + private double AsBaseNumericType(TorqueUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VitaminA.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VitaminA.WindowsRuntimeComponent.g.cs index f13cb99a14..7bedea0e13 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VitaminA.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VitaminA.WindowsRuntimeComponent.g.cs @@ -394,7 +394,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(VitaminA other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -408,7 +408,7 @@ public override bool Equals(object obj) public bool Equals(VitaminA other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -486,7 +486,7 @@ public double As(VitaminAUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -496,7 +496,7 @@ public double As(VitaminAUnit unit) /// A VitaminA with the specified unit. public VitaminA ToUnit(VitaminAUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new VitaminA(convertedValue, unit); } @@ -505,7 +505,7 @@ public VitaminA ToUnit(VitaminAUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -515,23 +515,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal VitaminA ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new VitaminA(baseUnitValue, BaseUnit); - } - - private double GetValueAs(VitaminAUnit unit) + private double AsBaseNumericType(VitaminAUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Volume.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Volume.WindowsRuntimeComponent.g.cs index 026fbc6a6b..3ddd7240cc 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Volume.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Volume.WindowsRuntimeComponent.g.cs @@ -1054,7 +1054,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(Volume other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -1068,7 +1068,7 @@ public override bool Equals(object obj) public bool Equals(Volume other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -1146,7 +1146,7 @@ public double As(VolumeUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -1156,7 +1156,7 @@ public double As(VolumeUnit unit) /// A Volume with the specified unit. public Volume ToUnit(VolumeUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new Volume(convertedValue, unit); } @@ -1165,7 +1165,7 @@ public Volume ToUnit(VolumeUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -1219,23 +1219,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal Volume ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new Volume(baseUnitValue, BaseUnit); - } - - private double GetValueAs(VolumeUnit unit) + private double AsBaseNumericType(VolumeUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeFlow.WindowsRuntimeComponent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeFlow.WindowsRuntimeComponent.g.cs index ee9efcf334..e8192ec645 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeFlow.WindowsRuntimeComponent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeFlow.WindowsRuntimeComponent.g.cs @@ -1099,7 +1099,7 @@ public int CompareTo(object obj) // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods internal int CompareTo(VolumeFlow other) { - return _value.CompareTo(other.GetValueAs(this.Unit)); + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); } [Windows.Foundation.Metadata.DefaultOverload] @@ -1113,7 +1113,7 @@ public override bool Equals(object obj) public bool Equals(VolumeFlow other) { - return _value.Equals(other.GetValueAs(this.Unit)); + return _value.Equals(other.AsBaseNumericType(this.Unit)); } /// @@ -1191,7 +1191,7 @@ public double As(VolumeFlowUnit unit) if(Unit == unit) return Convert.ToDouble(Value); - var converted = GetValueAs(unit); + var converted = AsBaseNumericType(unit); return Convert.ToDouble(converted); } @@ -1201,7 +1201,7 @@ public double As(VolumeFlowUnit unit) /// A VolumeFlow with the specified unit. public VolumeFlow ToUnit(VolumeFlowUnit unit) { - var convertedValue = GetValueAs(unit); + var convertedValue = AsBaseNumericType(unit); return new VolumeFlow(convertedValue, unit); } @@ -1210,7 +1210,7 @@ public VolumeFlow ToUnit(VolumeFlowUnit unit) /// This is typically the first step in converting from one unit to another. /// /// The value in the base unit representation. - private double GetValueInBaseUnit() + private double AsBaseUnit() { switch(Unit) { @@ -1267,23 +1267,12 @@ private double GetValueInBaseUnit() } } - /// - /// Converts the current value + unit to the base unit. - /// This is typically the first step in converting from one unit to another. - /// - /// The value in the base unit representation. - internal VolumeFlow ToBaseUnit() - { - var baseUnitValue = GetValueInBaseUnit(); - return new VolumeFlow(baseUnitValue, BaseUnit); - } - - private double GetValueAs(VolumeFlowUnit unit) + private double AsBaseNumericType(VolumeFlowUnit unit) { if(Unit == unit) return _value; - var baseUnitValue = GetValueInBaseUnit(); + var baseUnitValue = AsBaseUnit(); switch(unit) { diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs index e30134cd98..432687ff34 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs @@ -472,8 +472,10 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("en-US", typeof(IrradianceUnit), (int)IrradianceUnit.PicowattPerSquareMeter, new string[]{"pW/m²"}), ("en-US", typeof(IrradianceUnit), (int)IrradianceUnit.WattPerSquareCentimeter, new string[]{"W/cm²"}), ("en-US", typeof(IrradianceUnit), (int)IrradianceUnit.WattPerSquareMeter, new string[]{"W/m²"}), + ("en-US", typeof(IrradiationUnit), (int)IrradiationUnit.JoulePerSquareCentimeter, new string[]{"J/cm²"}), ("en-US", typeof(IrradiationUnit), (int)IrradiationUnit.JoulePerSquareMeter, new string[]{"J/m²"}), ("en-US", typeof(IrradiationUnit), (int)IrradiationUnit.JoulePerSquareMillimeter, new string[]{"J/mm²"}), + ("en-US", typeof(IrradiationUnit), (int)IrradiationUnit.KilojoulePerSquareMeter, new string[]{"kJ/m²"}), ("en-US", typeof(IrradiationUnit), (int)IrradiationUnit.KilowattHourPerSquareMeter, new string[]{"kWh/m²"}), ("en-US", typeof(IrradiationUnit), (int)IrradiationUnit.WattHourPerSquareMeter, new string[]{"Wh/m²"}), ("en-US", typeof(KinematicViscosityUnit), (int)KinematicViscosityUnit.Centistokes, new string[]{"cSt"}), diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/IrradiationUnit.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/IrradiationUnit.g.cs index 8db3408b40..00d1cd46c3 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/IrradiationUnit.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/IrradiationUnit.g.cs @@ -44,8 +44,10 @@ namespace UnitsNet.Units public enum IrradiationUnit { Undefined = 0, + JoulePerSquareCentimeter, JoulePerSquareMeter, JoulePerSquareMillimeter, + KilojoulePerSquareMeter, KilowattHourPerSquareMeter, WattHourPerSquareMeter, } From beedad4ba6a229b59c933c190b7f196f59ee39c0 Mon Sep 17 00:00:00 2001 From: Andreas Gullberg Larsen Date: Sat, 23 Feb 2019 14:33:52 +0100 Subject: [PATCH 08/21] Use IQuantity.Value in test case --- UnitsNet.Tests/UnitConverterTest.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/UnitsNet.Tests/UnitConverterTest.cs b/UnitsNet.Tests/UnitConverterTest.cs index e2efa4b941..c298255df2 100644 --- a/UnitsNet.Tests/UnitConverterTest.cs +++ b/UnitsNet.Tests/UnitConverterTest.cs @@ -57,7 +57,7 @@ public void CustomConversionWithDifferentQuantityTypes() [Fact] public void TryCustomConversionForOilBarrelsToUsGallons() { - ConversionFunction conversionFunction = (from) => Volume.FromUsGallons(((Volume)from).Value * 42); + ConversionFunction conversionFunction = (from) => Volume.FromUsGallons(from.Value * 42); var unitConverter = new UnitConverter(); unitConverter.SetConversionFunction(VolumeUnit.OilBarrel, VolumeUnit.UsGallon, conversionFunction); From bc3a808e924b8beea71e5563b16ef8339c88cdc8 Mon Sep 17 00:00:00 2001 From: Andreas Gullberg Larsen Date: Sat, 23 Feb 2019 14:58:54 +0100 Subject: [PATCH 09/21] Rename typeparams, remove empty ctor --- UnitsNet/UnitConverter.cs | 35 ++++++++++++++++------------------- 1 file changed, 16 insertions(+), 19 deletions(-) diff --git a/UnitsNet/UnitConverter.cs b/UnitsNet/UnitConverter.cs index aad99eb8bd..a10f606b96 100644 --- a/UnitsNet/UnitConverter.cs +++ b/UnitsNet/UnitConverter.cs @@ -55,21 +55,17 @@ static UnitConverter() RegisterDefaultConversions(Default); } - public UnitConverter() + public void SetConversionFunction(Enum from, Enum to, ConversionFunction conversionFunction) + where TQuantity : IQuantity { + SetConversionFunction(typeof(TQuantity), from, typeof(TQuantity), to, conversionFunction); } - public void SetConversionFunction(Enum from, Enum to, ConversionFunction conversionFunction) - where QuantityType : IQuantity + public void SetConversionFunction(Enum from, Enum to, ConversionFunction conversionFunction) + where TQuantityFrom : IQuantity + where TQuantityTo : IQuantity { - SetConversionFunction(typeof(QuantityType), from, typeof(QuantityType), to, conversionFunction); - } - - public void SetConversionFunction(Enum from, Enum to, ConversionFunction conversionFunction) - where SourceQuantity : IQuantity - where TargetQuantity : IQuantity - { - SetConversionFunction(typeof(SourceQuantity), from, typeof(TargetQuantity), to, conversionFunction); + SetConversionFunction(typeof(TQuantityFrom), from, typeof(TQuantityTo), to, conversionFunction); } public void SetConversionFunction(Type fromType, Enum from, Type toType, Enum to, ConversionFunction conversionFunction) @@ -88,11 +84,11 @@ public ConversionFunction GetConversionFunction(Enum from, Enum to) where T : return GetConversionFunction(typeof(T), from, typeof(T), to); } - public ConversionFunction GetConversionFunction(Enum from, Enum to) - where SourceQuantity : IQuantity - where TargetQuantity : IQuantity + public ConversionFunction GetConversionFunction(Enum from, Enum to) + where TQuantityFrom : IQuantity + where TQuantityTo : IQuantity { - return GetConversionFunction(typeof(SourceQuantity), from, typeof(TargetQuantity), to); + return GetConversionFunction(typeof(TQuantityFrom), from, typeof(TQuantityTo), to); } public ConversionFunction GetConversionFunction(Type fromType, Enum from, Type toType, Enum to) @@ -111,11 +107,11 @@ public bool TryGetConversionFunction(Enum from, Enum to, out ConversionFuncti return TryGetConversionFunction(typeof(T), from, typeof(T), to, out conversionFunction); } - public bool TryGetConversionFunction(Enum from, Enum to, out ConversionFunction conversionFunction) - where SourceQuantity : IQuantity - where TargetQuantity : IQuantity + public bool TryGetConversionFunction(Enum from, Enum to, out ConversionFunction conversionFunction) + where TQuantityFrom : IQuantity + where TQuantityTo : IQuantity { - return TryGetConversionFunction(typeof(SourceQuantity), from, typeof(TargetQuantity), to, out conversionFunction); + return TryGetConversionFunction(typeof(TQuantityFrom), from, typeof(TQuantityTo), to, out conversionFunction); } public bool TryGetConversionFunction(Type fromType, Enum from, Type toType, Enum to, out ConversionFunction conversionFunction) @@ -527,3 +523,4 @@ private static bool TryGetQuantityType(string quantityName, out Type quantityTyp } } } + From 619de36195608a811447636f4a792b84ca9fd8ee Mon Sep 17 00:00:00 2001 From: Andreas Gullberg Larsen Date: Sat, 23 Feb 2019 15:21:21 +0100 Subject: [PATCH 10/21] Micro optimization of lookup of IQuantity type It was looked up and wrapped N times --- UnitsNet/UnitConverter.cs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/UnitsNet/UnitConverter.cs b/UnitsNet/UnitConverter.cs index a10f606b96..69aacd1968 100644 --- a/UnitsNet/UnitConverter.cs +++ b/UnitsNet/UnitConverter.cs @@ -125,8 +125,10 @@ public bool TryGetConversionFunction(ConversionFunctionLookup conversionLookup, return _conversionFunctions.TryGetValue(conversionLookup, out conversionFunction); } + private static readonly TypeWrapper TypeOfIQuantity = typeof(IQuantity).Wrap(); + private static readonly Type[] QuantityTypes = UnitsNetAssembly.GetTypes() - .Where(typeof(IQuantity).Wrap().IsAssignableFrom) + .Where(TypeOfIQuantity.IsAssignableFrom) .Where(x => x.Wrap().IsClass || x.Wrap().IsValueType) // Future-proofing: we are discussing changing quantities from struct to class .ToArray(); From 6a2befdbae7d0b584d75362af727c5297d75dec2 Mon Sep 17 00:00:00 2001 From: Andreas Gullberg Larsen Date: Sat, 23 Feb 2019 15:23:18 +0100 Subject: [PATCH 11/21] UnitConverter: Move static field initialization to static ctor They became a bit unwieldy. Move fields to top of class. --- UnitsNet/UnitConverter.cs | 24 +++++++++++++----------- 1 file changed, 13 insertions(+), 11 deletions(-) diff --git a/UnitsNet/UnitConverter.cs b/UnitsNet/UnitConverter.cs index 69aacd1968..6e25498422 100644 --- a/UnitsNet/UnitConverter.cs +++ b/UnitsNet/UnitConverter.cs @@ -45,12 +45,25 @@ public sealed partial class UnitConverter private static readonly string UnitTypeNamespace = typeof(LengthUnit).Namespace; private static readonly Assembly UnitsNetAssembly = typeof(Length).Wrap().Assembly; + private static readonly TypeWrapper TypeOfIQuantity; + private static readonly Type[] QuantityTypes; + private static readonly Type[] UnitTypes; private readonly Dictionary _conversionFunctions = new Dictionary(); static UnitConverter() { Default = new UnitConverter(); + TypeOfIQuantity = typeof(IQuantity).Wrap(); + + QuantityTypes = UnitsNetAssembly.GetTypes() + .Where(TypeOfIQuantity.IsAssignableFrom) + .Where(x => x.Wrap().IsClass || x.Wrap().IsValueType) // Future-proofing: we are discussing changing quantities from struct to class + .ToArray(); + + UnitTypes = UnitsNetAssembly.GetTypes() + .Where(x => x.Namespace == UnitTypeNamespace && x.Wrap().IsEnum && x.Name.EndsWith("Unit")) + .ToArray(); RegisterDefaultConversions(Default); } @@ -125,17 +138,6 @@ public bool TryGetConversionFunction(ConversionFunctionLookup conversionLookup, return _conversionFunctions.TryGetValue(conversionLookup, out conversionFunction); } - private static readonly TypeWrapper TypeOfIQuantity = typeof(IQuantity).Wrap(); - - private static readonly Type[] QuantityTypes = UnitsNetAssembly.GetTypes() - .Where(TypeOfIQuantity.IsAssignableFrom) - .Where(x => x.Wrap().IsClass || x.Wrap().IsValueType) // Future-proofing: we are discussing changing quantities from struct to class - .ToArray(); - - private static readonly Type[] UnitTypes = UnitsNetAssembly.GetTypes() - .Where(x => x.Namespace == UnitTypeNamespace && x.Wrap().IsEnum && x.Name.EndsWith("Unit")) - .ToArray(); - /// /// Convert between any two quantity units given a numeric value and two unit enum values. /// From 1dc6c27d92a5f6c862d6330fa8f59b46ef9900f6 Mon Sep 17 00:00:00 2001 From: Andreas Gullberg Larsen Date: Sat, 23 Feb 2019 15:28:25 +0100 Subject: [PATCH 12/21] Add typed conversion function for same quantity conversion functions Since this is the most commonly used call path by far, it made sense to handle this case separately. The advantage is that the callback quantity is strongly typed. --- UnitsNet.Tests/UnitConverterTest.cs | 8 ++++---- UnitsNet/UnitConverter.cs | 17 +++++++++++++++-- 2 files changed, 19 insertions(+), 6 deletions(-) diff --git a/UnitsNet.Tests/UnitConverterTest.cs b/UnitsNet.Tests/UnitConverterTest.cs index c298255df2..d7393cad18 100644 --- a/UnitsNet.Tests/UnitConverterTest.cs +++ b/UnitsNet.Tests/UnitConverterTest.cs @@ -29,10 +29,10 @@ public class UnitConverterTest [Fact] public void CustomConversionWithSameQuantityType() { - ConversionFunction conversionFunction = (from) => Length.FromInches(18); + ConversionFunction conversionFunction = (from) => Length.FromInches(18); var unitConverter = new UnitConverter(); - unitConverter.SetConversionFunction(LengthUnit.Meter, LengthUnit.Inch, conversionFunction); + unitConverter.SetConversionFunction(LengthUnit.Meter, LengthUnit.Inch, conversionFunction); var foundConversionFunction = unitConverter.GetConversionFunction(LengthUnit.Meter, LengthUnit.Inch); var converted = foundConversionFunction(Length.FromMeters(1.0)); @@ -57,10 +57,10 @@ public void CustomConversionWithDifferentQuantityTypes() [Fact] public void TryCustomConversionForOilBarrelsToUsGallons() { - ConversionFunction conversionFunction = (from) => Volume.FromUsGallons(from.Value * 42); + ConversionFunction conversionFunction = (from) => Volume.FromUsGallons(from.Value * 42); var unitConverter = new UnitConverter(); - unitConverter.SetConversionFunction(VolumeUnit.OilBarrel, VolumeUnit.UsGallon, conversionFunction); + unitConverter.SetConversionFunction(VolumeUnit.OilBarrel, VolumeUnit.UsGallon, conversionFunction); var foundConversionFunction = unitConverter.GetConversionFunction(VolumeUnit.OilBarrel, VolumeUnit.UsGallon); var converted = foundConversionFunction(Volume.FromOilBarrels(1)); diff --git a/UnitsNet/UnitConverter.cs b/UnitsNet/UnitConverter.cs index 6e25498422..527029226e 100644 --- a/UnitsNet/UnitConverter.cs +++ b/UnitsNet/UnitConverter.cs @@ -35,6 +35,9 @@ namespace UnitsNet public delegate IQuantity ConversionFunction(IQuantity inputValue); + public delegate TQuantity ConversionFunction(TQuantity inputValue) + where TQuantity : IQuantity; + /// /// Convert between units of a quantity, such as converting from meters to centimeters of a given length. /// @@ -68,10 +71,12 @@ static UnitConverter() RegisterDefaultConversions(Default); } - public void SetConversionFunction(Enum from, Enum to, ConversionFunction conversionFunction) + public void SetConversionFunction(Enum from, Enum to, ConversionFunction conversionFunction) where TQuantity : IQuantity { - SetConversionFunction(typeof(TQuantity), from, typeof(TQuantity), to, conversionFunction); + var quantityType = typeof(TQuantity); + var conversionLookup = new ConversionFunctionLookup(quantityType, from, quantityType, to); + SetConversionFunction(conversionLookup, conversionFunction); } public void SetConversionFunction(Enum from, Enum to, ConversionFunction conversionFunction) @@ -92,6 +97,14 @@ public void SetConversionFunction(ConversionFunctionLookup conversionLookup, Con _conversionFunctions[conversionLookup] = conversionFunction; } + public void SetConversionFunction(ConversionFunctionLookup conversionLookup, ConversionFunction conversionFunction) + where TQuantity : IQuantity + { + IQuantity TypelessConversionFunction(IQuantity quantity) => conversionFunction((TQuantity) quantity); + + _conversionFunctions[conversionLookup] = TypelessConversionFunction; + } + public ConversionFunction GetConversionFunction(Enum from, Enum to) where T : IQuantity { return GetConversionFunction(typeof(T), from, typeof(T), to); From b27f3d57d7acca2f516ee2b2197237389f47dd92 Mon Sep 17 00:00:00 2001 From: Andreas Gullberg Larsen Date: Sat, 23 Feb 2019 15:31:51 +0100 Subject: [PATCH 13/21] Use typed conversions in RegisterDefaultConversions --- UnitsNet/GeneratedCode/UnitConverter.g.cs | 3380 ++++++++--------- ...GenerateUnitConverterDefaultSourceCode.ps1 | 6 +- 2 files changed, 1693 insertions(+), 1693 deletions(-) diff --git a/UnitsNet/GeneratedCode/UnitConverter.g.cs b/UnitsNet/GeneratedCode/UnitConverter.g.cs index b8416e8f17..603a67e7b6 100644 --- a/UnitsNet/GeneratedCode/UnitConverter.g.cs +++ b/UnitsNet/GeneratedCode/UnitConverter.g.cs @@ -47,1696 +47,1696 @@ public sealed partial class UnitConverter { public static void RegisterDefaultConversions(UnitConverter unitConverter) { - unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.CentimeterPerSecondSquared, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.CentimeterPerSecondSquared)); - unitConverter.SetConversionFunction(AccelerationUnit.CentimeterPerSecondSquared, Acceleration.BaseUnit, (q) => ((Acceleration)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.DecimeterPerSecondSquared, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.DecimeterPerSecondSquared)); - unitConverter.SetConversionFunction(AccelerationUnit.DecimeterPerSecondSquared, Acceleration.BaseUnit, (q) => ((Acceleration)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.FootPerSecondSquared, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.FootPerSecondSquared)); - unitConverter.SetConversionFunction(AccelerationUnit.FootPerSecondSquared, Acceleration.BaseUnit, (q) => ((Acceleration)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.InchPerSecondSquared, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.InchPerSecondSquared)); - unitConverter.SetConversionFunction(AccelerationUnit.InchPerSecondSquared, Acceleration.BaseUnit, (q) => ((Acceleration)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.KilometerPerSecondSquared, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.KilometerPerSecondSquared)); - unitConverter.SetConversionFunction(AccelerationUnit.KilometerPerSecondSquared, Acceleration.BaseUnit, (q) => ((Acceleration)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.KnotPerHour, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.KnotPerHour)); - unitConverter.SetConversionFunction(AccelerationUnit.KnotPerHour, Acceleration.BaseUnit, (q) => ((Acceleration)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.KnotPerMinute, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.KnotPerMinute)); - unitConverter.SetConversionFunction(AccelerationUnit.KnotPerMinute, Acceleration.BaseUnit, (q) => ((Acceleration)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.KnotPerSecond, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.KnotPerSecond)); - unitConverter.SetConversionFunction(AccelerationUnit.KnotPerSecond, Acceleration.BaseUnit, (q) => ((Acceleration)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Acceleration.BaseUnit, Acceleration.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.MicrometerPerSecondSquared, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.MicrometerPerSecondSquared)); - unitConverter.SetConversionFunction(AccelerationUnit.MicrometerPerSecondSquared, Acceleration.BaseUnit, (q) => ((Acceleration)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.MillimeterPerSecondSquared, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.MillimeterPerSecondSquared)); - unitConverter.SetConversionFunction(AccelerationUnit.MillimeterPerSecondSquared, Acceleration.BaseUnit, (q) => ((Acceleration)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.NanometerPerSecondSquared, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.NanometerPerSecondSquared)); - unitConverter.SetConversionFunction(AccelerationUnit.NanometerPerSecondSquared, Acceleration.BaseUnit, (q) => ((Acceleration)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.StandardGravity, (q) => ((Acceleration)q).ToUnit(AccelerationUnit.StandardGravity)); - unitConverter.SetConversionFunction(AccelerationUnit.StandardGravity, Acceleration.BaseUnit, (q) => ((Acceleration)q).ToBaseUnit()); - unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Centimole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.Centimole)); - unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Centimole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.CentipoundMole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.CentipoundMole)); - unitConverter.SetConversionFunction(AmountOfSubstanceUnit.CentipoundMole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Decimole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.Decimole)); - unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Decimole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.DecipoundMole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.DecipoundMole)); - unitConverter.SetConversionFunction(AmountOfSubstanceUnit.DecipoundMole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Kilomole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.Kilomole)); - unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Kilomole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.KilopoundMole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.KilopoundMole)); - unitConverter.SetConversionFunction(AmountOfSubstanceUnit.KilopoundMole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Megamole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.Megamole)); - unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Megamole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Micromole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.Micromole)); - unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Micromole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.MicropoundMole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.MicropoundMole)); - unitConverter.SetConversionFunction(AmountOfSubstanceUnit.MicropoundMole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Millimole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.Millimole)); - unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Millimole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.MillipoundMole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.MillipoundMole)); - unitConverter.SetConversionFunction(AmountOfSubstanceUnit.MillipoundMole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstance.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Nanomole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.Nanomole)); - unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Nanomole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.NanopoundMole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.NanopoundMole)); - unitConverter.SetConversionFunction(AmountOfSubstanceUnit.NanopoundMole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.PoundMole, (q) => ((AmountOfSubstance)q).ToUnit(AmountOfSubstanceUnit.PoundMole)); - unitConverter.SetConversionFunction(AmountOfSubstanceUnit.PoundMole, AmountOfSubstance.BaseUnit, (q) => ((AmountOfSubstance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(AmplitudeRatio.BaseUnit, AmplitudeRatioUnit.DecibelMicrovolt, (q) => ((AmplitudeRatio)q).ToUnit(AmplitudeRatioUnit.DecibelMicrovolt)); - unitConverter.SetConversionFunction(AmplitudeRatioUnit.DecibelMicrovolt, AmplitudeRatio.BaseUnit, (q) => ((AmplitudeRatio)q).ToBaseUnit()); - unitConverter.SetConversionFunction(AmplitudeRatio.BaseUnit, AmplitudeRatioUnit.DecibelMillivolt, (q) => ((AmplitudeRatio)q).ToUnit(AmplitudeRatioUnit.DecibelMillivolt)); - unitConverter.SetConversionFunction(AmplitudeRatioUnit.DecibelMillivolt, AmplitudeRatio.BaseUnit, (q) => ((AmplitudeRatio)q).ToBaseUnit()); - unitConverter.SetConversionFunction(AmplitudeRatio.BaseUnit, AmplitudeRatioUnit.DecibelUnloaded, (q) => ((AmplitudeRatio)q).ToUnit(AmplitudeRatioUnit.DecibelUnloaded)); - unitConverter.SetConversionFunction(AmplitudeRatioUnit.DecibelUnloaded, AmplitudeRatio.BaseUnit, (q) => ((AmplitudeRatio)q).ToBaseUnit()); - unitConverter.SetConversionFunction(AmplitudeRatio.BaseUnit, AmplitudeRatio.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Arcminute, (q) => ((Angle)q).ToUnit(AngleUnit.Arcminute)); - unitConverter.SetConversionFunction(AngleUnit.Arcminute, Angle.BaseUnit, (q) => ((Angle)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Arcsecond, (q) => ((Angle)q).ToUnit(AngleUnit.Arcsecond)); - unitConverter.SetConversionFunction(AngleUnit.Arcsecond, Angle.BaseUnit, (q) => ((Angle)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Centiradian, (q) => ((Angle)q).ToUnit(AngleUnit.Centiradian)); - unitConverter.SetConversionFunction(AngleUnit.Centiradian, Angle.BaseUnit, (q) => ((Angle)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Deciradian, (q) => ((Angle)q).ToUnit(AngleUnit.Deciradian)); - unitConverter.SetConversionFunction(AngleUnit.Deciradian, Angle.BaseUnit, (q) => ((Angle)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Angle.BaseUnit, Angle.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Gradian, (q) => ((Angle)q).ToUnit(AngleUnit.Gradian)); - unitConverter.SetConversionFunction(AngleUnit.Gradian, Angle.BaseUnit, (q) => ((Angle)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Microdegree, (q) => ((Angle)q).ToUnit(AngleUnit.Microdegree)); - unitConverter.SetConversionFunction(AngleUnit.Microdegree, Angle.BaseUnit, (q) => ((Angle)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Microradian, (q) => ((Angle)q).ToUnit(AngleUnit.Microradian)); - unitConverter.SetConversionFunction(AngleUnit.Microradian, Angle.BaseUnit, (q) => ((Angle)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Millidegree, (q) => ((Angle)q).ToUnit(AngleUnit.Millidegree)); - unitConverter.SetConversionFunction(AngleUnit.Millidegree, Angle.BaseUnit, (q) => ((Angle)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Milliradian, (q) => ((Angle)q).ToUnit(AngleUnit.Milliradian)); - unitConverter.SetConversionFunction(AngleUnit.Milliradian, Angle.BaseUnit, (q) => ((Angle)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Nanodegree, (q) => ((Angle)q).ToUnit(AngleUnit.Nanodegree)); - unitConverter.SetConversionFunction(AngleUnit.Nanodegree, Angle.BaseUnit, (q) => ((Angle)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Nanoradian, (q) => ((Angle)q).ToUnit(AngleUnit.Nanoradian)); - unitConverter.SetConversionFunction(AngleUnit.Nanoradian, Angle.BaseUnit, (q) => ((Angle)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Radian, (q) => ((Angle)q).ToUnit(AngleUnit.Radian)); - unitConverter.SetConversionFunction(AngleUnit.Radian, Angle.BaseUnit, (q) => ((Angle)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Revolution, (q) => ((Angle)q).ToUnit(AngleUnit.Revolution)); - unitConverter.SetConversionFunction(AngleUnit.Revolution, Angle.BaseUnit, (q) => ((Angle)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ApparentEnergy.BaseUnit, ApparentEnergyUnit.KilovoltampereHour, (q) => ((ApparentEnergy)q).ToUnit(ApparentEnergyUnit.KilovoltampereHour)); - unitConverter.SetConversionFunction(ApparentEnergyUnit.KilovoltampereHour, ApparentEnergy.BaseUnit, (q) => ((ApparentEnergy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ApparentEnergy.BaseUnit, ApparentEnergyUnit.MegavoltampereHour, (q) => ((ApparentEnergy)q).ToUnit(ApparentEnergyUnit.MegavoltampereHour)); - unitConverter.SetConversionFunction(ApparentEnergyUnit.MegavoltampereHour, ApparentEnergy.BaseUnit, (q) => ((ApparentEnergy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ApparentEnergy.BaseUnit, ApparentEnergy.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(ApparentPower.BaseUnit, ApparentPowerUnit.Gigavoltampere, (q) => ((ApparentPower)q).ToUnit(ApparentPowerUnit.Gigavoltampere)); - unitConverter.SetConversionFunction(ApparentPowerUnit.Gigavoltampere, ApparentPower.BaseUnit, (q) => ((ApparentPower)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ApparentPower.BaseUnit, ApparentPowerUnit.Kilovoltampere, (q) => ((ApparentPower)q).ToUnit(ApparentPowerUnit.Kilovoltampere)); - unitConverter.SetConversionFunction(ApparentPowerUnit.Kilovoltampere, ApparentPower.BaseUnit, (q) => ((ApparentPower)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ApparentPower.BaseUnit, ApparentPowerUnit.Megavoltampere, (q) => ((ApparentPower)q).ToUnit(ApparentPowerUnit.Megavoltampere)); - unitConverter.SetConversionFunction(ApparentPowerUnit.Megavoltampere, ApparentPower.BaseUnit, (q) => ((ApparentPower)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ApparentPower.BaseUnit, ApparentPower.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.Acre, (q) => ((Area)q).ToUnit(AreaUnit.Acre)); - unitConverter.SetConversionFunction(AreaUnit.Acre, Area.BaseUnit, (q) => ((Area)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.Hectare, (q) => ((Area)q).ToUnit(AreaUnit.Hectare)); - unitConverter.SetConversionFunction(AreaUnit.Hectare, Area.BaseUnit, (q) => ((Area)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareCentimeter, (q) => ((Area)q).ToUnit(AreaUnit.SquareCentimeter)); - unitConverter.SetConversionFunction(AreaUnit.SquareCentimeter, Area.BaseUnit, (q) => ((Area)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareDecimeter, (q) => ((Area)q).ToUnit(AreaUnit.SquareDecimeter)); - unitConverter.SetConversionFunction(AreaUnit.SquareDecimeter, Area.BaseUnit, (q) => ((Area)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareFoot, (q) => ((Area)q).ToUnit(AreaUnit.SquareFoot)); - unitConverter.SetConversionFunction(AreaUnit.SquareFoot, Area.BaseUnit, (q) => ((Area)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareInch, (q) => ((Area)q).ToUnit(AreaUnit.SquareInch)); - unitConverter.SetConversionFunction(AreaUnit.SquareInch, Area.BaseUnit, (q) => ((Area)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareKilometer, (q) => ((Area)q).ToUnit(AreaUnit.SquareKilometer)); - unitConverter.SetConversionFunction(AreaUnit.SquareKilometer, Area.BaseUnit, (q) => ((Area)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Area.BaseUnit, Area.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareMicrometer, (q) => ((Area)q).ToUnit(AreaUnit.SquareMicrometer)); - unitConverter.SetConversionFunction(AreaUnit.SquareMicrometer, Area.BaseUnit, (q) => ((Area)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareMile, (q) => ((Area)q).ToUnit(AreaUnit.SquareMile)); - unitConverter.SetConversionFunction(AreaUnit.SquareMile, Area.BaseUnit, (q) => ((Area)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareMillimeter, (q) => ((Area)q).ToUnit(AreaUnit.SquareMillimeter)); - unitConverter.SetConversionFunction(AreaUnit.SquareMillimeter, Area.BaseUnit, (q) => ((Area)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareYard, (q) => ((Area)q).ToUnit(AreaUnit.SquareYard)); - unitConverter.SetConversionFunction(AreaUnit.SquareYard, Area.BaseUnit, (q) => ((Area)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.UsSurveySquareFoot, (q) => ((Area)q).ToUnit(AreaUnit.UsSurveySquareFoot)); - unitConverter.SetConversionFunction(AreaUnit.UsSurveySquareFoot, Area.BaseUnit, (q) => ((Area)q).ToBaseUnit()); - unitConverter.SetConversionFunction(AreaDensity.BaseUnit, AreaDensity.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(AreaMomentOfInertia.BaseUnit, AreaMomentOfInertiaUnit.CentimeterToTheFourth, (q) => ((AreaMomentOfInertia)q).ToUnit(AreaMomentOfInertiaUnit.CentimeterToTheFourth)); - unitConverter.SetConversionFunction(AreaMomentOfInertiaUnit.CentimeterToTheFourth, AreaMomentOfInertia.BaseUnit, (q) => ((AreaMomentOfInertia)q).ToBaseUnit()); - unitConverter.SetConversionFunction(AreaMomentOfInertia.BaseUnit, AreaMomentOfInertiaUnit.DecimeterToTheFourth, (q) => ((AreaMomentOfInertia)q).ToUnit(AreaMomentOfInertiaUnit.DecimeterToTheFourth)); - unitConverter.SetConversionFunction(AreaMomentOfInertiaUnit.DecimeterToTheFourth, AreaMomentOfInertia.BaseUnit, (q) => ((AreaMomentOfInertia)q).ToBaseUnit()); - unitConverter.SetConversionFunction(AreaMomentOfInertia.BaseUnit, AreaMomentOfInertiaUnit.FootToTheFourth, (q) => ((AreaMomentOfInertia)q).ToUnit(AreaMomentOfInertiaUnit.FootToTheFourth)); - unitConverter.SetConversionFunction(AreaMomentOfInertiaUnit.FootToTheFourth, AreaMomentOfInertia.BaseUnit, (q) => ((AreaMomentOfInertia)q).ToBaseUnit()); - unitConverter.SetConversionFunction(AreaMomentOfInertia.BaseUnit, AreaMomentOfInertiaUnit.InchToTheFourth, (q) => ((AreaMomentOfInertia)q).ToUnit(AreaMomentOfInertiaUnit.InchToTheFourth)); - unitConverter.SetConversionFunction(AreaMomentOfInertiaUnit.InchToTheFourth, AreaMomentOfInertia.BaseUnit, (q) => ((AreaMomentOfInertia)q).ToBaseUnit()); - unitConverter.SetConversionFunction(AreaMomentOfInertia.BaseUnit, AreaMomentOfInertia.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(AreaMomentOfInertia.BaseUnit, AreaMomentOfInertiaUnit.MillimeterToTheFourth, (q) => ((AreaMomentOfInertia)q).ToUnit(AreaMomentOfInertiaUnit.MillimeterToTheFourth)); - unitConverter.SetConversionFunction(AreaMomentOfInertiaUnit.MillimeterToTheFourth, AreaMomentOfInertia.BaseUnit, (q) => ((AreaMomentOfInertia)q).ToBaseUnit()); - unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRate.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.BytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.BytePerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.BytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.ExabitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.ExabitPerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.ExabitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.ExabytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.ExabytePerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.ExabytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.ExbibitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.ExbibitPerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.ExbibitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.ExbibytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.ExbibytePerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.ExbibytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.GibibitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.GibibitPerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.GibibitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.GibibytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.GibibytePerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.GibibytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.GigabitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.GigabitPerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.GigabitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.GigabytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.GigabytePerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.GigabytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.KibibitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.KibibitPerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.KibibitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.KibibytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.KibibytePerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.KibibytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.KilobitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.KilobitPerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.KilobitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.KilobytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.KilobytePerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.KilobytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.MebibitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.MebibitPerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.MebibitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.MebibytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.MebibytePerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.MebibytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.MegabitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.MegabitPerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.MegabitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.MegabytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.MegabytePerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.MegabytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.PebibitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.PebibitPerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.PebibitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.PebibytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.PebibytePerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.PebibytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.PetabitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.PetabitPerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.PetabitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.PetabytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.PetabytePerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.PetabytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.TebibitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.TebibitPerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.TebibitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.TebibytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.TebibytePerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.TebibytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.TerabitPerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.TerabitPerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.TerabitPerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.TerabytePerSecond, (q) => ((BitRate)q).ToUnit(BitRateUnit.TerabytePerSecond)); - unitConverter.SetConversionFunction(BitRateUnit.TerabytePerSecond, BitRate.BaseUnit, (q) => ((BitRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(BrakeSpecificFuelConsumption.BaseUnit, BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour, (q) => ((BrakeSpecificFuelConsumption)q).ToUnit(BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour)); - unitConverter.SetConversionFunction(BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour, BrakeSpecificFuelConsumption.BaseUnit, (q) => ((BrakeSpecificFuelConsumption)q).ToBaseUnit()); - unitConverter.SetConversionFunction(BrakeSpecificFuelConsumption.BaseUnit, BrakeSpecificFuelConsumption.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(BrakeSpecificFuelConsumption.BaseUnit, BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour, (q) => ((BrakeSpecificFuelConsumption)q).ToUnit(BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour)); - unitConverter.SetConversionFunction(BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour, BrakeSpecificFuelConsumption.BaseUnit, (q) => ((BrakeSpecificFuelConsumption)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Capacitance.BaseUnit, Capacitance.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Capacitance.BaseUnit, CapacitanceUnit.Kilofarad, (q) => ((Capacitance)q).ToUnit(CapacitanceUnit.Kilofarad)); - unitConverter.SetConversionFunction(CapacitanceUnit.Kilofarad, Capacitance.BaseUnit, (q) => ((Capacitance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Capacitance.BaseUnit, CapacitanceUnit.Megafarad, (q) => ((Capacitance)q).ToUnit(CapacitanceUnit.Megafarad)); - unitConverter.SetConversionFunction(CapacitanceUnit.Megafarad, Capacitance.BaseUnit, (q) => ((Capacitance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Capacitance.BaseUnit, CapacitanceUnit.Microfarad, (q) => ((Capacitance)q).ToUnit(CapacitanceUnit.Microfarad)); - unitConverter.SetConversionFunction(CapacitanceUnit.Microfarad, Capacitance.BaseUnit, (q) => ((Capacitance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Capacitance.BaseUnit, CapacitanceUnit.Millifarad, (q) => ((Capacitance)q).ToUnit(CapacitanceUnit.Millifarad)); - unitConverter.SetConversionFunction(CapacitanceUnit.Millifarad, Capacitance.BaseUnit, (q) => ((Capacitance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Capacitance.BaseUnit, CapacitanceUnit.Nanofarad, (q) => ((Capacitance)q).ToUnit(CapacitanceUnit.Nanofarad)); - unitConverter.SetConversionFunction(CapacitanceUnit.Nanofarad, Capacitance.BaseUnit, (q) => ((Capacitance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Capacitance.BaseUnit, CapacitanceUnit.Picofarad, (q) => ((Capacitance)q).ToUnit(CapacitanceUnit.Picofarad)); - unitConverter.SetConversionFunction(CapacitanceUnit.Picofarad, Capacitance.BaseUnit, (q) => ((Capacitance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(CoefficientOfThermalExpansion.BaseUnit, CoefficientOfThermalExpansionUnit.InverseDegreeCelsius, (q) => ((CoefficientOfThermalExpansion)q).ToUnit(CoefficientOfThermalExpansionUnit.InverseDegreeCelsius)); - unitConverter.SetConversionFunction(CoefficientOfThermalExpansionUnit.InverseDegreeCelsius, CoefficientOfThermalExpansion.BaseUnit, (q) => ((CoefficientOfThermalExpansion)q).ToBaseUnit()); - unitConverter.SetConversionFunction(CoefficientOfThermalExpansion.BaseUnit, CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit, (q) => ((CoefficientOfThermalExpansion)q).ToUnit(CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit)); - unitConverter.SetConversionFunction(CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit, CoefficientOfThermalExpansion.BaseUnit, (q) => ((CoefficientOfThermalExpansion)q).ToBaseUnit()); - unitConverter.SetConversionFunction(CoefficientOfThermalExpansion.BaseUnit, CoefficientOfThermalExpansion.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.CentigramPerDeciliter, (q) => ((Density)q).ToUnit(DensityUnit.CentigramPerDeciliter)); - unitConverter.SetConversionFunction(DensityUnit.CentigramPerDeciliter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.CentigramPerLiter, (q) => ((Density)q).ToUnit(DensityUnit.CentigramPerLiter)); - unitConverter.SetConversionFunction(DensityUnit.CentigramPerLiter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.CentigramPerMilliliter, (q) => ((Density)q).ToUnit(DensityUnit.CentigramPerMilliliter)); - unitConverter.SetConversionFunction(DensityUnit.CentigramPerMilliliter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.DecigramPerDeciliter, (q) => ((Density)q).ToUnit(DensityUnit.DecigramPerDeciliter)); - unitConverter.SetConversionFunction(DensityUnit.DecigramPerDeciliter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.DecigramPerLiter, (q) => ((Density)q).ToUnit(DensityUnit.DecigramPerLiter)); - unitConverter.SetConversionFunction(DensityUnit.DecigramPerLiter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.DecigramPerMilliliter, (q) => ((Density)q).ToUnit(DensityUnit.DecigramPerMilliliter)); - unitConverter.SetConversionFunction(DensityUnit.DecigramPerMilliliter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.GramPerCubicCentimeter, (q) => ((Density)q).ToUnit(DensityUnit.GramPerCubicCentimeter)); - unitConverter.SetConversionFunction(DensityUnit.GramPerCubicCentimeter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.GramPerCubicMeter, (q) => ((Density)q).ToUnit(DensityUnit.GramPerCubicMeter)); - unitConverter.SetConversionFunction(DensityUnit.GramPerCubicMeter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.GramPerCubicMillimeter, (q) => ((Density)q).ToUnit(DensityUnit.GramPerCubicMillimeter)); - unitConverter.SetConversionFunction(DensityUnit.GramPerCubicMillimeter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.GramPerDeciliter, (q) => ((Density)q).ToUnit(DensityUnit.GramPerDeciliter)); - unitConverter.SetConversionFunction(DensityUnit.GramPerDeciliter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.GramPerLiter, (q) => ((Density)q).ToUnit(DensityUnit.GramPerLiter)); - unitConverter.SetConversionFunction(DensityUnit.GramPerLiter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.GramPerMilliliter, (q) => ((Density)q).ToUnit(DensityUnit.GramPerMilliliter)); - unitConverter.SetConversionFunction(DensityUnit.GramPerMilliliter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.KilogramPerCubicCentimeter, (q) => ((Density)q).ToUnit(DensityUnit.KilogramPerCubicCentimeter)); - unitConverter.SetConversionFunction(DensityUnit.KilogramPerCubicCentimeter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, Density.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.KilogramPerCubicMillimeter, (q) => ((Density)q).ToUnit(DensityUnit.KilogramPerCubicMillimeter)); - unitConverter.SetConversionFunction(DensityUnit.KilogramPerCubicMillimeter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.KilopoundPerCubicFoot, (q) => ((Density)q).ToUnit(DensityUnit.KilopoundPerCubicFoot)); - unitConverter.SetConversionFunction(DensityUnit.KilopoundPerCubicFoot, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.KilopoundPerCubicInch, (q) => ((Density)q).ToUnit(DensityUnit.KilopoundPerCubicInch)); - unitConverter.SetConversionFunction(DensityUnit.KilopoundPerCubicInch, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.MicrogramPerCubicMeter, (q) => ((Density)q).ToUnit(DensityUnit.MicrogramPerCubicMeter)); - unitConverter.SetConversionFunction(DensityUnit.MicrogramPerCubicMeter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.MicrogramPerDeciliter, (q) => ((Density)q).ToUnit(DensityUnit.MicrogramPerDeciliter)); - unitConverter.SetConversionFunction(DensityUnit.MicrogramPerDeciliter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.MicrogramPerLiter, (q) => ((Density)q).ToUnit(DensityUnit.MicrogramPerLiter)); - unitConverter.SetConversionFunction(DensityUnit.MicrogramPerLiter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.MicrogramPerMilliliter, (q) => ((Density)q).ToUnit(DensityUnit.MicrogramPerMilliliter)); - unitConverter.SetConversionFunction(DensityUnit.MicrogramPerMilliliter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.MilligramPerCubicMeter, (q) => ((Density)q).ToUnit(DensityUnit.MilligramPerCubicMeter)); - unitConverter.SetConversionFunction(DensityUnit.MilligramPerCubicMeter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.MilligramPerDeciliter, (q) => ((Density)q).ToUnit(DensityUnit.MilligramPerDeciliter)); - unitConverter.SetConversionFunction(DensityUnit.MilligramPerDeciliter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.MilligramPerLiter, (q) => ((Density)q).ToUnit(DensityUnit.MilligramPerLiter)); - unitConverter.SetConversionFunction(DensityUnit.MilligramPerLiter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.MilligramPerMilliliter, (q) => ((Density)q).ToUnit(DensityUnit.MilligramPerMilliliter)); - unitConverter.SetConversionFunction(DensityUnit.MilligramPerMilliliter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.NanogramPerDeciliter, (q) => ((Density)q).ToUnit(DensityUnit.NanogramPerDeciliter)); - unitConverter.SetConversionFunction(DensityUnit.NanogramPerDeciliter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.NanogramPerLiter, (q) => ((Density)q).ToUnit(DensityUnit.NanogramPerLiter)); - unitConverter.SetConversionFunction(DensityUnit.NanogramPerLiter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.NanogramPerMilliliter, (q) => ((Density)q).ToUnit(DensityUnit.NanogramPerMilliliter)); - unitConverter.SetConversionFunction(DensityUnit.NanogramPerMilliliter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PicogramPerDeciliter, (q) => ((Density)q).ToUnit(DensityUnit.PicogramPerDeciliter)); - unitConverter.SetConversionFunction(DensityUnit.PicogramPerDeciliter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PicogramPerLiter, (q) => ((Density)q).ToUnit(DensityUnit.PicogramPerLiter)); - unitConverter.SetConversionFunction(DensityUnit.PicogramPerLiter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PicogramPerMilliliter, (q) => ((Density)q).ToUnit(DensityUnit.PicogramPerMilliliter)); - unitConverter.SetConversionFunction(DensityUnit.PicogramPerMilliliter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PoundPerCubicFoot, (q) => ((Density)q).ToUnit(DensityUnit.PoundPerCubicFoot)); - unitConverter.SetConversionFunction(DensityUnit.PoundPerCubicFoot, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PoundPerCubicInch, (q) => ((Density)q).ToUnit(DensityUnit.PoundPerCubicInch)); - unitConverter.SetConversionFunction(DensityUnit.PoundPerCubicInch, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PoundPerImperialGallon, (q) => ((Density)q).ToUnit(DensityUnit.PoundPerImperialGallon)); - unitConverter.SetConversionFunction(DensityUnit.PoundPerImperialGallon, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PoundPerUSGallon, (q) => ((Density)q).ToUnit(DensityUnit.PoundPerUSGallon)); - unitConverter.SetConversionFunction(DensityUnit.PoundPerUSGallon, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.SlugPerCubicFoot, (q) => ((Density)q).ToUnit(DensityUnit.SlugPerCubicFoot)); - unitConverter.SetConversionFunction(DensityUnit.SlugPerCubicFoot, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.TonnePerCubicCentimeter, (q) => ((Density)q).ToUnit(DensityUnit.TonnePerCubicCentimeter)); - unitConverter.SetConversionFunction(DensityUnit.TonnePerCubicCentimeter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.TonnePerCubicMeter, (q) => ((Density)q).ToUnit(DensityUnit.TonnePerCubicMeter)); - unitConverter.SetConversionFunction(DensityUnit.TonnePerCubicMeter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.TonnePerCubicMillimeter, (q) => ((Density)q).ToUnit(DensityUnit.TonnePerCubicMillimeter)); - unitConverter.SetConversionFunction(DensityUnit.TonnePerCubicMillimeter, Density.BaseUnit, (q) => ((Density)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Day, (q) => ((Duration)q).ToUnit(DurationUnit.Day)); - unitConverter.SetConversionFunction(DurationUnit.Day, Duration.BaseUnit, (q) => ((Duration)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Hour, (q) => ((Duration)q).ToUnit(DurationUnit.Hour)); - unitConverter.SetConversionFunction(DurationUnit.Hour, Duration.BaseUnit, (q) => ((Duration)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Microsecond, (q) => ((Duration)q).ToUnit(DurationUnit.Microsecond)); - unitConverter.SetConversionFunction(DurationUnit.Microsecond, Duration.BaseUnit, (q) => ((Duration)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Millisecond, (q) => ((Duration)q).ToUnit(DurationUnit.Millisecond)); - unitConverter.SetConversionFunction(DurationUnit.Millisecond, Duration.BaseUnit, (q) => ((Duration)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Minute, (q) => ((Duration)q).ToUnit(DurationUnit.Minute)); - unitConverter.SetConversionFunction(DurationUnit.Minute, Duration.BaseUnit, (q) => ((Duration)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Month30, (q) => ((Duration)q).ToUnit(DurationUnit.Month30)); - unitConverter.SetConversionFunction(DurationUnit.Month30, Duration.BaseUnit, (q) => ((Duration)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Nanosecond, (q) => ((Duration)q).ToUnit(DurationUnit.Nanosecond)); - unitConverter.SetConversionFunction(DurationUnit.Nanosecond, Duration.BaseUnit, (q) => ((Duration)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Duration.BaseUnit, Duration.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Week, (q) => ((Duration)q).ToUnit(DurationUnit.Week)); - unitConverter.SetConversionFunction(DurationUnit.Week, Duration.BaseUnit, (q) => ((Duration)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Year365, (q) => ((Duration)q).ToUnit(DurationUnit.Year365)); - unitConverter.SetConversionFunction(DurationUnit.Year365, Duration.BaseUnit, (q) => ((Duration)q).ToBaseUnit()); - unitConverter.SetConversionFunction(DynamicViscosity.BaseUnit, DynamicViscosityUnit.Centipoise, (q) => ((DynamicViscosity)q).ToUnit(DynamicViscosityUnit.Centipoise)); - unitConverter.SetConversionFunction(DynamicViscosityUnit.Centipoise, DynamicViscosity.BaseUnit, (q) => ((DynamicViscosity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(DynamicViscosity.BaseUnit, DynamicViscosityUnit.MicropascalSecond, (q) => ((DynamicViscosity)q).ToUnit(DynamicViscosityUnit.MicropascalSecond)); - unitConverter.SetConversionFunction(DynamicViscosityUnit.MicropascalSecond, DynamicViscosity.BaseUnit, (q) => ((DynamicViscosity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(DynamicViscosity.BaseUnit, DynamicViscosityUnit.MillipascalSecond, (q) => ((DynamicViscosity)q).ToUnit(DynamicViscosityUnit.MillipascalSecond)); - unitConverter.SetConversionFunction(DynamicViscosityUnit.MillipascalSecond, DynamicViscosity.BaseUnit, (q) => ((DynamicViscosity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(DynamicViscosity.BaseUnit, DynamicViscosity.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(DynamicViscosity.BaseUnit, DynamicViscosityUnit.PascalSecond, (q) => ((DynamicViscosity)q).ToUnit(DynamicViscosityUnit.PascalSecond)); - unitConverter.SetConversionFunction(DynamicViscosityUnit.PascalSecond, DynamicViscosity.BaseUnit, (q) => ((DynamicViscosity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(DynamicViscosity.BaseUnit, DynamicViscosityUnit.Poise, (q) => ((DynamicViscosity)q).ToUnit(DynamicViscosityUnit.Poise)); - unitConverter.SetConversionFunction(DynamicViscosityUnit.Poise, DynamicViscosity.BaseUnit, (q) => ((DynamicViscosity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricAdmittance.BaseUnit, ElectricAdmittanceUnit.Microsiemens, (q) => ((ElectricAdmittance)q).ToUnit(ElectricAdmittanceUnit.Microsiemens)); - unitConverter.SetConversionFunction(ElectricAdmittanceUnit.Microsiemens, ElectricAdmittance.BaseUnit, (q) => ((ElectricAdmittance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricAdmittance.BaseUnit, ElectricAdmittanceUnit.Millisiemens, (q) => ((ElectricAdmittance)q).ToUnit(ElectricAdmittanceUnit.Millisiemens)); - unitConverter.SetConversionFunction(ElectricAdmittanceUnit.Millisiemens, ElectricAdmittance.BaseUnit, (q) => ((ElectricAdmittance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricAdmittance.BaseUnit, ElectricAdmittanceUnit.Nanosiemens, (q) => ((ElectricAdmittance)q).ToUnit(ElectricAdmittanceUnit.Nanosiemens)); - unitConverter.SetConversionFunction(ElectricAdmittanceUnit.Nanosiemens, ElectricAdmittance.BaseUnit, (q) => ((ElectricAdmittance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricAdmittance.BaseUnit, ElectricAdmittance.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(ElectricCharge.BaseUnit, ElectricCharge.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(ElectricChargeDensity.BaseUnit, ElectricChargeDensity.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(ElectricConductance.BaseUnit, ElectricConductanceUnit.Microsiemens, (q) => ((ElectricConductance)q).ToUnit(ElectricConductanceUnit.Microsiemens)); - unitConverter.SetConversionFunction(ElectricConductanceUnit.Microsiemens, ElectricConductance.BaseUnit, (q) => ((ElectricConductance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricConductance.BaseUnit, ElectricConductanceUnit.Millisiemens, (q) => ((ElectricConductance)q).ToUnit(ElectricConductanceUnit.Millisiemens)); - unitConverter.SetConversionFunction(ElectricConductanceUnit.Millisiemens, ElectricConductance.BaseUnit, (q) => ((ElectricConductance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricConductance.BaseUnit, ElectricConductance.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(ElectricConductivity.BaseUnit, ElectricConductivity.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(ElectricCurrent.BaseUnit, ElectricCurrent.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Centiampere, (q) => ((ElectricCurrent)q).ToUnit(ElectricCurrentUnit.Centiampere)); - unitConverter.SetConversionFunction(ElectricCurrentUnit.Centiampere, ElectricCurrent.BaseUnit, (q) => ((ElectricCurrent)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Kiloampere, (q) => ((ElectricCurrent)q).ToUnit(ElectricCurrentUnit.Kiloampere)); - unitConverter.SetConversionFunction(ElectricCurrentUnit.Kiloampere, ElectricCurrent.BaseUnit, (q) => ((ElectricCurrent)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Megaampere, (q) => ((ElectricCurrent)q).ToUnit(ElectricCurrentUnit.Megaampere)); - unitConverter.SetConversionFunction(ElectricCurrentUnit.Megaampere, ElectricCurrent.BaseUnit, (q) => ((ElectricCurrent)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Microampere, (q) => ((ElectricCurrent)q).ToUnit(ElectricCurrentUnit.Microampere)); - unitConverter.SetConversionFunction(ElectricCurrentUnit.Microampere, ElectricCurrent.BaseUnit, (q) => ((ElectricCurrent)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Milliampere, (q) => ((ElectricCurrent)q).ToUnit(ElectricCurrentUnit.Milliampere)); - unitConverter.SetConversionFunction(ElectricCurrentUnit.Milliampere, ElectricCurrent.BaseUnit, (q) => ((ElectricCurrent)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Nanoampere, (q) => ((ElectricCurrent)q).ToUnit(ElectricCurrentUnit.Nanoampere)); - unitConverter.SetConversionFunction(ElectricCurrentUnit.Nanoampere, ElectricCurrent.BaseUnit, (q) => ((ElectricCurrent)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Picoampere, (q) => ((ElectricCurrent)q).ToUnit(ElectricCurrentUnit.Picoampere)); - unitConverter.SetConversionFunction(ElectricCurrentUnit.Picoampere, ElectricCurrent.BaseUnit, (q) => ((ElectricCurrent)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricCurrentDensity.BaseUnit, ElectricCurrentDensity.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(ElectricCurrentGradient.BaseUnit, ElectricCurrentGradient.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(ElectricField.BaseUnit, ElectricField.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(ElectricInductance.BaseUnit, ElectricInductance.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(ElectricInductance.BaseUnit, ElectricInductanceUnit.Microhenry, (q) => ((ElectricInductance)q).ToUnit(ElectricInductanceUnit.Microhenry)); - unitConverter.SetConversionFunction(ElectricInductanceUnit.Microhenry, ElectricInductance.BaseUnit, (q) => ((ElectricInductance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricInductance.BaseUnit, ElectricInductanceUnit.Millihenry, (q) => ((ElectricInductance)q).ToUnit(ElectricInductanceUnit.Millihenry)); - unitConverter.SetConversionFunction(ElectricInductanceUnit.Millihenry, ElectricInductance.BaseUnit, (q) => ((ElectricInductance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricInductance.BaseUnit, ElectricInductanceUnit.Nanohenry, (q) => ((ElectricInductance)q).ToUnit(ElectricInductanceUnit.Nanohenry)); - unitConverter.SetConversionFunction(ElectricInductanceUnit.Nanohenry, ElectricInductance.BaseUnit, (q) => ((ElectricInductance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricPotential.BaseUnit, ElectricPotentialUnit.Kilovolt, (q) => ((ElectricPotential)q).ToUnit(ElectricPotentialUnit.Kilovolt)); - unitConverter.SetConversionFunction(ElectricPotentialUnit.Kilovolt, ElectricPotential.BaseUnit, (q) => ((ElectricPotential)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricPotential.BaseUnit, ElectricPotentialUnit.Megavolt, (q) => ((ElectricPotential)q).ToUnit(ElectricPotentialUnit.Megavolt)); - unitConverter.SetConversionFunction(ElectricPotentialUnit.Megavolt, ElectricPotential.BaseUnit, (q) => ((ElectricPotential)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricPotential.BaseUnit, ElectricPotentialUnit.Microvolt, (q) => ((ElectricPotential)q).ToUnit(ElectricPotentialUnit.Microvolt)); - unitConverter.SetConversionFunction(ElectricPotentialUnit.Microvolt, ElectricPotential.BaseUnit, (q) => ((ElectricPotential)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricPotential.BaseUnit, ElectricPotentialUnit.Millivolt, (q) => ((ElectricPotential)q).ToUnit(ElectricPotentialUnit.Millivolt)); - unitConverter.SetConversionFunction(ElectricPotentialUnit.Millivolt, ElectricPotential.BaseUnit, (q) => ((ElectricPotential)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricPotential.BaseUnit, ElectricPotential.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(ElectricPotentialAc.BaseUnit, ElectricPotentialAcUnit.KilovoltAc, (q) => ((ElectricPotentialAc)q).ToUnit(ElectricPotentialAcUnit.KilovoltAc)); - unitConverter.SetConversionFunction(ElectricPotentialAcUnit.KilovoltAc, ElectricPotentialAc.BaseUnit, (q) => ((ElectricPotentialAc)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricPotentialAc.BaseUnit, ElectricPotentialAcUnit.MegavoltAc, (q) => ((ElectricPotentialAc)q).ToUnit(ElectricPotentialAcUnit.MegavoltAc)); - unitConverter.SetConversionFunction(ElectricPotentialAcUnit.MegavoltAc, ElectricPotentialAc.BaseUnit, (q) => ((ElectricPotentialAc)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricPotentialAc.BaseUnit, ElectricPotentialAcUnit.MicrovoltAc, (q) => ((ElectricPotentialAc)q).ToUnit(ElectricPotentialAcUnit.MicrovoltAc)); - unitConverter.SetConversionFunction(ElectricPotentialAcUnit.MicrovoltAc, ElectricPotentialAc.BaseUnit, (q) => ((ElectricPotentialAc)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricPotentialAc.BaseUnit, ElectricPotentialAcUnit.MillivoltAc, (q) => ((ElectricPotentialAc)q).ToUnit(ElectricPotentialAcUnit.MillivoltAc)); - unitConverter.SetConversionFunction(ElectricPotentialAcUnit.MillivoltAc, ElectricPotentialAc.BaseUnit, (q) => ((ElectricPotentialAc)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricPotentialAc.BaseUnit, ElectricPotentialAc.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(ElectricPotentialDc.BaseUnit, ElectricPotentialDcUnit.KilovoltDc, (q) => ((ElectricPotentialDc)q).ToUnit(ElectricPotentialDcUnit.KilovoltDc)); - unitConverter.SetConversionFunction(ElectricPotentialDcUnit.KilovoltDc, ElectricPotentialDc.BaseUnit, (q) => ((ElectricPotentialDc)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricPotentialDc.BaseUnit, ElectricPotentialDcUnit.MegavoltDc, (q) => ((ElectricPotentialDc)q).ToUnit(ElectricPotentialDcUnit.MegavoltDc)); - unitConverter.SetConversionFunction(ElectricPotentialDcUnit.MegavoltDc, ElectricPotentialDc.BaseUnit, (q) => ((ElectricPotentialDc)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricPotentialDc.BaseUnit, ElectricPotentialDcUnit.MicrovoltDc, (q) => ((ElectricPotentialDc)q).ToUnit(ElectricPotentialDcUnit.MicrovoltDc)); - unitConverter.SetConversionFunction(ElectricPotentialDcUnit.MicrovoltDc, ElectricPotentialDc.BaseUnit, (q) => ((ElectricPotentialDc)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricPotentialDc.BaseUnit, ElectricPotentialDcUnit.MillivoltDc, (q) => ((ElectricPotentialDc)q).ToUnit(ElectricPotentialDcUnit.MillivoltDc)); - unitConverter.SetConversionFunction(ElectricPotentialDcUnit.MillivoltDc, ElectricPotentialDc.BaseUnit, (q) => ((ElectricPotentialDc)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricPotentialDc.BaseUnit, ElectricPotentialDc.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(ElectricResistance.BaseUnit, ElectricResistanceUnit.Gigaohm, (q) => ((ElectricResistance)q).ToUnit(ElectricResistanceUnit.Gigaohm)); - unitConverter.SetConversionFunction(ElectricResistanceUnit.Gigaohm, ElectricResistance.BaseUnit, (q) => ((ElectricResistance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricResistance.BaseUnit, ElectricResistanceUnit.Kiloohm, (q) => ((ElectricResistance)q).ToUnit(ElectricResistanceUnit.Kiloohm)); - unitConverter.SetConversionFunction(ElectricResistanceUnit.Kiloohm, ElectricResistance.BaseUnit, (q) => ((ElectricResistance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricResistance.BaseUnit, ElectricResistanceUnit.Megaohm, (q) => ((ElectricResistance)q).ToUnit(ElectricResistanceUnit.Megaohm)); - unitConverter.SetConversionFunction(ElectricResistanceUnit.Megaohm, ElectricResistance.BaseUnit, (q) => ((ElectricResistance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricResistance.BaseUnit, ElectricResistanceUnit.Milliohm, (q) => ((ElectricResistance)q).ToUnit(ElectricResistanceUnit.Milliohm)); - unitConverter.SetConversionFunction(ElectricResistanceUnit.Milliohm, ElectricResistance.BaseUnit, (q) => ((ElectricResistance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricResistance.BaseUnit, ElectricResistance.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.KiloohmCentimeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.KiloohmCentimeter)); - unitConverter.SetConversionFunction(ElectricResistivityUnit.KiloohmCentimeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.KiloohmMeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.KiloohmMeter)); - unitConverter.SetConversionFunction(ElectricResistivityUnit.KiloohmMeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.MegaohmCentimeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.MegaohmCentimeter)); - unitConverter.SetConversionFunction(ElectricResistivityUnit.MegaohmCentimeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.MegaohmMeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.MegaohmMeter)); - unitConverter.SetConversionFunction(ElectricResistivityUnit.MegaohmMeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.MicroohmCentimeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.MicroohmCentimeter)); - unitConverter.SetConversionFunction(ElectricResistivityUnit.MicroohmCentimeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.MicroohmMeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.MicroohmMeter)); - unitConverter.SetConversionFunction(ElectricResistivityUnit.MicroohmMeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.MilliohmCentimeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.MilliohmCentimeter)); - unitConverter.SetConversionFunction(ElectricResistivityUnit.MilliohmCentimeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.MilliohmMeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.MilliohmMeter)); - unitConverter.SetConversionFunction(ElectricResistivityUnit.MilliohmMeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.NanoohmCentimeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.NanoohmCentimeter)); - unitConverter.SetConversionFunction(ElectricResistivityUnit.NanoohmCentimeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.NanoohmMeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.NanoohmMeter)); - unitConverter.SetConversionFunction(ElectricResistivityUnit.NanoohmMeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.OhmCentimeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.OhmCentimeter)); - unitConverter.SetConversionFunction(ElectricResistivityUnit.OhmCentimeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivity.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.PicoohmCentimeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.PicoohmCentimeter)); - unitConverter.SetConversionFunction(ElectricResistivityUnit.PicoohmCentimeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.PicoohmMeter, (q) => ((ElectricResistivity)q).ToUnit(ElectricResistivityUnit.PicoohmMeter)); - unitConverter.SetConversionFunction(ElectricResistivityUnit.PicoohmMeter, ElectricResistivity.BaseUnit, (q) => ((ElectricResistivity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.BritishThermalUnit, (q) => ((Energy)q).ToUnit(EnergyUnit.BritishThermalUnit)); - unitConverter.SetConversionFunction(EnergyUnit.BritishThermalUnit, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.Calorie, (q) => ((Energy)q).ToUnit(EnergyUnit.Calorie)); - unitConverter.SetConversionFunction(EnergyUnit.Calorie, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.DecathermEc, (q) => ((Energy)q).ToUnit(EnergyUnit.DecathermEc)); - unitConverter.SetConversionFunction(EnergyUnit.DecathermEc, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.DecathermImperial, (q) => ((Energy)q).ToUnit(EnergyUnit.DecathermImperial)); - unitConverter.SetConversionFunction(EnergyUnit.DecathermImperial, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.DecathermUs, (q) => ((Energy)q).ToUnit(EnergyUnit.DecathermUs)); - unitConverter.SetConversionFunction(EnergyUnit.DecathermUs, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.ElectronVolt, (q) => ((Energy)q).ToUnit(EnergyUnit.ElectronVolt)); - unitConverter.SetConversionFunction(EnergyUnit.ElectronVolt, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.Erg, (q) => ((Energy)q).ToUnit(EnergyUnit.Erg)); - unitConverter.SetConversionFunction(EnergyUnit.Erg, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.FootPound, (q) => ((Energy)q).ToUnit(EnergyUnit.FootPound)); - unitConverter.SetConversionFunction(EnergyUnit.FootPound, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.GigabritishThermalUnit, (q) => ((Energy)q).ToUnit(EnergyUnit.GigabritishThermalUnit)); - unitConverter.SetConversionFunction(EnergyUnit.GigabritishThermalUnit, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.GigawattHour, (q) => ((Energy)q).ToUnit(EnergyUnit.GigawattHour)); - unitConverter.SetConversionFunction(EnergyUnit.GigawattHour, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Energy.BaseUnit, Energy.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.KilobritishThermalUnit, (q) => ((Energy)q).ToUnit(EnergyUnit.KilobritishThermalUnit)); - unitConverter.SetConversionFunction(EnergyUnit.KilobritishThermalUnit, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.Kilocalorie, (q) => ((Energy)q).ToUnit(EnergyUnit.Kilocalorie)); - unitConverter.SetConversionFunction(EnergyUnit.Kilocalorie, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.Kilojoule, (q) => ((Energy)q).ToUnit(EnergyUnit.Kilojoule)); - unitConverter.SetConversionFunction(EnergyUnit.Kilojoule, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.KilowattHour, (q) => ((Energy)q).ToUnit(EnergyUnit.KilowattHour)); - unitConverter.SetConversionFunction(EnergyUnit.KilowattHour, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.MegabritishThermalUnit, (q) => ((Energy)q).ToUnit(EnergyUnit.MegabritishThermalUnit)); - unitConverter.SetConversionFunction(EnergyUnit.MegabritishThermalUnit, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.Megajoule, (q) => ((Energy)q).ToUnit(EnergyUnit.Megajoule)); - unitConverter.SetConversionFunction(EnergyUnit.Megajoule, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.MegawattHour, (q) => ((Energy)q).ToUnit(EnergyUnit.MegawattHour)); - unitConverter.SetConversionFunction(EnergyUnit.MegawattHour, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.ThermEc, (q) => ((Energy)q).ToUnit(EnergyUnit.ThermEc)); - unitConverter.SetConversionFunction(EnergyUnit.ThermEc, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.ThermImperial, (q) => ((Energy)q).ToUnit(EnergyUnit.ThermImperial)); - unitConverter.SetConversionFunction(EnergyUnit.ThermImperial, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.ThermUs, (q) => ((Energy)q).ToUnit(EnergyUnit.ThermUs)); - unitConverter.SetConversionFunction(EnergyUnit.ThermUs, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.WattHour, (q) => ((Energy)q).ToUnit(EnergyUnit.WattHour)); - unitConverter.SetConversionFunction(EnergyUnit.WattHour, Energy.BaseUnit, (q) => ((Energy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Entropy.BaseUnit, EntropyUnit.CaloriePerKelvin, (q) => ((Entropy)q).ToUnit(EntropyUnit.CaloriePerKelvin)); - unitConverter.SetConversionFunction(EntropyUnit.CaloriePerKelvin, Entropy.BaseUnit, (q) => ((Entropy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Entropy.BaseUnit, EntropyUnit.JoulePerDegreeCelsius, (q) => ((Entropy)q).ToUnit(EntropyUnit.JoulePerDegreeCelsius)); - unitConverter.SetConversionFunction(EntropyUnit.JoulePerDegreeCelsius, Entropy.BaseUnit, (q) => ((Entropy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Entropy.BaseUnit, Entropy.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Entropy.BaseUnit, EntropyUnit.KilocaloriePerKelvin, (q) => ((Entropy)q).ToUnit(EntropyUnit.KilocaloriePerKelvin)); - unitConverter.SetConversionFunction(EntropyUnit.KilocaloriePerKelvin, Entropy.BaseUnit, (q) => ((Entropy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Entropy.BaseUnit, EntropyUnit.KilojoulePerDegreeCelsius, (q) => ((Entropy)q).ToUnit(EntropyUnit.KilojoulePerDegreeCelsius)); - unitConverter.SetConversionFunction(EntropyUnit.KilojoulePerDegreeCelsius, Entropy.BaseUnit, (q) => ((Entropy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Entropy.BaseUnit, EntropyUnit.KilojoulePerKelvin, (q) => ((Entropy)q).ToUnit(EntropyUnit.KilojoulePerKelvin)); - unitConverter.SetConversionFunction(EntropyUnit.KilojoulePerKelvin, Entropy.BaseUnit, (q) => ((Entropy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Entropy.BaseUnit, EntropyUnit.MegajoulePerKelvin, (q) => ((Entropy)q).ToUnit(EntropyUnit.MegajoulePerKelvin)); - unitConverter.SetConversionFunction(EntropyUnit.MegajoulePerKelvin, Entropy.BaseUnit, (q) => ((Entropy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.Decanewton, (q) => ((Force)q).ToUnit(ForceUnit.Decanewton)); - unitConverter.SetConversionFunction(ForceUnit.Decanewton, Force.BaseUnit, (q) => ((Force)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.Dyn, (q) => ((Force)q).ToUnit(ForceUnit.Dyn)); - unitConverter.SetConversionFunction(ForceUnit.Dyn, Force.BaseUnit, (q) => ((Force)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.KilogramForce, (q) => ((Force)q).ToUnit(ForceUnit.KilogramForce)); - unitConverter.SetConversionFunction(ForceUnit.KilogramForce, Force.BaseUnit, (q) => ((Force)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.Kilonewton, (q) => ((Force)q).ToUnit(ForceUnit.Kilonewton)); - unitConverter.SetConversionFunction(ForceUnit.Kilonewton, Force.BaseUnit, (q) => ((Force)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.KiloPond, (q) => ((Force)q).ToUnit(ForceUnit.KiloPond)); - unitConverter.SetConversionFunction(ForceUnit.KiloPond, Force.BaseUnit, (q) => ((Force)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.Meganewton, (q) => ((Force)q).ToUnit(ForceUnit.Meganewton)); - unitConverter.SetConversionFunction(ForceUnit.Meganewton, Force.BaseUnit, (q) => ((Force)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.Micronewton, (q) => ((Force)q).ToUnit(ForceUnit.Micronewton)); - unitConverter.SetConversionFunction(ForceUnit.Micronewton, Force.BaseUnit, (q) => ((Force)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.Millinewton, (q) => ((Force)q).ToUnit(ForceUnit.Millinewton)); - unitConverter.SetConversionFunction(ForceUnit.Millinewton, Force.BaseUnit, (q) => ((Force)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Force.BaseUnit, Force.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.OunceForce, (q) => ((Force)q).ToUnit(ForceUnit.OunceForce)); - unitConverter.SetConversionFunction(ForceUnit.OunceForce, Force.BaseUnit, (q) => ((Force)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.Poundal, (q) => ((Force)q).ToUnit(ForceUnit.Poundal)); - unitConverter.SetConversionFunction(ForceUnit.Poundal, Force.BaseUnit, (q) => ((Force)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.PoundForce, (q) => ((Force)q).ToUnit(ForceUnit.PoundForce)); - unitConverter.SetConversionFunction(ForceUnit.PoundForce, Force.BaseUnit, (q) => ((Force)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.TonneForce, (q) => ((Force)q).ToUnit(ForceUnit.TonneForce)); - unitConverter.SetConversionFunction(ForceUnit.TonneForce, Force.BaseUnit, (q) => ((Force)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.CentinewtonPerSecond, (q) => ((ForceChangeRate)q).ToUnit(ForceChangeRateUnit.CentinewtonPerSecond)); - unitConverter.SetConversionFunction(ForceChangeRateUnit.CentinewtonPerSecond, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.DecanewtonPerMinute, (q) => ((ForceChangeRate)q).ToUnit(ForceChangeRateUnit.DecanewtonPerMinute)); - unitConverter.SetConversionFunction(ForceChangeRateUnit.DecanewtonPerMinute, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.DecanewtonPerSecond, (q) => ((ForceChangeRate)q).ToUnit(ForceChangeRateUnit.DecanewtonPerSecond)); - unitConverter.SetConversionFunction(ForceChangeRateUnit.DecanewtonPerSecond, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.DecinewtonPerSecond, (q) => ((ForceChangeRate)q).ToUnit(ForceChangeRateUnit.DecinewtonPerSecond)); - unitConverter.SetConversionFunction(ForceChangeRateUnit.DecinewtonPerSecond, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.KilonewtonPerMinute, (q) => ((ForceChangeRate)q).ToUnit(ForceChangeRateUnit.KilonewtonPerMinute)); - unitConverter.SetConversionFunction(ForceChangeRateUnit.KilonewtonPerMinute, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.KilonewtonPerSecond, (q) => ((ForceChangeRate)q).ToUnit(ForceChangeRateUnit.KilonewtonPerSecond)); - unitConverter.SetConversionFunction(ForceChangeRateUnit.KilonewtonPerSecond, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.MicronewtonPerSecond, (q) => ((ForceChangeRate)q).ToUnit(ForceChangeRateUnit.MicronewtonPerSecond)); - unitConverter.SetConversionFunction(ForceChangeRateUnit.MicronewtonPerSecond, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.MillinewtonPerSecond, (q) => ((ForceChangeRate)q).ToUnit(ForceChangeRateUnit.MillinewtonPerSecond)); - unitConverter.SetConversionFunction(ForceChangeRateUnit.MillinewtonPerSecond, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.NanonewtonPerSecond, (q) => ((ForceChangeRate)q).ToUnit(ForceChangeRateUnit.NanonewtonPerSecond)); - unitConverter.SetConversionFunction(ForceChangeRateUnit.NanonewtonPerSecond, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.NewtonPerMinute, (q) => ((ForceChangeRate)q).ToUnit(ForceChangeRateUnit.NewtonPerMinute)); - unitConverter.SetConversionFunction(ForceChangeRateUnit.NewtonPerMinute, ForceChangeRate.BaseUnit, (q) => ((ForceChangeRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRate.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.CentinewtonPerMeter, (q) => ((ForcePerLength)q).ToUnit(ForcePerLengthUnit.CentinewtonPerMeter)); - unitConverter.SetConversionFunction(ForcePerLengthUnit.CentinewtonPerMeter, ForcePerLength.BaseUnit, (q) => ((ForcePerLength)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.DecinewtonPerMeter, (q) => ((ForcePerLength)q).ToUnit(ForcePerLengthUnit.DecinewtonPerMeter)); - unitConverter.SetConversionFunction(ForcePerLengthUnit.DecinewtonPerMeter, ForcePerLength.BaseUnit, (q) => ((ForcePerLength)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.KilogramForcePerMeter, (q) => ((ForcePerLength)q).ToUnit(ForcePerLengthUnit.KilogramForcePerMeter)); - unitConverter.SetConversionFunction(ForcePerLengthUnit.KilogramForcePerMeter, ForcePerLength.BaseUnit, (q) => ((ForcePerLength)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.KilonewtonPerMeter, (q) => ((ForcePerLength)q).ToUnit(ForcePerLengthUnit.KilonewtonPerMeter)); - unitConverter.SetConversionFunction(ForcePerLengthUnit.KilonewtonPerMeter, ForcePerLength.BaseUnit, (q) => ((ForcePerLength)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.MeganewtonPerMeter, (q) => ((ForcePerLength)q).ToUnit(ForcePerLengthUnit.MeganewtonPerMeter)); - unitConverter.SetConversionFunction(ForcePerLengthUnit.MeganewtonPerMeter, ForcePerLength.BaseUnit, (q) => ((ForcePerLength)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.MicronewtonPerMeter, (q) => ((ForcePerLength)q).ToUnit(ForcePerLengthUnit.MicronewtonPerMeter)); - unitConverter.SetConversionFunction(ForcePerLengthUnit.MicronewtonPerMeter, ForcePerLength.BaseUnit, (q) => ((ForcePerLength)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.MillinewtonPerMeter, (q) => ((ForcePerLength)q).ToUnit(ForcePerLengthUnit.MillinewtonPerMeter)); - unitConverter.SetConversionFunction(ForcePerLengthUnit.MillinewtonPerMeter, ForcePerLength.BaseUnit, (q) => ((ForcePerLength)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.NanonewtonPerMeter, (q) => ((ForcePerLength)q).ToUnit(ForcePerLengthUnit.NanonewtonPerMeter)); - unitConverter.SetConversionFunction(ForcePerLengthUnit.NanonewtonPerMeter, ForcePerLength.BaseUnit, (q) => ((ForcePerLength)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLength.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Frequency.BaseUnit, FrequencyUnit.CyclePerHour, (q) => ((Frequency)q).ToUnit(FrequencyUnit.CyclePerHour)); - unitConverter.SetConversionFunction(FrequencyUnit.CyclePerHour, Frequency.BaseUnit, (q) => ((Frequency)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Frequency.BaseUnit, FrequencyUnit.CyclePerMinute, (q) => ((Frequency)q).ToUnit(FrequencyUnit.CyclePerMinute)); - unitConverter.SetConversionFunction(FrequencyUnit.CyclePerMinute, Frequency.BaseUnit, (q) => ((Frequency)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Frequency.BaseUnit, FrequencyUnit.Gigahertz, (q) => ((Frequency)q).ToUnit(FrequencyUnit.Gigahertz)); - unitConverter.SetConversionFunction(FrequencyUnit.Gigahertz, Frequency.BaseUnit, (q) => ((Frequency)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Frequency.BaseUnit, Frequency.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Frequency.BaseUnit, FrequencyUnit.Kilohertz, (q) => ((Frequency)q).ToUnit(FrequencyUnit.Kilohertz)); - unitConverter.SetConversionFunction(FrequencyUnit.Kilohertz, Frequency.BaseUnit, (q) => ((Frequency)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Frequency.BaseUnit, FrequencyUnit.Megahertz, (q) => ((Frequency)q).ToUnit(FrequencyUnit.Megahertz)); - unitConverter.SetConversionFunction(FrequencyUnit.Megahertz, Frequency.BaseUnit, (q) => ((Frequency)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Frequency.BaseUnit, FrequencyUnit.RadianPerSecond, (q) => ((Frequency)q).ToUnit(FrequencyUnit.RadianPerSecond)); - unitConverter.SetConversionFunction(FrequencyUnit.RadianPerSecond, Frequency.BaseUnit, (q) => ((Frequency)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Frequency.BaseUnit, FrequencyUnit.Terahertz, (q) => ((Frequency)q).ToUnit(FrequencyUnit.Terahertz)); - unitConverter.SetConversionFunction(FrequencyUnit.Terahertz, Frequency.BaseUnit, (q) => ((Frequency)q).ToBaseUnit()); - unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.BtuPerHourSquareFoot, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.BtuPerHourSquareFoot)); - unitConverter.SetConversionFunction(HeatFluxUnit.BtuPerHourSquareFoot, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).ToBaseUnit()); - unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.BtuPerMinuteSquareFoot, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.BtuPerMinuteSquareFoot)); - unitConverter.SetConversionFunction(HeatFluxUnit.BtuPerMinuteSquareFoot, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).ToBaseUnit()); - unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.BtuPerSecondSquareFoot, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.BtuPerSecondSquareFoot)); - unitConverter.SetConversionFunction(HeatFluxUnit.BtuPerSecondSquareFoot, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).ToBaseUnit()); - unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.BtuPerSecondSquareInch, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.BtuPerSecondSquareInch)); - unitConverter.SetConversionFunction(HeatFluxUnit.BtuPerSecondSquareInch, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).ToBaseUnit()); - unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.CaloriePerSecondSquareCentimeter, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.CaloriePerSecondSquareCentimeter)); - unitConverter.SetConversionFunction(HeatFluxUnit.CaloriePerSecondSquareCentimeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).ToBaseUnit()); - unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.CentiwattPerSquareMeter, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.CentiwattPerSquareMeter)); - unitConverter.SetConversionFunction(HeatFluxUnit.CentiwattPerSquareMeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).ToBaseUnit()); - unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.DeciwattPerSquareMeter, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.DeciwattPerSquareMeter)); - unitConverter.SetConversionFunction(HeatFluxUnit.DeciwattPerSquareMeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).ToBaseUnit()); - unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.KilocaloriePerHourSquareMeter, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.KilocaloriePerHourSquareMeter)); - unitConverter.SetConversionFunction(HeatFluxUnit.KilocaloriePerHourSquareMeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).ToBaseUnit()); - unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.KilocaloriePerSecondSquareCentimeter, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.KilocaloriePerSecondSquareCentimeter)); - unitConverter.SetConversionFunction(HeatFluxUnit.KilocaloriePerSecondSquareCentimeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).ToBaseUnit()); - unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.KilowattPerSquareMeter, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.KilowattPerSquareMeter)); - unitConverter.SetConversionFunction(HeatFluxUnit.KilowattPerSquareMeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).ToBaseUnit()); - unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.MicrowattPerSquareMeter, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.MicrowattPerSquareMeter)); - unitConverter.SetConversionFunction(HeatFluxUnit.MicrowattPerSquareMeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).ToBaseUnit()); - unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.MilliwattPerSquareMeter, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.MilliwattPerSquareMeter)); - unitConverter.SetConversionFunction(HeatFluxUnit.MilliwattPerSquareMeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).ToBaseUnit()); - unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.NanowattPerSquareMeter, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.NanowattPerSquareMeter)); - unitConverter.SetConversionFunction(HeatFluxUnit.NanowattPerSquareMeter, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).ToBaseUnit()); - unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.PoundForcePerFootSecond, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.PoundForcePerFootSecond)); - unitConverter.SetConversionFunction(HeatFluxUnit.PoundForcePerFootSecond, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).ToBaseUnit()); - unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.PoundPerSecondCubed, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.PoundPerSecondCubed)); - unitConverter.SetConversionFunction(HeatFluxUnit.PoundPerSecondCubed, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).ToBaseUnit()); - unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.WattPerSquareFoot, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.WattPerSquareFoot)); - unitConverter.SetConversionFunction(HeatFluxUnit.WattPerSquareFoot, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).ToBaseUnit()); - unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.WattPerSquareInch, (q) => ((HeatFlux)q).ToUnit(HeatFluxUnit.WattPerSquareInch)); - unitConverter.SetConversionFunction(HeatFluxUnit.WattPerSquareInch, HeatFlux.BaseUnit, (q) => ((HeatFlux)q).ToBaseUnit()); - unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFlux.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(HeatTransferCoefficient.BaseUnit, HeatTransferCoefficientUnit.WattPerSquareMeterCelsius, (q) => ((HeatTransferCoefficient)q).ToUnit(HeatTransferCoefficientUnit.WattPerSquareMeterCelsius)); - unitConverter.SetConversionFunction(HeatTransferCoefficientUnit.WattPerSquareMeterCelsius, HeatTransferCoefficient.BaseUnit, (q) => ((HeatTransferCoefficient)q).ToBaseUnit()); - unitConverter.SetConversionFunction(HeatTransferCoefficient.BaseUnit, HeatTransferCoefficient.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Illuminance.BaseUnit, IlluminanceUnit.Kilolux, (q) => ((Illuminance)q).ToUnit(IlluminanceUnit.Kilolux)); - unitConverter.SetConversionFunction(IlluminanceUnit.Kilolux, Illuminance.BaseUnit, (q) => ((Illuminance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Illuminance.BaseUnit, Illuminance.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Illuminance.BaseUnit, IlluminanceUnit.Megalux, (q) => ((Illuminance)q).ToUnit(IlluminanceUnit.Megalux)); - unitConverter.SetConversionFunction(IlluminanceUnit.Megalux, Illuminance.BaseUnit, (q) => ((Illuminance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Illuminance.BaseUnit, IlluminanceUnit.Millilux, (q) => ((Illuminance)q).ToUnit(IlluminanceUnit.Millilux)); - unitConverter.SetConversionFunction(IlluminanceUnit.Millilux, Illuminance.BaseUnit, (q) => ((Illuminance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Information.BaseUnit, Information.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Byte, (q) => ((Information)q).ToUnit(InformationUnit.Byte)); - unitConverter.SetConversionFunction(InformationUnit.Byte, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Exabit, (q) => ((Information)q).ToUnit(InformationUnit.Exabit)); - unitConverter.SetConversionFunction(InformationUnit.Exabit, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Exabyte, (q) => ((Information)q).ToUnit(InformationUnit.Exabyte)); - unitConverter.SetConversionFunction(InformationUnit.Exabyte, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Exbibit, (q) => ((Information)q).ToUnit(InformationUnit.Exbibit)); - unitConverter.SetConversionFunction(InformationUnit.Exbibit, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Exbibyte, (q) => ((Information)q).ToUnit(InformationUnit.Exbibyte)); - unitConverter.SetConversionFunction(InformationUnit.Exbibyte, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Gibibit, (q) => ((Information)q).ToUnit(InformationUnit.Gibibit)); - unitConverter.SetConversionFunction(InformationUnit.Gibibit, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Gibibyte, (q) => ((Information)q).ToUnit(InformationUnit.Gibibyte)); - unitConverter.SetConversionFunction(InformationUnit.Gibibyte, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Gigabit, (q) => ((Information)q).ToUnit(InformationUnit.Gigabit)); - unitConverter.SetConversionFunction(InformationUnit.Gigabit, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Gigabyte, (q) => ((Information)q).ToUnit(InformationUnit.Gigabyte)); - unitConverter.SetConversionFunction(InformationUnit.Gigabyte, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Kibibit, (q) => ((Information)q).ToUnit(InformationUnit.Kibibit)); - unitConverter.SetConversionFunction(InformationUnit.Kibibit, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Kibibyte, (q) => ((Information)q).ToUnit(InformationUnit.Kibibyte)); - unitConverter.SetConversionFunction(InformationUnit.Kibibyte, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Kilobit, (q) => ((Information)q).ToUnit(InformationUnit.Kilobit)); - unitConverter.SetConversionFunction(InformationUnit.Kilobit, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Kilobyte, (q) => ((Information)q).ToUnit(InformationUnit.Kilobyte)); - unitConverter.SetConversionFunction(InformationUnit.Kilobyte, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Mebibit, (q) => ((Information)q).ToUnit(InformationUnit.Mebibit)); - unitConverter.SetConversionFunction(InformationUnit.Mebibit, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Mebibyte, (q) => ((Information)q).ToUnit(InformationUnit.Mebibyte)); - unitConverter.SetConversionFunction(InformationUnit.Mebibyte, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Megabit, (q) => ((Information)q).ToUnit(InformationUnit.Megabit)); - unitConverter.SetConversionFunction(InformationUnit.Megabit, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Megabyte, (q) => ((Information)q).ToUnit(InformationUnit.Megabyte)); - unitConverter.SetConversionFunction(InformationUnit.Megabyte, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Pebibit, (q) => ((Information)q).ToUnit(InformationUnit.Pebibit)); - unitConverter.SetConversionFunction(InformationUnit.Pebibit, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Pebibyte, (q) => ((Information)q).ToUnit(InformationUnit.Pebibyte)); - unitConverter.SetConversionFunction(InformationUnit.Pebibyte, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Petabit, (q) => ((Information)q).ToUnit(InformationUnit.Petabit)); - unitConverter.SetConversionFunction(InformationUnit.Petabit, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Petabyte, (q) => ((Information)q).ToUnit(InformationUnit.Petabyte)); - unitConverter.SetConversionFunction(InformationUnit.Petabyte, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Tebibit, (q) => ((Information)q).ToUnit(InformationUnit.Tebibit)); - unitConverter.SetConversionFunction(InformationUnit.Tebibit, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Tebibyte, (q) => ((Information)q).ToUnit(InformationUnit.Tebibyte)); - unitConverter.SetConversionFunction(InformationUnit.Tebibyte, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Terabit, (q) => ((Information)q).ToUnit(InformationUnit.Terabit)); - unitConverter.SetConversionFunction(InformationUnit.Terabit, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Terabyte, (q) => ((Information)q).ToUnit(InformationUnit.Terabyte)); - unitConverter.SetConversionFunction(InformationUnit.Terabyte, Information.BaseUnit, (q) => ((Information)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.KilowattPerSquareCentimeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.KilowattPerSquareCentimeter)); - unitConverter.SetConversionFunction(IrradianceUnit.KilowattPerSquareCentimeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.KilowattPerSquareMeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.KilowattPerSquareMeter)); - unitConverter.SetConversionFunction(IrradianceUnit.KilowattPerSquareMeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.MegawattPerSquareCentimeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.MegawattPerSquareCentimeter)); - unitConverter.SetConversionFunction(IrradianceUnit.MegawattPerSquareCentimeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.MegawattPerSquareMeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.MegawattPerSquareMeter)); - unitConverter.SetConversionFunction(IrradianceUnit.MegawattPerSquareMeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.MicrowattPerSquareCentimeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.MicrowattPerSquareCentimeter)); - unitConverter.SetConversionFunction(IrradianceUnit.MicrowattPerSquareCentimeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.MicrowattPerSquareMeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.MicrowattPerSquareMeter)); - unitConverter.SetConversionFunction(IrradianceUnit.MicrowattPerSquareMeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.MilliwattPerSquareCentimeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.MilliwattPerSquareCentimeter)); - unitConverter.SetConversionFunction(IrradianceUnit.MilliwattPerSquareCentimeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.MilliwattPerSquareMeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.MilliwattPerSquareMeter)); - unitConverter.SetConversionFunction(IrradianceUnit.MilliwattPerSquareMeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.NanowattPerSquareCentimeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.NanowattPerSquareCentimeter)); - unitConverter.SetConversionFunction(IrradianceUnit.NanowattPerSquareCentimeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.NanowattPerSquareMeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.NanowattPerSquareMeter)); - unitConverter.SetConversionFunction(IrradianceUnit.NanowattPerSquareMeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.PicowattPerSquareCentimeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.PicowattPerSquareCentimeter)); - unitConverter.SetConversionFunction(IrradianceUnit.PicowattPerSquareCentimeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.PicowattPerSquareMeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.PicowattPerSquareMeter)); - unitConverter.SetConversionFunction(IrradianceUnit.PicowattPerSquareMeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.WattPerSquareCentimeter, (q) => ((Irradiance)q).ToUnit(IrradianceUnit.WattPerSquareCentimeter)); - unitConverter.SetConversionFunction(IrradianceUnit.WattPerSquareCentimeter, Irradiance.BaseUnit, (q) => ((Irradiance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Irradiance.BaseUnit, Irradiance.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Irradiation.BaseUnit, IrradiationUnit.JoulePerSquareCentimeter, (q) => ((Irradiation)q).ToUnit(IrradiationUnit.JoulePerSquareCentimeter)); - unitConverter.SetConversionFunction(IrradiationUnit.JoulePerSquareCentimeter, Irradiation.BaseUnit, (q) => ((Irradiation)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Irradiation.BaseUnit, Irradiation.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Irradiation.BaseUnit, IrradiationUnit.JoulePerSquareMillimeter, (q) => ((Irradiation)q).ToUnit(IrradiationUnit.JoulePerSquareMillimeter)); - unitConverter.SetConversionFunction(IrradiationUnit.JoulePerSquareMillimeter, Irradiation.BaseUnit, (q) => ((Irradiation)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Irradiation.BaseUnit, IrradiationUnit.KilojoulePerSquareMeter, (q) => ((Irradiation)q).ToUnit(IrradiationUnit.KilojoulePerSquareMeter)); - unitConverter.SetConversionFunction(IrradiationUnit.KilojoulePerSquareMeter, Irradiation.BaseUnit, (q) => ((Irradiation)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Irradiation.BaseUnit, IrradiationUnit.KilowattHourPerSquareMeter, (q) => ((Irradiation)q).ToUnit(IrradiationUnit.KilowattHourPerSquareMeter)); - unitConverter.SetConversionFunction(IrradiationUnit.KilowattHourPerSquareMeter, Irradiation.BaseUnit, (q) => ((Irradiation)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Irradiation.BaseUnit, IrradiationUnit.WattHourPerSquareMeter, (q) => ((Irradiation)q).ToUnit(IrradiationUnit.WattHourPerSquareMeter)); - unitConverter.SetConversionFunction(IrradiationUnit.WattHourPerSquareMeter, Irradiation.BaseUnit, (q) => ((Irradiation)q).ToBaseUnit()); - unitConverter.SetConversionFunction(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Centistokes, (q) => ((KinematicViscosity)q).ToUnit(KinematicViscosityUnit.Centistokes)); - unitConverter.SetConversionFunction(KinematicViscosityUnit.Centistokes, KinematicViscosity.BaseUnit, (q) => ((KinematicViscosity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Decistokes, (q) => ((KinematicViscosity)q).ToUnit(KinematicViscosityUnit.Decistokes)); - unitConverter.SetConversionFunction(KinematicViscosityUnit.Decistokes, KinematicViscosity.BaseUnit, (q) => ((KinematicViscosity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Kilostokes, (q) => ((KinematicViscosity)q).ToUnit(KinematicViscosityUnit.Kilostokes)); - unitConverter.SetConversionFunction(KinematicViscosityUnit.Kilostokes, KinematicViscosity.BaseUnit, (q) => ((KinematicViscosity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Microstokes, (q) => ((KinematicViscosity)q).ToUnit(KinematicViscosityUnit.Microstokes)); - unitConverter.SetConversionFunction(KinematicViscosityUnit.Microstokes, KinematicViscosity.BaseUnit, (q) => ((KinematicViscosity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Millistokes, (q) => ((KinematicViscosity)q).ToUnit(KinematicViscosityUnit.Millistokes)); - unitConverter.SetConversionFunction(KinematicViscosityUnit.Millistokes, KinematicViscosity.BaseUnit, (q) => ((KinematicViscosity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Nanostokes, (q) => ((KinematicViscosity)q).ToUnit(KinematicViscosityUnit.Nanostokes)); - unitConverter.SetConversionFunction(KinematicViscosityUnit.Nanostokes, KinematicViscosity.BaseUnit, (q) => ((KinematicViscosity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(KinematicViscosity.BaseUnit, KinematicViscosity.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Stokes, (q) => ((KinematicViscosity)q).ToUnit(KinematicViscosityUnit.Stokes)); - unitConverter.SetConversionFunction(KinematicViscosityUnit.Stokes, KinematicViscosity.BaseUnit, (q) => ((KinematicViscosity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(LapseRate.BaseUnit, LapseRate.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Centimeter, (q) => ((Length)q).ToUnit(LengthUnit.Centimeter)); - unitConverter.SetConversionFunction(LengthUnit.Centimeter, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Decimeter, (q) => ((Length)q).ToUnit(LengthUnit.Decimeter)); - unitConverter.SetConversionFunction(LengthUnit.Decimeter, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.DtpPica, (q) => ((Length)q).ToUnit(LengthUnit.DtpPica)); - unitConverter.SetConversionFunction(LengthUnit.DtpPica, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.DtpPoint, (q) => ((Length)q).ToUnit(LengthUnit.DtpPoint)); - unitConverter.SetConversionFunction(LengthUnit.DtpPoint, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Fathom, (q) => ((Length)q).ToUnit(LengthUnit.Fathom)); - unitConverter.SetConversionFunction(LengthUnit.Fathom, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Foot, (q) => ((Length)q).ToUnit(LengthUnit.Foot)); - unitConverter.SetConversionFunction(LengthUnit.Foot, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Inch, (q) => ((Length)q).ToUnit(LengthUnit.Inch)); - unitConverter.SetConversionFunction(LengthUnit.Inch, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Kilometer, (q) => ((Length)q).ToUnit(LengthUnit.Kilometer)); - unitConverter.SetConversionFunction(LengthUnit.Kilometer, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Length.BaseUnit, Length.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Microinch, (q) => ((Length)q).ToUnit(LengthUnit.Microinch)); - unitConverter.SetConversionFunction(LengthUnit.Microinch, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Micrometer, (q) => ((Length)q).ToUnit(LengthUnit.Micrometer)); - unitConverter.SetConversionFunction(LengthUnit.Micrometer, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Mil, (q) => ((Length)q).ToUnit(LengthUnit.Mil)); - unitConverter.SetConversionFunction(LengthUnit.Mil, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Mile, (q) => ((Length)q).ToUnit(LengthUnit.Mile)); - unitConverter.SetConversionFunction(LengthUnit.Mile, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Millimeter, (q) => ((Length)q).ToUnit(LengthUnit.Millimeter)); - unitConverter.SetConversionFunction(LengthUnit.Millimeter, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Nanometer, (q) => ((Length)q).ToUnit(LengthUnit.Nanometer)); - unitConverter.SetConversionFunction(LengthUnit.Nanometer, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.NauticalMile, (q) => ((Length)q).ToUnit(LengthUnit.NauticalMile)); - unitConverter.SetConversionFunction(LengthUnit.NauticalMile, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.PrinterPica, (q) => ((Length)q).ToUnit(LengthUnit.PrinterPica)); - unitConverter.SetConversionFunction(LengthUnit.PrinterPica, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.PrinterPoint, (q) => ((Length)q).ToUnit(LengthUnit.PrinterPoint)); - unitConverter.SetConversionFunction(LengthUnit.PrinterPoint, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Shackle, (q) => ((Length)q).ToUnit(LengthUnit.Shackle)); - unitConverter.SetConversionFunction(LengthUnit.Shackle, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Twip, (q) => ((Length)q).ToUnit(LengthUnit.Twip)); - unitConverter.SetConversionFunction(LengthUnit.Twip, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.UsSurveyFoot, (q) => ((Length)q).ToUnit(LengthUnit.UsSurveyFoot)); - unitConverter.SetConversionFunction(LengthUnit.UsSurveyFoot, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Yard, (q) => ((Length)q).ToUnit(LengthUnit.Yard)); - unitConverter.SetConversionFunction(LengthUnit.Yard, Length.BaseUnit, (q) => ((Length)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Level.BaseUnit, Level.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Level.BaseUnit, LevelUnit.Neper, (q) => ((Level)q).ToUnit(LevelUnit.Neper)); - unitConverter.SetConversionFunction(LevelUnit.Neper, Level.BaseUnit, (q) => ((Level)q).ToBaseUnit()); - unitConverter.SetConversionFunction(LinearDensity.BaseUnit, LinearDensityUnit.GramPerMeter, (q) => ((LinearDensity)q).ToUnit(LinearDensityUnit.GramPerMeter)); - unitConverter.SetConversionFunction(LinearDensityUnit.GramPerMeter, LinearDensity.BaseUnit, (q) => ((LinearDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(LinearDensity.BaseUnit, LinearDensity.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(LinearDensity.BaseUnit, LinearDensityUnit.PoundPerFoot, (q) => ((LinearDensity)q).ToUnit(LinearDensityUnit.PoundPerFoot)); - unitConverter.SetConversionFunction(LinearDensityUnit.PoundPerFoot, LinearDensity.BaseUnit, (q) => ((LinearDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(LuminousFlux.BaseUnit, LuminousFlux.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(LuminousIntensity.BaseUnit, LuminousIntensity.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(MagneticField.BaseUnit, MagneticFieldUnit.Microtesla, (q) => ((MagneticField)q).ToUnit(MagneticFieldUnit.Microtesla)); - unitConverter.SetConversionFunction(MagneticFieldUnit.Microtesla, MagneticField.BaseUnit, (q) => ((MagneticField)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MagneticField.BaseUnit, MagneticFieldUnit.Millitesla, (q) => ((MagneticField)q).ToUnit(MagneticFieldUnit.Millitesla)); - unitConverter.SetConversionFunction(MagneticFieldUnit.Millitesla, MagneticField.BaseUnit, (q) => ((MagneticField)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MagneticField.BaseUnit, MagneticFieldUnit.Nanotesla, (q) => ((MagneticField)q).ToUnit(MagneticFieldUnit.Nanotesla)); - unitConverter.SetConversionFunction(MagneticFieldUnit.Nanotesla, MagneticField.BaseUnit, (q) => ((MagneticField)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MagneticField.BaseUnit, MagneticField.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(MagneticFlux.BaseUnit, MagneticFlux.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Magnetization.BaseUnit, Magnetization.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Centigram, (q) => ((Mass)q).ToUnit(MassUnit.Centigram)); - unitConverter.SetConversionFunction(MassUnit.Centigram, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Decagram, (q) => ((Mass)q).ToUnit(MassUnit.Decagram)); - unitConverter.SetConversionFunction(MassUnit.Decagram, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Decigram, (q) => ((Mass)q).ToUnit(MassUnit.Decigram)); - unitConverter.SetConversionFunction(MassUnit.Decigram, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Grain, (q) => ((Mass)q).ToUnit(MassUnit.Grain)); - unitConverter.SetConversionFunction(MassUnit.Grain, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Gram, (q) => ((Mass)q).ToUnit(MassUnit.Gram)); - unitConverter.SetConversionFunction(MassUnit.Gram, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Hectogram, (q) => ((Mass)q).ToUnit(MassUnit.Hectogram)); - unitConverter.SetConversionFunction(MassUnit.Hectogram, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Mass.BaseUnit, Mass.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Kilopound, (q) => ((Mass)q).ToUnit(MassUnit.Kilopound)); - unitConverter.SetConversionFunction(MassUnit.Kilopound, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Kilotonne, (q) => ((Mass)q).ToUnit(MassUnit.Kilotonne)); - unitConverter.SetConversionFunction(MassUnit.Kilotonne, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.LongHundredweight, (q) => ((Mass)q).ToUnit(MassUnit.LongHundredweight)); - unitConverter.SetConversionFunction(MassUnit.LongHundredweight, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.LongTon, (q) => ((Mass)q).ToUnit(MassUnit.LongTon)); - unitConverter.SetConversionFunction(MassUnit.LongTon, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Megapound, (q) => ((Mass)q).ToUnit(MassUnit.Megapound)); - unitConverter.SetConversionFunction(MassUnit.Megapound, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Megatonne, (q) => ((Mass)q).ToUnit(MassUnit.Megatonne)); - unitConverter.SetConversionFunction(MassUnit.Megatonne, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Microgram, (q) => ((Mass)q).ToUnit(MassUnit.Microgram)); - unitConverter.SetConversionFunction(MassUnit.Microgram, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Milligram, (q) => ((Mass)q).ToUnit(MassUnit.Milligram)); - unitConverter.SetConversionFunction(MassUnit.Milligram, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Nanogram, (q) => ((Mass)q).ToUnit(MassUnit.Nanogram)); - unitConverter.SetConversionFunction(MassUnit.Nanogram, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Ounce, (q) => ((Mass)q).ToUnit(MassUnit.Ounce)); - unitConverter.SetConversionFunction(MassUnit.Ounce, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Pound, (q) => ((Mass)q).ToUnit(MassUnit.Pound)); - unitConverter.SetConversionFunction(MassUnit.Pound, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.ShortHundredweight, (q) => ((Mass)q).ToUnit(MassUnit.ShortHundredweight)); - unitConverter.SetConversionFunction(MassUnit.ShortHundredweight, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.ShortTon, (q) => ((Mass)q).ToUnit(MassUnit.ShortTon)); - unitConverter.SetConversionFunction(MassUnit.ShortTon, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Slug, (q) => ((Mass)q).ToUnit(MassUnit.Slug)); - unitConverter.SetConversionFunction(MassUnit.Slug, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Stone, (q) => ((Mass)q).ToUnit(MassUnit.Stone)); - unitConverter.SetConversionFunction(MassUnit.Stone, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Tonne, (q) => ((Mass)q).ToUnit(MassUnit.Tonne)); - unitConverter.SetConversionFunction(MassUnit.Tonne, Mass.BaseUnit, (q) => ((Mass)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.CentigramPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.CentigramPerDay)); - unitConverter.SetConversionFunction(MassFlowUnit.CentigramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.CentigramPerSecond, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.CentigramPerSecond)); - unitConverter.SetConversionFunction(MassFlowUnit.CentigramPerSecond, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.DecagramPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.DecagramPerDay)); - unitConverter.SetConversionFunction(MassFlowUnit.DecagramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.DecagramPerSecond, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.DecagramPerSecond)); - unitConverter.SetConversionFunction(MassFlowUnit.DecagramPerSecond, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.DecigramPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.DecigramPerDay)); - unitConverter.SetConversionFunction(MassFlowUnit.DecigramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.DecigramPerSecond, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.DecigramPerSecond)); - unitConverter.SetConversionFunction(MassFlowUnit.DecigramPerSecond, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.GramPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.GramPerDay)); - unitConverter.SetConversionFunction(MassFlowUnit.GramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.GramPerHour, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.GramPerHour)); - unitConverter.SetConversionFunction(MassFlowUnit.GramPerHour, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlow.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.HectogramPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.HectogramPerDay)); - unitConverter.SetConversionFunction(MassFlowUnit.HectogramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.HectogramPerSecond, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.HectogramPerSecond)); - unitConverter.SetConversionFunction(MassFlowUnit.HectogramPerSecond, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.KilogramPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.KilogramPerDay)); - unitConverter.SetConversionFunction(MassFlowUnit.KilogramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.KilogramPerHour, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.KilogramPerHour)); - unitConverter.SetConversionFunction(MassFlowUnit.KilogramPerHour, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.KilogramPerMinute, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.KilogramPerMinute)); - unitConverter.SetConversionFunction(MassFlowUnit.KilogramPerMinute, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.KilogramPerSecond, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.KilogramPerSecond)); - unitConverter.SetConversionFunction(MassFlowUnit.KilogramPerSecond, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MegagramPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.MegagramPerDay)); - unitConverter.SetConversionFunction(MassFlowUnit.MegagramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MegapoundPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.MegapoundPerDay)); - unitConverter.SetConversionFunction(MassFlowUnit.MegapoundPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MegapoundPerHour, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.MegapoundPerHour)); - unitConverter.SetConversionFunction(MassFlowUnit.MegapoundPerHour, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MegapoundPerMinute, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.MegapoundPerMinute)); - unitConverter.SetConversionFunction(MassFlowUnit.MegapoundPerMinute, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MicrogramPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.MicrogramPerDay)); - unitConverter.SetConversionFunction(MassFlowUnit.MicrogramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MicrogramPerSecond, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.MicrogramPerSecond)); - unitConverter.SetConversionFunction(MassFlowUnit.MicrogramPerSecond, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MilligramPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.MilligramPerDay)); - unitConverter.SetConversionFunction(MassFlowUnit.MilligramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MilligramPerSecond, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.MilligramPerSecond)); - unitConverter.SetConversionFunction(MassFlowUnit.MilligramPerSecond, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.NanogramPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.NanogramPerDay)); - unitConverter.SetConversionFunction(MassFlowUnit.NanogramPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.NanogramPerSecond, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.NanogramPerSecond)); - unitConverter.SetConversionFunction(MassFlowUnit.NanogramPerSecond, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.PoundPerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.PoundPerDay)); - unitConverter.SetConversionFunction(MassFlowUnit.PoundPerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.PoundPerHour, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.PoundPerHour)); - unitConverter.SetConversionFunction(MassFlowUnit.PoundPerHour, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.PoundPerMinute, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.PoundPerMinute)); - unitConverter.SetConversionFunction(MassFlowUnit.PoundPerMinute, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.ShortTonPerHour, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.ShortTonPerHour)); - unitConverter.SetConversionFunction(MassFlowUnit.ShortTonPerHour, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.TonnePerDay, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.TonnePerDay)); - unitConverter.SetConversionFunction(MassFlowUnit.TonnePerDay, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.TonnePerHour, (q) => ((MassFlow)q).ToUnit(MassFlowUnit.TonnePerHour)); - unitConverter.SetConversionFunction(MassFlowUnit.TonnePerHour, MassFlow.BaseUnit, (q) => ((MassFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassFlux.BaseUnit, MassFluxUnit.GramPerSecondPerSquareMeter, (q) => ((MassFlux)q).ToUnit(MassFluxUnit.GramPerSecondPerSquareMeter)); - unitConverter.SetConversionFunction(MassFluxUnit.GramPerSecondPerSquareMeter, MassFlux.BaseUnit, (q) => ((MassFlux)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassFlux.BaseUnit, MassFlux.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.GramSquareCentimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.GramSquareCentimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.GramSquareCentimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.GramSquareDecimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.GramSquareDecimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.GramSquareDecimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.GramSquareMeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.GramSquareMeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.GramSquareMeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.GramSquareMillimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.GramSquareMillimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.GramSquareMillimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilogramSquareCentimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.KilogramSquareCentimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilogramSquareCentimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilogramSquareDecimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.KilogramSquareDecimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilogramSquareDecimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertia.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilogramSquareMillimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.KilogramSquareMillimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilogramSquareMillimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilotonneSquareCentimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.KilotonneSquareCentimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilotonneSquareCentimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilotonneSquareDecimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.KilotonneSquareDecimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilotonneSquareDecimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilotonneSquareMeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.KilotonneSquareMeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilotonneSquareMeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilotonneSquareMilimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.KilotonneSquareMilimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilotonneSquareMilimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MegatonneSquareCentimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.MegatonneSquareCentimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MegatonneSquareCentimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MegatonneSquareDecimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.MegatonneSquareDecimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MegatonneSquareDecimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MegatonneSquareMeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.MegatonneSquareMeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MegatonneSquareMeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MegatonneSquareMilimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.MegatonneSquareMilimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MegatonneSquareMilimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MilligramSquareCentimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.MilligramSquareCentimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MilligramSquareCentimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MilligramSquareDecimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.MilligramSquareDecimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MilligramSquareDecimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MilligramSquareMeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.MilligramSquareMeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MilligramSquareMeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MilligramSquareMillimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.MilligramSquareMillimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MilligramSquareMillimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.PoundSquareFoot, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.PoundSquareFoot)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.PoundSquareFoot, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.PoundSquareInch, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.PoundSquareInch)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.PoundSquareInch, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.SlugSquareFoot, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.SlugSquareFoot)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.SlugSquareFoot, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.SlugSquareInch, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.SlugSquareInch)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.SlugSquareInch, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.TonneSquareCentimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.TonneSquareCentimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.TonneSquareCentimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.TonneSquareDecimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.TonneSquareDecimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.TonneSquareDecimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.TonneSquareMeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.TonneSquareMeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.TonneSquareMeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.TonneSquareMilimeter, (q) => ((MassMomentOfInertia)q).ToUnit(MassMomentOfInertiaUnit.TonneSquareMilimeter)); - unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.TonneSquareMilimeter, MassMomentOfInertia.BaseUnit, (q) => ((MassMomentOfInertia)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MolarEnergy.BaseUnit, MolarEnergy.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(MolarEnergy.BaseUnit, MolarEnergyUnit.KilojoulePerMole, (q) => ((MolarEnergy)q).ToUnit(MolarEnergyUnit.KilojoulePerMole)); - unitConverter.SetConversionFunction(MolarEnergyUnit.KilojoulePerMole, MolarEnergy.BaseUnit, (q) => ((MolarEnergy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MolarEnergy.BaseUnit, MolarEnergyUnit.MegajoulePerMole, (q) => ((MolarEnergy)q).ToUnit(MolarEnergyUnit.MegajoulePerMole)); - unitConverter.SetConversionFunction(MolarEnergyUnit.MegajoulePerMole, MolarEnergy.BaseUnit, (q) => ((MolarEnergy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MolarEntropy.BaseUnit, MolarEntropy.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(MolarEntropy.BaseUnit, MolarEntropyUnit.KilojoulePerMoleKelvin, (q) => ((MolarEntropy)q).ToUnit(MolarEntropyUnit.KilojoulePerMoleKelvin)); - unitConverter.SetConversionFunction(MolarEntropyUnit.KilojoulePerMoleKelvin, MolarEntropy.BaseUnit, (q) => ((MolarEntropy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MolarEntropy.BaseUnit, MolarEntropyUnit.MegajoulePerMoleKelvin, (q) => ((MolarEntropy)q).ToUnit(MolarEntropyUnit.MegajoulePerMoleKelvin)); - unitConverter.SetConversionFunction(MolarEntropyUnit.MegajoulePerMoleKelvin, MolarEntropy.BaseUnit, (q) => ((MolarEntropy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Molarity.BaseUnit, MolarityUnit.CentimolesPerLiter, (q) => ((Molarity)q).ToUnit(MolarityUnit.CentimolesPerLiter)); - unitConverter.SetConversionFunction(MolarityUnit.CentimolesPerLiter, Molarity.BaseUnit, (q) => ((Molarity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Molarity.BaseUnit, MolarityUnit.DecimolesPerLiter, (q) => ((Molarity)q).ToUnit(MolarityUnit.DecimolesPerLiter)); - unitConverter.SetConversionFunction(MolarityUnit.DecimolesPerLiter, Molarity.BaseUnit, (q) => ((Molarity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Molarity.BaseUnit, MolarityUnit.MicromolesPerLiter, (q) => ((Molarity)q).ToUnit(MolarityUnit.MicromolesPerLiter)); - unitConverter.SetConversionFunction(MolarityUnit.MicromolesPerLiter, Molarity.BaseUnit, (q) => ((Molarity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Molarity.BaseUnit, MolarityUnit.MillimolesPerLiter, (q) => ((Molarity)q).ToUnit(MolarityUnit.MillimolesPerLiter)); - unitConverter.SetConversionFunction(MolarityUnit.MillimolesPerLiter, Molarity.BaseUnit, (q) => ((Molarity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Molarity.BaseUnit, Molarity.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Molarity.BaseUnit, MolarityUnit.MolesPerLiter, (q) => ((Molarity)q).ToUnit(MolarityUnit.MolesPerLiter)); - unitConverter.SetConversionFunction(MolarityUnit.MolesPerLiter, Molarity.BaseUnit, (q) => ((Molarity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Molarity.BaseUnit, MolarityUnit.NanomolesPerLiter, (q) => ((Molarity)q).ToUnit(MolarityUnit.NanomolesPerLiter)); - unitConverter.SetConversionFunction(MolarityUnit.NanomolesPerLiter, Molarity.BaseUnit, (q) => ((Molarity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Molarity.BaseUnit, MolarityUnit.PicomolesPerLiter, (q) => ((Molarity)q).ToUnit(MolarityUnit.PicomolesPerLiter)); - unitConverter.SetConversionFunction(MolarityUnit.PicomolesPerLiter, Molarity.BaseUnit, (q) => ((Molarity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.CentigramPerMole, (q) => ((MolarMass)q).ToUnit(MolarMassUnit.CentigramPerMole)); - unitConverter.SetConversionFunction(MolarMassUnit.CentigramPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.DecagramPerMole, (q) => ((MolarMass)q).ToUnit(MolarMassUnit.DecagramPerMole)); - unitConverter.SetConversionFunction(MolarMassUnit.DecagramPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.DecigramPerMole, (q) => ((MolarMass)q).ToUnit(MolarMassUnit.DecigramPerMole)); - unitConverter.SetConversionFunction(MolarMassUnit.DecigramPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.GramPerMole, (q) => ((MolarMass)q).ToUnit(MolarMassUnit.GramPerMole)); - unitConverter.SetConversionFunction(MolarMassUnit.GramPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.HectogramPerMole, (q) => ((MolarMass)q).ToUnit(MolarMassUnit.HectogramPerMole)); - unitConverter.SetConversionFunction(MolarMassUnit.HectogramPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMass.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.KilopoundPerMole, (q) => ((MolarMass)q).ToUnit(MolarMassUnit.KilopoundPerMole)); - unitConverter.SetConversionFunction(MolarMassUnit.KilopoundPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.MegapoundPerMole, (q) => ((MolarMass)q).ToUnit(MolarMassUnit.MegapoundPerMole)); - unitConverter.SetConversionFunction(MolarMassUnit.MegapoundPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.MicrogramPerMole, (q) => ((MolarMass)q).ToUnit(MolarMassUnit.MicrogramPerMole)); - unitConverter.SetConversionFunction(MolarMassUnit.MicrogramPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.MilligramPerMole, (q) => ((MolarMass)q).ToUnit(MolarMassUnit.MilligramPerMole)); - unitConverter.SetConversionFunction(MolarMassUnit.MilligramPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.NanogramPerMole, (q) => ((MolarMass)q).ToUnit(MolarMassUnit.NanogramPerMole)); - unitConverter.SetConversionFunction(MolarMassUnit.NanogramPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).ToBaseUnit()); - unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.PoundPerMole, (q) => ((MolarMass)q).ToUnit(MolarMassUnit.PoundPerMole)); - unitConverter.SetConversionFunction(MolarMassUnit.PoundPerMole, MolarMass.BaseUnit, (q) => ((MolarMass)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Permeability.BaseUnit, Permeability.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Permittivity.BaseUnit, Permittivity.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.BoilerHorsepower, (q) => ((Power)q).ToUnit(PowerUnit.BoilerHorsepower)); - unitConverter.SetConversionFunction(PowerUnit.BoilerHorsepower, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.BritishThermalUnitPerHour, (q) => ((Power)q).ToUnit(PowerUnit.BritishThermalUnitPerHour)); - unitConverter.SetConversionFunction(PowerUnit.BritishThermalUnitPerHour, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Decawatt, (q) => ((Power)q).ToUnit(PowerUnit.Decawatt)); - unitConverter.SetConversionFunction(PowerUnit.Decawatt, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Deciwatt, (q) => ((Power)q).ToUnit(PowerUnit.Deciwatt)); - unitConverter.SetConversionFunction(PowerUnit.Deciwatt, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.ElectricalHorsepower, (q) => ((Power)q).ToUnit(PowerUnit.ElectricalHorsepower)); - unitConverter.SetConversionFunction(PowerUnit.ElectricalHorsepower, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Femtowatt, (q) => ((Power)q).ToUnit(PowerUnit.Femtowatt)); - unitConverter.SetConversionFunction(PowerUnit.Femtowatt, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Gigawatt, (q) => ((Power)q).ToUnit(PowerUnit.Gigawatt)); - unitConverter.SetConversionFunction(PowerUnit.Gigawatt, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.HydraulicHorsepower, (q) => ((Power)q).ToUnit(PowerUnit.HydraulicHorsepower)); - unitConverter.SetConversionFunction(PowerUnit.HydraulicHorsepower, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.KilobritishThermalUnitPerHour, (q) => ((Power)q).ToUnit(PowerUnit.KilobritishThermalUnitPerHour)); - unitConverter.SetConversionFunction(PowerUnit.KilobritishThermalUnitPerHour, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Kilowatt, (q) => ((Power)q).ToUnit(PowerUnit.Kilowatt)); - unitConverter.SetConversionFunction(PowerUnit.Kilowatt, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.MechanicalHorsepower, (q) => ((Power)q).ToUnit(PowerUnit.MechanicalHorsepower)); - unitConverter.SetConversionFunction(PowerUnit.MechanicalHorsepower, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Megawatt, (q) => ((Power)q).ToUnit(PowerUnit.Megawatt)); - unitConverter.SetConversionFunction(PowerUnit.Megawatt, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.MetricHorsepower, (q) => ((Power)q).ToUnit(PowerUnit.MetricHorsepower)); - unitConverter.SetConversionFunction(PowerUnit.MetricHorsepower, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Microwatt, (q) => ((Power)q).ToUnit(PowerUnit.Microwatt)); - unitConverter.SetConversionFunction(PowerUnit.Microwatt, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Milliwatt, (q) => ((Power)q).ToUnit(PowerUnit.Milliwatt)); - unitConverter.SetConversionFunction(PowerUnit.Milliwatt, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Nanowatt, (q) => ((Power)q).ToUnit(PowerUnit.Nanowatt)); - unitConverter.SetConversionFunction(PowerUnit.Nanowatt, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Petawatt, (q) => ((Power)q).ToUnit(PowerUnit.Petawatt)); - unitConverter.SetConversionFunction(PowerUnit.Petawatt, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Picowatt, (q) => ((Power)q).ToUnit(PowerUnit.Picowatt)); - unitConverter.SetConversionFunction(PowerUnit.Picowatt, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Terawatt, (q) => ((Power)q).ToUnit(PowerUnit.Terawatt)); - unitConverter.SetConversionFunction(PowerUnit.Terawatt, Power.BaseUnit, (q) => ((Power)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Power.BaseUnit, Power.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.DecawattPerCubicFoot, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.DecawattPerCubicFoot)); - unitConverter.SetConversionFunction(PowerDensityUnit.DecawattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.DecawattPerCubicInch, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.DecawattPerCubicInch)); - unitConverter.SetConversionFunction(PowerDensityUnit.DecawattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.DecawattPerCubicMeter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.DecawattPerCubicMeter)); - unitConverter.SetConversionFunction(PowerDensityUnit.DecawattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.DecawattPerLiter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.DecawattPerLiter)); - unitConverter.SetConversionFunction(PowerDensityUnit.DecawattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.DeciwattPerCubicFoot, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.DeciwattPerCubicFoot)); - unitConverter.SetConversionFunction(PowerDensityUnit.DeciwattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.DeciwattPerCubicInch, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.DeciwattPerCubicInch)); - unitConverter.SetConversionFunction(PowerDensityUnit.DeciwattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.DeciwattPerCubicMeter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.DeciwattPerCubicMeter)); - unitConverter.SetConversionFunction(PowerDensityUnit.DeciwattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.DeciwattPerLiter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.DeciwattPerLiter)); - unitConverter.SetConversionFunction(PowerDensityUnit.DeciwattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.GigawattPerCubicFoot, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.GigawattPerCubicFoot)); - unitConverter.SetConversionFunction(PowerDensityUnit.GigawattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.GigawattPerCubicInch, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.GigawattPerCubicInch)); - unitConverter.SetConversionFunction(PowerDensityUnit.GigawattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.GigawattPerCubicMeter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.GigawattPerCubicMeter)); - unitConverter.SetConversionFunction(PowerDensityUnit.GigawattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.GigawattPerLiter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.GigawattPerLiter)); - unitConverter.SetConversionFunction(PowerDensityUnit.GigawattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.KilowattPerCubicFoot, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.KilowattPerCubicFoot)); - unitConverter.SetConversionFunction(PowerDensityUnit.KilowattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.KilowattPerCubicInch, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.KilowattPerCubicInch)); - unitConverter.SetConversionFunction(PowerDensityUnit.KilowattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.KilowattPerCubicMeter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.KilowattPerCubicMeter)); - unitConverter.SetConversionFunction(PowerDensityUnit.KilowattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.KilowattPerLiter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.KilowattPerLiter)); - unitConverter.SetConversionFunction(PowerDensityUnit.KilowattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MegawattPerCubicFoot, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MegawattPerCubicFoot)); - unitConverter.SetConversionFunction(PowerDensityUnit.MegawattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MegawattPerCubicInch, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MegawattPerCubicInch)); - unitConverter.SetConversionFunction(PowerDensityUnit.MegawattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MegawattPerCubicMeter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MegawattPerCubicMeter)); - unitConverter.SetConversionFunction(PowerDensityUnit.MegawattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MegawattPerLiter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MegawattPerLiter)); - unitConverter.SetConversionFunction(PowerDensityUnit.MegawattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MicrowattPerCubicFoot, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MicrowattPerCubicFoot)); - unitConverter.SetConversionFunction(PowerDensityUnit.MicrowattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MicrowattPerCubicInch, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MicrowattPerCubicInch)); - unitConverter.SetConversionFunction(PowerDensityUnit.MicrowattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MicrowattPerCubicMeter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MicrowattPerCubicMeter)); - unitConverter.SetConversionFunction(PowerDensityUnit.MicrowattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MicrowattPerLiter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MicrowattPerLiter)); - unitConverter.SetConversionFunction(PowerDensityUnit.MicrowattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MilliwattPerCubicFoot, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MilliwattPerCubicFoot)); - unitConverter.SetConversionFunction(PowerDensityUnit.MilliwattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MilliwattPerCubicInch, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MilliwattPerCubicInch)); - unitConverter.SetConversionFunction(PowerDensityUnit.MilliwattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MilliwattPerCubicMeter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MilliwattPerCubicMeter)); - unitConverter.SetConversionFunction(PowerDensityUnit.MilliwattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MilliwattPerLiter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.MilliwattPerLiter)); - unitConverter.SetConversionFunction(PowerDensityUnit.MilliwattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.NanowattPerCubicFoot, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.NanowattPerCubicFoot)); - unitConverter.SetConversionFunction(PowerDensityUnit.NanowattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.NanowattPerCubicInch, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.NanowattPerCubicInch)); - unitConverter.SetConversionFunction(PowerDensityUnit.NanowattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.NanowattPerCubicMeter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.NanowattPerCubicMeter)); - unitConverter.SetConversionFunction(PowerDensityUnit.NanowattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.NanowattPerLiter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.NanowattPerLiter)); - unitConverter.SetConversionFunction(PowerDensityUnit.NanowattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.PicowattPerCubicFoot, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.PicowattPerCubicFoot)); - unitConverter.SetConversionFunction(PowerDensityUnit.PicowattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.PicowattPerCubicInch, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.PicowattPerCubicInch)); - unitConverter.SetConversionFunction(PowerDensityUnit.PicowattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.PicowattPerCubicMeter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.PicowattPerCubicMeter)); - unitConverter.SetConversionFunction(PowerDensityUnit.PicowattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.PicowattPerLiter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.PicowattPerLiter)); - unitConverter.SetConversionFunction(PowerDensityUnit.PicowattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.TerawattPerCubicFoot, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.TerawattPerCubicFoot)); - unitConverter.SetConversionFunction(PowerDensityUnit.TerawattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.TerawattPerCubicInch, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.TerawattPerCubicInch)); - unitConverter.SetConversionFunction(PowerDensityUnit.TerawattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.TerawattPerCubicMeter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.TerawattPerCubicMeter)); - unitConverter.SetConversionFunction(PowerDensityUnit.TerawattPerCubicMeter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.TerawattPerLiter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.TerawattPerLiter)); - unitConverter.SetConversionFunction(PowerDensityUnit.TerawattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.WattPerCubicFoot, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.WattPerCubicFoot)); - unitConverter.SetConversionFunction(PowerDensityUnit.WattPerCubicFoot, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.WattPerCubicInch, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.WattPerCubicInch)); - unitConverter.SetConversionFunction(PowerDensityUnit.WattPerCubicInch, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensity.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.WattPerLiter, (q) => ((PowerDensity)q).ToUnit(PowerDensityUnit.WattPerLiter)); - unitConverter.SetConversionFunction(PowerDensityUnit.WattPerLiter, PowerDensity.BaseUnit, (q) => ((PowerDensity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerRatio.BaseUnit, PowerRatioUnit.DecibelMilliwatt, (q) => ((PowerRatio)q).ToUnit(PowerRatioUnit.DecibelMilliwatt)); - unitConverter.SetConversionFunction(PowerRatioUnit.DecibelMilliwatt, PowerRatio.BaseUnit, (q) => ((PowerRatio)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PowerRatio.BaseUnit, PowerRatio.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Atmosphere, (q) => ((Pressure)q).ToUnit(PressureUnit.Atmosphere)); - unitConverter.SetConversionFunction(PressureUnit.Atmosphere, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Bar, (q) => ((Pressure)q).ToUnit(PressureUnit.Bar)); - unitConverter.SetConversionFunction(PressureUnit.Bar, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Centibar, (q) => ((Pressure)q).ToUnit(PressureUnit.Centibar)); - unitConverter.SetConversionFunction(PressureUnit.Centibar, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Decapascal, (q) => ((Pressure)q).ToUnit(PressureUnit.Decapascal)); - unitConverter.SetConversionFunction(PressureUnit.Decapascal, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Decibar, (q) => ((Pressure)q).ToUnit(PressureUnit.Decibar)); - unitConverter.SetConversionFunction(PressureUnit.Decibar, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.DynePerSquareCentimeter, (q) => ((Pressure)q).ToUnit(PressureUnit.DynePerSquareCentimeter)); - unitConverter.SetConversionFunction(PressureUnit.DynePerSquareCentimeter, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.FootOfHead, (q) => ((Pressure)q).ToUnit(PressureUnit.FootOfHead)); - unitConverter.SetConversionFunction(PressureUnit.FootOfHead, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Gigapascal, (q) => ((Pressure)q).ToUnit(PressureUnit.Gigapascal)); - unitConverter.SetConversionFunction(PressureUnit.Gigapascal, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Hectopascal, (q) => ((Pressure)q).ToUnit(PressureUnit.Hectopascal)); - unitConverter.SetConversionFunction(PressureUnit.Hectopascal, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.InchOfMercury, (q) => ((Pressure)q).ToUnit(PressureUnit.InchOfMercury)); - unitConverter.SetConversionFunction(PressureUnit.InchOfMercury, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.InchOfWaterColumn, (q) => ((Pressure)q).ToUnit(PressureUnit.InchOfWaterColumn)); - unitConverter.SetConversionFunction(PressureUnit.InchOfWaterColumn, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Kilobar, (q) => ((Pressure)q).ToUnit(PressureUnit.Kilobar)); - unitConverter.SetConversionFunction(PressureUnit.Kilobar, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.KilogramForcePerSquareCentimeter, (q) => ((Pressure)q).ToUnit(PressureUnit.KilogramForcePerSquareCentimeter)); - unitConverter.SetConversionFunction(PressureUnit.KilogramForcePerSquareCentimeter, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.KilogramForcePerSquareMeter, (q) => ((Pressure)q).ToUnit(PressureUnit.KilogramForcePerSquareMeter)); - unitConverter.SetConversionFunction(PressureUnit.KilogramForcePerSquareMeter, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.KilogramForcePerSquareMillimeter, (q) => ((Pressure)q).ToUnit(PressureUnit.KilogramForcePerSquareMillimeter)); - unitConverter.SetConversionFunction(PressureUnit.KilogramForcePerSquareMillimeter, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.KilonewtonPerSquareCentimeter, (q) => ((Pressure)q).ToUnit(PressureUnit.KilonewtonPerSquareCentimeter)); - unitConverter.SetConversionFunction(PressureUnit.KilonewtonPerSquareCentimeter, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.KilonewtonPerSquareMeter, (q) => ((Pressure)q).ToUnit(PressureUnit.KilonewtonPerSquareMeter)); - unitConverter.SetConversionFunction(PressureUnit.KilonewtonPerSquareMeter, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.KilonewtonPerSquareMillimeter, (q) => ((Pressure)q).ToUnit(PressureUnit.KilonewtonPerSquareMillimeter)); - unitConverter.SetConversionFunction(PressureUnit.KilonewtonPerSquareMillimeter, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Kilopascal, (q) => ((Pressure)q).ToUnit(PressureUnit.Kilopascal)); - unitConverter.SetConversionFunction(PressureUnit.Kilopascal, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.KilopoundForcePerSquareFoot, (q) => ((Pressure)q).ToUnit(PressureUnit.KilopoundForcePerSquareFoot)); - unitConverter.SetConversionFunction(PressureUnit.KilopoundForcePerSquareFoot, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.KilopoundForcePerSquareInch, (q) => ((Pressure)q).ToUnit(PressureUnit.KilopoundForcePerSquareInch)); - unitConverter.SetConversionFunction(PressureUnit.KilopoundForcePerSquareInch, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Megabar, (q) => ((Pressure)q).ToUnit(PressureUnit.Megabar)); - unitConverter.SetConversionFunction(PressureUnit.Megabar, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.MeganewtonPerSquareMeter, (q) => ((Pressure)q).ToUnit(PressureUnit.MeganewtonPerSquareMeter)); - unitConverter.SetConversionFunction(PressureUnit.MeganewtonPerSquareMeter, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Megapascal, (q) => ((Pressure)q).ToUnit(PressureUnit.Megapascal)); - unitConverter.SetConversionFunction(PressureUnit.Megapascal, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.MeterOfHead, (q) => ((Pressure)q).ToUnit(PressureUnit.MeterOfHead)); - unitConverter.SetConversionFunction(PressureUnit.MeterOfHead, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Microbar, (q) => ((Pressure)q).ToUnit(PressureUnit.Microbar)); - unitConverter.SetConversionFunction(PressureUnit.Microbar, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Micropascal, (q) => ((Pressure)q).ToUnit(PressureUnit.Micropascal)); - unitConverter.SetConversionFunction(PressureUnit.Micropascal, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Millibar, (q) => ((Pressure)q).ToUnit(PressureUnit.Millibar)); - unitConverter.SetConversionFunction(PressureUnit.Millibar, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.MillimeterOfMercury, (q) => ((Pressure)q).ToUnit(PressureUnit.MillimeterOfMercury)); - unitConverter.SetConversionFunction(PressureUnit.MillimeterOfMercury, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Millipascal, (q) => ((Pressure)q).ToUnit(PressureUnit.Millipascal)); - unitConverter.SetConversionFunction(PressureUnit.Millipascal, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.NewtonPerSquareCentimeter, (q) => ((Pressure)q).ToUnit(PressureUnit.NewtonPerSquareCentimeter)); - unitConverter.SetConversionFunction(PressureUnit.NewtonPerSquareCentimeter, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.NewtonPerSquareMeter, (q) => ((Pressure)q).ToUnit(PressureUnit.NewtonPerSquareMeter)); - unitConverter.SetConversionFunction(PressureUnit.NewtonPerSquareMeter, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.NewtonPerSquareMillimeter, (q) => ((Pressure)q).ToUnit(PressureUnit.NewtonPerSquareMillimeter)); - unitConverter.SetConversionFunction(PressureUnit.NewtonPerSquareMillimeter, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, Pressure.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.PoundForcePerSquareFoot, (q) => ((Pressure)q).ToUnit(PressureUnit.PoundForcePerSquareFoot)); - unitConverter.SetConversionFunction(PressureUnit.PoundForcePerSquareFoot, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.PoundForcePerSquareInch, (q) => ((Pressure)q).ToUnit(PressureUnit.PoundForcePerSquareInch)); - unitConverter.SetConversionFunction(PressureUnit.PoundForcePerSquareInch, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.PoundPerInchSecondSquared, (q) => ((Pressure)q).ToUnit(PressureUnit.PoundPerInchSecondSquared)); - unitConverter.SetConversionFunction(PressureUnit.PoundPerInchSecondSquared, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.TechnicalAtmosphere, (q) => ((Pressure)q).ToUnit(PressureUnit.TechnicalAtmosphere)); - unitConverter.SetConversionFunction(PressureUnit.TechnicalAtmosphere, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.TonneForcePerSquareCentimeter, (q) => ((Pressure)q).ToUnit(PressureUnit.TonneForcePerSquareCentimeter)); - unitConverter.SetConversionFunction(PressureUnit.TonneForcePerSquareCentimeter, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.TonneForcePerSquareMeter, (q) => ((Pressure)q).ToUnit(PressureUnit.TonneForcePerSquareMeter)); - unitConverter.SetConversionFunction(PressureUnit.TonneForcePerSquareMeter, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.TonneForcePerSquareMillimeter, (q) => ((Pressure)q).ToUnit(PressureUnit.TonneForcePerSquareMillimeter)); - unitConverter.SetConversionFunction(PressureUnit.TonneForcePerSquareMillimeter, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Torr, (q) => ((Pressure)q).ToUnit(PressureUnit.Torr)); - unitConverter.SetConversionFunction(PressureUnit.Torr, Pressure.BaseUnit, (q) => ((Pressure)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.AtmospherePerSecond, (q) => ((PressureChangeRate)q).ToUnit(PressureChangeRateUnit.AtmospherePerSecond)); - unitConverter.SetConversionFunction(PressureChangeRateUnit.AtmospherePerSecond, PressureChangeRate.BaseUnit, (q) => ((PressureChangeRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.KilopascalPerMinute, (q) => ((PressureChangeRate)q).ToUnit(PressureChangeRateUnit.KilopascalPerMinute)); - unitConverter.SetConversionFunction(PressureChangeRateUnit.KilopascalPerMinute, PressureChangeRate.BaseUnit, (q) => ((PressureChangeRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.KilopascalPerSecond, (q) => ((PressureChangeRate)q).ToUnit(PressureChangeRateUnit.KilopascalPerSecond)); - unitConverter.SetConversionFunction(PressureChangeRateUnit.KilopascalPerSecond, PressureChangeRate.BaseUnit, (q) => ((PressureChangeRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.MegapascalPerMinute, (q) => ((PressureChangeRate)q).ToUnit(PressureChangeRateUnit.MegapascalPerMinute)); - unitConverter.SetConversionFunction(PressureChangeRateUnit.MegapascalPerMinute, PressureChangeRate.BaseUnit, (q) => ((PressureChangeRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.MegapascalPerSecond, (q) => ((PressureChangeRate)q).ToUnit(PressureChangeRateUnit.MegapascalPerSecond)); - unitConverter.SetConversionFunction(PressureChangeRateUnit.MegapascalPerSecond, PressureChangeRate.BaseUnit, (q) => ((PressureChangeRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.PascalPerMinute, (q) => ((PressureChangeRate)q).ToUnit(PressureChangeRateUnit.PascalPerMinute)); - unitConverter.SetConversionFunction(PressureChangeRateUnit.PascalPerMinute, PressureChangeRate.BaseUnit, (q) => ((PressureChangeRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRate.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Ratio.BaseUnit, Ratio.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Ratio.BaseUnit, RatioUnit.PartPerBillion, (q) => ((Ratio)q).ToUnit(RatioUnit.PartPerBillion)); - unitConverter.SetConversionFunction(RatioUnit.PartPerBillion, Ratio.BaseUnit, (q) => ((Ratio)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Ratio.BaseUnit, RatioUnit.PartPerMillion, (q) => ((Ratio)q).ToUnit(RatioUnit.PartPerMillion)); - unitConverter.SetConversionFunction(RatioUnit.PartPerMillion, Ratio.BaseUnit, (q) => ((Ratio)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Ratio.BaseUnit, RatioUnit.PartPerThousand, (q) => ((Ratio)q).ToUnit(RatioUnit.PartPerThousand)); - unitConverter.SetConversionFunction(RatioUnit.PartPerThousand, Ratio.BaseUnit, (q) => ((Ratio)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Ratio.BaseUnit, RatioUnit.PartPerTrillion, (q) => ((Ratio)q).ToUnit(RatioUnit.PartPerTrillion)); - unitConverter.SetConversionFunction(RatioUnit.PartPerTrillion, Ratio.BaseUnit, (q) => ((Ratio)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Ratio.BaseUnit, RatioUnit.Percent, (q) => ((Ratio)q).ToUnit(RatioUnit.Percent)); - unitConverter.SetConversionFunction(RatioUnit.Percent, Ratio.BaseUnit, (q) => ((Ratio)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ReactiveEnergy.BaseUnit, ReactiveEnergyUnit.KilovoltampereReactiveHour, (q) => ((ReactiveEnergy)q).ToUnit(ReactiveEnergyUnit.KilovoltampereReactiveHour)); - unitConverter.SetConversionFunction(ReactiveEnergyUnit.KilovoltampereReactiveHour, ReactiveEnergy.BaseUnit, (q) => ((ReactiveEnergy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ReactiveEnergy.BaseUnit, ReactiveEnergyUnit.MegavoltampereReactiveHour, (q) => ((ReactiveEnergy)q).ToUnit(ReactiveEnergyUnit.MegavoltampereReactiveHour)); - unitConverter.SetConversionFunction(ReactiveEnergyUnit.MegavoltampereReactiveHour, ReactiveEnergy.BaseUnit, (q) => ((ReactiveEnergy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ReactiveEnergy.BaseUnit, ReactiveEnergy.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(ReactivePower.BaseUnit, ReactivePowerUnit.GigavoltampereReactive, (q) => ((ReactivePower)q).ToUnit(ReactivePowerUnit.GigavoltampereReactive)); - unitConverter.SetConversionFunction(ReactivePowerUnit.GigavoltampereReactive, ReactivePower.BaseUnit, (q) => ((ReactivePower)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ReactivePower.BaseUnit, ReactivePowerUnit.KilovoltampereReactive, (q) => ((ReactivePower)q).ToUnit(ReactivePowerUnit.KilovoltampereReactive)); - unitConverter.SetConversionFunction(ReactivePowerUnit.KilovoltampereReactive, ReactivePower.BaseUnit, (q) => ((ReactivePower)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ReactivePower.BaseUnit, ReactivePowerUnit.MegavoltampereReactive, (q) => ((ReactivePower)q).ToUnit(ReactivePowerUnit.MegavoltampereReactive)); - unitConverter.SetConversionFunction(ReactivePowerUnit.MegavoltampereReactive, ReactivePower.BaseUnit, (q) => ((ReactivePower)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ReactivePower.BaseUnit, ReactivePower.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(RotationalAcceleration.BaseUnit, RotationalAccelerationUnit.DegreePerSecondSquared, (q) => ((RotationalAcceleration)q).ToUnit(RotationalAccelerationUnit.DegreePerSecondSquared)); - unitConverter.SetConversionFunction(RotationalAccelerationUnit.DegreePerSecondSquared, RotationalAcceleration.BaseUnit, (q) => ((RotationalAcceleration)q).ToBaseUnit()); - unitConverter.SetConversionFunction(RotationalAcceleration.BaseUnit, RotationalAcceleration.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(RotationalAcceleration.BaseUnit, RotationalAccelerationUnit.RevolutionPerMinutePerSecond, (q) => ((RotationalAcceleration)q).ToUnit(RotationalAccelerationUnit.RevolutionPerMinutePerSecond)); - unitConverter.SetConversionFunction(RotationalAccelerationUnit.RevolutionPerMinutePerSecond, RotationalAcceleration.BaseUnit, (q) => ((RotationalAcceleration)q).ToBaseUnit()); - unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.CentiradianPerSecond, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.CentiradianPerSecond)); - unitConverter.SetConversionFunction(RotationalSpeedUnit.CentiradianPerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.DeciradianPerSecond, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.DeciradianPerSecond)); - unitConverter.SetConversionFunction(RotationalSpeedUnit.DeciradianPerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.DegreePerMinute, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.DegreePerMinute)); - unitConverter.SetConversionFunction(RotationalSpeedUnit.DegreePerMinute, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.DegreePerSecond, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.DegreePerSecond)); - unitConverter.SetConversionFunction(RotationalSpeedUnit.DegreePerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.MicrodegreePerSecond, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.MicrodegreePerSecond)); - unitConverter.SetConversionFunction(RotationalSpeedUnit.MicrodegreePerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.MicroradianPerSecond, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.MicroradianPerSecond)); - unitConverter.SetConversionFunction(RotationalSpeedUnit.MicroradianPerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.MillidegreePerSecond, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.MillidegreePerSecond)); - unitConverter.SetConversionFunction(RotationalSpeedUnit.MillidegreePerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.MilliradianPerSecond, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.MilliradianPerSecond)); - unitConverter.SetConversionFunction(RotationalSpeedUnit.MilliradianPerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.NanodegreePerSecond, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.NanodegreePerSecond)); - unitConverter.SetConversionFunction(RotationalSpeedUnit.NanodegreePerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.NanoradianPerSecond, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.NanoradianPerSecond)); - unitConverter.SetConversionFunction(RotationalSpeedUnit.NanoradianPerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeed.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.RevolutionPerMinute, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.RevolutionPerMinute)); - unitConverter.SetConversionFunction(RotationalSpeedUnit.RevolutionPerMinute, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.RevolutionPerSecond, (q) => ((RotationalSpeed)q).ToUnit(RotationalSpeedUnit.RevolutionPerSecond)); - unitConverter.SetConversionFunction(RotationalSpeedUnit.RevolutionPerSecond, RotationalSpeed.BaseUnit, (q) => ((RotationalSpeed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.KilonewtonMeterPerRadian, (q) => ((RotationalStiffness)q).ToUnit(RotationalStiffnessUnit.KilonewtonMeterPerRadian)); - unitConverter.SetConversionFunction(RotationalStiffnessUnit.KilonewtonMeterPerRadian, RotationalStiffness.BaseUnit, (q) => ((RotationalStiffness)q).ToBaseUnit()); - unitConverter.SetConversionFunction(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.MeganewtonMeterPerRadian, (q) => ((RotationalStiffness)q).ToUnit(RotationalStiffnessUnit.MeganewtonMeterPerRadian)); - unitConverter.SetConversionFunction(RotationalStiffnessUnit.MeganewtonMeterPerRadian, RotationalStiffness.BaseUnit, (q) => ((RotationalStiffness)q).ToBaseUnit()); - unitConverter.SetConversionFunction(RotationalStiffness.BaseUnit, RotationalStiffness.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(RotationalStiffnessPerLength.BaseUnit, RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter, (q) => ((RotationalStiffnessPerLength)q).ToUnit(RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter)); - unitConverter.SetConversionFunction(RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter, RotationalStiffnessPerLength.BaseUnit, (q) => ((RotationalStiffnessPerLength)q).ToBaseUnit()); - unitConverter.SetConversionFunction(RotationalStiffnessPerLength.BaseUnit, RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter, (q) => ((RotationalStiffnessPerLength)q).ToUnit(RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter)); - unitConverter.SetConversionFunction(RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter, RotationalStiffnessPerLength.BaseUnit, (q) => ((RotationalStiffnessPerLength)q).ToBaseUnit()); - unitConverter.SetConversionFunction(RotationalStiffnessPerLength.BaseUnit, RotationalStiffnessPerLength.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(SolidAngle.BaseUnit, SolidAngle.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergyUnit.BtuPerPound, (q) => ((SpecificEnergy)q).ToUnit(SpecificEnergyUnit.BtuPerPound)); - unitConverter.SetConversionFunction(SpecificEnergyUnit.BtuPerPound, SpecificEnergy.BaseUnit, (q) => ((SpecificEnergy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergyUnit.CaloriePerGram, (q) => ((SpecificEnergy)q).ToUnit(SpecificEnergyUnit.CaloriePerGram)); - unitConverter.SetConversionFunction(SpecificEnergyUnit.CaloriePerGram, SpecificEnergy.BaseUnit, (q) => ((SpecificEnergy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergy.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergyUnit.KilocaloriePerGram, (q) => ((SpecificEnergy)q).ToUnit(SpecificEnergyUnit.KilocaloriePerGram)); - unitConverter.SetConversionFunction(SpecificEnergyUnit.KilocaloriePerGram, SpecificEnergy.BaseUnit, (q) => ((SpecificEnergy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergyUnit.KilojoulePerKilogram, (q) => ((SpecificEnergy)q).ToUnit(SpecificEnergyUnit.KilojoulePerKilogram)); - unitConverter.SetConversionFunction(SpecificEnergyUnit.KilojoulePerKilogram, SpecificEnergy.BaseUnit, (q) => ((SpecificEnergy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergyUnit.KilowattHourPerKilogram, (q) => ((SpecificEnergy)q).ToUnit(SpecificEnergyUnit.KilowattHourPerKilogram)); - unitConverter.SetConversionFunction(SpecificEnergyUnit.KilowattHourPerKilogram, SpecificEnergy.BaseUnit, (q) => ((SpecificEnergy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergyUnit.MegajoulePerKilogram, (q) => ((SpecificEnergy)q).ToUnit(SpecificEnergyUnit.MegajoulePerKilogram)); - unitConverter.SetConversionFunction(SpecificEnergyUnit.MegajoulePerKilogram, SpecificEnergy.BaseUnit, (q) => ((SpecificEnergy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergyUnit.MegawattHourPerKilogram, (q) => ((SpecificEnergy)q).ToUnit(SpecificEnergyUnit.MegawattHourPerKilogram)); - unitConverter.SetConversionFunction(SpecificEnergyUnit.MegawattHourPerKilogram, SpecificEnergy.BaseUnit, (q) => ((SpecificEnergy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergyUnit.WattHourPerKilogram, (q) => ((SpecificEnergy)q).ToUnit(SpecificEnergyUnit.WattHourPerKilogram)); - unitConverter.SetConversionFunction(SpecificEnergyUnit.WattHourPerKilogram, SpecificEnergy.BaseUnit, (q) => ((SpecificEnergy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(SpecificEntropy.BaseUnit, SpecificEntropyUnit.CaloriePerGramKelvin, (q) => ((SpecificEntropy)q).ToUnit(SpecificEntropyUnit.CaloriePerGramKelvin)); - unitConverter.SetConversionFunction(SpecificEntropyUnit.CaloriePerGramKelvin, SpecificEntropy.BaseUnit, (q) => ((SpecificEntropy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(SpecificEntropy.BaseUnit, SpecificEntropyUnit.JoulePerKilogramDegreeCelsius, (q) => ((SpecificEntropy)q).ToUnit(SpecificEntropyUnit.JoulePerKilogramDegreeCelsius)); - unitConverter.SetConversionFunction(SpecificEntropyUnit.JoulePerKilogramDegreeCelsius, SpecificEntropy.BaseUnit, (q) => ((SpecificEntropy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(SpecificEntropy.BaseUnit, SpecificEntropy.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(SpecificEntropy.BaseUnit, SpecificEntropyUnit.KilocaloriePerGramKelvin, (q) => ((SpecificEntropy)q).ToUnit(SpecificEntropyUnit.KilocaloriePerGramKelvin)); - unitConverter.SetConversionFunction(SpecificEntropyUnit.KilocaloriePerGramKelvin, SpecificEntropy.BaseUnit, (q) => ((SpecificEntropy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(SpecificEntropy.BaseUnit, SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius, (q) => ((SpecificEntropy)q).ToUnit(SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius)); - unitConverter.SetConversionFunction(SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius, SpecificEntropy.BaseUnit, (q) => ((SpecificEntropy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(SpecificEntropy.BaseUnit, SpecificEntropyUnit.KilojoulePerKilogramKelvin, (q) => ((SpecificEntropy)q).ToUnit(SpecificEntropyUnit.KilojoulePerKilogramKelvin)); - unitConverter.SetConversionFunction(SpecificEntropyUnit.KilojoulePerKilogramKelvin, SpecificEntropy.BaseUnit, (q) => ((SpecificEntropy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(SpecificEntropy.BaseUnit, SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius, (q) => ((SpecificEntropy)q).ToUnit(SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius)); - unitConverter.SetConversionFunction(SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius, SpecificEntropy.BaseUnit, (q) => ((SpecificEntropy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(SpecificEntropy.BaseUnit, SpecificEntropyUnit.MegajoulePerKilogramKelvin, (q) => ((SpecificEntropy)q).ToUnit(SpecificEntropyUnit.MegajoulePerKilogramKelvin)); - unitConverter.SetConversionFunction(SpecificEntropyUnit.MegajoulePerKilogramKelvin, SpecificEntropy.BaseUnit, (q) => ((SpecificEntropy)q).ToBaseUnit()); - unitConverter.SetConversionFunction(SpecificVolume.BaseUnit, SpecificVolumeUnit.CubicFootPerPound, (q) => ((SpecificVolume)q).ToUnit(SpecificVolumeUnit.CubicFootPerPound)); - unitConverter.SetConversionFunction(SpecificVolumeUnit.CubicFootPerPound, SpecificVolume.BaseUnit, (q) => ((SpecificVolume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(SpecificVolume.BaseUnit, SpecificVolume.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(SpecificVolume.BaseUnit, SpecificVolumeUnit.MillicubicMeterPerKilogram, (q) => ((SpecificVolume)q).ToUnit(SpecificVolumeUnit.MillicubicMeterPerKilogram)); - unitConverter.SetConversionFunction(SpecificVolumeUnit.MillicubicMeterPerKilogram, SpecificVolume.BaseUnit, (q) => ((SpecificVolume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.KilogramForcePerCubicCentimeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.KilogramForcePerCubicCentimeter)); - unitConverter.SetConversionFunction(SpecificWeightUnit.KilogramForcePerCubicCentimeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).ToBaseUnit()); - unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.KilogramForcePerCubicMeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.KilogramForcePerCubicMeter)); - unitConverter.SetConversionFunction(SpecificWeightUnit.KilogramForcePerCubicMeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).ToBaseUnit()); - unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.KilogramForcePerCubicMillimeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.KilogramForcePerCubicMillimeter)); - unitConverter.SetConversionFunction(SpecificWeightUnit.KilogramForcePerCubicMillimeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).ToBaseUnit()); - unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.KilonewtonPerCubicCentimeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.KilonewtonPerCubicCentimeter)); - unitConverter.SetConversionFunction(SpecificWeightUnit.KilonewtonPerCubicCentimeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).ToBaseUnit()); - unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.KilonewtonPerCubicMeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.KilonewtonPerCubicMeter)); - unitConverter.SetConversionFunction(SpecificWeightUnit.KilonewtonPerCubicMeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).ToBaseUnit()); - unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.KilonewtonPerCubicMillimeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.KilonewtonPerCubicMillimeter)); - unitConverter.SetConversionFunction(SpecificWeightUnit.KilonewtonPerCubicMillimeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).ToBaseUnit()); - unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.KilopoundForcePerCubicFoot, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.KilopoundForcePerCubicFoot)); - unitConverter.SetConversionFunction(SpecificWeightUnit.KilopoundForcePerCubicFoot, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).ToBaseUnit()); - unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.KilopoundForcePerCubicInch, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.KilopoundForcePerCubicInch)); - unitConverter.SetConversionFunction(SpecificWeightUnit.KilopoundForcePerCubicInch, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).ToBaseUnit()); - unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.MeganewtonPerCubicMeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.MeganewtonPerCubicMeter)); - unitConverter.SetConversionFunction(SpecificWeightUnit.MeganewtonPerCubicMeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).ToBaseUnit()); - unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.NewtonPerCubicCentimeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.NewtonPerCubicCentimeter)); - unitConverter.SetConversionFunction(SpecificWeightUnit.NewtonPerCubicCentimeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).ToBaseUnit()); - unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeight.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.NewtonPerCubicMillimeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.NewtonPerCubicMillimeter)); - unitConverter.SetConversionFunction(SpecificWeightUnit.NewtonPerCubicMillimeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).ToBaseUnit()); - unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.PoundForcePerCubicFoot, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.PoundForcePerCubicFoot)); - unitConverter.SetConversionFunction(SpecificWeightUnit.PoundForcePerCubicFoot, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).ToBaseUnit()); - unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.PoundForcePerCubicInch, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.PoundForcePerCubicInch)); - unitConverter.SetConversionFunction(SpecificWeightUnit.PoundForcePerCubicInch, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).ToBaseUnit()); - unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.TonneForcePerCubicCentimeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.TonneForcePerCubicCentimeter)); - unitConverter.SetConversionFunction(SpecificWeightUnit.TonneForcePerCubicCentimeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).ToBaseUnit()); - unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.TonneForcePerCubicMeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.TonneForcePerCubicMeter)); - unitConverter.SetConversionFunction(SpecificWeightUnit.TonneForcePerCubicMeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).ToBaseUnit()); - unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.TonneForcePerCubicMillimeter, (q) => ((SpecificWeight)q).ToUnit(SpecificWeightUnit.TonneForcePerCubicMillimeter)); - unitConverter.SetConversionFunction(SpecificWeightUnit.TonneForcePerCubicMillimeter, SpecificWeight.BaseUnit, (q) => ((SpecificWeight)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.CentimeterPerHour, (q) => ((Speed)q).ToUnit(SpeedUnit.CentimeterPerHour)); - unitConverter.SetConversionFunction(SpeedUnit.CentimeterPerHour, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.CentimeterPerMinute, (q) => ((Speed)q).ToUnit(SpeedUnit.CentimeterPerMinute)); - unitConverter.SetConversionFunction(SpeedUnit.CentimeterPerMinute, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.CentimeterPerSecond, (q) => ((Speed)q).ToUnit(SpeedUnit.CentimeterPerSecond)); - unitConverter.SetConversionFunction(SpeedUnit.CentimeterPerSecond, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.DecimeterPerMinute, (q) => ((Speed)q).ToUnit(SpeedUnit.DecimeterPerMinute)); - unitConverter.SetConversionFunction(SpeedUnit.DecimeterPerMinute, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.DecimeterPerSecond, (q) => ((Speed)q).ToUnit(SpeedUnit.DecimeterPerSecond)); - unitConverter.SetConversionFunction(SpeedUnit.DecimeterPerSecond, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.FootPerHour, (q) => ((Speed)q).ToUnit(SpeedUnit.FootPerHour)); - unitConverter.SetConversionFunction(SpeedUnit.FootPerHour, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.FootPerMinute, (q) => ((Speed)q).ToUnit(SpeedUnit.FootPerMinute)); - unitConverter.SetConversionFunction(SpeedUnit.FootPerMinute, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.FootPerSecond, (q) => ((Speed)q).ToUnit(SpeedUnit.FootPerSecond)); - unitConverter.SetConversionFunction(SpeedUnit.FootPerSecond, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.InchPerHour, (q) => ((Speed)q).ToUnit(SpeedUnit.InchPerHour)); - unitConverter.SetConversionFunction(SpeedUnit.InchPerHour, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.InchPerMinute, (q) => ((Speed)q).ToUnit(SpeedUnit.InchPerMinute)); - unitConverter.SetConversionFunction(SpeedUnit.InchPerMinute, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.InchPerSecond, (q) => ((Speed)q).ToUnit(SpeedUnit.InchPerSecond)); - unitConverter.SetConversionFunction(SpeedUnit.InchPerSecond, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.KilometerPerHour, (q) => ((Speed)q).ToUnit(SpeedUnit.KilometerPerHour)); - unitConverter.SetConversionFunction(SpeedUnit.KilometerPerHour, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.KilometerPerMinute, (q) => ((Speed)q).ToUnit(SpeedUnit.KilometerPerMinute)); - unitConverter.SetConversionFunction(SpeedUnit.KilometerPerMinute, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.KilometerPerSecond, (q) => ((Speed)q).ToUnit(SpeedUnit.KilometerPerSecond)); - unitConverter.SetConversionFunction(SpeedUnit.KilometerPerSecond, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.Knot, (q) => ((Speed)q).ToUnit(SpeedUnit.Knot)); - unitConverter.SetConversionFunction(SpeedUnit.Knot, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.MeterPerHour, (q) => ((Speed)q).ToUnit(SpeedUnit.MeterPerHour)); - unitConverter.SetConversionFunction(SpeedUnit.MeterPerHour, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.MeterPerMinute, (q) => ((Speed)q).ToUnit(SpeedUnit.MeterPerMinute)); - unitConverter.SetConversionFunction(SpeedUnit.MeterPerMinute, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Speed.BaseUnit, Speed.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.MicrometerPerMinute, (q) => ((Speed)q).ToUnit(SpeedUnit.MicrometerPerMinute)); - unitConverter.SetConversionFunction(SpeedUnit.MicrometerPerMinute, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.MicrometerPerSecond, (q) => ((Speed)q).ToUnit(SpeedUnit.MicrometerPerSecond)); - unitConverter.SetConversionFunction(SpeedUnit.MicrometerPerSecond, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.MilePerHour, (q) => ((Speed)q).ToUnit(SpeedUnit.MilePerHour)); - unitConverter.SetConversionFunction(SpeedUnit.MilePerHour, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.MillimeterPerHour, (q) => ((Speed)q).ToUnit(SpeedUnit.MillimeterPerHour)); - unitConverter.SetConversionFunction(SpeedUnit.MillimeterPerHour, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.MillimeterPerMinute, (q) => ((Speed)q).ToUnit(SpeedUnit.MillimeterPerMinute)); - unitConverter.SetConversionFunction(SpeedUnit.MillimeterPerMinute, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.MillimeterPerSecond, (q) => ((Speed)q).ToUnit(SpeedUnit.MillimeterPerSecond)); - unitConverter.SetConversionFunction(SpeedUnit.MillimeterPerSecond, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.NanometerPerMinute, (q) => ((Speed)q).ToUnit(SpeedUnit.NanometerPerMinute)); - unitConverter.SetConversionFunction(SpeedUnit.NanometerPerMinute, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.NanometerPerSecond, (q) => ((Speed)q).ToUnit(SpeedUnit.NanometerPerSecond)); - unitConverter.SetConversionFunction(SpeedUnit.NanometerPerSecond, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.UsSurveyFootPerHour, (q) => ((Speed)q).ToUnit(SpeedUnit.UsSurveyFootPerHour)); - unitConverter.SetConversionFunction(SpeedUnit.UsSurveyFootPerHour, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.UsSurveyFootPerMinute, (q) => ((Speed)q).ToUnit(SpeedUnit.UsSurveyFootPerMinute)); - unitConverter.SetConversionFunction(SpeedUnit.UsSurveyFootPerMinute, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.UsSurveyFootPerSecond, (q) => ((Speed)q).ToUnit(SpeedUnit.UsSurveyFootPerSecond)); - unitConverter.SetConversionFunction(SpeedUnit.UsSurveyFootPerSecond, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.YardPerHour, (q) => ((Speed)q).ToUnit(SpeedUnit.YardPerHour)); - unitConverter.SetConversionFunction(SpeedUnit.YardPerHour, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.YardPerMinute, (q) => ((Speed)q).ToUnit(SpeedUnit.YardPerMinute)); - unitConverter.SetConversionFunction(SpeedUnit.YardPerMinute, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.YardPerSecond, (q) => ((Speed)q).ToUnit(SpeedUnit.YardPerSecond)); - unitConverter.SetConversionFunction(SpeedUnit.YardPerSecond, Speed.BaseUnit, (q) => ((Speed)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Temperature.BaseUnit, TemperatureUnit.DegreeCelsius, (q) => ((Temperature)q).ToUnit(TemperatureUnit.DegreeCelsius)); - unitConverter.SetConversionFunction(TemperatureUnit.DegreeCelsius, Temperature.BaseUnit, (q) => ((Temperature)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Temperature.BaseUnit, TemperatureUnit.DegreeDelisle, (q) => ((Temperature)q).ToUnit(TemperatureUnit.DegreeDelisle)); - unitConverter.SetConversionFunction(TemperatureUnit.DegreeDelisle, Temperature.BaseUnit, (q) => ((Temperature)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Temperature.BaseUnit, TemperatureUnit.DegreeFahrenheit, (q) => ((Temperature)q).ToUnit(TemperatureUnit.DegreeFahrenheit)); - unitConverter.SetConversionFunction(TemperatureUnit.DegreeFahrenheit, Temperature.BaseUnit, (q) => ((Temperature)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Temperature.BaseUnit, TemperatureUnit.DegreeNewton, (q) => ((Temperature)q).ToUnit(TemperatureUnit.DegreeNewton)); - unitConverter.SetConversionFunction(TemperatureUnit.DegreeNewton, Temperature.BaseUnit, (q) => ((Temperature)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Temperature.BaseUnit, TemperatureUnit.DegreeRankine, (q) => ((Temperature)q).ToUnit(TemperatureUnit.DegreeRankine)); - unitConverter.SetConversionFunction(TemperatureUnit.DegreeRankine, Temperature.BaseUnit, (q) => ((Temperature)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Temperature.BaseUnit, TemperatureUnit.DegreeReaumur, (q) => ((Temperature)q).ToUnit(TemperatureUnit.DegreeReaumur)); - unitConverter.SetConversionFunction(TemperatureUnit.DegreeReaumur, Temperature.BaseUnit, (q) => ((Temperature)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Temperature.BaseUnit, TemperatureUnit.DegreeRoemer, (q) => ((Temperature)q).ToUnit(TemperatureUnit.DegreeRoemer)); - unitConverter.SetConversionFunction(TemperatureUnit.DegreeRoemer, Temperature.BaseUnit, (q) => ((Temperature)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Temperature.BaseUnit, Temperature.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond, (q) => ((TemperatureChangeRate)q).ToUnit(TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond)); - unitConverter.SetConversionFunction(TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond, (q) => ((TemperatureChangeRate)q).ToUnit(TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond)); - unitConverter.SetConversionFunction(TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond, (q) => ((TemperatureChangeRate)q).ToUnit(TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond)); - unitConverter.SetConversionFunction(TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.DegreeCelsiusPerMinute, (q) => ((TemperatureChangeRate)q).ToUnit(TemperatureChangeRateUnit.DegreeCelsiusPerMinute)); - unitConverter.SetConversionFunction(TemperatureChangeRateUnit.DegreeCelsiusPerMinute, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRate.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond, (q) => ((TemperatureChangeRate)q).ToUnit(TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond)); - unitConverter.SetConversionFunction(TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond, (q) => ((TemperatureChangeRate)q).ToUnit(TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond)); - unitConverter.SetConversionFunction(TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond, (q) => ((TemperatureChangeRate)q).ToUnit(TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond)); - unitConverter.SetConversionFunction(TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond, (q) => ((TemperatureChangeRate)q).ToUnit(TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond)); - unitConverter.SetConversionFunction(TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond, (q) => ((TemperatureChangeRate)q).ToUnit(TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond)); - unitConverter.SetConversionFunction(TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, (q) => ((TemperatureChangeRate)q).ToBaseUnit()); - unitConverter.SetConversionFunction(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeCelsius, (q) => ((TemperatureDelta)q).ToUnit(TemperatureDeltaUnit.DegreeCelsius)); - unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeCelsius, TemperatureDelta.BaseUnit, (q) => ((TemperatureDelta)q).ToBaseUnit()); - unitConverter.SetConversionFunction(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeDelisle, (q) => ((TemperatureDelta)q).ToUnit(TemperatureDeltaUnit.DegreeDelisle)); - unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeDelisle, TemperatureDelta.BaseUnit, (q) => ((TemperatureDelta)q).ToBaseUnit()); - unitConverter.SetConversionFunction(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeFahrenheit, (q) => ((TemperatureDelta)q).ToUnit(TemperatureDeltaUnit.DegreeFahrenheit)); - unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeFahrenheit, TemperatureDelta.BaseUnit, (q) => ((TemperatureDelta)q).ToBaseUnit()); - unitConverter.SetConversionFunction(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeNewton, (q) => ((TemperatureDelta)q).ToUnit(TemperatureDeltaUnit.DegreeNewton)); - unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeNewton, TemperatureDelta.BaseUnit, (q) => ((TemperatureDelta)q).ToBaseUnit()); - unitConverter.SetConversionFunction(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeRankine, (q) => ((TemperatureDelta)q).ToUnit(TemperatureDeltaUnit.DegreeRankine)); - unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeRankine, TemperatureDelta.BaseUnit, (q) => ((TemperatureDelta)q).ToBaseUnit()); - unitConverter.SetConversionFunction(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeReaumur, (q) => ((TemperatureDelta)q).ToUnit(TemperatureDeltaUnit.DegreeReaumur)); - unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeReaumur, TemperatureDelta.BaseUnit, (q) => ((TemperatureDelta)q).ToBaseUnit()); - unitConverter.SetConversionFunction(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeRoemer, (q) => ((TemperatureDelta)q).ToUnit(TemperatureDeltaUnit.DegreeRoemer)); - unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeRoemer, TemperatureDelta.BaseUnit, (q) => ((TemperatureDelta)q).ToBaseUnit()); - unitConverter.SetConversionFunction(TemperatureDelta.BaseUnit, TemperatureDelta.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(ThermalConductivity.BaseUnit, ThermalConductivityUnit.BtuPerHourFootFahrenheit, (q) => ((ThermalConductivity)q).ToUnit(ThermalConductivityUnit.BtuPerHourFootFahrenheit)); - unitConverter.SetConversionFunction(ThermalConductivityUnit.BtuPerHourFootFahrenheit, ThermalConductivity.BaseUnit, (q) => ((ThermalConductivity)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ThermalConductivity.BaseUnit, ThermalConductivity.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(ThermalResistance.BaseUnit, ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu, (q) => ((ThermalResistance)q).ToUnit(ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu)); - unitConverter.SetConversionFunction(ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu, ThermalResistance.BaseUnit, (q) => ((ThermalResistance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ThermalResistance.BaseUnit, ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie, (q) => ((ThermalResistance)q).ToUnit(ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie)); - unitConverter.SetConversionFunction(ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie, ThermalResistance.BaseUnit, (q) => ((ThermalResistance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ThermalResistance.BaseUnit, ThermalResistanceUnit.SquareCentimeterKelvinPerWatt, (q) => ((ThermalResistance)q).ToUnit(ThermalResistanceUnit.SquareCentimeterKelvinPerWatt)); - unitConverter.SetConversionFunction(ThermalResistanceUnit.SquareCentimeterKelvinPerWatt, ThermalResistance.BaseUnit, (q) => ((ThermalResistance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ThermalResistance.BaseUnit, ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt, (q) => ((ThermalResistance)q).ToUnit(ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt)); - unitConverter.SetConversionFunction(ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt, ThermalResistance.BaseUnit, (q) => ((ThermalResistance)q).ToBaseUnit()); - unitConverter.SetConversionFunction(ThermalResistance.BaseUnit, ThermalResistance.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.KilogramForceCentimeter, (q) => ((Torque)q).ToUnit(TorqueUnit.KilogramForceCentimeter)); - unitConverter.SetConversionFunction(TorqueUnit.KilogramForceCentimeter, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.KilogramForceMeter, (q) => ((Torque)q).ToUnit(TorqueUnit.KilogramForceMeter)); - unitConverter.SetConversionFunction(TorqueUnit.KilogramForceMeter, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.KilogramForceMillimeter, (q) => ((Torque)q).ToUnit(TorqueUnit.KilogramForceMillimeter)); - unitConverter.SetConversionFunction(TorqueUnit.KilogramForceMillimeter, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.KilonewtonCentimeter, (q) => ((Torque)q).ToUnit(TorqueUnit.KilonewtonCentimeter)); - unitConverter.SetConversionFunction(TorqueUnit.KilonewtonCentimeter, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.KilonewtonMeter, (q) => ((Torque)q).ToUnit(TorqueUnit.KilonewtonMeter)); - unitConverter.SetConversionFunction(TorqueUnit.KilonewtonMeter, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.KilonewtonMillimeter, (q) => ((Torque)q).ToUnit(TorqueUnit.KilonewtonMillimeter)); - unitConverter.SetConversionFunction(TorqueUnit.KilonewtonMillimeter, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.KilopoundForceFoot, (q) => ((Torque)q).ToUnit(TorqueUnit.KilopoundForceFoot)); - unitConverter.SetConversionFunction(TorqueUnit.KilopoundForceFoot, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.KilopoundForceInch, (q) => ((Torque)q).ToUnit(TorqueUnit.KilopoundForceInch)); - unitConverter.SetConversionFunction(TorqueUnit.KilopoundForceInch, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.MeganewtonCentimeter, (q) => ((Torque)q).ToUnit(TorqueUnit.MeganewtonCentimeter)); - unitConverter.SetConversionFunction(TorqueUnit.MeganewtonCentimeter, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.MeganewtonMeter, (q) => ((Torque)q).ToUnit(TorqueUnit.MeganewtonMeter)); - unitConverter.SetConversionFunction(TorqueUnit.MeganewtonMeter, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.MeganewtonMillimeter, (q) => ((Torque)q).ToUnit(TorqueUnit.MeganewtonMillimeter)); - unitConverter.SetConversionFunction(TorqueUnit.MeganewtonMillimeter, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.MegapoundForceFoot, (q) => ((Torque)q).ToUnit(TorqueUnit.MegapoundForceFoot)); - unitConverter.SetConversionFunction(TorqueUnit.MegapoundForceFoot, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.MegapoundForceInch, (q) => ((Torque)q).ToUnit(TorqueUnit.MegapoundForceInch)); - unitConverter.SetConversionFunction(TorqueUnit.MegapoundForceInch, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.NewtonCentimeter, (q) => ((Torque)q).ToUnit(TorqueUnit.NewtonCentimeter)); - unitConverter.SetConversionFunction(TorqueUnit.NewtonCentimeter, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Torque.BaseUnit, Torque.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.NewtonMillimeter, (q) => ((Torque)q).ToUnit(TorqueUnit.NewtonMillimeter)); - unitConverter.SetConversionFunction(TorqueUnit.NewtonMillimeter, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.PoundForceFoot, (q) => ((Torque)q).ToUnit(TorqueUnit.PoundForceFoot)); - unitConverter.SetConversionFunction(TorqueUnit.PoundForceFoot, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.PoundForceInch, (q) => ((Torque)q).ToUnit(TorqueUnit.PoundForceInch)); - unitConverter.SetConversionFunction(TorqueUnit.PoundForceInch, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.TonneForceCentimeter, (q) => ((Torque)q).ToUnit(TorqueUnit.TonneForceCentimeter)); - unitConverter.SetConversionFunction(TorqueUnit.TonneForceCentimeter, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.TonneForceMeter, (q) => ((Torque)q).ToUnit(TorqueUnit.TonneForceMeter)); - unitConverter.SetConversionFunction(TorqueUnit.TonneForceMeter, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.TonneForceMillimeter, (q) => ((Torque)q).ToUnit(TorqueUnit.TonneForceMillimeter)); - unitConverter.SetConversionFunction(TorqueUnit.TonneForceMillimeter, Torque.BaseUnit, (q) => ((Torque)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VitaminA.BaseUnit, VitaminA.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.AcreFoot, (q) => ((Volume)q).ToUnit(VolumeUnit.AcreFoot)); - unitConverter.SetConversionFunction(VolumeUnit.AcreFoot, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.AuTablespoon, (q) => ((Volume)q).ToUnit(VolumeUnit.AuTablespoon)); - unitConverter.SetConversionFunction(VolumeUnit.AuTablespoon, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.Centiliter, (q) => ((Volume)q).ToUnit(VolumeUnit.Centiliter)); - unitConverter.SetConversionFunction(VolumeUnit.Centiliter, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicCentimeter, (q) => ((Volume)q).ToUnit(VolumeUnit.CubicCentimeter)); - unitConverter.SetConversionFunction(VolumeUnit.CubicCentimeter, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicDecimeter, (q) => ((Volume)q).ToUnit(VolumeUnit.CubicDecimeter)); - unitConverter.SetConversionFunction(VolumeUnit.CubicDecimeter, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicFoot, (q) => ((Volume)q).ToUnit(VolumeUnit.CubicFoot)); - unitConverter.SetConversionFunction(VolumeUnit.CubicFoot, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicInch, (q) => ((Volume)q).ToUnit(VolumeUnit.CubicInch)); - unitConverter.SetConversionFunction(VolumeUnit.CubicInch, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicKilometer, (q) => ((Volume)q).ToUnit(VolumeUnit.CubicKilometer)); - unitConverter.SetConversionFunction(VolumeUnit.CubicKilometer, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, Volume.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicMicrometer, (q) => ((Volume)q).ToUnit(VolumeUnit.CubicMicrometer)); - unitConverter.SetConversionFunction(VolumeUnit.CubicMicrometer, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicMile, (q) => ((Volume)q).ToUnit(VolumeUnit.CubicMile)); - unitConverter.SetConversionFunction(VolumeUnit.CubicMile, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicMillimeter, (q) => ((Volume)q).ToUnit(VolumeUnit.CubicMillimeter)); - unitConverter.SetConversionFunction(VolumeUnit.CubicMillimeter, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicYard, (q) => ((Volume)q).ToUnit(VolumeUnit.CubicYard)); - unitConverter.SetConversionFunction(VolumeUnit.CubicYard, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.Deciliter, (q) => ((Volume)q).ToUnit(VolumeUnit.Deciliter)); - unitConverter.SetConversionFunction(VolumeUnit.Deciliter, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.HectocubicFoot, (q) => ((Volume)q).ToUnit(VolumeUnit.HectocubicFoot)); - unitConverter.SetConversionFunction(VolumeUnit.HectocubicFoot, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.HectocubicMeter, (q) => ((Volume)q).ToUnit(VolumeUnit.HectocubicMeter)); - unitConverter.SetConversionFunction(VolumeUnit.HectocubicMeter, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.Hectoliter, (q) => ((Volume)q).ToUnit(VolumeUnit.Hectoliter)); - unitConverter.SetConversionFunction(VolumeUnit.Hectoliter, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.ImperialBeerBarrel, (q) => ((Volume)q).ToUnit(VolumeUnit.ImperialBeerBarrel)); - unitConverter.SetConversionFunction(VolumeUnit.ImperialBeerBarrel, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.ImperialGallon, (q) => ((Volume)q).ToUnit(VolumeUnit.ImperialGallon)); - unitConverter.SetConversionFunction(VolumeUnit.ImperialGallon, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.ImperialOunce, (q) => ((Volume)q).ToUnit(VolumeUnit.ImperialOunce)); - unitConverter.SetConversionFunction(VolumeUnit.ImperialOunce, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.KilocubicFoot, (q) => ((Volume)q).ToUnit(VolumeUnit.KilocubicFoot)); - unitConverter.SetConversionFunction(VolumeUnit.KilocubicFoot, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.KilocubicMeter, (q) => ((Volume)q).ToUnit(VolumeUnit.KilocubicMeter)); - unitConverter.SetConversionFunction(VolumeUnit.KilocubicMeter, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.KiloimperialGallon, (q) => ((Volume)q).ToUnit(VolumeUnit.KiloimperialGallon)); - unitConverter.SetConversionFunction(VolumeUnit.KiloimperialGallon, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.Kiloliter, (q) => ((Volume)q).ToUnit(VolumeUnit.Kiloliter)); - unitConverter.SetConversionFunction(VolumeUnit.Kiloliter, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.KilousGallon, (q) => ((Volume)q).ToUnit(VolumeUnit.KilousGallon)); - unitConverter.SetConversionFunction(VolumeUnit.KilousGallon, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.Liter, (q) => ((Volume)q).ToUnit(VolumeUnit.Liter)); - unitConverter.SetConversionFunction(VolumeUnit.Liter, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.MegacubicFoot, (q) => ((Volume)q).ToUnit(VolumeUnit.MegacubicFoot)); - unitConverter.SetConversionFunction(VolumeUnit.MegacubicFoot, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.MegaimperialGallon, (q) => ((Volume)q).ToUnit(VolumeUnit.MegaimperialGallon)); - unitConverter.SetConversionFunction(VolumeUnit.MegaimperialGallon, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.Megaliter, (q) => ((Volume)q).ToUnit(VolumeUnit.Megaliter)); - unitConverter.SetConversionFunction(VolumeUnit.Megaliter, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.MegausGallon, (q) => ((Volume)q).ToUnit(VolumeUnit.MegausGallon)); - unitConverter.SetConversionFunction(VolumeUnit.MegausGallon, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.MetricCup, (q) => ((Volume)q).ToUnit(VolumeUnit.MetricCup)); - unitConverter.SetConversionFunction(VolumeUnit.MetricCup, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.MetricTeaspoon, (q) => ((Volume)q).ToUnit(VolumeUnit.MetricTeaspoon)); - unitConverter.SetConversionFunction(VolumeUnit.MetricTeaspoon, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.Microliter, (q) => ((Volume)q).ToUnit(VolumeUnit.Microliter)); - unitConverter.SetConversionFunction(VolumeUnit.Microliter, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.Milliliter, (q) => ((Volume)q).ToUnit(VolumeUnit.Milliliter)); - unitConverter.SetConversionFunction(VolumeUnit.Milliliter, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.OilBarrel, (q) => ((Volume)q).ToUnit(VolumeUnit.OilBarrel)); - unitConverter.SetConversionFunction(VolumeUnit.OilBarrel, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UkTablespoon, (q) => ((Volume)q).ToUnit(VolumeUnit.UkTablespoon)); - unitConverter.SetConversionFunction(VolumeUnit.UkTablespoon, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsBeerBarrel, (q) => ((Volume)q).ToUnit(VolumeUnit.UsBeerBarrel)); - unitConverter.SetConversionFunction(VolumeUnit.UsBeerBarrel, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsCustomaryCup, (q) => ((Volume)q).ToUnit(VolumeUnit.UsCustomaryCup)); - unitConverter.SetConversionFunction(VolumeUnit.UsCustomaryCup, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsGallon, (q) => ((Volume)q).ToUnit(VolumeUnit.UsGallon)); - unitConverter.SetConversionFunction(VolumeUnit.UsGallon, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsLegalCup, (q) => ((Volume)q).ToUnit(VolumeUnit.UsLegalCup)); - unitConverter.SetConversionFunction(VolumeUnit.UsLegalCup, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsOunce, (q) => ((Volume)q).ToUnit(VolumeUnit.UsOunce)); - unitConverter.SetConversionFunction(VolumeUnit.UsOunce, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsPint, (q) => ((Volume)q).ToUnit(VolumeUnit.UsPint)); - unitConverter.SetConversionFunction(VolumeUnit.UsPint, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsQuart, (q) => ((Volume)q).ToUnit(VolumeUnit.UsQuart)); - unitConverter.SetConversionFunction(VolumeUnit.UsQuart, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsTablespoon, (q) => ((Volume)q).ToUnit(VolumeUnit.UsTablespoon)); - unitConverter.SetConversionFunction(VolumeUnit.UsTablespoon, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsTeaspoon, (q) => ((Volume)q).ToUnit(VolumeUnit.UsTeaspoon)); - unitConverter.SetConversionFunction(VolumeUnit.UsTeaspoon, Volume.BaseUnit, (q) => ((Volume)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.AcreFootPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.AcreFootPerDay)); - unitConverter.SetConversionFunction(VolumeFlowUnit.AcreFootPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.AcreFootPerHour, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.AcreFootPerHour)); - unitConverter.SetConversionFunction(VolumeFlowUnit.AcreFootPerHour, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.AcreFootPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.AcreFootPerMinute)); - unitConverter.SetConversionFunction(VolumeFlowUnit.AcreFootPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.AcreFootPerSecond, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.AcreFootPerSecond)); - unitConverter.SetConversionFunction(VolumeFlowUnit.AcreFootPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CentiliterPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CentiliterPerDay)); - unitConverter.SetConversionFunction(VolumeFlowUnit.CentiliterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CentiliterPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CentiliterPerMinute)); - unitConverter.SetConversionFunction(VolumeFlowUnit.CentiliterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicDecimeterPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicDecimeterPerMinute)); - unitConverter.SetConversionFunction(VolumeFlowUnit.CubicDecimeterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicFootPerHour, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicFootPerHour)); - unitConverter.SetConversionFunction(VolumeFlowUnit.CubicFootPerHour, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicFootPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicFootPerMinute)); - unitConverter.SetConversionFunction(VolumeFlowUnit.CubicFootPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicFootPerSecond, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicFootPerSecond)); - unitConverter.SetConversionFunction(VolumeFlowUnit.CubicFootPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicMeterPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicMeterPerDay)); - unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMeterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicMeterPerHour, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicMeterPerHour)); - unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMeterPerHour, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicMeterPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicMeterPerMinute)); - unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMeterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlow.BaseUnit, (q) => q); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicMillimeterPerSecond, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicMillimeterPerSecond)); - unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMillimeterPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicYardPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicYardPerDay)); - unitConverter.SetConversionFunction(VolumeFlowUnit.CubicYardPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicYardPerHour, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicYardPerHour)); - unitConverter.SetConversionFunction(VolumeFlowUnit.CubicYardPerHour, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicYardPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicYardPerMinute)); - unitConverter.SetConversionFunction(VolumeFlowUnit.CubicYardPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicYardPerSecond, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.CubicYardPerSecond)); - unitConverter.SetConversionFunction(VolumeFlowUnit.CubicYardPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.DeciliterPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.DeciliterPerDay)); - unitConverter.SetConversionFunction(VolumeFlowUnit.DeciliterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.DeciliterPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.DeciliterPerMinute)); - unitConverter.SetConversionFunction(VolumeFlowUnit.DeciliterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.KiloliterPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.KiloliterPerDay)); - unitConverter.SetConversionFunction(VolumeFlowUnit.KiloliterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.KiloliterPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.KiloliterPerMinute)); - unitConverter.SetConversionFunction(VolumeFlowUnit.KiloliterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.KilousGallonPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.KilousGallonPerMinute)); - unitConverter.SetConversionFunction(VolumeFlowUnit.KilousGallonPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.LiterPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.LiterPerDay)); - unitConverter.SetConversionFunction(VolumeFlowUnit.LiterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.LiterPerHour, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.LiterPerHour)); - unitConverter.SetConversionFunction(VolumeFlowUnit.LiterPerHour, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.LiterPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.LiterPerMinute)); - unitConverter.SetConversionFunction(VolumeFlowUnit.LiterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.LiterPerSecond, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.LiterPerSecond)); - unitConverter.SetConversionFunction(VolumeFlowUnit.LiterPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.MegaliterPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.MegaliterPerDay)); - unitConverter.SetConversionFunction(VolumeFlowUnit.MegaliterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.MegaukGallonPerSecond, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.MegaukGallonPerSecond)); - unitConverter.SetConversionFunction(VolumeFlowUnit.MegaukGallonPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.MicroliterPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.MicroliterPerDay)); - unitConverter.SetConversionFunction(VolumeFlowUnit.MicroliterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.MicroliterPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.MicroliterPerMinute)); - unitConverter.SetConversionFunction(VolumeFlowUnit.MicroliterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.MilliliterPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.MilliliterPerDay)); - unitConverter.SetConversionFunction(VolumeFlowUnit.MilliliterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.MilliliterPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.MilliliterPerMinute)); - unitConverter.SetConversionFunction(VolumeFlowUnit.MilliliterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.MillionUsGallonsPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.MillionUsGallonsPerDay)); - unitConverter.SetConversionFunction(VolumeFlowUnit.MillionUsGallonsPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.NanoliterPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.NanoliterPerDay)); - unitConverter.SetConversionFunction(VolumeFlowUnit.NanoliterPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.NanoliterPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.NanoliterPerMinute)); - unitConverter.SetConversionFunction(VolumeFlowUnit.NanoliterPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.OilBarrelPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.OilBarrelPerDay)); - unitConverter.SetConversionFunction(VolumeFlowUnit.OilBarrelPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.OilBarrelPerHour, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.OilBarrelPerHour)); - unitConverter.SetConversionFunction(VolumeFlowUnit.OilBarrelPerHour, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.OilBarrelPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.OilBarrelPerMinute)); - unitConverter.SetConversionFunction(VolumeFlowUnit.OilBarrelPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.OilBarrelPerSecond, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.OilBarrelPerSecond)); - unitConverter.SetConversionFunction(VolumeFlowUnit.OilBarrelPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.UkGallonPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.UkGallonPerDay)); - unitConverter.SetConversionFunction(VolumeFlowUnit.UkGallonPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.UkGallonPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.UkGallonPerMinute)); - unitConverter.SetConversionFunction(VolumeFlowUnit.UkGallonPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.UkGallonPerSecond, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.UkGallonPerSecond)); - unitConverter.SetConversionFunction(VolumeFlowUnit.UkGallonPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.UsGallonPerDay, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.UsGallonPerDay)); - unitConverter.SetConversionFunction(VolumeFlowUnit.UsGallonPerDay, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.UsGallonPerHour, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.UsGallonPerHour)); - unitConverter.SetConversionFunction(VolumeFlowUnit.UsGallonPerHour, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.UsGallonPerMinute, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.UsGallonPerMinute)); - unitConverter.SetConversionFunction(VolumeFlowUnit.UsGallonPerMinute, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); - unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.UsGallonPerSecond, (q) => ((VolumeFlow)q).ToUnit(VolumeFlowUnit.UsGallonPerSecond)); - unitConverter.SetConversionFunction(VolumeFlowUnit.UsGallonPerSecond, VolumeFlow.BaseUnit, (q) => ((VolumeFlow)q).ToBaseUnit()); + unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.CentimeterPerSecondSquared, q => q.ToUnit(AccelerationUnit.CentimeterPerSecondSquared)); + unitConverter.SetConversionFunction(AccelerationUnit.CentimeterPerSecondSquared, Acceleration.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.DecimeterPerSecondSquared, q => q.ToUnit(AccelerationUnit.DecimeterPerSecondSquared)); + unitConverter.SetConversionFunction(AccelerationUnit.DecimeterPerSecondSquared, Acceleration.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.FootPerSecondSquared, q => q.ToUnit(AccelerationUnit.FootPerSecondSquared)); + unitConverter.SetConversionFunction(AccelerationUnit.FootPerSecondSquared, Acceleration.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.InchPerSecondSquared, q => q.ToUnit(AccelerationUnit.InchPerSecondSquared)); + unitConverter.SetConversionFunction(AccelerationUnit.InchPerSecondSquared, Acceleration.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.KilometerPerSecondSquared, q => q.ToUnit(AccelerationUnit.KilometerPerSecondSquared)); + unitConverter.SetConversionFunction(AccelerationUnit.KilometerPerSecondSquared, Acceleration.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.KnotPerHour, q => q.ToUnit(AccelerationUnit.KnotPerHour)); + unitConverter.SetConversionFunction(AccelerationUnit.KnotPerHour, Acceleration.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.KnotPerMinute, q => q.ToUnit(AccelerationUnit.KnotPerMinute)); + unitConverter.SetConversionFunction(AccelerationUnit.KnotPerMinute, Acceleration.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.KnotPerSecond, q => q.ToUnit(AccelerationUnit.KnotPerSecond)); + unitConverter.SetConversionFunction(AccelerationUnit.KnotPerSecond, Acceleration.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Acceleration.BaseUnit, Acceleration.BaseUnit, q => q); + unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.MicrometerPerSecondSquared, q => q.ToUnit(AccelerationUnit.MicrometerPerSecondSquared)); + unitConverter.SetConversionFunction(AccelerationUnit.MicrometerPerSecondSquared, Acceleration.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.MillimeterPerSecondSquared, q => q.ToUnit(AccelerationUnit.MillimeterPerSecondSquared)); + unitConverter.SetConversionFunction(AccelerationUnit.MillimeterPerSecondSquared, Acceleration.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.NanometerPerSecondSquared, q => q.ToUnit(AccelerationUnit.NanometerPerSecondSquared)); + unitConverter.SetConversionFunction(AccelerationUnit.NanometerPerSecondSquared, Acceleration.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Acceleration.BaseUnit, AccelerationUnit.StandardGravity, q => q.ToUnit(AccelerationUnit.StandardGravity)); + unitConverter.SetConversionFunction(AccelerationUnit.StandardGravity, Acceleration.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Centimole, q => q.ToUnit(AmountOfSubstanceUnit.Centimole)); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Centimole, AmountOfSubstance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.CentipoundMole, q => q.ToUnit(AmountOfSubstanceUnit.CentipoundMole)); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.CentipoundMole, AmountOfSubstance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Decimole, q => q.ToUnit(AmountOfSubstanceUnit.Decimole)); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Decimole, AmountOfSubstance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.DecipoundMole, q => q.ToUnit(AmountOfSubstanceUnit.DecipoundMole)); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.DecipoundMole, AmountOfSubstance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Kilomole, q => q.ToUnit(AmountOfSubstanceUnit.Kilomole)); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Kilomole, AmountOfSubstance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.KilopoundMole, q => q.ToUnit(AmountOfSubstanceUnit.KilopoundMole)); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.KilopoundMole, AmountOfSubstance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Megamole, q => q.ToUnit(AmountOfSubstanceUnit.Megamole)); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Megamole, AmountOfSubstance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Micromole, q => q.ToUnit(AmountOfSubstanceUnit.Micromole)); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Micromole, AmountOfSubstance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.MicropoundMole, q => q.ToUnit(AmountOfSubstanceUnit.MicropoundMole)); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.MicropoundMole, AmountOfSubstance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Millimole, q => q.ToUnit(AmountOfSubstanceUnit.Millimole)); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Millimole, AmountOfSubstance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.MillipoundMole, q => q.ToUnit(AmountOfSubstanceUnit.MillipoundMole)); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.MillipoundMole, AmountOfSubstance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstance.BaseUnit, q => q); + unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.Nanomole, q => q.ToUnit(AmountOfSubstanceUnit.Nanomole)); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.Nanomole, AmountOfSubstance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.NanopoundMole, q => q.ToUnit(AmountOfSubstanceUnit.NanopoundMole)); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.NanopoundMole, AmountOfSubstance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(AmountOfSubstance.BaseUnit, AmountOfSubstanceUnit.PoundMole, q => q.ToUnit(AmountOfSubstanceUnit.PoundMole)); + unitConverter.SetConversionFunction(AmountOfSubstanceUnit.PoundMole, AmountOfSubstance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(AmplitudeRatio.BaseUnit, AmplitudeRatioUnit.DecibelMicrovolt, q => q.ToUnit(AmplitudeRatioUnit.DecibelMicrovolt)); + unitConverter.SetConversionFunction(AmplitudeRatioUnit.DecibelMicrovolt, AmplitudeRatio.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(AmplitudeRatio.BaseUnit, AmplitudeRatioUnit.DecibelMillivolt, q => q.ToUnit(AmplitudeRatioUnit.DecibelMillivolt)); + unitConverter.SetConversionFunction(AmplitudeRatioUnit.DecibelMillivolt, AmplitudeRatio.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(AmplitudeRatio.BaseUnit, AmplitudeRatioUnit.DecibelUnloaded, q => q.ToUnit(AmplitudeRatioUnit.DecibelUnloaded)); + unitConverter.SetConversionFunction(AmplitudeRatioUnit.DecibelUnloaded, AmplitudeRatio.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(AmplitudeRatio.BaseUnit, AmplitudeRatio.BaseUnit, q => q); + unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Arcminute, q => q.ToUnit(AngleUnit.Arcminute)); + unitConverter.SetConversionFunction(AngleUnit.Arcminute, Angle.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Arcsecond, q => q.ToUnit(AngleUnit.Arcsecond)); + unitConverter.SetConversionFunction(AngleUnit.Arcsecond, Angle.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Centiradian, q => q.ToUnit(AngleUnit.Centiradian)); + unitConverter.SetConversionFunction(AngleUnit.Centiradian, Angle.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Deciradian, q => q.ToUnit(AngleUnit.Deciradian)); + unitConverter.SetConversionFunction(AngleUnit.Deciradian, Angle.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Angle.BaseUnit, Angle.BaseUnit, q => q); + unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Gradian, q => q.ToUnit(AngleUnit.Gradian)); + unitConverter.SetConversionFunction(AngleUnit.Gradian, Angle.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Microdegree, q => q.ToUnit(AngleUnit.Microdegree)); + unitConverter.SetConversionFunction(AngleUnit.Microdegree, Angle.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Microradian, q => q.ToUnit(AngleUnit.Microradian)); + unitConverter.SetConversionFunction(AngleUnit.Microradian, Angle.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Millidegree, q => q.ToUnit(AngleUnit.Millidegree)); + unitConverter.SetConversionFunction(AngleUnit.Millidegree, Angle.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Milliradian, q => q.ToUnit(AngleUnit.Milliradian)); + unitConverter.SetConversionFunction(AngleUnit.Milliradian, Angle.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Nanodegree, q => q.ToUnit(AngleUnit.Nanodegree)); + unitConverter.SetConversionFunction(AngleUnit.Nanodegree, Angle.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Nanoradian, q => q.ToUnit(AngleUnit.Nanoradian)); + unitConverter.SetConversionFunction(AngleUnit.Nanoradian, Angle.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Radian, q => q.ToUnit(AngleUnit.Radian)); + unitConverter.SetConversionFunction(AngleUnit.Radian, Angle.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Angle.BaseUnit, AngleUnit.Revolution, q => q.ToUnit(AngleUnit.Revolution)); + unitConverter.SetConversionFunction(AngleUnit.Revolution, Angle.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ApparentEnergy.BaseUnit, ApparentEnergyUnit.KilovoltampereHour, q => q.ToUnit(ApparentEnergyUnit.KilovoltampereHour)); + unitConverter.SetConversionFunction(ApparentEnergyUnit.KilovoltampereHour, ApparentEnergy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ApparentEnergy.BaseUnit, ApparentEnergyUnit.MegavoltampereHour, q => q.ToUnit(ApparentEnergyUnit.MegavoltampereHour)); + unitConverter.SetConversionFunction(ApparentEnergyUnit.MegavoltampereHour, ApparentEnergy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ApparentEnergy.BaseUnit, ApparentEnergy.BaseUnit, q => q); + unitConverter.SetConversionFunction(ApparentPower.BaseUnit, ApparentPowerUnit.Gigavoltampere, q => q.ToUnit(ApparentPowerUnit.Gigavoltampere)); + unitConverter.SetConversionFunction(ApparentPowerUnit.Gigavoltampere, ApparentPower.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ApparentPower.BaseUnit, ApparentPowerUnit.Kilovoltampere, q => q.ToUnit(ApparentPowerUnit.Kilovoltampere)); + unitConverter.SetConversionFunction(ApparentPowerUnit.Kilovoltampere, ApparentPower.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ApparentPower.BaseUnit, ApparentPowerUnit.Megavoltampere, q => q.ToUnit(ApparentPowerUnit.Megavoltampere)); + unitConverter.SetConversionFunction(ApparentPowerUnit.Megavoltampere, ApparentPower.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ApparentPower.BaseUnit, ApparentPower.BaseUnit, q => q); + unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.Acre, q => q.ToUnit(AreaUnit.Acre)); + unitConverter.SetConversionFunction(AreaUnit.Acre, Area.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.Hectare, q => q.ToUnit(AreaUnit.Hectare)); + unitConverter.SetConversionFunction(AreaUnit.Hectare, Area.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareCentimeter, q => q.ToUnit(AreaUnit.SquareCentimeter)); + unitConverter.SetConversionFunction(AreaUnit.SquareCentimeter, Area.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareDecimeter, q => q.ToUnit(AreaUnit.SquareDecimeter)); + unitConverter.SetConversionFunction(AreaUnit.SquareDecimeter, Area.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareFoot, q => q.ToUnit(AreaUnit.SquareFoot)); + unitConverter.SetConversionFunction(AreaUnit.SquareFoot, Area.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareInch, q => q.ToUnit(AreaUnit.SquareInch)); + unitConverter.SetConversionFunction(AreaUnit.SquareInch, Area.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareKilometer, q => q.ToUnit(AreaUnit.SquareKilometer)); + unitConverter.SetConversionFunction(AreaUnit.SquareKilometer, Area.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Area.BaseUnit, Area.BaseUnit, q => q); + unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareMicrometer, q => q.ToUnit(AreaUnit.SquareMicrometer)); + unitConverter.SetConversionFunction(AreaUnit.SquareMicrometer, Area.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareMile, q => q.ToUnit(AreaUnit.SquareMile)); + unitConverter.SetConversionFunction(AreaUnit.SquareMile, Area.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareMillimeter, q => q.ToUnit(AreaUnit.SquareMillimeter)); + unitConverter.SetConversionFunction(AreaUnit.SquareMillimeter, Area.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareYard, q => q.ToUnit(AreaUnit.SquareYard)); + unitConverter.SetConversionFunction(AreaUnit.SquareYard, Area.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.UsSurveySquareFoot, q => q.ToUnit(AreaUnit.UsSurveySquareFoot)); + unitConverter.SetConversionFunction(AreaUnit.UsSurveySquareFoot, Area.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(AreaDensity.BaseUnit, AreaDensity.BaseUnit, q => q); + unitConverter.SetConversionFunction(AreaMomentOfInertia.BaseUnit, AreaMomentOfInertiaUnit.CentimeterToTheFourth, q => q.ToUnit(AreaMomentOfInertiaUnit.CentimeterToTheFourth)); + unitConverter.SetConversionFunction(AreaMomentOfInertiaUnit.CentimeterToTheFourth, AreaMomentOfInertia.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(AreaMomentOfInertia.BaseUnit, AreaMomentOfInertiaUnit.DecimeterToTheFourth, q => q.ToUnit(AreaMomentOfInertiaUnit.DecimeterToTheFourth)); + unitConverter.SetConversionFunction(AreaMomentOfInertiaUnit.DecimeterToTheFourth, AreaMomentOfInertia.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(AreaMomentOfInertia.BaseUnit, AreaMomentOfInertiaUnit.FootToTheFourth, q => q.ToUnit(AreaMomentOfInertiaUnit.FootToTheFourth)); + unitConverter.SetConversionFunction(AreaMomentOfInertiaUnit.FootToTheFourth, AreaMomentOfInertia.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(AreaMomentOfInertia.BaseUnit, AreaMomentOfInertiaUnit.InchToTheFourth, q => q.ToUnit(AreaMomentOfInertiaUnit.InchToTheFourth)); + unitConverter.SetConversionFunction(AreaMomentOfInertiaUnit.InchToTheFourth, AreaMomentOfInertia.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(AreaMomentOfInertia.BaseUnit, AreaMomentOfInertia.BaseUnit, q => q); + unitConverter.SetConversionFunction(AreaMomentOfInertia.BaseUnit, AreaMomentOfInertiaUnit.MillimeterToTheFourth, q => q.ToUnit(AreaMomentOfInertiaUnit.MillimeterToTheFourth)); + unitConverter.SetConversionFunction(AreaMomentOfInertiaUnit.MillimeterToTheFourth, AreaMomentOfInertia.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRate.BaseUnit, q => q); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.BytePerSecond, q => q.ToUnit(BitRateUnit.BytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.BytePerSecond, BitRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.ExabitPerSecond, q => q.ToUnit(BitRateUnit.ExabitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.ExabitPerSecond, BitRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.ExabytePerSecond, q => q.ToUnit(BitRateUnit.ExabytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.ExabytePerSecond, BitRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.ExbibitPerSecond, q => q.ToUnit(BitRateUnit.ExbibitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.ExbibitPerSecond, BitRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.ExbibytePerSecond, q => q.ToUnit(BitRateUnit.ExbibytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.ExbibytePerSecond, BitRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.GibibitPerSecond, q => q.ToUnit(BitRateUnit.GibibitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.GibibitPerSecond, BitRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.GibibytePerSecond, q => q.ToUnit(BitRateUnit.GibibytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.GibibytePerSecond, BitRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.GigabitPerSecond, q => q.ToUnit(BitRateUnit.GigabitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.GigabitPerSecond, BitRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.GigabytePerSecond, q => q.ToUnit(BitRateUnit.GigabytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.GigabytePerSecond, BitRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.KibibitPerSecond, q => q.ToUnit(BitRateUnit.KibibitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.KibibitPerSecond, BitRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.KibibytePerSecond, q => q.ToUnit(BitRateUnit.KibibytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.KibibytePerSecond, BitRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.KilobitPerSecond, q => q.ToUnit(BitRateUnit.KilobitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.KilobitPerSecond, BitRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.KilobytePerSecond, q => q.ToUnit(BitRateUnit.KilobytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.KilobytePerSecond, BitRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.MebibitPerSecond, q => q.ToUnit(BitRateUnit.MebibitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.MebibitPerSecond, BitRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.MebibytePerSecond, q => q.ToUnit(BitRateUnit.MebibytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.MebibytePerSecond, BitRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.MegabitPerSecond, q => q.ToUnit(BitRateUnit.MegabitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.MegabitPerSecond, BitRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.MegabytePerSecond, q => q.ToUnit(BitRateUnit.MegabytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.MegabytePerSecond, BitRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.PebibitPerSecond, q => q.ToUnit(BitRateUnit.PebibitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.PebibitPerSecond, BitRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.PebibytePerSecond, q => q.ToUnit(BitRateUnit.PebibytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.PebibytePerSecond, BitRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.PetabitPerSecond, q => q.ToUnit(BitRateUnit.PetabitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.PetabitPerSecond, BitRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.PetabytePerSecond, q => q.ToUnit(BitRateUnit.PetabytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.PetabytePerSecond, BitRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.TebibitPerSecond, q => q.ToUnit(BitRateUnit.TebibitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.TebibitPerSecond, BitRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.TebibytePerSecond, q => q.ToUnit(BitRateUnit.TebibytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.TebibytePerSecond, BitRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.TerabitPerSecond, q => q.ToUnit(BitRateUnit.TerabitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.TerabitPerSecond, BitRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(BitRate.BaseUnit, BitRateUnit.TerabytePerSecond, q => q.ToUnit(BitRateUnit.TerabytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.TerabytePerSecond, BitRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(BrakeSpecificFuelConsumption.BaseUnit, BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour, q => q.ToUnit(BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour)); + unitConverter.SetConversionFunction(BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour, BrakeSpecificFuelConsumption.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(BrakeSpecificFuelConsumption.BaseUnit, BrakeSpecificFuelConsumption.BaseUnit, q => q); + unitConverter.SetConversionFunction(BrakeSpecificFuelConsumption.BaseUnit, BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour, q => q.ToUnit(BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour)); + unitConverter.SetConversionFunction(BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour, BrakeSpecificFuelConsumption.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Capacitance.BaseUnit, Capacitance.BaseUnit, q => q); + unitConverter.SetConversionFunction(Capacitance.BaseUnit, CapacitanceUnit.Kilofarad, q => q.ToUnit(CapacitanceUnit.Kilofarad)); + unitConverter.SetConversionFunction(CapacitanceUnit.Kilofarad, Capacitance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Capacitance.BaseUnit, CapacitanceUnit.Megafarad, q => q.ToUnit(CapacitanceUnit.Megafarad)); + unitConverter.SetConversionFunction(CapacitanceUnit.Megafarad, Capacitance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Capacitance.BaseUnit, CapacitanceUnit.Microfarad, q => q.ToUnit(CapacitanceUnit.Microfarad)); + unitConverter.SetConversionFunction(CapacitanceUnit.Microfarad, Capacitance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Capacitance.BaseUnit, CapacitanceUnit.Millifarad, q => q.ToUnit(CapacitanceUnit.Millifarad)); + unitConverter.SetConversionFunction(CapacitanceUnit.Millifarad, Capacitance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Capacitance.BaseUnit, CapacitanceUnit.Nanofarad, q => q.ToUnit(CapacitanceUnit.Nanofarad)); + unitConverter.SetConversionFunction(CapacitanceUnit.Nanofarad, Capacitance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Capacitance.BaseUnit, CapacitanceUnit.Picofarad, q => q.ToUnit(CapacitanceUnit.Picofarad)); + unitConverter.SetConversionFunction(CapacitanceUnit.Picofarad, Capacitance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(CoefficientOfThermalExpansion.BaseUnit, CoefficientOfThermalExpansionUnit.InverseDegreeCelsius, q => q.ToUnit(CoefficientOfThermalExpansionUnit.InverseDegreeCelsius)); + unitConverter.SetConversionFunction(CoefficientOfThermalExpansionUnit.InverseDegreeCelsius, CoefficientOfThermalExpansion.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(CoefficientOfThermalExpansion.BaseUnit, CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit, q => q.ToUnit(CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit)); + unitConverter.SetConversionFunction(CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit, CoefficientOfThermalExpansion.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(CoefficientOfThermalExpansion.BaseUnit, CoefficientOfThermalExpansion.BaseUnit, q => q); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.CentigramPerDeciliter, q => q.ToUnit(DensityUnit.CentigramPerDeciliter)); + unitConverter.SetConversionFunction(DensityUnit.CentigramPerDeciliter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.CentigramPerLiter, q => q.ToUnit(DensityUnit.CentigramPerLiter)); + unitConverter.SetConversionFunction(DensityUnit.CentigramPerLiter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.CentigramPerMilliliter, q => q.ToUnit(DensityUnit.CentigramPerMilliliter)); + unitConverter.SetConversionFunction(DensityUnit.CentigramPerMilliliter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.DecigramPerDeciliter, q => q.ToUnit(DensityUnit.DecigramPerDeciliter)); + unitConverter.SetConversionFunction(DensityUnit.DecigramPerDeciliter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.DecigramPerLiter, q => q.ToUnit(DensityUnit.DecigramPerLiter)); + unitConverter.SetConversionFunction(DensityUnit.DecigramPerLiter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.DecigramPerMilliliter, q => q.ToUnit(DensityUnit.DecigramPerMilliliter)); + unitConverter.SetConversionFunction(DensityUnit.DecigramPerMilliliter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.GramPerCubicCentimeter, q => q.ToUnit(DensityUnit.GramPerCubicCentimeter)); + unitConverter.SetConversionFunction(DensityUnit.GramPerCubicCentimeter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.GramPerCubicMeter, q => q.ToUnit(DensityUnit.GramPerCubicMeter)); + unitConverter.SetConversionFunction(DensityUnit.GramPerCubicMeter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.GramPerCubicMillimeter, q => q.ToUnit(DensityUnit.GramPerCubicMillimeter)); + unitConverter.SetConversionFunction(DensityUnit.GramPerCubicMillimeter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.GramPerDeciliter, q => q.ToUnit(DensityUnit.GramPerDeciliter)); + unitConverter.SetConversionFunction(DensityUnit.GramPerDeciliter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.GramPerLiter, q => q.ToUnit(DensityUnit.GramPerLiter)); + unitConverter.SetConversionFunction(DensityUnit.GramPerLiter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.GramPerMilliliter, q => q.ToUnit(DensityUnit.GramPerMilliliter)); + unitConverter.SetConversionFunction(DensityUnit.GramPerMilliliter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.KilogramPerCubicCentimeter, q => q.ToUnit(DensityUnit.KilogramPerCubicCentimeter)); + unitConverter.SetConversionFunction(DensityUnit.KilogramPerCubicCentimeter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, Density.BaseUnit, q => q); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.KilogramPerCubicMillimeter, q => q.ToUnit(DensityUnit.KilogramPerCubicMillimeter)); + unitConverter.SetConversionFunction(DensityUnit.KilogramPerCubicMillimeter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.KilopoundPerCubicFoot, q => q.ToUnit(DensityUnit.KilopoundPerCubicFoot)); + unitConverter.SetConversionFunction(DensityUnit.KilopoundPerCubicFoot, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.KilopoundPerCubicInch, q => q.ToUnit(DensityUnit.KilopoundPerCubicInch)); + unitConverter.SetConversionFunction(DensityUnit.KilopoundPerCubicInch, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.MicrogramPerCubicMeter, q => q.ToUnit(DensityUnit.MicrogramPerCubicMeter)); + unitConverter.SetConversionFunction(DensityUnit.MicrogramPerCubicMeter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.MicrogramPerDeciliter, q => q.ToUnit(DensityUnit.MicrogramPerDeciliter)); + unitConverter.SetConversionFunction(DensityUnit.MicrogramPerDeciliter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.MicrogramPerLiter, q => q.ToUnit(DensityUnit.MicrogramPerLiter)); + unitConverter.SetConversionFunction(DensityUnit.MicrogramPerLiter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.MicrogramPerMilliliter, q => q.ToUnit(DensityUnit.MicrogramPerMilliliter)); + unitConverter.SetConversionFunction(DensityUnit.MicrogramPerMilliliter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.MilligramPerCubicMeter, q => q.ToUnit(DensityUnit.MilligramPerCubicMeter)); + unitConverter.SetConversionFunction(DensityUnit.MilligramPerCubicMeter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.MilligramPerDeciliter, q => q.ToUnit(DensityUnit.MilligramPerDeciliter)); + unitConverter.SetConversionFunction(DensityUnit.MilligramPerDeciliter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.MilligramPerLiter, q => q.ToUnit(DensityUnit.MilligramPerLiter)); + unitConverter.SetConversionFunction(DensityUnit.MilligramPerLiter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.MilligramPerMilliliter, q => q.ToUnit(DensityUnit.MilligramPerMilliliter)); + unitConverter.SetConversionFunction(DensityUnit.MilligramPerMilliliter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.NanogramPerDeciliter, q => q.ToUnit(DensityUnit.NanogramPerDeciliter)); + unitConverter.SetConversionFunction(DensityUnit.NanogramPerDeciliter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.NanogramPerLiter, q => q.ToUnit(DensityUnit.NanogramPerLiter)); + unitConverter.SetConversionFunction(DensityUnit.NanogramPerLiter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.NanogramPerMilliliter, q => q.ToUnit(DensityUnit.NanogramPerMilliliter)); + unitConverter.SetConversionFunction(DensityUnit.NanogramPerMilliliter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PicogramPerDeciliter, q => q.ToUnit(DensityUnit.PicogramPerDeciliter)); + unitConverter.SetConversionFunction(DensityUnit.PicogramPerDeciliter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PicogramPerLiter, q => q.ToUnit(DensityUnit.PicogramPerLiter)); + unitConverter.SetConversionFunction(DensityUnit.PicogramPerLiter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PicogramPerMilliliter, q => q.ToUnit(DensityUnit.PicogramPerMilliliter)); + unitConverter.SetConversionFunction(DensityUnit.PicogramPerMilliliter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PoundPerCubicFoot, q => q.ToUnit(DensityUnit.PoundPerCubicFoot)); + unitConverter.SetConversionFunction(DensityUnit.PoundPerCubicFoot, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PoundPerCubicInch, q => q.ToUnit(DensityUnit.PoundPerCubicInch)); + unitConverter.SetConversionFunction(DensityUnit.PoundPerCubicInch, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PoundPerImperialGallon, q => q.ToUnit(DensityUnit.PoundPerImperialGallon)); + unitConverter.SetConversionFunction(DensityUnit.PoundPerImperialGallon, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PoundPerUSGallon, q => q.ToUnit(DensityUnit.PoundPerUSGallon)); + unitConverter.SetConversionFunction(DensityUnit.PoundPerUSGallon, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.SlugPerCubicFoot, q => q.ToUnit(DensityUnit.SlugPerCubicFoot)); + unitConverter.SetConversionFunction(DensityUnit.SlugPerCubicFoot, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.TonnePerCubicCentimeter, q => q.ToUnit(DensityUnit.TonnePerCubicCentimeter)); + unitConverter.SetConversionFunction(DensityUnit.TonnePerCubicCentimeter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.TonnePerCubicMeter, q => q.ToUnit(DensityUnit.TonnePerCubicMeter)); + unitConverter.SetConversionFunction(DensityUnit.TonnePerCubicMeter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.TonnePerCubicMillimeter, q => q.ToUnit(DensityUnit.TonnePerCubicMillimeter)); + unitConverter.SetConversionFunction(DensityUnit.TonnePerCubicMillimeter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Day, q => q.ToUnit(DurationUnit.Day)); + unitConverter.SetConversionFunction(DurationUnit.Day, Duration.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Hour, q => q.ToUnit(DurationUnit.Hour)); + unitConverter.SetConversionFunction(DurationUnit.Hour, Duration.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Microsecond, q => q.ToUnit(DurationUnit.Microsecond)); + unitConverter.SetConversionFunction(DurationUnit.Microsecond, Duration.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Millisecond, q => q.ToUnit(DurationUnit.Millisecond)); + unitConverter.SetConversionFunction(DurationUnit.Millisecond, Duration.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Minute, q => q.ToUnit(DurationUnit.Minute)); + unitConverter.SetConversionFunction(DurationUnit.Minute, Duration.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Month30, q => q.ToUnit(DurationUnit.Month30)); + unitConverter.SetConversionFunction(DurationUnit.Month30, Duration.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Nanosecond, q => q.ToUnit(DurationUnit.Nanosecond)); + unitConverter.SetConversionFunction(DurationUnit.Nanosecond, Duration.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Duration.BaseUnit, Duration.BaseUnit, q => q); + unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Week, q => q.ToUnit(DurationUnit.Week)); + unitConverter.SetConversionFunction(DurationUnit.Week, Duration.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Duration.BaseUnit, DurationUnit.Year365, q => q.ToUnit(DurationUnit.Year365)); + unitConverter.SetConversionFunction(DurationUnit.Year365, Duration.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(DynamicViscosity.BaseUnit, DynamicViscosityUnit.Centipoise, q => q.ToUnit(DynamicViscosityUnit.Centipoise)); + unitConverter.SetConversionFunction(DynamicViscosityUnit.Centipoise, DynamicViscosity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(DynamicViscosity.BaseUnit, DynamicViscosityUnit.MicropascalSecond, q => q.ToUnit(DynamicViscosityUnit.MicropascalSecond)); + unitConverter.SetConversionFunction(DynamicViscosityUnit.MicropascalSecond, DynamicViscosity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(DynamicViscosity.BaseUnit, DynamicViscosityUnit.MillipascalSecond, q => q.ToUnit(DynamicViscosityUnit.MillipascalSecond)); + unitConverter.SetConversionFunction(DynamicViscosityUnit.MillipascalSecond, DynamicViscosity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(DynamicViscosity.BaseUnit, DynamicViscosity.BaseUnit, q => q); + unitConverter.SetConversionFunction(DynamicViscosity.BaseUnit, DynamicViscosityUnit.PascalSecond, q => q.ToUnit(DynamicViscosityUnit.PascalSecond)); + unitConverter.SetConversionFunction(DynamicViscosityUnit.PascalSecond, DynamicViscosity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(DynamicViscosity.BaseUnit, DynamicViscosityUnit.Poise, q => q.ToUnit(DynamicViscosityUnit.Poise)); + unitConverter.SetConversionFunction(DynamicViscosityUnit.Poise, DynamicViscosity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricAdmittance.BaseUnit, ElectricAdmittanceUnit.Microsiemens, q => q.ToUnit(ElectricAdmittanceUnit.Microsiemens)); + unitConverter.SetConversionFunction(ElectricAdmittanceUnit.Microsiemens, ElectricAdmittance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricAdmittance.BaseUnit, ElectricAdmittanceUnit.Millisiemens, q => q.ToUnit(ElectricAdmittanceUnit.Millisiemens)); + unitConverter.SetConversionFunction(ElectricAdmittanceUnit.Millisiemens, ElectricAdmittance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricAdmittance.BaseUnit, ElectricAdmittanceUnit.Nanosiemens, q => q.ToUnit(ElectricAdmittanceUnit.Nanosiemens)); + unitConverter.SetConversionFunction(ElectricAdmittanceUnit.Nanosiemens, ElectricAdmittance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricAdmittance.BaseUnit, ElectricAdmittance.BaseUnit, q => q); + unitConverter.SetConversionFunction(ElectricCharge.BaseUnit, ElectricCharge.BaseUnit, q => q); + unitConverter.SetConversionFunction(ElectricChargeDensity.BaseUnit, ElectricChargeDensity.BaseUnit, q => q); + unitConverter.SetConversionFunction(ElectricConductance.BaseUnit, ElectricConductanceUnit.Microsiemens, q => q.ToUnit(ElectricConductanceUnit.Microsiemens)); + unitConverter.SetConversionFunction(ElectricConductanceUnit.Microsiemens, ElectricConductance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricConductance.BaseUnit, ElectricConductanceUnit.Millisiemens, q => q.ToUnit(ElectricConductanceUnit.Millisiemens)); + unitConverter.SetConversionFunction(ElectricConductanceUnit.Millisiemens, ElectricConductance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricConductance.BaseUnit, ElectricConductance.BaseUnit, q => q); + unitConverter.SetConversionFunction(ElectricConductivity.BaseUnit, ElectricConductivity.BaseUnit, q => q); + unitConverter.SetConversionFunction(ElectricCurrent.BaseUnit, ElectricCurrent.BaseUnit, q => q); + unitConverter.SetConversionFunction(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Centiampere, q => q.ToUnit(ElectricCurrentUnit.Centiampere)); + unitConverter.SetConversionFunction(ElectricCurrentUnit.Centiampere, ElectricCurrent.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Kiloampere, q => q.ToUnit(ElectricCurrentUnit.Kiloampere)); + unitConverter.SetConversionFunction(ElectricCurrentUnit.Kiloampere, ElectricCurrent.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Megaampere, q => q.ToUnit(ElectricCurrentUnit.Megaampere)); + unitConverter.SetConversionFunction(ElectricCurrentUnit.Megaampere, ElectricCurrent.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Microampere, q => q.ToUnit(ElectricCurrentUnit.Microampere)); + unitConverter.SetConversionFunction(ElectricCurrentUnit.Microampere, ElectricCurrent.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Milliampere, q => q.ToUnit(ElectricCurrentUnit.Milliampere)); + unitConverter.SetConversionFunction(ElectricCurrentUnit.Milliampere, ElectricCurrent.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Nanoampere, q => q.ToUnit(ElectricCurrentUnit.Nanoampere)); + unitConverter.SetConversionFunction(ElectricCurrentUnit.Nanoampere, ElectricCurrent.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricCurrent.BaseUnit, ElectricCurrentUnit.Picoampere, q => q.ToUnit(ElectricCurrentUnit.Picoampere)); + unitConverter.SetConversionFunction(ElectricCurrentUnit.Picoampere, ElectricCurrent.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricCurrentDensity.BaseUnit, ElectricCurrentDensity.BaseUnit, q => q); + unitConverter.SetConversionFunction(ElectricCurrentGradient.BaseUnit, ElectricCurrentGradient.BaseUnit, q => q); + unitConverter.SetConversionFunction(ElectricField.BaseUnit, ElectricField.BaseUnit, q => q); + unitConverter.SetConversionFunction(ElectricInductance.BaseUnit, ElectricInductance.BaseUnit, q => q); + unitConverter.SetConversionFunction(ElectricInductance.BaseUnit, ElectricInductanceUnit.Microhenry, q => q.ToUnit(ElectricInductanceUnit.Microhenry)); + unitConverter.SetConversionFunction(ElectricInductanceUnit.Microhenry, ElectricInductance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricInductance.BaseUnit, ElectricInductanceUnit.Millihenry, q => q.ToUnit(ElectricInductanceUnit.Millihenry)); + unitConverter.SetConversionFunction(ElectricInductanceUnit.Millihenry, ElectricInductance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricInductance.BaseUnit, ElectricInductanceUnit.Nanohenry, q => q.ToUnit(ElectricInductanceUnit.Nanohenry)); + unitConverter.SetConversionFunction(ElectricInductanceUnit.Nanohenry, ElectricInductance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotential.BaseUnit, ElectricPotentialUnit.Kilovolt, q => q.ToUnit(ElectricPotentialUnit.Kilovolt)); + unitConverter.SetConversionFunction(ElectricPotentialUnit.Kilovolt, ElectricPotential.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotential.BaseUnit, ElectricPotentialUnit.Megavolt, q => q.ToUnit(ElectricPotentialUnit.Megavolt)); + unitConverter.SetConversionFunction(ElectricPotentialUnit.Megavolt, ElectricPotential.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotential.BaseUnit, ElectricPotentialUnit.Microvolt, q => q.ToUnit(ElectricPotentialUnit.Microvolt)); + unitConverter.SetConversionFunction(ElectricPotentialUnit.Microvolt, ElectricPotential.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotential.BaseUnit, ElectricPotentialUnit.Millivolt, q => q.ToUnit(ElectricPotentialUnit.Millivolt)); + unitConverter.SetConversionFunction(ElectricPotentialUnit.Millivolt, ElectricPotential.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotential.BaseUnit, ElectricPotential.BaseUnit, q => q); + unitConverter.SetConversionFunction(ElectricPotentialAc.BaseUnit, ElectricPotentialAcUnit.KilovoltAc, q => q.ToUnit(ElectricPotentialAcUnit.KilovoltAc)); + unitConverter.SetConversionFunction(ElectricPotentialAcUnit.KilovoltAc, ElectricPotentialAc.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotentialAc.BaseUnit, ElectricPotentialAcUnit.MegavoltAc, q => q.ToUnit(ElectricPotentialAcUnit.MegavoltAc)); + unitConverter.SetConversionFunction(ElectricPotentialAcUnit.MegavoltAc, ElectricPotentialAc.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotentialAc.BaseUnit, ElectricPotentialAcUnit.MicrovoltAc, q => q.ToUnit(ElectricPotentialAcUnit.MicrovoltAc)); + unitConverter.SetConversionFunction(ElectricPotentialAcUnit.MicrovoltAc, ElectricPotentialAc.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotentialAc.BaseUnit, ElectricPotentialAcUnit.MillivoltAc, q => q.ToUnit(ElectricPotentialAcUnit.MillivoltAc)); + unitConverter.SetConversionFunction(ElectricPotentialAcUnit.MillivoltAc, ElectricPotentialAc.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotentialAc.BaseUnit, ElectricPotentialAc.BaseUnit, q => q); + unitConverter.SetConversionFunction(ElectricPotentialDc.BaseUnit, ElectricPotentialDcUnit.KilovoltDc, q => q.ToUnit(ElectricPotentialDcUnit.KilovoltDc)); + unitConverter.SetConversionFunction(ElectricPotentialDcUnit.KilovoltDc, ElectricPotentialDc.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotentialDc.BaseUnit, ElectricPotentialDcUnit.MegavoltDc, q => q.ToUnit(ElectricPotentialDcUnit.MegavoltDc)); + unitConverter.SetConversionFunction(ElectricPotentialDcUnit.MegavoltDc, ElectricPotentialDc.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotentialDc.BaseUnit, ElectricPotentialDcUnit.MicrovoltDc, q => q.ToUnit(ElectricPotentialDcUnit.MicrovoltDc)); + unitConverter.SetConversionFunction(ElectricPotentialDcUnit.MicrovoltDc, ElectricPotentialDc.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotentialDc.BaseUnit, ElectricPotentialDcUnit.MillivoltDc, q => q.ToUnit(ElectricPotentialDcUnit.MillivoltDc)); + unitConverter.SetConversionFunction(ElectricPotentialDcUnit.MillivoltDc, ElectricPotentialDc.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricPotentialDc.BaseUnit, ElectricPotentialDc.BaseUnit, q => q); + unitConverter.SetConversionFunction(ElectricResistance.BaseUnit, ElectricResistanceUnit.Gigaohm, q => q.ToUnit(ElectricResistanceUnit.Gigaohm)); + unitConverter.SetConversionFunction(ElectricResistanceUnit.Gigaohm, ElectricResistance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistance.BaseUnit, ElectricResistanceUnit.Kiloohm, q => q.ToUnit(ElectricResistanceUnit.Kiloohm)); + unitConverter.SetConversionFunction(ElectricResistanceUnit.Kiloohm, ElectricResistance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistance.BaseUnit, ElectricResistanceUnit.Megaohm, q => q.ToUnit(ElectricResistanceUnit.Megaohm)); + unitConverter.SetConversionFunction(ElectricResistanceUnit.Megaohm, ElectricResistance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistance.BaseUnit, ElectricResistanceUnit.Milliohm, q => q.ToUnit(ElectricResistanceUnit.Milliohm)); + unitConverter.SetConversionFunction(ElectricResistanceUnit.Milliohm, ElectricResistance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistance.BaseUnit, ElectricResistance.BaseUnit, q => q); + unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.KiloohmCentimeter, q => q.ToUnit(ElectricResistivityUnit.KiloohmCentimeter)); + unitConverter.SetConversionFunction(ElectricResistivityUnit.KiloohmCentimeter, ElectricResistivity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.KiloohmMeter, q => q.ToUnit(ElectricResistivityUnit.KiloohmMeter)); + unitConverter.SetConversionFunction(ElectricResistivityUnit.KiloohmMeter, ElectricResistivity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.MegaohmCentimeter, q => q.ToUnit(ElectricResistivityUnit.MegaohmCentimeter)); + unitConverter.SetConversionFunction(ElectricResistivityUnit.MegaohmCentimeter, ElectricResistivity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.MegaohmMeter, q => q.ToUnit(ElectricResistivityUnit.MegaohmMeter)); + unitConverter.SetConversionFunction(ElectricResistivityUnit.MegaohmMeter, ElectricResistivity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.MicroohmCentimeter, q => q.ToUnit(ElectricResistivityUnit.MicroohmCentimeter)); + unitConverter.SetConversionFunction(ElectricResistivityUnit.MicroohmCentimeter, ElectricResistivity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.MicroohmMeter, q => q.ToUnit(ElectricResistivityUnit.MicroohmMeter)); + unitConverter.SetConversionFunction(ElectricResistivityUnit.MicroohmMeter, ElectricResistivity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.MilliohmCentimeter, q => q.ToUnit(ElectricResistivityUnit.MilliohmCentimeter)); + unitConverter.SetConversionFunction(ElectricResistivityUnit.MilliohmCentimeter, ElectricResistivity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.MilliohmMeter, q => q.ToUnit(ElectricResistivityUnit.MilliohmMeter)); + unitConverter.SetConversionFunction(ElectricResistivityUnit.MilliohmMeter, ElectricResistivity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.NanoohmCentimeter, q => q.ToUnit(ElectricResistivityUnit.NanoohmCentimeter)); + unitConverter.SetConversionFunction(ElectricResistivityUnit.NanoohmCentimeter, ElectricResistivity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.NanoohmMeter, q => q.ToUnit(ElectricResistivityUnit.NanoohmMeter)); + unitConverter.SetConversionFunction(ElectricResistivityUnit.NanoohmMeter, ElectricResistivity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.OhmCentimeter, q => q.ToUnit(ElectricResistivityUnit.OhmCentimeter)); + unitConverter.SetConversionFunction(ElectricResistivityUnit.OhmCentimeter, ElectricResistivity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivity.BaseUnit, q => q); + unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.PicoohmCentimeter, q => q.ToUnit(ElectricResistivityUnit.PicoohmCentimeter)); + unitConverter.SetConversionFunction(ElectricResistivityUnit.PicoohmCentimeter, ElectricResistivity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ElectricResistivity.BaseUnit, ElectricResistivityUnit.PicoohmMeter, q => q.ToUnit(ElectricResistivityUnit.PicoohmMeter)); + unitConverter.SetConversionFunction(ElectricResistivityUnit.PicoohmMeter, ElectricResistivity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.BritishThermalUnit, q => q.ToUnit(EnergyUnit.BritishThermalUnit)); + unitConverter.SetConversionFunction(EnergyUnit.BritishThermalUnit, Energy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.Calorie, q => q.ToUnit(EnergyUnit.Calorie)); + unitConverter.SetConversionFunction(EnergyUnit.Calorie, Energy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.DecathermEc, q => q.ToUnit(EnergyUnit.DecathermEc)); + unitConverter.SetConversionFunction(EnergyUnit.DecathermEc, Energy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.DecathermImperial, q => q.ToUnit(EnergyUnit.DecathermImperial)); + unitConverter.SetConversionFunction(EnergyUnit.DecathermImperial, Energy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.DecathermUs, q => q.ToUnit(EnergyUnit.DecathermUs)); + unitConverter.SetConversionFunction(EnergyUnit.DecathermUs, Energy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.ElectronVolt, q => q.ToUnit(EnergyUnit.ElectronVolt)); + unitConverter.SetConversionFunction(EnergyUnit.ElectronVolt, Energy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.Erg, q => q.ToUnit(EnergyUnit.Erg)); + unitConverter.SetConversionFunction(EnergyUnit.Erg, Energy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.FootPound, q => q.ToUnit(EnergyUnit.FootPound)); + unitConverter.SetConversionFunction(EnergyUnit.FootPound, Energy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.GigabritishThermalUnit, q => q.ToUnit(EnergyUnit.GigabritishThermalUnit)); + unitConverter.SetConversionFunction(EnergyUnit.GigabritishThermalUnit, Energy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.GigawattHour, q => q.ToUnit(EnergyUnit.GigawattHour)); + unitConverter.SetConversionFunction(EnergyUnit.GigawattHour, Energy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, Energy.BaseUnit, q => q); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.KilobritishThermalUnit, q => q.ToUnit(EnergyUnit.KilobritishThermalUnit)); + unitConverter.SetConversionFunction(EnergyUnit.KilobritishThermalUnit, Energy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.Kilocalorie, q => q.ToUnit(EnergyUnit.Kilocalorie)); + unitConverter.SetConversionFunction(EnergyUnit.Kilocalorie, Energy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.Kilojoule, q => q.ToUnit(EnergyUnit.Kilojoule)); + unitConverter.SetConversionFunction(EnergyUnit.Kilojoule, Energy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.KilowattHour, q => q.ToUnit(EnergyUnit.KilowattHour)); + unitConverter.SetConversionFunction(EnergyUnit.KilowattHour, Energy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.MegabritishThermalUnit, q => q.ToUnit(EnergyUnit.MegabritishThermalUnit)); + unitConverter.SetConversionFunction(EnergyUnit.MegabritishThermalUnit, Energy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.Megajoule, q => q.ToUnit(EnergyUnit.Megajoule)); + unitConverter.SetConversionFunction(EnergyUnit.Megajoule, Energy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.MegawattHour, q => q.ToUnit(EnergyUnit.MegawattHour)); + unitConverter.SetConversionFunction(EnergyUnit.MegawattHour, Energy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.ThermEc, q => q.ToUnit(EnergyUnit.ThermEc)); + unitConverter.SetConversionFunction(EnergyUnit.ThermEc, Energy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.ThermImperial, q => q.ToUnit(EnergyUnit.ThermImperial)); + unitConverter.SetConversionFunction(EnergyUnit.ThermImperial, Energy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.ThermUs, q => q.ToUnit(EnergyUnit.ThermUs)); + unitConverter.SetConversionFunction(EnergyUnit.ThermUs, Energy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.WattHour, q => q.ToUnit(EnergyUnit.WattHour)); + unitConverter.SetConversionFunction(EnergyUnit.WattHour, Energy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Entropy.BaseUnit, EntropyUnit.CaloriePerKelvin, q => q.ToUnit(EntropyUnit.CaloriePerKelvin)); + unitConverter.SetConversionFunction(EntropyUnit.CaloriePerKelvin, Entropy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Entropy.BaseUnit, EntropyUnit.JoulePerDegreeCelsius, q => q.ToUnit(EntropyUnit.JoulePerDegreeCelsius)); + unitConverter.SetConversionFunction(EntropyUnit.JoulePerDegreeCelsius, Entropy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Entropy.BaseUnit, Entropy.BaseUnit, q => q); + unitConverter.SetConversionFunction(Entropy.BaseUnit, EntropyUnit.KilocaloriePerKelvin, q => q.ToUnit(EntropyUnit.KilocaloriePerKelvin)); + unitConverter.SetConversionFunction(EntropyUnit.KilocaloriePerKelvin, Entropy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Entropy.BaseUnit, EntropyUnit.KilojoulePerDegreeCelsius, q => q.ToUnit(EntropyUnit.KilojoulePerDegreeCelsius)); + unitConverter.SetConversionFunction(EntropyUnit.KilojoulePerDegreeCelsius, Entropy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Entropy.BaseUnit, EntropyUnit.KilojoulePerKelvin, q => q.ToUnit(EntropyUnit.KilojoulePerKelvin)); + unitConverter.SetConversionFunction(EntropyUnit.KilojoulePerKelvin, Entropy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Entropy.BaseUnit, EntropyUnit.MegajoulePerKelvin, q => q.ToUnit(EntropyUnit.MegajoulePerKelvin)); + unitConverter.SetConversionFunction(EntropyUnit.MegajoulePerKelvin, Entropy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.Decanewton, q => q.ToUnit(ForceUnit.Decanewton)); + unitConverter.SetConversionFunction(ForceUnit.Decanewton, Force.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.Dyn, q => q.ToUnit(ForceUnit.Dyn)); + unitConverter.SetConversionFunction(ForceUnit.Dyn, Force.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.KilogramForce, q => q.ToUnit(ForceUnit.KilogramForce)); + unitConverter.SetConversionFunction(ForceUnit.KilogramForce, Force.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.Kilonewton, q => q.ToUnit(ForceUnit.Kilonewton)); + unitConverter.SetConversionFunction(ForceUnit.Kilonewton, Force.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.KiloPond, q => q.ToUnit(ForceUnit.KiloPond)); + unitConverter.SetConversionFunction(ForceUnit.KiloPond, Force.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.Meganewton, q => q.ToUnit(ForceUnit.Meganewton)); + unitConverter.SetConversionFunction(ForceUnit.Meganewton, Force.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.Micronewton, q => q.ToUnit(ForceUnit.Micronewton)); + unitConverter.SetConversionFunction(ForceUnit.Micronewton, Force.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.Millinewton, q => q.ToUnit(ForceUnit.Millinewton)); + unitConverter.SetConversionFunction(ForceUnit.Millinewton, Force.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Force.BaseUnit, Force.BaseUnit, q => q); + unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.OunceForce, q => q.ToUnit(ForceUnit.OunceForce)); + unitConverter.SetConversionFunction(ForceUnit.OunceForce, Force.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.Poundal, q => q.ToUnit(ForceUnit.Poundal)); + unitConverter.SetConversionFunction(ForceUnit.Poundal, Force.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.PoundForce, q => q.ToUnit(ForceUnit.PoundForce)); + unitConverter.SetConversionFunction(ForceUnit.PoundForce, Force.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Force.BaseUnit, ForceUnit.TonneForce, q => q.ToUnit(ForceUnit.TonneForce)); + unitConverter.SetConversionFunction(ForceUnit.TonneForce, Force.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.CentinewtonPerSecond, q => q.ToUnit(ForceChangeRateUnit.CentinewtonPerSecond)); + unitConverter.SetConversionFunction(ForceChangeRateUnit.CentinewtonPerSecond, ForceChangeRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.DecanewtonPerMinute, q => q.ToUnit(ForceChangeRateUnit.DecanewtonPerMinute)); + unitConverter.SetConversionFunction(ForceChangeRateUnit.DecanewtonPerMinute, ForceChangeRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.DecanewtonPerSecond, q => q.ToUnit(ForceChangeRateUnit.DecanewtonPerSecond)); + unitConverter.SetConversionFunction(ForceChangeRateUnit.DecanewtonPerSecond, ForceChangeRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.DecinewtonPerSecond, q => q.ToUnit(ForceChangeRateUnit.DecinewtonPerSecond)); + unitConverter.SetConversionFunction(ForceChangeRateUnit.DecinewtonPerSecond, ForceChangeRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.KilonewtonPerMinute, q => q.ToUnit(ForceChangeRateUnit.KilonewtonPerMinute)); + unitConverter.SetConversionFunction(ForceChangeRateUnit.KilonewtonPerMinute, ForceChangeRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.KilonewtonPerSecond, q => q.ToUnit(ForceChangeRateUnit.KilonewtonPerSecond)); + unitConverter.SetConversionFunction(ForceChangeRateUnit.KilonewtonPerSecond, ForceChangeRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.MicronewtonPerSecond, q => q.ToUnit(ForceChangeRateUnit.MicronewtonPerSecond)); + unitConverter.SetConversionFunction(ForceChangeRateUnit.MicronewtonPerSecond, ForceChangeRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.MillinewtonPerSecond, q => q.ToUnit(ForceChangeRateUnit.MillinewtonPerSecond)); + unitConverter.SetConversionFunction(ForceChangeRateUnit.MillinewtonPerSecond, ForceChangeRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.NanonewtonPerSecond, q => q.ToUnit(ForceChangeRateUnit.NanonewtonPerSecond)); + unitConverter.SetConversionFunction(ForceChangeRateUnit.NanonewtonPerSecond, ForceChangeRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.NewtonPerMinute, q => q.ToUnit(ForceChangeRateUnit.NewtonPerMinute)); + unitConverter.SetConversionFunction(ForceChangeRateUnit.NewtonPerMinute, ForceChangeRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRate.BaseUnit, q => q); + unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.CentinewtonPerMeter, q => q.ToUnit(ForcePerLengthUnit.CentinewtonPerMeter)); + unitConverter.SetConversionFunction(ForcePerLengthUnit.CentinewtonPerMeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.DecinewtonPerMeter, q => q.ToUnit(ForcePerLengthUnit.DecinewtonPerMeter)); + unitConverter.SetConversionFunction(ForcePerLengthUnit.DecinewtonPerMeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.KilogramForcePerMeter, q => q.ToUnit(ForcePerLengthUnit.KilogramForcePerMeter)); + unitConverter.SetConversionFunction(ForcePerLengthUnit.KilogramForcePerMeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.KilonewtonPerMeter, q => q.ToUnit(ForcePerLengthUnit.KilonewtonPerMeter)); + unitConverter.SetConversionFunction(ForcePerLengthUnit.KilonewtonPerMeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.MeganewtonPerMeter, q => q.ToUnit(ForcePerLengthUnit.MeganewtonPerMeter)); + unitConverter.SetConversionFunction(ForcePerLengthUnit.MeganewtonPerMeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.MicronewtonPerMeter, q => q.ToUnit(ForcePerLengthUnit.MicronewtonPerMeter)); + unitConverter.SetConversionFunction(ForcePerLengthUnit.MicronewtonPerMeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.MillinewtonPerMeter, q => q.ToUnit(ForcePerLengthUnit.MillinewtonPerMeter)); + unitConverter.SetConversionFunction(ForcePerLengthUnit.MillinewtonPerMeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.NanonewtonPerMeter, q => q.ToUnit(ForcePerLengthUnit.NanonewtonPerMeter)); + unitConverter.SetConversionFunction(ForcePerLengthUnit.NanonewtonPerMeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLength.BaseUnit, q => q); + unitConverter.SetConversionFunction(Frequency.BaseUnit, FrequencyUnit.CyclePerHour, q => q.ToUnit(FrequencyUnit.CyclePerHour)); + unitConverter.SetConversionFunction(FrequencyUnit.CyclePerHour, Frequency.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Frequency.BaseUnit, FrequencyUnit.CyclePerMinute, q => q.ToUnit(FrequencyUnit.CyclePerMinute)); + unitConverter.SetConversionFunction(FrequencyUnit.CyclePerMinute, Frequency.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Frequency.BaseUnit, FrequencyUnit.Gigahertz, q => q.ToUnit(FrequencyUnit.Gigahertz)); + unitConverter.SetConversionFunction(FrequencyUnit.Gigahertz, Frequency.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Frequency.BaseUnit, Frequency.BaseUnit, q => q); + unitConverter.SetConversionFunction(Frequency.BaseUnit, FrequencyUnit.Kilohertz, q => q.ToUnit(FrequencyUnit.Kilohertz)); + unitConverter.SetConversionFunction(FrequencyUnit.Kilohertz, Frequency.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Frequency.BaseUnit, FrequencyUnit.Megahertz, q => q.ToUnit(FrequencyUnit.Megahertz)); + unitConverter.SetConversionFunction(FrequencyUnit.Megahertz, Frequency.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Frequency.BaseUnit, FrequencyUnit.RadianPerSecond, q => q.ToUnit(FrequencyUnit.RadianPerSecond)); + unitConverter.SetConversionFunction(FrequencyUnit.RadianPerSecond, Frequency.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Frequency.BaseUnit, FrequencyUnit.Terahertz, q => q.ToUnit(FrequencyUnit.Terahertz)); + unitConverter.SetConversionFunction(FrequencyUnit.Terahertz, Frequency.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.BtuPerHourSquareFoot, q => q.ToUnit(HeatFluxUnit.BtuPerHourSquareFoot)); + unitConverter.SetConversionFunction(HeatFluxUnit.BtuPerHourSquareFoot, HeatFlux.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.BtuPerMinuteSquareFoot, q => q.ToUnit(HeatFluxUnit.BtuPerMinuteSquareFoot)); + unitConverter.SetConversionFunction(HeatFluxUnit.BtuPerMinuteSquareFoot, HeatFlux.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.BtuPerSecondSquareFoot, q => q.ToUnit(HeatFluxUnit.BtuPerSecondSquareFoot)); + unitConverter.SetConversionFunction(HeatFluxUnit.BtuPerSecondSquareFoot, HeatFlux.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.BtuPerSecondSquareInch, q => q.ToUnit(HeatFluxUnit.BtuPerSecondSquareInch)); + unitConverter.SetConversionFunction(HeatFluxUnit.BtuPerSecondSquareInch, HeatFlux.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.CaloriePerSecondSquareCentimeter, q => q.ToUnit(HeatFluxUnit.CaloriePerSecondSquareCentimeter)); + unitConverter.SetConversionFunction(HeatFluxUnit.CaloriePerSecondSquareCentimeter, HeatFlux.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.CentiwattPerSquareMeter, q => q.ToUnit(HeatFluxUnit.CentiwattPerSquareMeter)); + unitConverter.SetConversionFunction(HeatFluxUnit.CentiwattPerSquareMeter, HeatFlux.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.DeciwattPerSquareMeter, q => q.ToUnit(HeatFluxUnit.DeciwattPerSquareMeter)); + unitConverter.SetConversionFunction(HeatFluxUnit.DeciwattPerSquareMeter, HeatFlux.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.KilocaloriePerHourSquareMeter, q => q.ToUnit(HeatFluxUnit.KilocaloriePerHourSquareMeter)); + unitConverter.SetConversionFunction(HeatFluxUnit.KilocaloriePerHourSquareMeter, HeatFlux.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.KilocaloriePerSecondSquareCentimeter, q => q.ToUnit(HeatFluxUnit.KilocaloriePerSecondSquareCentimeter)); + unitConverter.SetConversionFunction(HeatFluxUnit.KilocaloriePerSecondSquareCentimeter, HeatFlux.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.KilowattPerSquareMeter, q => q.ToUnit(HeatFluxUnit.KilowattPerSquareMeter)); + unitConverter.SetConversionFunction(HeatFluxUnit.KilowattPerSquareMeter, HeatFlux.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.MicrowattPerSquareMeter, q => q.ToUnit(HeatFluxUnit.MicrowattPerSquareMeter)); + unitConverter.SetConversionFunction(HeatFluxUnit.MicrowattPerSquareMeter, HeatFlux.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.MilliwattPerSquareMeter, q => q.ToUnit(HeatFluxUnit.MilliwattPerSquareMeter)); + unitConverter.SetConversionFunction(HeatFluxUnit.MilliwattPerSquareMeter, HeatFlux.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.NanowattPerSquareMeter, q => q.ToUnit(HeatFluxUnit.NanowattPerSquareMeter)); + unitConverter.SetConversionFunction(HeatFluxUnit.NanowattPerSquareMeter, HeatFlux.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.PoundForcePerFootSecond, q => q.ToUnit(HeatFluxUnit.PoundForcePerFootSecond)); + unitConverter.SetConversionFunction(HeatFluxUnit.PoundForcePerFootSecond, HeatFlux.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.PoundPerSecondCubed, q => q.ToUnit(HeatFluxUnit.PoundPerSecondCubed)); + unitConverter.SetConversionFunction(HeatFluxUnit.PoundPerSecondCubed, HeatFlux.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.WattPerSquareFoot, q => q.ToUnit(HeatFluxUnit.WattPerSquareFoot)); + unitConverter.SetConversionFunction(HeatFluxUnit.WattPerSquareFoot, HeatFlux.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.WattPerSquareInch, q => q.ToUnit(HeatFluxUnit.WattPerSquareInch)); + unitConverter.SetConversionFunction(HeatFluxUnit.WattPerSquareInch, HeatFlux.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFlux.BaseUnit, q => q); + unitConverter.SetConversionFunction(HeatTransferCoefficient.BaseUnit, HeatTransferCoefficientUnit.WattPerSquareMeterCelsius, q => q.ToUnit(HeatTransferCoefficientUnit.WattPerSquareMeterCelsius)); + unitConverter.SetConversionFunction(HeatTransferCoefficientUnit.WattPerSquareMeterCelsius, HeatTransferCoefficient.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(HeatTransferCoefficient.BaseUnit, HeatTransferCoefficient.BaseUnit, q => q); + unitConverter.SetConversionFunction(Illuminance.BaseUnit, IlluminanceUnit.Kilolux, q => q.ToUnit(IlluminanceUnit.Kilolux)); + unitConverter.SetConversionFunction(IlluminanceUnit.Kilolux, Illuminance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Illuminance.BaseUnit, Illuminance.BaseUnit, q => q); + unitConverter.SetConversionFunction(Illuminance.BaseUnit, IlluminanceUnit.Megalux, q => q.ToUnit(IlluminanceUnit.Megalux)); + unitConverter.SetConversionFunction(IlluminanceUnit.Megalux, Illuminance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Illuminance.BaseUnit, IlluminanceUnit.Millilux, q => q.ToUnit(IlluminanceUnit.Millilux)); + unitConverter.SetConversionFunction(IlluminanceUnit.Millilux, Illuminance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, Information.BaseUnit, q => q); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Byte, q => q.ToUnit(InformationUnit.Byte)); + unitConverter.SetConversionFunction(InformationUnit.Byte, Information.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Exabit, q => q.ToUnit(InformationUnit.Exabit)); + unitConverter.SetConversionFunction(InformationUnit.Exabit, Information.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Exabyte, q => q.ToUnit(InformationUnit.Exabyte)); + unitConverter.SetConversionFunction(InformationUnit.Exabyte, Information.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Exbibit, q => q.ToUnit(InformationUnit.Exbibit)); + unitConverter.SetConversionFunction(InformationUnit.Exbibit, Information.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Exbibyte, q => q.ToUnit(InformationUnit.Exbibyte)); + unitConverter.SetConversionFunction(InformationUnit.Exbibyte, Information.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Gibibit, q => q.ToUnit(InformationUnit.Gibibit)); + unitConverter.SetConversionFunction(InformationUnit.Gibibit, Information.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Gibibyte, q => q.ToUnit(InformationUnit.Gibibyte)); + unitConverter.SetConversionFunction(InformationUnit.Gibibyte, Information.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Gigabit, q => q.ToUnit(InformationUnit.Gigabit)); + unitConverter.SetConversionFunction(InformationUnit.Gigabit, Information.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Gigabyte, q => q.ToUnit(InformationUnit.Gigabyte)); + unitConverter.SetConversionFunction(InformationUnit.Gigabyte, Information.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Kibibit, q => q.ToUnit(InformationUnit.Kibibit)); + unitConverter.SetConversionFunction(InformationUnit.Kibibit, Information.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Kibibyte, q => q.ToUnit(InformationUnit.Kibibyte)); + unitConverter.SetConversionFunction(InformationUnit.Kibibyte, Information.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Kilobit, q => q.ToUnit(InformationUnit.Kilobit)); + unitConverter.SetConversionFunction(InformationUnit.Kilobit, Information.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Kilobyte, q => q.ToUnit(InformationUnit.Kilobyte)); + unitConverter.SetConversionFunction(InformationUnit.Kilobyte, Information.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Mebibit, q => q.ToUnit(InformationUnit.Mebibit)); + unitConverter.SetConversionFunction(InformationUnit.Mebibit, Information.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Mebibyte, q => q.ToUnit(InformationUnit.Mebibyte)); + unitConverter.SetConversionFunction(InformationUnit.Mebibyte, Information.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Megabit, q => q.ToUnit(InformationUnit.Megabit)); + unitConverter.SetConversionFunction(InformationUnit.Megabit, Information.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Megabyte, q => q.ToUnit(InformationUnit.Megabyte)); + unitConverter.SetConversionFunction(InformationUnit.Megabyte, Information.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Pebibit, q => q.ToUnit(InformationUnit.Pebibit)); + unitConverter.SetConversionFunction(InformationUnit.Pebibit, Information.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Pebibyte, q => q.ToUnit(InformationUnit.Pebibyte)); + unitConverter.SetConversionFunction(InformationUnit.Pebibyte, Information.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Petabit, q => q.ToUnit(InformationUnit.Petabit)); + unitConverter.SetConversionFunction(InformationUnit.Petabit, Information.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Petabyte, q => q.ToUnit(InformationUnit.Petabyte)); + unitConverter.SetConversionFunction(InformationUnit.Petabyte, Information.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Tebibit, q => q.ToUnit(InformationUnit.Tebibit)); + unitConverter.SetConversionFunction(InformationUnit.Tebibit, Information.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Tebibyte, q => q.ToUnit(InformationUnit.Tebibyte)); + unitConverter.SetConversionFunction(InformationUnit.Tebibyte, Information.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Terabit, q => q.ToUnit(InformationUnit.Terabit)); + unitConverter.SetConversionFunction(InformationUnit.Terabit, Information.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Information.BaseUnit, InformationUnit.Terabyte, q => q.ToUnit(InformationUnit.Terabyte)); + unitConverter.SetConversionFunction(InformationUnit.Terabyte, Information.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.KilowattPerSquareCentimeter, q => q.ToUnit(IrradianceUnit.KilowattPerSquareCentimeter)); + unitConverter.SetConversionFunction(IrradianceUnit.KilowattPerSquareCentimeter, Irradiance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.KilowattPerSquareMeter, q => q.ToUnit(IrradianceUnit.KilowattPerSquareMeter)); + unitConverter.SetConversionFunction(IrradianceUnit.KilowattPerSquareMeter, Irradiance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.MegawattPerSquareCentimeter, q => q.ToUnit(IrradianceUnit.MegawattPerSquareCentimeter)); + unitConverter.SetConversionFunction(IrradianceUnit.MegawattPerSquareCentimeter, Irradiance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.MegawattPerSquareMeter, q => q.ToUnit(IrradianceUnit.MegawattPerSquareMeter)); + unitConverter.SetConversionFunction(IrradianceUnit.MegawattPerSquareMeter, Irradiance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.MicrowattPerSquareCentimeter, q => q.ToUnit(IrradianceUnit.MicrowattPerSquareCentimeter)); + unitConverter.SetConversionFunction(IrradianceUnit.MicrowattPerSquareCentimeter, Irradiance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.MicrowattPerSquareMeter, q => q.ToUnit(IrradianceUnit.MicrowattPerSquareMeter)); + unitConverter.SetConversionFunction(IrradianceUnit.MicrowattPerSquareMeter, Irradiance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.MilliwattPerSquareCentimeter, q => q.ToUnit(IrradianceUnit.MilliwattPerSquareCentimeter)); + unitConverter.SetConversionFunction(IrradianceUnit.MilliwattPerSquareCentimeter, Irradiance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.MilliwattPerSquareMeter, q => q.ToUnit(IrradianceUnit.MilliwattPerSquareMeter)); + unitConverter.SetConversionFunction(IrradianceUnit.MilliwattPerSquareMeter, Irradiance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.NanowattPerSquareCentimeter, q => q.ToUnit(IrradianceUnit.NanowattPerSquareCentimeter)); + unitConverter.SetConversionFunction(IrradianceUnit.NanowattPerSquareCentimeter, Irradiance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.NanowattPerSquareMeter, q => q.ToUnit(IrradianceUnit.NanowattPerSquareMeter)); + unitConverter.SetConversionFunction(IrradianceUnit.NanowattPerSquareMeter, Irradiance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.PicowattPerSquareCentimeter, q => q.ToUnit(IrradianceUnit.PicowattPerSquareCentimeter)); + unitConverter.SetConversionFunction(IrradianceUnit.PicowattPerSquareCentimeter, Irradiance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.PicowattPerSquareMeter, q => q.ToUnit(IrradianceUnit.PicowattPerSquareMeter)); + unitConverter.SetConversionFunction(IrradianceUnit.PicowattPerSquareMeter, Irradiance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Irradiance.BaseUnit, IrradianceUnit.WattPerSquareCentimeter, q => q.ToUnit(IrradianceUnit.WattPerSquareCentimeter)); + unitConverter.SetConversionFunction(IrradianceUnit.WattPerSquareCentimeter, Irradiance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Irradiance.BaseUnit, Irradiance.BaseUnit, q => q); + unitConverter.SetConversionFunction(Irradiation.BaseUnit, IrradiationUnit.JoulePerSquareCentimeter, q => q.ToUnit(IrradiationUnit.JoulePerSquareCentimeter)); + unitConverter.SetConversionFunction(IrradiationUnit.JoulePerSquareCentimeter, Irradiation.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Irradiation.BaseUnit, Irradiation.BaseUnit, q => q); + unitConverter.SetConversionFunction(Irradiation.BaseUnit, IrradiationUnit.JoulePerSquareMillimeter, q => q.ToUnit(IrradiationUnit.JoulePerSquareMillimeter)); + unitConverter.SetConversionFunction(IrradiationUnit.JoulePerSquareMillimeter, Irradiation.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Irradiation.BaseUnit, IrradiationUnit.KilojoulePerSquareMeter, q => q.ToUnit(IrradiationUnit.KilojoulePerSquareMeter)); + unitConverter.SetConversionFunction(IrradiationUnit.KilojoulePerSquareMeter, Irradiation.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Irradiation.BaseUnit, IrradiationUnit.KilowattHourPerSquareMeter, q => q.ToUnit(IrradiationUnit.KilowattHourPerSquareMeter)); + unitConverter.SetConversionFunction(IrradiationUnit.KilowattHourPerSquareMeter, Irradiation.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Irradiation.BaseUnit, IrradiationUnit.WattHourPerSquareMeter, q => q.ToUnit(IrradiationUnit.WattHourPerSquareMeter)); + unitConverter.SetConversionFunction(IrradiationUnit.WattHourPerSquareMeter, Irradiation.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Centistokes, q => q.ToUnit(KinematicViscosityUnit.Centistokes)); + unitConverter.SetConversionFunction(KinematicViscosityUnit.Centistokes, KinematicViscosity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Decistokes, q => q.ToUnit(KinematicViscosityUnit.Decistokes)); + unitConverter.SetConversionFunction(KinematicViscosityUnit.Decistokes, KinematicViscosity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Kilostokes, q => q.ToUnit(KinematicViscosityUnit.Kilostokes)); + unitConverter.SetConversionFunction(KinematicViscosityUnit.Kilostokes, KinematicViscosity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Microstokes, q => q.ToUnit(KinematicViscosityUnit.Microstokes)); + unitConverter.SetConversionFunction(KinematicViscosityUnit.Microstokes, KinematicViscosity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Millistokes, q => q.ToUnit(KinematicViscosityUnit.Millistokes)); + unitConverter.SetConversionFunction(KinematicViscosityUnit.Millistokes, KinematicViscosity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Nanostokes, q => q.ToUnit(KinematicViscosityUnit.Nanostokes)); + unitConverter.SetConversionFunction(KinematicViscosityUnit.Nanostokes, KinematicViscosity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(KinematicViscosity.BaseUnit, KinematicViscosity.BaseUnit, q => q); + unitConverter.SetConversionFunction(KinematicViscosity.BaseUnit, KinematicViscosityUnit.Stokes, q => q.ToUnit(KinematicViscosityUnit.Stokes)); + unitConverter.SetConversionFunction(KinematicViscosityUnit.Stokes, KinematicViscosity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(LapseRate.BaseUnit, LapseRate.BaseUnit, q => q); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Centimeter, q => q.ToUnit(LengthUnit.Centimeter)); + unitConverter.SetConversionFunction(LengthUnit.Centimeter, Length.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Decimeter, q => q.ToUnit(LengthUnit.Decimeter)); + unitConverter.SetConversionFunction(LengthUnit.Decimeter, Length.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.DtpPica, q => q.ToUnit(LengthUnit.DtpPica)); + unitConverter.SetConversionFunction(LengthUnit.DtpPica, Length.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.DtpPoint, q => q.ToUnit(LengthUnit.DtpPoint)); + unitConverter.SetConversionFunction(LengthUnit.DtpPoint, Length.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Fathom, q => q.ToUnit(LengthUnit.Fathom)); + unitConverter.SetConversionFunction(LengthUnit.Fathom, Length.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Foot, q => q.ToUnit(LengthUnit.Foot)); + unitConverter.SetConversionFunction(LengthUnit.Foot, Length.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Inch, q => q.ToUnit(LengthUnit.Inch)); + unitConverter.SetConversionFunction(LengthUnit.Inch, Length.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Kilometer, q => q.ToUnit(LengthUnit.Kilometer)); + unitConverter.SetConversionFunction(LengthUnit.Kilometer, Length.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, Length.BaseUnit, q => q); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Microinch, q => q.ToUnit(LengthUnit.Microinch)); + unitConverter.SetConversionFunction(LengthUnit.Microinch, Length.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Micrometer, q => q.ToUnit(LengthUnit.Micrometer)); + unitConverter.SetConversionFunction(LengthUnit.Micrometer, Length.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Mil, q => q.ToUnit(LengthUnit.Mil)); + unitConverter.SetConversionFunction(LengthUnit.Mil, Length.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Mile, q => q.ToUnit(LengthUnit.Mile)); + unitConverter.SetConversionFunction(LengthUnit.Mile, Length.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Millimeter, q => q.ToUnit(LengthUnit.Millimeter)); + unitConverter.SetConversionFunction(LengthUnit.Millimeter, Length.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Nanometer, q => q.ToUnit(LengthUnit.Nanometer)); + unitConverter.SetConversionFunction(LengthUnit.Nanometer, Length.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.NauticalMile, q => q.ToUnit(LengthUnit.NauticalMile)); + unitConverter.SetConversionFunction(LengthUnit.NauticalMile, Length.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.PrinterPica, q => q.ToUnit(LengthUnit.PrinterPica)); + unitConverter.SetConversionFunction(LengthUnit.PrinterPica, Length.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.PrinterPoint, q => q.ToUnit(LengthUnit.PrinterPoint)); + unitConverter.SetConversionFunction(LengthUnit.PrinterPoint, Length.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Shackle, q => q.ToUnit(LengthUnit.Shackle)); + unitConverter.SetConversionFunction(LengthUnit.Shackle, Length.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Twip, q => q.ToUnit(LengthUnit.Twip)); + unitConverter.SetConversionFunction(LengthUnit.Twip, Length.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.UsSurveyFoot, q => q.ToUnit(LengthUnit.UsSurveyFoot)); + unitConverter.SetConversionFunction(LengthUnit.UsSurveyFoot, Length.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Length.BaseUnit, LengthUnit.Yard, q => q.ToUnit(LengthUnit.Yard)); + unitConverter.SetConversionFunction(LengthUnit.Yard, Length.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Level.BaseUnit, Level.BaseUnit, q => q); + unitConverter.SetConversionFunction(Level.BaseUnit, LevelUnit.Neper, q => q.ToUnit(LevelUnit.Neper)); + unitConverter.SetConversionFunction(LevelUnit.Neper, Level.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(LinearDensity.BaseUnit, LinearDensityUnit.GramPerMeter, q => q.ToUnit(LinearDensityUnit.GramPerMeter)); + unitConverter.SetConversionFunction(LinearDensityUnit.GramPerMeter, LinearDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(LinearDensity.BaseUnit, LinearDensity.BaseUnit, q => q); + unitConverter.SetConversionFunction(LinearDensity.BaseUnit, LinearDensityUnit.PoundPerFoot, q => q.ToUnit(LinearDensityUnit.PoundPerFoot)); + unitConverter.SetConversionFunction(LinearDensityUnit.PoundPerFoot, LinearDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(LuminousFlux.BaseUnit, LuminousFlux.BaseUnit, q => q); + unitConverter.SetConversionFunction(LuminousIntensity.BaseUnit, LuminousIntensity.BaseUnit, q => q); + unitConverter.SetConversionFunction(MagneticField.BaseUnit, MagneticFieldUnit.Microtesla, q => q.ToUnit(MagneticFieldUnit.Microtesla)); + unitConverter.SetConversionFunction(MagneticFieldUnit.Microtesla, MagneticField.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MagneticField.BaseUnit, MagneticFieldUnit.Millitesla, q => q.ToUnit(MagneticFieldUnit.Millitesla)); + unitConverter.SetConversionFunction(MagneticFieldUnit.Millitesla, MagneticField.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MagneticField.BaseUnit, MagneticFieldUnit.Nanotesla, q => q.ToUnit(MagneticFieldUnit.Nanotesla)); + unitConverter.SetConversionFunction(MagneticFieldUnit.Nanotesla, MagneticField.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MagneticField.BaseUnit, MagneticField.BaseUnit, q => q); + unitConverter.SetConversionFunction(MagneticFlux.BaseUnit, MagneticFlux.BaseUnit, q => q); + unitConverter.SetConversionFunction(Magnetization.BaseUnit, Magnetization.BaseUnit, q => q); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Centigram, q => q.ToUnit(MassUnit.Centigram)); + unitConverter.SetConversionFunction(MassUnit.Centigram, Mass.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Decagram, q => q.ToUnit(MassUnit.Decagram)); + unitConverter.SetConversionFunction(MassUnit.Decagram, Mass.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Decigram, q => q.ToUnit(MassUnit.Decigram)); + unitConverter.SetConversionFunction(MassUnit.Decigram, Mass.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Grain, q => q.ToUnit(MassUnit.Grain)); + unitConverter.SetConversionFunction(MassUnit.Grain, Mass.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Gram, q => q.ToUnit(MassUnit.Gram)); + unitConverter.SetConversionFunction(MassUnit.Gram, Mass.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Hectogram, q => q.ToUnit(MassUnit.Hectogram)); + unitConverter.SetConversionFunction(MassUnit.Hectogram, Mass.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, Mass.BaseUnit, q => q); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Kilopound, q => q.ToUnit(MassUnit.Kilopound)); + unitConverter.SetConversionFunction(MassUnit.Kilopound, Mass.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Kilotonne, q => q.ToUnit(MassUnit.Kilotonne)); + unitConverter.SetConversionFunction(MassUnit.Kilotonne, Mass.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.LongHundredweight, q => q.ToUnit(MassUnit.LongHundredweight)); + unitConverter.SetConversionFunction(MassUnit.LongHundredweight, Mass.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.LongTon, q => q.ToUnit(MassUnit.LongTon)); + unitConverter.SetConversionFunction(MassUnit.LongTon, Mass.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Megapound, q => q.ToUnit(MassUnit.Megapound)); + unitConverter.SetConversionFunction(MassUnit.Megapound, Mass.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Megatonne, q => q.ToUnit(MassUnit.Megatonne)); + unitConverter.SetConversionFunction(MassUnit.Megatonne, Mass.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Microgram, q => q.ToUnit(MassUnit.Microgram)); + unitConverter.SetConversionFunction(MassUnit.Microgram, Mass.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Milligram, q => q.ToUnit(MassUnit.Milligram)); + unitConverter.SetConversionFunction(MassUnit.Milligram, Mass.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Nanogram, q => q.ToUnit(MassUnit.Nanogram)); + unitConverter.SetConversionFunction(MassUnit.Nanogram, Mass.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Ounce, q => q.ToUnit(MassUnit.Ounce)); + unitConverter.SetConversionFunction(MassUnit.Ounce, Mass.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Pound, q => q.ToUnit(MassUnit.Pound)); + unitConverter.SetConversionFunction(MassUnit.Pound, Mass.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.ShortHundredweight, q => q.ToUnit(MassUnit.ShortHundredweight)); + unitConverter.SetConversionFunction(MassUnit.ShortHundredweight, Mass.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.ShortTon, q => q.ToUnit(MassUnit.ShortTon)); + unitConverter.SetConversionFunction(MassUnit.ShortTon, Mass.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Slug, q => q.ToUnit(MassUnit.Slug)); + unitConverter.SetConversionFunction(MassUnit.Slug, Mass.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Stone, q => q.ToUnit(MassUnit.Stone)); + unitConverter.SetConversionFunction(MassUnit.Stone, Mass.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Mass.BaseUnit, MassUnit.Tonne, q => q.ToUnit(MassUnit.Tonne)); + unitConverter.SetConversionFunction(MassUnit.Tonne, Mass.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.CentigramPerDay, q => q.ToUnit(MassFlowUnit.CentigramPerDay)); + unitConverter.SetConversionFunction(MassFlowUnit.CentigramPerDay, MassFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.CentigramPerSecond, q => q.ToUnit(MassFlowUnit.CentigramPerSecond)); + unitConverter.SetConversionFunction(MassFlowUnit.CentigramPerSecond, MassFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.DecagramPerDay, q => q.ToUnit(MassFlowUnit.DecagramPerDay)); + unitConverter.SetConversionFunction(MassFlowUnit.DecagramPerDay, MassFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.DecagramPerSecond, q => q.ToUnit(MassFlowUnit.DecagramPerSecond)); + unitConverter.SetConversionFunction(MassFlowUnit.DecagramPerSecond, MassFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.DecigramPerDay, q => q.ToUnit(MassFlowUnit.DecigramPerDay)); + unitConverter.SetConversionFunction(MassFlowUnit.DecigramPerDay, MassFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.DecigramPerSecond, q => q.ToUnit(MassFlowUnit.DecigramPerSecond)); + unitConverter.SetConversionFunction(MassFlowUnit.DecigramPerSecond, MassFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.GramPerDay, q => q.ToUnit(MassFlowUnit.GramPerDay)); + unitConverter.SetConversionFunction(MassFlowUnit.GramPerDay, MassFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.GramPerHour, q => q.ToUnit(MassFlowUnit.GramPerHour)); + unitConverter.SetConversionFunction(MassFlowUnit.GramPerHour, MassFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlow.BaseUnit, q => q); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.HectogramPerDay, q => q.ToUnit(MassFlowUnit.HectogramPerDay)); + unitConverter.SetConversionFunction(MassFlowUnit.HectogramPerDay, MassFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.HectogramPerSecond, q => q.ToUnit(MassFlowUnit.HectogramPerSecond)); + unitConverter.SetConversionFunction(MassFlowUnit.HectogramPerSecond, MassFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.KilogramPerDay, q => q.ToUnit(MassFlowUnit.KilogramPerDay)); + unitConverter.SetConversionFunction(MassFlowUnit.KilogramPerDay, MassFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.KilogramPerHour, q => q.ToUnit(MassFlowUnit.KilogramPerHour)); + unitConverter.SetConversionFunction(MassFlowUnit.KilogramPerHour, MassFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.KilogramPerMinute, q => q.ToUnit(MassFlowUnit.KilogramPerMinute)); + unitConverter.SetConversionFunction(MassFlowUnit.KilogramPerMinute, MassFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.KilogramPerSecond, q => q.ToUnit(MassFlowUnit.KilogramPerSecond)); + unitConverter.SetConversionFunction(MassFlowUnit.KilogramPerSecond, MassFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MegagramPerDay, q => q.ToUnit(MassFlowUnit.MegagramPerDay)); + unitConverter.SetConversionFunction(MassFlowUnit.MegagramPerDay, MassFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MegapoundPerDay, q => q.ToUnit(MassFlowUnit.MegapoundPerDay)); + unitConverter.SetConversionFunction(MassFlowUnit.MegapoundPerDay, MassFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MegapoundPerHour, q => q.ToUnit(MassFlowUnit.MegapoundPerHour)); + unitConverter.SetConversionFunction(MassFlowUnit.MegapoundPerHour, MassFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MegapoundPerMinute, q => q.ToUnit(MassFlowUnit.MegapoundPerMinute)); + unitConverter.SetConversionFunction(MassFlowUnit.MegapoundPerMinute, MassFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MicrogramPerDay, q => q.ToUnit(MassFlowUnit.MicrogramPerDay)); + unitConverter.SetConversionFunction(MassFlowUnit.MicrogramPerDay, MassFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MicrogramPerSecond, q => q.ToUnit(MassFlowUnit.MicrogramPerSecond)); + unitConverter.SetConversionFunction(MassFlowUnit.MicrogramPerSecond, MassFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MilligramPerDay, q => q.ToUnit(MassFlowUnit.MilligramPerDay)); + unitConverter.SetConversionFunction(MassFlowUnit.MilligramPerDay, MassFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MilligramPerSecond, q => q.ToUnit(MassFlowUnit.MilligramPerSecond)); + unitConverter.SetConversionFunction(MassFlowUnit.MilligramPerSecond, MassFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.NanogramPerDay, q => q.ToUnit(MassFlowUnit.NanogramPerDay)); + unitConverter.SetConversionFunction(MassFlowUnit.NanogramPerDay, MassFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.NanogramPerSecond, q => q.ToUnit(MassFlowUnit.NanogramPerSecond)); + unitConverter.SetConversionFunction(MassFlowUnit.NanogramPerSecond, MassFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.PoundPerDay, q => q.ToUnit(MassFlowUnit.PoundPerDay)); + unitConverter.SetConversionFunction(MassFlowUnit.PoundPerDay, MassFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.PoundPerHour, q => q.ToUnit(MassFlowUnit.PoundPerHour)); + unitConverter.SetConversionFunction(MassFlowUnit.PoundPerHour, MassFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.PoundPerMinute, q => q.ToUnit(MassFlowUnit.PoundPerMinute)); + unitConverter.SetConversionFunction(MassFlowUnit.PoundPerMinute, MassFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.ShortTonPerHour, q => q.ToUnit(MassFlowUnit.ShortTonPerHour)); + unitConverter.SetConversionFunction(MassFlowUnit.ShortTonPerHour, MassFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.TonnePerDay, q => q.ToUnit(MassFlowUnit.TonnePerDay)); + unitConverter.SetConversionFunction(MassFlowUnit.TonnePerDay, MassFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.TonnePerHour, q => q.ToUnit(MassFlowUnit.TonnePerHour)); + unitConverter.SetConversionFunction(MassFlowUnit.TonnePerHour, MassFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassFlux.BaseUnit, MassFluxUnit.GramPerSecondPerSquareMeter, q => q.ToUnit(MassFluxUnit.GramPerSecondPerSquareMeter)); + unitConverter.SetConversionFunction(MassFluxUnit.GramPerSecondPerSquareMeter, MassFlux.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassFlux.BaseUnit, MassFlux.BaseUnit, q => q); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.GramSquareCentimeter, q => q.ToUnit(MassMomentOfInertiaUnit.GramSquareCentimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.GramSquareCentimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.GramSquareDecimeter, q => q.ToUnit(MassMomentOfInertiaUnit.GramSquareDecimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.GramSquareDecimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.GramSquareMeter, q => q.ToUnit(MassMomentOfInertiaUnit.GramSquareMeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.GramSquareMeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.GramSquareMillimeter, q => q.ToUnit(MassMomentOfInertiaUnit.GramSquareMillimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.GramSquareMillimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilogramSquareCentimeter, q => q.ToUnit(MassMomentOfInertiaUnit.KilogramSquareCentimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilogramSquareCentimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilogramSquareDecimeter, q => q.ToUnit(MassMomentOfInertiaUnit.KilogramSquareDecimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilogramSquareDecimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertia.BaseUnit, q => q); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilogramSquareMillimeter, q => q.ToUnit(MassMomentOfInertiaUnit.KilogramSquareMillimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilogramSquareMillimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilotonneSquareCentimeter, q => q.ToUnit(MassMomentOfInertiaUnit.KilotonneSquareCentimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilotonneSquareCentimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilotonneSquareDecimeter, q => q.ToUnit(MassMomentOfInertiaUnit.KilotonneSquareDecimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilotonneSquareDecimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilotonneSquareMeter, q => q.ToUnit(MassMomentOfInertiaUnit.KilotonneSquareMeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilotonneSquareMeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.KilotonneSquareMilimeter, q => q.ToUnit(MassMomentOfInertiaUnit.KilotonneSquareMilimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.KilotonneSquareMilimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MegatonneSquareCentimeter, q => q.ToUnit(MassMomentOfInertiaUnit.MegatonneSquareCentimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MegatonneSquareCentimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MegatonneSquareDecimeter, q => q.ToUnit(MassMomentOfInertiaUnit.MegatonneSquareDecimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MegatonneSquareDecimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MegatonneSquareMeter, q => q.ToUnit(MassMomentOfInertiaUnit.MegatonneSquareMeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MegatonneSquareMeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MegatonneSquareMilimeter, q => q.ToUnit(MassMomentOfInertiaUnit.MegatonneSquareMilimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MegatonneSquareMilimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MilligramSquareCentimeter, q => q.ToUnit(MassMomentOfInertiaUnit.MilligramSquareCentimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MilligramSquareCentimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MilligramSquareDecimeter, q => q.ToUnit(MassMomentOfInertiaUnit.MilligramSquareDecimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MilligramSquareDecimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MilligramSquareMeter, q => q.ToUnit(MassMomentOfInertiaUnit.MilligramSquareMeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MilligramSquareMeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.MilligramSquareMillimeter, q => q.ToUnit(MassMomentOfInertiaUnit.MilligramSquareMillimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.MilligramSquareMillimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.PoundSquareFoot, q => q.ToUnit(MassMomentOfInertiaUnit.PoundSquareFoot)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.PoundSquareFoot, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.PoundSquareInch, q => q.ToUnit(MassMomentOfInertiaUnit.PoundSquareInch)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.PoundSquareInch, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.SlugSquareFoot, q => q.ToUnit(MassMomentOfInertiaUnit.SlugSquareFoot)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.SlugSquareFoot, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.SlugSquareInch, q => q.ToUnit(MassMomentOfInertiaUnit.SlugSquareInch)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.SlugSquareInch, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.TonneSquareCentimeter, q => q.ToUnit(MassMomentOfInertiaUnit.TonneSquareCentimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.TonneSquareCentimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.TonneSquareDecimeter, q => q.ToUnit(MassMomentOfInertiaUnit.TonneSquareDecimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.TonneSquareDecimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.TonneSquareMeter, q => q.ToUnit(MassMomentOfInertiaUnit.TonneSquareMeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.TonneSquareMeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassMomentOfInertia.BaseUnit, MassMomentOfInertiaUnit.TonneSquareMilimeter, q => q.ToUnit(MassMomentOfInertiaUnit.TonneSquareMilimeter)); + unitConverter.SetConversionFunction(MassMomentOfInertiaUnit.TonneSquareMilimeter, MassMomentOfInertia.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MolarEnergy.BaseUnit, MolarEnergy.BaseUnit, q => q); + unitConverter.SetConversionFunction(MolarEnergy.BaseUnit, MolarEnergyUnit.KilojoulePerMole, q => q.ToUnit(MolarEnergyUnit.KilojoulePerMole)); + unitConverter.SetConversionFunction(MolarEnergyUnit.KilojoulePerMole, MolarEnergy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MolarEnergy.BaseUnit, MolarEnergyUnit.MegajoulePerMole, q => q.ToUnit(MolarEnergyUnit.MegajoulePerMole)); + unitConverter.SetConversionFunction(MolarEnergyUnit.MegajoulePerMole, MolarEnergy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MolarEntropy.BaseUnit, MolarEntropy.BaseUnit, q => q); + unitConverter.SetConversionFunction(MolarEntropy.BaseUnit, MolarEntropyUnit.KilojoulePerMoleKelvin, q => q.ToUnit(MolarEntropyUnit.KilojoulePerMoleKelvin)); + unitConverter.SetConversionFunction(MolarEntropyUnit.KilojoulePerMoleKelvin, MolarEntropy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MolarEntropy.BaseUnit, MolarEntropyUnit.MegajoulePerMoleKelvin, q => q.ToUnit(MolarEntropyUnit.MegajoulePerMoleKelvin)); + unitConverter.SetConversionFunction(MolarEntropyUnit.MegajoulePerMoleKelvin, MolarEntropy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Molarity.BaseUnit, MolarityUnit.CentimolesPerLiter, q => q.ToUnit(MolarityUnit.CentimolesPerLiter)); + unitConverter.SetConversionFunction(MolarityUnit.CentimolesPerLiter, Molarity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Molarity.BaseUnit, MolarityUnit.DecimolesPerLiter, q => q.ToUnit(MolarityUnit.DecimolesPerLiter)); + unitConverter.SetConversionFunction(MolarityUnit.DecimolesPerLiter, Molarity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Molarity.BaseUnit, MolarityUnit.MicromolesPerLiter, q => q.ToUnit(MolarityUnit.MicromolesPerLiter)); + unitConverter.SetConversionFunction(MolarityUnit.MicromolesPerLiter, Molarity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Molarity.BaseUnit, MolarityUnit.MillimolesPerLiter, q => q.ToUnit(MolarityUnit.MillimolesPerLiter)); + unitConverter.SetConversionFunction(MolarityUnit.MillimolesPerLiter, Molarity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Molarity.BaseUnit, Molarity.BaseUnit, q => q); + unitConverter.SetConversionFunction(Molarity.BaseUnit, MolarityUnit.MolesPerLiter, q => q.ToUnit(MolarityUnit.MolesPerLiter)); + unitConverter.SetConversionFunction(MolarityUnit.MolesPerLiter, Molarity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Molarity.BaseUnit, MolarityUnit.NanomolesPerLiter, q => q.ToUnit(MolarityUnit.NanomolesPerLiter)); + unitConverter.SetConversionFunction(MolarityUnit.NanomolesPerLiter, Molarity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Molarity.BaseUnit, MolarityUnit.PicomolesPerLiter, q => q.ToUnit(MolarityUnit.PicomolesPerLiter)); + unitConverter.SetConversionFunction(MolarityUnit.PicomolesPerLiter, Molarity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.CentigramPerMole, q => q.ToUnit(MolarMassUnit.CentigramPerMole)); + unitConverter.SetConversionFunction(MolarMassUnit.CentigramPerMole, MolarMass.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.DecagramPerMole, q => q.ToUnit(MolarMassUnit.DecagramPerMole)); + unitConverter.SetConversionFunction(MolarMassUnit.DecagramPerMole, MolarMass.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.DecigramPerMole, q => q.ToUnit(MolarMassUnit.DecigramPerMole)); + unitConverter.SetConversionFunction(MolarMassUnit.DecigramPerMole, MolarMass.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.GramPerMole, q => q.ToUnit(MolarMassUnit.GramPerMole)); + unitConverter.SetConversionFunction(MolarMassUnit.GramPerMole, MolarMass.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.HectogramPerMole, q => q.ToUnit(MolarMassUnit.HectogramPerMole)); + unitConverter.SetConversionFunction(MolarMassUnit.HectogramPerMole, MolarMass.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMass.BaseUnit, q => q); + unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.KilopoundPerMole, q => q.ToUnit(MolarMassUnit.KilopoundPerMole)); + unitConverter.SetConversionFunction(MolarMassUnit.KilopoundPerMole, MolarMass.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.MegapoundPerMole, q => q.ToUnit(MolarMassUnit.MegapoundPerMole)); + unitConverter.SetConversionFunction(MolarMassUnit.MegapoundPerMole, MolarMass.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.MicrogramPerMole, q => q.ToUnit(MolarMassUnit.MicrogramPerMole)); + unitConverter.SetConversionFunction(MolarMassUnit.MicrogramPerMole, MolarMass.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.MilligramPerMole, q => q.ToUnit(MolarMassUnit.MilligramPerMole)); + unitConverter.SetConversionFunction(MolarMassUnit.MilligramPerMole, MolarMass.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.NanogramPerMole, q => q.ToUnit(MolarMassUnit.NanogramPerMole)); + unitConverter.SetConversionFunction(MolarMassUnit.NanogramPerMole, MolarMass.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MolarMass.BaseUnit, MolarMassUnit.PoundPerMole, q => q.ToUnit(MolarMassUnit.PoundPerMole)); + unitConverter.SetConversionFunction(MolarMassUnit.PoundPerMole, MolarMass.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Permeability.BaseUnit, Permeability.BaseUnit, q => q); + unitConverter.SetConversionFunction(Permittivity.BaseUnit, Permittivity.BaseUnit, q => q); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.BoilerHorsepower, q => q.ToUnit(PowerUnit.BoilerHorsepower)); + unitConverter.SetConversionFunction(PowerUnit.BoilerHorsepower, Power.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.BritishThermalUnitPerHour, q => q.ToUnit(PowerUnit.BritishThermalUnitPerHour)); + unitConverter.SetConversionFunction(PowerUnit.BritishThermalUnitPerHour, Power.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Decawatt, q => q.ToUnit(PowerUnit.Decawatt)); + unitConverter.SetConversionFunction(PowerUnit.Decawatt, Power.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Deciwatt, q => q.ToUnit(PowerUnit.Deciwatt)); + unitConverter.SetConversionFunction(PowerUnit.Deciwatt, Power.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.ElectricalHorsepower, q => q.ToUnit(PowerUnit.ElectricalHorsepower)); + unitConverter.SetConversionFunction(PowerUnit.ElectricalHorsepower, Power.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Femtowatt, q => q.ToUnit(PowerUnit.Femtowatt)); + unitConverter.SetConversionFunction(PowerUnit.Femtowatt, Power.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Gigawatt, q => q.ToUnit(PowerUnit.Gigawatt)); + unitConverter.SetConversionFunction(PowerUnit.Gigawatt, Power.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.HydraulicHorsepower, q => q.ToUnit(PowerUnit.HydraulicHorsepower)); + unitConverter.SetConversionFunction(PowerUnit.HydraulicHorsepower, Power.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.KilobritishThermalUnitPerHour, q => q.ToUnit(PowerUnit.KilobritishThermalUnitPerHour)); + unitConverter.SetConversionFunction(PowerUnit.KilobritishThermalUnitPerHour, Power.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Kilowatt, q => q.ToUnit(PowerUnit.Kilowatt)); + unitConverter.SetConversionFunction(PowerUnit.Kilowatt, Power.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.MechanicalHorsepower, q => q.ToUnit(PowerUnit.MechanicalHorsepower)); + unitConverter.SetConversionFunction(PowerUnit.MechanicalHorsepower, Power.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Megawatt, q => q.ToUnit(PowerUnit.Megawatt)); + unitConverter.SetConversionFunction(PowerUnit.Megawatt, Power.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.MetricHorsepower, q => q.ToUnit(PowerUnit.MetricHorsepower)); + unitConverter.SetConversionFunction(PowerUnit.MetricHorsepower, Power.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Microwatt, q => q.ToUnit(PowerUnit.Microwatt)); + unitConverter.SetConversionFunction(PowerUnit.Microwatt, Power.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Milliwatt, q => q.ToUnit(PowerUnit.Milliwatt)); + unitConverter.SetConversionFunction(PowerUnit.Milliwatt, Power.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Nanowatt, q => q.ToUnit(PowerUnit.Nanowatt)); + unitConverter.SetConversionFunction(PowerUnit.Nanowatt, Power.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Petawatt, q => q.ToUnit(PowerUnit.Petawatt)); + unitConverter.SetConversionFunction(PowerUnit.Petawatt, Power.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Picowatt, q => q.ToUnit(PowerUnit.Picowatt)); + unitConverter.SetConversionFunction(PowerUnit.Picowatt, Power.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, PowerUnit.Terawatt, q => q.ToUnit(PowerUnit.Terawatt)); + unitConverter.SetConversionFunction(PowerUnit.Terawatt, Power.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Power.BaseUnit, Power.BaseUnit, q => q); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.DecawattPerCubicFoot, q => q.ToUnit(PowerDensityUnit.DecawattPerCubicFoot)); + unitConverter.SetConversionFunction(PowerDensityUnit.DecawattPerCubicFoot, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.DecawattPerCubicInch, q => q.ToUnit(PowerDensityUnit.DecawattPerCubicInch)); + unitConverter.SetConversionFunction(PowerDensityUnit.DecawattPerCubicInch, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.DecawattPerCubicMeter, q => q.ToUnit(PowerDensityUnit.DecawattPerCubicMeter)); + unitConverter.SetConversionFunction(PowerDensityUnit.DecawattPerCubicMeter, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.DecawattPerLiter, q => q.ToUnit(PowerDensityUnit.DecawattPerLiter)); + unitConverter.SetConversionFunction(PowerDensityUnit.DecawattPerLiter, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.DeciwattPerCubicFoot, q => q.ToUnit(PowerDensityUnit.DeciwattPerCubicFoot)); + unitConverter.SetConversionFunction(PowerDensityUnit.DeciwattPerCubicFoot, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.DeciwattPerCubicInch, q => q.ToUnit(PowerDensityUnit.DeciwattPerCubicInch)); + unitConverter.SetConversionFunction(PowerDensityUnit.DeciwattPerCubicInch, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.DeciwattPerCubicMeter, q => q.ToUnit(PowerDensityUnit.DeciwattPerCubicMeter)); + unitConverter.SetConversionFunction(PowerDensityUnit.DeciwattPerCubicMeter, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.DeciwattPerLiter, q => q.ToUnit(PowerDensityUnit.DeciwattPerLiter)); + unitConverter.SetConversionFunction(PowerDensityUnit.DeciwattPerLiter, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.GigawattPerCubicFoot, q => q.ToUnit(PowerDensityUnit.GigawattPerCubicFoot)); + unitConverter.SetConversionFunction(PowerDensityUnit.GigawattPerCubicFoot, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.GigawattPerCubicInch, q => q.ToUnit(PowerDensityUnit.GigawattPerCubicInch)); + unitConverter.SetConversionFunction(PowerDensityUnit.GigawattPerCubicInch, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.GigawattPerCubicMeter, q => q.ToUnit(PowerDensityUnit.GigawattPerCubicMeter)); + unitConverter.SetConversionFunction(PowerDensityUnit.GigawattPerCubicMeter, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.GigawattPerLiter, q => q.ToUnit(PowerDensityUnit.GigawattPerLiter)); + unitConverter.SetConversionFunction(PowerDensityUnit.GigawattPerLiter, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.KilowattPerCubicFoot, q => q.ToUnit(PowerDensityUnit.KilowattPerCubicFoot)); + unitConverter.SetConversionFunction(PowerDensityUnit.KilowattPerCubicFoot, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.KilowattPerCubicInch, q => q.ToUnit(PowerDensityUnit.KilowattPerCubicInch)); + unitConverter.SetConversionFunction(PowerDensityUnit.KilowattPerCubicInch, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.KilowattPerCubicMeter, q => q.ToUnit(PowerDensityUnit.KilowattPerCubicMeter)); + unitConverter.SetConversionFunction(PowerDensityUnit.KilowattPerCubicMeter, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.KilowattPerLiter, q => q.ToUnit(PowerDensityUnit.KilowattPerLiter)); + unitConverter.SetConversionFunction(PowerDensityUnit.KilowattPerLiter, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MegawattPerCubicFoot, q => q.ToUnit(PowerDensityUnit.MegawattPerCubicFoot)); + unitConverter.SetConversionFunction(PowerDensityUnit.MegawattPerCubicFoot, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MegawattPerCubicInch, q => q.ToUnit(PowerDensityUnit.MegawattPerCubicInch)); + unitConverter.SetConversionFunction(PowerDensityUnit.MegawattPerCubicInch, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MegawattPerCubicMeter, q => q.ToUnit(PowerDensityUnit.MegawattPerCubicMeter)); + unitConverter.SetConversionFunction(PowerDensityUnit.MegawattPerCubicMeter, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MegawattPerLiter, q => q.ToUnit(PowerDensityUnit.MegawattPerLiter)); + unitConverter.SetConversionFunction(PowerDensityUnit.MegawattPerLiter, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MicrowattPerCubicFoot, q => q.ToUnit(PowerDensityUnit.MicrowattPerCubicFoot)); + unitConverter.SetConversionFunction(PowerDensityUnit.MicrowattPerCubicFoot, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MicrowattPerCubicInch, q => q.ToUnit(PowerDensityUnit.MicrowattPerCubicInch)); + unitConverter.SetConversionFunction(PowerDensityUnit.MicrowattPerCubicInch, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MicrowattPerCubicMeter, q => q.ToUnit(PowerDensityUnit.MicrowattPerCubicMeter)); + unitConverter.SetConversionFunction(PowerDensityUnit.MicrowattPerCubicMeter, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MicrowattPerLiter, q => q.ToUnit(PowerDensityUnit.MicrowattPerLiter)); + unitConverter.SetConversionFunction(PowerDensityUnit.MicrowattPerLiter, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MilliwattPerCubicFoot, q => q.ToUnit(PowerDensityUnit.MilliwattPerCubicFoot)); + unitConverter.SetConversionFunction(PowerDensityUnit.MilliwattPerCubicFoot, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MilliwattPerCubicInch, q => q.ToUnit(PowerDensityUnit.MilliwattPerCubicInch)); + unitConverter.SetConversionFunction(PowerDensityUnit.MilliwattPerCubicInch, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MilliwattPerCubicMeter, q => q.ToUnit(PowerDensityUnit.MilliwattPerCubicMeter)); + unitConverter.SetConversionFunction(PowerDensityUnit.MilliwattPerCubicMeter, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.MilliwattPerLiter, q => q.ToUnit(PowerDensityUnit.MilliwattPerLiter)); + unitConverter.SetConversionFunction(PowerDensityUnit.MilliwattPerLiter, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.NanowattPerCubicFoot, q => q.ToUnit(PowerDensityUnit.NanowattPerCubicFoot)); + unitConverter.SetConversionFunction(PowerDensityUnit.NanowattPerCubicFoot, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.NanowattPerCubicInch, q => q.ToUnit(PowerDensityUnit.NanowattPerCubicInch)); + unitConverter.SetConversionFunction(PowerDensityUnit.NanowattPerCubicInch, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.NanowattPerCubicMeter, q => q.ToUnit(PowerDensityUnit.NanowattPerCubicMeter)); + unitConverter.SetConversionFunction(PowerDensityUnit.NanowattPerCubicMeter, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.NanowattPerLiter, q => q.ToUnit(PowerDensityUnit.NanowattPerLiter)); + unitConverter.SetConversionFunction(PowerDensityUnit.NanowattPerLiter, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.PicowattPerCubicFoot, q => q.ToUnit(PowerDensityUnit.PicowattPerCubicFoot)); + unitConverter.SetConversionFunction(PowerDensityUnit.PicowattPerCubicFoot, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.PicowattPerCubicInch, q => q.ToUnit(PowerDensityUnit.PicowattPerCubicInch)); + unitConverter.SetConversionFunction(PowerDensityUnit.PicowattPerCubicInch, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.PicowattPerCubicMeter, q => q.ToUnit(PowerDensityUnit.PicowattPerCubicMeter)); + unitConverter.SetConversionFunction(PowerDensityUnit.PicowattPerCubicMeter, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.PicowattPerLiter, q => q.ToUnit(PowerDensityUnit.PicowattPerLiter)); + unitConverter.SetConversionFunction(PowerDensityUnit.PicowattPerLiter, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.TerawattPerCubicFoot, q => q.ToUnit(PowerDensityUnit.TerawattPerCubicFoot)); + unitConverter.SetConversionFunction(PowerDensityUnit.TerawattPerCubicFoot, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.TerawattPerCubicInch, q => q.ToUnit(PowerDensityUnit.TerawattPerCubicInch)); + unitConverter.SetConversionFunction(PowerDensityUnit.TerawattPerCubicInch, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.TerawattPerCubicMeter, q => q.ToUnit(PowerDensityUnit.TerawattPerCubicMeter)); + unitConverter.SetConversionFunction(PowerDensityUnit.TerawattPerCubicMeter, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.TerawattPerLiter, q => q.ToUnit(PowerDensityUnit.TerawattPerLiter)); + unitConverter.SetConversionFunction(PowerDensityUnit.TerawattPerLiter, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.WattPerCubicFoot, q => q.ToUnit(PowerDensityUnit.WattPerCubicFoot)); + unitConverter.SetConversionFunction(PowerDensityUnit.WattPerCubicFoot, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.WattPerCubicInch, q => q.ToUnit(PowerDensityUnit.WattPerCubicInch)); + unitConverter.SetConversionFunction(PowerDensityUnit.WattPerCubicInch, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensity.BaseUnit, q => q); + unitConverter.SetConversionFunction(PowerDensity.BaseUnit, PowerDensityUnit.WattPerLiter, q => q.ToUnit(PowerDensityUnit.WattPerLiter)); + unitConverter.SetConversionFunction(PowerDensityUnit.WattPerLiter, PowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerRatio.BaseUnit, PowerRatioUnit.DecibelMilliwatt, q => q.ToUnit(PowerRatioUnit.DecibelMilliwatt)); + unitConverter.SetConversionFunction(PowerRatioUnit.DecibelMilliwatt, PowerRatio.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PowerRatio.BaseUnit, PowerRatio.BaseUnit, q => q); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Atmosphere, q => q.ToUnit(PressureUnit.Atmosphere)); + unitConverter.SetConversionFunction(PressureUnit.Atmosphere, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Bar, q => q.ToUnit(PressureUnit.Bar)); + unitConverter.SetConversionFunction(PressureUnit.Bar, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Centibar, q => q.ToUnit(PressureUnit.Centibar)); + unitConverter.SetConversionFunction(PressureUnit.Centibar, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Decapascal, q => q.ToUnit(PressureUnit.Decapascal)); + unitConverter.SetConversionFunction(PressureUnit.Decapascal, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Decibar, q => q.ToUnit(PressureUnit.Decibar)); + unitConverter.SetConversionFunction(PressureUnit.Decibar, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.DynePerSquareCentimeter, q => q.ToUnit(PressureUnit.DynePerSquareCentimeter)); + unitConverter.SetConversionFunction(PressureUnit.DynePerSquareCentimeter, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.FootOfHead, q => q.ToUnit(PressureUnit.FootOfHead)); + unitConverter.SetConversionFunction(PressureUnit.FootOfHead, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Gigapascal, q => q.ToUnit(PressureUnit.Gigapascal)); + unitConverter.SetConversionFunction(PressureUnit.Gigapascal, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Hectopascal, q => q.ToUnit(PressureUnit.Hectopascal)); + unitConverter.SetConversionFunction(PressureUnit.Hectopascal, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.InchOfMercury, q => q.ToUnit(PressureUnit.InchOfMercury)); + unitConverter.SetConversionFunction(PressureUnit.InchOfMercury, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.InchOfWaterColumn, q => q.ToUnit(PressureUnit.InchOfWaterColumn)); + unitConverter.SetConversionFunction(PressureUnit.InchOfWaterColumn, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Kilobar, q => q.ToUnit(PressureUnit.Kilobar)); + unitConverter.SetConversionFunction(PressureUnit.Kilobar, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.KilogramForcePerSquareCentimeter, q => q.ToUnit(PressureUnit.KilogramForcePerSquareCentimeter)); + unitConverter.SetConversionFunction(PressureUnit.KilogramForcePerSquareCentimeter, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.KilogramForcePerSquareMeter, q => q.ToUnit(PressureUnit.KilogramForcePerSquareMeter)); + unitConverter.SetConversionFunction(PressureUnit.KilogramForcePerSquareMeter, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.KilogramForcePerSquareMillimeter, q => q.ToUnit(PressureUnit.KilogramForcePerSquareMillimeter)); + unitConverter.SetConversionFunction(PressureUnit.KilogramForcePerSquareMillimeter, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.KilonewtonPerSquareCentimeter, q => q.ToUnit(PressureUnit.KilonewtonPerSquareCentimeter)); + unitConverter.SetConversionFunction(PressureUnit.KilonewtonPerSquareCentimeter, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.KilonewtonPerSquareMeter, q => q.ToUnit(PressureUnit.KilonewtonPerSquareMeter)); + unitConverter.SetConversionFunction(PressureUnit.KilonewtonPerSquareMeter, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.KilonewtonPerSquareMillimeter, q => q.ToUnit(PressureUnit.KilonewtonPerSquareMillimeter)); + unitConverter.SetConversionFunction(PressureUnit.KilonewtonPerSquareMillimeter, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Kilopascal, q => q.ToUnit(PressureUnit.Kilopascal)); + unitConverter.SetConversionFunction(PressureUnit.Kilopascal, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.KilopoundForcePerSquareFoot, q => q.ToUnit(PressureUnit.KilopoundForcePerSquareFoot)); + unitConverter.SetConversionFunction(PressureUnit.KilopoundForcePerSquareFoot, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.KilopoundForcePerSquareInch, q => q.ToUnit(PressureUnit.KilopoundForcePerSquareInch)); + unitConverter.SetConversionFunction(PressureUnit.KilopoundForcePerSquareInch, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Megabar, q => q.ToUnit(PressureUnit.Megabar)); + unitConverter.SetConversionFunction(PressureUnit.Megabar, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.MeganewtonPerSquareMeter, q => q.ToUnit(PressureUnit.MeganewtonPerSquareMeter)); + unitConverter.SetConversionFunction(PressureUnit.MeganewtonPerSquareMeter, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Megapascal, q => q.ToUnit(PressureUnit.Megapascal)); + unitConverter.SetConversionFunction(PressureUnit.Megapascal, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.MeterOfHead, q => q.ToUnit(PressureUnit.MeterOfHead)); + unitConverter.SetConversionFunction(PressureUnit.MeterOfHead, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Microbar, q => q.ToUnit(PressureUnit.Microbar)); + unitConverter.SetConversionFunction(PressureUnit.Microbar, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Micropascal, q => q.ToUnit(PressureUnit.Micropascal)); + unitConverter.SetConversionFunction(PressureUnit.Micropascal, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Millibar, q => q.ToUnit(PressureUnit.Millibar)); + unitConverter.SetConversionFunction(PressureUnit.Millibar, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.MillimeterOfMercury, q => q.ToUnit(PressureUnit.MillimeterOfMercury)); + unitConverter.SetConversionFunction(PressureUnit.MillimeterOfMercury, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Millipascal, q => q.ToUnit(PressureUnit.Millipascal)); + unitConverter.SetConversionFunction(PressureUnit.Millipascal, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.NewtonPerSquareCentimeter, q => q.ToUnit(PressureUnit.NewtonPerSquareCentimeter)); + unitConverter.SetConversionFunction(PressureUnit.NewtonPerSquareCentimeter, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.NewtonPerSquareMeter, q => q.ToUnit(PressureUnit.NewtonPerSquareMeter)); + unitConverter.SetConversionFunction(PressureUnit.NewtonPerSquareMeter, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.NewtonPerSquareMillimeter, q => q.ToUnit(PressureUnit.NewtonPerSquareMillimeter)); + unitConverter.SetConversionFunction(PressureUnit.NewtonPerSquareMillimeter, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, Pressure.BaseUnit, q => q); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.PoundForcePerSquareFoot, q => q.ToUnit(PressureUnit.PoundForcePerSquareFoot)); + unitConverter.SetConversionFunction(PressureUnit.PoundForcePerSquareFoot, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.PoundForcePerSquareInch, q => q.ToUnit(PressureUnit.PoundForcePerSquareInch)); + unitConverter.SetConversionFunction(PressureUnit.PoundForcePerSquareInch, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.PoundPerInchSecondSquared, q => q.ToUnit(PressureUnit.PoundPerInchSecondSquared)); + unitConverter.SetConversionFunction(PressureUnit.PoundPerInchSecondSquared, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.TechnicalAtmosphere, q => q.ToUnit(PressureUnit.TechnicalAtmosphere)); + unitConverter.SetConversionFunction(PressureUnit.TechnicalAtmosphere, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.TonneForcePerSquareCentimeter, q => q.ToUnit(PressureUnit.TonneForcePerSquareCentimeter)); + unitConverter.SetConversionFunction(PressureUnit.TonneForcePerSquareCentimeter, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.TonneForcePerSquareMeter, q => q.ToUnit(PressureUnit.TonneForcePerSquareMeter)); + unitConverter.SetConversionFunction(PressureUnit.TonneForcePerSquareMeter, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.TonneForcePerSquareMillimeter, q => q.ToUnit(PressureUnit.TonneForcePerSquareMillimeter)); + unitConverter.SetConversionFunction(PressureUnit.TonneForcePerSquareMillimeter, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Pressure.BaseUnit, PressureUnit.Torr, q => q.ToUnit(PressureUnit.Torr)); + unitConverter.SetConversionFunction(PressureUnit.Torr, Pressure.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.AtmospherePerSecond, q => q.ToUnit(PressureChangeRateUnit.AtmospherePerSecond)); + unitConverter.SetConversionFunction(PressureChangeRateUnit.AtmospherePerSecond, PressureChangeRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.KilopascalPerMinute, q => q.ToUnit(PressureChangeRateUnit.KilopascalPerMinute)); + unitConverter.SetConversionFunction(PressureChangeRateUnit.KilopascalPerMinute, PressureChangeRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.KilopascalPerSecond, q => q.ToUnit(PressureChangeRateUnit.KilopascalPerSecond)); + unitConverter.SetConversionFunction(PressureChangeRateUnit.KilopascalPerSecond, PressureChangeRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.MegapascalPerMinute, q => q.ToUnit(PressureChangeRateUnit.MegapascalPerMinute)); + unitConverter.SetConversionFunction(PressureChangeRateUnit.MegapascalPerMinute, PressureChangeRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.MegapascalPerSecond, q => q.ToUnit(PressureChangeRateUnit.MegapascalPerSecond)); + unitConverter.SetConversionFunction(PressureChangeRateUnit.MegapascalPerSecond, PressureChangeRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.PascalPerMinute, q => q.ToUnit(PressureChangeRateUnit.PascalPerMinute)); + unitConverter.SetConversionFunction(PressureChangeRateUnit.PascalPerMinute, PressureChangeRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRate.BaseUnit, q => q); + unitConverter.SetConversionFunction(Ratio.BaseUnit, Ratio.BaseUnit, q => q); + unitConverter.SetConversionFunction(Ratio.BaseUnit, RatioUnit.PartPerBillion, q => q.ToUnit(RatioUnit.PartPerBillion)); + unitConverter.SetConversionFunction(RatioUnit.PartPerBillion, Ratio.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Ratio.BaseUnit, RatioUnit.PartPerMillion, q => q.ToUnit(RatioUnit.PartPerMillion)); + unitConverter.SetConversionFunction(RatioUnit.PartPerMillion, Ratio.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Ratio.BaseUnit, RatioUnit.PartPerThousand, q => q.ToUnit(RatioUnit.PartPerThousand)); + unitConverter.SetConversionFunction(RatioUnit.PartPerThousand, Ratio.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Ratio.BaseUnit, RatioUnit.PartPerTrillion, q => q.ToUnit(RatioUnit.PartPerTrillion)); + unitConverter.SetConversionFunction(RatioUnit.PartPerTrillion, Ratio.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Ratio.BaseUnit, RatioUnit.Percent, q => q.ToUnit(RatioUnit.Percent)); + unitConverter.SetConversionFunction(RatioUnit.Percent, Ratio.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ReactiveEnergy.BaseUnit, ReactiveEnergyUnit.KilovoltampereReactiveHour, q => q.ToUnit(ReactiveEnergyUnit.KilovoltampereReactiveHour)); + unitConverter.SetConversionFunction(ReactiveEnergyUnit.KilovoltampereReactiveHour, ReactiveEnergy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ReactiveEnergy.BaseUnit, ReactiveEnergyUnit.MegavoltampereReactiveHour, q => q.ToUnit(ReactiveEnergyUnit.MegavoltampereReactiveHour)); + unitConverter.SetConversionFunction(ReactiveEnergyUnit.MegavoltampereReactiveHour, ReactiveEnergy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ReactiveEnergy.BaseUnit, ReactiveEnergy.BaseUnit, q => q); + unitConverter.SetConversionFunction(ReactivePower.BaseUnit, ReactivePowerUnit.GigavoltampereReactive, q => q.ToUnit(ReactivePowerUnit.GigavoltampereReactive)); + unitConverter.SetConversionFunction(ReactivePowerUnit.GigavoltampereReactive, ReactivePower.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ReactivePower.BaseUnit, ReactivePowerUnit.KilovoltampereReactive, q => q.ToUnit(ReactivePowerUnit.KilovoltampereReactive)); + unitConverter.SetConversionFunction(ReactivePowerUnit.KilovoltampereReactive, ReactivePower.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ReactivePower.BaseUnit, ReactivePowerUnit.MegavoltampereReactive, q => q.ToUnit(ReactivePowerUnit.MegavoltampereReactive)); + unitConverter.SetConversionFunction(ReactivePowerUnit.MegavoltampereReactive, ReactivePower.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ReactivePower.BaseUnit, ReactivePower.BaseUnit, q => q); + unitConverter.SetConversionFunction(RotationalAcceleration.BaseUnit, RotationalAccelerationUnit.DegreePerSecondSquared, q => q.ToUnit(RotationalAccelerationUnit.DegreePerSecondSquared)); + unitConverter.SetConversionFunction(RotationalAccelerationUnit.DegreePerSecondSquared, RotationalAcceleration.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(RotationalAcceleration.BaseUnit, RotationalAcceleration.BaseUnit, q => q); + unitConverter.SetConversionFunction(RotationalAcceleration.BaseUnit, RotationalAccelerationUnit.RevolutionPerMinutePerSecond, q => q.ToUnit(RotationalAccelerationUnit.RevolutionPerMinutePerSecond)); + unitConverter.SetConversionFunction(RotationalAccelerationUnit.RevolutionPerMinutePerSecond, RotationalAcceleration.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.CentiradianPerSecond, q => q.ToUnit(RotationalSpeedUnit.CentiradianPerSecond)); + unitConverter.SetConversionFunction(RotationalSpeedUnit.CentiradianPerSecond, RotationalSpeed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.DeciradianPerSecond, q => q.ToUnit(RotationalSpeedUnit.DeciradianPerSecond)); + unitConverter.SetConversionFunction(RotationalSpeedUnit.DeciradianPerSecond, RotationalSpeed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.DegreePerMinute, q => q.ToUnit(RotationalSpeedUnit.DegreePerMinute)); + unitConverter.SetConversionFunction(RotationalSpeedUnit.DegreePerMinute, RotationalSpeed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.DegreePerSecond, q => q.ToUnit(RotationalSpeedUnit.DegreePerSecond)); + unitConverter.SetConversionFunction(RotationalSpeedUnit.DegreePerSecond, RotationalSpeed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.MicrodegreePerSecond, q => q.ToUnit(RotationalSpeedUnit.MicrodegreePerSecond)); + unitConverter.SetConversionFunction(RotationalSpeedUnit.MicrodegreePerSecond, RotationalSpeed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.MicroradianPerSecond, q => q.ToUnit(RotationalSpeedUnit.MicroradianPerSecond)); + unitConverter.SetConversionFunction(RotationalSpeedUnit.MicroradianPerSecond, RotationalSpeed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.MillidegreePerSecond, q => q.ToUnit(RotationalSpeedUnit.MillidegreePerSecond)); + unitConverter.SetConversionFunction(RotationalSpeedUnit.MillidegreePerSecond, RotationalSpeed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.MilliradianPerSecond, q => q.ToUnit(RotationalSpeedUnit.MilliradianPerSecond)); + unitConverter.SetConversionFunction(RotationalSpeedUnit.MilliradianPerSecond, RotationalSpeed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.NanodegreePerSecond, q => q.ToUnit(RotationalSpeedUnit.NanodegreePerSecond)); + unitConverter.SetConversionFunction(RotationalSpeedUnit.NanodegreePerSecond, RotationalSpeed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.NanoradianPerSecond, q => q.ToUnit(RotationalSpeedUnit.NanoradianPerSecond)); + unitConverter.SetConversionFunction(RotationalSpeedUnit.NanoradianPerSecond, RotationalSpeed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeed.BaseUnit, q => q); + unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.RevolutionPerMinute, q => q.ToUnit(RotationalSpeedUnit.RevolutionPerMinute)); + unitConverter.SetConversionFunction(RotationalSpeedUnit.RevolutionPerMinute, RotationalSpeed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.RevolutionPerSecond, q => q.ToUnit(RotationalSpeedUnit.RevolutionPerSecond)); + unitConverter.SetConversionFunction(RotationalSpeedUnit.RevolutionPerSecond, RotationalSpeed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.KilonewtonMeterPerRadian, q => q.ToUnit(RotationalStiffnessUnit.KilonewtonMeterPerRadian)); + unitConverter.SetConversionFunction(RotationalStiffnessUnit.KilonewtonMeterPerRadian, RotationalStiffness.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.MeganewtonMeterPerRadian, q => q.ToUnit(RotationalStiffnessUnit.MeganewtonMeterPerRadian)); + unitConverter.SetConversionFunction(RotationalStiffnessUnit.MeganewtonMeterPerRadian, RotationalStiffness.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(RotationalStiffness.BaseUnit, RotationalStiffness.BaseUnit, q => q); + unitConverter.SetConversionFunction(RotationalStiffnessPerLength.BaseUnit, RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter, q => q.ToUnit(RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter)); + unitConverter.SetConversionFunction(RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter, RotationalStiffnessPerLength.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(RotationalStiffnessPerLength.BaseUnit, RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter, q => q.ToUnit(RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter)); + unitConverter.SetConversionFunction(RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter, RotationalStiffnessPerLength.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(RotationalStiffnessPerLength.BaseUnit, RotationalStiffnessPerLength.BaseUnit, q => q); + unitConverter.SetConversionFunction(SolidAngle.BaseUnit, SolidAngle.BaseUnit, q => q); + unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergyUnit.BtuPerPound, q => q.ToUnit(SpecificEnergyUnit.BtuPerPound)); + unitConverter.SetConversionFunction(SpecificEnergyUnit.BtuPerPound, SpecificEnergy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergyUnit.CaloriePerGram, q => q.ToUnit(SpecificEnergyUnit.CaloriePerGram)); + unitConverter.SetConversionFunction(SpecificEnergyUnit.CaloriePerGram, SpecificEnergy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergy.BaseUnit, q => q); + unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergyUnit.KilocaloriePerGram, q => q.ToUnit(SpecificEnergyUnit.KilocaloriePerGram)); + unitConverter.SetConversionFunction(SpecificEnergyUnit.KilocaloriePerGram, SpecificEnergy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergyUnit.KilojoulePerKilogram, q => q.ToUnit(SpecificEnergyUnit.KilojoulePerKilogram)); + unitConverter.SetConversionFunction(SpecificEnergyUnit.KilojoulePerKilogram, SpecificEnergy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergyUnit.KilowattHourPerKilogram, q => q.ToUnit(SpecificEnergyUnit.KilowattHourPerKilogram)); + unitConverter.SetConversionFunction(SpecificEnergyUnit.KilowattHourPerKilogram, SpecificEnergy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergyUnit.MegajoulePerKilogram, q => q.ToUnit(SpecificEnergyUnit.MegajoulePerKilogram)); + unitConverter.SetConversionFunction(SpecificEnergyUnit.MegajoulePerKilogram, SpecificEnergy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergyUnit.MegawattHourPerKilogram, q => q.ToUnit(SpecificEnergyUnit.MegawattHourPerKilogram)); + unitConverter.SetConversionFunction(SpecificEnergyUnit.MegawattHourPerKilogram, SpecificEnergy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(SpecificEnergy.BaseUnit, SpecificEnergyUnit.WattHourPerKilogram, q => q.ToUnit(SpecificEnergyUnit.WattHourPerKilogram)); + unitConverter.SetConversionFunction(SpecificEnergyUnit.WattHourPerKilogram, SpecificEnergy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(SpecificEntropy.BaseUnit, SpecificEntropyUnit.CaloriePerGramKelvin, q => q.ToUnit(SpecificEntropyUnit.CaloriePerGramKelvin)); + unitConverter.SetConversionFunction(SpecificEntropyUnit.CaloriePerGramKelvin, SpecificEntropy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(SpecificEntropy.BaseUnit, SpecificEntropyUnit.JoulePerKilogramDegreeCelsius, q => q.ToUnit(SpecificEntropyUnit.JoulePerKilogramDegreeCelsius)); + unitConverter.SetConversionFunction(SpecificEntropyUnit.JoulePerKilogramDegreeCelsius, SpecificEntropy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(SpecificEntropy.BaseUnit, SpecificEntropy.BaseUnit, q => q); + unitConverter.SetConversionFunction(SpecificEntropy.BaseUnit, SpecificEntropyUnit.KilocaloriePerGramKelvin, q => q.ToUnit(SpecificEntropyUnit.KilocaloriePerGramKelvin)); + unitConverter.SetConversionFunction(SpecificEntropyUnit.KilocaloriePerGramKelvin, SpecificEntropy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(SpecificEntropy.BaseUnit, SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius, q => q.ToUnit(SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius)); + unitConverter.SetConversionFunction(SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius, SpecificEntropy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(SpecificEntropy.BaseUnit, SpecificEntropyUnit.KilojoulePerKilogramKelvin, q => q.ToUnit(SpecificEntropyUnit.KilojoulePerKilogramKelvin)); + unitConverter.SetConversionFunction(SpecificEntropyUnit.KilojoulePerKilogramKelvin, SpecificEntropy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(SpecificEntropy.BaseUnit, SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius, q => q.ToUnit(SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius)); + unitConverter.SetConversionFunction(SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius, SpecificEntropy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(SpecificEntropy.BaseUnit, SpecificEntropyUnit.MegajoulePerKilogramKelvin, q => q.ToUnit(SpecificEntropyUnit.MegajoulePerKilogramKelvin)); + unitConverter.SetConversionFunction(SpecificEntropyUnit.MegajoulePerKilogramKelvin, SpecificEntropy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(SpecificVolume.BaseUnit, SpecificVolumeUnit.CubicFootPerPound, q => q.ToUnit(SpecificVolumeUnit.CubicFootPerPound)); + unitConverter.SetConversionFunction(SpecificVolumeUnit.CubicFootPerPound, SpecificVolume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(SpecificVolume.BaseUnit, SpecificVolume.BaseUnit, q => q); + unitConverter.SetConversionFunction(SpecificVolume.BaseUnit, SpecificVolumeUnit.MillicubicMeterPerKilogram, q => q.ToUnit(SpecificVolumeUnit.MillicubicMeterPerKilogram)); + unitConverter.SetConversionFunction(SpecificVolumeUnit.MillicubicMeterPerKilogram, SpecificVolume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.KilogramForcePerCubicCentimeter, q => q.ToUnit(SpecificWeightUnit.KilogramForcePerCubicCentimeter)); + unitConverter.SetConversionFunction(SpecificWeightUnit.KilogramForcePerCubicCentimeter, SpecificWeight.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.KilogramForcePerCubicMeter, q => q.ToUnit(SpecificWeightUnit.KilogramForcePerCubicMeter)); + unitConverter.SetConversionFunction(SpecificWeightUnit.KilogramForcePerCubicMeter, SpecificWeight.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.KilogramForcePerCubicMillimeter, q => q.ToUnit(SpecificWeightUnit.KilogramForcePerCubicMillimeter)); + unitConverter.SetConversionFunction(SpecificWeightUnit.KilogramForcePerCubicMillimeter, SpecificWeight.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.KilonewtonPerCubicCentimeter, q => q.ToUnit(SpecificWeightUnit.KilonewtonPerCubicCentimeter)); + unitConverter.SetConversionFunction(SpecificWeightUnit.KilonewtonPerCubicCentimeter, SpecificWeight.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.KilonewtonPerCubicMeter, q => q.ToUnit(SpecificWeightUnit.KilonewtonPerCubicMeter)); + unitConverter.SetConversionFunction(SpecificWeightUnit.KilonewtonPerCubicMeter, SpecificWeight.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.KilonewtonPerCubicMillimeter, q => q.ToUnit(SpecificWeightUnit.KilonewtonPerCubicMillimeter)); + unitConverter.SetConversionFunction(SpecificWeightUnit.KilonewtonPerCubicMillimeter, SpecificWeight.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.KilopoundForcePerCubicFoot, q => q.ToUnit(SpecificWeightUnit.KilopoundForcePerCubicFoot)); + unitConverter.SetConversionFunction(SpecificWeightUnit.KilopoundForcePerCubicFoot, SpecificWeight.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.KilopoundForcePerCubicInch, q => q.ToUnit(SpecificWeightUnit.KilopoundForcePerCubicInch)); + unitConverter.SetConversionFunction(SpecificWeightUnit.KilopoundForcePerCubicInch, SpecificWeight.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.MeganewtonPerCubicMeter, q => q.ToUnit(SpecificWeightUnit.MeganewtonPerCubicMeter)); + unitConverter.SetConversionFunction(SpecificWeightUnit.MeganewtonPerCubicMeter, SpecificWeight.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.NewtonPerCubicCentimeter, q => q.ToUnit(SpecificWeightUnit.NewtonPerCubicCentimeter)); + unitConverter.SetConversionFunction(SpecificWeightUnit.NewtonPerCubicCentimeter, SpecificWeight.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeight.BaseUnit, q => q); + unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.NewtonPerCubicMillimeter, q => q.ToUnit(SpecificWeightUnit.NewtonPerCubicMillimeter)); + unitConverter.SetConversionFunction(SpecificWeightUnit.NewtonPerCubicMillimeter, SpecificWeight.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.PoundForcePerCubicFoot, q => q.ToUnit(SpecificWeightUnit.PoundForcePerCubicFoot)); + unitConverter.SetConversionFunction(SpecificWeightUnit.PoundForcePerCubicFoot, SpecificWeight.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.PoundForcePerCubicInch, q => q.ToUnit(SpecificWeightUnit.PoundForcePerCubicInch)); + unitConverter.SetConversionFunction(SpecificWeightUnit.PoundForcePerCubicInch, SpecificWeight.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.TonneForcePerCubicCentimeter, q => q.ToUnit(SpecificWeightUnit.TonneForcePerCubicCentimeter)); + unitConverter.SetConversionFunction(SpecificWeightUnit.TonneForcePerCubicCentimeter, SpecificWeight.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.TonneForcePerCubicMeter, q => q.ToUnit(SpecificWeightUnit.TonneForcePerCubicMeter)); + unitConverter.SetConversionFunction(SpecificWeightUnit.TonneForcePerCubicMeter, SpecificWeight.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(SpecificWeight.BaseUnit, SpecificWeightUnit.TonneForcePerCubicMillimeter, q => q.ToUnit(SpecificWeightUnit.TonneForcePerCubicMillimeter)); + unitConverter.SetConversionFunction(SpecificWeightUnit.TonneForcePerCubicMillimeter, SpecificWeight.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.CentimeterPerHour, q => q.ToUnit(SpeedUnit.CentimeterPerHour)); + unitConverter.SetConversionFunction(SpeedUnit.CentimeterPerHour, Speed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.CentimeterPerMinute, q => q.ToUnit(SpeedUnit.CentimeterPerMinute)); + unitConverter.SetConversionFunction(SpeedUnit.CentimeterPerMinute, Speed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.CentimeterPerSecond, q => q.ToUnit(SpeedUnit.CentimeterPerSecond)); + unitConverter.SetConversionFunction(SpeedUnit.CentimeterPerSecond, Speed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.DecimeterPerMinute, q => q.ToUnit(SpeedUnit.DecimeterPerMinute)); + unitConverter.SetConversionFunction(SpeedUnit.DecimeterPerMinute, Speed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.DecimeterPerSecond, q => q.ToUnit(SpeedUnit.DecimeterPerSecond)); + unitConverter.SetConversionFunction(SpeedUnit.DecimeterPerSecond, Speed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.FootPerHour, q => q.ToUnit(SpeedUnit.FootPerHour)); + unitConverter.SetConversionFunction(SpeedUnit.FootPerHour, Speed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.FootPerMinute, q => q.ToUnit(SpeedUnit.FootPerMinute)); + unitConverter.SetConversionFunction(SpeedUnit.FootPerMinute, Speed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.FootPerSecond, q => q.ToUnit(SpeedUnit.FootPerSecond)); + unitConverter.SetConversionFunction(SpeedUnit.FootPerSecond, Speed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.InchPerHour, q => q.ToUnit(SpeedUnit.InchPerHour)); + unitConverter.SetConversionFunction(SpeedUnit.InchPerHour, Speed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.InchPerMinute, q => q.ToUnit(SpeedUnit.InchPerMinute)); + unitConverter.SetConversionFunction(SpeedUnit.InchPerMinute, Speed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.InchPerSecond, q => q.ToUnit(SpeedUnit.InchPerSecond)); + unitConverter.SetConversionFunction(SpeedUnit.InchPerSecond, Speed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.KilometerPerHour, q => q.ToUnit(SpeedUnit.KilometerPerHour)); + unitConverter.SetConversionFunction(SpeedUnit.KilometerPerHour, Speed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.KilometerPerMinute, q => q.ToUnit(SpeedUnit.KilometerPerMinute)); + unitConverter.SetConversionFunction(SpeedUnit.KilometerPerMinute, Speed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.KilometerPerSecond, q => q.ToUnit(SpeedUnit.KilometerPerSecond)); + unitConverter.SetConversionFunction(SpeedUnit.KilometerPerSecond, Speed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.Knot, q => q.ToUnit(SpeedUnit.Knot)); + unitConverter.SetConversionFunction(SpeedUnit.Knot, Speed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.MeterPerHour, q => q.ToUnit(SpeedUnit.MeterPerHour)); + unitConverter.SetConversionFunction(SpeedUnit.MeterPerHour, Speed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.MeterPerMinute, q => q.ToUnit(SpeedUnit.MeterPerMinute)); + unitConverter.SetConversionFunction(SpeedUnit.MeterPerMinute, Speed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, Speed.BaseUnit, q => q); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.MicrometerPerMinute, q => q.ToUnit(SpeedUnit.MicrometerPerMinute)); + unitConverter.SetConversionFunction(SpeedUnit.MicrometerPerMinute, Speed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.MicrometerPerSecond, q => q.ToUnit(SpeedUnit.MicrometerPerSecond)); + unitConverter.SetConversionFunction(SpeedUnit.MicrometerPerSecond, Speed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.MilePerHour, q => q.ToUnit(SpeedUnit.MilePerHour)); + unitConverter.SetConversionFunction(SpeedUnit.MilePerHour, Speed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.MillimeterPerHour, q => q.ToUnit(SpeedUnit.MillimeterPerHour)); + unitConverter.SetConversionFunction(SpeedUnit.MillimeterPerHour, Speed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.MillimeterPerMinute, q => q.ToUnit(SpeedUnit.MillimeterPerMinute)); + unitConverter.SetConversionFunction(SpeedUnit.MillimeterPerMinute, Speed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.MillimeterPerSecond, q => q.ToUnit(SpeedUnit.MillimeterPerSecond)); + unitConverter.SetConversionFunction(SpeedUnit.MillimeterPerSecond, Speed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.NanometerPerMinute, q => q.ToUnit(SpeedUnit.NanometerPerMinute)); + unitConverter.SetConversionFunction(SpeedUnit.NanometerPerMinute, Speed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.NanometerPerSecond, q => q.ToUnit(SpeedUnit.NanometerPerSecond)); + unitConverter.SetConversionFunction(SpeedUnit.NanometerPerSecond, Speed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.UsSurveyFootPerHour, q => q.ToUnit(SpeedUnit.UsSurveyFootPerHour)); + unitConverter.SetConversionFunction(SpeedUnit.UsSurveyFootPerHour, Speed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.UsSurveyFootPerMinute, q => q.ToUnit(SpeedUnit.UsSurveyFootPerMinute)); + unitConverter.SetConversionFunction(SpeedUnit.UsSurveyFootPerMinute, Speed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.UsSurveyFootPerSecond, q => q.ToUnit(SpeedUnit.UsSurveyFootPerSecond)); + unitConverter.SetConversionFunction(SpeedUnit.UsSurveyFootPerSecond, Speed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.YardPerHour, q => q.ToUnit(SpeedUnit.YardPerHour)); + unitConverter.SetConversionFunction(SpeedUnit.YardPerHour, Speed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.YardPerMinute, q => q.ToUnit(SpeedUnit.YardPerMinute)); + unitConverter.SetConversionFunction(SpeedUnit.YardPerMinute, Speed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Speed.BaseUnit, SpeedUnit.YardPerSecond, q => q.ToUnit(SpeedUnit.YardPerSecond)); + unitConverter.SetConversionFunction(SpeedUnit.YardPerSecond, Speed.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Temperature.BaseUnit, TemperatureUnit.DegreeCelsius, q => q.ToUnit(TemperatureUnit.DegreeCelsius)); + unitConverter.SetConversionFunction(TemperatureUnit.DegreeCelsius, Temperature.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Temperature.BaseUnit, TemperatureUnit.DegreeDelisle, q => q.ToUnit(TemperatureUnit.DegreeDelisle)); + unitConverter.SetConversionFunction(TemperatureUnit.DegreeDelisle, Temperature.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Temperature.BaseUnit, TemperatureUnit.DegreeFahrenheit, q => q.ToUnit(TemperatureUnit.DegreeFahrenheit)); + unitConverter.SetConversionFunction(TemperatureUnit.DegreeFahrenheit, Temperature.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Temperature.BaseUnit, TemperatureUnit.DegreeNewton, q => q.ToUnit(TemperatureUnit.DegreeNewton)); + unitConverter.SetConversionFunction(TemperatureUnit.DegreeNewton, Temperature.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Temperature.BaseUnit, TemperatureUnit.DegreeRankine, q => q.ToUnit(TemperatureUnit.DegreeRankine)); + unitConverter.SetConversionFunction(TemperatureUnit.DegreeRankine, Temperature.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Temperature.BaseUnit, TemperatureUnit.DegreeReaumur, q => q.ToUnit(TemperatureUnit.DegreeReaumur)); + unitConverter.SetConversionFunction(TemperatureUnit.DegreeReaumur, Temperature.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Temperature.BaseUnit, TemperatureUnit.DegreeRoemer, q => q.ToUnit(TemperatureUnit.DegreeRoemer)); + unitConverter.SetConversionFunction(TemperatureUnit.DegreeRoemer, Temperature.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Temperature.BaseUnit, Temperature.BaseUnit, q => q); + unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond, q => q.ToUnit(TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond)); + unitConverter.SetConversionFunction(TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond, q => q.ToUnit(TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond)); + unitConverter.SetConversionFunction(TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond, q => q.ToUnit(TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond)); + unitConverter.SetConversionFunction(TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.DegreeCelsiusPerMinute, q => q.ToUnit(TemperatureChangeRateUnit.DegreeCelsiusPerMinute)); + unitConverter.SetConversionFunction(TemperatureChangeRateUnit.DegreeCelsiusPerMinute, TemperatureChangeRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRate.BaseUnit, q => q); + unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond, q => q.ToUnit(TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond)); + unitConverter.SetConversionFunction(TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond, q => q.ToUnit(TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond)); + unitConverter.SetConversionFunction(TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond, q => q.ToUnit(TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond)); + unitConverter.SetConversionFunction(TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond, q => q.ToUnit(TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond)); + unitConverter.SetConversionFunction(TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(TemperatureChangeRate.BaseUnit, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond, q => q.ToUnit(TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond)); + unitConverter.SetConversionFunction(TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond, TemperatureChangeRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeCelsius, q => q.ToUnit(TemperatureDeltaUnit.DegreeCelsius)); + unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeCelsius, TemperatureDelta.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeDelisle, q => q.ToUnit(TemperatureDeltaUnit.DegreeDelisle)); + unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeDelisle, TemperatureDelta.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeFahrenheit, q => q.ToUnit(TemperatureDeltaUnit.DegreeFahrenheit)); + unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeFahrenheit, TemperatureDelta.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeNewton, q => q.ToUnit(TemperatureDeltaUnit.DegreeNewton)); + unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeNewton, TemperatureDelta.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeRankine, q => q.ToUnit(TemperatureDeltaUnit.DegreeRankine)); + unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeRankine, TemperatureDelta.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeReaumur, q => q.ToUnit(TemperatureDeltaUnit.DegreeReaumur)); + unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeReaumur, TemperatureDelta.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(TemperatureDelta.BaseUnit, TemperatureDeltaUnit.DegreeRoemer, q => q.ToUnit(TemperatureDeltaUnit.DegreeRoemer)); + unitConverter.SetConversionFunction(TemperatureDeltaUnit.DegreeRoemer, TemperatureDelta.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(TemperatureDelta.BaseUnit, TemperatureDelta.BaseUnit, q => q); + unitConverter.SetConversionFunction(ThermalConductivity.BaseUnit, ThermalConductivityUnit.BtuPerHourFootFahrenheit, q => q.ToUnit(ThermalConductivityUnit.BtuPerHourFootFahrenheit)); + unitConverter.SetConversionFunction(ThermalConductivityUnit.BtuPerHourFootFahrenheit, ThermalConductivity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ThermalConductivity.BaseUnit, ThermalConductivity.BaseUnit, q => q); + unitConverter.SetConversionFunction(ThermalResistance.BaseUnit, ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu, q => q.ToUnit(ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu)); + unitConverter.SetConversionFunction(ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu, ThermalResistance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ThermalResistance.BaseUnit, ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie, q => q.ToUnit(ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie)); + unitConverter.SetConversionFunction(ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie, ThermalResistance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ThermalResistance.BaseUnit, ThermalResistanceUnit.SquareCentimeterKelvinPerWatt, q => q.ToUnit(ThermalResistanceUnit.SquareCentimeterKelvinPerWatt)); + unitConverter.SetConversionFunction(ThermalResistanceUnit.SquareCentimeterKelvinPerWatt, ThermalResistance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ThermalResistance.BaseUnit, ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt, q => q.ToUnit(ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt)); + unitConverter.SetConversionFunction(ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt, ThermalResistance.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ThermalResistance.BaseUnit, ThermalResistance.BaseUnit, q => q); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.KilogramForceCentimeter, q => q.ToUnit(TorqueUnit.KilogramForceCentimeter)); + unitConverter.SetConversionFunction(TorqueUnit.KilogramForceCentimeter, Torque.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.KilogramForceMeter, q => q.ToUnit(TorqueUnit.KilogramForceMeter)); + unitConverter.SetConversionFunction(TorqueUnit.KilogramForceMeter, Torque.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.KilogramForceMillimeter, q => q.ToUnit(TorqueUnit.KilogramForceMillimeter)); + unitConverter.SetConversionFunction(TorqueUnit.KilogramForceMillimeter, Torque.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.KilonewtonCentimeter, q => q.ToUnit(TorqueUnit.KilonewtonCentimeter)); + unitConverter.SetConversionFunction(TorqueUnit.KilonewtonCentimeter, Torque.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.KilonewtonMeter, q => q.ToUnit(TorqueUnit.KilonewtonMeter)); + unitConverter.SetConversionFunction(TorqueUnit.KilonewtonMeter, Torque.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.KilonewtonMillimeter, q => q.ToUnit(TorqueUnit.KilonewtonMillimeter)); + unitConverter.SetConversionFunction(TorqueUnit.KilonewtonMillimeter, Torque.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.KilopoundForceFoot, q => q.ToUnit(TorqueUnit.KilopoundForceFoot)); + unitConverter.SetConversionFunction(TorqueUnit.KilopoundForceFoot, Torque.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.KilopoundForceInch, q => q.ToUnit(TorqueUnit.KilopoundForceInch)); + unitConverter.SetConversionFunction(TorqueUnit.KilopoundForceInch, Torque.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.MeganewtonCentimeter, q => q.ToUnit(TorqueUnit.MeganewtonCentimeter)); + unitConverter.SetConversionFunction(TorqueUnit.MeganewtonCentimeter, Torque.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.MeganewtonMeter, q => q.ToUnit(TorqueUnit.MeganewtonMeter)); + unitConverter.SetConversionFunction(TorqueUnit.MeganewtonMeter, Torque.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.MeganewtonMillimeter, q => q.ToUnit(TorqueUnit.MeganewtonMillimeter)); + unitConverter.SetConversionFunction(TorqueUnit.MeganewtonMillimeter, Torque.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.MegapoundForceFoot, q => q.ToUnit(TorqueUnit.MegapoundForceFoot)); + unitConverter.SetConversionFunction(TorqueUnit.MegapoundForceFoot, Torque.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.MegapoundForceInch, q => q.ToUnit(TorqueUnit.MegapoundForceInch)); + unitConverter.SetConversionFunction(TorqueUnit.MegapoundForceInch, Torque.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.NewtonCentimeter, q => q.ToUnit(TorqueUnit.NewtonCentimeter)); + unitConverter.SetConversionFunction(TorqueUnit.NewtonCentimeter, Torque.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, Torque.BaseUnit, q => q); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.NewtonMillimeter, q => q.ToUnit(TorqueUnit.NewtonMillimeter)); + unitConverter.SetConversionFunction(TorqueUnit.NewtonMillimeter, Torque.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.PoundForceFoot, q => q.ToUnit(TorqueUnit.PoundForceFoot)); + unitConverter.SetConversionFunction(TorqueUnit.PoundForceFoot, Torque.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.PoundForceInch, q => q.ToUnit(TorqueUnit.PoundForceInch)); + unitConverter.SetConversionFunction(TorqueUnit.PoundForceInch, Torque.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.TonneForceCentimeter, q => q.ToUnit(TorqueUnit.TonneForceCentimeter)); + unitConverter.SetConversionFunction(TorqueUnit.TonneForceCentimeter, Torque.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.TonneForceMeter, q => q.ToUnit(TorqueUnit.TonneForceMeter)); + unitConverter.SetConversionFunction(TorqueUnit.TonneForceMeter, Torque.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Torque.BaseUnit, TorqueUnit.TonneForceMillimeter, q => q.ToUnit(TorqueUnit.TonneForceMillimeter)); + unitConverter.SetConversionFunction(TorqueUnit.TonneForceMillimeter, Torque.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VitaminA.BaseUnit, VitaminA.BaseUnit, q => q); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.AcreFoot, q => q.ToUnit(VolumeUnit.AcreFoot)); + unitConverter.SetConversionFunction(VolumeUnit.AcreFoot, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.AuTablespoon, q => q.ToUnit(VolumeUnit.AuTablespoon)); + unitConverter.SetConversionFunction(VolumeUnit.AuTablespoon, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.Centiliter, q => q.ToUnit(VolumeUnit.Centiliter)); + unitConverter.SetConversionFunction(VolumeUnit.Centiliter, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicCentimeter, q => q.ToUnit(VolumeUnit.CubicCentimeter)); + unitConverter.SetConversionFunction(VolumeUnit.CubicCentimeter, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicDecimeter, q => q.ToUnit(VolumeUnit.CubicDecimeter)); + unitConverter.SetConversionFunction(VolumeUnit.CubicDecimeter, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicFoot, q => q.ToUnit(VolumeUnit.CubicFoot)); + unitConverter.SetConversionFunction(VolumeUnit.CubicFoot, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicInch, q => q.ToUnit(VolumeUnit.CubicInch)); + unitConverter.SetConversionFunction(VolumeUnit.CubicInch, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicKilometer, q => q.ToUnit(VolumeUnit.CubicKilometer)); + unitConverter.SetConversionFunction(VolumeUnit.CubicKilometer, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, Volume.BaseUnit, q => q); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicMicrometer, q => q.ToUnit(VolumeUnit.CubicMicrometer)); + unitConverter.SetConversionFunction(VolumeUnit.CubicMicrometer, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicMile, q => q.ToUnit(VolumeUnit.CubicMile)); + unitConverter.SetConversionFunction(VolumeUnit.CubicMile, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicMillimeter, q => q.ToUnit(VolumeUnit.CubicMillimeter)); + unitConverter.SetConversionFunction(VolumeUnit.CubicMillimeter, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicYard, q => q.ToUnit(VolumeUnit.CubicYard)); + unitConverter.SetConversionFunction(VolumeUnit.CubicYard, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.Deciliter, q => q.ToUnit(VolumeUnit.Deciliter)); + unitConverter.SetConversionFunction(VolumeUnit.Deciliter, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.HectocubicFoot, q => q.ToUnit(VolumeUnit.HectocubicFoot)); + unitConverter.SetConversionFunction(VolumeUnit.HectocubicFoot, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.HectocubicMeter, q => q.ToUnit(VolumeUnit.HectocubicMeter)); + unitConverter.SetConversionFunction(VolumeUnit.HectocubicMeter, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.Hectoliter, q => q.ToUnit(VolumeUnit.Hectoliter)); + unitConverter.SetConversionFunction(VolumeUnit.Hectoliter, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.ImperialBeerBarrel, q => q.ToUnit(VolumeUnit.ImperialBeerBarrel)); + unitConverter.SetConversionFunction(VolumeUnit.ImperialBeerBarrel, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.ImperialGallon, q => q.ToUnit(VolumeUnit.ImperialGallon)); + unitConverter.SetConversionFunction(VolumeUnit.ImperialGallon, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.ImperialOunce, q => q.ToUnit(VolumeUnit.ImperialOunce)); + unitConverter.SetConversionFunction(VolumeUnit.ImperialOunce, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.KilocubicFoot, q => q.ToUnit(VolumeUnit.KilocubicFoot)); + unitConverter.SetConversionFunction(VolumeUnit.KilocubicFoot, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.KilocubicMeter, q => q.ToUnit(VolumeUnit.KilocubicMeter)); + unitConverter.SetConversionFunction(VolumeUnit.KilocubicMeter, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.KiloimperialGallon, q => q.ToUnit(VolumeUnit.KiloimperialGallon)); + unitConverter.SetConversionFunction(VolumeUnit.KiloimperialGallon, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.Kiloliter, q => q.ToUnit(VolumeUnit.Kiloliter)); + unitConverter.SetConversionFunction(VolumeUnit.Kiloliter, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.KilousGallon, q => q.ToUnit(VolumeUnit.KilousGallon)); + unitConverter.SetConversionFunction(VolumeUnit.KilousGallon, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.Liter, q => q.ToUnit(VolumeUnit.Liter)); + unitConverter.SetConversionFunction(VolumeUnit.Liter, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.MegacubicFoot, q => q.ToUnit(VolumeUnit.MegacubicFoot)); + unitConverter.SetConversionFunction(VolumeUnit.MegacubicFoot, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.MegaimperialGallon, q => q.ToUnit(VolumeUnit.MegaimperialGallon)); + unitConverter.SetConversionFunction(VolumeUnit.MegaimperialGallon, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.Megaliter, q => q.ToUnit(VolumeUnit.Megaliter)); + unitConverter.SetConversionFunction(VolumeUnit.Megaliter, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.MegausGallon, q => q.ToUnit(VolumeUnit.MegausGallon)); + unitConverter.SetConversionFunction(VolumeUnit.MegausGallon, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.MetricCup, q => q.ToUnit(VolumeUnit.MetricCup)); + unitConverter.SetConversionFunction(VolumeUnit.MetricCup, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.MetricTeaspoon, q => q.ToUnit(VolumeUnit.MetricTeaspoon)); + unitConverter.SetConversionFunction(VolumeUnit.MetricTeaspoon, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.Microliter, q => q.ToUnit(VolumeUnit.Microliter)); + unitConverter.SetConversionFunction(VolumeUnit.Microliter, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.Milliliter, q => q.ToUnit(VolumeUnit.Milliliter)); + unitConverter.SetConversionFunction(VolumeUnit.Milliliter, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.OilBarrel, q => q.ToUnit(VolumeUnit.OilBarrel)); + unitConverter.SetConversionFunction(VolumeUnit.OilBarrel, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UkTablespoon, q => q.ToUnit(VolumeUnit.UkTablespoon)); + unitConverter.SetConversionFunction(VolumeUnit.UkTablespoon, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsBeerBarrel, q => q.ToUnit(VolumeUnit.UsBeerBarrel)); + unitConverter.SetConversionFunction(VolumeUnit.UsBeerBarrel, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsCustomaryCup, q => q.ToUnit(VolumeUnit.UsCustomaryCup)); + unitConverter.SetConversionFunction(VolumeUnit.UsCustomaryCup, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsGallon, q => q.ToUnit(VolumeUnit.UsGallon)); + unitConverter.SetConversionFunction(VolumeUnit.UsGallon, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsLegalCup, q => q.ToUnit(VolumeUnit.UsLegalCup)); + unitConverter.SetConversionFunction(VolumeUnit.UsLegalCup, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsOunce, q => q.ToUnit(VolumeUnit.UsOunce)); + unitConverter.SetConversionFunction(VolumeUnit.UsOunce, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsPint, q => q.ToUnit(VolumeUnit.UsPint)); + unitConverter.SetConversionFunction(VolumeUnit.UsPint, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsQuart, q => q.ToUnit(VolumeUnit.UsQuart)); + unitConverter.SetConversionFunction(VolumeUnit.UsQuart, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsTablespoon, q => q.ToUnit(VolumeUnit.UsTablespoon)); + unitConverter.SetConversionFunction(VolumeUnit.UsTablespoon, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.UsTeaspoon, q => q.ToUnit(VolumeUnit.UsTeaspoon)); + unitConverter.SetConversionFunction(VolumeUnit.UsTeaspoon, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.AcreFootPerDay, q => q.ToUnit(VolumeFlowUnit.AcreFootPerDay)); + unitConverter.SetConversionFunction(VolumeFlowUnit.AcreFootPerDay, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.AcreFootPerHour, q => q.ToUnit(VolumeFlowUnit.AcreFootPerHour)); + unitConverter.SetConversionFunction(VolumeFlowUnit.AcreFootPerHour, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.AcreFootPerMinute, q => q.ToUnit(VolumeFlowUnit.AcreFootPerMinute)); + unitConverter.SetConversionFunction(VolumeFlowUnit.AcreFootPerMinute, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.AcreFootPerSecond, q => q.ToUnit(VolumeFlowUnit.AcreFootPerSecond)); + unitConverter.SetConversionFunction(VolumeFlowUnit.AcreFootPerSecond, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CentiliterPerDay, q => q.ToUnit(VolumeFlowUnit.CentiliterPerDay)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CentiliterPerDay, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CentiliterPerMinute, q => q.ToUnit(VolumeFlowUnit.CentiliterPerMinute)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CentiliterPerMinute, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicDecimeterPerMinute, q => q.ToUnit(VolumeFlowUnit.CubicDecimeterPerMinute)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicDecimeterPerMinute, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicFootPerHour, q => q.ToUnit(VolumeFlowUnit.CubicFootPerHour)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicFootPerHour, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicFootPerMinute, q => q.ToUnit(VolumeFlowUnit.CubicFootPerMinute)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicFootPerMinute, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicFootPerSecond, q => q.ToUnit(VolumeFlowUnit.CubicFootPerSecond)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicFootPerSecond, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicMeterPerDay, q => q.ToUnit(VolumeFlowUnit.CubicMeterPerDay)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMeterPerDay, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicMeterPerHour, q => q.ToUnit(VolumeFlowUnit.CubicMeterPerHour)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMeterPerHour, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicMeterPerMinute, q => q.ToUnit(VolumeFlowUnit.CubicMeterPerMinute)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMeterPerMinute, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlow.BaseUnit, q => q); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicMillimeterPerSecond, q => q.ToUnit(VolumeFlowUnit.CubicMillimeterPerSecond)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMillimeterPerSecond, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicYardPerDay, q => q.ToUnit(VolumeFlowUnit.CubicYardPerDay)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicYardPerDay, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicYardPerHour, q => q.ToUnit(VolumeFlowUnit.CubicYardPerHour)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicYardPerHour, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicYardPerMinute, q => q.ToUnit(VolumeFlowUnit.CubicYardPerMinute)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicYardPerMinute, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.CubicYardPerSecond, q => q.ToUnit(VolumeFlowUnit.CubicYardPerSecond)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicYardPerSecond, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.DeciliterPerDay, q => q.ToUnit(VolumeFlowUnit.DeciliterPerDay)); + unitConverter.SetConversionFunction(VolumeFlowUnit.DeciliterPerDay, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.DeciliterPerMinute, q => q.ToUnit(VolumeFlowUnit.DeciliterPerMinute)); + unitConverter.SetConversionFunction(VolumeFlowUnit.DeciliterPerMinute, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.KiloliterPerDay, q => q.ToUnit(VolumeFlowUnit.KiloliterPerDay)); + unitConverter.SetConversionFunction(VolumeFlowUnit.KiloliterPerDay, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.KiloliterPerMinute, q => q.ToUnit(VolumeFlowUnit.KiloliterPerMinute)); + unitConverter.SetConversionFunction(VolumeFlowUnit.KiloliterPerMinute, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.KilousGallonPerMinute, q => q.ToUnit(VolumeFlowUnit.KilousGallonPerMinute)); + unitConverter.SetConversionFunction(VolumeFlowUnit.KilousGallonPerMinute, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.LiterPerDay, q => q.ToUnit(VolumeFlowUnit.LiterPerDay)); + unitConverter.SetConversionFunction(VolumeFlowUnit.LiterPerDay, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.LiterPerHour, q => q.ToUnit(VolumeFlowUnit.LiterPerHour)); + unitConverter.SetConversionFunction(VolumeFlowUnit.LiterPerHour, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.LiterPerMinute, q => q.ToUnit(VolumeFlowUnit.LiterPerMinute)); + unitConverter.SetConversionFunction(VolumeFlowUnit.LiterPerMinute, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.LiterPerSecond, q => q.ToUnit(VolumeFlowUnit.LiterPerSecond)); + unitConverter.SetConversionFunction(VolumeFlowUnit.LiterPerSecond, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.MegaliterPerDay, q => q.ToUnit(VolumeFlowUnit.MegaliterPerDay)); + unitConverter.SetConversionFunction(VolumeFlowUnit.MegaliterPerDay, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.MegaukGallonPerSecond, q => q.ToUnit(VolumeFlowUnit.MegaukGallonPerSecond)); + unitConverter.SetConversionFunction(VolumeFlowUnit.MegaukGallonPerSecond, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.MicroliterPerDay, q => q.ToUnit(VolumeFlowUnit.MicroliterPerDay)); + unitConverter.SetConversionFunction(VolumeFlowUnit.MicroliterPerDay, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.MicroliterPerMinute, q => q.ToUnit(VolumeFlowUnit.MicroliterPerMinute)); + unitConverter.SetConversionFunction(VolumeFlowUnit.MicroliterPerMinute, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.MilliliterPerDay, q => q.ToUnit(VolumeFlowUnit.MilliliterPerDay)); + unitConverter.SetConversionFunction(VolumeFlowUnit.MilliliterPerDay, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.MilliliterPerMinute, q => q.ToUnit(VolumeFlowUnit.MilliliterPerMinute)); + unitConverter.SetConversionFunction(VolumeFlowUnit.MilliliterPerMinute, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.MillionUsGallonsPerDay, q => q.ToUnit(VolumeFlowUnit.MillionUsGallonsPerDay)); + unitConverter.SetConversionFunction(VolumeFlowUnit.MillionUsGallonsPerDay, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.NanoliterPerDay, q => q.ToUnit(VolumeFlowUnit.NanoliterPerDay)); + unitConverter.SetConversionFunction(VolumeFlowUnit.NanoliterPerDay, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.NanoliterPerMinute, q => q.ToUnit(VolumeFlowUnit.NanoliterPerMinute)); + unitConverter.SetConversionFunction(VolumeFlowUnit.NanoliterPerMinute, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.OilBarrelPerDay, q => q.ToUnit(VolumeFlowUnit.OilBarrelPerDay)); + unitConverter.SetConversionFunction(VolumeFlowUnit.OilBarrelPerDay, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.OilBarrelPerHour, q => q.ToUnit(VolumeFlowUnit.OilBarrelPerHour)); + unitConverter.SetConversionFunction(VolumeFlowUnit.OilBarrelPerHour, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.OilBarrelPerMinute, q => q.ToUnit(VolumeFlowUnit.OilBarrelPerMinute)); + unitConverter.SetConversionFunction(VolumeFlowUnit.OilBarrelPerMinute, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.OilBarrelPerSecond, q => q.ToUnit(VolumeFlowUnit.OilBarrelPerSecond)); + unitConverter.SetConversionFunction(VolumeFlowUnit.OilBarrelPerSecond, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.UkGallonPerDay, q => q.ToUnit(VolumeFlowUnit.UkGallonPerDay)); + unitConverter.SetConversionFunction(VolumeFlowUnit.UkGallonPerDay, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.UkGallonPerMinute, q => q.ToUnit(VolumeFlowUnit.UkGallonPerMinute)); + unitConverter.SetConversionFunction(VolumeFlowUnit.UkGallonPerMinute, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.UkGallonPerSecond, q => q.ToUnit(VolumeFlowUnit.UkGallonPerSecond)); + unitConverter.SetConversionFunction(VolumeFlowUnit.UkGallonPerSecond, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.UsGallonPerDay, q => q.ToUnit(VolumeFlowUnit.UsGallonPerDay)); + unitConverter.SetConversionFunction(VolumeFlowUnit.UsGallonPerDay, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.UsGallonPerHour, q => q.ToUnit(VolumeFlowUnit.UsGallonPerHour)); + unitConverter.SetConversionFunction(VolumeFlowUnit.UsGallonPerHour, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.UsGallonPerMinute, q => q.ToUnit(VolumeFlowUnit.UsGallonPerMinute)); + unitConverter.SetConversionFunction(VolumeFlowUnit.UsGallonPerMinute, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(VolumeFlow.BaseUnit, VolumeFlowUnit.UsGallonPerSecond, q => q.ToUnit(VolumeFlowUnit.UsGallonPerSecond)); + unitConverter.SetConversionFunction(VolumeFlowUnit.UsGallonPerSecond, VolumeFlow.BaseUnit, q => q.ToBaseUnit()); } } } diff --git a/UnitsNet/Scripts/Include-GenerateUnitConverterDefaultSourceCode.ps1 b/UnitsNet/Scripts/Include-GenerateUnitConverterDefaultSourceCode.ps1 index 8757b5d537..6d03ecf077 100644 --- a/UnitsNet/Scripts/Include-GenerateUnitConverterDefaultSourceCode.ps1 +++ b/UnitsNet/Scripts/Include-GenerateUnitConverterDefaultSourceCode.ps1 @@ -63,14 +63,14 @@ foreach ($quantity in $quantities) if( $quantity.BaseUnit -eq $enumValue ) { @" - unitConverter.SetConversionFunction<$quantityName>($quantityName.BaseUnit, $quantityName.BaseUnit, (q) => q); + unitConverter.SetConversionFunction<$quantityName>($quantityName.BaseUnit, $quantityName.BaseUnit, q => q); "@; } else { @" - unitConverter.SetConversionFunction<$quantityName>($quantityName.BaseUnit, $unitEnumName.$enumValue, (q) => (($quantityName)q).ToUnit($unitEnumName.$enumValue)); - unitConverter.SetConversionFunction<$quantityName>($unitEnumName.$enumValue, $quantityName.BaseUnit, (q) => (($quantityName)q).ToBaseUnit()); + unitConverter.SetConversionFunction<$quantityName>($quantityName.BaseUnit, $unitEnumName.$enumValue, q => q.ToUnit($unitEnumName.$enumValue)); + unitConverter.SetConversionFunction<$quantityName>($unitEnumName.$enumValue, $quantityName.BaseUnit, q => q.ToBaseUnit()); "@; } } From 5c49f66d73d33e819a2b7b069a4c413557d02a50 Mon Sep 17 00:00:00 2001 From: Tristan Milnthorp Date: Thu, 28 Feb 2019 23:14:32 -0500 Subject: [PATCH 14/21] Header update --- UnitsNet/GeneratedCode/UnitConverter.g.cs | 39 +------------------ ...GenerateUnitConverterDefaultSourceCode.ps1 | 39 +------------------ 2 files changed, 4 insertions(+), 74 deletions(-) diff --git a/UnitsNet/GeneratedCode/UnitConverter.g.cs b/UnitsNet/GeneratedCode/UnitConverter.g.cs index 9221c9fb37..9183233272 100644 --- a/UnitsNet/GeneratedCode/UnitConverter.g.cs +++ b/UnitsNet/GeneratedCode/UnitConverter.g.cs @@ -1,41 +1,6 @@ -//------------------------------------------------------------------------------ -// -// This code was generated by \generate-code.bat. -// -// Changes to this file will be lost when the code is regenerated. -// The build server regenerates the code before each build and a pre-build -// step will regenerate the code on each local build. -// -// See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units. -// -// Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities. -// Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities. -// -// -//------------------------------------------------------------------------------ +// Licensed under MIT No Attribution, see LICENSE file at the root. +// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet. -// Copyright (c) 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). -// https://github.com/angularsen/UnitsNet -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -// THE SOFTWARE. - -using System; using UnitsNet.Units; // ReSharper disable RedundantCommaInArrayInitializer diff --git a/UnitsNet/Scripts/Include-GenerateUnitConverterDefaultSourceCode.ps1 b/UnitsNet/Scripts/Include-GenerateUnitConverterDefaultSourceCode.ps1 index 6e911a9fe3..a501d34500 100644 --- a/UnitsNet/Scripts/Include-GenerateUnitConverterDefaultSourceCode.ps1 +++ b/UnitsNet/Scripts/Include-GenerateUnitConverterDefaultSourceCode.ps1 @@ -1,44 +1,9 @@ function GenerateUnitConverterDefaultSourceCode($quantities) { @" -//------------------------------------------------------------------------------ -// -// This code was generated by \generate-code.bat. -// -// Changes to this file will be lost when the code is regenerated. -// The build server regenerates the code before each build and a pre-build -// step will regenerate the code on each local build. -// -// See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units. -// -// Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities. -// Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities. -// -// -//------------------------------------------------------------------------------ +// Licensed under MIT No Attribution, see LICENSE file at the root. +// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet. -// Copyright (c) 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). -// https://github.com/angularsen/UnitsNet -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -// THE SOFTWARE. - -using System; using UnitsNet.Units; // ReSharper disable RedundantCommaInArrayInitializer From 8cc352e9eeac80fd12f86e01a6dacb2a7ed4590c Mon Sep 17 00:00:00 2001 From: Andreas Gullberg Larsen Date: Mon, 22 Apr 2019 09:58:47 +0200 Subject: [PATCH 15/21] Add xmldoc and minor renaming --- UnitsNet/UnitConverter.cs | 169 +++++++++++++++++++------------------- 1 file changed, 84 insertions(+), 85 deletions(-) diff --git a/UnitsNet/UnitConverter.cs b/UnitsNet/UnitConverter.cs index 38e56e8c08..18bbc3b856 100644 --- a/UnitsNet/UnitConverter.cs +++ b/UnitsNet/UnitConverter.cs @@ -10,17 +10,17 @@ namespace UnitsNet { - using ConversionFunctionLookup = ValueTuple; + using ConversionFunctionLookupKey = ValueTuple; /// - /// + /// /// /// /// public delegate IQuantity ConversionFunction(IQuantity inputValue); /// - /// + /// /// /// /// @@ -35,11 +35,12 @@ public delegate TQuantity ConversionFunction(TQuantity inputValue) public sealed partial class UnitConverter { /// - /// + /// The static instance used by Units.NET to convert between units. Modify this to add/remove conversion functions at runtime, such + /// as adding your own third-party units and quantities to convert between. /// public static UnitConverter Default { get; } - private readonly Dictionary _conversionFunctions = new Dictionary(); + private readonly Dictionary _conversionFunctions = new Dictionary(); static UnitConverter() { @@ -48,28 +49,28 @@ static UnitConverter() } /// - /// + /// Sets the conversion function from two units of the same quantity type. /// - /// - /// - /// - /// + /// The type of quantity, must implement . + /// From unit enum value, such as . + /// To unit enum value, such as . + /// The quantity conversion function. public void SetConversionFunction(Enum from, Enum to, ConversionFunction conversionFunction) where TQuantity : IQuantity { var quantityType = typeof(TQuantity); - var conversionLookup = new ConversionFunctionLookup(quantityType, from, quantityType, to); + var conversionLookup = new ConversionFunctionLookupKey(quantityType, from, quantityType, to); SetConversionFunction(conversionLookup, conversionFunction); } /// - /// + /// Sets the conversion function from two units of different quantity types. /// - /// - /// - /// - /// - /// + /// From quantity type, must implement . + /// To quantity type, must implement . + /// From unit enum value, such as . + /// To unit enum value, such as . + /// The quantity conversion function. public void SetConversionFunction(Enum from, Enum to, ConversionFunction conversionFunction) where TQuantityFrom : IQuantity where TQuantityTo : IQuantity @@ -78,36 +79,36 @@ public void SetConversionFunction(Enum from, Enum to } /// - /// + /// Sets the conversion function from two units of different quantity types. /// - /// - /// - /// - /// - /// + /// From quantity type, must implement . + /// From unit enum value, such as . + /// To quantity type, must implement . + /// To unit enum value, such as . + /// The quantity conversion function. public void SetConversionFunction(Type fromType, Enum from, Type toType, Enum to, ConversionFunction conversionFunction) { - var conversionLookup = new ConversionFunctionLookup(fromType, from, toType, to); + var conversionLookup = new ConversionFunctionLookupKey(fromType, from, toType, to); SetConversionFunction(conversionLookup, conversionFunction); } /// - /// + /// Sets the conversion function for a particular conversion function lookup. /// - /// - /// - public void SetConversionFunction(ConversionFunctionLookup conversionLookup, ConversionFunction conversionFunction) + /// The lookup key. + /// The quantity conversion function. + internal void SetConversionFunction(ConversionFunctionLookupKey lookupKey, ConversionFunction conversionFunction) { - _conversionFunctions[conversionLookup] = conversionFunction; + _conversionFunctions[lookupKey] = conversionFunction; } /// - /// + /// Sets the conversion function for a particular conversion function lookup. /// - /// - /// - /// - public void SetConversionFunction(ConversionFunctionLookup conversionLookup, ConversionFunction conversionFunction) + /// The quantity type, must implement . + /// The quantity conversion function lookup key. + /// The quantity conversion function. + internal void SetConversionFunction(ConversionFunctionLookupKey conversionLookup, ConversionFunction conversionFunction) where TQuantity : IQuantity { IQuantity TypelessConversionFunction(IQuantity quantity) => conversionFunction((TQuantity) quantity); @@ -116,24 +117,24 @@ public void SetConversionFunction(ConversionFunctionLookup conversion } /// - /// + /// Gets the conversion function from two units of the same quantity type. /// - /// - /// - /// + /// The quantity type, must implement . + /// From unit enum value, such as . + /// To unit enum value, such as . /// - public ConversionFunction GetConversionFunction(Enum from, Enum to) where T : IQuantity + public ConversionFunction GetConversionFunction(Enum from, Enum to) where TQuantity : IQuantity { - return GetConversionFunction(typeof(T), from, typeof(T), to); + return GetConversionFunction(typeof(TQuantity), from, typeof(TQuantity), to); } /// - /// + /// Gets the conversion function from two units of different quantity types. /// - /// - /// - /// - /// + /// From quantity type, must implement . + /// To quantity type, must implement . + /// From unit enum value, such as . + /// To unit enum value, such as . /// public ConversionFunction GetConversionFunction(Enum from, Enum to) where TQuantityFrom : IQuantity @@ -143,51 +144,49 @@ public ConversionFunction GetConversionFunction(Enum } /// - /// + /// Gets the conversion function from two units of different quantity types. /// - /// - /// - /// - /// - /// + /// From quantity type, must implement . + /// From unit enum value, such as . + /// To quantity type, must implement . + /// To unit enum value, such as . public ConversionFunction GetConversionFunction(Type fromType, Enum from, Type toType, Enum to) { - var conversionLookup = new ConversionFunctionLookup(fromType, from, toType, to); + var conversionLookup = new ConversionFunctionLookupKey(fromType, from, toType, to); return GetConversionFunction(conversionLookup); } /// - /// + /// Gets the conversion function by its lookup key. /// - /// - /// - public ConversionFunction GetConversionFunction(ConversionFunctionLookup conversionLookup) + /// + internal ConversionFunction GetConversionFunction(ConversionFunctionLookupKey lookupKey) { - return _conversionFunctions[conversionLookup]; + return _conversionFunctions[lookupKey]; } /// - /// + /// Gets the conversion function for two units of the same quantity type. /// - /// - /// - /// - /// - /// - public bool TryGetConversionFunction(Enum from, Enum to, out ConversionFunction conversionFunction) where T : IQuantity + /// The quantity type, must implement . + /// From unit enum value, such as . + /// To unit enum value, such as . + /// The quantity conversion function. + /// true if set; otherwise, false. + public bool TryGetConversionFunction(Enum from, Enum to, out ConversionFunction conversionFunction) where TQuantity : IQuantity { - return TryGetConversionFunction(typeof(T), from, typeof(T), to, out conversionFunction); + return TryGetConversionFunction(typeof(TQuantity), from, typeof(TQuantity), to, out conversionFunction); } /// - /// + /// Gets the conversion function for two units of different quantity types. /// - /// - /// - /// - /// - /// - /// + /// From quantity type, must implement . + /// To quantity type, must implement . + /// From unit enum value, such as . + /// To unit enum value, such as . + /// The quantity conversion function. + /// true if set; otherwise, false. public bool TryGetConversionFunction(Enum from, Enum to, out ConversionFunction conversionFunction) where TQuantityFrom : IQuantity where TQuantityTo : IQuantity @@ -196,29 +195,29 @@ public bool TryGetConversionFunction(Enum from, Enum } /// - /// + /// Try to get the conversion function for two units of the same quantity type. /// - /// - /// - /// - /// - /// - /// + /// From quantity type, must implement . + /// From unit enum value, such as . + /// To quantity type, must implement . + /// To unit enum value, such as . + /// The quantity conversion function. + /// true if set; otherwise, false. public bool TryGetConversionFunction(Type fromType, Enum from, Type toType, Enum to, out ConversionFunction conversionFunction) { - var conversionLookup = new ConversionFunctionLookup(fromType, from, toType, to); + var conversionLookup = new ConversionFunctionLookupKey(fromType, from, toType, to); return TryGetConversionFunction(conversionLookup, out conversionFunction); } /// - /// + /// /// - /// + /// /// - /// - public bool TryGetConversionFunction(ConversionFunctionLookup conversionLookup, out ConversionFunction conversionFunction) + /// true if set; otherwise, false. + public bool TryGetConversionFunction(ConversionFunctionLookupKey lookupKey, out ConversionFunction conversionFunction) { - return _conversionFunctions.TryGetValue(conversionLookup, out conversionFunction); + return _conversionFunctions.TryGetValue(lookupKey, out conversionFunction); } /// From 16dca81144a7a9a0719e7ffe0b373fc7ca492ac6 Mon Sep 17 00:00:00 2001 From: Andreas Gullberg Larsen Date: Mon, 22 Apr 2019 10:21:14 +0200 Subject: [PATCH 16/21] Add test cases for Type parameters --- UnitsNet.Tests/UnitConverterTest.cs | 40 ++++++++++++++++++++++++----- 1 file changed, 34 insertions(+), 6 deletions(-) diff --git a/UnitsNet.Tests/UnitConverterTest.cs b/UnitsNet.Tests/UnitConverterTest.cs index 64a72a111e..cf8c313e46 100644 --- a/UnitsNet.Tests/UnitConverterTest.cs +++ b/UnitsNet.Tests/UnitConverterTest.cs @@ -11,10 +11,10 @@ public class UnitConverterTest [Fact] public void CustomConversionWithSameQuantityType() { - ConversionFunction conversionFunction = (from) => Length.FromInches(18); + Length ConversionFunction(Length from) => Length.FromInches(18); var unitConverter = new UnitConverter(); - unitConverter.SetConversionFunction(LengthUnit.Meter, LengthUnit.Inch, conversionFunction); + unitConverter.SetConversionFunction(LengthUnit.Meter, LengthUnit.Inch, ConversionFunction); var foundConversionFunction = unitConverter.GetConversionFunction(LengthUnit.Meter, LengthUnit.Inch); var converted = foundConversionFunction(Length.FromMeters(1.0)); @@ -22,13 +22,27 @@ public void CustomConversionWithSameQuantityType() Assert.Equal(Length.FromInches(18), converted); } + [Fact] + public void CustomConversionWithSameQuantityTypeByTypeParam() + { + Length ConversionFunction(Length from) => Length.FromInches(18); + + var unitConverter = new UnitConverter(); + unitConverter.SetConversionFunction(LengthUnit.Meter, LengthUnit.Inch, (ConversionFunction) ConversionFunction); + + var foundConversionFunction = unitConverter.GetConversionFunction(typeof(Length), LengthUnit.Meter, typeof(Length), LengthUnit.Inch); + var converted = foundConversionFunction(Length.FromMeters(1.0)); + + Assert.Equal(Length.FromInches(18), converted); + } + [Fact] public void CustomConversionWithDifferentQuantityTypes() { - ConversionFunction conversionFunction = (from) => Length.FromInches(18); + IQuantity ConversionFunction(IQuantity from) => Length.FromInches(18); var unitConverter = new UnitConverter(); - unitConverter.SetConversionFunction(MassUnit.Grain, LengthUnit.Inch, conversionFunction); + unitConverter.SetConversionFunction(MassUnit.Grain, LengthUnit.Inch, ConversionFunction); var foundConversionFunction = unitConverter.GetConversionFunction(MassUnit.Grain, LengthUnit.Inch); var converted = foundConversionFunction(Mass.FromGrains(100)); @@ -36,13 +50,27 @@ public void CustomConversionWithDifferentQuantityTypes() Assert.Equal(Length.FromInches(18), converted); } + [Fact] + public void CustomConversionWithDifferentQuantityTypesByTypeParam() + { + IQuantity ConversionFunction(IQuantity from) => Length.FromInches(18); + + var unitConverter = new UnitConverter(); + unitConverter.SetConversionFunction(MassUnit.Grain, LengthUnit.Inch, ConversionFunction); + + var foundConversionFunction = unitConverter.GetConversionFunction(typeof(Mass), MassUnit.Grain, typeof(Length), LengthUnit.Inch); + var converted = foundConversionFunction(Mass.FromGrains(100)); + + Assert.Equal(Length.FromInches(18), converted); + } + [Fact] public void TryCustomConversionForOilBarrelsToUsGallons() { - ConversionFunction conversionFunction = (from) => Volume.FromUsGallons(from.Value * 42); + Volume ConversionFunction(Volume from) => Volume.FromUsGallons(from.Value * 42); var unitConverter = new UnitConverter(); - unitConverter.SetConversionFunction(VolumeUnit.OilBarrel, VolumeUnit.UsGallon, conversionFunction); + unitConverter.SetConversionFunction(VolumeUnit.OilBarrel, VolumeUnit.UsGallon, ConversionFunction); var foundConversionFunction = unitConverter.GetConversionFunction(VolumeUnit.OilBarrel, VolumeUnit.UsGallon); var converted = foundConversionFunction(Volume.FromOilBarrels(1)); From 995be8c594ee5865db18cbbe7b9f597a6a72437b Mon Sep 17 00:00:00 2001 From: Andreas Gullberg Larsen Date: Mon, 22 Apr 2019 10:33:31 +0200 Subject: [PATCH 17/21] QuantityParser: Make field readonly --- UnitsNet/CustomCode/QuantityParser.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/UnitsNet/CustomCode/QuantityParser.cs b/UnitsNet/CustomCode/QuantityParser.cs index 82c9b4f097..596a8a8e18 100644 --- a/UnitsNet/CustomCode/QuantityParser.cs +++ b/UnitsNet/CustomCode/QuantityParser.cs @@ -25,7 +25,7 @@ internal class QuantityParser private const NumberStyles ParseNumberStyles = NumberStyles.Number | NumberStyles.Float | NumberStyles.AllowExponent; private readonly UnitAbbreviationsCache _unitAbbreviationsCache; - private UnitParser _unitParser; + private readonly UnitParser _unitParser; public static QuantityParser Default { get; } From b60a94035a6b370d99f03016eec65425c3bcab92 Mon Sep 17 00:00:00 2001 From: Andreas Gullberg Larsen Date: Mon, 22 Apr 2019 11:41:19 +0200 Subject: [PATCH 18/21] UnitParser: Add test parsing HowMuch custom unit --- UnitsNet.Tests/UnitParserTests.cs | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/UnitsNet.Tests/UnitParserTests.cs b/UnitsNet.Tests/UnitParserTests.cs index 6dfdf7021c..9b599ccca4 100644 --- a/UnitsNet.Tests/UnitParserTests.cs +++ b/UnitsNet.Tests/UnitParserTests.cs @@ -3,6 +3,7 @@ using System; using System.Globalization; +using UnitsNet.Tests.CustomQuantities; using UnitsNet.Units; using Xunit; @@ -145,5 +146,17 @@ public void ParseMassUnit_GivenCulture(string str, string cultureName, Enum expe { Assert.Equal(expectedUnit, UnitParser.Default.Parse(str, new CultureInfo(cultureName))); } + + [Fact] + public void Parse_MappedCustomUnit() + { + var unitAbbreviationsCache = new UnitAbbreviationsCache(); + unitAbbreviationsCache.MapUnitToAbbreviation(HowMuchUnit.Some, "fooh"); + var unitParser = new UnitParser(unitAbbreviationsCache); + + var parsedUnit = unitParser.Parse("fooh"); + + Assert.Equal(HowMuchUnit.Some, parsedUnit); + } } } From 605386d784fc697181279e093707a8c9251b3604 Mon Sep 17 00:00:00 2001 From: Andreas Gullberg Larsen Date: Mon, 22 Apr 2019 11:45:24 +0200 Subject: [PATCH 19/21] UnitConverter: Echo quantity when converting to same unit, test custom quantity conversions --- UnitsNet.Tests/UnitConverterTest.cs | 32 +++++++++++++++++++++++++++++ UnitsNet/UnitConverter.cs | 7 +++++++ 2 files changed, 39 insertions(+) diff --git a/UnitsNet.Tests/UnitConverterTest.cs b/UnitsNet.Tests/UnitConverterTest.cs index cf8c313e46..c94ef6159e 100644 --- a/UnitsNet.Tests/UnitConverterTest.cs +++ b/UnitsNet.Tests/UnitConverterTest.cs @@ -1,6 +1,8 @@ // Licensed under MIT No Attribution, see LICENSE file at the root. // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet. +using System; +using UnitsNet.Tests.CustomQuantities; using UnitsNet.Units; using Xunit; @@ -78,6 +80,36 @@ public void TryCustomConversionForOilBarrelsToUsGallons() Assert.Equal(Volume.FromUsGallons(42), converted); } + [Fact] + public void ConversionToSameUnit_ReturnsSameQuantity() + { + var unitConverter = new UnitConverter(); + + var foundConversionFunction = unitConverter.GetConversionFunction(HowMuchUnit.ATon, HowMuchUnit.ATon); + var converted = foundConversionFunction(new HowMuch(39, HowMuchUnit.Some)); // Intentionally pass the wrong unit here, to test that the exact same quantity is returned + + Assert.Equal(39, converted.Value); + Assert.Equal(HowMuchUnit.Some, converted.Unit); + } + + [Theory] + [InlineData(1, HowMuchUnit.Some, HowMuchUnit.Some, 1)] + [InlineData(1, HowMuchUnit.Some, HowMuchUnit.ATon, 2)] + [InlineData(1, HowMuchUnit.Some, HowMuchUnit.AShitTon, 10)] + public void ConversionForUnitsOfCustomQuantity(double fromValue, Enum fromUnit, Enum toUnit, double expectedValue) + { + // Intentionally don't map conversion Some->Some, it is not necessary + var unitConverter = new UnitConverter(); + unitConverter.SetConversionFunction(HowMuchUnit.Some, HowMuchUnit.ATon, x => new HowMuch(x.Value * 2, HowMuchUnit.ATon)); + unitConverter.SetConversionFunction(HowMuchUnit.Some, HowMuchUnit.AShitTon, x => new HowMuch(x.Value * 10, HowMuchUnit.AShitTon)); + + var foundConversionFunction = unitConverter.GetConversionFunction(fromUnit, toUnit); + var converted = foundConversionFunction(new HowMuch(fromValue, fromUnit)); + + Assert.Equal(expectedValue, converted.Value); + Assert.Equal(toUnit, converted.Unit); + } + [Theory] [InlineData(0, 0, "length", "meter", "centimeter")] [InlineData(0, 0, "Length", "Meter", "Centimeter")] diff --git a/UnitsNet/UnitConverter.cs b/UnitsNet/UnitConverter.cs index 18bbc3b856..b9641f03ce 100644 --- a/UnitsNet/UnitConverter.cs +++ b/UnitsNet/UnitConverter.cs @@ -162,6 +162,13 @@ public ConversionFunction GetConversionFunction(Type fromType, Enum from, Type t /// internal ConversionFunction GetConversionFunction(ConversionFunctionLookupKey lookupKey) { + IQuantity EchoFunction(IQuantity fromQuantity) => fromQuantity; + + // If from/to units and to quantity types are equal, then return a function that echoes the input quantity + // in order to not have to map conversion functions to "self". + if (lookupKey.Item1 == lookupKey.Item3 && Equals(lookupKey.Item2, lookupKey.Item4)) + return EchoFunction; + return _conversionFunctions[lookupKey]; } From dff33f02097d7e865def5ef942a199e45012b689 Mon Sep 17 00:00:00 2001 From: Andreas Gullberg Larsen Date: Thu, 2 May 2019 01:40:53 +0200 Subject: [PATCH 20/21] Port codegen scripts to C# The only difference is fixing the header of a file. --- .../UnitsNetGen/QuantityGenerator.cs | 11 ++++ .../UnitsNetGen/UnitConverterGenerator.cs | 56 +++++++++++++++++++ CodeGen/Generators/UnitsNetGenerator.cs | 8 +++ UnitsNet/GeneratedCode/UnitConverter.g.cs | 18 +++++- 4 files changed, 92 insertions(+), 1 deletion(-) create mode 100644 CodeGen/Generators/UnitsNetGen/UnitConverterGenerator.cs diff --git a/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs b/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs index 1d8692fe51..397d5910b6 100644 --- a/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs +++ b/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs @@ -904,6 +904,17 @@ IQuantity IQuantity.ToUnit(Enum unit) }} }} + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal {_quantity.Name} ToBaseUnit() + {{ + var baseUnitValue = GetValueInBaseUnit(); + return new {_quantity.Name}(baseUnitValue, BaseUnit); + }} + private {_valueType} GetValueAs({_unitEnumName} unit) {{ if(Unit == unit) diff --git a/CodeGen/Generators/UnitsNetGen/UnitConverterGenerator.cs b/CodeGen/Generators/UnitsNetGen/UnitConverterGenerator.cs new file mode 100644 index 0000000000..09047b06e9 --- /dev/null +++ b/CodeGen/Generators/UnitsNetGen/UnitConverterGenerator.cs @@ -0,0 +1,56 @@ +// Licensed under MIT No Attribution, see LICENSE file at the root. +// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet. + +using CodeGen.Helpers; +using CodeGen.JsonTypes; + +namespace CodeGen.Generators.UnitsNetGen +{ + internal class UnitConverterGenerator : GeneratorBase + { + private readonly Quantity[] _quantities; + + public UnitConverterGenerator(Quantity[] quantities) + { + _quantities = quantities; + } + + public override string Generate() + { + Writer.WL(GeneratedFileHeader); + Writer.WL($@" +using UnitsNet.Units; + +// ReSharper disable RedundantCommaInArrayInitializer +// ReSharper disable once CheckNamespace + +namespace UnitsNet +{{ + public sealed partial class UnitConverter + {{ + /// + /// Registers the default conversion functions in the given instance. + /// + /// The to register the default conversion functions in. + public static void RegisterDefaultConversions(UnitConverter unitConverter) + {{"); + foreach (Quantity quantity in _quantities) + foreach (Unit unit in quantity.Units) + { + Writer.WL(quantity.BaseUnit == unit.SingularName + ? $@" + unitConverter.SetConversionFunction<{quantity.Name}>({quantity.Name}.BaseUnit, {quantity.Name}.BaseUnit, q => q);" + : $@" + unitConverter.SetConversionFunction<{quantity.Name}>({quantity.Name}.BaseUnit, {quantity.Name}Unit.{unit.SingularName}, q => q.ToUnit({quantity.Name}Unit.{unit.SingularName})); + unitConverter.SetConversionFunction<{quantity.Name}>({quantity.Name}Unit.{unit.SingularName}, {quantity.Name}.BaseUnit, q => q.ToBaseUnit());"); + } + + Writer.WL($@" + }} + }} +}}"); + + return Writer.ToString(); + } + } +} diff --git a/CodeGen/Generators/UnitsNetGenerator.cs b/CodeGen/Generators/UnitsNetGenerator.cs index 2bbd8655c7..6669647c2b 100644 --- a/CodeGen/Generators/UnitsNetGenerator.cs +++ b/CodeGen/Generators/UnitsNetGenerator.cs @@ -53,6 +53,7 @@ public static void Generate(string rootDir, Quantity[] quantities) GenerateUnitAbbreviationsCache(quantities, $"{outputDir}/UnitAbbreviationsCache.g.cs"); GenerateQuantityType(quantities, $"{outputDir}/QuantityType.g.cs"); GenerateStaticQuantity(quantities, $"{outputDir}/Quantity.g.cs"); + GenerateUnitConverter(quantities, $"{outputDir}/UnitConverter.g.cs"); var unitCount = quantities.SelectMany(q => q.Units).Count(); Log.Information(""); @@ -114,5 +115,12 @@ private static void GenerateStaticQuantity(Quantity[] quantities, string filePat File.WriteAllText(filePath, content, Encoding.UTF8); Log.Information("Quantity.g.cs: ".PadRight(AlignPad) + "(OK)"); } + + private static void GenerateUnitConverter(Quantity[] quantities, string filePath) + { + var content = new UnitConverterGenerator(quantities).Generate(); + File.WriteAllText(filePath, content, Encoding.UTF8); + Log.Information("UnitConverter.g.cs: ".PadRight(AlignPad) + "(OK)"); + } } } diff --git a/UnitsNet/GeneratedCode/UnitConverter.g.cs b/UnitsNet/GeneratedCode/UnitConverter.g.cs index 5a5f706403..827c6efaca 100644 --- a/UnitsNet/GeneratedCode/UnitConverter.g.cs +++ b/UnitsNet/GeneratedCode/UnitConverter.g.cs @@ -1,4 +1,20 @@ -// Licensed under MIT No Attribution, see LICENSE file at the root. +//------------------------------------------------------------------------------ +// +// This code was generated by \generate-code.bat. +// +// Changes to this file will be lost when the code is regenerated. +// The build server regenerates the code before each build and a pre-build +// step will regenerate the code on each local build. +// +// See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units. +// +// Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities. +// Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities. +// +// +//------------------------------------------------------------------------------ + +// Licensed under MIT No Attribution, see LICENSE file at the root. // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet. using UnitsNet.Units; From 53c43cf1a09ed071cbf36c67640e98b5e7d1821d Mon Sep 17 00:00:00 2001 From: Andreas Gullberg Larsen Date: Wed, 17 Jul 2019 22:54:10 +0200 Subject: [PATCH 21/21] Regen code --- UnitsNet/GeneratedCode/UnitConverter.g.cs | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/UnitsNet/GeneratedCode/UnitConverter.g.cs b/UnitsNet/GeneratedCode/UnitConverter.g.cs index 827c6efaca..9c6f6748c1 100644 --- a/UnitsNet/GeneratedCode/UnitConverter.g.cs +++ b/UnitsNet/GeneratedCode/UnitConverter.g.cs @@ -153,6 +153,8 @@ public static void RegisterDefaultConversions(UnitConverter unitConverter) unitConverter.SetConversionFunction(AreaUnit.SquareMile, Area.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareMillimeter, q => q.ToUnit(AreaUnit.SquareMillimeter)); unitConverter.SetConversionFunction(AreaUnit.SquareMillimeter, Area.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareNauticalMile, q => q.ToUnit(AreaUnit.SquareNauticalMile)); + unitConverter.SetConversionFunction(AreaUnit.SquareNauticalMile, Area.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.SquareYard, q => q.ToUnit(AreaUnit.SquareYard)); unitConverter.SetConversionFunction(AreaUnit.SquareYard, Area.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Area.BaseUnit, AreaUnit.UsSurveySquareFoot, q => q.ToUnit(AreaUnit.UsSurveySquareFoot)); @@ -595,6 +597,12 @@ public static void RegisterDefaultConversions(UnitConverter unitConverter) unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.NanonewtonPerMeter, q => q.ToUnit(ForcePerLengthUnit.NanonewtonPerMeter)); unitConverter.SetConversionFunction(ForcePerLengthUnit.NanonewtonPerMeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLength.BaseUnit, q => q); + unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.PoundForcePerFoot, q => q.ToUnit(ForcePerLengthUnit.PoundForcePerFoot)); + unitConverter.SetConversionFunction(ForcePerLengthUnit.PoundForcePerFoot, ForcePerLength.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.PoundForcePerInch, q => q.ToUnit(ForcePerLengthUnit.PoundForcePerInch)); + unitConverter.SetConversionFunction(ForcePerLengthUnit.PoundForcePerInch, ForcePerLength.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.PoundForcePerYard, q => q.ToUnit(ForcePerLengthUnit.PoundForcePerYard)); + unitConverter.SetConversionFunction(ForcePerLengthUnit.PoundForcePerYard, ForcePerLength.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Frequency.BaseUnit, FrequencyUnit.BeatPerMinute, q => q.ToUnit(FrequencyUnit.BeatPerMinute)); unitConverter.SetConversionFunction(FrequencyUnit.BeatPerMinute, Frequency.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Frequency.BaseUnit, FrequencyUnit.CyclePerHour, q => q.ToUnit(FrequencyUnit.CyclePerHour)); @@ -647,6 +655,8 @@ public static void RegisterDefaultConversions(UnitConverter unitConverter) unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFluxUnit.WattPerSquareInch, q => q.ToUnit(HeatFluxUnit.WattPerSquareInch)); unitConverter.SetConversionFunction(HeatFluxUnit.WattPerSquareInch, HeatFlux.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(HeatFlux.BaseUnit, HeatFlux.BaseUnit, q => q); + unitConverter.SetConversionFunction(HeatTransferCoefficient.BaseUnit, HeatTransferCoefficientUnit.BtuPerSquareFootDegreeFahrenheit, q => q.ToUnit(HeatTransferCoefficientUnit.BtuPerSquareFootDegreeFahrenheit)); + unitConverter.SetConversionFunction(HeatTransferCoefficientUnit.BtuPerSquareFootDegreeFahrenheit, HeatTransferCoefficient.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(HeatTransferCoefficient.BaseUnit, HeatTransferCoefficientUnit.WattPerSquareMeterCelsius, q => q.ToUnit(HeatTransferCoefficientUnit.WattPerSquareMeterCelsius)); unitConverter.SetConversionFunction(HeatTransferCoefficientUnit.WattPerSquareMeterCelsius, HeatTransferCoefficient.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(HeatTransferCoefficient.BaseUnit, HeatTransferCoefficient.BaseUnit, q => q); @@ -991,6 +1001,8 @@ public static void RegisterDefaultConversions(UnitConverter unitConverter) unitConverter.SetConversionFunction(MassFlowUnit.MegapoundPerHour, MassFlow.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MegapoundPerMinute, q => q.ToUnit(MassFlowUnit.MegapoundPerMinute)); unitConverter.SetConversionFunction(MassFlowUnit.MegapoundPerMinute, MassFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MegapoundPerSecond, q => q.ToUnit(MassFlowUnit.MegapoundPerSecond)); + unitConverter.SetConversionFunction(MassFlowUnit.MegapoundPerSecond, MassFlow.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MicrogramPerDay, q => q.ToUnit(MassFlowUnit.MicrogramPerDay)); unitConverter.SetConversionFunction(MassFlowUnit.MicrogramPerDay, MassFlow.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.MicrogramPerSecond, q => q.ToUnit(MassFlowUnit.MicrogramPerSecond)); @@ -1009,6 +1021,8 @@ public static void RegisterDefaultConversions(UnitConverter unitConverter) unitConverter.SetConversionFunction(MassFlowUnit.PoundPerHour, MassFlow.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.PoundPerMinute, q => q.ToUnit(MassFlowUnit.PoundPerMinute)); unitConverter.SetConversionFunction(MassFlowUnit.PoundPerMinute, MassFlow.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.PoundPerSecond, q => q.ToUnit(MassFlowUnit.PoundPerSecond)); + unitConverter.SetConversionFunction(MassFlowUnit.PoundPerSecond, MassFlow.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.ShortTonPerHour, q => q.ToUnit(MassFlowUnit.ShortTonPerHour)); unitConverter.SetConversionFunction(MassFlowUnit.ShortTonPerHour, MassFlow.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(MassFlow.BaseUnit, MassFlowUnit.TonnePerDay, q => q.ToUnit(MassFlowUnit.TonnePerDay)); @@ -1423,6 +1437,8 @@ public static void RegisterDefaultConversions(UnitConverter unitConverter) unitConverter.SetConversionFunction(RotationalAcceleration.BaseUnit, RotationalAcceleration.BaseUnit, q => q); unitConverter.SetConversionFunction(RotationalAcceleration.BaseUnit, RotationalAccelerationUnit.RevolutionPerMinutePerSecond, q => q.ToUnit(RotationalAccelerationUnit.RevolutionPerMinutePerSecond)); unitConverter.SetConversionFunction(RotationalAccelerationUnit.RevolutionPerMinutePerSecond, RotationalAcceleration.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(RotationalAcceleration.BaseUnit, RotationalAccelerationUnit.RevolutionPerSecondSquared, q => q.ToUnit(RotationalAccelerationUnit.RevolutionPerSecondSquared)); + unitConverter.SetConversionFunction(RotationalAccelerationUnit.RevolutionPerSecondSquared, RotationalAcceleration.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.CentiradianPerSecond, q => q.ToUnit(RotationalSpeedUnit.CentiradianPerSecond)); unitConverter.SetConversionFunction(RotationalSpeedUnit.CentiradianPerSecond, RotationalSpeed.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(RotationalSpeed.BaseUnit, RotationalSpeedUnit.DeciradianPerSecond, q => q.ToUnit(RotationalSpeedUnit.DeciradianPerSecond));