diff --git a/Common/UnitDefinitions/Density.json b/Common/UnitDefinitions/Density.json index 5e00c2ab12..16825fbd52 100644 --- a/Common/UnitDefinitions/Density.json +++ b/Common/UnitDefinitions/Density.json @@ -241,6 +241,182 @@ "Abbreviations": [ "kg/l" ] } ] + }, + { + "SingularName": "TonnePerCubicFoot", + "PluralName": "TonnesPerCubicFoot", + "BaseUnits": { + "L": "Foot", + "M": "Tonne" + }, + "FromUnitToBaseFunc": "x*3.53146667214886e4", + "FromBaseToUnitFunc": "x/3.53146667214886e4", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "t/ft³" ] + } + ] + }, + { + "SingularName": "TonnePerCubicInch", + "PluralName": "TonnesPerCubicInch", + "BaseUnits": { + "L": "Inch", + "M": "Tonne" + }, + "FromUnitToBaseFunc": "x*6.10237440947323e7", + "FromBaseToUnitFunc": "x/6.10237440947323e7", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "t/in³" ] + } + ] + }, + { + "SingularName": "GramPerCubicFoot", + "PluralName": "GramsPerCubicFoot", + "BaseUnits": { + "L": "Foot", + "M": "Gram" + }, + "FromUnitToBaseFunc": "x*0.0353146667214886", + "FromBaseToUnitFunc": "x/0.0353146667214886", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "g/ft³" ] + } + ] + }, + { + "SingularName": "GramPerCubicInch", + "PluralName": "GramsPerCubicInch", + "BaseUnits": { + "L": "Inch", + "M": "Gram" + }, + "FromUnitToBaseFunc": "x*61.0237440947323", + "FromBaseToUnitFunc": "x/61.0237440947323", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "g/in³" ] + } + ] + }, + { + "SingularName": "PoundPerCubicMeter", + "PluralName": "PoundsPerCubicMeter", + "BaseUnits": { + "L": "Meter", + "M": "Pound" + }, + "FromUnitToBaseFunc": "x/2.204622621848775", + "FromBaseToUnitFunc": "x*2.204622621848775", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "lb/m³" ] + } + ] + }, + { + "SingularName": "PoundPerCubicCentimeter", + "PluralName": "PoundsPerCubicCentimeter", + "BaseUnits": { + "L": "Centimeter", + "M": "Pound" + }, + "FromUnitToBaseFunc": "x/2.204622621848775e-6", + "FromBaseToUnitFunc": "x*2.204622621848775e-6", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "lb/cm³" ] + } + ] + }, + { + "SingularName": "PoundPerCubicMillimeter", + "PluralName": "PoundsPerCubicMillimeter", + "BaseUnits": { + "L": "Millimeter", + "M": "Pound" + }, + "FromUnitToBaseFunc": "x/2.204622621848775e-9", + "FromBaseToUnitFunc": "x*2.204622621848775e-9", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "lb/mm³" ] + } + ] + }, + { + "SingularName": "SlugPerCubicMeter", + "PluralName": "SlugsPerCubicMeter", + "BaseUnits": { + "L": "Meter", + "M": "Slug" + }, + "FromUnitToBaseFunc": "x*14.5939", + "FromBaseToUnitFunc": "x/14.5939", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "slug/m³" ] + } + ] + }, + { + "SingularName": "SlugPerCubicCentimeter", + "PluralName": "SlugsPerCubicCentimeter", + "BaseUnits": { + "L": "Centimeter", + "M": "Slug" + }, + "FromUnitToBaseFunc": "x*14593903", + "FromBaseToUnitFunc": "x/14593903", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "slug/cm³" ] + } + ] + }, + { + "SingularName": "SlugPerCubicMillimeter", + "PluralName": "SlugsPerCubicMillimeter", + "BaseUnits": { + "L": "Millimeter", + "M": "Slug" + }, + "FromUnitToBaseFunc": "x*14593903000", + "FromBaseToUnitFunc": "x/14593903000", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "slug/mm³" ] + } + ] + }, + { + "SingularName": "SlugPerCubicInch", + "PluralName": "SlugsPerCubicInch", + "BaseUnits": { + "L": "Inch", + "M": "Slug" + }, + "FromUnitToBaseFunc": "x*890574.60201535", + "FromBaseToUnitFunc": "x/890574.60201535", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "slug/in³" ] + } + ] } ] } diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToDensityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToDensityExtensionsTest.g.cs index a21dc146e9..8857f33283 100644 --- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToDensityExtensionsTest.g.cs +++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToDensityExtensionsTest.g.cs @@ -52,6 +52,14 @@ public void NumberToDecigramsPerMilliliterTest() => public void NumberToGramsPerCubicCentimeterTest() => Assert.Equal(Density.FromGramsPerCubicCentimeter(2), 2.GramsPerCubicCentimeter()); + [Fact] + public void NumberToGramsPerCubicFootTest() => + Assert.Equal(Density.FromGramsPerCubicFoot(2), 2.GramsPerCubicFoot()); + + [Fact] + public void NumberToGramsPerCubicInchTest() => + Assert.Equal(Density.FromGramsPerCubicInch(2), 2.GramsPerCubicInch()); + [Fact] public void NumberToGramsPerCubicMeterTest() => Assert.Equal(Density.FromGramsPerCubicMeter(2), 2.GramsPerCubicMeter()); @@ -152,6 +160,10 @@ public void NumberToPicogramsPerLiterTest() => public void NumberToPicogramsPerMilliliterTest() => Assert.Equal(Density.FromPicogramsPerMilliliter(2), 2.PicogramsPerMilliliter()); + [Fact] + public void NumberToPoundsPerCubicCentimeterTest() => + Assert.Equal(Density.FromPoundsPerCubicCentimeter(2), 2.PoundsPerCubicCentimeter()); + [Fact] public void NumberToPoundsPerCubicFootTest() => Assert.Equal(Density.FromPoundsPerCubicFoot(2), 2.PoundsPerCubicFoot()); @@ -160,6 +172,14 @@ public void NumberToPoundsPerCubicFootTest() => public void NumberToPoundsPerCubicInchTest() => Assert.Equal(Density.FromPoundsPerCubicInch(2), 2.PoundsPerCubicInch()); + [Fact] + public void NumberToPoundsPerCubicMeterTest() => + Assert.Equal(Density.FromPoundsPerCubicMeter(2), 2.PoundsPerCubicMeter()); + + [Fact] + public void NumberToPoundsPerCubicMillimeterTest() => + Assert.Equal(Density.FromPoundsPerCubicMillimeter(2), 2.PoundsPerCubicMillimeter()); + [Fact] public void NumberToPoundsPerImperialGallonTest() => Assert.Equal(Density.FromPoundsPerImperialGallon(2), 2.PoundsPerImperialGallon()); @@ -168,14 +188,38 @@ public void NumberToPoundsPerImperialGallonTest() => public void NumberToPoundsPerUSGallonTest() => Assert.Equal(Density.FromPoundsPerUSGallon(2), 2.PoundsPerUSGallon()); + [Fact] + public void NumberToSlugsPerCubicCentimeterTest() => + Assert.Equal(Density.FromSlugsPerCubicCentimeter(2), 2.SlugsPerCubicCentimeter()); + [Fact] public void NumberToSlugsPerCubicFootTest() => Assert.Equal(Density.FromSlugsPerCubicFoot(2), 2.SlugsPerCubicFoot()); + [Fact] + public void NumberToSlugsPerCubicInchTest() => + Assert.Equal(Density.FromSlugsPerCubicInch(2), 2.SlugsPerCubicInch()); + + [Fact] + public void NumberToSlugsPerCubicMeterTest() => + Assert.Equal(Density.FromSlugsPerCubicMeter(2), 2.SlugsPerCubicMeter()); + + [Fact] + public void NumberToSlugsPerCubicMillimeterTest() => + Assert.Equal(Density.FromSlugsPerCubicMillimeter(2), 2.SlugsPerCubicMillimeter()); + [Fact] public void NumberToTonnesPerCubicCentimeterTest() => Assert.Equal(Density.FromTonnesPerCubicCentimeter(2), 2.TonnesPerCubicCentimeter()); + [Fact] + public void NumberToTonnesPerCubicFootTest() => + Assert.Equal(Density.FromTonnesPerCubicFoot(2), 2.TonnesPerCubicFoot()); + + [Fact] + public void NumberToTonnesPerCubicInchTest() => + Assert.Equal(Density.FromTonnesPerCubicInch(2), 2.TonnesPerCubicInch()); + [Fact] public void NumberToTonnesPerCubicMeterTest() => Assert.Equal(Density.FromTonnesPerCubicMeter(2), 2.TonnesPerCubicMeter()); diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToDensityExtensions.g.cs index 9a685e0f85..ca8e02308b 100644 --- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToDensityExtensions.g.cs +++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToDensityExtensions.g.cs @@ -56,6 +56,14 @@ public static Density DecigramsPerMilliliter(this T value) => public static Density GramsPerCubicCentimeter(this T value) => Density.FromGramsPerCubicCentimeter(Convert.ToDouble(value)); + /// + public static Density GramsPerCubicFoot(this T value) => + Density.FromGramsPerCubicFoot(Convert.ToDouble(value)); + + /// + public static Density GramsPerCubicInch(this T value) => + Density.FromGramsPerCubicInch(Convert.ToDouble(value)); + /// public static Density GramsPerCubicMeter(this T value) => Density.FromGramsPerCubicMeter(Convert.ToDouble(value)); @@ -156,6 +164,10 @@ public static Density PicogramsPerLiter(this T value) => public static Density PicogramsPerMilliliter(this T value) => Density.FromPicogramsPerMilliliter(Convert.ToDouble(value)); + /// + public static Density PoundsPerCubicCentimeter(this T value) => + Density.FromPoundsPerCubicCentimeter(Convert.ToDouble(value)); + /// public static Density PoundsPerCubicFoot(this T value) => Density.FromPoundsPerCubicFoot(Convert.ToDouble(value)); @@ -164,6 +176,14 @@ public static Density PoundsPerCubicFoot(this T value) => public static Density PoundsPerCubicInch(this T value) => Density.FromPoundsPerCubicInch(Convert.ToDouble(value)); + /// + public static Density PoundsPerCubicMeter(this T value) => + Density.FromPoundsPerCubicMeter(Convert.ToDouble(value)); + + /// + public static Density PoundsPerCubicMillimeter(this T value) => + Density.FromPoundsPerCubicMillimeter(Convert.ToDouble(value)); + /// public static Density PoundsPerImperialGallon(this T value) => Density.FromPoundsPerImperialGallon(Convert.ToDouble(value)); @@ -172,14 +192,38 @@ public static Density PoundsPerImperialGallon(this T value) => public static Density PoundsPerUSGallon(this T value) => Density.FromPoundsPerUSGallon(Convert.ToDouble(value)); + /// + public static Density SlugsPerCubicCentimeter(this T value) => + Density.FromSlugsPerCubicCentimeter(Convert.ToDouble(value)); + /// public static Density SlugsPerCubicFoot(this T value) => Density.FromSlugsPerCubicFoot(Convert.ToDouble(value)); + /// + public static Density SlugsPerCubicInch(this T value) => + Density.FromSlugsPerCubicInch(Convert.ToDouble(value)); + + /// + public static Density SlugsPerCubicMeter(this T value) => + Density.FromSlugsPerCubicMeter(Convert.ToDouble(value)); + + /// + public static Density SlugsPerCubicMillimeter(this T value) => + Density.FromSlugsPerCubicMillimeter(Convert.ToDouble(value)); + /// public static Density TonnesPerCubicCentimeter(this T value) => Density.FromTonnesPerCubicCentimeter(Convert.ToDouble(value)); + /// + public static Density TonnesPerCubicFoot(this T value) => + Density.FromTonnesPerCubicFoot(Convert.ToDouble(value)); + + /// + public static Density TonnesPerCubicInch(this T value) => + Density.FromTonnesPerCubicInch(Convert.ToDouble(value)); + /// public static Density TonnesPerCubicMeter(this T value) => Density.FromTonnesPerCubicMeter(Convert.ToDouble(value)); diff --git a/UnitsNet.Tests/CustomCode/DensityTests.cs b/UnitsNet.Tests/CustomCode/DensityTests.cs index 8e61cb8225..e9202f65bc 100644 --- a/UnitsNet.Tests/CustomCode/DensityTests.cs +++ b/UnitsNet.Tests/CustomCode/DensityTests.cs @@ -89,6 +89,28 @@ public class DensityTests : DensityTestsBase protected override double KilogramsPerLiterInOneKilogramPerCubicMeter => 1e-3; + protected override double TonnesPerCubicFootInOneKilogramPerCubicMeter => 2.8316846591999996e-05; + + protected override double TonnesPerCubicInchInOneKilogramPerCubicMeter => 1.6387063999999997e-08; + + protected override double GramsPerCubicFootInOneKilogramPerCubicMeter => 28.316846591999994; + + protected override double GramsPerCubicInchInOneKilogramPerCubicMeter => 0.016387063999999996; + + protected override double PoundsPerCubicMeterInOneKilogramPerCubicMeter => 2.204622621848775; + + protected override double PoundsPerCubicCentimeterInOneKilogramPerCubicMeter => 2.204622621848775e-6; + + protected override double PoundsPerCubicMillimeterInOneKilogramPerCubicMeter => 2.204622621848775e-9; + + protected override double SlugsPerCubicMeterInOneKilogramPerCubicMeter => 0.068521765561961; + + protected override double SlugsPerCubicCentimeterInOneKilogramPerCubicMeter => 6.8521765561961e-8; + + protected override double SlugsPerCubicMillimeterInOneKilogramPerCubicMeter => 6.8521765561961e-11; + + protected override double SlugsPerCubicInchInOneKilogramPerCubicMeter => 1.1228705576569e-6; + [Fact] public static void DensityTimesVolumeEqualsMass() { diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/DensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/DensityTestsBase.g.cs index f37285aba0..b7bc23a8f1 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/DensityTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/DensityTestsBase.g.cs @@ -44,6 +44,8 @@ public abstract partial class DensityTestsBase : QuantityTestsBase protected abstract double DecigramsPerLiterInOneKilogramPerCubicMeter { get; } protected abstract double DecigramsPerMilliliterInOneKilogramPerCubicMeter { get; } protected abstract double GramsPerCubicCentimeterInOneKilogramPerCubicMeter { get; } + protected abstract double GramsPerCubicFootInOneKilogramPerCubicMeter { get; } + protected abstract double GramsPerCubicInchInOneKilogramPerCubicMeter { get; } protected abstract double GramsPerCubicMeterInOneKilogramPerCubicMeter { get; } protected abstract double GramsPerCubicMillimeterInOneKilogramPerCubicMeter { get; } protected abstract double GramsPerDeciLiterInOneKilogramPerCubicMeter { get; } @@ -69,12 +71,21 @@ public abstract partial class DensityTestsBase : QuantityTestsBase protected abstract double PicogramsPerDeciLiterInOneKilogramPerCubicMeter { get; } protected abstract double PicogramsPerLiterInOneKilogramPerCubicMeter { get; } protected abstract double PicogramsPerMilliliterInOneKilogramPerCubicMeter { get; } + protected abstract double PoundsPerCubicCentimeterInOneKilogramPerCubicMeter { get; } protected abstract double PoundsPerCubicFootInOneKilogramPerCubicMeter { get; } protected abstract double PoundsPerCubicInchInOneKilogramPerCubicMeter { get; } + protected abstract double PoundsPerCubicMeterInOneKilogramPerCubicMeter { get; } + protected abstract double PoundsPerCubicMillimeterInOneKilogramPerCubicMeter { get; } protected abstract double PoundsPerImperialGallonInOneKilogramPerCubicMeter { get; } protected abstract double PoundsPerUSGallonInOneKilogramPerCubicMeter { get; } + protected abstract double SlugsPerCubicCentimeterInOneKilogramPerCubicMeter { get; } protected abstract double SlugsPerCubicFootInOneKilogramPerCubicMeter { get; } + protected abstract double SlugsPerCubicInchInOneKilogramPerCubicMeter { get; } + protected abstract double SlugsPerCubicMeterInOneKilogramPerCubicMeter { get; } + protected abstract double SlugsPerCubicMillimeterInOneKilogramPerCubicMeter { get; } protected abstract double TonnesPerCubicCentimeterInOneKilogramPerCubicMeter { get; } + protected abstract double TonnesPerCubicFootInOneKilogramPerCubicMeter { get; } + protected abstract double TonnesPerCubicInchInOneKilogramPerCubicMeter { get; } protected abstract double TonnesPerCubicMeterInOneKilogramPerCubicMeter { get; } protected abstract double TonnesPerCubicMillimeterInOneKilogramPerCubicMeter { get; } @@ -86,6 +97,8 @@ public abstract partial class DensityTestsBase : QuantityTestsBase protected virtual double DecigramsPerLiterTolerance { get { return 1e-5; } } protected virtual double DecigramsPerMilliliterTolerance { get { return 1e-5; } } protected virtual double GramsPerCubicCentimeterTolerance { get { return 1e-5; } } + protected virtual double GramsPerCubicFootTolerance { get { return 1e-5; } } + protected virtual double GramsPerCubicInchTolerance { get { return 1e-5; } } protected virtual double GramsPerCubicMeterTolerance { get { return 1e-5; } } protected virtual double GramsPerCubicMillimeterTolerance { get { return 1e-5; } } protected virtual double GramsPerDeciLiterTolerance { get { return 1e-5; } } @@ -111,12 +124,21 @@ public abstract partial class DensityTestsBase : QuantityTestsBase protected virtual double PicogramsPerDeciLiterTolerance { get { return 1e-5; } } protected virtual double PicogramsPerLiterTolerance { get { return 1e-5; } } protected virtual double PicogramsPerMilliliterTolerance { get { return 1e-5; } } + protected virtual double PoundsPerCubicCentimeterTolerance { get { return 1e-5; } } protected virtual double PoundsPerCubicFootTolerance { get { return 1e-5; } } protected virtual double PoundsPerCubicInchTolerance { get { return 1e-5; } } + protected virtual double PoundsPerCubicMeterTolerance { get { return 1e-5; } } + protected virtual double PoundsPerCubicMillimeterTolerance { get { return 1e-5; } } protected virtual double PoundsPerImperialGallonTolerance { get { return 1e-5; } } protected virtual double PoundsPerUSGallonTolerance { get { return 1e-5; } } + protected virtual double SlugsPerCubicCentimeterTolerance { get { return 1e-5; } } protected virtual double SlugsPerCubicFootTolerance { get { return 1e-5; } } + protected virtual double SlugsPerCubicInchTolerance { get { return 1e-5; } } + protected virtual double SlugsPerCubicMeterTolerance { get { return 1e-5; } } + protected virtual double SlugsPerCubicMillimeterTolerance { get { return 1e-5; } } protected virtual double TonnesPerCubicCentimeterTolerance { get { return 1e-5; } } + protected virtual double TonnesPerCubicFootTolerance { get { return 1e-5; } } + protected virtual double TonnesPerCubicInchTolerance { get { return 1e-5; } } protected virtual double TonnesPerCubicMeterTolerance { get { return 1e-5; } } protected virtual double TonnesPerCubicMillimeterTolerance { get { return 1e-5; } } // ReSharper restore VirtualMemberNeverOverriden.Global @@ -200,6 +222,8 @@ public void KilogramPerCubicMeterToDensityUnits() AssertEx.EqualTolerance(DecigramsPerLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.DecigramsPerLiter, DecigramsPerLiterTolerance); AssertEx.EqualTolerance(DecigramsPerMilliliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.DecigramsPerMilliliter, DecigramsPerMilliliterTolerance); AssertEx.EqualTolerance(GramsPerCubicCentimeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.GramsPerCubicCentimeter, GramsPerCubicCentimeterTolerance); + AssertEx.EqualTolerance(GramsPerCubicFootInOneKilogramPerCubicMeter, kilogrampercubicmeter.GramsPerCubicFoot, GramsPerCubicFootTolerance); + AssertEx.EqualTolerance(GramsPerCubicInchInOneKilogramPerCubicMeter, kilogrampercubicmeter.GramsPerCubicInch, GramsPerCubicInchTolerance); AssertEx.EqualTolerance(GramsPerCubicMeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.GramsPerCubicMeter, GramsPerCubicMeterTolerance); AssertEx.EqualTolerance(GramsPerCubicMillimeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.GramsPerCubicMillimeter, GramsPerCubicMillimeterTolerance); AssertEx.EqualTolerance(GramsPerDeciLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.GramsPerDeciLiter, GramsPerDeciLiterTolerance); @@ -225,12 +249,21 @@ public void KilogramPerCubicMeterToDensityUnits() AssertEx.EqualTolerance(PicogramsPerDeciLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.PicogramsPerDeciLiter, PicogramsPerDeciLiterTolerance); AssertEx.EqualTolerance(PicogramsPerLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.PicogramsPerLiter, PicogramsPerLiterTolerance); AssertEx.EqualTolerance(PicogramsPerMilliliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.PicogramsPerMilliliter, PicogramsPerMilliliterTolerance); + AssertEx.EqualTolerance(PoundsPerCubicCentimeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.PoundsPerCubicCentimeter, PoundsPerCubicCentimeterTolerance); AssertEx.EqualTolerance(PoundsPerCubicFootInOneKilogramPerCubicMeter, kilogrampercubicmeter.PoundsPerCubicFoot, PoundsPerCubicFootTolerance); AssertEx.EqualTolerance(PoundsPerCubicInchInOneKilogramPerCubicMeter, kilogrampercubicmeter.PoundsPerCubicInch, PoundsPerCubicInchTolerance); + AssertEx.EqualTolerance(PoundsPerCubicMeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.PoundsPerCubicMeter, PoundsPerCubicMeterTolerance); + AssertEx.EqualTolerance(PoundsPerCubicMillimeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.PoundsPerCubicMillimeter, PoundsPerCubicMillimeterTolerance); AssertEx.EqualTolerance(PoundsPerImperialGallonInOneKilogramPerCubicMeter, kilogrampercubicmeter.PoundsPerImperialGallon, PoundsPerImperialGallonTolerance); AssertEx.EqualTolerance(PoundsPerUSGallonInOneKilogramPerCubicMeter, kilogrampercubicmeter.PoundsPerUSGallon, PoundsPerUSGallonTolerance); + AssertEx.EqualTolerance(SlugsPerCubicCentimeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.SlugsPerCubicCentimeter, SlugsPerCubicCentimeterTolerance); AssertEx.EqualTolerance(SlugsPerCubicFootInOneKilogramPerCubicMeter, kilogrampercubicmeter.SlugsPerCubicFoot, SlugsPerCubicFootTolerance); + AssertEx.EqualTolerance(SlugsPerCubicInchInOneKilogramPerCubicMeter, kilogrampercubicmeter.SlugsPerCubicInch, SlugsPerCubicInchTolerance); + AssertEx.EqualTolerance(SlugsPerCubicMeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.SlugsPerCubicMeter, SlugsPerCubicMeterTolerance); + AssertEx.EqualTolerance(SlugsPerCubicMillimeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.SlugsPerCubicMillimeter, SlugsPerCubicMillimeterTolerance); AssertEx.EqualTolerance(TonnesPerCubicCentimeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.TonnesPerCubicCentimeter, TonnesPerCubicCentimeterTolerance); + AssertEx.EqualTolerance(TonnesPerCubicFootInOneKilogramPerCubicMeter, kilogrampercubicmeter.TonnesPerCubicFoot, TonnesPerCubicFootTolerance); + AssertEx.EqualTolerance(TonnesPerCubicInchInOneKilogramPerCubicMeter, kilogrampercubicmeter.TonnesPerCubicInch, TonnesPerCubicInchTolerance); AssertEx.EqualTolerance(TonnesPerCubicMeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.TonnesPerCubicMeter, TonnesPerCubicMeterTolerance); AssertEx.EqualTolerance(TonnesPerCubicMillimeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.TonnesPerCubicMillimeter, TonnesPerCubicMillimeterTolerance); } @@ -266,137 +299,181 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() AssertEx.EqualTolerance(1, quantity06.GramsPerCubicCentimeter, GramsPerCubicCentimeterTolerance); Assert.Equal(DensityUnit.GramPerCubicCentimeter, quantity06.Unit); - var quantity07 = Density.From(1, DensityUnit.GramPerCubicMeter); - AssertEx.EqualTolerance(1, quantity07.GramsPerCubicMeter, GramsPerCubicMeterTolerance); - Assert.Equal(DensityUnit.GramPerCubicMeter, quantity07.Unit); + var quantity07 = Density.From(1, DensityUnit.GramPerCubicFoot); + AssertEx.EqualTolerance(1, quantity07.GramsPerCubicFoot, GramsPerCubicFootTolerance); + Assert.Equal(DensityUnit.GramPerCubicFoot, quantity07.Unit); - var quantity08 = Density.From(1, DensityUnit.GramPerCubicMillimeter); - AssertEx.EqualTolerance(1, quantity08.GramsPerCubicMillimeter, GramsPerCubicMillimeterTolerance); - Assert.Equal(DensityUnit.GramPerCubicMillimeter, quantity08.Unit); + var quantity08 = Density.From(1, DensityUnit.GramPerCubicInch); + AssertEx.EqualTolerance(1, quantity08.GramsPerCubicInch, GramsPerCubicInchTolerance); + Assert.Equal(DensityUnit.GramPerCubicInch, quantity08.Unit); - var quantity09 = Density.From(1, DensityUnit.GramPerDeciliter); - AssertEx.EqualTolerance(1, quantity09.GramsPerDeciLiter, GramsPerDeciLiterTolerance); - Assert.Equal(DensityUnit.GramPerDeciliter, quantity09.Unit); + var quantity09 = Density.From(1, DensityUnit.GramPerCubicMeter); + AssertEx.EqualTolerance(1, quantity09.GramsPerCubicMeter, GramsPerCubicMeterTolerance); + Assert.Equal(DensityUnit.GramPerCubicMeter, quantity09.Unit); - var quantity10 = Density.From(1, DensityUnit.GramPerLiter); - AssertEx.EqualTolerance(1, quantity10.GramsPerLiter, GramsPerLiterTolerance); - Assert.Equal(DensityUnit.GramPerLiter, quantity10.Unit); + var quantity10 = Density.From(1, DensityUnit.GramPerCubicMillimeter); + AssertEx.EqualTolerance(1, quantity10.GramsPerCubicMillimeter, GramsPerCubicMillimeterTolerance); + Assert.Equal(DensityUnit.GramPerCubicMillimeter, quantity10.Unit); - var quantity11 = Density.From(1, DensityUnit.GramPerMilliliter); - AssertEx.EqualTolerance(1, quantity11.GramsPerMilliliter, GramsPerMilliliterTolerance); - Assert.Equal(DensityUnit.GramPerMilliliter, quantity11.Unit); + var quantity11 = Density.From(1, DensityUnit.GramPerDeciliter); + AssertEx.EqualTolerance(1, quantity11.GramsPerDeciLiter, GramsPerDeciLiterTolerance); + Assert.Equal(DensityUnit.GramPerDeciliter, quantity11.Unit); - var quantity12 = Density.From(1, DensityUnit.KilogramPerCubicCentimeter); - AssertEx.EqualTolerance(1, quantity12.KilogramsPerCubicCentimeter, KilogramsPerCubicCentimeterTolerance); - Assert.Equal(DensityUnit.KilogramPerCubicCentimeter, quantity12.Unit); + var quantity12 = Density.From(1, DensityUnit.GramPerLiter); + AssertEx.EqualTolerance(1, quantity12.GramsPerLiter, GramsPerLiterTolerance); + Assert.Equal(DensityUnit.GramPerLiter, quantity12.Unit); - var quantity13 = Density.From(1, DensityUnit.KilogramPerCubicMeter); - AssertEx.EqualTolerance(1, quantity13.KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance); - Assert.Equal(DensityUnit.KilogramPerCubicMeter, quantity13.Unit); + var quantity13 = Density.From(1, DensityUnit.GramPerMilliliter); + AssertEx.EqualTolerance(1, quantity13.GramsPerMilliliter, GramsPerMilliliterTolerance); + Assert.Equal(DensityUnit.GramPerMilliliter, quantity13.Unit); - var quantity14 = Density.From(1, DensityUnit.KilogramPerCubicMillimeter); - AssertEx.EqualTolerance(1, quantity14.KilogramsPerCubicMillimeter, KilogramsPerCubicMillimeterTolerance); - Assert.Equal(DensityUnit.KilogramPerCubicMillimeter, quantity14.Unit); + var quantity14 = Density.From(1, DensityUnit.KilogramPerCubicCentimeter); + AssertEx.EqualTolerance(1, quantity14.KilogramsPerCubicCentimeter, KilogramsPerCubicCentimeterTolerance); + Assert.Equal(DensityUnit.KilogramPerCubicCentimeter, quantity14.Unit); - var quantity15 = Density.From(1, DensityUnit.KilogramPerLiter); - AssertEx.EqualTolerance(1, quantity15.KilogramsPerLiter, KilogramsPerLiterTolerance); - Assert.Equal(DensityUnit.KilogramPerLiter, quantity15.Unit); + var quantity15 = Density.From(1, DensityUnit.KilogramPerCubicMeter); + AssertEx.EqualTolerance(1, quantity15.KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance); + Assert.Equal(DensityUnit.KilogramPerCubicMeter, quantity15.Unit); - var quantity16 = Density.From(1, DensityUnit.KilopoundPerCubicFoot); - AssertEx.EqualTolerance(1, quantity16.KilopoundsPerCubicFoot, KilopoundsPerCubicFootTolerance); - Assert.Equal(DensityUnit.KilopoundPerCubicFoot, quantity16.Unit); + var quantity16 = Density.From(1, DensityUnit.KilogramPerCubicMillimeter); + AssertEx.EqualTolerance(1, quantity16.KilogramsPerCubicMillimeter, KilogramsPerCubicMillimeterTolerance); + Assert.Equal(DensityUnit.KilogramPerCubicMillimeter, quantity16.Unit); - var quantity17 = Density.From(1, DensityUnit.KilopoundPerCubicInch); - AssertEx.EqualTolerance(1, quantity17.KilopoundsPerCubicInch, KilopoundsPerCubicInchTolerance); - Assert.Equal(DensityUnit.KilopoundPerCubicInch, quantity17.Unit); + var quantity17 = Density.From(1, DensityUnit.KilogramPerLiter); + AssertEx.EqualTolerance(1, quantity17.KilogramsPerLiter, KilogramsPerLiterTolerance); + Assert.Equal(DensityUnit.KilogramPerLiter, quantity17.Unit); - var quantity18 = Density.From(1, DensityUnit.MicrogramPerCubicMeter); - AssertEx.EqualTolerance(1, quantity18.MicrogramsPerCubicMeter, MicrogramsPerCubicMeterTolerance); - Assert.Equal(DensityUnit.MicrogramPerCubicMeter, quantity18.Unit); + var quantity18 = Density.From(1, DensityUnit.KilopoundPerCubicFoot); + AssertEx.EqualTolerance(1, quantity18.KilopoundsPerCubicFoot, KilopoundsPerCubicFootTolerance); + Assert.Equal(DensityUnit.KilopoundPerCubicFoot, quantity18.Unit); - var quantity19 = Density.From(1, DensityUnit.MicrogramPerDeciliter); - AssertEx.EqualTolerance(1, quantity19.MicrogramsPerDeciLiter, MicrogramsPerDeciLiterTolerance); - Assert.Equal(DensityUnit.MicrogramPerDeciliter, quantity19.Unit); + var quantity19 = Density.From(1, DensityUnit.KilopoundPerCubicInch); + AssertEx.EqualTolerance(1, quantity19.KilopoundsPerCubicInch, KilopoundsPerCubicInchTolerance); + Assert.Equal(DensityUnit.KilopoundPerCubicInch, quantity19.Unit); - var quantity20 = Density.From(1, DensityUnit.MicrogramPerLiter); - AssertEx.EqualTolerance(1, quantity20.MicrogramsPerLiter, MicrogramsPerLiterTolerance); - Assert.Equal(DensityUnit.MicrogramPerLiter, quantity20.Unit); + var quantity20 = Density.From(1, DensityUnit.MicrogramPerCubicMeter); + AssertEx.EqualTolerance(1, quantity20.MicrogramsPerCubicMeter, MicrogramsPerCubicMeterTolerance); + Assert.Equal(DensityUnit.MicrogramPerCubicMeter, quantity20.Unit); - var quantity21 = Density.From(1, DensityUnit.MicrogramPerMilliliter); - AssertEx.EqualTolerance(1, quantity21.MicrogramsPerMilliliter, MicrogramsPerMilliliterTolerance); - Assert.Equal(DensityUnit.MicrogramPerMilliliter, quantity21.Unit); + var quantity21 = Density.From(1, DensityUnit.MicrogramPerDeciliter); + AssertEx.EqualTolerance(1, quantity21.MicrogramsPerDeciLiter, MicrogramsPerDeciLiterTolerance); + Assert.Equal(DensityUnit.MicrogramPerDeciliter, quantity21.Unit); - var quantity22 = Density.From(1, DensityUnit.MilligramPerCubicMeter); - AssertEx.EqualTolerance(1, quantity22.MilligramsPerCubicMeter, MilligramsPerCubicMeterTolerance); - Assert.Equal(DensityUnit.MilligramPerCubicMeter, quantity22.Unit); + var quantity22 = Density.From(1, DensityUnit.MicrogramPerLiter); + AssertEx.EqualTolerance(1, quantity22.MicrogramsPerLiter, MicrogramsPerLiterTolerance); + Assert.Equal(DensityUnit.MicrogramPerLiter, quantity22.Unit); - var quantity23 = Density.From(1, DensityUnit.MilligramPerDeciliter); - AssertEx.EqualTolerance(1, quantity23.MilligramsPerDeciLiter, MilligramsPerDeciLiterTolerance); - Assert.Equal(DensityUnit.MilligramPerDeciliter, quantity23.Unit); + var quantity23 = Density.From(1, DensityUnit.MicrogramPerMilliliter); + AssertEx.EqualTolerance(1, quantity23.MicrogramsPerMilliliter, MicrogramsPerMilliliterTolerance); + Assert.Equal(DensityUnit.MicrogramPerMilliliter, quantity23.Unit); - var quantity24 = Density.From(1, DensityUnit.MilligramPerLiter); - AssertEx.EqualTolerance(1, quantity24.MilligramsPerLiter, MilligramsPerLiterTolerance); - Assert.Equal(DensityUnit.MilligramPerLiter, quantity24.Unit); + var quantity24 = Density.From(1, DensityUnit.MilligramPerCubicMeter); + AssertEx.EqualTolerance(1, quantity24.MilligramsPerCubicMeter, MilligramsPerCubicMeterTolerance); + Assert.Equal(DensityUnit.MilligramPerCubicMeter, quantity24.Unit); - var quantity25 = Density.From(1, DensityUnit.MilligramPerMilliliter); - AssertEx.EqualTolerance(1, quantity25.MilligramsPerMilliliter, MilligramsPerMilliliterTolerance); - Assert.Equal(DensityUnit.MilligramPerMilliliter, quantity25.Unit); + var quantity25 = Density.From(1, DensityUnit.MilligramPerDeciliter); + AssertEx.EqualTolerance(1, quantity25.MilligramsPerDeciLiter, MilligramsPerDeciLiterTolerance); + Assert.Equal(DensityUnit.MilligramPerDeciliter, quantity25.Unit); - var quantity26 = Density.From(1, DensityUnit.NanogramPerDeciliter); - AssertEx.EqualTolerance(1, quantity26.NanogramsPerDeciLiter, NanogramsPerDeciLiterTolerance); - Assert.Equal(DensityUnit.NanogramPerDeciliter, quantity26.Unit); + var quantity26 = Density.From(1, DensityUnit.MilligramPerLiter); + AssertEx.EqualTolerance(1, quantity26.MilligramsPerLiter, MilligramsPerLiterTolerance); + Assert.Equal(DensityUnit.MilligramPerLiter, quantity26.Unit); - var quantity27 = Density.From(1, DensityUnit.NanogramPerLiter); - AssertEx.EqualTolerance(1, quantity27.NanogramsPerLiter, NanogramsPerLiterTolerance); - Assert.Equal(DensityUnit.NanogramPerLiter, quantity27.Unit); + var quantity27 = Density.From(1, DensityUnit.MilligramPerMilliliter); + AssertEx.EqualTolerance(1, quantity27.MilligramsPerMilliliter, MilligramsPerMilliliterTolerance); + Assert.Equal(DensityUnit.MilligramPerMilliliter, quantity27.Unit); - var quantity28 = Density.From(1, DensityUnit.NanogramPerMilliliter); - AssertEx.EqualTolerance(1, quantity28.NanogramsPerMilliliter, NanogramsPerMilliliterTolerance); - Assert.Equal(DensityUnit.NanogramPerMilliliter, quantity28.Unit); + var quantity28 = Density.From(1, DensityUnit.NanogramPerDeciliter); + AssertEx.EqualTolerance(1, quantity28.NanogramsPerDeciLiter, NanogramsPerDeciLiterTolerance); + Assert.Equal(DensityUnit.NanogramPerDeciliter, quantity28.Unit); - var quantity29 = Density.From(1, DensityUnit.PicogramPerDeciliter); - AssertEx.EqualTolerance(1, quantity29.PicogramsPerDeciLiter, PicogramsPerDeciLiterTolerance); - Assert.Equal(DensityUnit.PicogramPerDeciliter, quantity29.Unit); + var quantity29 = Density.From(1, DensityUnit.NanogramPerLiter); + AssertEx.EqualTolerance(1, quantity29.NanogramsPerLiter, NanogramsPerLiterTolerance); + Assert.Equal(DensityUnit.NanogramPerLiter, quantity29.Unit); - var quantity30 = Density.From(1, DensityUnit.PicogramPerLiter); - AssertEx.EqualTolerance(1, quantity30.PicogramsPerLiter, PicogramsPerLiterTolerance); - Assert.Equal(DensityUnit.PicogramPerLiter, quantity30.Unit); + var quantity30 = Density.From(1, DensityUnit.NanogramPerMilliliter); + AssertEx.EqualTolerance(1, quantity30.NanogramsPerMilliliter, NanogramsPerMilliliterTolerance); + Assert.Equal(DensityUnit.NanogramPerMilliliter, quantity30.Unit); - var quantity31 = Density.From(1, DensityUnit.PicogramPerMilliliter); - AssertEx.EqualTolerance(1, quantity31.PicogramsPerMilliliter, PicogramsPerMilliliterTolerance); - Assert.Equal(DensityUnit.PicogramPerMilliliter, quantity31.Unit); + var quantity31 = Density.From(1, DensityUnit.PicogramPerDeciliter); + AssertEx.EqualTolerance(1, quantity31.PicogramsPerDeciLiter, PicogramsPerDeciLiterTolerance); + Assert.Equal(DensityUnit.PicogramPerDeciliter, quantity31.Unit); - var quantity32 = Density.From(1, DensityUnit.PoundPerCubicFoot); - AssertEx.EqualTolerance(1, quantity32.PoundsPerCubicFoot, PoundsPerCubicFootTolerance); - Assert.Equal(DensityUnit.PoundPerCubicFoot, quantity32.Unit); + var quantity32 = Density.From(1, DensityUnit.PicogramPerLiter); + AssertEx.EqualTolerance(1, quantity32.PicogramsPerLiter, PicogramsPerLiterTolerance); + Assert.Equal(DensityUnit.PicogramPerLiter, quantity32.Unit); - var quantity33 = Density.From(1, DensityUnit.PoundPerCubicInch); - AssertEx.EqualTolerance(1, quantity33.PoundsPerCubicInch, PoundsPerCubicInchTolerance); - Assert.Equal(DensityUnit.PoundPerCubicInch, quantity33.Unit); + var quantity33 = Density.From(1, DensityUnit.PicogramPerMilliliter); + AssertEx.EqualTolerance(1, quantity33.PicogramsPerMilliliter, PicogramsPerMilliliterTolerance); + Assert.Equal(DensityUnit.PicogramPerMilliliter, quantity33.Unit); - var quantity34 = Density.From(1, DensityUnit.PoundPerImperialGallon); - AssertEx.EqualTolerance(1, quantity34.PoundsPerImperialGallon, PoundsPerImperialGallonTolerance); - Assert.Equal(DensityUnit.PoundPerImperialGallon, quantity34.Unit); + var quantity34 = Density.From(1, DensityUnit.PoundPerCubicCentimeter); + AssertEx.EqualTolerance(1, quantity34.PoundsPerCubicCentimeter, PoundsPerCubicCentimeterTolerance); + Assert.Equal(DensityUnit.PoundPerCubicCentimeter, quantity34.Unit); - var quantity35 = Density.From(1, DensityUnit.PoundPerUSGallon); - AssertEx.EqualTolerance(1, quantity35.PoundsPerUSGallon, PoundsPerUSGallonTolerance); - Assert.Equal(DensityUnit.PoundPerUSGallon, quantity35.Unit); + var quantity35 = Density.From(1, DensityUnit.PoundPerCubicFoot); + AssertEx.EqualTolerance(1, quantity35.PoundsPerCubicFoot, PoundsPerCubicFootTolerance); + Assert.Equal(DensityUnit.PoundPerCubicFoot, quantity35.Unit); - var quantity36 = Density.From(1, DensityUnit.SlugPerCubicFoot); - AssertEx.EqualTolerance(1, quantity36.SlugsPerCubicFoot, SlugsPerCubicFootTolerance); - Assert.Equal(DensityUnit.SlugPerCubicFoot, quantity36.Unit); + var quantity36 = Density.From(1, DensityUnit.PoundPerCubicInch); + AssertEx.EqualTolerance(1, quantity36.PoundsPerCubicInch, PoundsPerCubicInchTolerance); + Assert.Equal(DensityUnit.PoundPerCubicInch, quantity36.Unit); - var quantity37 = Density.From(1, DensityUnit.TonnePerCubicCentimeter); - AssertEx.EqualTolerance(1, quantity37.TonnesPerCubicCentimeter, TonnesPerCubicCentimeterTolerance); - Assert.Equal(DensityUnit.TonnePerCubicCentimeter, quantity37.Unit); + var quantity37 = Density.From(1, DensityUnit.PoundPerCubicMeter); + AssertEx.EqualTolerance(1, quantity37.PoundsPerCubicMeter, PoundsPerCubicMeterTolerance); + Assert.Equal(DensityUnit.PoundPerCubicMeter, quantity37.Unit); - var quantity38 = Density.From(1, DensityUnit.TonnePerCubicMeter); - AssertEx.EqualTolerance(1, quantity38.TonnesPerCubicMeter, TonnesPerCubicMeterTolerance); - Assert.Equal(DensityUnit.TonnePerCubicMeter, quantity38.Unit); + var quantity38 = Density.From(1, DensityUnit.PoundPerCubicMillimeter); + AssertEx.EqualTolerance(1, quantity38.PoundsPerCubicMillimeter, PoundsPerCubicMillimeterTolerance); + Assert.Equal(DensityUnit.PoundPerCubicMillimeter, quantity38.Unit); - var quantity39 = Density.From(1, DensityUnit.TonnePerCubicMillimeter); - AssertEx.EqualTolerance(1, quantity39.TonnesPerCubicMillimeter, TonnesPerCubicMillimeterTolerance); - Assert.Equal(DensityUnit.TonnePerCubicMillimeter, quantity39.Unit); + var quantity39 = Density.From(1, DensityUnit.PoundPerImperialGallon); + AssertEx.EqualTolerance(1, quantity39.PoundsPerImperialGallon, PoundsPerImperialGallonTolerance); + Assert.Equal(DensityUnit.PoundPerImperialGallon, quantity39.Unit); + + var quantity40 = Density.From(1, DensityUnit.PoundPerUSGallon); + AssertEx.EqualTolerance(1, quantity40.PoundsPerUSGallon, PoundsPerUSGallonTolerance); + Assert.Equal(DensityUnit.PoundPerUSGallon, quantity40.Unit); + + var quantity41 = Density.From(1, DensityUnit.SlugPerCubicCentimeter); + AssertEx.EqualTolerance(1, quantity41.SlugsPerCubicCentimeter, SlugsPerCubicCentimeterTolerance); + Assert.Equal(DensityUnit.SlugPerCubicCentimeter, quantity41.Unit); + + var quantity42 = Density.From(1, DensityUnit.SlugPerCubicFoot); + AssertEx.EqualTolerance(1, quantity42.SlugsPerCubicFoot, SlugsPerCubicFootTolerance); + Assert.Equal(DensityUnit.SlugPerCubicFoot, quantity42.Unit); + + var quantity43 = Density.From(1, DensityUnit.SlugPerCubicInch); + AssertEx.EqualTolerance(1, quantity43.SlugsPerCubicInch, SlugsPerCubicInchTolerance); + Assert.Equal(DensityUnit.SlugPerCubicInch, quantity43.Unit); + + var quantity44 = Density.From(1, DensityUnit.SlugPerCubicMeter); + AssertEx.EqualTolerance(1, quantity44.SlugsPerCubicMeter, SlugsPerCubicMeterTolerance); + Assert.Equal(DensityUnit.SlugPerCubicMeter, quantity44.Unit); + + var quantity45 = Density.From(1, DensityUnit.SlugPerCubicMillimeter); + AssertEx.EqualTolerance(1, quantity45.SlugsPerCubicMillimeter, SlugsPerCubicMillimeterTolerance); + Assert.Equal(DensityUnit.SlugPerCubicMillimeter, quantity45.Unit); + + var quantity46 = Density.From(1, DensityUnit.TonnePerCubicCentimeter); + AssertEx.EqualTolerance(1, quantity46.TonnesPerCubicCentimeter, TonnesPerCubicCentimeterTolerance); + Assert.Equal(DensityUnit.TonnePerCubicCentimeter, quantity46.Unit); + + var quantity47 = Density.From(1, DensityUnit.TonnePerCubicFoot); + AssertEx.EqualTolerance(1, quantity47.TonnesPerCubicFoot, TonnesPerCubicFootTolerance); + Assert.Equal(DensityUnit.TonnePerCubicFoot, quantity47.Unit); + + var quantity48 = Density.From(1, DensityUnit.TonnePerCubicInch); + AssertEx.EqualTolerance(1, quantity48.TonnesPerCubicInch, TonnesPerCubicInchTolerance); + Assert.Equal(DensityUnit.TonnePerCubicInch, quantity48.Unit); + + var quantity49 = Density.From(1, DensityUnit.TonnePerCubicMeter); + AssertEx.EqualTolerance(1, quantity49.TonnesPerCubicMeter, TonnesPerCubicMeterTolerance); + Assert.Equal(DensityUnit.TonnePerCubicMeter, quantity49.Unit); + + var quantity50 = Density.From(1, DensityUnit.TonnePerCubicMillimeter); + AssertEx.EqualTolerance(1, quantity50.TonnesPerCubicMillimeter, TonnesPerCubicMillimeterTolerance); + Assert.Equal(DensityUnit.TonnePerCubicMillimeter, quantity50.Unit); } @@ -424,6 +501,8 @@ public void As() AssertEx.EqualTolerance(DecigramsPerLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.DecigramPerLiter), DecigramsPerLiterTolerance); AssertEx.EqualTolerance(DecigramsPerMilliliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.DecigramPerMilliliter), DecigramsPerMilliliterTolerance); AssertEx.EqualTolerance(GramsPerCubicCentimeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.GramPerCubicCentimeter), GramsPerCubicCentimeterTolerance); + AssertEx.EqualTolerance(GramsPerCubicFootInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.GramPerCubicFoot), GramsPerCubicFootTolerance); + AssertEx.EqualTolerance(GramsPerCubicInchInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.GramPerCubicInch), GramsPerCubicInchTolerance); AssertEx.EqualTolerance(GramsPerCubicMeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.GramPerCubicMeter), GramsPerCubicMeterTolerance); AssertEx.EqualTolerance(GramsPerCubicMillimeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.GramPerCubicMillimeter), GramsPerCubicMillimeterTolerance); AssertEx.EqualTolerance(GramsPerDeciLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.GramPerDeciliter), GramsPerDeciLiterTolerance); @@ -449,12 +528,21 @@ public void As() AssertEx.EqualTolerance(PicogramsPerDeciLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.PicogramPerDeciliter), PicogramsPerDeciLiterTolerance); AssertEx.EqualTolerance(PicogramsPerLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.PicogramPerLiter), PicogramsPerLiterTolerance); AssertEx.EqualTolerance(PicogramsPerMilliliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.PicogramPerMilliliter), PicogramsPerMilliliterTolerance); + AssertEx.EqualTolerance(PoundsPerCubicCentimeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.PoundPerCubicCentimeter), PoundsPerCubicCentimeterTolerance); AssertEx.EqualTolerance(PoundsPerCubicFootInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.PoundPerCubicFoot), PoundsPerCubicFootTolerance); AssertEx.EqualTolerance(PoundsPerCubicInchInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.PoundPerCubicInch), PoundsPerCubicInchTolerance); + AssertEx.EqualTolerance(PoundsPerCubicMeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.PoundPerCubicMeter), PoundsPerCubicMeterTolerance); + AssertEx.EqualTolerance(PoundsPerCubicMillimeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.PoundPerCubicMillimeter), PoundsPerCubicMillimeterTolerance); AssertEx.EqualTolerance(PoundsPerImperialGallonInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.PoundPerImperialGallon), PoundsPerImperialGallonTolerance); AssertEx.EqualTolerance(PoundsPerUSGallonInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.PoundPerUSGallon), PoundsPerUSGallonTolerance); + AssertEx.EqualTolerance(SlugsPerCubicCentimeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.SlugPerCubicCentimeter), SlugsPerCubicCentimeterTolerance); AssertEx.EqualTolerance(SlugsPerCubicFootInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.SlugPerCubicFoot), SlugsPerCubicFootTolerance); + AssertEx.EqualTolerance(SlugsPerCubicInchInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.SlugPerCubicInch), SlugsPerCubicInchTolerance); + AssertEx.EqualTolerance(SlugsPerCubicMeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.SlugPerCubicMeter), SlugsPerCubicMeterTolerance); + AssertEx.EqualTolerance(SlugsPerCubicMillimeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.SlugPerCubicMillimeter), SlugsPerCubicMillimeterTolerance); AssertEx.EqualTolerance(TonnesPerCubicCentimeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.TonnePerCubicCentimeter), TonnesPerCubicCentimeterTolerance); + AssertEx.EqualTolerance(TonnesPerCubicFootInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.TonnePerCubicFoot), TonnesPerCubicFootTolerance); + AssertEx.EqualTolerance(TonnesPerCubicInchInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.TonnePerCubicInch), TonnesPerCubicInchTolerance); AssertEx.EqualTolerance(TonnesPerCubicMeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.TonnePerCubicMeter), TonnesPerCubicMeterTolerance); AssertEx.EqualTolerance(TonnesPerCubicMillimeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.TonnePerCubicMillimeter), TonnesPerCubicMillimeterTolerance); } @@ -509,6 +597,14 @@ public void ToUnit() AssertEx.EqualTolerance(GramsPerCubicCentimeterInOneKilogramPerCubicMeter, (double)grampercubiccentimeterQuantity.Value, GramsPerCubicCentimeterTolerance); Assert.Equal(DensityUnit.GramPerCubicCentimeter, grampercubiccentimeterQuantity.Unit); + var grampercubicfootQuantity = kilogrampercubicmeter.ToUnit(DensityUnit.GramPerCubicFoot); + AssertEx.EqualTolerance(GramsPerCubicFootInOneKilogramPerCubicMeter, (double)grampercubicfootQuantity.Value, GramsPerCubicFootTolerance); + Assert.Equal(DensityUnit.GramPerCubicFoot, grampercubicfootQuantity.Unit); + + var grampercubicinchQuantity = kilogrampercubicmeter.ToUnit(DensityUnit.GramPerCubicInch); + AssertEx.EqualTolerance(GramsPerCubicInchInOneKilogramPerCubicMeter, (double)grampercubicinchQuantity.Value, GramsPerCubicInchTolerance); + Assert.Equal(DensityUnit.GramPerCubicInch, grampercubicinchQuantity.Unit); + var grampercubicmeterQuantity = kilogrampercubicmeter.ToUnit(DensityUnit.GramPerCubicMeter); AssertEx.EqualTolerance(GramsPerCubicMeterInOneKilogramPerCubicMeter, (double)grampercubicmeterQuantity.Value, GramsPerCubicMeterTolerance); Assert.Equal(DensityUnit.GramPerCubicMeter, grampercubicmeterQuantity.Unit); @@ -609,6 +705,10 @@ public void ToUnit() AssertEx.EqualTolerance(PicogramsPerMilliliterInOneKilogramPerCubicMeter, (double)picogrampermilliliterQuantity.Value, PicogramsPerMilliliterTolerance); Assert.Equal(DensityUnit.PicogramPerMilliliter, picogrampermilliliterQuantity.Unit); + var poundpercubiccentimeterQuantity = kilogrampercubicmeter.ToUnit(DensityUnit.PoundPerCubicCentimeter); + AssertEx.EqualTolerance(PoundsPerCubicCentimeterInOneKilogramPerCubicMeter, (double)poundpercubiccentimeterQuantity.Value, PoundsPerCubicCentimeterTolerance); + Assert.Equal(DensityUnit.PoundPerCubicCentimeter, poundpercubiccentimeterQuantity.Unit); + var poundpercubicfootQuantity = kilogrampercubicmeter.ToUnit(DensityUnit.PoundPerCubicFoot); AssertEx.EqualTolerance(PoundsPerCubicFootInOneKilogramPerCubicMeter, (double)poundpercubicfootQuantity.Value, PoundsPerCubicFootTolerance); Assert.Equal(DensityUnit.PoundPerCubicFoot, poundpercubicfootQuantity.Unit); @@ -617,6 +717,14 @@ public void ToUnit() AssertEx.EqualTolerance(PoundsPerCubicInchInOneKilogramPerCubicMeter, (double)poundpercubicinchQuantity.Value, PoundsPerCubicInchTolerance); Assert.Equal(DensityUnit.PoundPerCubicInch, poundpercubicinchQuantity.Unit); + var poundpercubicmeterQuantity = kilogrampercubicmeter.ToUnit(DensityUnit.PoundPerCubicMeter); + AssertEx.EqualTolerance(PoundsPerCubicMeterInOneKilogramPerCubicMeter, (double)poundpercubicmeterQuantity.Value, PoundsPerCubicMeterTolerance); + Assert.Equal(DensityUnit.PoundPerCubicMeter, poundpercubicmeterQuantity.Unit); + + var poundpercubicmillimeterQuantity = kilogrampercubicmeter.ToUnit(DensityUnit.PoundPerCubicMillimeter); + AssertEx.EqualTolerance(PoundsPerCubicMillimeterInOneKilogramPerCubicMeter, (double)poundpercubicmillimeterQuantity.Value, PoundsPerCubicMillimeterTolerance); + Assert.Equal(DensityUnit.PoundPerCubicMillimeter, poundpercubicmillimeterQuantity.Unit); + var poundperimperialgallonQuantity = kilogrampercubicmeter.ToUnit(DensityUnit.PoundPerImperialGallon); AssertEx.EqualTolerance(PoundsPerImperialGallonInOneKilogramPerCubicMeter, (double)poundperimperialgallonQuantity.Value, PoundsPerImperialGallonTolerance); Assert.Equal(DensityUnit.PoundPerImperialGallon, poundperimperialgallonQuantity.Unit); @@ -625,14 +733,38 @@ public void ToUnit() AssertEx.EqualTolerance(PoundsPerUSGallonInOneKilogramPerCubicMeter, (double)poundperusgallonQuantity.Value, PoundsPerUSGallonTolerance); Assert.Equal(DensityUnit.PoundPerUSGallon, poundperusgallonQuantity.Unit); + var slugpercubiccentimeterQuantity = kilogrampercubicmeter.ToUnit(DensityUnit.SlugPerCubicCentimeter); + AssertEx.EqualTolerance(SlugsPerCubicCentimeterInOneKilogramPerCubicMeter, (double)slugpercubiccentimeterQuantity.Value, SlugsPerCubicCentimeterTolerance); + Assert.Equal(DensityUnit.SlugPerCubicCentimeter, slugpercubiccentimeterQuantity.Unit); + var slugpercubicfootQuantity = kilogrampercubicmeter.ToUnit(DensityUnit.SlugPerCubicFoot); AssertEx.EqualTolerance(SlugsPerCubicFootInOneKilogramPerCubicMeter, (double)slugpercubicfootQuantity.Value, SlugsPerCubicFootTolerance); Assert.Equal(DensityUnit.SlugPerCubicFoot, slugpercubicfootQuantity.Unit); + var slugpercubicinchQuantity = kilogrampercubicmeter.ToUnit(DensityUnit.SlugPerCubicInch); + AssertEx.EqualTolerance(SlugsPerCubicInchInOneKilogramPerCubicMeter, (double)slugpercubicinchQuantity.Value, SlugsPerCubicInchTolerance); + Assert.Equal(DensityUnit.SlugPerCubicInch, slugpercubicinchQuantity.Unit); + + var slugpercubicmeterQuantity = kilogrampercubicmeter.ToUnit(DensityUnit.SlugPerCubicMeter); + AssertEx.EqualTolerance(SlugsPerCubicMeterInOneKilogramPerCubicMeter, (double)slugpercubicmeterQuantity.Value, SlugsPerCubicMeterTolerance); + Assert.Equal(DensityUnit.SlugPerCubicMeter, slugpercubicmeterQuantity.Unit); + + var slugpercubicmillimeterQuantity = kilogrampercubicmeter.ToUnit(DensityUnit.SlugPerCubicMillimeter); + AssertEx.EqualTolerance(SlugsPerCubicMillimeterInOneKilogramPerCubicMeter, (double)slugpercubicmillimeterQuantity.Value, SlugsPerCubicMillimeterTolerance); + Assert.Equal(DensityUnit.SlugPerCubicMillimeter, slugpercubicmillimeterQuantity.Unit); + var tonnepercubiccentimeterQuantity = kilogrampercubicmeter.ToUnit(DensityUnit.TonnePerCubicCentimeter); AssertEx.EqualTolerance(TonnesPerCubicCentimeterInOneKilogramPerCubicMeter, (double)tonnepercubiccentimeterQuantity.Value, TonnesPerCubicCentimeterTolerance); Assert.Equal(DensityUnit.TonnePerCubicCentimeter, tonnepercubiccentimeterQuantity.Unit); + var tonnepercubicfootQuantity = kilogrampercubicmeter.ToUnit(DensityUnit.TonnePerCubicFoot); + AssertEx.EqualTolerance(TonnesPerCubicFootInOneKilogramPerCubicMeter, (double)tonnepercubicfootQuantity.Value, TonnesPerCubicFootTolerance); + Assert.Equal(DensityUnit.TonnePerCubicFoot, tonnepercubicfootQuantity.Unit); + + var tonnepercubicinchQuantity = kilogrampercubicmeter.ToUnit(DensityUnit.TonnePerCubicInch); + AssertEx.EqualTolerance(TonnesPerCubicInchInOneKilogramPerCubicMeter, (double)tonnepercubicinchQuantity.Value, TonnesPerCubicInchTolerance); + Assert.Equal(DensityUnit.TonnePerCubicInch, tonnepercubicinchQuantity.Unit); + var tonnepercubicmeterQuantity = kilogrampercubicmeter.ToUnit(DensityUnit.TonnePerCubicMeter); AssertEx.EqualTolerance(TonnesPerCubicMeterInOneKilogramPerCubicMeter, (double)tonnepercubicmeterQuantity.Value, TonnesPerCubicMeterTolerance); Assert.Equal(DensityUnit.TonnePerCubicMeter, tonnepercubicmeterQuantity.Unit); @@ -660,6 +792,8 @@ public void ConversionRoundTrip() AssertEx.EqualTolerance(1, Density.FromDecigramsPerLiter(kilogrampercubicmeter.DecigramsPerLiter).KilogramsPerCubicMeter, DecigramsPerLiterTolerance); AssertEx.EqualTolerance(1, Density.FromDecigramsPerMilliliter(kilogrampercubicmeter.DecigramsPerMilliliter).KilogramsPerCubicMeter, DecigramsPerMilliliterTolerance); AssertEx.EqualTolerance(1, Density.FromGramsPerCubicCentimeter(kilogrampercubicmeter.GramsPerCubicCentimeter).KilogramsPerCubicMeter, GramsPerCubicCentimeterTolerance); + AssertEx.EqualTolerance(1, Density.FromGramsPerCubicFoot(kilogrampercubicmeter.GramsPerCubicFoot).KilogramsPerCubicMeter, GramsPerCubicFootTolerance); + AssertEx.EqualTolerance(1, Density.FromGramsPerCubicInch(kilogrampercubicmeter.GramsPerCubicInch).KilogramsPerCubicMeter, GramsPerCubicInchTolerance); AssertEx.EqualTolerance(1, Density.FromGramsPerCubicMeter(kilogrampercubicmeter.GramsPerCubicMeter).KilogramsPerCubicMeter, GramsPerCubicMeterTolerance); AssertEx.EqualTolerance(1, Density.FromGramsPerCubicMillimeter(kilogrampercubicmeter.GramsPerCubicMillimeter).KilogramsPerCubicMeter, GramsPerCubicMillimeterTolerance); AssertEx.EqualTolerance(1, Density.FromGramsPerDeciLiter(kilogrampercubicmeter.GramsPerDeciLiter).KilogramsPerCubicMeter, GramsPerDeciLiterTolerance); @@ -685,12 +819,21 @@ public void ConversionRoundTrip() AssertEx.EqualTolerance(1, Density.FromPicogramsPerDeciLiter(kilogrampercubicmeter.PicogramsPerDeciLiter).KilogramsPerCubicMeter, PicogramsPerDeciLiterTolerance); AssertEx.EqualTolerance(1, Density.FromPicogramsPerLiter(kilogrampercubicmeter.PicogramsPerLiter).KilogramsPerCubicMeter, PicogramsPerLiterTolerance); AssertEx.EqualTolerance(1, Density.FromPicogramsPerMilliliter(kilogrampercubicmeter.PicogramsPerMilliliter).KilogramsPerCubicMeter, PicogramsPerMilliliterTolerance); + AssertEx.EqualTolerance(1, Density.FromPoundsPerCubicCentimeter(kilogrampercubicmeter.PoundsPerCubicCentimeter).KilogramsPerCubicMeter, PoundsPerCubicCentimeterTolerance); AssertEx.EqualTolerance(1, Density.FromPoundsPerCubicFoot(kilogrampercubicmeter.PoundsPerCubicFoot).KilogramsPerCubicMeter, PoundsPerCubicFootTolerance); AssertEx.EqualTolerance(1, Density.FromPoundsPerCubicInch(kilogrampercubicmeter.PoundsPerCubicInch).KilogramsPerCubicMeter, PoundsPerCubicInchTolerance); + AssertEx.EqualTolerance(1, Density.FromPoundsPerCubicMeter(kilogrampercubicmeter.PoundsPerCubicMeter).KilogramsPerCubicMeter, PoundsPerCubicMeterTolerance); + AssertEx.EqualTolerance(1, Density.FromPoundsPerCubicMillimeter(kilogrampercubicmeter.PoundsPerCubicMillimeter).KilogramsPerCubicMeter, PoundsPerCubicMillimeterTolerance); AssertEx.EqualTolerance(1, Density.FromPoundsPerImperialGallon(kilogrampercubicmeter.PoundsPerImperialGallon).KilogramsPerCubicMeter, PoundsPerImperialGallonTolerance); AssertEx.EqualTolerance(1, Density.FromPoundsPerUSGallon(kilogrampercubicmeter.PoundsPerUSGallon).KilogramsPerCubicMeter, PoundsPerUSGallonTolerance); + AssertEx.EqualTolerance(1, Density.FromSlugsPerCubicCentimeter(kilogrampercubicmeter.SlugsPerCubicCentimeter).KilogramsPerCubicMeter, SlugsPerCubicCentimeterTolerance); AssertEx.EqualTolerance(1, Density.FromSlugsPerCubicFoot(kilogrampercubicmeter.SlugsPerCubicFoot).KilogramsPerCubicMeter, SlugsPerCubicFootTolerance); + AssertEx.EqualTolerance(1, Density.FromSlugsPerCubicInch(kilogrampercubicmeter.SlugsPerCubicInch).KilogramsPerCubicMeter, SlugsPerCubicInchTolerance); + AssertEx.EqualTolerance(1, Density.FromSlugsPerCubicMeter(kilogrampercubicmeter.SlugsPerCubicMeter).KilogramsPerCubicMeter, SlugsPerCubicMeterTolerance); + AssertEx.EqualTolerance(1, Density.FromSlugsPerCubicMillimeter(kilogrampercubicmeter.SlugsPerCubicMillimeter).KilogramsPerCubicMeter, SlugsPerCubicMillimeterTolerance); AssertEx.EqualTolerance(1, Density.FromTonnesPerCubicCentimeter(kilogrampercubicmeter.TonnesPerCubicCentimeter).KilogramsPerCubicMeter, TonnesPerCubicCentimeterTolerance); + AssertEx.EqualTolerance(1, Density.FromTonnesPerCubicFoot(kilogrampercubicmeter.TonnesPerCubicFoot).KilogramsPerCubicMeter, TonnesPerCubicFootTolerance); + AssertEx.EqualTolerance(1, Density.FromTonnesPerCubicInch(kilogrampercubicmeter.TonnesPerCubicInch).KilogramsPerCubicMeter, TonnesPerCubicInchTolerance); AssertEx.EqualTolerance(1, Density.FromTonnesPerCubicMeter(kilogrampercubicmeter.TonnesPerCubicMeter).KilogramsPerCubicMeter, TonnesPerCubicMeterTolerance); AssertEx.EqualTolerance(1, Density.FromTonnesPerCubicMillimeter(kilogrampercubicmeter.TonnesPerCubicMillimeter).KilogramsPerCubicMeter, TonnesPerCubicMillimeterTolerance); } @@ -858,6 +1001,8 @@ public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture() Assert.Equal("1 dg/L", new Density(1, DensityUnit.DecigramPerLiter).ToString()); Assert.Equal("1 dg/ml", new Density(1, DensityUnit.DecigramPerMilliliter).ToString()); Assert.Equal("1 g/cm³", new Density(1, DensityUnit.GramPerCubicCentimeter).ToString()); + Assert.Equal("1 g/ft³", new Density(1, DensityUnit.GramPerCubicFoot).ToString()); + Assert.Equal("1 g/in³", new Density(1, DensityUnit.GramPerCubicInch).ToString()); Assert.Equal("1 g/m³", new Density(1, DensityUnit.GramPerCubicMeter).ToString()); Assert.Equal("1 g/mm³", new Density(1, DensityUnit.GramPerCubicMillimeter).ToString()); Assert.Equal("1 g/dl", new Density(1, DensityUnit.GramPerDeciliter).ToString()); @@ -883,12 +1028,21 @@ public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture() Assert.Equal("1 pg/dl", new Density(1, DensityUnit.PicogramPerDeciliter).ToString()); Assert.Equal("1 pg/L", new Density(1, DensityUnit.PicogramPerLiter).ToString()); Assert.Equal("1 pg/ml", new Density(1, DensityUnit.PicogramPerMilliliter).ToString()); + Assert.Equal("1 lb/cm³", new Density(1, DensityUnit.PoundPerCubicCentimeter).ToString()); Assert.Equal("1 lb/ft³", new Density(1, DensityUnit.PoundPerCubicFoot).ToString()); Assert.Equal("1 lb/in³", new Density(1, DensityUnit.PoundPerCubicInch).ToString()); + Assert.Equal("1 lb/m³", new Density(1, DensityUnit.PoundPerCubicMeter).ToString()); + Assert.Equal("1 lb/mm³", new Density(1, DensityUnit.PoundPerCubicMillimeter).ToString()); Assert.Equal("1 ppg (imp.)", new Density(1, DensityUnit.PoundPerImperialGallon).ToString()); Assert.Equal("1 ppg (U.S.)", new Density(1, DensityUnit.PoundPerUSGallon).ToString()); + Assert.Equal("1 slug/cm³", new Density(1, DensityUnit.SlugPerCubicCentimeter).ToString()); Assert.Equal("1 slug/ft³", new Density(1, DensityUnit.SlugPerCubicFoot).ToString()); + Assert.Equal("1 slug/in³", new Density(1, DensityUnit.SlugPerCubicInch).ToString()); + Assert.Equal("1 slug/m³", new Density(1, DensityUnit.SlugPerCubicMeter).ToString()); + Assert.Equal("1 slug/mm³", new Density(1, DensityUnit.SlugPerCubicMillimeter).ToString()); Assert.Equal("1 t/cm³", new Density(1, DensityUnit.TonnePerCubicCentimeter).ToString()); + Assert.Equal("1 t/ft³", new Density(1, DensityUnit.TonnePerCubicFoot).ToString()); + Assert.Equal("1 t/in³", new Density(1, DensityUnit.TonnePerCubicInch).ToString()); Assert.Equal("1 t/m³", new Density(1, DensityUnit.TonnePerCubicMeter).ToString()); Assert.Equal("1 t/mm³", new Density(1, DensityUnit.TonnePerCubicMillimeter).ToString()); } @@ -911,6 +1065,8 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture Assert.Equal("1 dg/L", new Density(1, DensityUnit.DecigramPerLiter).ToString(swedishCulture)); Assert.Equal("1 dg/ml", new Density(1, DensityUnit.DecigramPerMilliliter).ToString(swedishCulture)); Assert.Equal("1 g/cm³", new Density(1, DensityUnit.GramPerCubicCentimeter).ToString(swedishCulture)); + Assert.Equal("1 g/ft³", new Density(1, DensityUnit.GramPerCubicFoot).ToString(swedishCulture)); + Assert.Equal("1 g/in³", new Density(1, DensityUnit.GramPerCubicInch).ToString(swedishCulture)); Assert.Equal("1 g/m³", new Density(1, DensityUnit.GramPerCubicMeter).ToString(swedishCulture)); Assert.Equal("1 g/mm³", new Density(1, DensityUnit.GramPerCubicMillimeter).ToString(swedishCulture)); Assert.Equal("1 g/dl", new Density(1, DensityUnit.GramPerDeciliter).ToString(swedishCulture)); @@ -936,12 +1092,21 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture Assert.Equal("1 pg/dl", new Density(1, DensityUnit.PicogramPerDeciliter).ToString(swedishCulture)); Assert.Equal("1 pg/L", new Density(1, DensityUnit.PicogramPerLiter).ToString(swedishCulture)); Assert.Equal("1 pg/ml", new Density(1, DensityUnit.PicogramPerMilliliter).ToString(swedishCulture)); + Assert.Equal("1 lb/cm³", new Density(1, DensityUnit.PoundPerCubicCentimeter).ToString(swedishCulture)); Assert.Equal("1 lb/ft³", new Density(1, DensityUnit.PoundPerCubicFoot).ToString(swedishCulture)); Assert.Equal("1 lb/in³", new Density(1, DensityUnit.PoundPerCubicInch).ToString(swedishCulture)); + Assert.Equal("1 lb/m³", new Density(1, DensityUnit.PoundPerCubicMeter).ToString(swedishCulture)); + Assert.Equal("1 lb/mm³", new Density(1, DensityUnit.PoundPerCubicMillimeter).ToString(swedishCulture)); Assert.Equal("1 ppg (imp.)", new Density(1, DensityUnit.PoundPerImperialGallon).ToString(swedishCulture)); Assert.Equal("1 ppg (U.S.)", new Density(1, DensityUnit.PoundPerUSGallon).ToString(swedishCulture)); + Assert.Equal("1 slug/cm³", new Density(1, DensityUnit.SlugPerCubicCentimeter).ToString(swedishCulture)); Assert.Equal("1 slug/ft³", new Density(1, DensityUnit.SlugPerCubicFoot).ToString(swedishCulture)); + Assert.Equal("1 slug/in³", new Density(1, DensityUnit.SlugPerCubicInch).ToString(swedishCulture)); + Assert.Equal("1 slug/m³", new Density(1, DensityUnit.SlugPerCubicMeter).ToString(swedishCulture)); + Assert.Equal("1 slug/mm³", new Density(1, DensityUnit.SlugPerCubicMillimeter).ToString(swedishCulture)); Assert.Equal("1 t/cm³", new Density(1, DensityUnit.TonnePerCubicCentimeter).ToString(swedishCulture)); + Assert.Equal("1 t/ft³", new Density(1, DensityUnit.TonnePerCubicFoot).ToString(swedishCulture)); + Assert.Equal("1 t/in³", new Density(1, DensityUnit.TonnePerCubicInch).ToString(swedishCulture)); Assert.Equal("1 t/m³", new Density(1, DensityUnit.TonnePerCubicMeter).ToString(swedishCulture)); Assert.Equal("1 t/mm³", new Density(1, DensityUnit.TonnePerCubicMillimeter).ToString(swedishCulture)); } diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Density.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Density.g.cs index 4322085fa7..96ea94f58f 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Density.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Density.g.cs @@ -193,6 +193,16 @@ private Density(double value, DensityUnit unit) /// public double GramsPerCubicCentimeter => As(DensityUnit.GramPerCubicCentimeter); + /// + /// Get Density in GramsPerCubicFoot. + /// + public double GramsPerCubicFoot => As(DensityUnit.GramPerCubicFoot); + + /// + /// Get Density in GramsPerCubicInch. + /// + public double GramsPerCubicInch => As(DensityUnit.GramPerCubicInch); + /// /// Get Density in GramsPerCubicMeter. /// @@ -318,6 +328,11 @@ private Density(double value, DensityUnit unit) /// public double PicogramsPerMilliliter => As(DensityUnit.PicogramPerMilliliter); + /// + /// Get Density in PoundsPerCubicCentimeter. + /// + public double PoundsPerCubicCentimeter => As(DensityUnit.PoundPerCubicCentimeter); + /// /// Get Density in PoundsPerCubicFoot. /// @@ -328,6 +343,16 @@ private Density(double value, DensityUnit unit) /// public double PoundsPerCubicInch => As(DensityUnit.PoundPerCubicInch); + /// + /// Get Density in PoundsPerCubicMeter. + /// + public double PoundsPerCubicMeter => As(DensityUnit.PoundPerCubicMeter); + + /// + /// Get Density in PoundsPerCubicMillimeter. + /// + public double PoundsPerCubicMillimeter => As(DensityUnit.PoundPerCubicMillimeter); + /// /// Get Density in PoundsPerImperialGallon. /// @@ -338,16 +363,46 @@ private Density(double value, DensityUnit unit) /// public double PoundsPerUSGallon => As(DensityUnit.PoundPerUSGallon); + /// + /// Get Density in SlugsPerCubicCentimeter. + /// + public double SlugsPerCubicCentimeter => As(DensityUnit.SlugPerCubicCentimeter); + /// /// Get Density in SlugsPerCubicFoot. /// public double SlugsPerCubicFoot => As(DensityUnit.SlugPerCubicFoot); + /// + /// Get Density in SlugsPerCubicInch. + /// + public double SlugsPerCubicInch => As(DensityUnit.SlugPerCubicInch); + + /// + /// Get Density in SlugsPerCubicMeter. + /// + public double SlugsPerCubicMeter => As(DensityUnit.SlugPerCubicMeter); + + /// + /// Get Density in SlugsPerCubicMillimeter. + /// + public double SlugsPerCubicMillimeter => As(DensityUnit.SlugPerCubicMillimeter); + /// /// Get Density in TonnesPerCubicCentimeter. /// public double TonnesPerCubicCentimeter => As(DensityUnit.TonnePerCubicCentimeter); + /// + /// Get Density in TonnesPerCubicFoot. + /// + public double TonnesPerCubicFoot => As(DensityUnit.TonnePerCubicFoot); + + /// + /// Get Density in TonnesPerCubicInch. + /// + public double TonnesPerCubicInch => As(DensityUnit.TonnePerCubicInch); + /// /// Get Density in TonnesPerCubicMeter. /// @@ -459,6 +514,26 @@ public static Density FromGramsPerCubicCentimeter(double gramspercubiccentimeter return new Density(value, DensityUnit.GramPerCubicCentimeter); } /// + /// Get Density from GramsPerCubicFoot. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static Density FromGramsPerCubicFoot(double gramspercubicfoot) + { + double value = (double) gramspercubicfoot; + return new Density(value, DensityUnit.GramPerCubicFoot); + } + /// + /// Get Density from GramsPerCubicInch. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static Density FromGramsPerCubicInch(double gramspercubicinch) + { + double value = (double) gramspercubicinch; + return new Density(value, DensityUnit.GramPerCubicInch); + } + /// /// Get Density from GramsPerCubicMeter. /// /// If value is NaN or Infinity. @@ -709,6 +784,16 @@ public static Density FromPicogramsPerMilliliter(double picogramspermilliliter) return new Density(value, DensityUnit.PicogramPerMilliliter); } /// + /// Get Density from PoundsPerCubicCentimeter. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static Density FromPoundsPerCubicCentimeter(double poundspercubiccentimeter) + { + double value = (double) poundspercubiccentimeter; + return new Density(value, DensityUnit.PoundPerCubicCentimeter); + } + /// /// Get Density from PoundsPerCubicFoot. /// /// If value is NaN or Infinity. @@ -729,6 +814,26 @@ public static Density FromPoundsPerCubicInch(double poundspercubicinch) return new Density(value, DensityUnit.PoundPerCubicInch); } /// + /// Get Density from PoundsPerCubicMeter. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static Density FromPoundsPerCubicMeter(double poundspercubicmeter) + { + double value = (double) poundspercubicmeter; + return new Density(value, DensityUnit.PoundPerCubicMeter); + } + /// + /// Get Density from PoundsPerCubicMillimeter. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static Density FromPoundsPerCubicMillimeter(double poundspercubicmillimeter) + { + double value = (double) poundspercubicmillimeter; + return new Density(value, DensityUnit.PoundPerCubicMillimeter); + } + /// /// Get Density from PoundsPerImperialGallon. /// /// If value is NaN or Infinity. @@ -749,6 +854,16 @@ public static Density FromPoundsPerUSGallon(double poundsperusgallon) return new Density(value, DensityUnit.PoundPerUSGallon); } /// + /// Get Density from SlugsPerCubicCentimeter. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static Density FromSlugsPerCubicCentimeter(double slugspercubiccentimeter) + { + double value = (double) slugspercubiccentimeter; + return new Density(value, DensityUnit.SlugPerCubicCentimeter); + } + /// /// Get Density from SlugsPerCubicFoot. /// /// If value is NaN or Infinity. @@ -759,6 +874,36 @@ public static Density FromSlugsPerCubicFoot(double slugspercubicfoot) return new Density(value, DensityUnit.SlugPerCubicFoot); } /// + /// Get Density from SlugsPerCubicInch. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static Density FromSlugsPerCubicInch(double slugspercubicinch) + { + double value = (double) slugspercubicinch; + return new Density(value, DensityUnit.SlugPerCubicInch); + } + /// + /// Get Density from SlugsPerCubicMeter. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static Density FromSlugsPerCubicMeter(double slugspercubicmeter) + { + double value = (double) slugspercubicmeter; + return new Density(value, DensityUnit.SlugPerCubicMeter); + } + /// + /// Get Density from SlugsPerCubicMillimeter. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static Density FromSlugsPerCubicMillimeter(double slugspercubicmillimeter) + { + double value = (double) slugspercubicmillimeter; + return new Density(value, DensityUnit.SlugPerCubicMillimeter); + } + /// /// Get Density from TonnesPerCubicCentimeter. /// /// If value is NaN or Infinity. @@ -769,6 +914,26 @@ public static Density FromTonnesPerCubicCentimeter(double tonnespercubiccentimet return new Density(value, DensityUnit.TonnePerCubicCentimeter); } /// + /// Get Density from TonnesPerCubicFoot. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static Density FromTonnesPerCubicFoot(double tonnespercubicfoot) + { + double value = (double) tonnespercubicfoot; + return new Density(value, DensityUnit.TonnePerCubicFoot); + } + /// + /// Get Density from TonnesPerCubicInch. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static Density FromTonnesPerCubicInch(double tonnespercubicinch) + { + double value = (double) tonnespercubicinch; + return new Density(value, DensityUnit.TonnePerCubicInch); + } + /// /// Get Density from TonnesPerCubicMeter. /// /// If value is NaN or Infinity. @@ -1086,6 +1251,8 @@ private double AsBaseUnit() case DensityUnit.DecigramPerLiter: return (_value/1) * 1e-1d; case DensityUnit.DecigramPerMilliliter: return (_value/1e-3) * 1e-1d; case DensityUnit.GramPerCubicCentimeter: return _value/1e-3; + case DensityUnit.GramPerCubicFoot: return _value*0.0353146667214886; + case DensityUnit.GramPerCubicInch: return _value*61.0237440947323; case DensityUnit.GramPerCubicMeter: return _value/1e3; case DensityUnit.GramPerCubicMillimeter: return _value/1e-6; case DensityUnit.GramPerDeciliter: return _value/1e-1; @@ -1111,12 +1278,21 @@ private double AsBaseUnit() case DensityUnit.PicogramPerDeciliter: return (_value/1e-1) * 1e-12d; case DensityUnit.PicogramPerLiter: return (_value/1) * 1e-12d; case DensityUnit.PicogramPerMilliliter: return (_value/1e-3) * 1e-12d; + case DensityUnit.PoundPerCubicCentimeter: return _value/2.204622621848775e-6; case DensityUnit.PoundPerCubicFoot: return _value/0.062427961; case DensityUnit.PoundPerCubicInch: return _value/3.6127298147753e-5; + case DensityUnit.PoundPerCubicMeter: return _value/2.204622621848775; + case DensityUnit.PoundPerCubicMillimeter: return _value/2.204622621848775e-9; case DensityUnit.PoundPerImperialGallon: return _value*9.9776398e1; case DensityUnit.PoundPerUSGallon: return _value*1.19826427e2; + case DensityUnit.SlugPerCubicCentimeter: return _value*14593903; case DensityUnit.SlugPerCubicFoot: return _value*515.378818; + case DensityUnit.SlugPerCubicInch: return _value*890574.60201535; + case DensityUnit.SlugPerCubicMeter: return _value*14.5939; + case DensityUnit.SlugPerCubicMillimeter: return _value*14593903000; case DensityUnit.TonnePerCubicCentimeter: return _value/1e-9; + case DensityUnit.TonnePerCubicFoot: return _value*3.53146667214886e4; + case DensityUnit.TonnePerCubicInch: return _value*6.10237440947323e7; case DensityUnit.TonnePerCubicMeter: return _value/0.001; case DensityUnit.TonnePerCubicMillimeter: return _value/1e-12; default: @@ -1140,6 +1316,8 @@ private double AsBaseNumericType(DensityUnit unit) case DensityUnit.DecigramPerLiter: return (baseUnitValue*1) / 1e-1d; case DensityUnit.DecigramPerMilliliter: return (baseUnitValue*1e-3) / 1e-1d; case DensityUnit.GramPerCubicCentimeter: return baseUnitValue*1e-3; + case DensityUnit.GramPerCubicFoot: return baseUnitValue/0.0353146667214886; + case DensityUnit.GramPerCubicInch: return baseUnitValue/61.0237440947323; case DensityUnit.GramPerCubicMeter: return baseUnitValue*1e3; case DensityUnit.GramPerCubicMillimeter: return baseUnitValue*1e-6; case DensityUnit.GramPerDeciliter: return baseUnitValue*1e-1; @@ -1165,12 +1343,21 @@ private double AsBaseNumericType(DensityUnit unit) case DensityUnit.PicogramPerDeciliter: return (baseUnitValue*1e-1) / 1e-12d; case DensityUnit.PicogramPerLiter: return (baseUnitValue*1) / 1e-12d; case DensityUnit.PicogramPerMilliliter: return (baseUnitValue*1e-3) / 1e-12d; + case DensityUnit.PoundPerCubicCentimeter: return baseUnitValue*2.204622621848775e-6; case DensityUnit.PoundPerCubicFoot: return baseUnitValue*0.062427961; case DensityUnit.PoundPerCubicInch: return baseUnitValue*3.6127298147753e-5; + case DensityUnit.PoundPerCubicMeter: return baseUnitValue*2.204622621848775; + case DensityUnit.PoundPerCubicMillimeter: return baseUnitValue*2.204622621848775e-9; case DensityUnit.PoundPerImperialGallon: return baseUnitValue/9.9776398e1; case DensityUnit.PoundPerUSGallon: return baseUnitValue/1.19826427e2; + case DensityUnit.SlugPerCubicCentimeter: return baseUnitValue/14593903; case DensityUnit.SlugPerCubicFoot: return baseUnitValue*0.00194032033; + case DensityUnit.SlugPerCubicInch: return baseUnitValue/890574.60201535; + case DensityUnit.SlugPerCubicMeter: return baseUnitValue/14.5939; + case DensityUnit.SlugPerCubicMillimeter: return baseUnitValue/14593903000; case DensityUnit.TonnePerCubicCentimeter: return baseUnitValue*1e-9; + case DensityUnit.TonnePerCubicFoot: return baseUnitValue/3.53146667214886e4; + case DensityUnit.TonnePerCubicInch: return baseUnitValue/6.10237440947323e7; case DensityUnit.TonnePerCubicMeter: return baseUnitValue*0.001; case DensityUnit.TonnePerCubicMillimeter: return baseUnitValue*1e-12; default: diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs index f88721f296..a8bd618304 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs @@ -205,6 +205,8 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("en-US", typeof(DensityUnit), (int)DensityUnit.DecigramPerLiter, new string[]{"dg/L"}), ("en-US", typeof(DensityUnit), (int)DensityUnit.DecigramPerMilliliter, new string[]{"dg/ml"}), ("en-US", typeof(DensityUnit), (int)DensityUnit.GramPerCubicCentimeter, new string[]{"g/cm³"}), + ("en-US", typeof(DensityUnit), (int)DensityUnit.GramPerCubicFoot, new string[]{"g/ft³"}), + ("en-US", typeof(DensityUnit), (int)DensityUnit.GramPerCubicInch, new string[]{"g/in³"}), ("en-US", typeof(DensityUnit), (int)DensityUnit.GramPerCubicMeter, new string[]{"g/m³"}), ("ru-RU", typeof(DensityUnit), (int)DensityUnit.GramPerCubicMeter, new string[]{"г/м³"}), ("en-US", typeof(DensityUnit), (int)DensityUnit.GramPerCubicMillimeter, new string[]{"g/mm³"}), @@ -234,12 +236,21 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("en-US", typeof(DensityUnit), (int)DensityUnit.PicogramPerDeciliter, new string[]{"pg/dl"}), ("en-US", typeof(DensityUnit), (int)DensityUnit.PicogramPerLiter, new string[]{"pg/L"}), ("en-US", typeof(DensityUnit), (int)DensityUnit.PicogramPerMilliliter, new string[]{"pg/ml"}), + ("en-US", typeof(DensityUnit), (int)DensityUnit.PoundPerCubicCentimeter, new string[]{"lb/cm³"}), ("en-US", typeof(DensityUnit), (int)DensityUnit.PoundPerCubicFoot, new string[]{"lb/ft³"}), ("en-US", typeof(DensityUnit), (int)DensityUnit.PoundPerCubicInch, new string[]{"lb/in³"}), + ("en-US", typeof(DensityUnit), (int)DensityUnit.PoundPerCubicMeter, new string[]{"lb/m³"}), + ("en-US", typeof(DensityUnit), (int)DensityUnit.PoundPerCubicMillimeter, new string[]{"lb/mm³"}), ("en-US", typeof(DensityUnit), (int)DensityUnit.PoundPerImperialGallon, new string[]{"ppg (imp.)"}), ("en-US", typeof(DensityUnit), (int)DensityUnit.PoundPerUSGallon, new string[]{"ppg (U.S.)"}), + ("en-US", typeof(DensityUnit), (int)DensityUnit.SlugPerCubicCentimeter, new string[]{"slug/cm³"}), ("en-US", typeof(DensityUnit), (int)DensityUnit.SlugPerCubicFoot, new string[]{"slug/ft³"}), + ("en-US", typeof(DensityUnit), (int)DensityUnit.SlugPerCubicInch, new string[]{"slug/in³"}), + ("en-US", typeof(DensityUnit), (int)DensityUnit.SlugPerCubicMeter, new string[]{"slug/m³"}), + ("en-US", typeof(DensityUnit), (int)DensityUnit.SlugPerCubicMillimeter, new string[]{"slug/mm³"}), ("en-US", typeof(DensityUnit), (int)DensityUnit.TonnePerCubicCentimeter, new string[]{"t/cm³"}), + ("en-US", typeof(DensityUnit), (int)DensityUnit.TonnePerCubicFoot, new string[]{"t/ft³"}), + ("en-US", typeof(DensityUnit), (int)DensityUnit.TonnePerCubicInch, new string[]{"t/in³"}), ("en-US", typeof(DensityUnit), (int)DensityUnit.TonnePerCubicMeter, new string[]{"t/m³"}), ("en-US", typeof(DensityUnit), (int)DensityUnit.TonnePerCubicMillimeter, new string[]{"t/mm³"}), ("en-US", typeof(DurationUnit), (int)DurationUnit.Day, new string[]{"d", "day", "days"}), diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/DensityUnit.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/DensityUnit.g.cs index 94f3fd7948..62795a2b36 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/DensityUnit.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/DensityUnit.g.cs @@ -33,6 +33,8 @@ public enum DensityUnit DecigramPerLiter, DecigramPerMilliliter, GramPerCubicCentimeter, + GramPerCubicFoot, + GramPerCubicInch, GramPerCubicMeter, GramPerCubicMillimeter, GramPerDeciliter, @@ -58,12 +60,21 @@ public enum DensityUnit PicogramPerDeciliter, PicogramPerLiter, PicogramPerMilliliter, + PoundPerCubicCentimeter, PoundPerCubicFoot, PoundPerCubicInch, + PoundPerCubicMeter, + PoundPerCubicMillimeter, PoundPerImperialGallon, PoundPerUSGallon, + SlugPerCubicCentimeter, SlugPerCubicFoot, + SlugPerCubicInch, + SlugPerCubicMeter, + SlugPerCubicMillimeter, TonnePerCubicCentimeter, + TonnePerCubicFoot, + TonnePerCubicInch, TonnePerCubicMeter, TonnePerCubicMillimeter, } diff --git a/UnitsNet/GeneratedCode/Quantities/Density.g.cs b/UnitsNet/GeneratedCode/Quantities/Density.g.cs index 11b60bd3d2..86e39a3f31 100644 --- a/UnitsNet/GeneratedCode/Quantities/Density.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Density.g.cs @@ -66,6 +66,8 @@ static Density() new UnitInfo(DensityUnit.DecigramPerLiter, "DecigramsPerLiter", BaseUnits.Undefined), new UnitInfo(DensityUnit.DecigramPerMilliliter, "DecigramsPerMilliliter", BaseUnits.Undefined), new UnitInfo(DensityUnit.GramPerCubicCentimeter, "GramsPerCubicCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Gram)), + new UnitInfo(DensityUnit.GramPerCubicFoot, "GramsPerCubicFoot", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Gram)), + new UnitInfo(DensityUnit.GramPerCubicInch, "GramsPerCubicInch", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Gram)), new UnitInfo(DensityUnit.GramPerCubicMeter, "GramsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram)), new UnitInfo(DensityUnit.GramPerCubicMillimeter, "GramsPerCubicMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Gram)), new UnitInfo(DensityUnit.GramPerDeciliter, "GramsPerDeciLiter", BaseUnits.Undefined), @@ -91,12 +93,21 @@ static Density() new UnitInfo(DensityUnit.PicogramPerDeciliter, "PicogramsPerDeciLiter", BaseUnits.Undefined), new UnitInfo(DensityUnit.PicogramPerLiter, "PicogramsPerLiter", BaseUnits.Undefined), new UnitInfo(DensityUnit.PicogramPerMilliliter, "PicogramsPerMilliliter", BaseUnits.Undefined), + new UnitInfo(DensityUnit.PoundPerCubicCentimeter, "PoundsPerCubicCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Pound)), new UnitInfo(DensityUnit.PoundPerCubicFoot, "PoundsPerCubicFoot", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Pound)), new UnitInfo(DensityUnit.PoundPerCubicInch, "PoundsPerCubicInch", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Pound)), + new UnitInfo(DensityUnit.PoundPerCubicMeter, "PoundsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Pound)), + new UnitInfo(DensityUnit.PoundPerCubicMillimeter, "PoundsPerCubicMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Pound)), new UnitInfo(DensityUnit.PoundPerImperialGallon, "PoundsPerImperialGallon", BaseUnits.Undefined), new UnitInfo(DensityUnit.PoundPerUSGallon, "PoundsPerUSGallon", BaseUnits.Undefined), + new UnitInfo(DensityUnit.SlugPerCubicCentimeter, "SlugsPerCubicCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Slug)), new UnitInfo(DensityUnit.SlugPerCubicFoot, "SlugsPerCubicFoot", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Slug)), + new UnitInfo(DensityUnit.SlugPerCubicInch, "SlugsPerCubicInch", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Slug)), + new UnitInfo(DensityUnit.SlugPerCubicMeter, "SlugsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Slug)), + new UnitInfo(DensityUnit.SlugPerCubicMillimeter, "SlugsPerCubicMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Slug)), new UnitInfo(DensityUnit.TonnePerCubicCentimeter, "TonnesPerCubicCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Tonne)), + new UnitInfo(DensityUnit.TonnePerCubicFoot, "TonnesPerCubicFoot", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Tonne)), + new UnitInfo(DensityUnit.TonnePerCubicInch, "TonnesPerCubicInch", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Tonne)), new UnitInfo(DensityUnit.TonnePerCubicMeter, "TonnesPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Tonne)), new UnitInfo(DensityUnit.TonnePerCubicMillimeter, "TonnesPerCubicMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Tonne)), }, @@ -249,6 +260,16 @@ public Density(double value, UnitSystem unitSystem) /// public double GramsPerCubicCentimeter => As(DensityUnit.GramPerCubicCentimeter); + /// + /// Get Density in GramsPerCubicFoot. + /// + public double GramsPerCubicFoot => As(DensityUnit.GramPerCubicFoot); + + /// + /// Get Density in GramsPerCubicInch. + /// + public double GramsPerCubicInch => As(DensityUnit.GramPerCubicInch); + /// /// Get Density in GramsPerCubicMeter. /// @@ -374,6 +395,11 @@ public Density(double value, UnitSystem unitSystem) /// public double PicogramsPerMilliliter => As(DensityUnit.PicogramPerMilliliter); + /// + /// Get Density in PoundsPerCubicCentimeter. + /// + public double PoundsPerCubicCentimeter => As(DensityUnit.PoundPerCubicCentimeter); + /// /// Get Density in PoundsPerCubicFoot. /// @@ -384,6 +410,16 @@ public Density(double value, UnitSystem unitSystem) /// public double PoundsPerCubicInch => As(DensityUnit.PoundPerCubicInch); + /// + /// Get Density in PoundsPerCubicMeter. + /// + public double PoundsPerCubicMeter => As(DensityUnit.PoundPerCubicMeter); + + /// + /// Get Density in PoundsPerCubicMillimeter. + /// + public double PoundsPerCubicMillimeter => As(DensityUnit.PoundPerCubicMillimeter); + /// /// Get Density in PoundsPerImperialGallon. /// @@ -394,16 +430,46 @@ public Density(double value, UnitSystem unitSystem) /// public double PoundsPerUSGallon => As(DensityUnit.PoundPerUSGallon); + /// + /// Get Density in SlugsPerCubicCentimeter. + /// + public double SlugsPerCubicCentimeter => As(DensityUnit.SlugPerCubicCentimeter); + /// /// Get Density in SlugsPerCubicFoot. /// public double SlugsPerCubicFoot => As(DensityUnit.SlugPerCubicFoot); + /// + /// Get Density in SlugsPerCubicInch. + /// + public double SlugsPerCubicInch => As(DensityUnit.SlugPerCubicInch); + + /// + /// Get Density in SlugsPerCubicMeter. + /// + public double SlugsPerCubicMeter => As(DensityUnit.SlugPerCubicMeter); + + /// + /// Get Density in SlugsPerCubicMillimeter. + /// + public double SlugsPerCubicMillimeter => As(DensityUnit.SlugPerCubicMillimeter); + /// /// Get Density in TonnesPerCubicCentimeter. /// public double TonnesPerCubicCentimeter => As(DensityUnit.TonnePerCubicCentimeter); + /// + /// Get Density in TonnesPerCubicFoot. + /// + public double TonnesPerCubicFoot => As(DensityUnit.TonnePerCubicFoot); + + /// + /// Get Density in TonnesPerCubicInch. + /// + public double TonnesPerCubicInch => As(DensityUnit.TonnePerCubicInch); + /// /// Get Density in TonnesPerCubicMeter. /// @@ -507,6 +573,24 @@ public static Density FromGramsPerCubicCentimeter(QuantityValue gramspercubiccen return new Density(value, DensityUnit.GramPerCubicCentimeter); } /// + /// Get Density from GramsPerCubicFoot. + /// + /// If value is NaN or Infinity. + public static Density FromGramsPerCubicFoot(QuantityValue gramspercubicfoot) + { + double value = (double) gramspercubicfoot; + return new Density(value, DensityUnit.GramPerCubicFoot); + } + /// + /// Get Density from GramsPerCubicInch. + /// + /// If value is NaN or Infinity. + public static Density FromGramsPerCubicInch(QuantityValue gramspercubicinch) + { + double value = (double) gramspercubicinch; + return new Density(value, DensityUnit.GramPerCubicInch); + } + /// /// Get Density from GramsPerCubicMeter. /// /// If value is NaN or Infinity. @@ -732,6 +816,15 @@ public static Density FromPicogramsPerMilliliter(QuantityValue picogramspermilli return new Density(value, DensityUnit.PicogramPerMilliliter); } /// + /// Get Density from PoundsPerCubicCentimeter. + /// + /// If value is NaN or Infinity. + public static Density FromPoundsPerCubicCentimeter(QuantityValue poundspercubiccentimeter) + { + double value = (double) poundspercubiccentimeter; + return new Density(value, DensityUnit.PoundPerCubicCentimeter); + } + /// /// Get Density from PoundsPerCubicFoot. /// /// If value is NaN or Infinity. @@ -750,6 +843,24 @@ public static Density FromPoundsPerCubicInch(QuantityValue poundspercubicinch) return new Density(value, DensityUnit.PoundPerCubicInch); } /// + /// Get Density from PoundsPerCubicMeter. + /// + /// If value is NaN or Infinity. + public static Density FromPoundsPerCubicMeter(QuantityValue poundspercubicmeter) + { + double value = (double) poundspercubicmeter; + return new Density(value, DensityUnit.PoundPerCubicMeter); + } + /// + /// Get Density from PoundsPerCubicMillimeter. + /// + /// If value is NaN or Infinity. + public static Density FromPoundsPerCubicMillimeter(QuantityValue poundspercubicmillimeter) + { + double value = (double) poundspercubicmillimeter; + return new Density(value, DensityUnit.PoundPerCubicMillimeter); + } + /// /// Get Density from PoundsPerImperialGallon. /// /// If value is NaN or Infinity. @@ -768,6 +879,15 @@ public static Density FromPoundsPerUSGallon(QuantityValue poundsperusgallon) return new Density(value, DensityUnit.PoundPerUSGallon); } /// + /// Get Density from SlugsPerCubicCentimeter. + /// + /// If value is NaN or Infinity. + public static Density FromSlugsPerCubicCentimeter(QuantityValue slugspercubiccentimeter) + { + double value = (double) slugspercubiccentimeter; + return new Density(value, DensityUnit.SlugPerCubicCentimeter); + } + /// /// Get Density from SlugsPerCubicFoot. /// /// If value is NaN or Infinity. @@ -777,6 +897,33 @@ public static Density FromSlugsPerCubicFoot(QuantityValue slugspercubicfoot) return new Density(value, DensityUnit.SlugPerCubicFoot); } /// + /// Get Density from SlugsPerCubicInch. + /// + /// If value is NaN or Infinity. + public static Density FromSlugsPerCubicInch(QuantityValue slugspercubicinch) + { + double value = (double) slugspercubicinch; + return new Density(value, DensityUnit.SlugPerCubicInch); + } + /// + /// Get Density from SlugsPerCubicMeter. + /// + /// If value is NaN or Infinity. + public static Density FromSlugsPerCubicMeter(QuantityValue slugspercubicmeter) + { + double value = (double) slugspercubicmeter; + return new Density(value, DensityUnit.SlugPerCubicMeter); + } + /// + /// Get Density from SlugsPerCubicMillimeter. + /// + /// If value is NaN or Infinity. + public static Density FromSlugsPerCubicMillimeter(QuantityValue slugspercubicmillimeter) + { + double value = (double) slugspercubicmillimeter; + return new Density(value, DensityUnit.SlugPerCubicMillimeter); + } + /// /// Get Density from TonnesPerCubicCentimeter. /// /// If value is NaN or Infinity. @@ -786,6 +933,24 @@ public static Density FromTonnesPerCubicCentimeter(QuantityValue tonnespercubicc return new Density(value, DensityUnit.TonnePerCubicCentimeter); } /// + /// Get Density from TonnesPerCubicFoot. + /// + /// If value is NaN or Infinity. + public static Density FromTonnesPerCubicFoot(QuantityValue tonnespercubicfoot) + { + double value = (double) tonnespercubicfoot; + return new Density(value, DensityUnit.TonnePerCubicFoot); + } + /// + /// Get Density from TonnesPerCubicInch. + /// + /// If value is NaN or Infinity. + public static Density FromTonnesPerCubicInch(QuantityValue tonnespercubicinch) + { + double value = (double) tonnespercubicinch; + return new Density(value, DensityUnit.TonnePerCubicInch); + } + /// /// Get Density from TonnesPerCubicMeter. /// /// If value is NaN or Infinity. @@ -1239,6 +1404,8 @@ private double GetValueInBaseUnit() case DensityUnit.DecigramPerLiter: return (_value/1) * 1e-1d; case DensityUnit.DecigramPerMilliliter: return (_value/1e-3) * 1e-1d; case DensityUnit.GramPerCubicCentimeter: return _value/1e-3; + case DensityUnit.GramPerCubicFoot: return _value*0.0353146667214886; + case DensityUnit.GramPerCubicInch: return _value*61.0237440947323; case DensityUnit.GramPerCubicMeter: return _value/1e3; case DensityUnit.GramPerCubicMillimeter: return _value/1e-6; case DensityUnit.GramPerDeciliter: return _value/1e-1; @@ -1264,12 +1431,21 @@ private double GetValueInBaseUnit() case DensityUnit.PicogramPerDeciliter: return (_value/1e-1) * 1e-12d; case DensityUnit.PicogramPerLiter: return (_value/1) * 1e-12d; case DensityUnit.PicogramPerMilliliter: return (_value/1e-3) * 1e-12d; + case DensityUnit.PoundPerCubicCentimeter: return _value/2.204622621848775e-6; case DensityUnit.PoundPerCubicFoot: return _value/0.062427961; case DensityUnit.PoundPerCubicInch: return _value/3.6127298147753e-5; + case DensityUnit.PoundPerCubicMeter: return _value/2.204622621848775; + case DensityUnit.PoundPerCubicMillimeter: return _value/2.204622621848775e-9; case DensityUnit.PoundPerImperialGallon: return _value*9.9776398e1; case DensityUnit.PoundPerUSGallon: return _value*1.19826427e2; + case DensityUnit.SlugPerCubicCentimeter: return _value*14593903; case DensityUnit.SlugPerCubicFoot: return _value*515.378818; + case DensityUnit.SlugPerCubicInch: return _value*890574.60201535; + case DensityUnit.SlugPerCubicMeter: return _value*14.5939; + case DensityUnit.SlugPerCubicMillimeter: return _value*14593903000; case DensityUnit.TonnePerCubicCentimeter: return _value/1e-9; + case DensityUnit.TonnePerCubicFoot: return _value*3.53146667214886e4; + case DensityUnit.TonnePerCubicInch: return _value*6.10237440947323e7; case DensityUnit.TonnePerCubicMeter: return _value/0.001; case DensityUnit.TonnePerCubicMillimeter: return _value/1e-12; default: @@ -1304,6 +1480,8 @@ private double GetValueAs(DensityUnit unit) case DensityUnit.DecigramPerLiter: return (baseUnitValue*1) / 1e-1d; case DensityUnit.DecigramPerMilliliter: return (baseUnitValue*1e-3) / 1e-1d; case DensityUnit.GramPerCubicCentimeter: return baseUnitValue*1e-3; + case DensityUnit.GramPerCubicFoot: return baseUnitValue/0.0353146667214886; + case DensityUnit.GramPerCubicInch: return baseUnitValue/61.0237440947323; case DensityUnit.GramPerCubicMeter: return baseUnitValue*1e3; case DensityUnit.GramPerCubicMillimeter: return baseUnitValue*1e-6; case DensityUnit.GramPerDeciliter: return baseUnitValue*1e-1; @@ -1329,12 +1507,21 @@ private double GetValueAs(DensityUnit unit) case DensityUnit.PicogramPerDeciliter: return (baseUnitValue*1e-1) / 1e-12d; case DensityUnit.PicogramPerLiter: return (baseUnitValue*1) / 1e-12d; case DensityUnit.PicogramPerMilliliter: return (baseUnitValue*1e-3) / 1e-12d; + case DensityUnit.PoundPerCubicCentimeter: return baseUnitValue*2.204622621848775e-6; case DensityUnit.PoundPerCubicFoot: return baseUnitValue*0.062427961; case DensityUnit.PoundPerCubicInch: return baseUnitValue*3.6127298147753e-5; + case DensityUnit.PoundPerCubicMeter: return baseUnitValue*2.204622621848775; + case DensityUnit.PoundPerCubicMillimeter: return baseUnitValue*2.204622621848775e-9; case DensityUnit.PoundPerImperialGallon: return baseUnitValue/9.9776398e1; case DensityUnit.PoundPerUSGallon: return baseUnitValue/1.19826427e2; + case DensityUnit.SlugPerCubicCentimeter: return baseUnitValue/14593903; case DensityUnit.SlugPerCubicFoot: return baseUnitValue*0.00194032033; + case DensityUnit.SlugPerCubicInch: return baseUnitValue/890574.60201535; + case DensityUnit.SlugPerCubicMeter: return baseUnitValue/14.5939; + case DensityUnit.SlugPerCubicMillimeter: return baseUnitValue/14593903000; case DensityUnit.TonnePerCubicCentimeter: return baseUnitValue*1e-9; + case DensityUnit.TonnePerCubicFoot: return baseUnitValue/3.53146667214886e4; + case DensityUnit.TonnePerCubicInch: return baseUnitValue/6.10237440947323e7; case DensityUnit.TonnePerCubicMeter: return baseUnitValue*0.001; case DensityUnit.TonnePerCubicMillimeter: return baseUnitValue*1e-12; default: diff --git a/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs b/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs index 7c3a2e165c..d94e5c1a70 100644 --- a/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs +++ b/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs @@ -205,6 +205,8 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("en-US", typeof(DensityUnit), (int)DensityUnit.DecigramPerLiter, new string[]{"dg/L"}), ("en-US", typeof(DensityUnit), (int)DensityUnit.DecigramPerMilliliter, new string[]{"dg/ml"}), ("en-US", typeof(DensityUnit), (int)DensityUnit.GramPerCubicCentimeter, new string[]{"g/cm³"}), + ("en-US", typeof(DensityUnit), (int)DensityUnit.GramPerCubicFoot, new string[]{"g/ft³"}), + ("en-US", typeof(DensityUnit), (int)DensityUnit.GramPerCubicInch, new string[]{"g/in³"}), ("en-US", typeof(DensityUnit), (int)DensityUnit.GramPerCubicMeter, new string[]{"g/m³"}), ("ru-RU", typeof(DensityUnit), (int)DensityUnit.GramPerCubicMeter, new string[]{"г/м³"}), ("en-US", typeof(DensityUnit), (int)DensityUnit.GramPerCubicMillimeter, new string[]{"g/mm³"}), @@ -234,12 +236,21 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("en-US", typeof(DensityUnit), (int)DensityUnit.PicogramPerDeciliter, new string[]{"pg/dl"}), ("en-US", typeof(DensityUnit), (int)DensityUnit.PicogramPerLiter, new string[]{"pg/L"}), ("en-US", typeof(DensityUnit), (int)DensityUnit.PicogramPerMilliliter, new string[]{"pg/ml"}), + ("en-US", typeof(DensityUnit), (int)DensityUnit.PoundPerCubicCentimeter, new string[]{"lb/cm³"}), ("en-US", typeof(DensityUnit), (int)DensityUnit.PoundPerCubicFoot, new string[]{"lb/ft³"}), ("en-US", typeof(DensityUnit), (int)DensityUnit.PoundPerCubicInch, new string[]{"lb/in³"}), + ("en-US", typeof(DensityUnit), (int)DensityUnit.PoundPerCubicMeter, new string[]{"lb/m³"}), + ("en-US", typeof(DensityUnit), (int)DensityUnit.PoundPerCubicMillimeter, new string[]{"lb/mm³"}), ("en-US", typeof(DensityUnit), (int)DensityUnit.PoundPerImperialGallon, new string[]{"ppg (imp.)"}), ("en-US", typeof(DensityUnit), (int)DensityUnit.PoundPerUSGallon, new string[]{"ppg (U.S.)"}), + ("en-US", typeof(DensityUnit), (int)DensityUnit.SlugPerCubicCentimeter, new string[]{"slug/cm³"}), ("en-US", typeof(DensityUnit), (int)DensityUnit.SlugPerCubicFoot, new string[]{"slug/ft³"}), + ("en-US", typeof(DensityUnit), (int)DensityUnit.SlugPerCubicInch, new string[]{"slug/in³"}), + ("en-US", typeof(DensityUnit), (int)DensityUnit.SlugPerCubicMeter, new string[]{"slug/m³"}), + ("en-US", typeof(DensityUnit), (int)DensityUnit.SlugPerCubicMillimeter, new string[]{"slug/mm³"}), ("en-US", typeof(DensityUnit), (int)DensityUnit.TonnePerCubicCentimeter, new string[]{"t/cm³"}), + ("en-US", typeof(DensityUnit), (int)DensityUnit.TonnePerCubicFoot, new string[]{"t/ft³"}), + ("en-US", typeof(DensityUnit), (int)DensityUnit.TonnePerCubicInch, new string[]{"t/in³"}), ("en-US", typeof(DensityUnit), (int)DensityUnit.TonnePerCubicMeter, new string[]{"t/m³"}), ("en-US", typeof(DensityUnit), (int)DensityUnit.TonnePerCubicMillimeter, new string[]{"t/mm³"}), ("en-US", typeof(DurationUnit), (int)DurationUnit.Day, new string[]{"d", "day", "days"}), diff --git a/UnitsNet/GeneratedCode/UnitConverter.g.cs b/UnitsNet/GeneratedCode/UnitConverter.g.cs index f86b5b3f67..98de708910 100644 --- a/UnitsNet/GeneratedCode/UnitConverter.g.cs +++ b/UnitsNet/GeneratedCode/UnitConverter.g.cs @@ -265,6 +265,10 @@ public static void RegisterDefaultConversions(UnitConverter unitConverter) unitConverter.SetConversionFunction(DensityUnit.DecigramPerMilliliter, Density.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.GramPerCubicCentimeter, q => q.ToUnit(DensityUnit.GramPerCubicCentimeter)); unitConverter.SetConversionFunction(DensityUnit.GramPerCubicCentimeter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.GramPerCubicFoot, q => q.ToUnit(DensityUnit.GramPerCubicFoot)); + unitConverter.SetConversionFunction(DensityUnit.GramPerCubicFoot, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.GramPerCubicInch, q => q.ToUnit(DensityUnit.GramPerCubicInch)); + unitConverter.SetConversionFunction(DensityUnit.GramPerCubicInch, Density.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.GramPerCubicMeter, q => q.ToUnit(DensityUnit.GramPerCubicMeter)); unitConverter.SetConversionFunction(DensityUnit.GramPerCubicMeter, Density.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.GramPerCubicMillimeter, q => q.ToUnit(DensityUnit.GramPerCubicMillimeter)); @@ -314,18 +318,36 @@ public static void RegisterDefaultConversions(UnitConverter unitConverter) unitConverter.SetConversionFunction(DensityUnit.PicogramPerLiter, Density.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PicogramPerMilliliter, q => q.ToUnit(DensityUnit.PicogramPerMilliliter)); unitConverter.SetConversionFunction(DensityUnit.PicogramPerMilliliter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PoundPerCubicCentimeter, q => q.ToUnit(DensityUnit.PoundPerCubicCentimeter)); + unitConverter.SetConversionFunction(DensityUnit.PoundPerCubicCentimeter, Density.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PoundPerCubicFoot, q => q.ToUnit(DensityUnit.PoundPerCubicFoot)); unitConverter.SetConversionFunction(DensityUnit.PoundPerCubicFoot, Density.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PoundPerCubicInch, q => q.ToUnit(DensityUnit.PoundPerCubicInch)); unitConverter.SetConversionFunction(DensityUnit.PoundPerCubicInch, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PoundPerCubicMeter, q => q.ToUnit(DensityUnit.PoundPerCubicMeter)); + unitConverter.SetConversionFunction(DensityUnit.PoundPerCubicMeter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PoundPerCubicMillimeter, q => q.ToUnit(DensityUnit.PoundPerCubicMillimeter)); + unitConverter.SetConversionFunction(DensityUnit.PoundPerCubicMillimeter, Density.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PoundPerImperialGallon, q => q.ToUnit(DensityUnit.PoundPerImperialGallon)); unitConverter.SetConversionFunction(DensityUnit.PoundPerImperialGallon, Density.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.PoundPerUSGallon, q => q.ToUnit(DensityUnit.PoundPerUSGallon)); unitConverter.SetConversionFunction(DensityUnit.PoundPerUSGallon, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.SlugPerCubicCentimeter, q => q.ToUnit(DensityUnit.SlugPerCubicCentimeter)); + unitConverter.SetConversionFunction(DensityUnit.SlugPerCubicCentimeter, Density.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.SlugPerCubicFoot, q => q.ToUnit(DensityUnit.SlugPerCubicFoot)); unitConverter.SetConversionFunction(DensityUnit.SlugPerCubicFoot, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.SlugPerCubicInch, q => q.ToUnit(DensityUnit.SlugPerCubicInch)); + unitConverter.SetConversionFunction(DensityUnit.SlugPerCubicInch, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.SlugPerCubicMeter, q => q.ToUnit(DensityUnit.SlugPerCubicMeter)); + unitConverter.SetConversionFunction(DensityUnit.SlugPerCubicMeter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.SlugPerCubicMillimeter, q => q.ToUnit(DensityUnit.SlugPerCubicMillimeter)); + unitConverter.SetConversionFunction(DensityUnit.SlugPerCubicMillimeter, Density.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.TonnePerCubicCentimeter, q => q.ToUnit(DensityUnit.TonnePerCubicCentimeter)); unitConverter.SetConversionFunction(DensityUnit.TonnePerCubicCentimeter, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.TonnePerCubicFoot, q => q.ToUnit(DensityUnit.TonnePerCubicFoot)); + unitConverter.SetConversionFunction(DensityUnit.TonnePerCubicFoot, Density.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.TonnePerCubicInch, q => q.ToUnit(DensityUnit.TonnePerCubicInch)); + unitConverter.SetConversionFunction(DensityUnit.TonnePerCubicInch, Density.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.TonnePerCubicMeter, q => q.ToUnit(DensityUnit.TonnePerCubicMeter)); unitConverter.SetConversionFunction(DensityUnit.TonnePerCubicMeter, Density.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Density.BaseUnit, DensityUnit.TonnePerCubicMillimeter, q => q.ToUnit(DensityUnit.TonnePerCubicMillimeter)); diff --git a/UnitsNet/GeneratedCode/Units/DensityUnit.g.cs b/UnitsNet/GeneratedCode/Units/DensityUnit.g.cs index 94f3fd7948..62795a2b36 100644 --- a/UnitsNet/GeneratedCode/Units/DensityUnit.g.cs +++ b/UnitsNet/GeneratedCode/Units/DensityUnit.g.cs @@ -33,6 +33,8 @@ public enum DensityUnit DecigramPerLiter, DecigramPerMilliliter, GramPerCubicCentimeter, + GramPerCubicFoot, + GramPerCubicInch, GramPerCubicMeter, GramPerCubicMillimeter, GramPerDeciliter, @@ -58,12 +60,21 @@ public enum DensityUnit PicogramPerDeciliter, PicogramPerLiter, PicogramPerMilliliter, + PoundPerCubicCentimeter, PoundPerCubicFoot, PoundPerCubicInch, + PoundPerCubicMeter, + PoundPerCubicMillimeter, PoundPerImperialGallon, PoundPerUSGallon, + SlugPerCubicCentimeter, SlugPerCubicFoot, + SlugPerCubicInch, + SlugPerCubicMeter, + SlugPerCubicMillimeter, TonnePerCubicCentimeter, + TonnePerCubicFoot, + TonnePerCubicInch, TonnePerCubicMeter, TonnePerCubicMillimeter, }