diff --git a/Common/UnitDefinitions/Volume.json b/Common/UnitDefinitions/Volume.json index d2e87ac4b2..f1d933dbe9 100644 --- a/Common/UnitDefinitions/Volume.json +++ b/Common/UnitDefinitions/Volume.json @@ -242,7 +242,7 @@ "PluralName": "UsGallons", "FromUnitToBaseFunc": "x*0.00378541", "FromBaseToUnitFunc": "x/0.00378541", - "Prefixes": [ "Kilo", "Mega" ], + "Prefixes": [ "Deca", "Deci", "Hecto", "Kilo", "Mega" ], "Localization": [ { "Culture": "en-US", diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeExtensionsTest.g.cs index 7db2fa9c11..9086c1d7f9 100644 --- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeExtensionsTest.g.cs +++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeExtensionsTest.g.cs @@ -80,10 +80,18 @@ public void NumberToCubicMillimetersTest() => public void NumberToCubicYardsTest() => Assert.Equal(Volume.FromCubicYards(2), 2.CubicYards()); + [Fact] + public void NumberToDecausGallonsTest() => + Assert.Equal(Volume.FromDecausGallons(2), 2.DecausGallons()); + [Fact] public void NumberToDecilitersTest() => Assert.Equal(Volume.FromDeciliters(2), 2.Deciliters()); + [Fact] + public void NumberToDeciusGallonsTest() => + Assert.Equal(Volume.FromDeciusGallons(2), 2.DeciusGallons()); + [Fact] public void NumberToHectocubicFeetTest() => Assert.Equal(Volume.FromHectocubicFeet(2), 2.HectocubicFeet()); @@ -96,6 +104,10 @@ public void NumberToHectocubicMetersTest() => public void NumberToHectolitersTest() => Assert.Equal(Volume.FromHectoliters(2), 2.Hectoliters()); + [Fact] + public void NumberToHectousGallonsTest() => + Assert.Equal(Volume.FromHectousGallons(2), 2.HectousGallons()); + [Fact] public void NumberToImperialBeerBarrelsTest() => Assert.Equal(Volume.FromImperialBeerBarrels(2), 2.ImperialBeerBarrels()); diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeExtensions.g.cs index b037633869..2fc02fa339 100644 --- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeExtensions.g.cs +++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeExtensions.g.cs @@ -82,10 +82,18 @@ public static Volume CubicMillimeters(this T value) => public static Volume CubicYards(this T value) => Volume.FromCubicYards(Convert.ToDouble(value)); + /// + public static Volume DecausGallons(this T value) => + Volume.FromDecausGallons(Convert.ToDouble(value)); + /// public static Volume Deciliters(this T value) => Volume.FromDeciliters(Convert.ToDouble(value)); + /// + public static Volume DeciusGallons(this T value) => + Volume.FromDeciusGallons(Convert.ToDouble(value)); + /// public static Volume HectocubicFeet(this T value) => Volume.FromHectocubicFeet(Convert.ToDouble(value)); @@ -98,6 +106,10 @@ public static Volume HectocubicMeters(this T value) => public static Volume Hectoliters(this T value) => Volume.FromHectoliters(Convert.ToDouble(value)); + /// + public static Volume HectousGallons(this T value) => + Volume.FromHectousGallons(Convert.ToDouble(value)); + /// public static Volume ImperialBeerBarrels(this T value) => Volume.FromImperialBeerBarrels(Convert.ToDouble(value)); diff --git a/UnitsNet.Tests/CustomCode/VolumeTests.cs b/UnitsNet.Tests/CustomCode/VolumeTests.cs index ad6c2dca04..41720c53d4 100644 --- a/UnitsNet.Tests/CustomCode/VolumeTests.cs +++ b/UnitsNet.Tests/CustomCode/VolumeTests.cs @@ -32,12 +32,17 @@ public class VolumeTests : VolumeTestsBase protected override double CubicYardsInOneCubicMeter => 1.30795062; + protected override double DecausGallonsInOneCubicMeter => 2.6417217e+1; + protected override double DecilitersInOneCubicMeter => 1E4; + protected override double DeciusGallonsInOneCubicMeter => 2.6417217e+3; protected override double HectocubicFeetInOneCubicMeter => 3.531472e-1; protected override double HectocubicMetersInOneCubicMeter => 0.01; protected override double HectolitersInOneCubicMeter => 1E1; + protected override double HectousGallonsInOneCubicMeter => 2.6417217; + protected override double ImperialGallonsInOneCubicMeter => 219.96924; protected override double ImperialOuncesInOneCubicMeter => 35195.07972; diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeTestsBase.g.cs index 9cf267017e..171d19ac38 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeTestsBase.g.cs @@ -50,10 +50,13 @@ public abstract partial class VolumeTestsBase protected abstract double CubicMilesInOneCubicMeter { get; } protected abstract double CubicMillimetersInOneCubicMeter { get; } protected abstract double CubicYardsInOneCubicMeter { get; } + protected abstract double DecausGallonsInOneCubicMeter { get; } protected abstract double DecilitersInOneCubicMeter { get; } + protected abstract double DeciusGallonsInOneCubicMeter { get; } protected abstract double HectocubicFeetInOneCubicMeter { get; } protected abstract double HectocubicMetersInOneCubicMeter { get; } protected abstract double HectolitersInOneCubicMeter { get; } + protected abstract double HectousGallonsInOneCubicMeter { get; } protected abstract double ImperialBeerBarrelsInOneCubicMeter { get; } protected abstract double ImperialGallonsInOneCubicMeter { get; } protected abstract double ImperialOuncesInOneCubicMeter { get; } @@ -99,10 +102,13 @@ public abstract partial class VolumeTestsBase protected virtual double CubicMilesTolerance { get { return 1e-5; } } protected virtual double CubicMillimetersTolerance { get { return 1e-5; } } protected virtual double CubicYardsTolerance { get { return 1e-5; } } + protected virtual double DecausGallonsTolerance { get { return 1e-5; } } protected virtual double DecilitersTolerance { get { return 1e-5; } } + protected virtual double DeciusGallonsTolerance { get { return 1e-5; } } protected virtual double HectocubicFeetTolerance { get { return 1e-5; } } protected virtual double HectocubicMetersTolerance { get { return 1e-5; } } protected virtual double HectolitersTolerance { get { return 1e-5; } } + protected virtual double HectousGallonsTolerance { get { return 1e-5; } } protected virtual double ImperialBeerBarrelsTolerance { get { return 1e-5; } } protected virtual double ImperialGallonsTolerance { get { return 1e-5; } } protected virtual double ImperialOuncesTolerance { get { return 1e-5; } } @@ -207,10 +213,13 @@ public void CubicMeterToVolumeUnits() AssertEx.EqualTolerance(CubicMilesInOneCubicMeter, cubicmeter.CubicMiles, CubicMilesTolerance); AssertEx.EqualTolerance(CubicMillimetersInOneCubicMeter, cubicmeter.CubicMillimeters, CubicMillimetersTolerance); AssertEx.EqualTolerance(CubicYardsInOneCubicMeter, cubicmeter.CubicYards, CubicYardsTolerance); + AssertEx.EqualTolerance(DecausGallonsInOneCubicMeter, cubicmeter.DecausGallons, DecausGallonsTolerance); AssertEx.EqualTolerance(DecilitersInOneCubicMeter, cubicmeter.Deciliters, DecilitersTolerance); + AssertEx.EqualTolerance(DeciusGallonsInOneCubicMeter, cubicmeter.DeciusGallons, DeciusGallonsTolerance); AssertEx.EqualTolerance(HectocubicFeetInOneCubicMeter, cubicmeter.HectocubicFeet, HectocubicFeetTolerance); AssertEx.EqualTolerance(HectocubicMetersInOneCubicMeter, cubicmeter.HectocubicMeters, HectocubicMetersTolerance); AssertEx.EqualTolerance(HectolitersInOneCubicMeter, cubicmeter.Hectoliters, HectolitersTolerance); + AssertEx.EqualTolerance(HectousGallonsInOneCubicMeter, cubicmeter.HectousGallons, HectousGallonsTolerance); AssertEx.EqualTolerance(ImperialBeerBarrelsInOneCubicMeter, cubicmeter.ImperialBeerBarrels, ImperialBeerBarrelsTolerance); AssertEx.EqualTolerance(ImperialGallonsInOneCubicMeter, cubicmeter.ImperialGallons, ImperialGallonsTolerance); AssertEx.EqualTolerance(ImperialOuncesInOneCubicMeter, cubicmeter.ImperialOunces, ImperialOuncesTolerance); @@ -301,137 +310,149 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() AssertEx.EqualTolerance(1, quantity13.CubicYards, CubicYardsTolerance); Assert.Equal(VolumeUnit.CubicYard, quantity13.Unit); - var quantity14 = Volume.From(1, VolumeUnit.Deciliter); - AssertEx.EqualTolerance(1, quantity14.Deciliters, DecilitersTolerance); - Assert.Equal(VolumeUnit.Deciliter, quantity14.Unit); + var quantity14 = Volume.From(1, VolumeUnit.DecausGallon); + AssertEx.EqualTolerance(1, quantity14.DecausGallons, DecausGallonsTolerance); + Assert.Equal(VolumeUnit.DecausGallon, quantity14.Unit); - var quantity15 = Volume.From(1, VolumeUnit.HectocubicFoot); - AssertEx.EqualTolerance(1, quantity15.HectocubicFeet, HectocubicFeetTolerance); - Assert.Equal(VolumeUnit.HectocubicFoot, quantity15.Unit); + var quantity15 = Volume.From(1, VolumeUnit.Deciliter); + AssertEx.EqualTolerance(1, quantity15.Deciliters, DecilitersTolerance); + Assert.Equal(VolumeUnit.Deciliter, quantity15.Unit); - var quantity16 = Volume.From(1, VolumeUnit.HectocubicMeter); - AssertEx.EqualTolerance(1, quantity16.HectocubicMeters, HectocubicMetersTolerance); - Assert.Equal(VolumeUnit.HectocubicMeter, quantity16.Unit); + var quantity16 = Volume.From(1, VolumeUnit.DeciusGallon); + AssertEx.EqualTolerance(1, quantity16.DeciusGallons, DeciusGallonsTolerance); + Assert.Equal(VolumeUnit.DeciusGallon, quantity16.Unit); - var quantity17 = Volume.From(1, VolumeUnit.Hectoliter); - AssertEx.EqualTolerance(1, quantity17.Hectoliters, HectolitersTolerance); - Assert.Equal(VolumeUnit.Hectoliter, quantity17.Unit); + var quantity17 = Volume.From(1, VolumeUnit.HectocubicFoot); + AssertEx.EqualTolerance(1, quantity17.HectocubicFeet, HectocubicFeetTolerance); + Assert.Equal(VolumeUnit.HectocubicFoot, quantity17.Unit); - var quantity18 = Volume.From(1, VolumeUnit.ImperialBeerBarrel); - AssertEx.EqualTolerance(1, quantity18.ImperialBeerBarrels, ImperialBeerBarrelsTolerance); - Assert.Equal(VolumeUnit.ImperialBeerBarrel, quantity18.Unit); + var quantity18 = Volume.From(1, VolumeUnit.HectocubicMeter); + AssertEx.EqualTolerance(1, quantity18.HectocubicMeters, HectocubicMetersTolerance); + Assert.Equal(VolumeUnit.HectocubicMeter, quantity18.Unit); - var quantity19 = Volume.From(1, VolumeUnit.ImperialGallon); - AssertEx.EqualTolerance(1, quantity19.ImperialGallons, ImperialGallonsTolerance); - Assert.Equal(VolumeUnit.ImperialGallon, quantity19.Unit); + var quantity19 = Volume.From(1, VolumeUnit.Hectoliter); + AssertEx.EqualTolerance(1, quantity19.Hectoliters, HectolitersTolerance); + Assert.Equal(VolumeUnit.Hectoliter, quantity19.Unit); - var quantity20 = Volume.From(1, VolumeUnit.ImperialOunce); - AssertEx.EqualTolerance(1, quantity20.ImperialOunces, ImperialOuncesTolerance); - Assert.Equal(VolumeUnit.ImperialOunce, quantity20.Unit); + var quantity20 = Volume.From(1, VolumeUnit.HectousGallon); + AssertEx.EqualTolerance(1, quantity20.HectousGallons, HectousGallonsTolerance); + Assert.Equal(VolumeUnit.HectousGallon, quantity20.Unit); - var quantity21 = Volume.From(1, VolumeUnit.ImperialPint); - AssertEx.EqualTolerance(1, quantity21.ImperialPints, ImperialPintsTolerance); - Assert.Equal(VolumeUnit.ImperialPint, quantity21.Unit); + var quantity21 = Volume.From(1, VolumeUnit.ImperialBeerBarrel); + AssertEx.EqualTolerance(1, quantity21.ImperialBeerBarrels, ImperialBeerBarrelsTolerance); + Assert.Equal(VolumeUnit.ImperialBeerBarrel, quantity21.Unit); - var quantity22 = Volume.From(1, VolumeUnit.KilocubicFoot); - AssertEx.EqualTolerance(1, quantity22.KilocubicFeet, KilocubicFeetTolerance); - Assert.Equal(VolumeUnit.KilocubicFoot, quantity22.Unit); + var quantity22 = Volume.From(1, VolumeUnit.ImperialGallon); + AssertEx.EqualTolerance(1, quantity22.ImperialGallons, ImperialGallonsTolerance); + Assert.Equal(VolumeUnit.ImperialGallon, quantity22.Unit); - var quantity23 = Volume.From(1, VolumeUnit.KilocubicMeter); - AssertEx.EqualTolerance(1, quantity23.KilocubicMeters, KilocubicMetersTolerance); - Assert.Equal(VolumeUnit.KilocubicMeter, quantity23.Unit); + var quantity23 = Volume.From(1, VolumeUnit.ImperialOunce); + AssertEx.EqualTolerance(1, quantity23.ImperialOunces, ImperialOuncesTolerance); + Assert.Equal(VolumeUnit.ImperialOunce, quantity23.Unit); - var quantity24 = Volume.From(1, VolumeUnit.KiloimperialGallon); - AssertEx.EqualTolerance(1, quantity24.KiloimperialGallons, KiloimperialGallonsTolerance); - Assert.Equal(VolumeUnit.KiloimperialGallon, quantity24.Unit); + var quantity24 = Volume.From(1, VolumeUnit.ImperialPint); + AssertEx.EqualTolerance(1, quantity24.ImperialPints, ImperialPintsTolerance); + Assert.Equal(VolumeUnit.ImperialPint, quantity24.Unit); - var quantity25 = Volume.From(1, VolumeUnit.Kiloliter); - AssertEx.EqualTolerance(1, quantity25.Kiloliters, KilolitersTolerance); - Assert.Equal(VolumeUnit.Kiloliter, quantity25.Unit); + var quantity25 = Volume.From(1, VolumeUnit.KilocubicFoot); + AssertEx.EqualTolerance(1, quantity25.KilocubicFeet, KilocubicFeetTolerance); + Assert.Equal(VolumeUnit.KilocubicFoot, quantity25.Unit); - var quantity26 = Volume.From(1, VolumeUnit.KilousGallon); - AssertEx.EqualTolerance(1, quantity26.KilousGallons, KilousGallonsTolerance); - Assert.Equal(VolumeUnit.KilousGallon, quantity26.Unit); + var quantity26 = Volume.From(1, VolumeUnit.KilocubicMeter); + AssertEx.EqualTolerance(1, quantity26.KilocubicMeters, KilocubicMetersTolerance); + Assert.Equal(VolumeUnit.KilocubicMeter, quantity26.Unit); - var quantity27 = Volume.From(1, VolumeUnit.Liter); - AssertEx.EqualTolerance(1, quantity27.Liters, LitersTolerance); - Assert.Equal(VolumeUnit.Liter, quantity27.Unit); + var quantity27 = Volume.From(1, VolumeUnit.KiloimperialGallon); + AssertEx.EqualTolerance(1, quantity27.KiloimperialGallons, KiloimperialGallonsTolerance); + Assert.Equal(VolumeUnit.KiloimperialGallon, quantity27.Unit); - var quantity28 = Volume.From(1, VolumeUnit.MegacubicFoot); - AssertEx.EqualTolerance(1, quantity28.MegacubicFeet, MegacubicFeetTolerance); - Assert.Equal(VolumeUnit.MegacubicFoot, quantity28.Unit); + var quantity28 = Volume.From(1, VolumeUnit.Kiloliter); + AssertEx.EqualTolerance(1, quantity28.Kiloliters, KilolitersTolerance); + Assert.Equal(VolumeUnit.Kiloliter, quantity28.Unit); - var quantity29 = Volume.From(1, VolumeUnit.MegaimperialGallon); - AssertEx.EqualTolerance(1, quantity29.MegaimperialGallons, MegaimperialGallonsTolerance); - Assert.Equal(VolumeUnit.MegaimperialGallon, quantity29.Unit); + var quantity29 = Volume.From(1, VolumeUnit.KilousGallon); + AssertEx.EqualTolerance(1, quantity29.KilousGallons, KilousGallonsTolerance); + Assert.Equal(VolumeUnit.KilousGallon, quantity29.Unit); - var quantity30 = Volume.From(1, VolumeUnit.Megaliter); - AssertEx.EqualTolerance(1, quantity30.Megaliters, MegalitersTolerance); - Assert.Equal(VolumeUnit.Megaliter, quantity30.Unit); + var quantity30 = Volume.From(1, VolumeUnit.Liter); + AssertEx.EqualTolerance(1, quantity30.Liters, LitersTolerance); + Assert.Equal(VolumeUnit.Liter, quantity30.Unit); - var quantity31 = Volume.From(1, VolumeUnit.MegausGallon); - AssertEx.EqualTolerance(1, quantity31.MegausGallons, MegausGallonsTolerance); - Assert.Equal(VolumeUnit.MegausGallon, quantity31.Unit); + var quantity31 = Volume.From(1, VolumeUnit.MegacubicFoot); + AssertEx.EqualTolerance(1, quantity31.MegacubicFeet, MegacubicFeetTolerance); + Assert.Equal(VolumeUnit.MegacubicFoot, quantity31.Unit); - var quantity32 = Volume.From(1, VolumeUnit.MetricCup); - AssertEx.EqualTolerance(1, quantity32.MetricCups, MetricCupsTolerance); - Assert.Equal(VolumeUnit.MetricCup, quantity32.Unit); + var quantity32 = Volume.From(1, VolumeUnit.MegaimperialGallon); + AssertEx.EqualTolerance(1, quantity32.MegaimperialGallons, MegaimperialGallonsTolerance); + Assert.Equal(VolumeUnit.MegaimperialGallon, quantity32.Unit); - var quantity33 = Volume.From(1, VolumeUnit.MetricTeaspoon); - AssertEx.EqualTolerance(1, quantity33.MetricTeaspoons, MetricTeaspoonsTolerance); - Assert.Equal(VolumeUnit.MetricTeaspoon, quantity33.Unit); + var quantity33 = Volume.From(1, VolumeUnit.Megaliter); + AssertEx.EqualTolerance(1, quantity33.Megaliters, MegalitersTolerance); + Assert.Equal(VolumeUnit.Megaliter, quantity33.Unit); - var quantity34 = Volume.From(1, VolumeUnit.Microliter); - AssertEx.EqualTolerance(1, quantity34.Microliters, MicrolitersTolerance); - Assert.Equal(VolumeUnit.Microliter, quantity34.Unit); + var quantity34 = Volume.From(1, VolumeUnit.MegausGallon); + AssertEx.EqualTolerance(1, quantity34.MegausGallons, MegausGallonsTolerance); + Assert.Equal(VolumeUnit.MegausGallon, quantity34.Unit); - var quantity35 = Volume.From(1, VolumeUnit.Milliliter); - AssertEx.EqualTolerance(1, quantity35.Milliliters, MillilitersTolerance); - Assert.Equal(VolumeUnit.Milliliter, quantity35.Unit); + var quantity35 = Volume.From(1, VolumeUnit.MetricCup); + AssertEx.EqualTolerance(1, quantity35.MetricCups, MetricCupsTolerance); + Assert.Equal(VolumeUnit.MetricCup, quantity35.Unit); - var quantity36 = Volume.From(1, VolumeUnit.OilBarrel); - AssertEx.EqualTolerance(1, quantity36.OilBarrels, OilBarrelsTolerance); - Assert.Equal(VolumeUnit.OilBarrel, quantity36.Unit); + var quantity36 = Volume.From(1, VolumeUnit.MetricTeaspoon); + AssertEx.EqualTolerance(1, quantity36.MetricTeaspoons, MetricTeaspoonsTolerance); + Assert.Equal(VolumeUnit.MetricTeaspoon, quantity36.Unit); - var quantity37 = Volume.From(1, VolumeUnit.UkTablespoon); - AssertEx.EqualTolerance(1, quantity37.UkTablespoons, UkTablespoonsTolerance); - Assert.Equal(VolumeUnit.UkTablespoon, quantity37.Unit); + var quantity37 = Volume.From(1, VolumeUnit.Microliter); + AssertEx.EqualTolerance(1, quantity37.Microliters, MicrolitersTolerance); + Assert.Equal(VolumeUnit.Microliter, quantity37.Unit); - var quantity38 = Volume.From(1, VolumeUnit.UsBeerBarrel); - AssertEx.EqualTolerance(1, quantity38.UsBeerBarrels, UsBeerBarrelsTolerance); - Assert.Equal(VolumeUnit.UsBeerBarrel, quantity38.Unit); + var quantity38 = Volume.From(1, VolumeUnit.Milliliter); + AssertEx.EqualTolerance(1, quantity38.Milliliters, MillilitersTolerance); + Assert.Equal(VolumeUnit.Milliliter, quantity38.Unit); - var quantity39 = Volume.From(1, VolumeUnit.UsCustomaryCup); - AssertEx.EqualTolerance(1, quantity39.UsCustomaryCups, UsCustomaryCupsTolerance); - Assert.Equal(VolumeUnit.UsCustomaryCup, quantity39.Unit); + var quantity39 = Volume.From(1, VolumeUnit.OilBarrel); + AssertEx.EqualTolerance(1, quantity39.OilBarrels, OilBarrelsTolerance); + Assert.Equal(VolumeUnit.OilBarrel, quantity39.Unit); - var quantity40 = Volume.From(1, VolumeUnit.UsGallon); - AssertEx.EqualTolerance(1, quantity40.UsGallons, UsGallonsTolerance); - Assert.Equal(VolumeUnit.UsGallon, quantity40.Unit); + var quantity40 = Volume.From(1, VolumeUnit.UkTablespoon); + AssertEx.EqualTolerance(1, quantity40.UkTablespoons, UkTablespoonsTolerance); + Assert.Equal(VolumeUnit.UkTablespoon, quantity40.Unit); - var quantity41 = Volume.From(1, VolumeUnit.UsLegalCup); - AssertEx.EqualTolerance(1, quantity41.UsLegalCups, UsLegalCupsTolerance); - Assert.Equal(VolumeUnit.UsLegalCup, quantity41.Unit); + var quantity41 = Volume.From(1, VolumeUnit.UsBeerBarrel); + AssertEx.EqualTolerance(1, quantity41.UsBeerBarrels, UsBeerBarrelsTolerance); + Assert.Equal(VolumeUnit.UsBeerBarrel, quantity41.Unit); - var quantity42 = Volume.From(1, VolumeUnit.UsOunce); - AssertEx.EqualTolerance(1, quantity42.UsOunces, UsOuncesTolerance); - Assert.Equal(VolumeUnit.UsOunce, quantity42.Unit); + var quantity42 = Volume.From(1, VolumeUnit.UsCustomaryCup); + AssertEx.EqualTolerance(1, quantity42.UsCustomaryCups, UsCustomaryCupsTolerance); + Assert.Equal(VolumeUnit.UsCustomaryCup, quantity42.Unit); - var quantity43 = Volume.From(1, VolumeUnit.UsPint); - AssertEx.EqualTolerance(1, quantity43.UsPints, UsPintsTolerance); - Assert.Equal(VolumeUnit.UsPint, quantity43.Unit); + var quantity43 = Volume.From(1, VolumeUnit.UsGallon); + AssertEx.EqualTolerance(1, quantity43.UsGallons, UsGallonsTolerance); + Assert.Equal(VolumeUnit.UsGallon, quantity43.Unit); - var quantity44 = Volume.From(1, VolumeUnit.UsQuart); - AssertEx.EqualTolerance(1, quantity44.UsQuarts, UsQuartsTolerance); - Assert.Equal(VolumeUnit.UsQuart, quantity44.Unit); + var quantity44 = Volume.From(1, VolumeUnit.UsLegalCup); + AssertEx.EqualTolerance(1, quantity44.UsLegalCups, UsLegalCupsTolerance); + Assert.Equal(VolumeUnit.UsLegalCup, quantity44.Unit); - var quantity45 = Volume.From(1, VolumeUnit.UsTablespoon); - AssertEx.EqualTolerance(1, quantity45.UsTablespoons, UsTablespoonsTolerance); - Assert.Equal(VolumeUnit.UsTablespoon, quantity45.Unit); + var quantity45 = Volume.From(1, VolumeUnit.UsOunce); + AssertEx.EqualTolerance(1, quantity45.UsOunces, UsOuncesTolerance); + Assert.Equal(VolumeUnit.UsOunce, quantity45.Unit); - var quantity46 = Volume.From(1, VolumeUnit.UsTeaspoon); - AssertEx.EqualTolerance(1, quantity46.UsTeaspoons, UsTeaspoonsTolerance); - Assert.Equal(VolumeUnit.UsTeaspoon, quantity46.Unit); + var quantity46 = Volume.From(1, VolumeUnit.UsPint); + AssertEx.EqualTolerance(1, quantity46.UsPints, UsPintsTolerance); + Assert.Equal(VolumeUnit.UsPint, quantity46.Unit); + + var quantity47 = Volume.From(1, VolumeUnit.UsQuart); + AssertEx.EqualTolerance(1, quantity47.UsQuarts, UsQuartsTolerance); + Assert.Equal(VolumeUnit.UsQuart, quantity47.Unit); + + var quantity48 = Volume.From(1, VolumeUnit.UsTablespoon); + AssertEx.EqualTolerance(1, quantity48.UsTablespoons, UsTablespoonsTolerance); + Assert.Equal(VolumeUnit.UsTablespoon, quantity48.Unit); + + var quantity49 = Volume.From(1, VolumeUnit.UsTeaspoon); + AssertEx.EqualTolerance(1, quantity49.UsTeaspoons, UsTeaspoonsTolerance); + Assert.Equal(VolumeUnit.UsTeaspoon, quantity49.Unit); } @@ -466,10 +487,13 @@ public void As() AssertEx.EqualTolerance(CubicMilesInOneCubicMeter, cubicmeter.As(VolumeUnit.CubicMile), CubicMilesTolerance); AssertEx.EqualTolerance(CubicMillimetersInOneCubicMeter, cubicmeter.As(VolumeUnit.CubicMillimeter), CubicMillimetersTolerance); AssertEx.EqualTolerance(CubicYardsInOneCubicMeter, cubicmeter.As(VolumeUnit.CubicYard), CubicYardsTolerance); + AssertEx.EqualTolerance(DecausGallonsInOneCubicMeter, cubicmeter.As(VolumeUnit.DecausGallon), DecausGallonsTolerance); AssertEx.EqualTolerance(DecilitersInOneCubicMeter, cubicmeter.As(VolumeUnit.Deciliter), DecilitersTolerance); + AssertEx.EqualTolerance(DeciusGallonsInOneCubicMeter, cubicmeter.As(VolumeUnit.DeciusGallon), DeciusGallonsTolerance); AssertEx.EqualTolerance(HectocubicFeetInOneCubicMeter, cubicmeter.As(VolumeUnit.HectocubicFoot), HectocubicFeetTolerance); AssertEx.EqualTolerance(HectocubicMetersInOneCubicMeter, cubicmeter.As(VolumeUnit.HectocubicMeter), HectocubicMetersTolerance); AssertEx.EqualTolerance(HectolitersInOneCubicMeter, cubicmeter.As(VolumeUnit.Hectoliter), HectolitersTolerance); + AssertEx.EqualTolerance(HectousGallonsInOneCubicMeter, cubicmeter.As(VolumeUnit.HectousGallon), HectousGallonsTolerance); AssertEx.EqualTolerance(ImperialBeerBarrelsInOneCubicMeter, cubicmeter.As(VolumeUnit.ImperialBeerBarrel), ImperialBeerBarrelsTolerance); AssertEx.EqualTolerance(ImperialGallonsInOneCubicMeter, cubicmeter.As(VolumeUnit.ImperialGallon), ImperialGallonsTolerance); AssertEx.EqualTolerance(ImperialOuncesInOneCubicMeter, cubicmeter.As(VolumeUnit.ImperialOunce), ImperialOuncesTolerance); @@ -562,10 +586,18 @@ public void ToUnit() AssertEx.EqualTolerance(CubicYardsInOneCubicMeter, (double)cubicyardQuantity.Value, CubicYardsTolerance); Assert.Equal(VolumeUnit.CubicYard, cubicyardQuantity.Unit); + var decausgallonQuantity = cubicmeter.ToUnit(VolumeUnit.DecausGallon); + AssertEx.EqualTolerance(DecausGallonsInOneCubicMeter, (double)decausgallonQuantity.Value, DecausGallonsTolerance); + Assert.Equal(VolumeUnit.DecausGallon, decausgallonQuantity.Unit); + var deciliterQuantity = cubicmeter.ToUnit(VolumeUnit.Deciliter); AssertEx.EqualTolerance(DecilitersInOneCubicMeter, (double)deciliterQuantity.Value, DecilitersTolerance); Assert.Equal(VolumeUnit.Deciliter, deciliterQuantity.Unit); + var deciusgallonQuantity = cubicmeter.ToUnit(VolumeUnit.DeciusGallon); + AssertEx.EqualTolerance(DeciusGallonsInOneCubicMeter, (double)deciusgallonQuantity.Value, DeciusGallonsTolerance); + Assert.Equal(VolumeUnit.DeciusGallon, deciusgallonQuantity.Unit); + var hectocubicfootQuantity = cubicmeter.ToUnit(VolumeUnit.HectocubicFoot); AssertEx.EqualTolerance(HectocubicFeetInOneCubicMeter, (double)hectocubicfootQuantity.Value, HectocubicFeetTolerance); Assert.Equal(VolumeUnit.HectocubicFoot, hectocubicfootQuantity.Unit); @@ -578,6 +610,10 @@ public void ToUnit() AssertEx.EqualTolerance(HectolitersInOneCubicMeter, (double)hectoliterQuantity.Value, HectolitersTolerance); Assert.Equal(VolumeUnit.Hectoliter, hectoliterQuantity.Unit); + var hectousgallonQuantity = cubicmeter.ToUnit(VolumeUnit.HectousGallon); + AssertEx.EqualTolerance(HectousGallonsInOneCubicMeter, (double)hectousgallonQuantity.Value, HectousGallonsTolerance); + Assert.Equal(VolumeUnit.HectousGallon, hectousgallonQuantity.Unit); + var imperialbeerbarrelQuantity = cubicmeter.ToUnit(VolumeUnit.ImperialBeerBarrel); AssertEx.EqualTolerance(ImperialBeerBarrelsInOneCubicMeter, (double)imperialbeerbarrelQuantity.Value, ImperialBeerBarrelsTolerance); Assert.Equal(VolumeUnit.ImperialBeerBarrel, imperialbeerbarrelQuantity.Unit); @@ -713,10 +749,13 @@ public void ConversionRoundTrip() AssertEx.EqualTolerance(1, Volume.FromCubicMiles(cubicmeter.CubicMiles).CubicMeters, CubicMilesTolerance); AssertEx.EqualTolerance(1, Volume.FromCubicMillimeters(cubicmeter.CubicMillimeters).CubicMeters, CubicMillimetersTolerance); AssertEx.EqualTolerance(1, Volume.FromCubicYards(cubicmeter.CubicYards).CubicMeters, CubicYardsTolerance); + AssertEx.EqualTolerance(1, Volume.FromDecausGallons(cubicmeter.DecausGallons).CubicMeters, DecausGallonsTolerance); AssertEx.EqualTolerance(1, Volume.FromDeciliters(cubicmeter.Deciliters).CubicMeters, DecilitersTolerance); + AssertEx.EqualTolerance(1, Volume.FromDeciusGallons(cubicmeter.DeciusGallons).CubicMeters, DeciusGallonsTolerance); AssertEx.EqualTolerance(1, Volume.FromHectocubicFeet(cubicmeter.HectocubicFeet).CubicMeters, HectocubicFeetTolerance); AssertEx.EqualTolerance(1, Volume.FromHectocubicMeters(cubicmeter.HectocubicMeters).CubicMeters, HectocubicMetersTolerance); AssertEx.EqualTolerance(1, Volume.FromHectoliters(cubicmeter.Hectoliters).CubicMeters, HectolitersTolerance); + AssertEx.EqualTolerance(1, Volume.FromHectousGallons(cubicmeter.HectousGallons).CubicMeters, HectousGallonsTolerance); AssertEx.EqualTolerance(1, Volume.FromImperialBeerBarrels(cubicmeter.ImperialBeerBarrels).CubicMeters, ImperialBeerBarrelsTolerance); AssertEx.EqualTolerance(1, Volume.FromImperialGallons(cubicmeter.ImperialGallons).CubicMeters, ImperialGallonsTolerance); AssertEx.EqualTolerance(1, Volume.FromImperialOunces(cubicmeter.ImperialOunces).CubicMeters, ImperialOuncesTolerance); @@ -899,10 +938,13 @@ public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture() Assert.Equal("1 mi³", new Volume(1, VolumeUnit.CubicMile).ToString()); Assert.Equal("1 mm³", new Volume(1, VolumeUnit.CubicMillimeter).ToString()); Assert.Equal("1 yd³", new Volume(1, VolumeUnit.CubicYard).ToString()); + Assert.Equal("1 dagal (U.S.)", new Volume(1, VolumeUnit.DecausGallon).ToString()); Assert.Equal("1 dl", new Volume(1, VolumeUnit.Deciliter).ToString()); + Assert.Equal("1 dgal (U.S.)", new Volume(1, VolumeUnit.DeciusGallon).ToString()); Assert.Equal("1 hft³", new Volume(1, VolumeUnit.HectocubicFoot).ToString()); Assert.Equal("1 hm³", new Volume(1, VolumeUnit.HectocubicMeter).ToString()); Assert.Equal("1 hl", new Volume(1, VolumeUnit.Hectoliter).ToString()); + Assert.Equal("1 hgal (U.S.)", new Volume(1, VolumeUnit.HectousGallon).ToString()); Assert.Equal("1 bl (imp.)", new Volume(1, VolumeUnit.ImperialBeerBarrel).ToString()); Assert.Equal("1 gal (imp.)", new Volume(1, VolumeUnit.ImperialGallon).ToString()); Assert.Equal("1 oz (imp.)", new Volume(1, VolumeUnit.ImperialOunce).ToString()); @@ -959,10 +1001,13 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture Assert.Equal("1 mi³", new Volume(1, VolumeUnit.CubicMile).ToString(swedishCulture)); Assert.Equal("1 mm³", new Volume(1, VolumeUnit.CubicMillimeter).ToString(swedishCulture)); Assert.Equal("1 yd³", new Volume(1, VolumeUnit.CubicYard).ToString(swedishCulture)); + Assert.Equal("1 dagal (U.S.)", new Volume(1, VolumeUnit.DecausGallon).ToString(swedishCulture)); Assert.Equal("1 dl", new Volume(1, VolumeUnit.Deciliter).ToString(swedishCulture)); + Assert.Equal("1 dgal (U.S.)", new Volume(1, VolumeUnit.DeciusGallon).ToString(swedishCulture)); Assert.Equal("1 hft³", new Volume(1, VolumeUnit.HectocubicFoot).ToString(swedishCulture)); Assert.Equal("1 hm³", new Volume(1, VolumeUnit.HectocubicMeter).ToString(swedishCulture)); Assert.Equal("1 hl", new Volume(1, VolumeUnit.Hectoliter).ToString(swedishCulture)); + Assert.Equal("1 hgal (U.S.)", new Volume(1, VolumeUnit.HectousGallon).ToString(swedishCulture)); Assert.Equal("1 bl (imp.)", new Volume(1, VolumeUnit.ImperialBeerBarrel).ToString(swedishCulture)); Assert.Equal("1 gal (imp.)", new Volume(1, VolumeUnit.ImperialGallon).ToString(swedishCulture)); Assert.Equal("1 oz (imp.)", new Volume(1, VolumeUnit.ImperialOunce).ToString(swedishCulture)); diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Volume.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Volume.g.cs index 5ab6d276cf..e25242851d 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Volume.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Volume.g.cs @@ -225,11 +225,21 @@ private Volume(double value, VolumeUnit unit) /// public double CubicYards => As(VolumeUnit.CubicYard); + /// + /// Get Volume in DecausGallons. + /// + public double DecausGallons => As(VolumeUnit.DecausGallon); + /// /// Get Volume in Deciliters. /// public double Deciliters => As(VolumeUnit.Deciliter); + /// + /// Get Volume in DeciusGallons. + /// + public double DeciusGallons => As(VolumeUnit.DeciusGallon); + /// /// Get Volume in HectocubicFeet. /// @@ -245,6 +255,11 @@ private Volume(double value, VolumeUnit unit) /// public double Hectoliters => As(VolumeUnit.Hectoliter); + /// + /// Get Volume in HectousGallons. + /// + public double HectousGallons => As(VolumeUnit.HectousGallon); + /// /// Get Volume in ImperialBeerBarrels. /// @@ -561,6 +576,16 @@ public static Volume FromCubicYards(double cubicyards) return new Volume(value, VolumeUnit.CubicYard); } /// + /// Get Volume from DecausGallons. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static Volume FromDecausGallons(double decausgallons) + { + double value = (double) decausgallons; + return new Volume(value, VolumeUnit.DecausGallon); + } + /// /// Get Volume from Deciliters. /// /// If value is NaN or Infinity. @@ -571,6 +596,16 @@ public static Volume FromDeciliters(double deciliters) return new Volume(value, VolumeUnit.Deciliter); } /// + /// Get Volume from DeciusGallons. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static Volume FromDeciusGallons(double deciusgallons) + { + double value = (double) deciusgallons; + return new Volume(value, VolumeUnit.DeciusGallon); + } + /// /// Get Volume from HectocubicFeet. /// /// If value is NaN or Infinity. @@ -601,6 +636,16 @@ public static Volume FromHectoliters(double hectoliters) return new Volume(value, VolumeUnit.Hectoliter); } /// + /// Get Volume from HectousGallons. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static Volume FromHectousGallons(double hectousgallons) + { + double value = (double) hectousgallons; + return new Volume(value, VolumeUnit.HectousGallon); + } + /// /// Get Volume from ImperialBeerBarrels. /// /// If value is NaN or Infinity. @@ -1195,10 +1240,13 @@ private double AsBaseUnit() case VolumeUnit.CubicMile: return _value*4.16818182544058e9; case VolumeUnit.CubicMillimeter: return _value/1e9; case VolumeUnit.CubicYard: return _value*0.764554858; + case VolumeUnit.DecausGallon: return (_value*0.00378541) * 1e1d; case VolumeUnit.Deciliter: return (_value/1e3) * 1e-1d; + case VolumeUnit.DeciusGallon: return (_value*0.00378541) * 1e-1d; case VolumeUnit.HectocubicFoot: return (_value*0.0283168) * 1e2d; case VolumeUnit.HectocubicMeter: return (_value) * 1e2d; case VolumeUnit.Hectoliter: return (_value/1e3) * 1e2d; + case VolumeUnit.HectousGallon: return (_value*0.00378541) * 1e2d; case VolumeUnit.ImperialBeerBarrel: return _value*0.16365924; case VolumeUnit.ImperialGallon: return _value*0.00454609000000181429905810072407; case VolumeUnit.ImperialOunce: return _value*2.8413062499962901241875439064617e-5; @@ -1256,10 +1304,13 @@ private double AsBaseNumericType(VolumeUnit unit) case VolumeUnit.CubicMile: return baseUnitValue/4.16818182544058e9; case VolumeUnit.CubicMillimeter: return baseUnitValue*1e9; case VolumeUnit.CubicYard: return baseUnitValue/0.764554858; + case VolumeUnit.DecausGallon: return (baseUnitValue/0.00378541) / 1e1d; case VolumeUnit.Deciliter: return (baseUnitValue*1e3) / 1e-1d; + case VolumeUnit.DeciusGallon: return (baseUnitValue/0.00378541) / 1e-1d; case VolumeUnit.HectocubicFoot: return (baseUnitValue/0.0283168) / 1e2d; case VolumeUnit.HectocubicMeter: return (baseUnitValue) / 1e2d; case VolumeUnit.Hectoliter: return (baseUnitValue*1e3) / 1e2d; + case VolumeUnit.HectousGallon: return (baseUnitValue/0.00378541) / 1e2d; case VolumeUnit.ImperialBeerBarrel: return baseUnitValue/0.16365924; case VolumeUnit.ImperialGallon: return baseUnitValue/0.00454609000000181429905810072407; case VolumeUnit.ImperialOunce: return baseUnitValue/2.8413062499962901241875439064617e-5; diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs index 4bb8c274fc..cbc975a5d7 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs @@ -1366,14 +1366,20 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("ru-RU", typeof(VolumeUnit), (int)VolumeUnit.CubicMillimeter, new string[]{"мм³"}), ("en-US", typeof(VolumeUnit), (int)VolumeUnit.CubicYard, new string[]{"yd³"}), ("ru-RU", typeof(VolumeUnit), (int)VolumeUnit.CubicYard, new string[]{"ярд³"}), + ("en-US", typeof(VolumeUnit), (int)VolumeUnit.DecausGallon, new string[]{"dagal (U.S.)"}), + ("ru-RU", typeof(VolumeUnit), (int)VolumeUnit.DecausGallon, new string[]{"даАмериканский галлон"}), ("en-US", typeof(VolumeUnit), (int)VolumeUnit.Deciliter, new string[]{"dl"}), ("ru-RU", typeof(VolumeUnit), (int)VolumeUnit.Deciliter, new string[]{"дл"}), + ("en-US", typeof(VolumeUnit), (int)VolumeUnit.DeciusGallon, new string[]{"dgal (U.S.)"}), + ("ru-RU", typeof(VolumeUnit), (int)VolumeUnit.DeciusGallon, new string[]{"дАмериканский галлон"}), ("en-US", typeof(VolumeUnit), (int)VolumeUnit.HectocubicFoot, new string[]{"hft³"}), ("ru-RU", typeof(VolumeUnit), (int)VolumeUnit.HectocubicFoot, new string[]{"гфут³"}), ("en-US", typeof(VolumeUnit), (int)VolumeUnit.HectocubicMeter, new string[]{"hm³"}), ("ru-RU", typeof(VolumeUnit), (int)VolumeUnit.HectocubicMeter, new string[]{"гм³"}), ("en-US", typeof(VolumeUnit), (int)VolumeUnit.Hectoliter, new string[]{"hl"}), ("ru-RU", typeof(VolumeUnit), (int)VolumeUnit.Hectoliter, new string[]{"гл"}), + ("en-US", typeof(VolumeUnit), (int)VolumeUnit.HectousGallon, new string[]{"hgal (U.S.)"}), + ("ru-RU", typeof(VolumeUnit), (int)VolumeUnit.HectousGallon, new string[]{"гАмериканский галлон"}), ("en-US", typeof(VolumeUnit), (int)VolumeUnit.ImperialBeerBarrel, new string[]{"bl (imp.)"}), ("en-US", typeof(VolumeUnit), (int)VolumeUnit.ImperialGallon, new string[]{"gal (imp.)"}), ("ru-RU", typeof(VolumeUnit), (int)VolumeUnit.ImperialGallon, new string[]{"Английский галлон"}), diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/VolumeUnit.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/VolumeUnit.g.cs index 9dbbc08cfe..c3f687a35c 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/VolumeUnit.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/VolumeUnit.g.cs @@ -40,10 +40,13 @@ public enum VolumeUnit CubicMile, CubicMillimeter, CubicYard, + DecausGallon, Deciliter, + DeciusGallon, HectocubicFoot, HectocubicMeter, Hectoliter, + HectousGallon, ImperialBeerBarrel, ImperialGallon, ImperialOunce, diff --git a/UnitsNet/GeneratedCode/Quantities/Volume.g.cs b/UnitsNet/GeneratedCode/Quantities/Volume.g.cs index d3a12dceaa..fbe1f2febf 100644 --- a/UnitsNet/GeneratedCode/Quantities/Volume.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Volume.g.cs @@ -64,10 +64,13 @@ static Volume() new UnitInfo(VolumeUnit.CubicMile, BaseUnits.Undefined), new UnitInfo(VolumeUnit.CubicMillimeter, BaseUnits.Undefined), new UnitInfo(VolumeUnit.CubicYard, BaseUnits.Undefined), + new UnitInfo(VolumeUnit.DecausGallon, BaseUnits.Undefined), new UnitInfo(VolumeUnit.Deciliter, BaseUnits.Undefined), + new UnitInfo(VolumeUnit.DeciusGallon, BaseUnits.Undefined), new UnitInfo(VolumeUnit.HectocubicFoot, BaseUnits.Undefined), new UnitInfo(VolumeUnit.HectocubicMeter, BaseUnits.Undefined), new UnitInfo(VolumeUnit.Hectoliter, BaseUnits.Undefined), + new UnitInfo(VolumeUnit.HectousGallon, BaseUnits.Undefined), new UnitInfo(VolumeUnit.ImperialBeerBarrel, BaseUnits.Undefined), new UnitInfo(VolumeUnit.ImperialGallon, BaseUnits.Undefined), new UnitInfo(VolumeUnit.ImperialOunce, BaseUnits.Undefined), @@ -279,11 +282,21 @@ public Volume(double value, UnitSystem unitSystem) /// public double CubicYards => As(VolumeUnit.CubicYard); + /// + /// Get Volume in DecausGallons. + /// + public double DecausGallons => As(VolumeUnit.DecausGallon); + /// /// Get Volume in Deciliters. /// public double Deciliters => As(VolumeUnit.Deciliter); + /// + /// Get Volume in DeciusGallons. + /// + public double DeciusGallons => As(VolumeUnit.DeciusGallon); + /// /// Get Volume in HectocubicFeet. /// @@ -299,6 +312,11 @@ public Volume(double value, UnitSystem unitSystem) /// public double Hectoliters => As(VolumeUnit.Hectoliter); + /// + /// Get Volume in HectousGallons. + /// + public double HectousGallons => As(VolumeUnit.HectousGallon); + /// /// Get Volume in ImperialBeerBarrels. /// @@ -600,6 +618,15 @@ public static Volume FromCubicYards(QuantityValue cubicyards) return new Volume(value, VolumeUnit.CubicYard); } /// + /// Get Volume from DecausGallons. + /// + /// If value is NaN or Infinity. + public static Volume FromDecausGallons(QuantityValue decausgallons) + { + double value = (double) decausgallons; + return new Volume(value, VolumeUnit.DecausGallon); + } + /// /// Get Volume from Deciliters. /// /// If value is NaN or Infinity. @@ -609,6 +636,15 @@ public static Volume FromDeciliters(QuantityValue deciliters) return new Volume(value, VolumeUnit.Deciliter); } /// + /// Get Volume from DeciusGallons. + /// + /// If value is NaN or Infinity. + public static Volume FromDeciusGallons(QuantityValue deciusgallons) + { + double value = (double) deciusgallons; + return new Volume(value, VolumeUnit.DeciusGallon); + } + /// /// Get Volume from HectocubicFeet. /// /// If value is NaN or Infinity. @@ -636,6 +672,15 @@ public static Volume FromHectoliters(QuantityValue hectoliters) return new Volume(value, VolumeUnit.Hectoliter); } /// + /// Get Volume from HectousGallons. + /// + /// If value is NaN or Infinity. + public static Volume FromHectousGallons(QuantityValue hectousgallons) + { + double value = (double) hectousgallons; + return new Volume(value, VolumeUnit.HectousGallon); + } + /// /// Get Volume from ImperialBeerBarrels. /// /// If value is NaN or Infinity. @@ -1339,10 +1384,13 @@ private double GetValueInBaseUnit() case VolumeUnit.CubicMile: return _value*4.16818182544058e9; case VolumeUnit.CubicMillimeter: return _value/1e9; case VolumeUnit.CubicYard: return _value*0.764554858; + case VolumeUnit.DecausGallon: return (_value*0.00378541) * 1e1d; case VolumeUnit.Deciliter: return (_value/1e3) * 1e-1d; + case VolumeUnit.DeciusGallon: return (_value*0.00378541) * 1e-1d; case VolumeUnit.HectocubicFoot: return (_value*0.0283168) * 1e2d; case VolumeUnit.HectocubicMeter: return (_value) * 1e2d; case VolumeUnit.Hectoliter: return (_value/1e3) * 1e2d; + case VolumeUnit.HectousGallon: return (_value*0.00378541) * 1e2d; case VolumeUnit.ImperialBeerBarrel: return _value*0.16365924; case VolumeUnit.ImperialGallon: return _value*0.00454609000000181429905810072407; case VolumeUnit.ImperialOunce: return _value*2.8413062499962901241875439064617e-5; @@ -1411,10 +1459,13 @@ private double GetValueAs(VolumeUnit unit) case VolumeUnit.CubicMile: return baseUnitValue/4.16818182544058e9; case VolumeUnit.CubicMillimeter: return baseUnitValue*1e9; case VolumeUnit.CubicYard: return baseUnitValue/0.764554858; + case VolumeUnit.DecausGallon: return (baseUnitValue/0.00378541) / 1e1d; case VolumeUnit.Deciliter: return (baseUnitValue*1e3) / 1e-1d; + case VolumeUnit.DeciusGallon: return (baseUnitValue/0.00378541) / 1e-1d; case VolumeUnit.HectocubicFoot: return (baseUnitValue/0.0283168) / 1e2d; case VolumeUnit.HectocubicMeter: return (baseUnitValue) / 1e2d; case VolumeUnit.Hectoliter: return (baseUnitValue*1e3) / 1e2d; + case VolumeUnit.HectousGallon: return (baseUnitValue/0.00378541) / 1e2d; case VolumeUnit.ImperialBeerBarrel: return baseUnitValue/0.16365924; case VolumeUnit.ImperialGallon: return baseUnitValue/0.00454609000000181429905810072407; case VolumeUnit.ImperialOunce: return baseUnitValue/2.8413062499962901241875439064617e-5; diff --git a/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs b/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs index d2d4c566a6..a6ede7f36e 100644 --- a/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs +++ b/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs @@ -1366,14 +1366,20 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("ru-RU", typeof(VolumeUnit), (int)VolumeUnit.CubicMillimeter, new string[]{"мм³"}), ("en-US", typeof(VolumeUnit), (int)VolumeUnit.CubicYard, new string[]{"yd³"}), ("ru-RU", typeof(VolumeUnit), (int)VolumeUnit.CubicYard, new string[]{"ярд³"}), + ("en-US", typeof(VolumeUnit), (int)VolumeUnit.DecausGallon, new string[]{"dagal (U.S.)"}), + ("ru-RU", typeof(VolumeUnit), (int)VolumeUnit.DecausGallon, new string[]{"даАмериканский галлон"}), ("en-US", typeof(VolumeUnit), (int)VolumeUnit.Deciliter, new string[]{"dl"}), ("ru-RU", typeof(VolumeUnit), (int)VolumeUnit.Deciliter, new string[]{"дл"}), + ("en-US", typeof(VolumeUnit), (int)VolumeUnit.DeciusGallon, new string[]{"dgal (U.S.)"}), + ("ru-RU", typeof(VolumeUnit), (int)VolumeUnit.DeciusGallon, new string[]{"дАмериканский галлон"}), ("en-US", typeof(VolumeUnit), (int)VolumeUnit.HectocubicFoot, new string[]{"hft³"}), ("ru-RU", typeof(VolumeUnit), (int)VolumeUnit.HectocubicFoot, new string[]{"гфут³"}), ("en-US", typeof(VolumeUnit), (int)VolumeUnit.HectocubicMeter, new string[]{"hm³"}), ("ru-RU", typeof(VolumeUnit), (int)VolumeUnit.HectocubicMeter, new string[]{"гм³"}), ("en-US", typeof(VolumeUnit), (int)VolumeUnit.Hectoliter, new string[]{"hl"}), ("ru-RU", typeof(VolumeUnit), (int)VolumeUnit.Hectoliter, new string[]{"гл"}), + ("en-US", typeof(VolumeUnit), (int)VolumeUnit.HectousGallon, new string[]{"hgal (U.S.)"}), + ("ru-RU", typeof(VolumeUnit), (int)VolumeUnit.HectousGallon, new string[]{"гАмериканский галлон"}), ("en-US", typeof(VolumeUnit), (int)VolumeUnit.ImperialBeerBarrel, new string[]{"bl (imp.)"}), ("en-US", typeof(VolumeUnit), (int)VolumeUnit.ImperialGallon, new string[]{"gal (imp.)"}), ("ru-RU", typeof(VolumeUnit), (int)VolumeUnit.ImperialGallon, new string[]{"Английский галлон"}), diff --git a/UnitsNet/GeneratedCode/UnitConverter.g.cs b/UnitsNet/GeneratedCode/UnitConverter.g.cs index 6e33b946de..62fe6a292e 100644 --- a/UnitsNet/GeneratedCode/UnitConverter.g.cs +++ b/UnitsNet/GeneratedCode/UnitConverter.g.cs @@ -2120,14 +2120,20 @@ public static void RegisterDefaultConversions(UnitConverter unitConverter) unitConverter.SetConversionFunction(VolumeUnit.CubicMillimeter, Volume.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.CubicYard, q => q.ToUnit(VolumeUnit.CubicYard)); unitConverter.SetConversionFunction(VolumeUnit.CubicYard, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.DecausGallon, q => q.ToUnit(VolumeUnit.DecausGallon)); + unitConverter.SetConversionFunction(VolumeUnit.DecausGallon, Volume.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.Deciliter, q => q.ToUnit(VolumeUnit.Deciliter)); unitConverter.SetConversionFunction(VolumeUnit.Deciliter, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.DeciusGallon, q => q.ToUnit(VolumeUnit.DeciusGallon)); + unitConverter.SetConversionFunction(VolumeUnit.DeciusGallon, Volume.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.HectocubicFoot, q => q.ToUnit(VolumeUnit.HectocubicFoot)); unitConverter.SetConversionFunction(VolumeUnit.HectocubicFoot, Volume.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.HectocubicMeter, q => q.ToUnit(VolumeUnit.HectocubicMeter)); unitConverter.SetConversionFunction(VolumeUnit.HectocubicMeter, Volume.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.Hectoliter, q => q.ToUnit(VolumeUnit.Hectoliter)); unitConverter.SetConversionFunction(VolumeUnit.Hectoliter, Volume.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.HectousGallon, q => q.ToUnit(VolumeUnit.HectousGallon)); + unitConverter.SetConversionFunction(VolumeUnit.HectousGallon, Volume.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.ImperialBeerBarrel, q => q.ToUnit(VolumeUnit.ImperialBeerBarrel)); unitConverter.SetConversionFunction(VolumeUnit.ImperialBeerBarrel, Volume.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Volume.BaseUnit, VolumeUnit.ImperialGallon, q => q.ToUnit(VolumeUnit.ImperialGallon)); diff --git a/UnitsNet/GeneratedCode/Units/VolumeUnit.g.cs b/UnitsNet/GeneratedCode/Units/VolumeUnit.g.cs index 9dbbc08cfe..c3f687a35c 100644 --- a/UnitsNet/GeneratedCode/Units/VolumeUnit.g.cs +++ b/UnitsNet/GeneratedCode/Units/VolumeUnit.g.cs @@ -40,10 +40,13 @@ public enum VolumeUnit CubicMile, CubicMillimeter, CubicYard, + DecausGallon, Deciliter, + DeciusGallon, HectocubicFoot, HectocubicMeter, Hectoliter, + HectousGallon, ImperialBeerBarrel, ImperialGallon, ImperialOunce,