diff --git a/UnitsNet.Tests/CustomCode/TemperatureDeltaTests.cs b/UnitsNet.Tests/CustomCode/TemperatureDeltaTests.cs index c4fcc50589..93bec7b831 100644 --- a/UnitsNet.Tests/CustomCode/TemperatureDeltaTests.cs +++ b/UnitsNet.Tests/CustomCode/TemperatureDeltaTests.cs @@ -44,13 +44,22 @@ namespace UnitsNet.Tests.CustomCode { public class TemperatureDeltaTests : TemperatureDeltaTestsBase { - protected override double DegreesCelsiusDeltaInOneKelvinDelta => 1; - protected override double DegreesDelisleDeltaInOneKelvinDelta => -1.5d; - protected override double DegreesFahrenheitDeltaInOneKelvinDelta => 1.8; - protected override double DegreesNewtonDeltaInOneKelvinDelta => 0.33d; - protected override double DegreesRankineDeltaInOneKelvinDelta => 1.8; - protected override double DegreesReaumurDeltaInOneKelvinDelta => 0.8; - protected override double DegreesRoemerDeltaInOneKelvinDelta => 21/40d; - protected override double KelvinsDeltaInOneKelvinDelta => 1; + protected override double DegreesCelsiusDeltaInOneKelvin => 1; + protected override double DegreesDelisleDeltaInOneKelvin => -1.5d; + protected override double DegreesFahrenheitDeltaInOneKelvin => 1.8; + protected override double DegreesNewtonDeltaInOneKelvin => 0.33d; + protected override double DegreesRankineDeltaInOneKelvin => 1.8; + protected override double DegreesReaumurDeltaInOneKelvin => 0.8; + protected override double DegreesRoemerDeltaInOneKelvin => 21/40d; + protected override double KelvinsDeltaInOneKelvin => 1; + + protected override double DegreesCelsiusInOneKelvin => 1; + protected override double DegreesDelisleInOneKelvin => -1.5d; + protected override double DegreesFahrenheitInOneKelvin => 1.8; + protected override double DegreesNewtonInOneKelvin => 0.33d; + protected override double DegreesRankineInOneKelvin => 1.8; + protected override double DegreesReaumurInOneKelvin => 0.8; + protected override double DegreesRoemerInOneKelvin => 21 / 40d; + protected override double KelvinsInOneKelvin => 1; } } diff --git a/UnitsNet.Tests/CustomCode/TemperatureTests.cs b/UnitsNet.Tests/CustomCode/TemperatureTests.cs index 6ea8178b62..ad2c029b78 100644 --- a/UnitsNet.Tests/CustomCode/TemperatureTests.cs +++ b/UnitsNet.Tests/CustomCode/TemperatureTests.cs @@ -19,6 +19,7 @@ // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // THE SOFTWARE. +using System; using System.Diagnostics.CodeAnalysis; using System.Globalization; using Xunit; @@ -94,7 +95,7 @@ public void MultiplyByTemperatureDeltaEqualsTemperature(TemperatureUnit unit, in public void TemperatureDeltaPlusTemperatureEqualsTemperature(TemperatureUnit unit, int deltaVal, int temperatureVal, string expected) { Temperature temperature = Temperature.From(temperatureVal, unit); - TemperatureDelta delta = TemperatureDelta.From(deltaVal, (TemperatureDeltaUnit) unit); + TemperatureDelta delta = TemperatureDelta.From(deltaVal, (TemperatureDeltaUnit)Enum.Parse(typeof(TemperatureDeltaUnit), unit.ToString())); // Act Temperature resultTemp = delta + temperature; @@ -113,7 +114,7 @@ public void TemperatureDeltaPlusTemperatureEqualsTemperature(TemperatureUnit uni public void TemperatureMinusTemperatureDeltaEqualsTemperature(TemperatureUnit unit, int temperatureVal, int deltaVal, string expected) { Temperature temperature = Temperature.From(temperatureVal, unit); - TemperatureDelta delta = TemperatureDelta.From(deltaVal, (TemperatureDeltaUnit) unit); + TemperatureDelta delta = TemperatureDelta.From(deltaVal, (TemperatureDeltaUnit)Enum.Parse(typeof(TemperatureDeltaUnit), unit.ToString())); // Act Temperature resultTemp = temperature - delta; @@ -132,7 +133,7 @@ public void TemperatureMinusTemperatureDeltaEqualsTemperature(TemperatureUnit un public void TemperaturePlusTemperatureDeltaEqualsTemperature(TemperatureUnit unit, int temperatureVal, int deltaVal, string expected) { Temperature temperature = Temperature.From(temperatureVal, unit); - TemperatureDelta delta = TemperatureDelta.From(deltaVal, (TemperatureDeltaUnit) unit); + TemperatureDelta delta = TemperatureDelta.From(deltaVal, (TemperatureDeltaUnit)Enum.Parse(typeof(TemperatureDeltaUnit), unit.ToString())); // Act Temperature resultTemp = temperature + delta; diff --git a/UnitsNet.Tests/GeneratedCode/TemperatureDeltaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TemperatureDeltaTestsBase.g.cs index 68c86589cf..cd6c968011 100644 --- a/UnitsNet.Tests/GeneratedCode/TemperatureDeltaTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TemperatureDeltaTestsBase.g.cs @@ -52,140 +52,188 @@ namespace UnitsNet.Tests // ReSharper disable once PartialTypeWithSinglePart public abstract partial class TemperatureDeltaTestsBase { - protected abstract double DegreesCelsiusDeltaInOneKelvinDelta { get; } - protected abstract double DegreesDelisleDeltaInOneKelvinDelta { get; } - protected abstract double DegreesFahrenheitDeltaInOneKelvinDelta { get; } - protected abstract double DegreesNewtonDeltaInOneKelvinDelta { get; } - protected abstract double DegreesRankineDeltaInOneKelvinDelta { get; } - protected abstract double DegreesReaumurDeltaInOneKelvinDelta { get; } - protected abstract double DegreesRoemerDeltaInOneKelvinDelta { get; } - protected abstract double KelvinsDeltaInOneKelvinDelta { get; } + protected abstract double DegreesCelsiusInOneKelvin { get; } + protected abstract double DegreesCelsiusDeltaInOneKelvin { get; } + protected abstract double DegreesDelisleInOneKelvin { get; } + protected abstract double DegreesDelisleDeltaInOneKelvin { get; } + protected abstract double DegreesFahrenheitInOneKelvin { get; } + protected abstract double DegreesFahrenheitDeltaInOneKelvin { get; } + protected abstract double DegreesNewtonInOneKelvin { get; } + protected abstract double DegreesNewtonDeltaInOneKelvin { get; } + protected abstract double DegreesRankineInOneKelvin { get; } + protected abstract double DegreesRankineDeltaInOneKelvin { get; } + protected abstract double DegreesReaumurInOneKelvin { get; } + protected abstract double DegreesReaumurDeltaInOneKelvin { get; } + protected abstract double DegreesRoemerInOneKelvin { get; } + protected abstract double DegreesRoemerDeltaInOneKelvin { get; } + protected abstract double KelvinsInOneKelvin { get; } + protected abstract double KelvinsDeltaInOneKelvin { get; } // ReSharper disable VirtualMemberNeverOverriden.Global + protected virtual double DegreesCelsiusTolerance { get { return 1e-5; } } protected virtual double DegreesCelsiusDeltaTolerance { get { return 1e-5; } } + protected virtual double DegreesDelisleTolerance { get { return 1e-5; } } protected virtual double DegreesDelisleDeltaTolerance { get { return 1e-5; } } + protected virtual double DegreesFahrenheitTolerance { get { return 1e-5; } } protected virtual double DegreesFahrenheitDeltaTolerance { get { return 1e-5; } } + protected virtual double DegreesNewtonTolerance { get { return 1e-5; } } protected virtual double DegreesNewtonDeltaTolerance { get { return 1e-5; } } + protected virtual double DegreesRankineTolerance { get { return 1e-5; } } protected virtual double DegreesRankineDeltaTolerance { get { return 1e-5; } } + protected virtual double DegreesReaumurTolerance { get { return 1e-5; } } protected virtual double DegreesReaumurDeltaTolerance { get { return 1e-5; } } + protected virtual double DegreesRoemerTolerance { get { return 1e-5; } } protected virtual double DegreesRoemerDeltaTolerance { get { return 1e-5; } } + protected virtual double KelvinsTolerance { get { return 1e-5; } } protected virtual double KelvinsDeltaTolerance { get { return 1e-5; } } // ReSharper restore VirtualMemberNeverOverriden.Global [Fact] - public void KelvinDeltaToTemperatureDeltaUnits() + public void KelvinToTemperatureDeltaUnits() { - TemperatureDelta kelvindelta = TemperatureDelta.FromKelvinsDelta(1); - AssertEx.EqualTolerance(DegreesCelsiusDeltaInOneKelvinDelta, kelvindelta.DegreesCelsiusDelta, DegreesCelsiusDeltaTolerance); - AssertEx.EqualTolerance(DegreesDelisleDeltaInOneKelvinDelta, kelvindelta.DegreesDelisleDelta, DegreesDelisleDeltaTolerance); - AssertEx.EqualTolerance(DegreesFahrenheitDeltaInOneKelvinDelta, kelvindelta.DegreesFahrenheitDelta, DegreesFahrenheitDeltaTolerance); - AssertEx.EqualTolerance(DegreesNewtonDeltaInOneKelvinDelta, kelvindelta.DegreesNewtonDelta, DegreesNewtonDeltaTolerance); - AssertEx.EqualTolerance(DegreesRankineDeltaInOneKelvinDelta, kelvindelta.DegreesRankineDelta, DegreesRankineDeltaTolerance); - AssertEx.EqualTolerance(DegreesReaumurDeltaInOneKelvinDelta, kelvindelta.DegreesReaumurDelta, DegreesReaumurDeltaTolerance); - AssertEx.EqualTolerance(DegreesRoemerDeltaInOneKelvinDelta, kelvindelta.DegreesRoemerDelta, DegreesRoemerDeltaTolerance); - AssertEx.EqualTolerance(KelvinsDeltaInOneKelvinDelta, kelvindelta.KelvinsDelta, KelvinsDeltaTolerance); + TemperatureDelta kelvin = TemperatureDelta.FromKelvins(1); + AssertEx.EqualTolerance(DegreesCelsiusInOneKelvin, kelvin.DegreesCelsius, DegreesCelsiusTolerance); + AssertEx.EqualTolerance(DegreesCelsiusDeltaInOneKelvin, kelvin.DegreesCelsiusDelta, DegreesCelsiusDeltaTolerance); + AssertEx.EqualTolerance(DegreesDelisleInOneKelvin, kelvin.DegreesDelisle, DegreesDelisleTolerance); + AssertEx.EqualTolerance(DegreesDelisleDeltaInOneKelvin, kelvin.DegreesDelisleDelta, DegreesDelisleDeltaTolerance); + AssertEx.EqualTolerance(DegreesFahrenheitInOneKelvin, kelvin.DegreesFahrenheit, DegreesFahrenheitTolerance); + AssertEx.EqualTolerance(DegreesFahrenheitDeltaInOneKelvin, kelvin.DegreesFahrenheitDelta, DegreesFahrenheitDeltaTolerance); + AssertEx.EqualTolerance(DegreesNewtonInOneKelvin, kelvin.DegreesNewton, DegreesNewtonTolerance); + AssertEx.EqualTolerance(DegreesNewtonDeltaInOneKelvin, kelvin.DegreesNewtonDelta, DegreesNewtonDeltaTolerance); + AssertEx.EqualTolerance(DegreesRankineInOneKelvin, kelvin.DegreesRankine, DegreesRankineTolerance); + AssertEx.EqualTolerance(DegreesRankineDeltaInOneKelvin, kelvin.DegreesRankineDelta, DegreesRankineDeltaTolerance); + AssertEx.EqualTolerance(DegreesReaumurInOneKelvin, kelvin.DegreesReaumur, DegreesReaumurTolerance); + AssertEx.EqualTolerance(DegreesReaumurDeltaInOneKelvin, kelvin.DegreesReaumurDelta, DegreesReaumurDeltaTolerance); + AssertEx.EqualTolerance(DegreesRoemerInOneKelvin, kelvin.DegreesRoemer, DegreesRoemerTolerance); + AssertEx.EqualTolerance(DegreesRoemerDeltaInOneKelvin, kelvin.DegreesRoemerDelta, DegreesRoemerDeltaTolerance); + AssertEx.EqualTolerance(KelvinsInOneKelvin, kelvin.Kelvins, KelvinsTolerance); + AssertEx.EqualTolerance(KelvinsDeltaInOneKelvin, kelvin.KelvinsDelta, KelvinsDeltaTolerance); } [Fact] public void FromValueAndUnit() { + AssertEx.EqualTolerance(1, TemperatureDelta.From(1, TemperatureDeltaUnit.DegreeCelsius).DegreesCelsius, DegreesCelsiusTolerance); AssertEx.EqualTolerance(1, TemperatureDelta.From(1, TemperatureDeltaUnit.DegreeCelsiusDelta).DegreesCelsiusDelta, DegreesCelsiusDeltaTolerance); + AssertEx.EqualTolerance(1, TemperatureDelta.From(1, TemperatureDeltaUnit.DegreeDelisle).DegreesDelisle, DegreesDelisleTolerance); AssertEx.EqualTolerance(1, TemperatureDelta.From(1, TemperatureDeltaUnit.DegreeDelisleDelta).DegreesDelisleDelta, DegreesDelisleDeltaTolerance); + AssertEx.EqualTolerance(1, TemperatureDelta.From(1, TemperatureDeltaUnit.DegreeFahrenheit).DegreesFahrenheit, DegreesFahrenheitTolerance); AssertEx.EqualTolerance(1, TemperatureDelta.From(1, TemperatureDeltaUnit.DegreeFahrenheitDelta).DegreesFahrenheitDelta, DegreesFahrenheitDeltaTolerance); + AssertEx.EqualTolerance(1, TemperatureDelta.From(1, TemperatureDeltaUnit.DegreeNewton).DegreesNewton, DegreesNewtonTolerance); AssertEx.EqualTolerance(1, TemperatureDelta.From(1, TemperatureDeltaUnit.DegreeNewtonDelta).DegreesNewtonDelta, DegreesNewtonDeltaTolerance); + AssertEx.EqualTolerance(1, TemperatureDelta.From(1, TemperatureDeltaUnit.DegreeRankine).DegreesRankine, DegreesRankineTolerance); AssertEx.EqualTolerance(1, TemperatureDelta.From(1, TemperatureDeltaUnit.DegreeRankineDelta).DegreesRankineDelta, DegreesRankineDeltaTolerance); + AssertEx.EqualTolerance(1, TemperatureDelta.From(1, TemperatureDeltaUnit.DegreeReaumur).DegreesReaumur, DegreesReaumurTolerance); AssertEx.EqualTolerance(1, TemperatureDelta.From(1, TemperatureDeltaUnit.DegreeReaumurDelta).DegreesReaumurDelta, DegreesReaumurDeltaTolerance); + AssertEx.EqualTolerance(1, TemperatureDelta.From(1, TemperatureDeltaUnit.DegreeRoemer).DegreesRoemer, DegreesRoemerTolerance); AssertEx.EqualTolerance(1, TemperatureDelta.From(1, TemperatureDeltaUnit.DegreeRoemerDelta).DegreesRoemerDelta, DegreesRoemerDeltaTolerance); + AssertEx.EqualTolerance(1, TemperatureDelta.From(1, TemperatureDeltaUnit.Kelvin).Kelvins, KelvinsTolerance); AssertEx.EqualTolerance(1, TemperatureDelta.From(1, TemperatureDeltaUnit.KelvinDelta).KelvinsDelta, KelvinsDeltaTolerance); } [Fact] public void As() { - var kelvindelta = TemperatureDelta.FromKelvinsDelta(1); - AssertEx.EqualTolerance(DegreesCelsiusDeltaInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeCelsiusDelta), DegreesCelsiusDeltaTolerance); - AssertEx.EqualTolerance(DegreesDelisleDeltaInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeDelisleDelta), DegreesDelisleDeltaTolerance); - AssertEx.EqualTolerance(DegreesFahrenheitDeltaInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeFahrenheitDelta), DegreesFahrenheitDeltaTolerance); - AssertEx.EqualTolerance(DegreesNewtonDeltaInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeNewtonDelta), DegreesNewtonDeltaTolerance); - AssertEx.EqualTolerance(DegreesRankineDeltaInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeRankineDelta), DegreesRankineDeltaTolerance); - AssertEx.EqualTolerance(DegreesReaumurDeltaInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeReaumurDelta), DegreesReaumurDeltaTolerance); - AssertEx.EqualTolerance(DegreesRoemerDeltaInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeRoemerDelta), DegreesRoemerDeltaTolerance); - AssertEx.EqualTolerance(KelvinsDeltaInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.KelvinDelta), KelvinsDeltaTolerance); + var kelvin = TemperatureDelta.FromKelvins(1); + AssertEx.EqualTolerance(DegreesCelsiusInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeCelsius), DegreesCelsiusTolerance); + AssertEx.EqualTolerance(DegreesCelsiusDeltaInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeCelsiusDelta), DegreesCelsiusDeltaTolerance); + AssertEx.EqualTolerance(DegreesDelisleInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeDelisle), DegreesDelisleTolerance); + AssertEx.EqualTolerance(DegreesDelisleDeltaInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeDelisleDelta), DegreesDelisleDeltaTolerance); + AssertEx.EqualTolerance(DegreesFahrenheitInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeFahrenheit), DegreesFahrenheitTolerance); + AssertEx.EqualTolerance(DegreesFahrenheitDeltaInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeFahrenheitDelta), DegreesFahrenheitDeltaTolerance); + AssertEx.EqualTolerance(DegreesNewtonInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeNewton), DegreesNewtonTolerance); + AssertEx.EqualTolerance(DegreesNewtonDeltaInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeNewtonDelta), DegreesNewtonDeltaTolerance); + AssertEx.EqualTolerance(DegreesRankineInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeRankine), DegreesRankineTolerance); + AssertEx.EqualTolerance(DegreesRankineDeltaInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeRankineDelta), DegreesRankineDeltaTolerance); + AssertEx.EqualTolerance(DegreesReaumurInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeReaumur), DegreesReaumurTolerance); + AssertEx.EqualTolerance(DegreesReaumurDeltaInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeReaumurDelta), DegreesReaumurDeltaTolerance); + AssertEx.EqualTolerance(DegreesRoemerInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeRoemer), DegreesRoemerTolerance); + AssertEx.EqualTolerance(DegreesRoemerDeltaInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeRoemerDelta), DegreesRoemerDeltaTolerance); + AssertEx.EqualTolerance(KelvinsInOneKelvin, kelvin.As(TemperatureDeltaUnit.Kelvin), KelvinsTolerance); + AssertEx.EqualTolerance(KelvinsDeltaInOneKelvin, kelvin.As(TemperatureDeltaUnit.KelvinDelta), KelvinsDeltaTolerance); } [Fact] public void ConversionRoundTrip() { - TemperatureDelta kelvindelta = TemperatureDelta.FromKelvinsDelta(1); - AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesCelsiusDelta(kelvindelta.DegreesCelsiusDelta).KelvinsDelta, DegreesCelsiusDeltaTolerance); - AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesDelisleDelta(kelvindelta.DegreesDelisleDelta).KelvinsDelta, DegreesDelisleDeltaTolerance); - AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesFahrenheitDelta(kelvindelta.DegreesFahrenheitDelta).KelvinsDelta, DegreesFahrenheitDeltaTolerance); - AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesNewtonDelta(kelvindelta.DegreesNewtonDelta).KelvinsDelta, DegreesNewtonDeltaTolerance); - AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesRankineDelta(kelvindelta.DegreesRankineDelta).KelvinsDelta, DegreesRankineDeltaTolerance); - AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesReaumurDelta(kelvindelta.DegreesReaumurDelta).KelvinsDelta, DegreesReaumurDeltaTolerance); - AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesRoemerDelta(kelvindelta.DegreesRoemerDelta).KelvinsDelta, DegreesRoemerDeltaTolerance); - AssertEx.EqualTolerance(1, TemperatureDelta.FromKelvinsDelta(kelvindelta.KelvinsDelta).KelvinsDelta, KelvinsDeltaTolerance); + TemperatureDelta kelvin = TemperatureDelta.FromKelvins(1); + AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesCelsius(kelvin.DegreesCelsius).Kelvins, DegreesCelsiusTolerance); + AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesCelsiusDelta(kelvin.DegreesCelsiusDelta).Kelvins, DegreesCelsiusDeltaTolerance); + AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesDelisle(kelvin.DegreesDelisle).Kelvins, DegreesDelisleTolerance); + AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesDelisleDelta(kelvin.DegreesDelisleDelta).Kelvins, DegreesDelisleDeltaTolerance); + AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesFahrenheit(kelvin.DegreesFahrenheit).Kelvins, DegreesFahrenheitTolerance); + AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesFahrenheitDelta(kelvin.DegreesFahrenheitDelta).Kelvins, DegreesFahrenheitDeltaTolerance); + AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesNewton(kelvin.DegreesNewton).Kelvins, DegreesNewtonTolerance); + AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesNewtonDelta(kelvin.DegreesNewtonDelta).Kelvins, DegreesNewtonDeltaTolerance); + AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesRankine(kelvin.DegreesRankine).Kelvins, DegreesRankineTolerance); + AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesRankineDelta(kelvin.DegreesRankineDelta).Kelvins, DegreesRankineDeltaTolerance); + AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesReaumur(kelvin.DegreesReaumur).Kelvins, DegreesReaumurTolerance); + AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesReaumurDelta(kelvin.DegreesReaumurDelta).Kelvins, DegreesReaumurDeltaTolerance); + AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesRoemer(kelvin.DegreesRoemer).Kelvins, DegreesRoemerTolerance); + AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesRoemerDelta(kelvin.DegreesRoemerDelta).Kelvins, DegreesRoemerDeltaTolerance); + AssertEx.EqualTolerance(1, TemperatureDelta.FromKelvins(kelvin.Kelvins).Kelvins, KelvinsTolerance); + AssertEx.EqualTolerance(1, TemperatureDelta.FromKelvinsDelta(kelvin.KelvinsDelta).Kelvins, KelvinsDeltaTolerance); } [Fact] public void ArithmeticOperators() { - TemperatureDelta v = TemperatureDelta.FromKelvinsDelta(1); - AssertEx.EqualTolerance(-1, -v.KelvinsDelta, KelvinsDeltaTolerance); - AssertEx.EqualTolerance(2, (TemperatureDelta.FromKelvinsDelta(3)-v).KelvinsDelta, KelvinsDeltaTolerance); - AssertEx.EqualTolerance(2, (v + v).KelvinsDelta, KelvinsDeltaTolerance); - AssertEx.EqualTolerance(10, (v*10).KelvinsDelta, KelvinsDeltaTolerance); - AssertEx.EqualTolerance(10, (10*v).KelvinsDelta, KelvinsDeltaTolerance); - AssertEx.EqualTolerance(2, (TemperatureDelta.FromKelvinsDelta(10)/5).KelvinsDelta, KelvinsDeltaTolerance); - AssertEx.EqualTolerance(2, TemperatureDelta.FromKelvinsDelta(10)/TemperatureDelta.FromKelvinsDelta(5), KelvinsDeltaTolerance); + TemperatureDelta v = TemperatureDelta.FromKelvins(1); + AssertEx.EqualTolerance(-1, -v.Kelvins, KelvinsTolerance); + AssertEx.EqualTolerance(2, (TemperatureDelta.FromKelvins(3)-v).Kelvins, KelvinsTolerance); + AssertEx.EqualTolerance(2, (v + v).Kelvins, KelvinsTolerance); + AssertEx.EqualTolerance(10, (v*10).Kelvins, KelvinsTolerance); + AssertEx.EqualTolerance(10, (10*v).Kelvins, KelvinsTolerance); + AssertEx.EqualTolerance(2, (TemperatureDelta.FromKelvins(10)/5).Kelvins, KelvinsTolerance); + AssertEx.EqualTolerance(2, TemperatureDelta.FromKelvins(10)/TemperatureDelta.FromKelvins(5), KelvinsTolerance); } [Fact] public void ComparisonOperators() { - TemperatureDelta oneKelvinDelta = TemperatureDelta.FromKelvinsDelta(1); - TemperatureDelta twoKelvinsDelta = TemperatureDelta.FromKelvinsDelta(2); - - Assert.True(oneKelvinDelta < twoKelvinsDelta); - Assert.True(oneKelvinDelta <= twoKelvinsDelta); - Assert.True(twoKelvinsDelta > oneKelvinDelta); - Assert.True(twoKelvinsDelta >= oneKelvinDelta); - - Assert.False(oneKelvinDelta > twoKelvinsDelta); - Assert.False(oneKelvinDelta >= twoKelvinsDelta); - Assert.False(twoKelvinsDelta < oneKelvinDelta); - Assert.False(twoKelvinsDelta <= oneKelvinDelta); + TemperatureDelta oneKelvin = TemperatureDelta.FromKelvins(1); + TemperatureDelta twoKelvins = TemperatureDelta.FromKelvins(2); + + Assert.True(oneKelvin < twoKelvins); + Assert.True(oneKelvin <= twoKelvins); + Assert.True(twoKelvins > oneKelvin); + Assert.True(twoKelvins >= oneKelvin); + + Assert.False(oneKelvin > twoKelvins); + Assert.False(oneKelvin >= twoKelvins); + Assert.False(twoKelvins < oneKelvin); + Assert.False(twoKelvins <= oneKelvin); } [Fact] public void CompareToIsImplemented() { - TemperatureDelta kelvindelta = TemperatureDelta.FromKelvinsDelta(1); - Assert.Equal(0, kelvindelta.CompareTo(kelvindelta)); - Assert.True(kelvindelta.CompareTo(TemperatureDelta.Zero) > 0); - Assert.True(TemperatureDelta.Zero.CompareTo(kelvindelta) < 0); + TemperatureDelta kelvin = TemperatureDelta.FromKelvins(1); + Assert.Equal(0, kelvin.CompareTo(kelvin)); + Assert.True(kelvin.CompareTo(TemperatureDelta.Zero) > 0); + Assert.True(TemperatureDelta.Zero.CompareTo(kelvin) < 0); } [Fact] public void CompareToThrowsOnTypeMismatch() { - TemperatureDelta kelvindelta = TemperatureDelta.FromKelvinsDelta(1); - Assert.Throws(() => kelvindelta.CompareTo(new object())); + TemperatureDelta kelvin = TemperatureDelta.FromKelvins(1); + Assert.Throws(() => kelvin.CompareTo(new object())); } [Fact] public void CompareToThrowsOnNull() { - TemperatureDelta kelvindelta = TemperatureDelta.FromKelvinsDelta(1); - Assert.Throws(() => kelvindelta.CompareTo(null)); + TemperatureDelta kelvin = TemperatureDelta.FromKelvins(1); + Assert.Throws(() => kelvin.CompareTo(null)); } [Fact] public void EqualityOperators() { - TemperatureDelta a = TemperatureDelta.FromKelvinsDelta(1); - TemperatureDelta b = TemperatureDelta.FromKelvinsDelta(2); + TemperatureDelta a = TemperatureDelta.FromKelvins(1); + TemperatureDelta b = TemperatureDelta.FromKelvins(2); // ReSharper disable EqualExpressionComparison Assert.True(a == a); @@ -199,23 +247,23 @@ public void EqualityOperators() [Fact] public void EqualsIsImplemented() { - TemperatureDelta v = TemperatureDelta.FromKelvinsDelta(1); - Assert.True(v.Equals(TemperatureDelta.FromKelvinsDelta(1))); + TemperatureDelta v = TemperatureDelta.FromKelvins(1); + Assert.True(v.Equals(TemperatureDelta.FromKelvins(1))); Assert.False(v.Equals(TemperatureDelta.Zero)); } [Fact] public void EqualsReturnsFalseOnTypeMismatch() { - TemperatureDelta kelvindelta = TemperatureDelta.FromKelvinsDelta(1); - Assert.False(kelvindelta.Equals(new object())); + TemperatureDelta kelvin = TemperatureDelta.FromKelvins(1); + Assert.False(kelvin.Equals(new object())); } [Fact] public void EqualsReturnsFalseOnNull() { - TemperatureDelta kelvindelta = TemperatureDelta.FromKelvinsDelta(1); - Assert.False(kelvindelta.Equals(null)); + TemperatureDelta kelvin = TemperatureDelta.FromKelvins(1); + Assert.False(kelvin.Equals(null)); } } } diff --git a/UnitsNet/GeneratedCode/Extensions/Number/NumberToTemperatureDeltaExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/Number/NumberToTemperatureDeltaExtensions.g.cs index aa04e8d920..3bb55b15c4 100644 --- a/UnitsNet/GeneratedCode/Extensions/Number/NumberToTemperatureDeltaExtensions.g.cs +++ b/UnitsNet/GeneratedCode/Extensions/Number/NumberToTemperatureDeltaExtensions.g.cs @@ -44,6 +44,40 @@ namespace UnitsNet.Extensions.NumberToTemperatureDelta { public static class NumberToTemperatureDeltaExtensions { + #region DegreeCelsius + + /// + public static TemperatureDelta DegreesCelsius(this int value) => TemperatureDelta.FromDegreesCelsius(value); + + /// + public static TemperatureDelta? DegreesCelsius(this int? value) => TemperatureDelta.FromDegreesCelsius(value); + + /// + public static TemperatureDelta DegreesCelsius(this long value) => TemperatureDelta.FromDegreesCelsius(value); + + /// + public static TemperatureDelta? DegreesCelsius(this long? value) => TemperatureDelta.FromDegreesCelsius(value); + + /// + public static TemperatureDelta DegreesCelsius(this double value) => TemperatureDelta.FromDegreesCelsius(value); + + /// + public static TemperatureDelta? DegreesCelsius(this double? value) => TemperatureDelta.FromDegreesCelsius(value); + + /// + public static TemperatureDelta DegreesCelsius(this float value) => TemperatureDelta.FromDegreesCelsius(value); + + /// + public static TemperatureDelta? DegreesCelsius(this float? value) => TemperatureDelta.FromDegreesCelsius(value); + + /// + public static TemperatureDelta DegreesCelsius(this decimal value) => TemperatureDelta.FromDegreesCelsius(Convert.ToDouble(value)); + + /// + public static TemperatureDelta? DegreesCelsius(this decimal? value) => TemperatureDelta.FromDegreesCelsius(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + #region DegreeCelsiusDelta /// @@ -78,6 +112,40 @@ public static class NumberToTemperatureDeltaExtensions #endregion + #region DegreeDelisle + + /// + public static TemperatureDelta DegreesDelisle(this int value) => TemperatureDelta.FromDegreesDelisle(value); + + /// + public static TemperatureDelta? DegreesDelisle(this int? value) => TemperatureDelta.FromDegreesDelisle(value); + + /// + public static TemperatureDelta DegreesDelisle(this long value) => TemperatureDelta.FromDegreesDelisle(value); + + /// + public static TemperatureDelta? DegreesDelisle(this long? value) => TemperatureDelta.FromDegreesDelisle(value); + + /// + public static TemperatureDelta DegreesDelisle(this double value) => TemperatureDelta.FromDegreesDelisle(value); + + /// + public static TemperatureDelta? DegreesDelisle(this double? value) => TemperatureDelta.FromDegreesDelisle(value); + + /// + public static TemperatureDelta DegreesDelisle(this float value) => TemperatureDelta.FromDegreesDelisle(value); + + /// + public static TemperatureDelta? DegreesDelisle(this float? value) => TemperatureDelta.FromDegreesDelisle(value); + + /// + public static TemperatureDelta DegreesDelisle(this decimal value) => TemperatureDelta.FromDegreesDelisle(Convert.ToDouble(value)); + + /// + public static TemperatureDelta? DegreesDelisle(this decimal? value) => TemperatureDelta.FromDegreesDelisle(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + #region DegreeDelisleDelta /// @@ -112,6 +180,40 @@ public static class NumberToTemperatureDeltaExtensions #endregion + #region DegreeFahrenheit + + /// + public static TemperatureDelta DegreesFahrenheit(this int value) => TemperatureDelta.FromDegreesFahrenheit(value); + + /// + public static TemperatureDelta? DegreesFahrenheit(this int? value) => TemperatureDelta.FromDegreesFahrenheit(value); + + /// + public static TemperatureDelta DegreesFahrenheit(this long value) => TemperatureDelta.FromDegreesFahrenheit(value); + + /// + public static TemperatureDelta? DegreesFahrenheit(this long? value) => TemperatureDelta.FromDegreesFahrenheit(value); + + /// + public static TemperatureDelta DegreesFahrenheit(this double value) => TemperatureDelta.FromDegreesFahrenheit(value); + + /// + public static TemperatureDelta? DegreesFahrenheit(this double? value) => TemperatureDelta.FromDegreesFahrenheit(value); + + /// + public static TemperatureDelta DegreesFahrenheit(this float value) => TemperatureDelta.FromDegreesFahrenheit(value); + + /// + public static TemperatureDelta? DegreesFahrenheit(this float? value) => TemperatureDelta.FromDegreesFahrenheit(value); + + /// + public static TemperatureDelta DegreesFahrenheit(this decimal value) => TemperatureDelta.FromDegreesFahrenheit(Convert.ToDouble(value)); + + /// + public static TemperatureDelta? DegreesFahrenheit(this decimal? value) => TemperatureDelta.FromDegreesFahrenheit(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + #region DegreeFahrenheitDelta /// @@ -146,6 +248,40 @@ public static class NumberToTemperatureDeltaExtensions #endregion + #region DegreeNewton + + /// + public static TemperatureDelta DegreesNewton(this int value) => TemperatureDelta.FromDegreesNewton(value); + + /// + public static TemperatureDelta? DegreesNewton(this int? value) => TemperatureDelta.FromDegreesNewton(value); + + /// + public static TemperatureDelta DegreesNewton(this long value) => TemperatureDelta.FromDegreesNewton(value); + + /// + public static TemperatureDelta? DegreesNewton(this long? value) => TemperatureDelta.FromDegreesNewton(value); + + /// + public static TemperatureDelta DegreesNewton(this double value) => TemperatureDelta.FromDegreesNewton(value); + + /// + public static TemperatureDelta? DegreesNewton(this double? value) => TemperatureDelta.FromDegreesNewton(value); + + /// + public static TemperatureDelta DegreesNewton(this float value) => TemperatureDelta.FromDegreesNewton(value); + + /// + public static TemperatureDelta? DegreesNewton(this float? value) => TemperatureDelta.FromDegreesNewton(value); + + /// + public static TemperatureDelta DegreesNewton(this decimal value) => TemperatureDelta.FromDegreesNewton(Convert.ToDouble(value)); + + /// + public static TemperatureDelta? DegreesNewton(this decimal? value) => TemperatureDelta.FromDegreesNewton(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + #region DegreeNewtonDelta /// @@ -180,6 +316,40 @@ public static class NumberToTemperatureDeltaExtensions #endregion + #region DegreeRankine + + /// + public static TemperatureDelta DegreesRankine(this int value) => TemperatureDelta.FromDegreesRankine(value); + + /// + public static TemperatureDelta? DegreesRankine(this int? value) => TemperatureDelta.FromDegreesRankine(value); + + /// + public static TemperatureDelta DegreesRankine(this long value) => TemperatureDelta.FromDegreesRankine(value); + + /// + public static TemperatureDelta? DegreesRankine(this long? value) => TemperatureDelta.FromDegreesRankine(value); + + /// + public static TemperatureDelta DegreesRankine(this double value) => TemperatureDelta.FromDegreesRankine(value); + + /// + public static TemperatureDelta? DegreesRankine(this double? value) => TemperatureDelta.FromDegreesRankine(value); + + /// + public static TemperatureDelta DegreesRankine(this float value) => TemperatureDelta.FromDegreesRankine(value); + + /// + public static TemperatureDelta? DegreesRankine(this float? value) => TemperatureDelta.FromDegreesRankine(value); + + /// + public static TemperatureDelta DegreesRankine(this decimal value) => TemperatureDelta.FromDegreesRankine(Convert.ToDouble(value)); + + /// + public static TemperatureDelta? DegreesRankine(this decimal? value) => TemperatureDelta.FromDegreesRankine(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + #region DegreeRankineDelta /// @@ -214,6 +384,40 @@ public static class NumberToTemperatureDeltaExtensions #endregion + #region DegreeReaumur + + /// + public static TemperatureDelta DegreesReaumur(this int value) => TemperatureDelta.FromDegreesReaumur(value); + + /// + public static TemperatureDelta? DegreesReaumur(this int? value) => TemperatureDelta.FromDegreesReaumur(value); + + /// + public static TemperatureDelta DegreesReaumur(this long value) => TemperatureDelta.FromDegreesReaumur(value); + + /// + public static TemperatureDelta? DegreesReaumur(this long? value) => TemperatureDelta.FromDegreesReaumur(value); + + /// + public static TemperatureDelta DegreesReaumur(this double value) => TemperatureDelta.FromDegreesReaumur(value); + + /// + public static TemperatureDelta? DegreesReaumur(this double? value) => TemperatureDelta.FromDegreesReaumur(value); + + /// + public static TemperatureDelta DegreesReaumur(this float value) => TemperatureDelta.FromDegreesReaumur(value); + + /// + public static TemperatureDelta? DegreesReaumur(this float? value) => TemperatureDelta.FromDegreesReaumur(value); + + /// + public static TemperatureDelta DegreesReaumur(this decimal value) => TemperatureDelta.FromDegreesReaumur(Convert.ToDouble(value)); + + /// + public static TemperatureDelta? DegreesReaumur(this decimal? value) => TemperatureDelta.FromDegreesReaumur(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + #region DegreeReaumurDelta /// @@ -248,6 +452,40 @@ public static class NumberToTemperatureDeltaExtensions #endregion + #region DegreeRoemer + + /// + public static TemperatureDelta DegreesRoemer(this int value) => TemperatureDelta.FromDegreesRoemer(value); + + /// + public static TemperatureDelta? DegreesRoemer(this int? value) => TemperatureDelta.FromDegreesRoemer(value); + + /// + public static TemperatureDelta DegreesRoemer(this long value) => TemperatureDelta.FromDegreesRoemer(value); + + /// + public static TemperatureDelta? DegreesRoemer(this long? value) => TemperatureDelta.FromDegreesRoemer(value); + + /// + public static TemperatureDelta DegreesRoemer(this double value) => TemperatureDelta.FromDegreesRoemer(value); + + /// + public static TemperatureDelta? DegreesRoemer(this double? value) => TemperatureDelta.FromDegreesRoemer(value); + + /// + public static TemperatureDelta DegreesRoemer(this float value) => TemperatureDelta.FromDegreesRoemer(value); + + /// + public static TemperatureDelta? DegreesRoemer(this float? value) => TemperatureDelta.FromDegreesRoemer(value); + + /// + public static TemperatureDelta DegreesRoemer(this decimal value) => TemperatureDelta.FromDegreesRoemer(Convert.ToDouble(value)); + + /// + public static TemperatureDelta? DegreesRoemer(this decimal? value) => TemperatureDelta.FromDegreesRoemer(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + #region DegreeRoemerDelta /// @@ -282,6 +520,40 @@ public static class NumberToTemperatureDeltaExtensions #endregion + #region Kelvin + + /// + public static TemperatureDelta Kelvins(this int value) => TemperatureDelta.FromKelvins(value); + + /// + public static TemperatureDelta? Kelvins(this int? value) => TemperatureDelta.FromKelvins(value); + + /// + public static TemperatureDelta Kelvins(this long value) => TemperatureDelta.FromKelvins(value); + + /// + public static TemperatureDelta? Kelvins(this long? value) => TemperatureDelta.FromKelvins(value); + + /// + public static TemperatureDelta Kelvins(this double value) => TemperatureDelta.FromKelvins(value); + + /// + public static TemperatureDelta? Kelvins(this double? value) => TemperatureDelta.FromKelvins(value); + + /// + public static TemperatureDelta Kelvins(this float value) => TemperatureDelta.FromKelvins(value); + + /// + public static TemperatureDelta? Kelvins(this float? value) => TemperatureDelta.FromKelvins(value); + + /// + public static TemperatureDelta Kelvins(this decimal value) => TemperatureDelta.FromKelvins(Convert.ToDouble(value)); + + /// + public static TemperatureDelta? Kelvins(this decimal? value) => TemperatureDelta.FromKelvins(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + #region KelvinDelta /// diff --git a/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs b/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs index 6a4fa86f13..0de68fd658 100644 --- a/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs @@ -72,7 +72,7 @@ public partial struct TemperatureDelta : IComparable, IComparable /// Base unit of TemperatureDelta. /// - private readonly double _kelvinsDelta; + private readonly double _kelvins; // Windows Runtime Component requires a default constructor #if WINDOWS_UWP @@ -81,9 +81,9 @@ public TemperatureDelta() : this(0) } #endif - public TemperatureDelta(double kelvinsdelta) + public TemperatureDelta(double kelvins) { - _kelvinsDelta = Convert.ToDouble(kelvinsdelta); + _kelvins = Convert.ToDouble(kelvins); } // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods @@ -92,9 +92,9 @@ public TemperatureDelta(double kelvinsdelta) #else public #endif - TemperatureDelta(long kelvinsdelta) + TemperatureDelta(long kelvins) { - _kelvinsDelta = Convert.ToDouble(kelvinsdelta); + _kelvins = Convert.ToDouble(kelvins); } // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods @@ -104,9 +104,9 @@ public TemperatureDelta(double kelvinsdelta) #else public #endif - TemperatureDelta(decimal kelvinsdelta) + TemperatureDelta(decimal kelvins) { - _kelvinsDelta = Convert.ToDouble(kelvinsdelta); + _kelvins = Convert.ToDouble(kelvins); } #region Properties @@ -121,7 +121,7 @@ public TemperatureDelta(double kelvinsdelta) /// public static TemperatureDeltaUnit BaseUnit { - get { return TemperatureDeltaUnit.KelvinDelta; } + get { return TemperatureDeltaUnit.Kelvin; } } /// @@ -129,68 +129,140 @@ public static TemperatureDeltaUnit BaseUnit /// public static TemperatureDeltaUnit[] Units { get; } = Enum.GetValues(typeof(TemperatureDeltaUnit)).Cast().ToArray(); + /// + /// Get TemperatureDelta in DegreesCelsius. + /// + public double DegreesCelsius + { + get { return _kelvins; } + } + /// /// Get TemperatureDelta in DegreesCelsiusDelta. /// + [System.Obsolete("Deprecated due to github issue #180, please use DegreeCelsius instead")] public double DegreesCelsiusDelta { - get { return _kelvinsDelta; } + get { return _kelvins; } + } + + /// + /// Get TemperatureDelta in DegreesDelisle. + /// + public double DegreesDelisle + { + get { return _kelvins*-3/2; } } /// /// Get TemperatureDelta in DegreesDelisleDelta. /// + [System.Obsolete("Deprecated due to github issue #180, please use DegreeDelisle instead")] public double DegreesDelisleDelta { - get { return _kelvinsDelta*-3/2; } + get { return _kelvins*-3/2; } + } + + /// + /// Get TemperatureDelta in DegreesFahrenheit. + /// + public double DegreesFahrenheit + { + get { return _kelvins*9/5; } } /// /// Get TemperatureDelta in DegreesFahrenheitDelta. /// + [System.Obsolete("Deprecated due to github issue #180, please use DegreeFahrenheit instead")] public double DegreesFahrenheitDelta { - get { return _kelvinsDelta*9/5; } + get { return _kelvins*9/5; } + } + + /// + /// Get TemperatureDelta in DegreesNewton. + /// + public double DegreesNewton + { + get { return _kelvins*33/100; } } /// /// Get TemperatureDelta in DegreesNewtonDelta. /// + [System.Obsolete("Deprecated due to github issue #180, please use DegreeNewton instead")] public double DegreesNewtonDelta { - get { return _kelvinsDelta*33/100; } + get { return _kelvins*33/100; } + } + + /// + /// Get TemperatureDelta in DegreesRankine. + /// + public double DegreesRankine + { + get { return _kelvins*9/5; } } /// /// Get TemperatureDelta in DegreesRankineDelta. /// + [System.Obsolete("Deprecated due to github issue #180, please use DegreeRankine instead")] public double DegreesRankineDelta { - get { return _kelvinsDelta*9/5; } + get { return _kelvins*9/5; } + } + + /// + /// Get TemperatureDelta in DegreesReaumur. + /// + public double DegreesReaumur + { + get { return _kelvins*4/5; } } /// /// Get TemperatureDelta in DegreesReaumurDelta. /// + [System.Obsolete("Deprecated due to github issue #180, please use DegreeReaumur instead")] public double DegreesReaumurDelta { - get { return _kelvinsDelta*4/5; } + get { return _kelvins*4/5; } + } + + /// + /// Get TemperatureDelta in DegreesRoemer. + /// + public double DegreesRoemer + { + get { return _kelvins*21/40; } } /// /// Get TemperatureDelta in DegreesRoemerDelta. /// + [System.Obsolete("Deprecated due to github issue #180, please use DegreeRoemer instead")] public double DegreesRoemerDelta { - get { return _kelvinsDelta*21/40; } + get { return _kelvins*21/40; } + } + + /// + /// Get TemperatureDelta in Kelvins. + /// + public double Kelvins + { + get { return _kelvins; } } /// /// Get TemperatureDelta in KelvinsDelta. /// + [System.Obsolete("Deprecated due to github issue #180, please use Kelvin instead")] public double KelvinsDelta { - get { return _kelvinsDelta; } + get { return _kelvins; } } #endregion @@ -202,6 +274,24 @@ public static TemperatureDelta Zero get { return new TemperatureDelta(); } } + /// + /// Get TemperatureDelta from DegreesCelsius. + /// +#if WINDOWS_UWP + [Windows.Foundation.Metadata.DefaultOverload] + public static TemperatureDelta FromDegreesCelsius(double degreescelsius) + { + double value = (double) degreescelsius; + return new TemperatureDelta(value); + } +#else + public static TemperatureDelta FromDegreesCelsius(QuantityValue degreescelsius) + { + double value = (double) degreescelsius; + return new TemperatureDelta((value)); + } +#endif + /// /// Get TemperatureDelta from DegreesCelsiusDelta. /// @@ -220,6 +310,24 @@ public static TemperatureDelta FromDegreesCelsiusDelta(QuantityValue degreescels } #endif + /// + /// Get TemperatureDelta from DegreesDelisle. + /// +#if WINDOWS_UWP + [Windows.Foundation.Metadata.DefaultOverload] + public static TemperatureDelta FromDegreesDelisle(double degreesdelisle) + { + double value = (double) degreesdelisle; + return new TemperatureDelta(value*-2/3); + } +#else + public static TemperatureDelta FromDegreesDelisle(QuantityValue degreesdelisle) + { + double value = (double) degreesdelisle; + return new TemperatureDelta((value*-2/3)); + } +#endif + /// /// Get TemperatureDelta from DegreesDelisleDelta. /// @@ -238,6 +346,24 @@ public static TemperatureDelta FromDegreesDelisleDelta(QuantityValue degreesdeli } #endif + /// + /// Get TemperatureDelta from DegreesFahrenheit. + /// +#if WINDOWS_UWP + [Windows.Foundation.Metadata.DefaultOverload] + public static TemperatureDelta FromDegreesFahrenheit(double degreesfahrenheit) + { + double value = (double) degreesfahrenheit; + return new TemperatureDelta(value*5/9); + } +#else + public static TemperatureDelta FromDegreesFahrenheit(QuantityValue degreesfahrenheit) + { + double value = (double) degreesfahrenheit; + return new TemperatureDelta((value*5/9)); + } +#endif + /// /// Get TemperatureDelta from DegreesFahrenheitDelta. /// @@ -256,6 +382,24 @@ public static TemperatureDelta FromDegreesFahrenheitDelta(QuantityValue degreesf } #endif + /// + /// Get TemperatureDelta from DegreesNewton. + /// +#if WINDOWS_UWP + [Windows.Foundation.Metadata.DefaultOverload] + public static TemperatureDelta FromDegreesNewton(double degreesnewton) + { + double value = (double) degreesnewton; + return new TemperatureDelta(value*100/33); + } +#else + public static TemperatureDelta FromDegreesNewton(QuantityValue degreesnewton) + { + double value = (double) degreesnewton; + return new TemperatureDelta((value*100/33)); + } +#endif + /// /// Get TemperatureDelta from DegreesNewtonDelta. /// @@ -274,6 +418,24 @@ public static TemperatureDelta FromDegreesNewtonDelta(QuantityValue degreesnewto } #endif + /// + /// Get TemperatureDelta from DegreesRankine. + /// +#if WINDOWS_UWP + [Windows.Foundation.Metadata.DefaultOverload] + public static TemperatureDelta FromDegreesRankine(double degreesrankine) + { + double value = (double) degreesrankine; + return new TemperatureDelta(value*5/9); + } +#else + public static TemperatureDelta FromDegreesRankine(QuantityValue degreesrankine) + { + double value = (double) degreesrankine; + return new TemperatureDelta((value*5/9)); + } +#endif + /// /// Get TemperatureDelta from DegreesRankineDelta. /// @@ -292,6 +454,24 @@ public static TemperatureDelta FromDegreesRankineDelta(QuantityValue degreesrank } #endif + /// + /// Get TemperatureDelta from DegreesReaumur. + /// +#if WINDOWS_UWP + [Windows.Foundation.Metadata.DefaultOverload] + public static TemperatureDelta FromDegreesReaumur(double degreesreaumur) + { + double value = (double) degreesreaumur; + return new TemperatureDelta(value*5/4); + } +#else + public static TemperatureDelta FromDegreesReaumur(QuantityValue degreesreaumur) + { + double value = (double) degreesreaumur; + return new TemperatureDelta((value*5/4)); + } +#endif + /// /// Get TemperatureDelta from DegreesReaumurDelta. /// @@ -310,6 +490,24 @@ public static TemperatureDelta FromDegreesReaumurDelta(QuantityValue degreesreau } #endif + /// + /// Get TemperatureDelta from DegreesRoemer. + /// +#if WINDOWS_UWP + [Windows.Foundation.Metadata.DefaultOverload] + public static TemperatureDelta FromDegreesRoemer(double degreesroemer) + { + double value = (double) degreesroemer; + return new TemperatureDelta(value*40/21); + } +#else + public static TemperatureDelta FromDegreesRoemer(QuantityValue degreesroemer) + { + double value = (double) degreesroemer; + return new TemperatureDelta((value*40/21)); + } +#endif + /// /// Get TemperatureDelta from DegreesRoemerDelta. /// @@ -328,6 +526,24 @@ public static TemperatureDelta FromDegreesRoemerDelta(QuantityValue degreesroeme } #endif + /// + /// Get TemperatureDelta from Kelvins. + /// +#if WINDOWS_UWP + [Windows.Foundation.Metadata.DefaultOverload] + public static TemperatureDelta FromKelvins(double kelvins) + { + double value = (double) kelvins; + return new TemperatureDelta(value); + } +#else + public static TemperatureDelta FromKelvins(QuantityValue kelvins) + { + double value = (double) kelvins; + return new TemperatureDelta((value)); + } +#endif + /// /// Get TemperatureDelta from KelvinsDelta. /// @@ -348,6 +564,21 @@ public static TemperatureDelta FromKelvinsDelta(QuantityValue kelvinsdelta) // Windows Runtime Component does not support nullable types (double?): https://msdn.microsoft.com/en-us/library/br230301.aspx #if !WINDOWS_UWP + /// + /// Get nullable TemperatureDelta from nullable DegreesCelsius. + /// + public static TemperatureDelta? FromDegreesCelsius(QuantityValue? degreescelsius) + { + if (degreescelsius.HasValue) + { + return FromDegreesCelsius(degreescelsius.Value); + } + else + { + return null; + } + } + /// /// Get nullable TemperatureDelta from nullable DegreesCelsiusDelta. /// @@ -363,6 +594,21 @@ public static TemperatureDelta FromKelvinsDelta(QuantityValue kelvinsdelta) } } + /// + /// Get nullable TemperatureDelta from nullable DegreesDelisle. + /// + public static TemperatureDelta? FromDegreesDelisle(QuantityValue? degreesdelisle) + { + if (degreesdelisle.HasValue) + { + return FromDegreesDelisle(degreesdelisle.Value); + } + else + { + return null; + } + } + /// /// Get nullable TemperatureDelta from nullable DegreesDelisleDelta. /// @@ -378,6 +624,21 @@ public static TemperatureDelta FromKelvinsDelta(QuantityValue kelvinsdelta) } } + /// + /// Get nullable TemperatureDelta from nullable DegreesFahrenheit. + /// + public static TemperatureDelta? FromDegreesFahrenheit(QuantityValue? degreesfahrenheit) + { + if (degreesfahrenheit.HasValue) + { + return FromDegreesFahrenheit(degreesfahrenheit.Value); + } + else + { + return null; + } + } + /// /// Get nullable TemperatureDelta from nullable DegreesFahrenheitDelta. /// @@ -393,6 +654,21 @@ public static TemperatureDelta FromKelvinsDelta(QuantityValue kelvinsdelta) } } + /// + /// Get nullable TemperatureDelta from nullable DegreesNewton. + /// + public static TemperatureDelta? FromDegreesNewton(QuantityValue? degreesnewton) + { + if (degreesnewton.HasValue) + { + return FromDegreesNewton(degreesnewton.Value); + } + else + { + return null; + } + } + /// /// Get nullable TemperatureDelta from nullable DegreesNewtonDelta. /// @@ -408,6 +684,21 @@ public static TemperatureDelta FromKelvinsDelta(QuantityValue kelvinsdelta) } } + /// + /// Get nullable TemperatureDelta from nullable DegreesRankine. + /// + public static TemperatureDelta? FromDegreesRankine(QuantityValue? degreesrankine) + { + if (degreesrankine.HasValue) + { + return FromDegreesRankine(degreesrankine.Value); + } + else + { + return null; + } + } + /// /// Get nullable TemperatureDelta from nullable DegreesRankineDelta. /// @@ -423,6 +714,21 @@ public static TemperatureDelta FromKelvinsDelta(QuantityValue kelvinsdelta) } } + /// + /// Get nullable TemperatureDelta from nullable DegreesReaumur. + /// + public static TemperatureDelta? FromDegreesReaumur(QuantityValue? degreesreaumur) + { + if (degreesreaumur.HasValue) + { + return FromDegreesReaumur(degreesreaumur.Value); + } + else + { + return null; + } + } + /// /// Get nullable TemperatureDelta from nullable DegreesReaumurDelta. /// @@ -438,6 +744,21 @@ public static TemperatureDelta FromKelvinsDelta(QuantityValue kelvinsdelta) } } + /// + /// Get nullable TemperatureDelta from nullable DegreesRoemer. + /// + public static TemperatureDelta? FromDegreesRoemer(QuantityValue? degreesroemer) + { + if (degreesroemer.HasValue) + { + return FromDegreesRoemer(degreesroemer.Value); + } + else + { + return null; + } + } + /// /// Get nullable TemperatureDelta from nullable DegreesRoemerDelta. /// @@ -453,6 +774,21 @@ public static TemperatureDelta FromKelvinsDelta(QuantityValue kelvinsdelta) } } + /// + /// Get nullable TemperatureDelta from nullable Kelvins. + /// + public static TemperatureDelta? FromKelvins(QuantityValue? kelvins) + { + if (kelvins.HasValue) + { + return FromKelvins(kelvins.Value); + } + else + { + return null; + } + } + /// /// Get nullable TemperatureDelta from nullable KelvinsDelta. /// @@ -486,20 +822,36 @@ public static TemperatureDelta From(QuantityValue value, TemperatureDeltaUnit fr { switch (fromUnit) { + case TemperatureDeltaUnit.DegreeCelsius: + return FromDegreesCelsius(value); case TemperatureDeltaUnit.DegreeCelsiusDelta: return FromDegreesCelsiusDelta(value); + case TemperatureDeltaUnit.DegreeDelisle: + return FromDegreesDelisle(value); case TemperatureDeltaUnit.DegreeDelisleDelta: return FromDegreesDelisleDelta(value); + case TemperatureDeltaUnit.DegreeFahrenheit: + return FromDegreesFahrenheit(value); case TemperatureDeltaUnit.DegreeFahrenheitDelta: return FromDegreesFahrenheitDelta(value); + case TemperatureDeltaUnit.DegreeNewton: + return FromDegreesNewton(value); case TemperatureDeltaUnit.DegreeNewtonDelta: return FromDegreesNewtonDelta(value); + case TemperatureDeltaUnit.DegreeRankine: + return FromDegreesRankine(value); case TemperatureDeltaUnit.DegreeRankineDelta: return FromDegreesRankineDelta(value); + case TemperatureDeltaUnit.DegreeReaumur: + return FromDegreesReaumur(value); case TemperatureDeltaUnit.DegreeReaumurDelta: return FromDegreesReaumurDelta(value); + case TemperatureDeltaUnit.DegreeRoemer: + return FromDegreesRoemer(value); case TemperatureDeltaUnit.DegreeRoemerDelta: return FromDegreesRoemerDelta(value); + case TemperatureDeltaUnit.Kelvin: + return FromKelvins(value); case TemperatureDeltaUnit.KelvinDelta: return FromKelvinsDelta(value); @@ -524,20 +876,36 @@ public static TemperatureDelta From(QuantityValue value, TemperatureDeltaUnit fr } switch (fromUnit) { + case TemperatureDeltaUnit.DegreeCelsius: + return FromDegreesCelsius(value.Value); case TemperatureDeltaUnit.DegreeCelsiusDelta: return FromDegreesCelsiusDelta(value.Value); + case TemperatureDeltaUnit.DegreeDelisle: + return FromDegreesDelisle(value.Value); case TemperatureDeltaUnit.DegreeDelisleDelta: return FromDegreesDelisleDelta(value.Value); + case TemperatureDeltaUnit.DegreeFahrenheit: + return FromDegreesFahrenheit(value.Value); case TemperatureDeltaUnit.DegreeFahrenheitDelta: return FromDegreesFahrenheitDelta(value.Value); + case TemperatureDeltaUnit.DegreeNewton: + return FromDegreesNewton(value.Value); case TemperatureDeltaUnit.DegreeNewtonDelta: return FromDegreesNewtonDelta(value.Value); + case TemperatureDeltaUnit.DegreeRankine: + return FromDegreesRankine(value.Value); case TemperatureDeltaUnit.DegreeRankineDelta: return FromDegreesRankineDelta(value.Value); + case TemperatureDeltaUnit.DegreeReaumur: + return FromDegreesReaumur(value.Value); case TemperatureDeltaUnit.DegreeReaumurDelta: return FromDegreesReaumurDelta(value.Value); + case TemperatureDeltaUnit.DegreeRoemer: + return FromDegreesRoemer(value.Value); case TemperatureDeltaUnit.DegreeRoemerDelta: return FromDegreesRoemerDelta(value.Value); + case TemperatureDeltaUnit.Kelvin: + return FromKelvins(value.Value); case TemperatureDeltaUnit.KelvinDelta: return FromKelvinsDelta(value.Value); @@ -578,37 +946,37 @@ public static string GetAbbreviation(TemperatureDeltaUnit unit, [CanBeNull] Cult #if !WINDOWS_UWP public static TemperatureDelta operator -(TemperatureDelta right) { - return new TemperatureDelta(-right._kelvinsDelta); + return new TemperatureDelta(-right._kelvins); } public static TemperatureDelta operator +(TemperatureDelta left, TemperatureDelta right) { - return new TemperatureDelta(left._kelvinsDelta + right._kelvinsDelta); + return new TemperatureDelta(left._kelvins + right._kelvins); } public static TemperatureDelta operator -(TemperatureDelta left, TemperatureDelta right) { - return new TemperatureDelta(left._kelvinsDelta - right._kelvinsDelta); + return new TemperatureDelta(left._kelvins - right._kelvins); } public static TemperatureDelta operator *(double left, TemperatureDelta right) { - return new TemperatureDelta(left*right._kelvinsDelta); + return new TemperatureDelta(left*right._kelvins); } public static TemperatureDelta operator *(TemperatureDelta left, double right) { - return new TemperatureDelta(left._kelvinsDelta*(double)right); + return new TemperatureDelta(left._kelvins*(double)right); } public static TemperatureDelta operator /(TemperatureDelta left, double right) { - return new TemperatureDelta(left._kelvinsDelta/(double)right); + return new TemperatureDelta(left._kelvins/(double)right); } public static double operator /(TemperatureDelta left, TemperatureDelta right) { - return Convert.ToDouble(left._kelvinsDelta/right._kelvinsDelta); + return Convert.ToDouble(left._kelvins/right._kelvins); } #endif @@ -631,43 +999,43 @@ public int CompareTo(object obj) #endif int CompareTo(TemperatureDelta other) { - return _kelvinsDelta.CompareTo(other._kelvinsDelta); + return _kelvins.CompareTo(other._kelvins); } // Windows Runtime Component does not allow operator overloads: https://msdn.microsoft.com/en-us/library/br230301.aspx #if !WINDOWS_UWP public static bool operator <=(TemperatureDelta left, TemperatureDelta right) { - return left._kelvinsDelta <= right._kelvinsDelta; + return left._kelvins <= right._kelvins; } public static bool operator >=(TemperatureDelta left, TemperatureDelta right) { - return left._kelvinsDelta >= right._kelvinsDelta; + return left._kelvins >= right._kelvins; } public static bool operator <(TemperatureDelta left, TemperatureDelta right) { - return left._kelvinsDelta < right._kelvinsDelta; + return left._kelvins < right._kelvins; } public static bool operator >(TemperatureDelta left, TemperatureDelta right) { - return left._kelvinsDelta > right._kelvinsDelta; + return left._kelvins > right._kelvins; } [Obsolete("It is not safe to compare equality due to using System.Double as the internal representation. It is very easy to get slightly different values due to floating point operations. Instead use Equals(other, maxError) to provide the max allowed error.")] public static bool operator ==(TemperatureDelta left, TemperatureDelta right) { // ReSharper disable once CompareOfFloatsByEqualityOperator - return left._kelvinsDelta == right._kelvinsDelta; + return left._kelvins == right._kelvins; } [Obsolete("It is not safe to compare equality due to using System.Double as the internal representation. It is very easy to get slightly different values due to floating point operations. Instead use Equals(other, maxError) to provide the max allowed error.")] public static bool operator !=(TemperatureDelta left, TemperatureDelta right) { // ReSharper disable once CompareOfFloatsByEqualityOperator - return left._kelvinsDelta != right._kelvinsDelta; + return left._kelvins != right._kelvins; } #endif @@ -679,7 +1047,7 @@ public override bool Equals(object obj) return false; } - return _kelvinsDelta.Equals(((TemperatureDelta) obj)._kelvinsDelta); + return _kelvins.Equals(((TemperatureDelta) obj)._kelvins); } /// @@ -692,12 +1060,12 @@ public override bool Equals(object obj) /// True if the difference between the two values is not greater than the specified max. public bool Equals(TemperatureDelta other, TemperatureDelta maxError) { - return Math.Abs(_kelvinsDelta - other._kelvinsDelta) <= maxError._kelvinsDelta; + return Math.Abs(_kelvins - other._kelvins) <= maxError._kelvins; } public override int GetHashCode() { - return _kelvinsDelta.GetHashCode(); + return _kelvins.GetHashCode(); } #endregion @@ -713,20 +1081,36 @@ public double As(TemperatureDeltaUnit unit) { switch (unit) { + case TemperatureDeltaUnit.DegreeCelsius: + return DegreesCelsius; case TemperatureDeltaUnit.DegreeCelsiusDelta: return DegreesCelsiusDelta; + case TemperatureDeltaUnit.DegreeDelisle: + return DegreesDelisle; case TemperatureDeltaUnit.DegreeDelisleDelta: return DegreesDelisleDelta; + case TemperatureDeltaUnit.DegreeFahrenheit: + return DegreesFahrenheit; case TemperatureDeltaUnit.DegreeFahrenheitDelta: return DegreesFahrenheitDelta; + case TemperatureDeltaUnit.DegreeNewton: + return DegreesNewton; case TemperatureDeltaUnit.DegreeNewtonDelta: return DegreesNewtonDelta; + case TemperatureDeltaUnit.DegreeRankine: + return DegreesRankine; case TemperatureDeltaUnit.DegreeRankineDelta: return DegreesRankineDelta; + case TemperatureDeltaUnit.DegreeReaumur: + return DegreesReaumur; case TemperatureDeltaUnit.DegreeReaumurDelta: return DegreesReaumurDelta; + case TemperatureDeltaUnit.DegreeRoemer: + return DegreesRoemer; case TemperatureDeltaUnit.DegreeRoemerDelta: return DegreesRoemerDelta; + case TemperatureDeltaUnit.Kelvin: + return Kelvins; case TemperatureDeltaUnit.KelvinDelta: return KelvinsDelta; @@ -805,7 +1189,7 @@ public static TemperatureDelta Parse(string str, [CanBeNull] Culture culture) double parsedValue = double.Parse(value, formatProvider2); TemperatureDeltaUnit parsedUnit = ParseUnit(unit, formatProvider2); return From(parsedValue, parsedUnit); - }, (x, y) => FromKelvinsDelta(x.KelvinsDelta + y.KelvinsDelta)); + }, (x, y) => FromKelvins(x.Kelvins + y.Kelvins)); } /// @@ -906,9 +1290,9 @@ static TemperatureDeltaUnit ParseUnit(string str, IFormatProvider formatProvider #endregion /// - /// Set the default unit used by ToString(). Default is KelvinDelta + /// Set the default unit used by ToString(). Default is Kelvin /// - public static TemperatureDeltaUnit ToStringDefaultUnit { get; set; } = TemperatureDeltaUnit.KelvinDelta; + public static TemperatureDeltaUnit ToStringDefaultUnit { get; set; } = TemperatureDeltaUnit.Kelvin; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs index 27b3bf9424..0f1ec3aa7e 100644 --- a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs +++ b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs @@ -3060,45 +3060,85 @@ private static readonly ReadOnlyCollection DefaultLocalization new UnitLocalization(typeof (TemperatureDeltaUnit), new[] { + new CulturesForEnumValue((int) TemperatureDeltaUnit.DegreeCelsius, + new[] + { + new AbbreviationsForCulture("en-US", "∆°C"), + }), new CulturesForEnumValue((int) TemperatureDeltaUnit.DegreeCelsiusDelta, new[] { - new AbbreviationsForCulture("en-US", "▲°C"), + new AbbreviationsForCulture("en-US", "∆°C"), + }), + new CulturesForEnumValue((int) TemperatureDeltaUnit.DegreeDelisle, + new[] + { + new AbbreviationsForCulture("en-US", "∆°De"), }), new CulturesForEnumValue((int) TemperatureDeltaUnit.DegreeDelisleDelta, new[] { - new AbbreviationsForCulture("en-US", "▲°De"), + new AbbreviationsForCulture("en-US", "∆°De"), + }), + new CulturesForEnumValue((int) TemperatureDeltaUnit.DegreeFahrenheit, + new[] + { + new AbbreviationsForCulture("en-US", "∆°F"), }), new CulturesForEnumValue((int) TemperatureDeltaUnit.DegreeFahrenheitDelta, new[] { - new AbbreviationsForCulture("en-US", "▲°F"), + new AbbreviationsForCulture("en-US", "∆°F"), + }), + new CulturesForEnumValue((int) TemperatureDeltaUnit.DegreeNewton, + new[] + { + new AbbreviationsForCulture("en-US", "∆°N"), }), new CulturesForEnumValue((int) TemperatureDeltaUnit.DegreeNewtonDelta, new[] { - new AbbreviationsForCulture("en-US", "▲°N"), + new AbbreviationsForCulture("en-US", "∆°N"), + }), + new CulturesForEnumValue((int) TemperatureDeltaUnit.DegreeRankine, + new[] + { + new AbbreviationsForCulture("en-US", "∆°R"), }), new CulturesForEnumValue((int) TemperatureDeltaUnit.DegreeRankineDelta, new[] { - new AbbreviationsForCulture("en-US", "▲°R"), + new AbbreviationsForCulture("en-US", "∆°R"), + }), + new CulturesForEnumValue((int) TemperatureDeltaUnit.DegreeReaumur, + new[] + { + new AbbreviationsForCulture("en-US", "∆°Ré"), }), new CulturesForEnumValue((int) TemperatureDeltaUnit.DegreeReaumurDelta, new[] { - new AbbreviationsForCulture("en-US", "▲°Ré"), + new AbbreviationsForCulture("en-US", "∆°Ré"), + }), + new CulturesForEnumValue((int) TemperatureDeltaUnit.DegreeRoemer, + new[] + { + new AbbreviationsForCulture("en-US", "∆°Rø"), }), new CulturesForEnumValue((int) TemperatureDeltaUnit.DegreeRoemerDelta, new[] { - new AbbreviationsForCulture("en-US", "▲°Rø"), + new AbbreviationsForCulture("en-US", "∆°Rø"), + }), + new CulturesForEnumValue((int) TemperatureDeltaUnit.Kelvin, + new[] + { + new AbbreviationsForCulture("en-US", "∆K"), }), new CulturesForEnumValue((int) TemperatureDeltaUnit.KelvinDelta, new[] { - new AbbreviationsForCulture("en-US", "▲K"), + new AbbreviationsForCulture("en-US", "∆K"), }), }), new UnitLocalization(typeof (ThermalResistanceUnit), diff --git a/UnitsNet/GeneratedCode/Units/TemperatureDeltaUnit.g.cs b/UnitsNet/GeneratedCode/Units/TemperatureDeltaUnit.g.cs index 0470e75cea..5e5de36947 100644 --- a/UnitsNet/GeneratedCode/Units/TemperatureDeltaUnit.g.cs +++ b/UnitsNet/GeneratedCode/Units/TemperatureDeltaUnit.g.cs @@ -42,13 +42,29 @@ namespace UnitsNet.Units public enum TemperatureDeltaUnit { Undefined = 0, + DegreeCelsius, + [System.Obsolete("Deprecated due to github issue #180, please use DegreeCelsius instead")] DegreeCelsiusDelta, + DegreeDelisle, + [System.Obsolete("Deprecated due to github issue #180, please use DegreeDelisle instead")] DegreeDelisleDelta, + DegreeFahrenheit, + [System.Obsolete("Deprecated due to github issue #180, please use DegreeFahrenheit instead")] DegreeFahrenheitDelta, + DegreeNewton, + [System.Obsolete("Deprecated due to github issue #180, please use DegreeNewton instead")] DegreeNewtonDelta, + DegreeRankine, + [System.Obsolete("Deprecated due to github issue #180, please use DegreeRankine instead")] DegreeRankineDelta, + DegreeReaumur, + [System.Obsolete("Deprecated due to github issue #180, please use DegreeReaumur instead")] DegreeReaumurDelta, + DegreeRoemer, + [System.Obsolete("Deprecated due to github issue #180, please use DegreeRoemer instead")] DegreeRoemerDelta, + Kelvin, + [System.Obsolete("Deprecated due to github issue #180, please use Kelvin instead")] KelvinDelta, } } diff --git a/UnitsNet/UnitDefinitions/TemperatureDelta.json b/UnitsNet/UnitDefinitions/TemperatureDelta.json index ae2badb880..771f916667 100644 --- a/UnitsNet/UnitDefinitions/TemperatureDelta.json +++ b/UnitsNet/UnitDefinitions/TemperatureDelta.json @@ -1,101 +1,205 @@ { "Name": "TemperatureDelta", - "BaseUnit": "KelvinDelta", + "BaseUnit": "Kelvin", "XmlDoc": "Difference between two temperatures. The conversions are different than for Temperature.", "Units": [ + { + "SingularName": "Kelvin", + "PluralName": "Kelvins", + "FromUnitToBaseFunc": "x", + "FromBaseToUnitFunc": "x", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "∆K" ] + } + ] + }, + { + "SingularName": "DegreeCelsius", + "PluralName": "DegreesCelsius", + "FromUnitToBaseFunc": "x", + "FromBaseToUnitFunc": "x", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "∆°C" ] + } + ] + }, + { + "SingularName": "DegreeDelisle", + "PluralName": "DegreesDelisle", + "FromUnitToBaseFunc": "x*-2/3", + "FromBaseToUnitFunc": "x*-3/2", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "∆°De" ] + } + ] + }, + { + "SingularName": "DegreeFahrenheit", + "PluralName": "DegreesFahrenheit", + "FromUnitToBaseFunc": "x*5/9", + "FromBaseToUnitFunc": "x*9/5", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "∆°F" ] + } + ] + }, + { + "SingularName": "DegreeNewton", + "PluralName": "DegreesNewton", + "FromUnitToBaseFunc": "x*100/33", + "FromBaseToUnitFunc": "x*33/100", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "∆°N" ] + } + ] + }, + { + "SingularName": "DegreeRankine", + "PluralName": "DegreesRankine", + "FromUnitToBaseFunc": "x*5/9", + "FromBaseToUnitFunc": "x*9/5", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "∆°R" ] + } + ] + }, + { + "SingularName": "DegreeReaumur", + "PluralName": "DegreesReaumur", + "FromUnitToBaseFunc": "x*5/4", + "FromBaseToUnitFunc": "x*4/5", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "∆°Ré" ] + } + ] + }, + { + "SingularName": "DegreeRoemer", + "PluralName": "DegreesRoemer", + "FromUnitToBaseFunc": "x*40/21", + "FromBaseToUnitFunc": "x*21/40", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "∆°Rø" ] + } + ] + }, { "SingularName": "KelvinDelta", "PluralName": "KelvinsDelta", + "ObsoleteText": "Deprecated due to github issue #180, please use Kelvin instead", "FromUnitToBaseFunc": "x", "FromBaseToUnitFunc": "x", "Localization": [ { "Culture": "en-US", - "Abbreviations": [ "▲K" ] + "Abbreviations": [ "∆K" ] } ] }, { "SingularName": "DegreeCelsiusDelta", "PluralName": "DegreesCelsiusDelta", + "ObsoleteText": "Deprecated due to github issue #180, please use DegreeCelsius instead", "FromUnitToBaseFunc": "x", "FromBaseToUnitFunc": "x", "Localization": [ { "Culture": "en-US", - "Abbreviations": [ "▲°C" ] + "Abbreviations": [ "∆°C" ] } ] }, { "SingularName": "DegreeDelisleDelta", "PluralName": "DegreesDelisleDelta", + "ObsoleteText": "Deprecated due to github issue #180, please use DegreeDelisle instead", "FromUnitToBaseFunc": "x*-2/3", "FromBaseToUnitFunc": "x*-3/2", "Localization": [ { "Culture": "en-US", - "Abbreviations": [ "▲°De" ] + "Abbreviations": [ "∆°De" ] } ] }, { "SingularName": "DegreeFahrenheitDelta", "PluralName": "DegreesFahrenheitDelta", + "ObsoleteText": "Deprecated due to github issue #180, please use DegreeFahrenheit instead", "FromUnitToBaseFunc": "x*5/9", "FromBaseToUnitFunc": "x*9/5", "Localization": [ { "Culture": "en-US", - "Abbreviations": [ "▲°F" ] + "Abbreviations": [ "∆°F" ] } ] }, { "SingularName": "DegreeNewtonDelta", "PluralName": "DegreesNewtonDelta", + "ObsoleteText": "Deprecated due to github issue #180, please use DegreeNewton instead", "FromUnitToBaseFunc": "x*100/33", "FromBaseToUnitFunc": "x*33/100", "Localization": [ { "Culture": "en-US", - "Abbreviations": [ "▲°N" ] + "Abbreviations": [ "∆°N" ] } ] }, { "SingularName": "DegreeRankineDelta", "PluralName": "DegreesRankineDelta", + "ObsoleteText": "Deprecated due to github issue #180, please use DegreeRankine instead", "FromUnitToBaseFunc": "x*5/9", "FromBaseToUnitFunc": "x*9/5", "Localization": [ { "Culture": "en-US", - "Abbreviations": [ "▲°R" ] + "Abbreviations": [ "∆°R" ] } ] }, { "SingularName": "DegreeReaumurDelta", "PluralName": "DegreesReaumurDelta", + "ObsoleteText": "Deprecated due to github issue #180, please use DegreeReaumur instead", "FromUnitToBaseFunc": "x*5/4", "FromBaseToUnitFunc": "x*4/5", "Localization": [ { "Culture": "en-US", - "Abbreviations": [ "▲°Ré" ] + "Abbreviations": [ "∆°Ré" ] } ] }, { "SingularName": "DegreeRoemerDelta", "PluralName": "DegreesRoemerDelta", + "ObsoleteText": "Deprecated due to github issue #180, please use DegreeRoemer instead", "FromUnitToBaseFunc": "x*40/21", "FromBaseToUnitFunc": "x*21/40", "Localization": [ { "Culture": "en-US", - "Abbreviations": [ "▲°Rø" ] + "Abbreviations": [ "∆°Rø" ] } ] } diff --git a/generate-code.bat b/generate-code.bat index 6be05df836..b005b957fe 100644 --- a/generate-code.bat +++ b/generate-code.bat @@ -1,3 +1,3 @@ @echo off SET scriptdir=%~dp0 -powershell -ExecutionPolicy Bypass -NoProfile -File %scriptdir%UnitsNet\Scripts\GenerateUnits.ps1 +powershell -ExecutionPolicy Bypass -NoProfile -File "%scriptdir%UnitsNet\Scripts\GenerateUnits.ps1"