From d3af09baa0deae190de6590292d790ffc6fb95cb Mon Sep 17 00:00:00 2001 From: trb5016 Date: Fri, 21 Feb 2020 12:52:35 -0500 Subject: [PATCH 1/3] Add Energy.WattDays (Prefixes) --- Common/UnitDefinitions/Energy.json | 17 ++ .../NumberToEnergyExtensionsTest.g.cs | 20 ++ .../NumberToEnergyExtensions.g.cs | 20 ++ UnitsNet.Tests/CustomCode/EnergyTests.cs | 12 +- .../TestsBase/EnergyTestsBase.g.cs | 189 ++++++++++++------ .../GeneratedCode/Quantities/Energy.g.cs | 85 ++++++++ .../GeneratedCode/UnitAbbreviationsCache.g.cs | 10 + .../GeneratedCode/Units/EnergyUnit.g.cs | 5 + UnitsNet/GeneratedCode/Quantities/Energy.g.cs | 85 ++++++++ .../GeneratedCode/UnitAbbreviationsCache.g.cs | 10 + UnitsNet/GeneratedCode/UnitConverter.g.cs | 10 + UnitsNet/GeneratedCode/Units/EnergyUnit.g.cs | 5 + 12 files changed, 410 insertions(+), 58 deletions(-) diff --git a/Common/UnitDefinitions/Energy.json b/Common/UnitDefinitions/Energy.json index 3795c4e1ad..356bb67b60 100644 --- a/Common/UnitDefinitions/Energy.json +++ b/Common/UnitDefinitions/Energy.json @@ -115,6 +115,23 @@ } ] }, + { + "SingularName": "WattDay", + "PluralName": "WattDays", + "FromUnitToBaseFunc": "x*24*3600d", + "FromBaseToUnitFunc": "x/(24*3600d)", + "Prefixes": [ "Kilo", "Mega", "Giga", "Tera" ], + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "Wd" ] + }, + { + "Culture": "ru-RU", + "Abbreviations": [ "Вт/д" ] + } + ] + }, { "SingularName": "ThermEc", "PluralName": "ThermsEc", diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToEnergyExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToEnergyExtensionsTest.g.cs index bbb82cb2a9..b211b1819f 100644 --- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToEnergyExtensionsTest.g.cs +++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToEnergyExtensionsTest.g.cs @@ -68,6 +68,10 @@ public void NumberToGigaelectronVoltsTest() => public void NumberToGigajoulesTest() => Assert.Equal(Energy.FromGigajoules(2), 2.Gigajoules()); + [Fact] + public void NumberToGigawattDaysTest() => + Assert.Equal(Energy.FromGigawattDays(2), 2.GigawattDays()); + [Fact] public void NumberToGigawattHoursTest() => Assert.Equal(Energy.FromGigawattHours(2), 2.GigawattHours()); @@ -92,6 +96,10 @@ public void NumberToKiloelectronVoltsTest() => public void NumberToKilojoulesTest() => Assert.Equal(Energy.FromKilojoules(2), 2.Kilojoules()); + [Fact] + public void NumberToKilowattDaysTest() => + Assert.Equal(Energy.FromKilowattDays(2), 2.KilowattDays()); + [Fact] public void NumberToKilowattHoursTest() => Assert.Equal(Energy.FromKilowattHours(2), 2.KilowattHours()); @@ -112,6 +120,10 @@ public void NumberToMegaelectronVoltsTest() => public void NumberToMegajoulesTest() => Assert.Equal(Energy.FromMegajoules(2), 2.Megajoules()); + [Fact] + public void NumberToMegawattDaysTest() => + Assert.Equal(Energy.FromMegawattDays(2), 2.MegawattDays()); + [Fact] public void NumberToMegawattHoursTest() => Assert.Equal(Energy.FromMegawattHours(2), 2.MegawattHours()); @@ -124,6 +136,10 @@ public void NumberToMillijoulesTest() => public void NumberToTeraelectronVoltsTest() => Assert.Equal(Energy.FromTeraelectronVolts(2), 2.TeraelectronVolts()); + [Fact] + public void NumberToTerawattDaysTest() => + Assert.Equal(Energy.FromTerawattDays(2), 2.TerawattDays()); + [Fact] public void NumberToTerawattHoursTest() => Assert.Equal(Energy.FromTerawattHours(2), 2.TerawattHours()); @@ -140,6 +156,10 @@ public void NumberToThermsImperialTest() => public void NumberToThermsUsTest() => Assert.Equal(Energy.FromThermsUs(2), 2.ThermsUs()); + [Fact] + public void NumberToWattDaysTest() => + Assert.Equal(Energy.FromWattDays(2), 2.WattDays()); + [Fact] public void NumberToWattHoursTest() => Assert.Equal(Energy.FromWattHours(2), 2.WattHours()); diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToEnergyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToEnergyExtensions.g.cs index f77975062d..9354fe4432 100644 --- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToEnergyExtensions.g.cs +++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToEnergyExtensions.g.cs @@ -70,6 +70,10 @@ public static Energy GigaelectronVolts(this T value) => public static Energy Gigajoules(this T value) => Energy.FromGigajoules(Convert.ToDouble(value)); + /// + public static Energy GigawattDays(this T value) => + Energy.FromGigawattDays(Convert.ToDouble(value)); + /// public static Energy GigawattHours(this T value) => Energy.FromGigawattHours(Convert.ToDouble(value)); @@ -94,6 +98,10 @@ public static Energy KiloelectronVolts(this T value) => public static Energy Kilojoules(this T value) => Energy.FromKilojoules(Convert.ToDouble(value)); + /// + public static Energy KilowattDays(this T value) => + Energy.FromKilowattDays(Convert.ToDouble(value)); + /// public static Energy KilowattHours(this T value) => Energy.FromKilowattHours(Convert.ToDouble(value)); @@ -114,6 +122,10 @@ public static Energy MegaelectronVolts(this T value) => public static Energy Megajoules(this T value) => Energy.FromMegajoules(Convert.ToDouble(value)); + /// + public static Energy MegawattDays(this T value) => + Energy.FromMegawattDays(Convert.ToDouble(value)); + /// public static Energy MegawattHours(this T value) => Energy.FromMegawattHours(Convert.ToDouble(value)); @@ -126,6 +138,10 @@ public static Energy Millijoules(this T value) => public static Energy TeraelectronVolts(this T value) => Energy.FromTeraelectronVolts(Convert.ToDouble(value)); + /// + public static Energy TerawattDays(this T value) => + Energy.FromTerawattDays(Convert.ToDouble(value)); + /// public static Energy TerawattHours(this T value) => Energy.FromTerawattHours(Convert.ToDouble(value)); @@ -142,6 +158,10 @@ public static Energy ThermsImperial(this T value) => public static Energy ThermsUs(this T value) => Energy.FromThermsUs(Convert.ToDouble(value)); + /// + public static Energy WattDays(this T value) => + Energy.FromWattDays(Convert.ToDouble(value)); + /// public static Energy WattHours(this T value) => Energy.FromWattHours(Convert.ToDouble(value)); diff --git a/UnitsNet.Tests/CustomCode/EnergyTests.cs b/UnitsNet.Tests/CustomCode/EnergyTests.cs index e23431960b..f789fe7d01 100644 --- a/UnitsNet.Tests/CustomCode/EnergyTests.cs +++ b/UnitsNet.Tests/CustomCode/EnergyTests.cs @@ -1,4 +1,4 @@ -// Licensed under MIT No Attribution, see LICENSE file at the root. +// Licensed under MIT No Attribution, see LICENSE file at the root. // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet. using UnitsNet.Units; @@ -38,6 +38,8 @@ public class EnergyTests : EnergyTestsBase protected override double TerawattHoursInOneJoule => 2.77777778e-16; + protected override double TerawattDaysInOneJoule => 1.157407407407410E-17; + protected override double ThermsEcInOneJoule => 9.4781712031331720001278504447561e-9; protected override double FootPoundsInOneJoule => 0.737562149; @@ -48,16 +50,24 @@ public class EnergyTests : EnergyTestsBase protected override double GigawattHoursInOneJoule => 2.77777778e-13; + protected override double GigawattDaysInOneJoule => 1.157407407407410E-14; + protected override double KilocaloriesInOneJoule => 0.00023900573614; protected override double KilowattHoursInOneJoule => 2.77777778e-7; + protected override double KilowattDaysInOneJoule => 1.157407407407410E-08; + protected override double MegawattHoursInOneJoule => 2.77777778e-10; + protected override double MegawattDaysInOneJoule => 1.157407407407410E-11; + protected override double ThermsUsInOneJoule => 9.4804342797334860315281322406817e-9; protected override double WattHoursInOneJoule => 0.000277777778; + protected override double WattDaysInOneJoule => 1.157407407407410E-05; + protected override double ElectronVoltsInOneJoule => 6.241509343260179e18; protected override double KiloelectronVoltsInOneJoule => 6.2415093433e+15; diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/EnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/EnergyTestsBase.g.cs index 092a019875..0fdc7cb5c1 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/EnergyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/EnergyTestsBase.g.cs @@ -47,24 +47,29 @@ public abstract partial class EnergyTestsBase protected abstract double GigabritishThermalUnitsInOneJoule { get; } protected abstract double GigaelectronVoltsInOneJoule { get; } protected abstract double GigajoulesInOneJoule { get; } + protected abstract double GigawattDaysInOneJoule { get; } protected abstract double GigawattHoursInOneJoule { get; } protected abstract double JoulesInOneJoule { get; } protected abstract double KilobritishThermalUnitsInOneJoule { get; } protected abstract double KilocaloriesInOneJoule { get; } protected abstract double KiloelectronVoltsInOneJoule { get; } protected abstract double KilojoulesInOneJoule { get; } + protected abstract double KilowattDaysInOneJoule { get; } protected abstract double KilowattHoursInOneJoule { get; } protected abstract double MegabritishThermalUnitsInOneJoule { get; } protected abstract double MegacaloriesInOneJoule { get; } protected abstract double MegaelectronVoltsInOneJoule { get; } protected abstract double MegajoulesInOneJoule { get; } + protected abstract double MegawattDaysInOneJoule { get; } protected abstract double MegawattHoursInOneJoule { get; } protected abstract double MillijoulesInOneJoule { get; } protected abstract double TeraelectronVoltsInOneJoule { get; } + protected abstract double TerawattDaysInOneJoule { get; } protected abstract double TerawattHoursInOneJoule { get; } protected abstract double ThermsEcInOneJoule { get; } protected abstract double ThermsImperialInOneJoule { get; } protected abstract double ThermsUsInOneJoule { get; } + protected abstract double WattDaysInOneJoule { get; } protected abstract double WattHoursInOneJoule { get; } // ReSharper disable VirtualMemberNeverOverriden.Global @@ -79,24 +84,29 @@ public abstract partial class EnergyTestsBase protected virtual double GigabritishThermalUnitsTolerance { get { return 1e-5; } } protected virtual double GigaelectronVoltsTolerance { get { return 1e-5; } } protected virtual double GigajoulesTolerance { get { return 1e-5; } } + protected virtual double GigawattDaysTolerance { get { return 1e-5; } } protected virtual double GigawattHoursTolerance { get { return 1e-5; } } protected virtual double JoulesTolerance { get { return 1e-5; } } protected virtual double KilobritishThermalUnitsTolerance { get { return 1e-5; } } protected virtual double KilocaloriesTolerance { get { return 1e-5; } } protected virtual double KiloelectronVoltsTolerance { get { return 1e-5; } } protected virtual double KilojoulesTolerance { get { return 1e-5; } } + protected virtual double KilowattDaysTolerance { get { return 1e-5; } } protected virtual double KilowattHoursTolerance { get { return 1e-5; } } protected virtual double MegabritishThermalUnitsTolerance { get { return 1e-5; } } protected virtual double MegacaloriesTolerance { get { return 1e-5; } } protected virtual double MegaelectronVoltsTolerance { get { return 1e-5; } } protected virtual double MegajoulesTolerance { get { return 1e-5; } } + protected virtual double MegawattDaysTolerance { get { return 1e-5; } } protected virtual double MegawattHoursTolerance { get { return 1e-5; } } protected virtual double MillijoulesTolerance { get { return 1e-5; } } protected virtual double TeraelectronVoltsTolerance { get { return 1e-5; } } + protected virtual double TerawattDaysTolerance { get { return 1e-5; } } protected virtual double TerawattHoursTolerance { get { return 1e-5; } } protected virtual double ThermsEcTolerance { get { return 1e-5; } } protected virtual double ThermsImperialTolerance { get { return 1e-5; } } protected virtual double ThermsUsTolerance { get { return 1e-5; } } + protected virtual double WattDaysTolerance { get { return 1e-5; } } protected virtual double WattHoursTolerance { get { return 1e-5; } } // ReSharper restore VirtualMemberNeverOverriden.Global @@ -170,24 +180,29 @@ public void JouleToEnergyUnits() AssertEx.EqualTolerance(GigabritishThermalUnitsInOneJoule, joule.GigabritishThermalUnits, GigabritishThermalUnitsTolerance); AssertEx.EqualTolerance(GigaelectronVoltsInOneJoule, joule.GigaelectronVolts, GigaelectronVoltsTolerance); AssertEx.EqualTolerance(GigajoulesInOneJoule, joule.Gigajoules, GigajoulesTolerance); + AssertEx.EqualTolerance(GigawattDaysInOneJoule, joule.GigawattDays, GigawattDaysTolerance); AssertEx.EqualTolerance(GigawattHoursInOneJoule, joule.GigawattHours, GigawattHoursTolerance); AssertEx.EqualTolerance(JoulesInOneJoule, joule.Joules, JoulesTolerance); AssertEx.EqualTolerance(KilobritishThermalUnitsInOneJoule, joule.KilobritishThermalUnits, KilobritishThermalUnitsTolerance); AssertEx.EqualTolerance(KilocaloriesInOneJoule, joule.Kilocalories, KilocaloriesTolerance); AssertEx.EqualTolerance(KiloelectronVoltsInOneJoule, joule.KiloelectronVolts, KiloelectronVoltsTolerance); AssertEx.EqualTolerance(KilojoulesInOneJoule, joule.Kilojoules, KilojoulesTolerance); + AssertEx.EqualTolerance(KilowattDaysInOneJoule, joule.KilowattDays, KilowattDaysTolerance); AssertEx.EqualTolerance(KilowattHoursInOneJoule, joule.KilowattHours, KilowattHoursTolerance); AssertEx.EqualTolerance(MegabritishThermalUnitsInOneJoule, joule.MegabritishThermalUnits, MegabritishThermalUnitsTolerance); AssertEx.EqualTolerance(MegacaloriesInOneJoule, joule.Megacalories, MegacaloriesTolerance); AssertEx.EqualTolerance(MegaelectronVoltsInOneJoule, joule.MegaelectronVolts, MegaelectronVoltsTolerance); AssertEx.EqualTolerance(MegajoulesInOneJoule, joule.Megajoules, MegajoulesTolerance); + AssertEx.EqualTolerance(MegawattDaysInOneJoule, joule.MegawattDays, MegawattDaysTolerance); AssertEx.EqualTolerance(MegawattHoursInOneJoule, joule.MegawattHours, MegawattHoursTolerance); AssertEx.EqualTolerance(MillijoulesInOneJoule, joule.Millijoules, MillijoulesTolerance); AssertEx.EqualTolerance(TeraelectronVoltsInOneJoule, joule.TeraelectronVolts, TeraelectronVoltsTolerance); + AssertEx.EqualTolerance(TerawattDaysInOneJoule, joule.TerawattDays, TerawattDaysTolerance); AssertEx.EqualTolerance(TerawattHoursInOneJoule, joule.TerawattHours, TerawattHoursTolerance); AssertEx.EqualTolerance(ThermsEcInOneJoule, joule.ThermsEc, ThermsEcTolerance); AssertEx.EqualTolerance(ThermsImperialInOneJoule, joule.ThermsImperial, ThermsImperialTolerance); AssertEx.EqualTolerance(ThermsUsInOneJoule, joule.ThermsUs, ThermsUsTolerance); + AssertEx.EqualTolerance(WattDaysInOneJoule, joule.WattDays, WattDaysTolerance); AssertEx.EqualTolerance(WattHoursInOneJoule, joule.WattHours, WattHoursTolerance); } @@ -238,81 +253,101 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() AssertEx.EqualTolerance(1, quantity10.Gigajoules, GigajoulesTolerance); Assert.Equal(EnergyUnit.Gigajoule, quantity10.Unit); - var quantity11 = Energy.From(1, EnergyUnit.GigawattHour); - AssertEx.EqualTolerance(1, quantity11.GigawattHours, GigawattHoursTolerance); - Assert.Equal(EnergyUnit.GigawattHour, quantity11.Unit); + var quantity11 = Energy.From(1, EnergyUnit.GigawattDay); + AssertEx.EqualTolerance(1, quantity11.GigawattDays, GigawattDaysTolerance); + Assert.Equal(EnergyUnit.GigawattDay, quantity11.Unit); - var quantity12 = Energy.From(1, EnergyUnit.Joule); - AssertEx.EqualTolerance(1, quantity12.Joules, JoulesTolerance); - Assert.Equal(EnergyUnit.Joule, quantity12.Unit); + var quantity12 = Energy.From(1, EnergyUnit.GigawattHour); + AssertEx.EqualTolerance(1, quantity12.GigawattHours, GigawattHoursTolerance); + Assert.Equal(EnergyUnit.GigawattHour, quantity12.Unit); - var quantity13 = Energy.From(1, EnergyUnit.KilobritishThermalUnit); - AssertEx.EqualTolerance(1, quantity13.KilobritishThermalUnits, KilobritishThermalUnitsTolerance); - Assert.Equal(EnergyUnit.KilobritishThermalUnit, quantity13.Unit); + var quantity13 = Energy.From(1, EnergyUnit.Joule); + AssertEx.EqualTolerance(1, quantity13.Joules, JoulesTolerance); + Assert.Equal(EnergyUnit.Joule, quantity13.Unit); - var quantity14 = Energy.From(1, EnergyUnit.Kilocalorie); - AssertEx.EqualTolerance(1, quantity14.Kilocalories, KilocaloriesTolerance); - Assert.Equal(EnergyUnit.Kilocalorie, quantity14.Unit); + var quantity14 = Energy.From(1, EnergyUnit.KilobritishThermalUnit); + AssertEx.EqualTolerance(1, quantity14.KilobritishThermalUnits, KilobritishThermalUnitsTolerance); + Assert.Equal(EnergyUnit.KilobritishThermalUnit, quantity14.Unit); - var quantity15 = Energy.From(1, EnergyUnit.KiloelectronVolt); - AssertEx.EqualTolerance(1, quantity15.KiloelectronVolts, KiloelectronVoltsTolerance); - Assert.Equal(EnergyUnit.KiloelectronVolt, quantity15.Unit); + var quantity15 = Energy.From(1, EnergyUnit.Kilocalorie); + AssertEx.EqualTolerance(1, quantity15.Kilocalories, KilocaloriesTolerance); + Assert.Equal(EnergyUnit.Kilocalorie, quantity15.Unit); - var quantity16 = Energy.From(1, EnergyUnit.Kilojoule); - AssertEx.EqualTolerance(1, quantity16.Kilojoules, KilojoulesTolerance); - Assert.Equal(EnergyUnit.Kilojoule, quantity16.Unit); + var quantity16 = Energy.From(1, EnergyUnit.KiloelectronVolt); + AssertEx.EqualTolerance(1, quantity16.KiloelectronVolts, KiloelectronVoltsTolerance); + Assert.Equal(EnergyUnit.KiloelectronVolt, quantity16.Unit); - var quantity17 = Energy.From(1, EnergyUnit.KilowattHour); - AssertEx.EqualTolerance(1, quantity17.KilowattHours, KilowattHoursTolerance); - Assert.Equal(EnergyUnit.KilowattHour, quantity17.Unit); + var quantity17 = Energy.From(1, EnergyUnit.Kilojoule); + AssertEx.EqualTolerance(1, quantity17.Kilojoules, KilojoulesTolerance); + Assert.Equal(EnergyUnit.Kilojoule, quantity17.Unit); - var quantity18 = Energy.From(1, EnergyUnit.MegabritishThermalUnit); - AssertEx.EqualTolerance(1, quantity18.MegabritishThermalUnits, MegabritishThermalUnitsTolerance); - Assert.Equal(EnergyUnit.MegabritishThermalUnit, quantity18.Unit); + var quantity18 = Energy.From(1, EnergyUnit.KilowattDay); + AssertEx.EqualTolerance(1, quantity18.KilowattDays, KilowattDaysTolerance); + Assert.Equal(EnergyUnit.KilowattDay, quantity18.Unit); - var quantity19 = Energy.From(1, EnergyUnit.Megacalorie); - AssertEx.EqualTolerance(1, quantity19.Megacalories, MegacaloriesTolerance); - Assert.Equal(EnergyUnit.Megacalorie, quantity19.Unit); + var quantity19 = Energy.From(1, EnergyUnit.KilowattHour); + AssertEx.EqualTolerance(1, quantity19.KilowattHours, KilowattHoursTolerance); + Assert.Equal(EnergyUnit.KilowattHour, quantity19.Unit); - var quantity20 = Energy.From(1, EnergyUnit.MegaelectronVolt); - AssertEx.EqualTolerance(1, quantity20.MegaelectronVolts, MegaelectronVoltsTolerance); - Assert.Equal(EnergyUnit.MegaelectronVolt, quantity20.Unit); + var quantity20 = Energy.From(1, EnergyUnit.MegabritishThermalUnit); + AssertEx.EqualTolerance(1, quantity20.MegabritishThermalUnits, MegabritishThermalUnitsTolerance); + Assert.Equal(EnergyUnit.MegabritishThermalUnit, quantity20.Unit); - var quantity21 = Energy.From(1, EnergyUnit.Megajoule); - AssertEx.EqualTolerance(1, quantity21.Megajoules, MegajoulesTolerance); - Assert.Equal(EnergyUnit.Megajoule, quantity21.Unit); + var quantity21 = Energy.From(1, EnergyUnit.Megacalorie); + AssertEx.EqualTolerance(1, quantity21.Megacalories, MegacaloriesTolerance); + Assert.Equal(EnergyUnit.Megacalorie, quantity21.Unit); - var quantity22 = Energy.From(1, EnergyUnit.MegawattHour); - AssertEx.EqualTolerance(1, quantity22.MegawattHours, MegawattHoursTolerance); - Assert.Equal(EnergyUnit.MegawattHour, quantity22.Unit); + var quantity22 = Energy.From(1, EnergyUnit.MegaelectronVolt); + AssertEx.EqualTolerance(1, quantity22.MegaelectronVolts, MegaelectronVoltsTolerance); + Assert.Equal(EnergyUnit.MegaelectronVolt, quantity22.Unit); - var quantity23 = Energy.From(1, EnergyUnit.Millijoule); - AssertEx.EqualTolerance(1, quantity23.Millijoules, MillijoulesTolerance); - Assert.Equal(EnergyUnit.Millijoule, quantity23.Unit); + var quantity23 = Energy.From(1, EnergyUnit.Megajoule); + AssertEx.EqualTolerance(1, quantity23.Megajoules, MegajoulesTolerance); + Assert.Equal(EnergyUnit.Megajoule, quantity23.Unit); - var quantity24 = Energy.From(1, EnergyUnit.TeraelectronVolt); - AssertEx.EqualTolerance(1, quantity24.TeraelectronVolts, TeraelectronVoltsTolerance); - Assert.Equal(EnergyUnit.TeraelectronVolt, quantity24.Unit); + var quantity24 = Energy.From(1, EnergyUnit.MegawattDay); + AssertEx.EqualTolerance(1, quantity24.MegawattDays, MegawattDaysTolerance); + Assert.Equal(EnergyUnit.MegawattDay, quantity24.Unit); - var quantity25 = Energy.From(1, EnergyUnit.TerawattHour); - AssertEx.EqualTolerance(1, quantity25.TerawattHours, TerawattHoursTolerance); - Assert.Equal(EnergyUnit.TerawattHour, quantity25.Unit); + var quantity25 = Energy.From(1, EnergyUnit.MegawattHour); + AssertEx.EqualTolerance(1, quantity25.MegawattHours, MegawattHoursTolerance); + Assert.Equal(EnergyUnit.MegawattHour, quantity25.Unit); - var quantity26 = Energy.From(1, EnergyUnit.ThermEc); - AssertEx.EqualTolerance(1, quantity26.ThermsEc, ThermsEcTolerance); - Assert.Equal(EnergyUnit.ThermEc, quantity26.Unit); + var quantity26 = Energy.From(1, EnergyUnit.Millijoule); + AssertEx.EqualTolerance(1, quantity26.Millijoules, MillijoulesTolerance); + Assert.Equal(EnergyUnit.Millijoule, quantity26.Unit); - var quantity27 = Energy.From(1, EnergyUnit.ThermImperial); - AssertEx.EqualTolerance(1, quantity27.ThermsImperial, ThermsImperialTolerance); - Assert.Equal(EnergyUnit.ThermImperial, quantity27.Unit); + var quantity27 = Energy.From(1, EnergyUnit.TeraelectronVolt); + AssertEx.EqualTolerance(1, quantity27.TeraelectronVolts, TeraelectronVoltsTolerance); + Assert.Equal(EnergyUnit.TeraelectronVolt, quantity27.Unit); - var quantity28 = Energy.From(1, EnergyUnit.ThermUs); - AssertEx.EqualTolerance(1, quantity28.ThermsUs, ThermsUsTolerance); - Assert.Equal(EnergyUnit.ThermUs, quantity28.Unit); + var quantity28 = Energy.From(1, EnergyUnit.TerawattDay); + AssertEx.EqualTolerance(1, quantity28.TerawattDays, TerawattDaysTolerance); + Assert.Equal(EnergyUnit.TerawattDay, quantity28.Unit); - var quantity29 = Energy.From(1, EnergyUnit.WattHour); - AssertEx.EqualTolerance(1, quantity29.WattHours, WattHoursTolerance); - Assert.Equal(EnergyUnit.WattHour, quantity29.Unit); + var quantity29 = Energy.From(1, EnergyUnit.TerawattHour); + AssertEx.EqualTolerance(1, quantity29.TerawattHours, TerawattHoursTolerance); + Assert.Equal(EnergyUnit.TerawattHour, quantity29.Unit); + + var quantity30 = Energy.From(1, EnergyUnit.ThermEc); + AssertEx.EqualTolerance(1, quantity30.ThermsEc, ThermsEcTolerance); + Assert.Equal(EnergyUnit.ThermEc, quantity30.Unit); + + var quantity31 = Energy.From(1, EnergyUnit.ThermImperial); + AssertEx.EqualTolerance(1, quantity31.ThermsImperial, ThermsImperialTolerance); + Assert.Equal(EnergyUnit.ThermImperial, quantity31.Unit); + + var quantity32 = Energy.From(1, EnergyUnit.ThermUs); + AssertEx.EqualTolerance(1, quantity32.ThermsUs, ThermsUsTolerance); + Assert.Equal(EnergyUnit.ThermUs, quantity32.Unit); + + var quantity33 = Energy.From(1, EnergyUnit.WattDay); + AssertEx.EqualTolerance(1, quantity33.WattDays, WattDaysTolerance); + Assert.Equal(EnergyUnit.WattDay, quantity33.Unit); + + var quantity34 = Energy.From(1, EnergyUnit.WattHour); + AssertEx.EqualTolerance(1, quantity34.WattHours, WattHoursTolerance); + Assert.Equal(EnergyUnit.WattHour, quantity34.Unit); } @@ -344,24 +379,29 @@ public void As() AssertEx.EqualTolerance(GigabritishThermalUnitsInOneJoule, joule.As(EnergyUnit.GigabritishThermalUnit), GigabritishThermalUnitsTolerance); AssertEx.EqualTolerance(GigaelectronVoltsInOneJoule, joule.As(EnergyUnit.GigaelectronVolt), GigaelectronVoltsTolerance); AssertEx.EqualTolerance(GigajoulesInOneJoule, joule.As(EnergyUnit.Gigajoule), GigajoulesTolerance); + AssertEx.EqualTolerance(GigawattDaysInOneJoule, joule.As(EnergyUnit.GigawattDay), GigawattDaysTolerance); AssertEx.EqualTolerance(GigawattHoursInOneJoule, joule.As(EnergyUnit.GigawattHour), GigawattHoursTolerance); AssertEx.EqualTolerance(JoulesInOneJoule, joule.As(EnergyUnit.Joule), JoulesTolerance); AssertEx.EqualTolerance(KilobritishThermalUnitsInOneJoule, joule.As(EnergyUnit.KilobritishThermalUnit), KilobritishThermalUnitsTolerance); AssertEx.EqualTolerance(KilocaloriesInOneJoule, joule.As(EnergyUnit.Kilocalorie), KilocaloriesTolerance); AssertEx.EqualTolerance(KiloelectronVoltsInOneJoule, joule.As(EnergyUnit.KiloelectronVolt), KiloelectronVoltsTolerance); AssertEx.EqualTolerance(KilojoulesInOneJoule, joule.As(EnergyUnit.Kilojoule), KilojoulesTolerance); + AssertEx.EqualTolerance(KilowattDaysInOneJoule, joule.As(EnergyUnit.KilowattDay), KilowattDaysTolerance); AssertEx.EqualTolerance(KilowattHoursInOneJoule, joule.As(EnergyUnit.KilowattHour), KilowattHoursTolerance); AssertEx.EqualTolerance(MegabritishThermalUnitsInOneJoule, joule.As(EnergyUnit.MegabritishThermalUnit), MegabritishThermalUnitsTolerance); AssertEx.EqualTolerance(MegacaloriesInOneJoule, joule.As(EnergyUnit.Megacalorie), MegacaloriesTolerance); AssertEx.EqualTolerance(MegaelectronVoltsInOneJoule, joule.As(EnergyUnit.MegaelectronVolt), MegaelectronVoltsTolerance); AssertEx.EqualTolerance(MegajoulesInOneJoule, joule.As(EnergyUnit.Megajoule), MegajoulesTolerance); + AssertEx.EqualTolerance(MegawattDaysInOneJoule, joule.As(EnergyUnit.MegawattDay), MegawattDaysTolerance); AssertEx.EqualTolerance(MegawattHoursInOneJoule, joule.As(EnergyUnit.MegawattHour), MegawattHoursTolerance); AssertEx.EqualTolerance(MillijoulesInOneJoule, joule.As(EnergyUnit.Millijoule), MillijoulesTolerance); AssertEx.EqualTolerance(TeraelectronVoltsInOneJoule, joule.As(EnergyUnit.TeraelectronVolt), TeraelectronVoltsTolerance); + AssertEx.EqualTolerance(TerawattDaysInOneJoule, joule.As(EnergyUnit.TerawattDay), TerawattDaysTolerance); AssertEx.EqualTolerance(TerawattHoursInOneJoule, joule.As(EnergyUnit.TerawattHour), TerawattHoursTolerance); AssertEx.EqualTolerance(ThermsEcInOneJoule, joule.As(EnergyUnit.ThermEc), ThermsEcTolerance); AssertEx.EqualTolerance(ThermsImperialInOneJoule, joule.As(EnergyUnit.ThermImperial), ThermsImperialTolerance); AssertEx.EqualTolerance(ThermsUsInOneJoule, joule.As(EnergyUnit.ThermUs), ThermsUsTolerance); + AssertEx.EqualTolerance(WattDaysInOneJoule, joule.As(EnergyUnit.WattDay), WattDaysTolerance); AssertEx.EqualTolerance(WattHoursInOneJoule, joule.As(EnergyUnit.WattHour), WattHoursTolerance); } @@ -414,6 +454,10 @@ public void ToUnit() AssertEx.EqualTolerance(GigajoulesInOneJoule, (double)gigajouleQuantity.Value, GigajoulesTolerance); Assert.Equal(EnergyUnit.Gigajoule, gigajouleQuantity.Unit); + var gigawattdayQuantity = joule.ToUnit(EnergyUnit.GigawattDay); + AssertEx.EqualTolerance(GigawattDaysInOneJoule, (double)gigawattdayQuantity.Value, GigawattDaysTolerance); + Assert.Equal(EnergyUnit.GigawattDay, gigawattdayQuantity.Unit); + var gigawatthourQuantity = joule.ToUnit(EnergyUnit.GigawattHour); AssertEx.EqualTolerance(GigawattHoursInOneJoule, (double)gigawatthourQuantity.Value, GigawattHoursTolerance); Assert.Equal(EnergyUnit.GigawattHour, gigawatthourQuantity.Unit); @@ -438,6 +482,10 @@ public void ToUnit() AssertEx.EqualTolerance(KilojoulesInOneJoule, (double)kilojouleQuantity.Value, KilojoulesTolerance); Assert.Equal(EnergyUnit.Kilojoule, kilojouleQuantity.Unit); + var kilowattdayQuantity = joule.ToUnit(EnergyUnit.KilowattDay); + AssertEx.EqualTolerance(KilowattDaysInOneJoule, (double)kilowattdayQuantity.Value, KilowattDaysTolerance); + Assert.Equal(EnergyUnit.KilowattDay, kilowattdayQuantity.Unit); + var kilowatthourQuantity = joule.ToUnit(EnergyUnit.KilowattHour); AssertEx.EqualTolerance(KilowattHoursInOneJoule, (double)kilowatthourQuantity.Value, KilowattHoursTolerance); Assert.Equal(EnergyUnit.KilowattHour, kilowatthourQuantity.Unit); @@ -458,6 +506,10 @@ public void ToUnit() AssertEx.EqualTolerance(MegajoulesInOneJoule, (double)megajouleQuantity.Value, MegajoulesTolerance); Assert.Equal(EnergyUnit.Megajoule, megajouleQuantity.Unit); + var megawattdayQuantity = joule.ToUnit(EnergyUnit.MegawattDay); + AssertEx.EqualTolerance(MegawattDaysInOneJoule, (double)megawattdayQuantity.Value, MegawattDaysTolerance); + Assert.Equal(EnergyUnit.MegawattDay, megawattdayQuantity.Unit); + var megawatthourQuantity = joule.ToUnit(EnergyUnit.MegawattHour); AssertEx.EqualTolerance(MegawattHoursInOneJoule, (double)megawatthourQuantity.Value, MegawattHoursTolerance); Assert.Equal(EnergyUnit.MegawattHour, megawatthourQuantity.Unit); @@ -470,6 +522,10 @@ public void ToUnit() AssertEx.EqualTolerance(TeraelectronVoltsInOneJoule, (double)teraelectronvoltQuantity.Value, TeraelectronVoltsTolerance); Assert.Equal(EnergyUnit.TeraelectronVolt, teraelectronvoltQuantity.Unit); + var terawattdayQuantity = joule.ToUnit(EnergyUnit.TerawattDay); + AssertEx.EqualTolerance(TerawattDaysInOneJoule, (double)terawattdayQuantity.Value, TerawattDaysTolerance); + Assert.Equal(EnergyUnit.TerawattDay, terawattdayQuantity.Unit); + var terawatthourQuantity = joule.ToUnit(EnergyUnit.TerawattHour); AssertEx.EqualTolerance(TerawattHoursInOneJoule, (double)terawatthourQuantity.Value, TerawattHoursTolerance); Assert.Equal(EnergyUnit.TerawattHour, terawatthourQuantity.Unit); @@ -486,6 +542,10 @@ public void ToUnit() AssertEx.EqualTolerance(ThermsUsInOneJoule, (double)thermusQuantity.Value, ThermsUsTolerance); Assert.Equal(EnergyUnit.ThermUs, thermusQuantity.Unit); + var wattdayQuantity = joule.ToUnit(EnergyUnit.WattDay); + AssertEx.EqualTolerance(WattDaysInOneJoule, (double)wattdayQuantity.Value, WattDaysTolerance); + Assert.Equal(EnergyUnit.WattDay, wattdayQuantity.Unit); + var watthourQuantity = joule.ToUnit(EnergyUnit.WattHour); AssertEx.EqualTolerance(WattHoursInOneJoule, (double)watthourQuantity.Value, WattHoursTolerance); Assert.Equal(EnergyUnit.WattHour, watthourQuantity.Unit); @@ -506,24 +566,29 @@ public void ConversionRoundTrip() AssertEx.EqualTolerance(1, Energy.FromGigabritishThermalUnits(joule.GigabritishThermalUnits).Joules, GigabritishThermalUnitsTolerance); AssertEx.EqualTolerance(1, Energy.FromGigaelectronVolts(joule.GigaelectronVolts).Joules, GigaelectronVoltsTolerance); AssertEx.EqualTolerance(1, Energy.FromGigajoules(joule.Gigajoules).Joules, GigajoulesTolerance); + AssertEx.EqualTolerance(1, Energy.FromGigawattDays(joule.GigawattDays).Joules, GigawattDaysTolerance); AssertEx.EqualTolerance(1, Energy.FromGigawattHours(joule.GigawattHours).Joules, GigawattHoursTolerance); AssertEx.EqualTolerance(1, Energy.FromJoules(joule.Joules).Joules, JoulesTolerance); AssertEx.EqualTolerance(1, Energy.FromKilobritishThermalUnits(joule.KilobritishThermalUnits).Joules, KilobritishThermalUnitsTolerance); AssertEx.EqualTolerance(1, Energy.FromKilocalories(joule.Kilocalories).Joules, KilocaloriesTolerance); AssertEx.EqualTolerance(1, Energy.FromKiloelectronVolts(joule.KiloelectronVolts).Joules, KiloelectronVoltsTolerance); AssertEx.EqualTolerance(1, Energy.FromKilojoules(joule.Kilojoules).Joules, KilojoulesTolerance); + AssertEx.EqualTolerance(1, Energy.FromKilowattDays(joule.KilowattDays).Joules, KilowattDaysTolerance); AssertEx.EqualTolerance(1, Energy.FromKilowattHours(joule.KilowattHours).Joules, KilowattHoursTolerance); AssertEx.EqualTolerance(1, Energy.FromMegabritishThermalUnits(joule.MegabritishThermalUnits).Joules, MegabritishThermalUnitsTolerance); AssertEx.EqualTolerance(1, Energy.FromMegacalories(joule.Megacalories).Joules, MegacaloriesTolerance); AssertEx.EqualTolerance(1, Energy.FromMegaelectronVolts(joule.MegaelectronVolts).Joules, MegaelectronVoltsTolerance); AssertEx.EqualTolerance(1, Energy.FromMegajoules(joule.Megajoules).Joules, MegajoulesTolerance); + AssertEx.EqualTolerance(1, Energy.FromMegawattDays(joule.MegawattDays).Joules, MegawattDaysTolerance); AssertEx.EqualTolerance(1, Energy.FromMegawattHours(joule.MegawattHours).Joules, MegawattHoursTolerance); AssertEx.EqualTolerance(1, Energy.FromMillijoules(joule.Millijoules).Joules, MillijoulesTolerance); AssertEx.EqualTolerance(1, Energy.FromTeraelectronVolts(joule.TeraelectronVolts).Joules, TeraelectronVoltsTolerance); + AssertEx.EqualTolerance(1, Energy.FromTerawattDays(joule.TerawattDays).Joules, TerawattDaysTolerance); AssertEx.EqualTolerance(1, Energy.FromTerawattHours(joule.TerawattHours).Joules, TerawattHoursTolerance); AssertEx.EqualTolerance(1, Energy.FromThermsEc(joule.ThermsEc).Joules, ThermsEcTolerance); AssertEx.EqualTolerance(1, Energy.FromThermsImperial(joule.ThermsImperial).Joules, ThermsImperialTolerance); AssertEx.EqualTolerance(1, Energy.FromThermsUs(joule.ThermsUs).Joules, ThermsUsTolerance); + AssertEx.EqualTolerance(1, Energy.FromWattDays(joule.WattDays).Joules, WattDaysTolerance); AssertEx.EqualTolerance(1, Energy.FromWattHours(joule.WattHours).Joules, WattHoursTolerance); } @@ -675,24 +740,29 @@ public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture() Assert.Equal("1 GBTU", new Energy(1, EnergyUnit.GigabritishThermalUnit).ToString()); Assert.Equal("1 GeV", new Energy(1, EnergyUnit.GigaelectronVolt).ToString()); Assert.Equal("1 GJ", new Energy(1, EnergyUnit.Gigajoule).ToString()); + Assert.Equal("1 GWd", new Energy(1, EnergyUnit.GigawattDay).ToString()); Assert.Equal("1 GWh", new Energy(1, EnergyUnit.GigawattHour).ToString()); Assert.Equal("1 J", new Energy(1, EnergyUnit.Joule).ToString()); Assert.Equal("1 kBTU", new Energy(1, EnergyUnit.KilobritishThermalUnit).ToString()); Assert.Equal("1 kcal", new Energy(1, EnergyUnit.Kilocalorie).ToString()); Assert.Equal("1 keV", new Energy(1, EnergyUnit.KiloelectronVolt).ToString()); Assert.Equal("1 kJ", new Energy(1, EnergyUnit.Kilojoule).ToString()); + Assert.Equal("1 kWd", new Energy(1, EnergyUnit.KilowattDay).ToString()); Assert.Equal("1 kWh", new Energy(1, EnergyUnit.KilowattHour).ToString()); Assert.Equal("1 MBTU", new Energy(1, EnergyUnit.MegabritishThermalUnit).ToString()); Assert.Equal("1 Mcal", new Energy(1, EnergyUnit.Megacalorie).ToString()); Assert.Equal("1 MeV", new Energy(1, EnergyUnit.MegaelectronVolt).ToString()); Assert.Equal("1 MJ", new Energy(1, EnergyUnit.Megajoule).ToString()); + Assert.Equal("1 MWd", new Energy(1, EnergyUnit.MegawattDay).ToString()); Assert.Equal("1 MWh", new Energy(1, EnergyUnit.MegawattHour).ToString()); Assert.Equal("1 mJ", new Energy(1, EnergyUnit.Millijoule).ToString()); Assert.Equal("1 TeV", new Energy(1, EnergyUnit.TeraelectronVolt).ToString()); + Assert.Equal("1 TWd", new Energy(1, EnergyUnit.TerawattDay).ToString()); Assert.Equal("1 TWh", new Energy(1, EnergyUnit.TerawattHour).ToString()); Assert.Equal("1 th (E.C.)", new Energy(1, EnergyUnit.ThermEc).ToString()); Assert.Equal("1 th (imp.)", new Energy(1, EnergyUnit.ThermImperial).ToString()); Assert.Equal("1 th (U.S.)", new Energy(1, EnergyUnit.ThermUs).ToString()); + Assert.Equal("1 Wd", new Energy(1, EnergyUnit.WattDay).ToString()); Assert.Equal("1 Wh", new Energy(1, EnergyUnit.WattHour).ToString()); } finally @@ -718,24 +788,29 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture Assert.Equal("1 GBTU", new Energy(1, EnergyUnit.GigabritishThermalUnit).ToString(swedishCulture)); Assert.Equal("1 GeV", new Energy(1, EnergyUnit.GigaelectronVolt).ToString(swedishCulture)); Assert.Equal("1 GJ", new Energy(1, EnergyUnit.Gigajoule).ToString(swedishCulture)); + Assert.Equal("1 GWd", new Energy(1, EnergyUnit.GigawattDay).ToString(swedishCulture)); Assert.Equal("1 GWh", new Energy(1, EnergyUnit.GigawattHour).ToString(swedishCulture)); Assert.Equal("1 J", new Energy(1, EnergyUnit.Joule).ToString(swedishCulture)); Assert.Equal("1 kBTU", new Energy(1, EnergyUnit.KilobritishThermalUnit).ToString(swedishCulture)); Assert.Equal("1 kcal", new Energy(1, EnergyUnit.Kilocalorie).ToString(swedishCulture)); Assert.Equal("1 keV", new Energy(1, EnergyUnit.KiloelectronVolt).ToString(swedishCulture)); Assert.Equal("1 kJ", new Energy(1, EnergyUnit.Kilojoule).ToString(swedishCulture)); + Assert.Equal("1 kWd", new Energy(1, EnergyUnit.KilowattDay).ToString(swedishCulture)); Assert.Equal("1 kWh", new Energy(1, EnergyUnit.KilowattHour).ToString(swedishCulture)); Assert.Equal("1 MBTU", new Energy(1, EnergyUnit.MegabritishThermalUnit).ToString(swedishCulture)); Assert.Equal("1 Mcal", new Energy(1, EnergyUnit.Megacalorie).ToString(swedishCulture)); Assert.Equal("1 MeV", new Energy(1, EnergyUnit.MegaelectronVolt).ToString(swedishCulture)); Assert.Equal("1 MJ", new Energy(1, EnergyUnit.Megajoule).ToString(swedishCulture)); + Assert.Equal("1 MWd", new Energy(1, EnergyUnit.MegawattDay).ToString(swedishCulture)); Assert.Equal("1 MWh", new Energy(1, EnergyUnit.MegawattHour).ToString(swedishCulture)); Assert.Equal("1 mJ", new Energy(1, EnergyUnit.Millijoule).ToString(swedishCulture)); Assert.Equal("1 TeV", new Energy(1, EnergyUnit.TeraelectronVolt).ToString(swedishCulture)); + Assert.Equal("1 TWd", new Energy(1, EnergyUnit.TerawattDay).ToString(swedishCulture)); Assert.Equal("1 TWh", new Energy(1, EnergyUnit.TerawattHour).ToString(swedishCulture)); Assert.Equal("1 th (E.C.)", new Energy(1, EnergyUnit.ThermEc).ToString(swedishCulture)); Assert.Equal("1 th (imp.)", new Energy(1, EnergyUnit.ThermImperial).ToString(swedishCulture)); Assert.Equal("1 th (U.S.)", new Energy(1, EnergyUnit.ThermUs).ToString(swedishCulture)); + Assert.Equal("1 Wd", new Energy(1, EnergyUnit.WattDay).ToString(swedishCulture)); Assert.Equal("1 Wh", new Energy(1, EnergyUnit.WattHour).ToString(swedishCulture)); } diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Energy.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Energy.g.cs index 4b88a7acf3..74769c1d26 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Energy.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Energy.g.cs @@ -210,6 +210,11 @@ private Energy(double value, EnergyUnit unit) /// public double Gigajoules => As(EnergyUnit.Gigajoule); + /// + /// Get Energy in GigawattDays. + /// + public double GigawattDays => As(EnergyUnit.GigawattDay); + /// /// Get Energy in GigawattHours. /// @@ -240,6 +245,11 @@ private Energy(double value, EnergyUnit unit) /// public double Kilojoules => As(EnergyUnit.Kilojoule); + /// + /// Get Energy in KilowattDays. + /// + public double KilowattDays => As(EnergyUnit.KilowattDay); + /// /// Get Energy in KilowattHours. /// @@ -265,6 +275,11 @@ private Energy(double value, EnergyUnit unit) /// public double Megajoules => As(EnergyUnit.Megajoule); + /// + /// Get Energy in MegawattDays. + /// + public double MegawattDays => As(EnergyUnit.MegawattDay); + /// /// Get Energy in MegawattHours. /// @@ -280,6 +295,11 @@ private Energy(double value, EnergyUnit unit) /// public double TeraelectronVolts => As(EnergyUnit.TeraelectronVolt); + /// + /// Get Energy in TerawattDays. + /// + public double TerawattDays => As(EnergyUnit.TerawattDay); + /// /// Get Energy in TerawattHours. /// @@ -300,6 +320,11 @@ private Energy(double value, EnergyUnit unit) /// public double ThermsUs => As(EnergyUnit.ThermUs); + /// + /// Get Energy in WattDays. + /// + public double WattDays => As(EnergyUnit.WattDay); + /// /// Get Energy in WattHours. /// @@ -446,6 +471,16 @@ public static Energy FromGigajoules(double gigajoules) return new Energy(value, EnergyUnit.Gigajoule); } /// + /// Get Energy from GigawattDays. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static Energy FromGigawattDays(double gigawattdays) + { + double value = (double) gigawattdays; + return new Energy(value, EnergyUnit.GigawattDay); + } + /// /// Get Energy from GigawattHours. /// /// If value is NaN or Infinity. @@ -506,6 +541,16 @@ public static Energy FromKilojoules(double kilojoules) return new Energy(value, EnergyUnit.Kilojoule); } /// + /// Get Energy from KilowattDays. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static Energy FromKilowattDays(double kilowattdays) + { + double value = (double) kilowattdays; + return new Energy(value, EnergyUnit.KilowattDay); + } + /// /// Get Energy from KilowattHours. /// /// If value is NaN or Infinity. @@ -556,6 +601,16 @@ public static Energy FromMegajoules(double megajoules) return new Energy(value, EnergyUnit.Megajoule); } /// + /// Get Energy from MegawattDays. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static Energy FromMegawattDays(double megawattdays) + { + double value = (double) megawattdays; + return new Energy(value, EnergyUnit.MegawattDay); + } + /// /// Get Energy from MegawattHours. /// /// If value is NaN or Infinity. @@ -586,6 +641,16 @@ public static Energy FromTeraelectronVolts(double teraelectronvolts) return new Energy(value, EnergyUnit.TeraelectronVolt); } /// + /// Get Energy from TerawattDays. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static Energy FromTerawattDays(double terawattdays) + { + double value = (double) terawattdays; + return new Energy(value, EnergyUnit.TerawattDay); + } + /// /// Get Energy from TerawattHours. /// /// If value is NaN or Infinity. @@ -626,6 +691,16 @@ public static Energy FromThermsUs(double thermsus) return new Energy(value, EnergyUnit.ThermUs); } /// + /// Get Energy from WattDays. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static Energy FromWattDays(double wattdays) + { + double value = (double) wattdays; + return new Energy(value, EnergyUnit.WattDay); + } + /// /// Get Energy from WattHours. /// /// If value is NaN or Infinity. @@ -937,24 +1012,29 @@ private double AsBaseUnit() case EnergyUnit.GigabritishThermalUnit: return (_value*1055.05585262) * 1e9d; case EnergyUnit.GigaelectronVolt: return (_value*1.602176565e-19) * 1e9d; case EnergyUnit.Gigajoule: return (_value) * 1e9d; + case EnergyUnit.GigawattDay: return (_value*24*3600d) * 1e9d; case EnergyUnit.GigawattHour: return (_value*3600d) * 1e9d; case EnergyUnit.Joule: return _value; case EnergyUnit.KilobritishThermalUnit: return (_value*1055.05585262) * 1e3d; case EnergyUnit.Kilocalorie: return (_value*4.184) * 1e3d; case EnergyUnit.KiloelectronVolt: return (_value*1.602176565e-19) * 1e3d; case EnergyUnit.Kilojoule: return (_value) * 1e3d; + case EnergyUnit.KilowattDay: return (_value*24*3600d) * 1e3d; case EnergyUnit.KilowattHour: return (_value*3600d) * 1e3d; case EnergyUnit.MegabritishThermalUnit: return (_value*1055.05585262) * 1e6d; case EnergyUnit.Megacalorie: return (_value*4.184) * 1e6d; case EnergyUnit.MegaelectronVolt: return (_value*1.602176565e-19) * 1e6d; case EnergyUnit.Megajoule: return (_value) * 1e6d; + case EnergyUnit.MegawattDay: return (_value*24*3600d) * 1e6d; case EnergyUnit.MegawattHour: return (_value*3600d) * 1e6d; case EnergyUnit.Millijoule: return (_value) * 1e-3d; case EnergyUnit.TeraelectronVolt: return (_value*1.602176565e-19) * 1e12d; + case EnergyUnit.TerawattDay: return (_value*24*3600d) * 1e12d; case EnergyUnit.TerawattHour: return (_value*3600d) * 1e12d; case EnergyUnit.ThermEc: return _value*1.05505585262e8; case EnergyUnit.ThermImperial: return _value*1.05505585257348e8; case EnergyUnit.ThermUs: return _value*1.054804e8; + case EnergyUnit.WattDay: return _value*24*3600d; case EnergyUnit.WattHour: return _value*3600d; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); @@ -981,24 +1061,29 @@ private double AsBaseNumericType(EnergyUnit unit) case EnergyUnit.GigabritishThermalUnit: return (baseUnitValue/1055.05585262) / 1e9d; case EnergyUnit.GigaelectronVolt: return (baseUnitValue/1.602176565e-19) / 1e9d; case EnergyUnit.Gigajoule: return (baseUnitValue) / 1e9d; + case EnergyUnit.GigawattDay: return (baseUnitValue/(24*3600d)) / 1e9d; case EnergyUnit.GigawattHour: return (baseUnitValue/3600d) / 1e9d; case EnergyUnit.Joule: return baseUnitValue; case EnergyUnit.KilobritishThermalUnit: return (baseUnitValue/1055.05585262) / 1e3d; case EnergyUnit.Kilocalorie: return (baseUnitValue/4.184) / 1e3d; case EnergyUnit.KiloelectronVolt: return (baseUnitValue/1.602176565e-19) / 1e3d; case EnergyUnit.Kilojoule: return (baseUnitValue) / 1e3d; + case EnergyUnit.KilowattDay: return (baseUnitValue/(24*3600d)) / 1e3d; case EnergyUnit.KilowattHour: return (baseUnitValue/3600d) / 1e3d; case EnergyUnit.MegabritishThermalUnit: return (baseUnitValue/1055.05585262) / 1e6d; case EnergyUnit.Megacalorie: return (baseUnitValue/4.184) / 1e6d; case EnergyUnit.MegaelectronVolt: return (baseUnitValue/1.602176565e-19) / 1e6d; case EnergyUnit.Megajoule: return (baseUnitValue) / 1e6d; + case EnergyUnit.MegawattDay: return (baseUnitValue/(24*3600d)) / 1e6d; case EnergyUnit.MegawattHour: return (baseUnitValue/3600d) / 1e6d; case EnergyUnit.Millijoule: return (baseUnitValue) / 1e-3d; case EnergyUnit.TeraelectronVolt: return (baseUnitValue/1.602176565e-19) / 1e12d; + case EnergyUnit.TerawattDay: return (baseUnitValue/(24*3600d)) / 1e12d; case EnergyUnit.TerawattHour: return (baseUnitValue/3600d) / 1e12d; case EnergyUnit.ThermEc: return baseUnitValue/1.05505585262e8; case EnergyUnit.ThermImperial: return baseUnitValue/1.05505585257348e8; case EnergyUnit.ThermUs: return baseUnitValue/1.054804e8; + case EnergyUnit.WattDay: return baseUnitValue/(24*3600d); case EnergyUnit.WattHour: return baseUnitValue/3600d; default: throw new NotImplementedException($"Can not convert {Unit} to {unit}."); diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs index 31b0279ea9..21f1e7723a 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs @@ -328,6 +328,8 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("en-US", typeof(EnergyUnit), (int)EnergyUnit.GigaelectronVolt, new string[]{"GeV"}), ("ru-RU", typeof(EnergyUnit), (int)EnergyUnit.GigaelectronVolt, new string[]{"ГэВ"}), ("en-US", typeof(EnergyUnit), (int)EnergyUnit.Gigajoule, new string[]{"GJ"}), + ("en-US", typeof(EnergyUnit), (int)EnergyUnit.GigawattDay, new string[]{"GWd"}), + ("ru-RU", typeof(EnergyUnit), (int)EnergyUnit.GigawattDay, new string[]{"ГВт/д"}), ("en-US", typeof(EnergyUnit), (int)EnergyUnit.GigawattHour, new string[]{"GWh"}), ("ru-RU", typeof(EnergyUnit), (int)EnergyUnit.GigawattHour, new string[]{"ГВт/ч"}), ("en-US", typeof(EnergyUnit), (int)EnergyUnit.Joule, new string[]{"J"}), @@ -336,6 +338,8 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("en-US", typeof(EnergyUnit), (int)EnergyUnit.KiloelectronVolt, new string[]{"keV"}), ("ru-RU", typeof(EnergyUnit), (int)EnergyUnit.KiloelectronVolt, new string[]{"кэВ"}), ("en-US", typeof(EnergyUnit), (int)EnergyUnit.Kilojoule, new string[]{"kJ"}), + ("en-US", typeof(EnergyUnit), (int)EnergyUnit.KilowattDay, new string[]{"kWd"}), + ("ru-RU", typeof(EnergyUnit), (int)EnergyUnit.KilowattDay, new string[]{"кВт/д"}), ("en-US", typeof(EnergyUnit), (int)EnergyUnit.KilowattHour, new string[]{"kWh"}), ("ru-RU", typeof(EnergyUnit), (int)EnergyUnit.KilowattHour, new string[]{"кВт/ч"}), ("en-US", typeof(EnergyUnit), (int)EnergyUnit.MegabritishThermalUnit, new string[]{"MBTU"}), @@ -343,11 +347,15 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("en-US", typeof(EnergyUnit), (int)EnergyUnit.MegaelectronVolt, new string[]{"MeV"}), ("ru-RU", typeof(EnergyUnit), (int)EnergyUnit.MegaelectronVolt, new string[]{"МэВ"}), ("en-US", typeof(EnergyUnit), (int)EnergyUnit.Megajoule, new string[]{"MJ"}), + ("en-US", typeof(EnergyUnit), (int)EnergyUnit.MegawattDay, new string[]{"MWd"}), + ("ru-RU", typeof(EnergyUnit), (int)EnergyUnit.MegawattDay, new string[]{"МВт/д"}), ("en-US", typeof(EnergyUnit), (int)EnergyUnit.MegawattHour, new string[]{"MWh"}), ("ru-RU", typeof(EnergyUnit), (int)EnergyUnit.MegawattHour, new string[]{"МВт/ч"}), ("en-US", typeof(EnergyUnit), (int)EnergyUnit.Millijoule, new string[]{"mJ"}), ("en-US", typeof(EnergyUnit), (int)EnergyUnit.TeraelectronVolt, new string[]{"TeV"}), ("ru-RU", typeof(EnergyUnit), (int)EnergyUnit.TeraelectronVolt, new string[]{"ТэВ"}), + ("en-US", typeof(EnergyUnit), (int)EnergyUnit.TerawattDay, new string[]{"TWd"}), + ("ru-RU", typeof(EnergyUnit), (int)EnergyUnit.TerawattDay, new string[]{"ТВт/д"}), ("en-US", typeof(EnergyUnit), (int)EnergyUnit.TerawattHour, new string[]{"TWh"}), ("ru-RU", typeof(EnergyUnit), (int)EnergyUnit.TerawattHour, new string[]{"ТВт/ч"}), ("en-US", typeof(EnergyUnit), (int)EnergyUnit.ThermEc, new string[]{"th (E.C.)"}), @@ -356,6 +364,8 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("ru-RU", typeof(EnergyUnit), (int)EnergyUnit.ThermImperial, new string[]{"Английский терм"}), ("en-US", typeof(EnergyUnit), (int)EnergyUnit.ThermUs, new string[]{"th (U.S.)"}), ("ru-RU", typeof(EnergyUnit), (int)EnergyUnit.ThermUs, new string[]{"Американский терм"}), + ("en-US", typeof(EnergyUnit), (int)EnergyUnit.WattDay, new string[]{"Wd"}), + ("ru-RU", typeof(EnergyUnit), (int)EnergyUnit.WattDay, new string[]{"Вт/д"}), ("en-US", typeof(EnergyUnit), (int)EnergyUnit.WattHour, new string[]{"Wh"}), ("ru-RU", typeof(EnergyUnit), (int)EnergyUnit.WattHour, new string[]{"Вт/ч"}), ("en-US", typeof(EntropyUnit), (int)EntropyUnit.CaloriePerKelvin, new string[]{"cal/K"}), diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/EnergyUnit.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/EnergyUnit.g.cs index a8373d564c..e9c7517e1c 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/EnergyUnit.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/EnergyUnit.g.cs @@ -37,24 +37,29 @@ public enum EnergyUnit GigabritishThermalUnit, GigaelectronVolt, Gigajoule, + GigawattDay, GigawattHour, Joule, KilobritishThermalUnit, Kilocalorie, KiloelectronVolt, Kilojoule, + KilowattDay, KilowattHour, MegabritishThermalUnit, Megacalorie, MegaelectronVolt, Megajoule, + MegawattDay, MegawattHour, Millijoule, TeraelectronVolt, + TerawattDay, TerawattHour, ThermEc, ThermImperial, ThermUs, + WattDay, WattHour, } diff --git a/UnitsNet/GeneratedCode/Quantities/Energy.g.cs b/UnitsNet/GeneratedCode/Quantities/Energy.g.cs index 509f64780b..9977662665 100644 --- a/UnitsNet/GeneratedCode/Quantities/Energy.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Energy.g.cs @@ -61,24 +61,29 @@ static Energy() new UnitInfo(EnergyUnit.GigabritishThermalUnit, BaseUnits.Undefined), new UnitInfo(EnergyUnit.GigaelectronVolt, BaseUnits.Undefined), new UnitInfo(EnergyUnit.Gigajoule, BaseUnits.Undefined), + new UnitInfo(EnergyUnit.GigawattDay, BaseUnits.Undefined), new UnitInfo(EnergyUnit.GigawattHour, BaseUnits.Undefined), new UnitInfo(EnergyUnit.Joule, new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second)), new UnitInfo(EnergyUnit.KilobritishThermalUnit, BaseUnits.Undefined), new UnitInfo(EnergyUnit.Kilocalorie, BaseUnits.Undefined), new UnitInfo(EnergyUnit.KiloelectronVolt, BaseUnits.Undefined), new UnitInfo(EnergyUnit.Kilojoule, BaseUnits.Undefined), + new UnitInfo(EnergyUnit.KilowattDay, BaseUnits.Undefined), new UnitInfo(EnergyUnit.KilowattHour, BaseUnits.Undefined), new UnitInfo(EnergyUnit.MegabritishThermalUnit, BaseUnits.Undefined), new UnitInfo(EnergyUnit.Megacalorie, BaseUnits.Undefined), new UnitInfo(EnergyUnit.MegaelectronVolt, BaseUnits.Undefined), new UnitInfo(EnergyUnit.Megajoule, BaseUnits.Undefined), + new UnitInfo(EnergyUnit.MegawattDay, BaseUnits.Undefined), new UnitInfo(EnergyUnit.MegawattHour, BaseUnits.Undefined), new UnitInfo(EnergyUnit.Millijoule, BaseUnits.Undefined), new UnitInfo(EnergyUnit.TeraelectronVolt, BaseUnits.Undefined), + new UnitInfo(EnergyUnit.TerawattDay, BaseUnits.Undefined), new UnitInfo(EnergyUnit.TerawattHour, BaseUnits.Undefined), new UnitInfo(EnergyUnit.ThermEc, BaseUnits.Undefined), new UnitInfo(EnergyUnit.ThermImperial, BaseUnits.Undefined), new UnitInfo(EnergyUnit.ThermUs, BaseUnits.Undefined), + new UnitInfo(EnergyUnit.WattDay, BaseUnits.Undefined), new UnitInfo(EnergyUnit.WattHour, BaseUnits.Undefined), }, BaseUnit, Zero, BaseDimensions); @@ -247,6 +252,11 @@ public Energy(double value, UnitSystem unitSystem) /// public double Gigajoules => As(EnergyUnit.Gigajoule); + /// + /// Get Energy in GigawattDays. + /// + public double GigawattDays => As(EnergyUnit.GigawattDay); + /// /// Get Energy in GigawattHours. /// @@ -277,6 +287,11 @@ public Energy(double value, UnitSystem unitSystem) /// public double Kilojoules => As(EnergyUnit.Kilojoule); + /// + /// Get Energy in KilowattDays. + /// + public double KilowattDays => As(EnergyUnit.KilowattDay); + /// /// Get Energy in KilowattHours. /// @@ -302,6 +317,11 @@ public Energy(double value, UnitSystem unitSystem) /// public double Megajoules => As(EnergyUnit.Megajoule); + /// + /// Get Energy in MegawattDays. + /// + public double MegawattDays => As(EnergyUnit.MegawattDay); + /// /// Get Energy in MegawattHours. /// @@ -317,6 +337,11 @@ public Energy(double value, UnitSystem unitSystem) /// public double TeraelectronVolts => As(EnergyUnit.TeraelectronVolt); + /// + /// Get Energy in TerawattDays. + /// + public double TerawattDays => As(EnergyUnit.TerawattDay); + /// /// Get Energy in TerawattHours. /// @@ -337,6 +362,11 @@ public Energy(double value, UnitSystem unitSystem) /// public double ThermsUs => As(EnergyUnit.ThermUs); + /// + /// Get Energy in WattDays. + /// + public double WattDays => As(EnergyUnit.WattDay); + /// /// Get Energy in WattHours. /// @@ -471,6 +501,15 @@ public static Energy FromGigajoules(QuantityValue gigajoules) return new Energy(value, EnergyUnit.Gigajoule); } /// + /// Get Energy from GigawattDays. + /// + /// If value is NaN or Infinity. + public static Energy FromGigawattDays(QuantityValue gigawattdays) + { + double value = (double) gigawattdays; + return new Energy(value, EnergyUnit.GigawattDay); + } + /// /// Get Energy from GigawattHours. /// /// If value is NaN or Infinity. @@ -525,6 +564,15 @@ public static Energy FromKilojoules(QuantityValue kilojoules) return new Energy(value, EnergyUnit.Kilojoule); } /// + /// Get Energy from KilowattDays. + /// + /// If value is NaN or Infinity. + public static Energy FromKilowattDays(QuantityValue kilowattdays) + { + double value = (double) kilowattdays; + return new Energy(value, EnergyUnit.KilowattDay); + } + /// /// Get Energy from KilowattHours. /// /// If value is NaN or Infinity. @@ -570,6 +618,15 @@ public static Energy FromMegajoules(QuantityValue megajoules) return new Energy(value, EnergyUnit.Megajoule); } /// + /// Get Energy from MegawattDays. + /// + /// If value is NaN or Infinity. + public static Energy FromMegawattDays(QuantityValue megawattdays) + { + double value = (double) megawattdays; + return new Energy(value, EnergyUnit.MegawattDay); + } + /// /// Get Energy from MegawattHours. /// /// If value is NaN or Infinity. @@ -597,6 +654,15 @@ public static Energy FromTeraelectronVolts(QuantityValue teraelectronvolts) return new Energy(value, EnergyUnit.TeraelectronVolt); } /// + /// Get Energy from TerawattDays. + /// + /// If value is NaN or Infinity. + public static Energy FromTerawattDays(QuantityValue terawattdays) + { + double value = (double) terawattdays; + return new Energy(value, EnergyUnit.TerawattDay); + } + /// /// Get Energy from TerawattHours. /// /// If value is NaN or Infinity. @@ -633,6 +699,15 @@ public static Energy FromThermsUs(QuantityValue thermsus) return new Energy(value, EnergyUnit.ThermUs); } /// + /// Get Energy from WattDays. + /// + /// If value is NaN or Infinity. + public static Energy FromWattDays(QuantityValue wattdays) + { + double value = (double) wattdays; + return new Energy(value, EnergyUnit.WattDay); + } + /// /// Get Energy from WattHours. /// /// If value is NaN or Infinity. @@ -1081,24 +1156,29 @@ private double GetValueInBaseUnit() case EnergyUnit.GigabritishThermalUnit: return (_value*1055.05585262) * 1e9d; case EnergyUnit.GigaelectronVolt: return (_value*1.602176565e-19) * 1e9d; case EnergyUnit.Gigajoule: return (_value) * 1e9d; + case EnergyUnit.GigawattDay: return (_value*24*3600d) * 1e9d; case EnergyUnit.GigawattHour: return (_value*3600d) * 1e9d; case EnergyUnit.Joule: return _value; case EnergyUnit.KilobritishThermalUnit: return (_value*1055.05585262) * 1e3d; case EnergyUnit.Kilocalorie: return (_value*4.184) * 1e3d; case EnergyUnit.KiloelectronVolt: return (_value*1.602176565e-19) * 1e3d; case EnergyUnit.Kilojoule: return (_value) * 1e3d; + case EnergyUnit.KilowattDay: return (_value*24*3600d) * 1e3d; case EnergyUnit.KilowattHour: return (_value*3600d) * 1e3d; case EnergyUnit.MegabritishThermalUnit: return (_value*1055.05585262) * 1e6d; case EnergyUnit.Megacalorie: return (_value*4.184) * 1e6d; case EnergyUnit.MegaelectronVolt: return (_value*1.602176565e-19) * 1e6d; case EnergyUnit.Megajoule: return (_value) * 1e6d; + case EnergyUnit.MegawattDay: return (_value*24*3600d) * 1e6d; case EnergyUnit.MegawattHour: return (_value*3600d) * 1e6d; case EnergyUnit.Millijoule: return (_value) * 1e-3d; case EnergyUnit.TeraelectronVolt: return (_value*1.602176565e-19) * 1e12d; + case EnergyUnit.TerawattDay: return (_value*24*3600d) * 1e12d; case EnergyUnit.TerawattHour: return (_value*3600d) * 1e12d; case EnergyUnit.ThermEc: return _value*1.05505585262e8; case EnergyUnit.ThermImperial: return _value*1.05505585257348e8; case EnergyUnit.ThermUs: return _value*1.054804e8; + case EnergyUnit.WattDay: return _value*24*3600d; case EnergyUnit.WattHour: return _value*3600d; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); @@ -1136,24 +1216,29 @@ private double GetValueAs(EnergyUnit unit) case EnergyUnit.GigabritishThermalUnit: return (baseUnitValue/1055.05585262) / 1e9d; case EnergyUnit.GigaelectronVolt: return (baseUnitValue/1.602176565e-19) / 1e9d; case EnergyUnit.Gigajoule: return (baseUnitValue) / 1e9d; + case EnergyUnit.GigawattDay: return (baseUnitValue/(24*3600d)) / 1e9d; case EnergyUnit.GigawattHour: return (baseUnitValue/3600d) / 1e9d; case EnergyUnit.Joule: return baseUnitValue; case EnergyUnit.KilobritishThermalUnit: return (baseUnitValue/1055.05585262) / 1e3d; case EnergyUnit.Kilocalorie: return (baseUnitValue/4.184) / 1e3d; case EnergyUnit.KiloelectronVolt: return (baseUnitValue/1.602176565e-19) / 1e3d; case EnergyUnit.Kilojoule: return (baseUnitValue) / 1e3d; + case EnergyUnit.KilowattDay: return (baseUnitValue/(24*3600d)) / 1e3d; case EnergyUnit.KilowattHour: return (baseUnitValue/3600d) / 1e3d; case EnergyUnit.MegabritishThermalUnit: return (baseUnitValue/1055.05585262) / 1e6d; case EnergyUnit.Megacalorie: return (baseUnitValue/4.184) / 1e6d; case EnergyUnit.MegaelectronVolt: return (baseUnitValue/1.602176565e-19) / 1e6d; case EnergyUnit.Megajoule: return (baseUnitValue) / 1e6d; + case EnergyUnit.MegawattDay: return (baseUnitValue/(24*3600d)) / 1e6d; case EnergyUnit.MegawattHour: return (baseUnitValue/3600d) / 1e6d; case EnergyUnit.Millijoule: return (baseUnitValue) / 1e-3d; case EnergyUnit.TeraelectronVolt: return (baseUnitValue/1.602176565e-19) / 1e12d; + case EnergyUnit.TerawattDay: return (baseUnitValue/(24*3600d)) / 1e12d; case EnergyUnit.TerawattHour: return (baseUnitValue/3600d) / 1e12d; case EnergyUnit.ThermEc: return baseUnitValue/1.05505585262e8; case EnergyUnit.ThermImperial: return baseUnitValue/1.05505585257348e8; case EnergyUnit.ThermUs: return baseUnitValue/1.054804e8; + case EnergyUnit.WattDay: return baseUnitValue/(24*3600d); case EnergyUnit.WattHour: return baseUnitValue/3600d; default: throw new NotImplementedException($"Can not convert {Unit} to {unit}."); diff --git a/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs b/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs index d17aba49a4..557170cff6 100644 --- a/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs +++ b/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs @@ -328,6 +328,8 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("en-US", typeof(EnergyUnit), (int)EnergyUnit.GigaelectronVolt, new string[]{"GeV"}), ("ru-RU", typeof(EnergyUnit), (int)EnergyUnit.GigaelectronVolt, new string[]{"ГэВ"}), ("en-US", typeof(EnergyUnit), (int)EnergyUnit.Gigajoule, new string[]{"GJ"}), + ("en-US", typeof(EnergyUnit), (int)EnergyUnit.GigawattDay, new string[]{"GWd"}), + ("ru-RU", typeof(EnergyUnit), (int)EnergyUnit.GigawattDay, new string[]{"ГВт/д"}), ("en-US", typeof(EnergyUnit), (int)EnergyUnit.GigawattHour, new string[]{"GWh"}), ("ru-RU", typeof(EnergyUnit), (int)EnergyUnit.GigawattHour, new string[]{"ГВт/ч"}), ("en-US", typeof(EnergyUnit), (int)EnergyUnit.Joule, new string[]{"J"}), @@ -336,6 +338,8 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("en-US", typeof(EnergyUnit), (int)EnergyUnit.KiloelectronVolt, new string[]{"keV"}), ("ru-RU", typeof(EnergyUnit), (int)EnergyUnit.KiloelectronVolt, new string[]{"кэВ"}), ("en-US", typeof(EnergyUnit), (int)EnergyUnit.Kilojoule, new string[]{"kJ"}), + ("en-US", typeof(EnergyUnit), (int)EnergyUnit.KilowattDay, new string[]{"kWd"}), + ("ru-RU", typeof(EnergyUnit), (int)EnergyUnit.KilowattDay, new string[]{"кВт/д"}), ("en-US", typeof(EnergyUnit), (int)EnergyUnit.KilowattHour, new string[]{"kWh"}), ("ru-RU", typeof(EnergyUnit), (int)EnergyUnit.KilowattHour, new string[]{"кВт/ч"}), ("en-US", typeof(EnergyUnit), (int)EnergyUnit.MegabritishThermalUnit, new string[]{"MBTU"}), @@ -343,11 +347,15 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("en-US", typeof(EnergyUnit), (int)EnergyUnit.MegaelectronVolt, new string[]{"MeV"}), ("ru-RU", typeof(EnergyUnit), (int)EnergyUnit.MegaelectronVolt, new string[]{"МэВ"}), ("en-US", typeof(EnergyUnit), (int)EnergyUnit.Megajoule, new string[]{"MJ"}), + ("en-US", typeof(EnergyUnit), (int)EnergyUnit.MegawattDay, new string[]{"MWd"}), + ("ru-RU", typeof(EnergyUnit), (int)EnergyUnit.MegawattDay, new string[]{"МВт/д"}), ("en-US", typeof(EnergyUnit), (int)EnergyUnit.MegawattHour, new string[]{"MWh"}), ("ru-RU", typeof(EnergyUnit), (int)EnergyUnit.MegawattHour, new string[]{"МВт/ч"}), ("en-US", typeof(EnergyUnit), (int)EnergyUnit.Millijoule, new string[]{"mJ"}), ("en-US", typeof(EnergyUnit), (int)EnergyUnit.TeraelectronVolt, new string[]{"TeV"}), ("ru-RU", typeof(EnergyUnit), (int)EnergyUnit.TeraelectronVolt, new string[]{"ТэВ"}), + ("en-US", typeof(EnergyUnit), (int)EnergyUnit.TerawattDay, new string[]{"TWd"}), + ("ru-RU", typeof(EnergyUnit), (int)EnergyUnit.TerawattDay, new string[]{"ТВт/д"}), ("en-US", typeof(EnergyUnit), (int)EnergyUnit.TerawattHour, new string[]{"TWh"}), ("ru-RU", typeof(EnergyUnit), (int)EnergyUnit.TerawattHour, new string[]{"ТВт/ч"}), ("en-US", typeof(EnergyUnit), (int)EnergyUnit.ThermEc, new string[]{"th (E.C.)"}), @@ -356,6 +364,8 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("ru-RU", typeof(EnergyUnit), (int)EnergyUnit.ThermImperial, new string[]{"Английский терм"}), ("en-US", typeof(EnergyUnit), (int)EnergyUnit.ThermUs, new string[]{"th (U.S.)"}), ("ru-RU", typeof(EnergyUnit), (int)EnergyUnit.ThermUs, new string[]{"Американский терм"}), + ("en-US", typeof(EnergyUnit), (int)EnergyUnit.WattDay, new string[]{"Wd"}), + ("ru-RU", typeof(EnergyUnit), (int)EnergyUnit.WattDay, new string[]{"Вт/д"}), ("en-US", typeof(EnergyUnit), (int)EnergyUnit.WattHour, new string[]{"Wh"}), ("ru-RU", typeof(EnergyUnit), (int)EnergyUnit.WattHour, new string[]{"Вт/ч"}), ("en-US", typeof(EntropyUnit), (int)EntropyUnit.CaloriePerKelvin, new string[]{"cal/K"}), diff --git a/UnitsNet/GeneratedCode/UnitConverter.g.cs b/UnitsNet/GeneratedCode/UnitConverter.g.cs index 7fbe57cfd0..02c2dd459a 100644 --- a/UnitsNet/GeneratedCode/UnitConverter.g.cs +++ b/UnitsNet/GeneratedCode/UnitConverter.g.cs @@ -506,6 +506,8 @@ public static void RegisterDefaultConversions(UnitConverter unitConverter) unitConverter.SetConversionFunction(EnergyUnit.GigaelectronVolt, Energy.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.Gigajoule, q => q.ToUnit(EnergyUnit.Gigajoule)); unitConverter.SetConversionFunction(EnergyUnit.Gigajoule, Energy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.GigawattDay, q => q.ToUnit(EnergyUnit.GigawattDay)); + unitConverter.SetConversionFunction(EnergyUnit.GigawattDay, Energy.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.GigawattHour, q => q.ToUnit(EnergyUnit.GigawattHour)); unitConverter.SetConversionFunction(EnergyUnit.GigawattHour, Energy.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, Energy.BaseUnit, q => q); @@ -517,6 +519,8 @@ public static void RegisterDefaultConversions(UnitConverter unitConverter) unitConverter.SetConversionFunction(EnergyUnit.KiloelectronVolt, Energy.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.Kilojoule, q => q.ToUnit(EnergyUnit.Kilojoule)); unitConverter.SetConversionFunction(EnergyUnit.Kilojoule, Energy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.KilowattDay, q => q.ToUnit(EnergyUnit.KilowattDay)); + unitConverter.SetConversionFunction(EnergyUnit.KilowattDay, Energy.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.KilowattHour, q => q.ToUnit(EnergyUnit.KilowattHour)); unitConverter.SetConversionFunction(EnergyUnit.KilowattHour, Energy.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.MegabritishThermalUnit, q => q.ToUnit(EnergyUnit.MegabritishThermalUnit)); @@ -527,12 +531,16 @@ public static void RegisterDefaultConversions(UnitConverter unitConverter) unitConverter.SetConversionFunction(EnergyUnit.MegaelectronVolt, Energy.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.Megajoule, q => q.ToUnit(EnergyUnit.Megajoule)); unitConverter.SetConversionFunction(EnergyUnit.Megajoule, Energy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.MegawattDay, q => q.ToUnit(EnergyUnit.MegawattDay)); + unitConverter.SetConversionFunction(EnergyUnit.MegawattDay, Energy.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.MegawattHour, q => q.ToUnit(EnergyUnit.MegawattHour)); unitConverter.SetConversionFunction(EnergyUnit.MegawattHour, Energy.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.Millijoule, q => q.ToUnit(EnergyUnit.Millijoule)); unitConverter.SetConversionFunction(EnergyUnit.Millijoule, Energy.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.TeraelectronVolt, q => q.ToUnit(EnergyUnit.TeraelectronVolt)); unitConverter.SetConversionFunction(EnergyUnit.TeraelectronVolt, Energy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.TerawattDay, q => q.ToUnit(EnergyUnit.TerawattDay)); + unitConverter.SetConversionFunction(EnergyUnit.TerawattDay, Energy.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.TerawattHour, q => q.ToUnit(EnergyUnit.TerawattHour)); unitConverter.SetConversionFunction(EnergyUnit.TerawattHour, Energy.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.ThermEc, q => q.ToUnit(EnergyUnit.ThermEc)); @@ -541,6 +549,8 @@ public static void RegisterDefaultConversions(UnitConverter unitConverter) unitConverter.SetConversionFunction(EnergyUnit.ThermImperial, Energy.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.ThermUs, q => q.ToUnit(EnergyUnit.ThermUs)); unitConverter.SetConversionFunction(EnergyUnit.ThermUs, Energy.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.WattDay, q => q.ToUnit(EnergyUnit.WattDay)); + unitConverter.SetConversionFunction(EnergyUnit.WattDay, Energy.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Energy.BaseUnit, EnergyUnit.WattHour, q => q.ToUnit(EnergyUnit.WattHour)); unitConverter.SetConversionFunction(EnergyUnit.WattHour, Energy.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Entropy.BaseUnit, EntropyUnit.CaloriePerKelvin, q => q.ToUnit(EntropyUnit.CaloriePerKelvin)); diff --git a/UnitsNet/GeneratedCode/Units/EnergyUnit.g.cs b/UnitsNet/GeneratedCode/Units/EnergyUnit.g.cs index a8373d564c..e9c7517e1c 100644 --- a/UnitsNet/GeneratedCode/Units/EnergyUnit.g.cs +++ b/UnitsNet/GeneratedCode/Units/EnergyUnit.g.cs @@ -37,24 +37,29 @@ public enum EnergyUnit GigabritishThermalUnit, GigaelectronVolt, Gigajoule, + GigawattDay, GigawattHour, Joule, KilobritishThermalUnit, Kilocalorie, KiloelectronVolt, Kilojoule, + KilowattDay, KilowattHour, MegabritishThermalUnit, Megacalorie, MegaelectronVolt, Megajoule, + MegawattDay, MegawattHour, Millijoule, TeraelectronVolt, + TerawattDay, TerawattHour, ThermEc, ThermImperial, ThermUs, + WattDay, WattHour, } From cfca9c1652e3f91816a5c12a9b757f53ed760d0c Mon Sep 17 00:00:00 2001 From: trb5016 Date: Sat, 22 Feb 2020 00:28:21 -0500 Subject: [PATCH 2/3] Added "ST" as an abbreviation for short ton (common in nuclear industry to distinguish from metric tons) --- Common/UnitDefinitions/Mass.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Common/UnitDefinitions/Mass.json b/Common/UnitDefinitions/Mass.json index 51b8ea513d..40286053a2 100644 --- a/Common/UnitDefinitions/Mass.json +++ b/Common/UnitDefinitions/Mass.json @@ -59,7 +59,7 @@ "Localization": [ { "Culture": "en-US", - "Abbreviations": [ "short tn" ] + "Abbreviations": [ "short tn", "ST" ] }, { "Culture": "ru-RU", From eb5882e2969da13dd3f33dc14a5aa99f83117273 Mon Sep 17 00:00:00 2001 From: Andreas Gullberg Larsen Date: Sat, 22 Feb 2020 16:17:45 +0100 Subject: [PATCH 3/3] Regen code --- .../GeneratedCode/UnitAbbreviationsCache.g.cs | 2 +- UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs index 21f1e7723a..b99a316351 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs @@ -639,7 +639,7 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("en-US", typeof(MassUnit), (int)MassUnit.Pound, new string[]{"lb", "lbs", "lbm"}), ("ru-RU", typeof(MassUnit), (int)MassUnit.Pound, new string[]{"фунт"}), ("en-US", typeof(MassUnit), (int)MassUnit.ShortHundredweight, new string[]{"cwt"}), - ("en-US", typeof(MassUnit), (int)MassUnit.ShortTon, new string[]{"short tn"}), + ("en-US", typeof(MassUnit), (int)MassUnit.ShortTon, new string[]{"short tn", "ST"}), ("ru-RU", typeof(MassUnit), (int)MassUnit.ShortTon, new string[]{"тонна малая"}), ("en-US", typeof(MassUnit), (int)MassUnit.Slug, new string[]{"slug"}), ("en-US", typeof(MassUnit), (int)MassUnit.SolarMass, new string[]{"M⊙"}), diff --git a/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs b/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs index 557170cff6..8925d5549c 100644 --- a/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs +++ b/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs @@ -639,7 +639,7 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("en-US", typeof(MassUnit), (int)MassUnit.Pound, new string[]{"lb", "lbs", "lbm"}), ("ru-RU", typeof(MassUnit), (int)MassUnit.Pound, new string[]{"фунт"}), ("en-US", typeof(MassUnit), (int)MassUnit.ShortHundredweight, new string[]{"cwt"}), - ("en-US", typeof(MassUnit), (int)MassUnit.ShortTon, new string[]{"short tn"}), + ("en-US", typeof(MassUnit), (int)MassUnit.ShortTon, new string[]{"short tn", "ST"}), ("ru-RU", typeof(MassUnit), (int)MassUnit.ShortTon, new string[]{"тонна малая"}), ("en-US", typeof(MassUnit), (int)MassUnit.Slug, new string[]{"slug"}), ("en-US", typeof(MassUnit), (int)MassUnit.SolarMass, new string[]{"M⊙"}),