From c5186411f069bd0832dd2aef67145c3d47f03110 Mon Sep 17 00:00:00 2001 From: Richard Dutton Date: Sun, 10 Dec 2017 18:48:54 +0000 Subject: [PATCH 1/4] Removed Delta suffix of TemperatureDelta units (Fixes #331). Fixed generate-code.bat to allow spaces in script path. --- .../CustomCode/TemperatureDeltaTests.cs | 9 + .../TemperatureDeltaTestsBase.g.cs | 48 +++ .../NumberToTemperatureDeltaExtensions.g.cs | 272 +++++++++++++ .../Quantities/TemperatureDelta.g.cs | 384 ++++++++++++++++++ .../GeneratedCode/UnitSystem.Default.g.cs | 40 ++ .../Units/TemperatureDeltaUnit.g.cs | 16 + .../UnitDefinitions/TemperatureDelta.json | 104 +++++ generate-code.bat | 2 +- 8 files changed, 874 insertions(+), 1 deletion(-) diff --git a/UnitsNet.Tests/CustomCode/TemperatureDeltaTests.cs b/UnitsNet.Tests/CustomCode/TemperatureDeltaTests.cs index c4fcc50589..24314eab8f 100644 --- a/UnitsNet.Tests/CustomCode/TemperatureDeltaTests.cs +++ b/UnitsNet.Tests/CustomCode/TemperatureDeltaTests.cs @@ -52,5 +52,14 @@ public class TemperatureDeltaTests : TemperatureDeltaTestsBase protected override double DegreesReaumurDeltaInOneKelvinDelta => 0.8; protected override double DegreesRoemerDeltaInOneKelvinDelta => 21/40d; protected override double KelvinsDeltaInOneKelvinDelta => 1; + + protected override double DegreesCelsiusInOneKelvinDelta => 1; + protected override double DegreesDelisleInOneKelvinDelta => -1.5d; + protected override double DegreesFahrenheitInOneKelvinDelta => 1.8; + protected override double DegreesNewtonInOneKelvinDelta => 0.33d; + protected override double DegreesRankineInOneKelvinDelta => 1.8; + protected override double DegreesReaumurInOneKelvinDelta => 0.8; + protected override double DegreesRoemerInOneKelvinDelta => 21 / 40d; + protected override double KelvinsInOneKelvinDelta => 1; } } diff --git a/UnitsNet.Tests/GeneratedCode/TemperatureDeltaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TemperatureDeltaTestsBase.g.cs index 68c86589cf..bbf4543178 100644 --- a/UnitsNet.Tests/GeneratedCode/TemperatureDeltaTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TemperatureDeltaTestsBase.g.cs @@ -52,23 +52,39 @@ namespace UnitsNet.Tests // ReSharper disable once PartialTypeWithSinglePart public abstract partial class TemperatureDeltaTestsBase { + protected abstract double DegreesCelsiusInOneKelvinDelta { get; } protected abstract double DegreesCelsiusDeltaInOneKelvinDelta { get; } + protected abstract double DegreesDelisleInOneKelvinDelta { get; } protected abstract double DegreesDelisleDeltaInOneKelvinDelta { get; } + protected abstract double DegreesFahrenheitInOneKelvinDelta { get; } protected abstract double DegreesFahrenheitDeltaInOneKelvinDelta { get; } + protected abstract double DegreesNewtonInOneKelvinDelta { get; } protected abstract double DegreesNewtonDeltaInOneKelvinDelta { get; } + protected abstract double DegreesRankineInOneKelvinDelta { get; } protected abstract double DegreesRankineDeltaInOneKelvinDelta { get; } + protected abstract double DegreesReaumurInOneKelvinDelta { get; } protected abstract double DegreesReaumurDeltaInOneKelvinDelta { get; } + protected abstract double DegreesRoemerInOneKelvinDelta { get; } protected abstract double DegreesRoemerDeltaInOneKelvinDelta { get; } + protected abstract double KelvinsInOneKelvinDelta { get; } protected abstract double KelvinsDeltaInOneKelvinDelta { 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 @@ -76,26 +92,42 @@ public abstract partial class TemperatureDeltaTestsBase public void KelvinDeltaToTemperatureDeltaUnits() { TemperatureDelta kelvindelta = TemperatureDelta.FromKelvinsDelta(1); + AssertEx.EqualTolerance(DegreesCelsiusInOneKelvinDelta, kelvindelta.DegreesCelsius, DegreesCelsiusTolerance); AssertEx.EqualTolerance(DegreesCelsiusDeltaInOneKelvinDelta, kelvindelta.DegreesCelsiusDelta, DegreesCelsiusDeltaTolerance); + AssertEx.EqualTolerance(DegreesDelisleInOneKelvinDelta, kelvindelta.DegreesDelisle, DegreesDelisleTolerance); AssertEx.EqualTolerance(DegreesDelisleDeltaInOneKelvinDelta, kelvindelta.DegreesDelisleDelta, DegreesDelisleDeltaTolerance); + AssertEx.EqualTolerance(DegreesFahrenheitInOneKelvinDelta, kelvindelta.DegreesFahrenheit, DegreesFahrenheitTolerance); AssertEx.EqualTolerance(DegreesFahrenheitDeltaInOneKelvinDelta, kelvindelta.DegreesFahrenheitDelta, DegreesFahrenheitDeltaTolerance); + AssertEx.EqualTolerance(DegreesNewtonInOneKelvinDelta, kelvindelta.DegreesNewton, DegreesNewtonTolerance); AssertEx.EqualTolerance(DegreesNewtonDeltaInOneKelvinDelta, kelvindelta.DegreesNewtonDelta, DegreesNewtonDeltaTolerance); + AssertEx.EqualTolerance(DegreesRankineInOneKelvinDelta, kelvindelta.DegreesRankine, DegreesRankineTolerance); AssertEx.EqualTolerance(DegreesRankineDeltaInOneKelvinDelta, kelvindelta.DegreesRankineDelta, DegreesRankineDeltaTolerance); + AssertEx.EqualTolerance(DegreesReaumurInOneKelvinDelta, kelvindelta.DegreesReaumur, DegreesReaumurTolerance); AssertEx.EqualTolerance(DegreesReaumurDeltaInOneKelvinDelta, kelvindelta.DegreesReaumurDelta, DegreesReaumurDeltaTolerance); + AssertEx.EqualTolerance(DegreesRoemerInOneKelvinDelta, kelvindelta.DegreesRoemer, DegreesRoemerTolerance); AssertEx.EqualTolerance(DegreesRoemerDeltaInOneKelvinDelta, kelvindelta.DegreesRoemerDelta, DegreesRoemerDeltaTolerance); + AssertEx.EqualTolerance(KelvinsInOneKelvinDelta, kelvindelta.Kelvins, KelvinsTolerance); AssertEx.EqualTolerance(KelvinsDeltaInOneKelvinDelta, kelvindelta.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); } @@ -103,13 +135,21 @@ public void FromValueAndUnit() public void As() { var kelvindelta = TemperatureDelta.FromKelvinsDelta(1); + AssertEx.EqualTolerance(DegreesCelsiusInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeCelsius), DegreesCelsiusTolerance); AssertEx.EqualTolerance(DegreesCelsiusDeltaInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeCelsiusDelta), DegreesCelsiusDeltaTolerance); + AssertEx.EqualTolerance(DegreesDelisleInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeDelisle), DegreesDelisleTolerance); AssertEx.EqualTolerance(DegreesDelisleDeltaInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeDelisleDelta), DegreesDelisleDeltaTolerance); + AssertEx.EqualTolerance(DegreesFahrenheitInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeFahrenheit), DegreesFahrenheitTolerance); AssertEx.EqualTolerance(DegreesFahrenheitDeltaInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeFahrenheitDelta), DegreesFahrenheitDeltaTolerance); + AssertEx.EqualTolerance(DegreesNewtonInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeNewton), DegreesNewtonTolerance); AssertEx.EqualTolerance(DegreesNewtonDeltaInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeNewtonDelta), DegreesNewtonDeltaTolerance); + AssertEx.EqualTolerance(DegreesRankineInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeRankine), DegreesRankineTolerance); AssertEx.EqualTolerance(DegreesRankineDeltaInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeRankineDelta), DegreesRankineDeltaTolerance); + AssertEx.EqualTolerance(DegreesReaumurInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeReaumur), DegreesReaumurTolerance); AssertEx.EqualTolerance(DegreesReaumurDeltaInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeReaumurDelta), DegreesReaumurDeltaTolerance); + AssertEx.EqualTolerance(DegreesRoemerInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeRoemer), DegreesRoemerTolerance); AssertEx.EqualTolerance(DegreesRoemerDeltaInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeRoemerDelta), DegreesRoemerDeltaTolerance); + AssertEx.EqualTolerance(KelvinsInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.Kelvin), KelvinsTolerance); AssertEx.EqualTolerance(KelvinsDeltaInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.KelvinDelta), KelvinsDeltaTolerance); } @@ -117,13 +157,21 @@ public void As() public void ConversionRoundTrip() { TemperatureDelta kelvindelta = TemperatureDelta.FromKelvinsDelta(1); + AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesCelsius(kelvindelta.DegreesCelsius).KelvinsDelta, DegreesCelsiusTolerance); AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesCelsiusDelta(kelvindelta.DegreesCelsiusDelta).KelvinsDelta, DegreesCelsiusDeltaTolerance); + AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesDelisle(kelvindelta.DegreesDelisle).KelvinsDelta, DegreesDelisleTolerance); AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesDelisleDelta(kelvindelta.DegreesDelisleDelta).KelvinsDelta, DegreesDelisleDeltaTolerance); + AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesFahrenheit(kelvindelta.DegreesFahrenheit).KelvinsDelta, DegreesFahrenheitTolerance); AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesFahrenheitDelta(kelvindelta.DegreesFahrenheitDelta).KelvinsDelta, DegreesFahrenheitDeltaTolerance); + AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesNewton(kelvindelta.DegreesNewton).KelvinsDelta, DegreesNewtonTolerance); AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesNewtonDelta(kelvindelta.DegreesNewtonDelta).KelvinsDelta, DegreesNewtonDeltaTolerance); + AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesRankine(kelvindelta.DegreesRankine).KelvinsDelta, DegreesRankineTolerance); AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesRankineDelta(kelvindelta.DegreesRankineDelta).KelvinsDelta, DegreesRankineDeltaTolerance); + AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesReaumur(kelvindelta.DegreesReaumur).KelvinsDelta, DegreesReaumurTolerance); AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesReaumurDelta(kelvindelta.DegreesReaumurDelta).KelvinsDelta, DegreesReaumurDeltaTolerance); + AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesRoemer(kelvindelta.DegreesRoemer).KelvinsDelta, DegreesRoemerTolerance); AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesRoemerDelta(kelvindelta.DegreesRoemerDelta).KelvinsDelta, DegreesRoemerDeltaTolerance); + AssertEx.EqualTolerance(1, TemperatureDelta.FromKelvins(kelvindelta.Kelvins).KelvinsDelta, KelvinsTolerance); AssertEx.EqualTolerance(1, TemperatureDelta.FromKelvinsDelta(kelvindelta.KelvinsDelta).KelvinsDelta, KelvinsDeltaTolerance); } 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..8ecc323aa5 100644 --- a/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs @@ -129,65 +129,137 @@ public static TemperatureDeltaUnit BaseUnit /// public static TemperatureDeltaUnit[] Units { get; } = Enum.GetValues(typeof(TemperatureDeltaUnit)).Cast().ToArray(); + /// + /// Get TemperatureDelta in DegreesCelsius. + /// + public double DegreesCelsius + { + get { return _kelvinsDelta; } + } + /// /// Get TemperatureDelta in DegreesCelsiusDelta. /// + [System.Obsolete("Deprecated due to github issue #180, please use DegreeCelsius instead")] public double DegreesCelsiusDelta { get { return _kelvinsDelta; } } + /// + /// Get TemperatureDelta in DegreesDelisle. + /// + public double DegreesDelisle + { + get { return _kelvinsDelta*-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 TemperatureDelta in DegreesFahrenheit. + /// + public double DegreesFahrenheit + { + get { return _kelvinsDelta*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 TemperatureDelta in DegreesNewton. + /// + public double DegreesNewton + { + get { return _kelvinsDelta*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 TemperatureDelta in DegreesRankine. + /// + public double DegreesRankine + { + get { return _kelvinsDelta*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 TemperatureDelta in DegreesReaumur. + /// + public double DegreesReaumur + { + get { return _kelvinsDelta*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 TemperatureDelta in DegreesRoemer. + /// + public double DegreesRoemer + { + get { return _kelvinsDelta*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 TemperatureDelta in Kelvins. + /// + public double Kelvins + { + get { return _kelvinsDelta; } + } + /// /// Get TemperatureDelta in KelvinsDelta. /// + [System.Obsolete("Deprecated due to github issue #180, please use Kelvin instead")] public double KelvinsDelta { get { return _kelvinsDelta; } @@ -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); @@ -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; diff --git a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs index 27b3bf9424..f219136f5d 100644 --- a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs +++ b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs @@ -3060,41 +3060,81 @@ 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 CulturesForEnumValue((int) TemperatureDeltaUnit.DegreeDelisle, + new[] + { + new AbbreviationsForCulture("en-US", "▲°De"), + }), new CulturesForEnumValue((int) TemperatureDeltaUnit.DegreeDelisleDelta, new[] { 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 CulturesForEnumValue((int) TemperatureDeltaUnit.DegreeNewton, + new[] + { + new AbbreviationsForCulture("en-US", "▲°N"), + }), new CulturesForEnumValue((int) TemperatureDeltaUnit.DegreeNewtonDelta, new[] { 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 CulturesForEnumValue((int) TemperatureDeltaUnit.DegreeReaumur, + new[] + { + new AbbreviationsForCulture("en-US", "▲°Ré"), + }), new CulturesForEnumValue((int) TemperatureDeltaUnit.DegreeReaumurDelta, new[] { 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 CulturesForEnumValue((int) TemperatureDeltaUnit.Kelvin, + new[] + { + new AbbreviationsForCulture("en-US", "▲K"), + }), new CulturesForEnumValue((int) TemperatureDeltaUnit.KelvinDelta, new[] { 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..79fccc9b79 100644 --- a/UnitsNet/UnitDefinitions/TemperatureDelta.json +++ b/UnitsNet/UnitDefinitions/TemperatureDelta.json @@ -3,9 +3,106 @@ "BaseUnit": "KelvinDelta", "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": [ @@ -18,6 +115,7 @@ { "SingularName": "DegreeCelsiusDelta", "PluralName": "DegreesCelsiusDelta", + "ObsoleteText": "Deprecated due to github issue #180, please use DegreeCelsius instead", "FromUnitToBaseFunc": "x", "FromBaseToUnitFunc": "x", "Localization": [ @@ -30,6 +128,7 @@ { "SingularName": "DegreeDelisleDelta", "PluralName": "DegreesDelisleDelta", + "ObsoleteText": "Deprecated due to github issue #180, please use DegreeDelisle instead", "FromUnitToBaseFunc": "x*-2/3", "FromBaseToUnitFunc": "x*-3/2", "Localization": [ @@ -42,6 +141,7 @@ { "SingularName": "DegreeFahrenheitDelta", "PluralName": "DegreesFahrenheitDelta", + "ObsoleteText": "Deprecated due to github issue #180, please use DegreeFahrenheit instead", "FromUnitToBaseFunc": "x*5/9", "FromBaseToUnitFunc": "x*9/5", "Localization": [ @@ -54,6 +154,7 @@ { "SingularName": "DegreeNewtonDelta", "PluralName": "DegreesNewtonDelta", + "ObsoleteText": "Deprecated due to github issue #180, please use DegreeNewton instead", "FromUnitToBaseFunc": "x*100/33", "FromBaseToUnitFunc": "x*33/100", "Localization": [ @@ -66,6 +167,7 @@ { "SingularName": "DegreeRankineDelta", "PluralName": "DegreesRankineDelta", + "ObsoleteText": "Deprecated due to github issue #180, please use DegreeRankine instead", "FromUnitToBaseFunc": "x*5/9", "FromBaseToUnitFunc": "x*9/5", "Localization": [ @@ -78,6 +180,7 @@ { "SingularName": "DegreeReaumurDelta", "PluralName": "DegreesReaumurDelta", + "ObsoleteText": "Deprecated due to github issue #180, please use DegreeReaumur instead", "FromUnitToBaseFunc": "x*5/4", "FromBaseToUnitFunc": "x*4/5", "Localization": [ @@ -90,6 +193,7 @@ { "SingularName": "DegreeRoemerDelta", "PluralName": "DegreesRoemerDelta", + "ObsoleteText": "Deprecated due to github issue #180, please use DegreeRoemer instead", "FromUnitToBaseFunc": "x*40/21", "FromBaseToUnitFunc": "x*21/40", "Localization": [ 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" From 0a7174b85fb0d8aa0c042713f334d4a17bf6bbed Mon Sep 17 00:00:00 2001 From: Richard Dutton Date: Sun, 10 Dec 2017 19:28:43 +0000 Subject: [PATCH 2/4] Fixed breaking tests caused by enums no longer matching by value with the addition of new non-"Delta" units --- UnitsNet.Tests/CustomCode/TemperatureTests.cs | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) 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; From 88c6079d721cf5b8eb7b330b85ab88e4ed76a6ac Mon Sep 17 00:00:00 2001 From: Richard Dutton Date: Sun, 10 Dec 2017 19:40:47 +0000 Subject: [PATCH 3/4] Changed BaseUnit from KelvinDelta to Kelvin and updated test code --- .../CustomCode/TemperatureDeltaTests.cs | 32 +-- .../TemperatureDeltaTestsBase.g.cs | 204 +++++++++--------- .../Quantities/TemperatureDelta.g.cs | 88 ++++---- .../UnitDefinitions/TemperatureDelta.json | 2 +- 4 files changed, 163 insertions(+), 163 deletions(-) diff --git a/UnitsNet.Tests/CustomCode/TemperatureDeltaTests.cs b/UnitsNet.Tests/CustomCode/TemperatureDeltaTests.cs index 24314eab8f..93bec7b831 100644 --- a/UnitsNet.Tests/CustomCode/TemperatureDeltaTests.cs +++ b/UnitsNet.Tests/CustomCode/TemperatureDeltaTests.cs @@ -44,22 +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 DegreesCelsiusInOneKelvinDelta => 1; - protected override double DegreesDelisleInOneKelvinDelta => -1.5d; - protected override double DegreesFahrenheitInOneKelvinDelta => 1.8; - protected override double DegreesNewtonInOneKelvinDelta => 0.33d; - protected override double DegreesRankineInOneKelvinDelta => 1.8; - protected override double DegreesReaumurInOneKelvinDelta => 0.8; - protected override double DegreesRoemerInOneKelvinDelta => 21 / 40d; - protected override double KelvinsInOneKelvinDelta => 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/GeneratedCode/TemperatureDeltaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TemperatureDeltaTestsBase.g.cs index bbf4543178..cd6c968011 100644 --- a/UnitsNet.Tests/GeneratedCode/TemperatureDeltaTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TemperatureDeltaTestsBase.g.cs @@ -52,22 +52,22 @@ namespace UnitsNet.Tests // ReSharper disable once PartialTypeWithSinglePart public abstract partial class TemperatureDeltaTestsBase { - protected abstract double DegreesCelsiusInOneKelvinDelta { get; } - protected abstract double DegreesCelsiusDeltaInOneKelvinDelta { get; } - protected abstract double DegreesDelisleInOneKelvinDelta { get; } - protected abstract double DegreesDelisleDeltaInOneKelvinDelta { get; } - protected abstract double DegreesFahrenheitInOneKelvinDelta { get; } - protected abstract double DegreesFahrenheitDeltaInOneKelvinDelta { get; } - protected abstract double DegreesNewtonInOneKelvinDelta { get; } - protected abstract double DegreesNewtonDeltaInOneKelvinDelta { get; } - protected abstract double DegreesRankineInOneKelvinDelta { get; } - protected abstract double DegreesRankineDeltaInOneKelvinDelta { get; } - protected abstract double DegreesReaumurInOneKelvinDelta { get; } - protected abstract double DegreesReaumurDeltaInOneKelvinDelta { get; } - protected abstract double DegreesRoemerInOneKelvinDelta { get; } - protected abstract double DegreesRoemerDeltaInOneKelvinDelta { get; } - protected abstract double KelvinsInOneKelvinDelta { 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; } } @@ -89,25 +89,25 @@ public abstract partial class TemperatureDeltaTestsBase // ReSharper restore VirtualMemberNeverOverriden.Global [Fact] - public void KelvinDeltaToTemperatureDeltaUnits() + public void KelvinToTemperatureDeltaUnits() { - TemperatureDelta kelvindelta = TemperatureDelta.FromKelvinsDelta(1); - AssertEx.EqualTolerance(DegreesCelsiusInOneKelvinDelta, kelvindelta.DegreesCelsius, DegreesCelsiusTolerance); - AssertEx.EqualTolerance(DegreesCelsiusDeltaInOneKelvinDelta, kelvindelta.DegreesCelsiusDelta, DegreesCelsiusDeltaTolerance); - AssertEx.EqualTolerance(DegreesDelisleInOneKelvinDelta, kelvindelta.DegreesDelisle, DegreesDelisleTolerance); - AssertEx.EqualTolerance(DegreesDelisleDeltaInOneKelvinDelta, kelvindelta.DegreesDelisleDelta, DegreesDelisleDeltaTolerance); - AssertEx.EqualTolerance(DegreesFahrenheitInOneKelvinDelta, kelvindelta.DegreesFahrenheit, DegreesFahrenheitTolerance); - AssertEx.EqualTolerance(DegreesFahrenheitDeltaInOneKelvinDelta, kelvindelta.DegreesFahrenheitDelta, DegreesFahrenheitDeltaTolerance); - AssertEx.EqualTolerance(DegreesNewtonInOneKelvinDelta, kelvindelta.DegreesNewton, DegreesNewtonTolerance); - AssertEx.EqualTolerance(DegreesNewtonDeltaInOneKelvinDelta, kelvindelta.DegreesNewtonDelta, DegreesNewtonDeltaTolerance); - AssertEx.EqualTolerance(DegreesRankineInOneKelvinDelta, kelvindelta.DegreesRankine, DegreesRankineTolerance); - AssertEx.EqualTolerance(DegreesRankineDeltaInOneKelvinDelta, kelvindelta.DegreesRankineDelta, DegreesRankineDeltaTolerance); - AssertEx.EqualTolerance(DegreesReaumurInOneKelvinDelta, kelvindelta.DegreesReaumur, DegreesReaumurTolerance); - AssertEx.EqualTolerance(DegreesReaumurDeltaInOneKelvinDelta, kelvindelta.DegreesReaumurDelta, DegreesReaumurDeltaTolerance); - AssertEx.EqualTolerance(DegreesRoemerInOneKelvinDelta, kelvindelta.DegreesRoemer, DegreesRoemerTolerance); - AssertEx.EqualTolerance(DegreesRoemerDeltaInOneKelvinDelta, kelvindelta.DegreesRoemerDelta, DegreesRoemerDeltaTolerance); - AssertEx.EqualTolerance(KelvinsInOneKelvinDelta, kelvindelta.Kelvins, KelvinsTolerance); - 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] @@ -134,106 +134,106 @@ public void FromValueAndUnit() [Fact] public void As() { - var kelvindelta = TemperatureDelta.FromKelvinsDelta(1); - AssertEx.EqualTolerance(DegreesCelsiusInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeCelsius), DegreesCelsiusTolerance); - AssertEx.EqualTolerance(DegreesCelsiusDeltaInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeCelsiusDelta), DegreesCelsiusDeltaTolerance); - AssertEx.EqualTolerance(DegreesDelisleInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeDelisle), DegreesDelisleTolerance); - AssertEx.EqualTolerance(DegreesDelisleDeltaInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeDelisleDelta), DegreesDelisleDeltaTolerance); - AssertEx.EqualTolerance(DegreesFahrenheitInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeFahrenheit), DegreesFahrenheitTolerance); - AssertEx.EqualTolerance(DegreesFahrenheitDeltaInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeFahrenheitDelta), DegreesFahrenheitDeltaTolerance); - AssertEx.EqualTolerance(DegreesNewtonInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeNewton), DegreesNewtonTolerance); - AssertEx.EqualTolerance(DegreesNewtonDeltaInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeNewtonDelta), DegreesNewtonDeltaTolerance); - AssertEx.EqualTolerance(DegreesRankineInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeRankine), DegreesRankineTolerance); - AssertEx.EqualTolerance(DegreesRankineDeltaInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeRankineDelta), DegreesRankineDeltaTolerance); - AssertEx.EqualTolerance(DegreesReaumurInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeReaumur), DegreesReaumurTolerance); - AssertEx.EqualTolerance(DegreesReaumurDeltaInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeReaumurDelta), DegreesReaumurDeltaTolerance); - AssertEx.EqualTolerance(DegreesRoemerInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeRoemer), DegreesRoemerTolerance); - AssertEx.EqualTolerance(DegreesRoemerDeltaInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.DegreeRoemerDelta), DegreesRoemerDeltaTolerance); - AssertEx.EqualTolerance(KelvinsInOneKelvinDelta, kelvindelta.As(TemperatureDeltaUnit.Kelvin), KelvinsTolerance); - 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.FromDegreesCelsius(kelvindelta.DegreesCelsius).KelvinsDelta, DegreesCelsiusTolerance); - AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesCelsiusDelta(kelvindelta.DegreesCelsiusDelta).KelvinsDelta, DegreesCelsiusDeltaTolerance); - AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesDelisle(kelvindelta.DegreesDelisle).KelvinsDelta, DegreesDelisleTolerance); - AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesDelisleDelta(kelvindelta.DegreesDelisleDelta).KelvinsDelta, DegreesDelisleDeltaTolerance); - AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesFahrenheit(kelvindelta.DegreesFahrenheit).KelvinsDelta, DegreesFahrenheitTolerance); - AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesFahrenheitDelta(kelvindelta.DegreesFahrenheitDelta).KelvinsDelta, DegreesFahrenheitDeltaTolerance); - AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesNewton(kelvindelta.DegreesNewton).KelvinsDelta, DegreesNewtonTolerance); - AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesNewtonDelta(kelvindelta.DegreesNewtonDelta).KelvinsDelta, DegreesNewtonDeltaTolerance); - AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesRankine(kelvindelta.DegreesRankine).KelvinsDelta, DegreesRankineTolerance); - AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesRankineDelta(kelvindelta.DegreesRankineDelta).KelvinsDelta, DegreesRankineDeltaTolerance); - AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesReaumur(kelvindelta.DegreesReaumur).KelvinsDelta, DegreesReaumurTolerance); - AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesReaumurDelta(kelvindelta.DegreesReaumurDelta).KelvinsDelta, DegreesReaumurDeltaTolerance); - AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesRoemer(kelvindelta.DegreesRoemer).KelvinsDelta, DegreesRoemerTolerance); - AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesRoemerDelta(kelvindelta.DegreesRoemerDelta).KelvinsDelta, DegreesRoemerDeltaTolerance); - AssertEx.EqualTolerance(1, TemperatureDelta.FromKelvins(kelvindelta.Kelvins).KelvinsDelta, KelvinsTolerance); - 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); + TemperatureDelta oneKelvin = TemperatureDelta.FromKelvins(1); + TemperatureDelta twoKelvins = TemperatureDelta.FromKelvins(2); - Assert.True(oneKelvinDelta < twoKelvinsDelta); - Assert.True(oneKelvinDelta <= twoKelvinsDelta); - Assert.True(twoKelvinsDelta > oneKelvinDelta); - Assert.True(twoKelvinsDelta >= oneKelvinDelta); + Assert.True(oneKelvin < twoKelvins); + Assert.True(oneKelvin <= twoKelvins); + Assert.True(twoKelvins > oneKelvin); + Assert.True(twoKelvins >= oneKelvin); - Assert.False(oneKelvinDelta > twoKelvinsDelta); - Assert.False(oneKelvinDelta >= twoKelvinsDelta); - Assert.False(twoKelvinsDelta < oneKelvinDelta); - Assert.False(twoKelvinsDelta <= oneKelvinDelta); + 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); @@ -247,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/Quantities/TemperatureDelta.g.cs b/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs index 8ecc323aa5..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; } } /// @@ -134,7 +134,7 @@ public static TemperatureDeltaUnit BaseUnit /// public double DegreesCelsius { - get { return _kelvinsDelta; } + get { return _kelvins; } } /// @@ -143,7 +143,7 @@ public double DegreesCelsius [System.Obsolete("Deprecated due to github issue #180, please use DegreeCelsius instead")] public double DegreesCelsiusDelta { - get { return _kelvinsDelta; } + get { return _kelvins; } } /// @@ -151,7 +151,7 @@ public double DegreesCelsiusDelta /// public double DegreesDelisle { - get { return _kelvinsDelta*-3/2; } + get { return _kelvins*-3/2; } } /// @@ -160,7 +160,7 @@ public double DegreesDelisle [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; } } /// @@ -168,7 +168,7 @@ public double DegreesDelisleDelta /// public double DegreesFahrenheit { - get { return _kelvinsDelta*9/5; } + get { return _kelvins*9/5; } } /// @@ -177,7 +177,7 @@ public double DegreesFahrenheit [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; } } /// @@ -185,7 +185,7 @@ public double DegreesFahrenheitDelta /// public double DegreesNewton { - get { return _kelvinsDelta*33/100; } + get { return _kelvins*33/100; } } /// @@ -194,7 +194,7 @@ public double DegreesNewton [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; } } /// @@ -202,7 +202,7 @@ public double DegreesNewtonDelta /// public double DegreesRankine { - get { return _kelvinsDelta*9/5; } + get { return _kelvins*9/5; } } /// @@ -211,7 +211,7 @@ public double DegreesRankine [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; } } /// @@ -219,7 +219,7 @@ public double DegreesRankineDelta /// public double DegreesReaumur { - get { return _kelvinsDelta*4/5; } + get { return _kelvins*4/5; } } /// @@ -228,7 +228,7 @@ public double DegreesReaumur [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; } } /// @@ -236,7 +236,7 @@ public double DegreesReaumurDelta /// public double DegreesRoemer { - get { return _kelvinsDelta*21/40; } + get { return _kelvins*21/40; } } /// @@ -245,7 +245,7 @@ public double DegreesRoemer [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; } } /// @@ -253,7 +253,7 @@ public double DegreesRoemerDelta /// public double Kelvins { - get { return _kelvinsDelta; } + get { return _kelvins; } } /// @@ -262,7 +262,7 @@ public double Kelvins [System.Obsolete("Deprecated due to github issue #180, please use Kelvin instead")] public double KelvinsDelta { - get { return _kelvinsDelta; } + get { return _kelvins; } } #endregion @@ -946,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 @@ -999,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 @@ -1047,7 +1047,7 @@ public override bool Equals(object obj) return false; } - return _kelvinsDelta.Equals(((TemperatureDelta) obj)._kelvinsDelta); + return _kelvins.Equals(((TemperatureDelta) obj)._kelvins); } /// @@ -1060,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 @@ -1189,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)); } /// @@ -1290,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/UnitDefinitions/TemperatureDelta.json b/UnitsNet/UnitDefinitions/TemperatureDelta.json index 79fccc9b79..990c115f88 100644 --- a/UnitsNet/UnitDefinitions/TemperatureDelta.json +++ b/UnitsNet/UnitDefinitions/TemperatureDelta.json @@ -1,6 +1,6 @@ { "Name": "TemperatureDelta", - "BaseUnit": "KelvinDelta", + "BaseUnit": "Kelvin", "XmlDoc": "Difference between two temperatures. The conversions are different than for Temperature.", "Units": [ { From acb20665b3ce9cb19e1953e6e36aec8703e46565 Mon Sep 17 00:00:00 2001 From: Richard Dutton Date: Sun, 10 Dec 2017 19:44:11 +0000 Subject: [PATCH 4/4] =?UTF-8?q?Changed=20=E2=96=B2to=20=E2=88=86=20as=20pe?= =?UTF-8?q?r=20#327=20and=20#328?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../GeneratedCode/UnitSystem.Default.g.cs | 32 +++++++++---------- .../UnitDefinitions/TemperatureDelta.json | 32 +++++++++---------- 2 files changed, 32 insertions(+), 32 deletions(-) diff --git a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs index f219136f5d..0f1ec3aa7e 100644 --- a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs +++ b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs @@ -3063,82 +3063,82 @@ private static readonly ReadOnlyCollection DefaultLocalization new CulturesForEnumValue((int) TemperatureDeltaUnit.DegreeCelsius, new[] { - new AbbreviationsForCulture("en-US", "▲°C"), + 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 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 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 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 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 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 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 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/UnitDefinitions/TemperatureDelta.json b/UnitsNet/UnitDefinitions/TemperatureDelta.json index 990c115f88..771f916667 100644 --- a/UnitsNet/UnitDefinitions/TemperatureDelta.json +++ b/UnitsNet/UnitDefinitions/TemperatureDelta.json @@ -11,7 +11,7 @@ "Localization": [ { "Culture": "en-US", - "Abbreviations": [ "▲K" ] + "Abbreviations": [ "∆K" ] } ] }, @@ -23,7 +23,7 @@ "Localization": [ { "Culture": "en-US", - "Abbreviations": [ "▲°C" ] + "Abbreviations": [ "∆°C" ] } ] }, @@ -35,7 +35,7 @@ "Localization": [ { "Culture": "en-US", - "Abbreviations": [ "▲°De" ] + "Abbreviations": [ "∆°De" ] } ] }, @@ -47,7 +47,7 @@ "Localization": [ { "Culture": "en-US", - "Abbreviations": [ "▲°F" ] + "Abbreviations": [ "∆°F" ] } ] }, @@ -59,7 +59,7 @@ "Localization": [ { "Culture": "en-US", - "Abbreviations": [ "▲°N" ] + "Abbreviations": [ "∆°N" ] } ] }, @@ -71,7 +71,7 @@ "Localization": [ { "Culture": "en-US", - "Abbreviations": [ "▲°R" ] + "Abbreviations": [ "∆°R" ] } ] }, @@ -83,7 +83,7 @@ "Localization": [ { "Culture": "en-US", - "Abbreviations": [ "▲°Ré" ] + "Abbreviations": [ "∆°Ré" ] } ] }, @@ -95,7 +95,7 @@ "Localization": [ { "Culture": "en-US", - "Abbreviations": [ "▲°Rø" ] + "Abbreviations": [ "∆°Rø" ] } ] }, @@ -108,7 +108,7 @@ "Localization": [ { "Culture": "en-US", - "Abbreviations": [ "▲K" ] + "Abbreviations": [ "∆K" ] } ] }, @@ -121,7 +121,7 @@ "Localization": [ { "Culture": "en-US", - "Abbreviations": [ "▲°C" ] + "Abbreviations": [ "∆°C" ] } ] }, @@ -134,7 +134,7 @@ "Localization": [ { "Culture": "en-US", - "Abbreviations": [ "▲°De" ] + "Abbreviations": [ "∆°De" ] } ] }, @@ -147,7 +147,7 @@ "Localization": [ { "Culture": "en-US", - "Abbreviations": [ "▲°F" ] + "Abbreviations": [ "∆°F" ] } ] }, @@ -160,7 +160,7 @@ "Localization": [ { "Culture": "en-US", - "Abbreviations": [ "▲°N" ] + "Abbreviations": [ "∆°N" ] } ] }, @@ -173,7 +173,7 @@ "Localization": [ { "Culture": "en-US", - "Abbreviations": [ "▲°R" ] + "Abbreviations": [ "∆°R" ] } ] }, @@ -186,7 +186,7 @@ "Localization": [ { "Culture": "en-US", - "Abbreviations": [ "▲°Ré" ] + "Abbreviations": [ "∆°Ré" ] } ] }, @@ -199,7 +199,7 @@ "Localization": [ { "Culture": "en-US", - "Abbreviations": [ "▲°Rø" ] + "Abbreviations": [ "∆°Rø" ] } ] }