diff --git a/Common/UnitDefinitions/Force.json b/Common/UnitDefinitions/Force.json index 290195855d..b3ee6a66c9 100644 --- a/Common/UnitDefinitions/Force.json +++ b/Common/UnitDefinitions/Force.json @@ -125,14 +125,17 @@ "PluralName": "PoundsForce", "FromUnitToBaseFunc": "x*4.4482216152605095551842641431421", "FromBaseToUnitFunc": "x/4.4482216152605095551842641431421", + "Prefixes": [ "Kilo" ], "Localization": [ { "Culture": "en-US", - "Abbreviations": [ "lbf" ] + "Abbreviations": [ "lbf" ], + "AbbreviationsForPrefixes": { "Kilo": [ "kipf", "kip", "k" ] } }, { "Culture": "ru-RU", - "Abbreviations": [ "фунт-сила" ] + "Abbreviations": [ "фунт-сила" ], + "AbbreviationsForPrefixes": { "Kilo": [ "кипф", "койка", "К" ] } } ] }, @@ -148,22 +151,6 @@ } ] }, - { - "SingularName": "KilopoundForce", - "PluralName": "KilopoundsForce", - "FromUnitToBaseFunc": "x*4448.2216152605095551842641431421", - "FromBaseToUnitFunc": "x/4448.2216152605095551842641431421", - "Localization": [ - { - "Culture": "en-US", - "Abbreviations": [ "kipf", "kip", "k" ] - }, - { - "Culture": "ru-RU", - "Abbreviations": [ "кипф", "койка", "К" ] - } - ] - }, { "SingularName": "ShortTonForce", "PluralName": "ShortTonsForce", diff --git a/Common/UnitDefinitions/ForceChangeRate.json b/Common/UnitDefinitions/ForceChangeRate.json index f45bb58699..c2722b5cb9 100644 --- a/Common/UnitDefinitions/ForceChangeRate.json +++ b/Common/UnitDefinitions/ForceChangeRate.json @@ -33,6 +33,34 @@ "Abbreviations": [ "N/s" ] } ] + }, + { + "SingularName": "PoundForcePerMinute", + "PluralName": "PoundsForcePerMinute", + "FromUnitToBaseFunc": "x*4.4482216152605095551842641431421/60", + "FromBaseToUnitFunc": "x/4.4482216152605095551842641431421*60", + "Prefixes": [ "Kilo" ], + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "lbf/min" ], + "AbbreviationsForPrefixes": { "Kilo": [ "kipf/min", "kip/min", "k/min" ] } + } + ] + }, + { + "SingularName": "PoundForcePerSecond", + "PluralName": "PoundsForcePerSecond", + "FromUnitToBaseFunc": "x*4.4482216152605095551842641431421", + "FromBaseToUnitFunc": "x/4.4482216152605095551842641431421", + "Prefixes": [ "Kilo" ], + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "lbf/s" ], + "AbbreviationsForPrefixes": { "Kilo": [ "kipf/s", "kip/s", "k/s" ] } + } + ] } ] } diff --git a/Common/UnitDefinitions/Pressure.json b/Common/UnitDefinitions/Pressure.json index 15507b26ca..8d548cee5f 100644 --- a/Common/UnitDefinitions/Pressure.json +++ b/Common/UnitDefinitions/Pressure.json @@ -204,12 +204,12 @@ { "Culture": "en-US", "Abbreviations": [ "psi", "lb/in²" ], - "AbbreviationsForPrefixes": { "Kilo": "kipf/in²" } + "AbbreviationsForPrefixes": { "Kilo": [ "ksi", "kipf/in²" ]} }, { "Culture": "ru-RU", "Abbreviations": [ "psi", "lb/in²" ], - "AbbreviationsForPrefixes": { "Kilo": "kipf/in²" } + "AbbreviationsForPrefixes": { "Kilo": [ "ksi", "kipf/in²" ]} } ] }, diff --git a/Common/UnitDefinitions/PressureChangeRate.json b/Common/UnitDefinitions/PressureChangeRate.json index f4261f3d18..8f301bdea0 100644 --- a/Common/UnitDefinitions/PressureChangeRate.json +++ b/Common/UnitDefinitions/PressureChangeRate.json @@ -38,7 +38,7 @@ }, { "Culture": "ru-RU", - "Abbreviations": [ "Па/с" ] + "Abbreviations": [ "Па/мин" ] } ] }, @@ -57,6 +57,44 @@ "Abbreviations": [ "атм/с" ] } ] + }, + { + "SingularName": "PoundForcePerSquareInchPerSecond", + "PluralName": "PoundsForcePerSquareInchPerSecond", + "FromUnitToBaseFunc": "x*6.894757293168361e3", + "FromBaseToUnitFunc": "x/6.894757293168361e3", + "Prefixes": [ "Kilo", "Mega" ], + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "psi/s", "lb/in²/s" ], + "AbbreviationsForPrefixes": { "Kilo": [ "ksi/s", "kipf/in²/s" ]} + }, + { + "Culture": "ru-RU", + "Abbreviations": [ "psi/с", "lb/in²/с" ], + "AbbreviationsForPrefixes": { "Kilo": [ "ksi/с", "kipf/in²/с" ]} + } + ] + }, + { + "SingularName": "PoundForcePerSquareInchPerMinute", + "PluralName": "PoundsForcePerSquareInchPerMinute", + "FromUnitToBaseFunc": "x*6.894757293168361e3/60", + "FromBaseToUnitFunc": "x/6.894757293168361e3*60", + "Prefixes": [ "Kilo", "Mega" ], + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "psi/min", "lb/in²/min" ], + "AbbreviationsForPrefixes": { "Kilo": [ "ksi/min", "kipf/in²/min" ]} + }, + { + "Culture": "ru-RU", + "Abbreviations": [ "psi/мин", "lb/in²/мин" ], + "AbbreviationsForPrefixes": { "Kilo": [ "ksi/мин", "kipf/in²/мин" ]} + } + ] } ] } diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToForceChangeRateExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToForceChangeRateExtensionsTest.g.cs index 5991f324d8..33c690c637 100644 --- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToForceChangeRateExtensionsTest.g.cs +++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToForceChangeRateExtensionsTest.g.cs @@ -48,6 +48,14 @@ public void NumberToKilonewtonsPerMinuteTest() => public void NumberToKilonewtonsPerSecondTest() => Assert.Equal(ForceChangeRate.FromKilonewtonsPerSecond(2), 2.KilonewtonsPerSecond()); + [Fact] + public void NumberToKilopoundsForcePerMinuteTest() => + Assert.Equal(ForceChangeRate.FromKilopoundsForcePerMinute(2), 2.KilopoundsForcePerMinute()); + + [Fact] + public void NumberToKilopoundsForcePerSecondTest() => + Assert.Equal(ForceChangeRate.FromKilopoundsForcePerSecond(2), 2.KilopoundsForcePerSecond()); + [Fact] public void NumberToMicronewtonsPerSecondTest() => Assert.Equal(ForceChangeRate.FromMicronewtonsPerSecond(2), 2.MicronewtonsPerSecond()); @@ -68,5 +76,13 @@ public void NumberToNewtonsPerMinuteTest() => public void NumberToNewtonsPerSecondTest() => Assert.Equal(ForceChangeRate.FromNewtonsPerSecond(2), 2.NewtonsPerSecond()); + [Fact] + public void NumberToPoundsForcePerMinuteTest() => + Assert.Equal(ForceChangeRate.FromPoundsForcePerMinute(2), 2.PoundsForcePerMinute()); + + [Fact] + public void NumberToPoundsForcePerSecondTest() => + Assert.Equal(ForceChangeRate.FromPoundsForcePerSecond(2), 2.PoundsForcePerSecond()); + } } diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPressureChangeRateExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPressureChangeRateExtensionsTest.g.cs index b231f11fff..8aba87d1ed 100644 --- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPressureChangeRateExtensionsTest.g.cs +++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPressureChangeRateExtensionsTest.g.cs @@ -36,6 +36,14 @@ public void NumberToKilopascalsPerMinuteTest() => public void NumberToKilopascalsPerSecondTest() => Assert.Equal(PressureChangeRate.FromKilopascalsPerSecond(2), 2.KilopascalsPerSecond()); + [Fact] + public void NumberToKilopoundsForcePerSquareInchPerMinuteTest() => + Assert.Equal(PressureChangeRate.FromKilopoundsForcePerSquareInchPerMinute(2), 2.KilopoundsForcePerSquareInchPerMinute()); + + [Fact] + public void NumberToKilopoundsForcePerSquareInchPerSecondTest() => + Assert.Equal(PressureChangeRate.FromKilopoundsForcePerSquareInchPerSecond(2), 2.KilopoundsForcePerSquareInchPerSecond()); + [Fact] public void NumberToMegapascalsPerMinuteTest() => Assert.Equal(PressureChangeRate.FromMegapascalsPerMinute(2), 2.MegapascalsPerMinute()); @@ -44,6 +52,14 @@ public void NumberToMegapascalsPerMinuteTest() => public void NumberToMegapascalsPerSecondTest() => Assert.Equal(PressureChangeRate.FromMegapascalsPerSecond(2), 2.MegapascalsPerSecond()); + [Fact] + public void NumberToMegapoundsForcePerSquareInchPerMinuteTest() => + Assert.Equal(PressureChangeRate.FromMegapoundsForcePerSquareInchPerMinute(2), 2.MegapoundsForcePerSquareInchPerMinute()); + + [Fact] + public void NumberToMegapoundsForcePerSquareInchPerSecondTest() => + Assert.Equal(PressureChangeRate.FromMegapoundsForcePerSquareInchPerSecond(2), 2.MegapoundsForcePerSquareInchPerSecond()); + [Fact] public void NumberToPascalsPerMinuteTest() => Assert.Equal(PressureChangeRate.FromPascalsPerMinute(2), 2.PascalsPerMinute()); @@ -52,5 +68,13 @@ public void NumberToPascalsPerMinuteTest() => public void NumberToPascalsPerSecondTest() => Assert.Equal(PressureChangeRate.FromPascalsPerSecond(2), 2.PascalsPerSecond()); + [Fact] + public void NumberToPoundsForcePerSquareInchPerMinuteTest() => + Assert.Equal(PressureChangeRate.FromPoundsForcePerSquareInchPerMinute(2), 2.PoundsForcePerSquareInchPerMinute()); + + [Fact] + public void NumberToPoundsForcePerSquareInchPerSecondTest() => + Assert.Equal(PressureChangeRate.FromPoundsForcePerSquareInchPerSecond(2), 2.PoundsForcePerSquareInchPerSecond()); + } } diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToForceChangeRateExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToForceChangeRateExtensions.g.cs index df75da1487..5c8c7133cb 100644 --- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToForceChangeRateExtensions.g.cs +++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToForceChangeRateExtensions.g.cs @@ -52,6 +52,14 @@ public static ForceChangeRate KilonewtonsPerMinute(this T value) => public static ForceChangeRate KilonewtonsPerSecond(this T value) => ForceChangeRate.FromKilonewtonsPerSecond(Convert.ToDouble(value)); + /// + public static ForceChangeRate KilopoundsForcePerMinute(this T value) => + ForceChangeRate.FromKilopoundsForcePerMinute(Convert.ToDouble(value)); + + /// + public static ForceChangeRate KilopoundsForcePerSecond(this T value) => + ForceChangeRate.FromKilopoundsForcePerSecond(Convert.ToDouble(value)); + /// public static ForceChangeRate MicronewtonsPerSecond(this T value) => ForceChangeRate.FromMicronewtonsPerSecond(Convert.ToDouble(value)); @@ -72,5 +80,13 @@ public static ForceChangeRate NewtonsPerMinute(this T value) => public static ForceChangeRate NewtonsPerSecond(this T value) => ForceChangeRate.FromNewtonsPerSecond(Convert.ToDouble(value)); + /// + public static ForceChangeRate PoundsForcePerMinute(this T value) => + ForceChangeRate.FromPoundsForcePerMinute(Convert.ToDouble(value)); + + /// + public static ForceChangeRate PoundsForcePerSecond(this T value) => + ForceChangeRate.FromPoundsForcePerSecond(Convert.ToDouble(value)); + } } diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureChangeRateExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureChangeRateExtensions.g.cs index f503510093..0e438df905 100644 --- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureChangeRateExtensions.g.cs +++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureChangeRateExtensions.g.cs @@ -40,6 +40,14 @@ public static PressureChangeRate KilopascalsPerMinute(this T value) => public static PressureChangeRate KilopascalsPerSecond(this T value) => PressureChangeRate.FromKilopascalsPerSecond(Convert.ToDouble(value)); + /// + public static PressureChangeRate KilopoundsForcePerSquareInchPerMinute(this T value) => + PressureChangeRate.FromKilopoundsForcePerSquareInchPerMinute(Convert.ToDouble(value)); + + /// + public static PressureChangeRate KilopoundsForcePerSquareInchPerSecond(this T value) => + PressureChangeRate.FromKilopoundsForcePerSquareInchPerSecond(Convert.ToDouble(value)); + /// public static PressureChangeRate MegapascalsPerMinute(this T value) => PressureChangeRate.FromMegapascalsPerMinute(Convert.ToDouble(value)); @@ -48,6 +56,14 @@ public static PressureChangeRate MegapascalsPerMinute(this T value) => public static PressureChangeRate MegapascalsPerSecond(this T value) => PressureChangeRate.FromMegapascalsPerSecond(Convert.ToDouble(value)); + /// + public static PressureChangeRate MegapoundsForcePerSquareInchPerMinute(this T value) => + PressureChangeRate.FromMegapoundsForcePerSquareInchPerMinute(Convert.ToDouble(value)); + + /// + public static PressureChangeRate MegapoundsForcePerSquareInchPerSecond(this T value) => + PressureChangeRate.FromMegapoundsForcePerSquareInchPerSecond(Convert.ToDouble(value)); + /// public static PressureChangeRate PascalsPerMinute(this T value) => PressureChangeRate.FromPascalsPerMinute(Convert.ToDouble(value)); @@ -56,5 +72,13 @@ public static PressureChangeRate PascalsPerMinute(this T value) => public static PressureChangeRate PascalsPerSecond(this T value) => PressureChangeRate.FromPascalsPerSecond(Convert.ToDouble(value)); + /// + public static PressureChangeRate PoundsForcePerSquareInchPerMinute(this T value) => + PressureChangeRate.FromPoundsForcePerSquareInchPerMinute(Convert.ToDouble(value)); + + /// + public static PressureChangeRate PoundsForcePerSquareInchPerSecond(this T value) => + PressureChangeRate.FromPoundsForcePerSquareInchPerSecond(Convert.ToDouble(value)); + } } diff --git a/UnitsNet.Tests/CustomCode/ForceChangeRateTests.cs b/UnitsNet.Tests/CustomCode/ForceChangeRateTests.cs index c24572b9a0..0dddcebeb3 100644 --- a/UnitsNet.Tests/CustomCode/ForceChangeRateTests.cs +++ b/UnitsNet.Tests/CustomCode/ForceChangeRateTests.cs @@ -10,8 +10,12 @@ public class ForceChangeRateTests : ForceChangeRateTestsBase protected override double DecanewtonsPerMinuteInOneNewtonPerSecond => 6; protected override double KilonewtonsPerMinuteInOneNewtonPerSecond => 0.06; protected override double KilonewtonsPerSecondInOneNewtonPerSecond => 1E-3; + protected override double KilopoundsForcePerMinuteInOneNewtonPerSecond => 0.22481e-3*60; + protected override double KilopoundsForcePerSecondInOneNewtonPerSecond => 0.22481e-3; protected override double DecanewtonsPerSecondInOneNewtonPerSecond => 1E-1; protected override double NewtonsPerSecondInOneNewtonPerSecond => 1; + protected override double PoundsForcePerMinuteInOneNewtonPerSecond => 0.22481 * 60; + protected override double PoundsForcePerSecondInOneNewtonPerSecond => 0.22481; protected override double DecinewtonsPerSecondInOneNewtonPerSecond => 1E1; protected override double CentinewtonsPerSecondInOneNewtonPerSecond => 1E2; protected override double MillinewtonsPerSecondInOneNewtonPerSecond => 1E3; diff --git a/UnitsNet.Tests/CustomCode/PressureChangeRateTests.cs b/UnitsNet.Tests/CustomCode/PressureChangeRateTests.cs index 5aa974e135..8f2b63a074 100644 --- a/UnitsNet.Tests/CustomCode/PressureChangeRateTests.cs +++ b/UnitsNet.Tests/CustomCode/PressureChangeRateTests.cs @@ -10,10 +10,22 @@ public class PressureChangeRateTests : PressureChangeRateTestsBase protected override double KilopascalsPerSecondInOnePascalPerSecond => 1e-3; + protected override double KilopoundsForcePerSquareInchPerMinuteInOnePascalPerSecond => 1.450377377302092e-7 * 60; + + protected override double KilopoundsForcePerSquareInchPerSecondInOnePascalPerSecond => 1.450377377302092e-7; + protected override double MegapascalsPerSecondInOnePascalPerSecond => 1E-6; + protected override double MegapoundsForcePerSquareInchPerMinuteInOnePascalPerSecond => 1.450377377302092e-10 * 60; + + protected override double MegapoundsForcePerSquareInchPerSecondInOnePascalPerSecond => 1.450377377302092e-10; + protected override double PascalsPerSecondInOnePascalPerSecond => 1; + protected override double PoundsForcePerSquareInchPerMinuteInOnePascalPerSecond => 1.450377377302092e-4 * 60; + + protected override double PoundsForcePerSquareInchPerSecondInOnePascalPerSecond => 1.450377377302092e-4; + protected override double MegapascalsPerMinuteInOnePascalPerSecond => 6e-5; protected override double KilopascalsPerMinuteInOnePascalPerSecond => 6e-2; diff --git a/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs b/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs index 06256585f7..c1344dd079 100644 --- a/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs +++ b/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs @@ -70,7 +70,7 @@ void Assertion(int expectedValue, Enum expectedUnit, IQuantity quantity) Assertion(3, EnergyUnit.WattHour, Quantity.From(3, EnergyUnit.WattHour)); Assertion(3, EntropyUnit.MegajoulePerKelvin, Quantity.From(3, EntropyUnit.MegajoulePerKelvin)); Assertion(3, ForceUnit.TonneForce, Quantity.From(3, ForceUnit.TonneForce)); - Assertion(3, ForceChangeRateUnit.NewtonPerSecond, Quantity.From(3, ForceChangeRateUnit.NewtonPerSecond)); + Assertion(3, ForceChangeRateUnit.PoundForcePerSecond, Quantity.From(3, ForceChangeRateUnit.PoundForcePerSecond)); Assertion(3, ForcePerLengthUnit.TonneForcePerMillimeter, Quantity.From(3, ForcePerLengthUnit.TonneForcePerMillimeter)); Assertion(3, FrequencyUnit.Terahertz, Quantity.From(3, FrequencyUnit.Terahertz)); Assertion(3, FuelEfficiencyUnit.MilePerUsGallon, Quantity.From(3, FuelEfficiencyUnit.MilePerUsGallon)); @@ -108,7 +108,7 @@ void Assertion(int expectedValue, Enum expectedUnit, IQuantity quantity) Assertion(3, PowerDensityUnit.WattPerLiter, Quantity.From(3, PowerDensityUnit.WattPerLiter)); Assertion(3, PowerRatioUnit.DecibelWatt, Quantity.From(3, PowerRatioUnit.DecibelWatt)); Assertion(3, PressureUnit.Torr, Quantity.From(3, PressureUnit.Torr)); - Assertion(3, PressureChangeRateUnit.PascalPerSecond, Quantity.From(3, PressureChangeRateUnit.PascalPerSecond)); + Assertion(3, PressureChangeRateUnit.PoundForcePerSquareInchPerSecond, Quantity.From(3, PressureChangeRateUnit.PoundForcePerSquareInchPerSecond)); Assertion(3, RatioUnit.Percent, Quantity.From(3, RatioUnit.Percent)); Assertion(3, RatioChangeRateUnit.PercentPerSecond, Quantity.From(3, RatioChangeRateUnit.PercentPerSecond)); Assertion(3, ReactiveEnergyUnit.VoltampereReactiveHour, Quantity.From(3, ReactiveEnergyUnit.VoltampereReactiveHour)); diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ForceChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ForceChangeRateTestsBase.g.cs index f411068d8a..e453cd6fd9 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/ForceChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ForceChangeRateTestsBase.g.cs @@ -43,11 +43,15 @@ public abstract partial class ForceChangeRateTestsBase : QuantityTestsBase protected abstract double DecinewtonsPerSecondInOneNewtonPerSecond { get; } protected abstract double KilonewtonsPerMinuteInOneNewtonPerSecond { get; } protected abstract double KilonewtonsPerSecondInOneNewtonPerSecond { get; } + protected abstract double KilopoundsForcePerMinuteInOneNewtonPerSecond { get; } + protected abstract double KilopoundsForcePerSecondInOneNewtonPerSecond { get; } protected abstract double MicronewtonsPerSecondInOneNewtonPerSecond { get; } protected abstract double MillinewtonsPerSecondInOneNewtonPerSecond { get; } protected abstract double NanonewtonsPerSecondInOneNewtonPerSecond { get; } protected abstract double NewtonsPerMinuteInOneNewtonPerSecond { get; } protected abstract double NewtonsPerSecondInOneNewtonPerSecond { get; } + protected abstract double PoundsForcePerMinuteInOneNewtonPerSecond { get; } + protected abstract double PoundsForcePerSecondInOneNewtonPerSecond { get; } // ReSharper disable VirtualMemberNeverOverriden.Global protected virtual double CentinewtonsPerSecondTolerance { get { return 1e-5; } } @@ -56,11 +60,15 @@ public abstract partial class ForceChangeRateTestsBase : QuantityTestsBase protected virtual double DecinewtonsPerSecondTolerance { get { return 1e-5; } } protected virtual double KilonewtonsPerMinuteTolerance { get { return 1e-5; } } protected virtual double KilonewtonsPerSecondTolerance { get { return 1e-5; } } + protected virtual double KilopoundsForcePerMinuteTolerance { get { return 1e-5; } } + protected virtual double KilopoundsForcePerSecondTolerance { get { return 1e-5; } } protected virtual double MicronewtonsPerSecondTolerance { get { return 1e-5; } } protected virtual double MillinewtonsPerSecondTolerance { get { return 1e-5; } } protected virtual double NanonewtonsPerSecondTolerance { get { return 1e-5; } } protected virtual double NewtonsPerMinuteTolerance { get { return 1e-5; } } protected virtual double NewtonsPerSecondTolerance { get { return 1e-5; } } + protected virtual double PoundsForcePerMinuteTolerance { get { return 1e-5; } } + protected virtual double PoundsForcePerSecondTolerance { get { return 1e-5; } } // ReSharper restore VirtualMemberNeverOverriden.Global [Fact] @@ -141,11 +149,15 @@ public void NewtonPerSecondToForceChangeRateUnits() AssertEx.EqualTolerance(DecinewtonsPerSecondInOneNewtonPerSecond, newtonpersecond.DecinewtonsPerSecond, DecinewtonsPerSecondTolerance); AssertEx.EqualTolerance(KilonewtonsPerMinuteInOneNewtonPerSecond, newtonpersecond.KilonewtonsPerMinute, KilonewtonsPerMinuteTolerance); AssertEx.EqualTolerance(KilonewtonsPerSecondInOneNewtonPerSecond, newtonpersecond.KilonewtonsPerSecond, KilonewtonsPerSecondTolerance); + AssertEx.EqualTolerance(KilopoundsForcePerMinuteInOneNewtonPerSecond, newtonpersecond.KilopoundsForcePerMinute, KilopoundsForcePerMinuteTolerance); + AssertEx.EqualTolerance(KilopoundsForcePerSecondInOneNewtonPerSecond, newtonpersecond.KilopoundsForcePerSecond, KilopoundsForcePerSecondTolerance); AssertEx.EqualTolerance(MicronewtonsPerSecondInOneNewtonPerSecond, newtonpersecond.MicronewtonsPerSecond, MicronewtonsPerSecondTolerance); AssertEx.EqualTolerance(MillinewtonsPerSecondInOneNewtonPerSecond, newtonpersecond.MillinewtonsPerSecond, MillinewtonsPerSecondTolerance); AssertEx.EqualTolerance(NanonewtonsPerSecondInOneNewtonPerSecond, newtonpersecond.NanonewtonsPerSecond, NanonewtonsPerSecondTolerance); AssertEx.EqualTolerance(NewtonsPerMinuteInOneNewtonPerSecond, newtonpersecond.NewtonsPerMinute, NewtonsPerMinuteTolerance); AssertEx.EqualTolerance(NewtonsPerSecondInOneNewtonPerSecond, newtonpersecond.NewtonsPerSecond, NewtonsPerSecondTolerance); + AssertEx.EqualTolerance(PoundsForcePerMinuteInOneNewtonPerSecond, newtonpersecond.PoundsForcePerMinute, PoundsForcePerMinuteTolerance); + AssertEx.EqualTolerance(PoundsForcePerSecondInOneNewtonPerSecond, newtonpersecond.PoundsForcePerSecond, PoundsForcePerSecondTolerance); } [Fact] @@ -175,25 +187,41 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() AssertEx.EqualTolerance(1, quantity05.KilonewtonsPerSecond, KilonewtonsPerSecondTolerance); Assert.Equal(ForceChangeRateUnit.KilonewtonPerSecond, quantity05.Unit); - var quantity06 = ForceChangeRate.From(1, ForceChangeRateUnit.MicronewtonPerSecond); - AssertEx.EqualTolerance(1, quantity06.MicronewtonsPerSecond, MicronewtonsPerSecondTolerance); - Assert.Equal(ForceChangeRateUnit.MicronewtonPerSecond, quantity06.Unit); + var quantity06 = ForceChangeRate.From(1, ForceChangeRateUnit.KilopoundForcePerMinute); + AssertEx.EqualTolerance(1, quantity06.KilopoundsForcePerMinute, KilopoundsForcePerMinuteTolerance); + Assert.Equal(ForceChangeRateUnit.KilopoundForcePerMinute, quantity06.Unit); - var quantity07 = ForceChangeRate.From(1, ForceChangeRateUnit.MillinewtonPerSecond); - AssertEx.EqualTolerance(1, quantity07.MillinewtonsPerSecond, MillinewtonsPerSecondTolerance); - Assert.Equal(ForceChangeRateUnit.MillinewtonPerSecond, quantity07.Unit); + var quantity07 = ForceChangeRate.From(1, ForceChangeRateUnit.KilopoundForcePerSecond); + AssertEx.EqualTolerance(1, quantity07.KilopoundsForcePerSecond, KilopoundsForcePerSecondTolerance); + Assert.Equal(ForceChangeRateUnit.KilopoundForcePerSecond, quantity07.Unit); - var quantity08 = ForceChangeRate.From(1, ForceChangeRateUnit.NanonewtonPerSecond); - AssertEx.EqualTolerance(1, quantity08.NanonewtonsPerSecond, NanonewtonsPerSecondTolerance); - Assert.Equal(ForceChangeRateUnit.NanonewtonPerSecond, quantity08.Unit); + var quantity08 = ForceChangeRate.From(1, ForceChangeRateUnit.MicronewtonPerSecond); + AssertEx.EqualTolerance(1, quantity08.MicronewtonsPerSecond, MicronewtonsPerSecondTolerance); + Assert.Equal(ForceChangeRateUnit.MicronewtonPerSecond, quantity08.Unit); - var quantity09 = ForceChangeRate.From(1, ForceChangeRateUnit.NewtonPerMinute); - AssertEx.EqualTolerance(1, quantity09.NewtonsPerMinute, NewtonsPerMinuteTolerance); - Assert.Equal(ForceChangeRateUnit.NewtonPerMinute, quantity09.Unit); + var quantity09 = ForceChangeRate.From(1, ForceChangeRateUnit.MillinewtonPerSecond); + AssertEx.EqualTolerance(1, quantity09.MillinewtonsPerSecond, MillinewtonsPerSecondTolerance); + Assert.Equal(ForceChangeRateUnit.MillinewtonPerSecond, quantity09.Unit); - var quantity10 = ForceChangeRate.From(1, ForceChangeRateUnit.NewtonPerSecond); - AssertEx.EqualTolerance(1, quantity10.NewtonsPerSecond, NewtonsPerSecondTolerance); - Assert.Equal(ForceChangeRateUnit.NewtonPerSecond, quantity10.Unit); + var quantity10 = ForceChangeRate.From(1, ForceChangeRateUnit.NanonewtonPerSecond); + AssertEx.EqualTolerance(1, quantity10.NanonewtonsPerSecond, NanonewtonsPerSecondTolerance); + Assert.Equal(ForceChangeRateUnit.NanonewtonPerSecond, quantity10.Unit); + + var quantity11 = ForceChangeRate.From(1, ForceChangeRateUnit.NewtonPerMinute); + AssertEx.EqualTolerance(1, quantity11.NewtonsPerMinute, NewtonsPerMinuteTolerance); + Assert.Equal(ForceChangeRateUnit.NewtonPerMinute, quantity11.Unit); + + var quantity12 = ForceChangeRate.From(1, ForceChangeRateUnit.NewtonPerSecond); + AssertEx.EqualTolerance(1, quantity12.NewtonsPerSecond, NewtonsPerSecondTolerance); + Assert.Equal(ForceChangeRateUnit.NewtonPerSecond, quantity12.Unit); + + var quantity13 = ForceChangeRate.From(1, ForceChangeRateUnit.PoundForcePerMinute); + AssertEx.EqualTolerance(1, quantity13.PoundsForcePerMinute, PoundsForcePerMinuteTolerance); + Assert.Equal(ForceChangeRateUnit.PoundForcePerMinute, quantity13.Unit); + + var quantity14 = ForceChangeRate.From(1, ForceChangeRateUnit.PoundForcePerSecond); + AssertEx.EqualTolerance(1, quantity14.PoundsForcePerSecond, PoundsForcePerSecondTolerance); + Assert.Equal(ForceChangeRateUnit.PoundForcePerSecond, quantity14.Unit); } @@ -220,11 +248,15 @@ public void As() AssertEx.EqualTolerance(DecinewtonsPerSecondInOneNewtonPerSecond, newtonpersecond.As(ForceChangeRateUnit.DecinewtonPerSecond), DecinewtonsPerSecondTolerance); AssertEx.EqualTolerance(KilonewtonsPerMinuteInOneNewtonPerSecond, newtonpersecond.As(ForceChangeRateUnit.KilonewtonPerMinute), KilonewtonsPerMinuteTolerance); AssertEx.EqualTolerance(KilonewtonsPerSecondInOneNewtonPerSecond, newtonpersecond.As(ForceChangeRateUnit.KilonewtonPerSecond), KilonewtonsPerSecondTolerance); + AssertEx.EqualTolerance(KilopoundsForcePerMinuteInOneNewtonPerSecond, newtonpersecond.As(ForceChangeRateUnit.KilopoundForcePerMinute), KilopoundsForcePerMinuteTolerance); + AssertEx.EqualTolerance(KilopoundsForcePerSecondInOneNewtonPerSecond, newtonpersecond.As(ForceChangeRateUnit.KilopoundForcePerSecond), KilopoundsForcePerSecondTolerance); AssertEx.EqualTolerance(MicronewtonsPerSecondInOneNewtonPerSecond, newtonpersecond.As(ForceChangeRateUnit.MicronewtonPerSecond), MicronewtonsPerSecondTolerance); AssertEx.EqualTolerance(MillinewtonsPerSecondInOneNewtonPerSecond, newtonpersecond.As(ForceChangeRateUnit.MillinewtonPerSecond), MillinewtonsPerSecondTolerance); AssertEx.EqualTolerance(NanonewtonsPerSecondInOneNewtonPerSecond, newtonpersecond.As(ForceChangeRateUnit.NanonewtonPerSecond), NanonewtonsPerSecondTolerance); AssertEx.EqualTolerance(NewtonsPerMinuteInOneNewtonPerSecond, newtonpersecond.As(ForceChangeRateUnit.NewtonPerMinute), NewtonsPerMinuteTolerance); AssertEx.EqualTolerance(NewtonsPerSecondInOneNewtonPerSecond, newtonpersecond.As(ForceChangeRateUnit.NewtonPerSecond), NewtonsPerSecondTolerance); + AssertEx.EqualTolerance(PoundsForcePerMinuteInOneNewtonPerSecond, newtonpersecond.As(ForceChangeRateUnit.PoundForcePerMinute), PoundsForcePerMinuteTolerance); + AssertEx.EqualTolerance(PoundsForcePerSecondInOneNewtonPerSecond, newtonpersecond.As(ForceChangeRateUnit.PoundForcePerSecond), PoundsForcePerSecondTolerance); } [Fact] @@ -273,6 +305,14 @@ public void ToUnit() AssertEx.EqualTolerance(KilonewtonsPerSecondInOneNewtonPerSecond, (double)kilonewtonpersecondQuantity.Value, KilonewtonsPerSecondTolerance); Assert.Equal(ForceChangeRateUnit.KilonewtonPerSecond, kilonewtonpersecondQuantity.Unit); + var kilopoundforceperminuteQuantity = newtonpersecond.ToUnit(ForceChangeRateUnit.KilopoundForcePerMinute); + AssertEx.EqualTolerance(KilopoundsForcePerMinuteInOneNewtonPerSecond, (double)kilopoundforceperminuteQuantity.Value, KilopoundsForcePerMinuteTolerance); + Assert.Equal(ForceChangeRateUnit.KilopoundForcePerMinute, kilopoundforceperminuteQuantity.Unit); + + var kilopoundforcepersecondQuantity = newtonpersecond.ToUnit(ForceChangeRateUnit.KilopoundForcePerSecond); + AssertEx.EqualTolerance(KilopoundsForcePerSecondInOneNewtonPerSecond, (double)kilopoundforcepersecondQuantity.Value, KilopoundsForcePerSecondTolerance); + Assert.Equal(ForceChangeRateUnit.KilopoundForcePerSecond, kilopoundforcepersecondQuantity.Unit); + var micronewtonpersecondQuantity = newtonpersecond.ToUnit(ForceChangeRateUnit.MicronewtonPerSecond); AssertEx.EqualTolerance(MicronewtonsPerSecondInOneNewtonPerSecond, (double)micronewtonpersecondQuantity.Value, MicronewtonsPerSecondTolerance); Assert.Equal(ForceChangeRateUnit.MicronewtonPerSecond, micronewtonpersecondQuantity.Unit); @@ -292,6 +332,14 @@ public void ToUnit() var newtonpersecondQuantity = newtonpersecond.ToUnit(ForceChangeRateUnit.NewtonPerSecond); AssertEx.EqualTolerance(NewtonsPerSecondInOneNewtonPerSecond, (double)newtonpersecondQuantity.Value, NewtonsPerSecondTolerance); Assert.Equal(ForceChangeRateUnit.NewtonPerSecond, newtonpersecondQuantity.Unit); + + var poundforceperminuteQuantity = newtonpersecond.ToUnit(ForceChangeRateUnit.PoundForcePerMinute); + AssertEx.EqualTolerance(PoundsForcePerMinuteInOneNewtonPerSecond, (double)poundforceperminuteQuantity.Value, PoundsForcePerMinuteTolerance); + Assert.Equal(ForceChangeRateUnit.PoundForcePerMinute, poundforceperminuteQuantity.Unit); + + var poundforcepersecondQuantity = newtonpersecond.ToUnit(ForceChangeRateUnit.PoundForcePerSecond); + AssertEx.EqualTolerance(PoundsForcePerSecondInOneNewtonPerSecond, (double)poundforcepersecondQuantity.Value, PoundsForcePerSecondTolerance); + Assert.Equal(ForceChangeRateUnit.PoundForcePerSecond, poundforcepersecondQuantity.Unit); } [Fact] @@ -311,11 +359,15 @@ public void ConversionRoundTrip() AssertEx.EqualTolerance(1, ForceChangeRate.FromDecinewtonsPerSecond(newtonpersecond.DecinewtonsPerSecond).NewtonsPerSecond, DecinewtonsPerSecondTolerance); AssertEx.EqualTolerance(1, ForceChangeRate.FromKilonewtonsPerMinute(newtonpersecond.KilonewtonsPerMinute).NewtonsPerSecond, KilonewtonsPerMinuteTolerance); AssertEx.EqualTolerance(1, ForceChangeRate.FromKilonewtonsPerSecond(newtonpersecond.KilonewtonsPerSecond).NewtonsPerSecond, KilonewtonsPerSecondTolerance); + AssertEx.EqualTolerance(1, ForceChangeRate.FromKilopoundsForcePerMinute(newtonpersecond.KilopoundsForcePerMinute).NewtonsPerSecond, KilopoundsForcePerMinuteTolerance); + AssertEx.EqualTolerance(1, ForceChangeRate.FromKilopoundsForcePerSecond(newtonpersecond.KilopoundsForcePerSecond).NewtonsPerSecond, KilopoundsForcePerSecondTolerance); AssertEx.EqualTolerance(1, ForceChangeRate.FromMicronewtonsPerSecond(newtonpersecond.MicronewtonsPerSecond).NewtonsPerSecond, MicronewtonsPerSecondTolerance); AssertEx.EqualTolerance(1, ForceChangeRate.FromMillinewtonsPerSecond(newtonpersecond.MillinewtonsPerSecond).NewtonsPerSecond, MillinewtonsPerSecondTolerance); AssertEx.EqualTolerance(1, ForceChangeRate.FromNanonewtonsPerSecond(newtonpersecond.NanonewtonsPerSecond).NewtonsPerSecond, NanonewtonsPerSecondTolerance); AssertEx.EqualTolerance(1, ForceChangeRate.FromNewtonsPerMinute(newtonpersecond.NewtonsPerMinute).NewtonsPerSecond, NewtonsPerMinuteTolerance); AssertEx.EqualTolerance(1, ForceChangeRate.FromNewtonsPerSecond(newtonpersecond.NewtonsPerSecond).NewtonsPerSecond, NewtonsPerSecondTolerance); + AssertEx.EqualTolerance(1, ForceChangeRate.FromPoundsForcePerMinute(newtonpersecond.PoundsForcePerMinute).NewtonsPerSecond, PoundsForcePerMinuteTolerance); + AssertEx.EqualTolerance(1, ForceChangeRate.FromPoundsForcePerSecond(newtonpersecond.PoundsForcePerSecond).NewtonsPerSecond, PoundsForcePerSecondTolerance); } [Fact] @@ -478,11 +530,15 @@ public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture() Assert.Equal("1 dN/s", new ForceChangeRate(1, ForceChangeRateUnit.DecinewtonPerSecond).ToString()); Assert.Equal("1 kN/min", new ForceChangeRate(1, ForceChangeRateUnit.KilonewtonPerMinute).ToString()); Assert.Equal("1 kN/s", new ForceChangeRate(1, ForceChangeRateUnit.KilonewtonPerSecond).ToString()); + Assert.Equal("1 kipf/min", new ForceChangeRate(1, ForceChangeRateUnit.KilopoundForcePerMinute).ToString()); + Assert.Equal("1 kipf/s", new ForceChangeRate(1, ForceChangeRateUnit.KilopoundForcePerSecond).ToString()); Assert.Equal("1 µN/s", new ForceChangeRate(1, ForceChangeRateUnit.MicronewtonPerSecond).ToString()); Assert.Equal("1 mN/s", new ForceChangeRate(1, ForceChangeRateUnit.MillinewtonPerSecond).ToString()); Assert.Equal("1 nN/s", new ForceChangeRate(1, ForceChangeRateUnit.NanonewtonPerSecond).ToString()); Assert.Equal("1 N/min", new ForceChangeRate(1, ForceChangeRateUnit.NewtonPerMinute).ToString()); Assert.Equal("1 N/s", new ForceChangeRate(1, ForceChangeRateUnit.NewtonPerSecond).ToString()); + Assert.Equal("1 lbf/min", new ForceChangeRate(1, ForceChangeRateUnit.PoundForcePerMinute).ToString()); + Assert.Equal("1 lbf/s", new ForceChangeRate(1, ForceChangeRateUnit.PoundForcePerSecond).ToString()); } finally { @@ -502,11 +558,15 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture Assert.Equal("1 dN/s", new ForceChangeRate(1, ForceChangeRateUnit.DecinewtonPerSecond).ToString(swedishCulture)); Assert.Equal("1 kN/min", new ForceChangeRate(1, ForceChangeRateUnit.KilonewtonPerMinute).ToString(swedishCulture)); Assert.Equal("1 kN/s", new ForceChangeRate(1, ForceChangeRateUnit.KilonewtonPerSecond).ToString(swedishCulture)); + Assert.Equal("1 kipf/min", new ForceChangeRate(1, ForceChangeRateUnit.KilopoundForcePerMinute).ToString(swedishCulture)); + Assert.Equal("1 kipf/s", new ForceChangeRate(1, ForceChangeRateUnit.KilopoundForcePerSecond).ToString(swedishCulture)); Assert.Equal("1 µN/s", new ForceChangeRate(1, ForceChangeRateUnit.MicronewtonPerSecond).ToString(swedishCulture)); Assert.Equal("1 mN/s", new ForceChangeRate(1, ForceChangeRateUnit.MillinewtonPerSecond).ToString(swedishCulture)); Assert.Equal("1 nN/s", new ForceChangeRate(1, ForceChangeRateUnit.NanonewtonPerSecond).ToString(swedishCulture)); Assert.Equal("1 N/min", new ForceChangeRate(1, ForceChangeRateUnit.NewtonPerMinute).ToString(swedishCulture)); Assert.Equal("1 N/s", new ForceChangeRate(1, ForceChangeRateUnit.NewtonPerSecond).ToString(swedishCulture)); + Assert.Equal("1 lbf/min", new ForceChangeRate(1, ForceChangeRateUnit.PoundForcePerMinute).ToString(swedishCulture)); + Assert.Equal("1 lbf/s", new ForceChangeRate(1, ForceChangeRateUnit.PoundForcePerSecond).ToString(swedishCulture)); } [Fact] diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/PressureChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/PressureChangeRateTestsBase.g.cs index e75af9d61b..2dc4b4c71f 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/PressureChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/PressureChangeRateTestsBase.g.cs @@ -40,19 +40,31 @@ public abstract partial class PressureChangeRateTestsBase : QuantityTestsBase protected abstract double AtmospheresPerSecondInOnePascalPerSecond { get; } protected abstract double KilopascalsPerMinuteInOnePascalPerSecond { get; } protected abstract double KilopascalsPerSecondInOnePascalPerSecond { get; } + protected abstract double KilopoundsForcePerSquareInchPerMinuteInOnePascalPerSecond { get; } + protected abstract double KilopoundsForcePerSquareInchPerSecondInOnePascalPerSecond { get; } protected abstract double MegapascalsPerMinuteInOnePascalPerSecond { get; } protected abstract double MegapascalsPerSecondInOnePascalPerSecond { get; } + protected abstract double MegapoundsForcePerSquareInchPerMinuteInOnePascalPerSecond { get; } + protected abstract double MegapoundsForcePerSquareInchPerSecondInOnePascalPerSecond { get; } protected abstract double PascalsPerMinuteInOnePascalPerSecond { get; } protected abstract double PascalsPerSecondInOnePascalPerSecond { get; } + protected abstract double PoundsForcePerSquareInchPerMinuteInOnePascalPerSecond { get; } + protected abstract double PoundsForcePerSquareInchPerSecondInOnePascalPerSecond { get; } // ReSharper disable VirtualMemberNeverOverriden.Global protected virtual double AtmospheresPerSecondTolerance { get { return 1e-5; } } protected virtual double KilopascalsPerMinuteTolerance { get { return 1e-5; } } protected virtual double KilopascalsPerSecondTolerance { get { return 1e-5; } } + protected virtual double KilopoundsForcePerSquareInchPerMinuteTolerance { get { return 1e-5; } } + protected virtual double KilopoundsForcePerSquareInchPerSecondTolerance { get { return 1e-5; } } protected virtual double MegapascalsPerMinuteTolerance { get { return 1e-5; } } protected virtual double MegapascalsPerSecondTolerance { get { return 1e-5; } } + protected virtual double MegapoundsForcePerSquareInchPerMinuteTolerance { get { return 1e-5; } } + protected virtual double MegapoundsForcePerSquareInchPerSecondTolerance { get { return 1e-5; } } protected virtual double PascalsPerMinuteTolerance { get { return 1e-5; } } protected virtual double PascalsPerSecondTolerance { get { return 1e-5; } } + protected virtual double PoundsForcePerSquareInchPerMinuteTolerance { get { return 1e-5; } } + protected virtual double PoundsForcePerSquareInchPerSecondTolerance { get { return 1e-5; } } // ReSharper restore VirtualMemberNeverOverriden.Global [Fact] @@ -130,10 +142,16 @@ public void PascalPerSecondToPressureChangeRateUnits() AssertEx.EqualTolerance(AtmospheresPerSecondInOnePascalPerSecond, pascalpersecond.AtmospheresPerSecond, AtmospheresPerSecondTolerance); AssertEx.EqualTolerance(KilopascalsPerMinuteInOnePascalPerSecond, pascalpersecond.KilopascalsPerMinute, KilopascalsPerMinuteTolerance); AssertEx.EqualTolerance(KilopascalsPerSecondInOnePascalPerSecond, pascalpersecond.KilopascalsPerSecond, KilopascalsPerSecondTolerance); + AssertEx.EqualTolerance(KilopoundsForcePerSquareInchPerMinuteInOnePascalPerSecond, pascalpersecond.KilopoundsForcePerSquareInchPerMinute, KilopoundsForcePerSquareInchPerMinuteTolerance); + AssertEx.EqualTolerance(KilopoundsForcePerSquareInchPerSecondInOnePascalPerSecond, pascalpersecond.KilopoundsForcePerSquareInchPerSecond, KilopoundsForcePerSquareInchPerSecondTolerance); AssertEx.EqualTolerance(MegapascalsPerMinuteInOnePascalPerSecond, pascalpersecond.MegapascalsPerMinute, MegapascalsPerMinuteTolerance); AssertEx.EqualTolerance(MegapascalsPerSecondInOnePascalPerSecond, pascalpersecond.MegapascalsPerSecond, MegapascalsPerSecondTolerance); + AssertEx.EqualTolerance(MegapoundsForcePerSquareInchPerMinuteInOnePascalPerSecond, pascalpersecond.MegapoundsForcePerSquareInchPerMinute, MegapoundsForcePerSquareInchPerMinuteTolerance); + AssertEx.EqualTolerance(MegapoundsForcePerSquareInchPerSecondInOnePascalPerSecond, pascalpersecond.MegapoundsForcePerSquareInchPerSecond, MegapoundsForcePerSquareInchPerSecondTolerance); AssertEx.EqualTolerance(PascalsPerMinuteInOnePascalPerSecond, pascalpersecond.PascalsPerMinute, PascalsPerMinuteTolerance); AssertEx.EqualTolerance(PascalsPerSecondInOnePascalPerSecond, pascalpersecond.PascalsPerSecond, PascalsPerSecondTolerance); + AssertEx.EqualTolerance(PoundsForcePerSquareInchPerMinuteInOnePascalPerSecond, pascalpersecond.PoundsForcePerSquareInchPerMinute, PoundsForcePerSquareInchPerMinuteTolerance); + AssertEx.EqualTolerance(PoundsForcePerSquareInchPerSecondInOnePascalPerSecond, pascalpersecond.PoundsForcePerSquareInchPerSecond, PoundsForcePerSquareInchPerSecondTolerance); } [Fact] @@ -151,21 +169,45 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() AssertEx.EqualTolerance(1, quantity02.KilopascalsPerSecond, KilopascalsPerSecondTolerance); Assert.Equal(PressureChangeRateUnit.KilopascalPerSecond, quantity02.Unit); - var quantity03 = PressureChangeRate.From(1, PressureChangeRateUnit.MegapascalPerMinute); - AssertEx.EqualTolerance(1, quantity03.MegapascalsPerMinute, MegapascalsPerMinuteTolerance); - Assert.Equal(PressureChangeRateUnit.MegapascalPerMinute, quantity03.Unit); + var quantity03 = PressureChangeRate.From(1, PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute); + AssertEx.EqualTolerance(1, quantity03.KilopoundsForcePerSquareInchPerMinute, KilopoundsForcePerSquareInchPerMinuteTolerance); + Assert.Equal(PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute, quantity03.Unit); - var quantity04 = PressureChangeRate.From(1, PressureChangeRateUnit.MegapascalPerSecond); - AssertEx.EqualTolerance(1, quantity04.MegapascalsPerSecond, MegapascalsPerSecondTolerance); - Assert.Equal(PressureChangeRateUnit.MegapascalPerSecond, quantity04.Unit); + var quantity04 = PressureChangeRate.From(1, PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond); + AssertEx.EqualTolerance(1, quantity04.KilopoundsForcePerSquareInchPerSecond, KilopoundsForcePerSquareInchPerSecondTolerance); + Assert.Equal(PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond, quantity04.Unit); - var quantity05 = PressureChangeRate.From(1, PressureChangeRateUnit.PascalPerMinute); - AssertEx.EqualTolerance(1, quantity05.PascalsPerMinute, PascalsPerMinuteTolerance); - Assert.Equal(PressureChangeRateUnit.PascalPerMinute, quantity05.Unit); + var quantity05 = PressureChangeRate.From(1, PressureChangeRateUnit.MegapascalPerMinute); + AssertEx.EqualTolerance(1, quantity05.MegapascalsPerMinute, MegapascalsPerMinuteTolerance); + Assert.Equal(PressureChangeRateUnit.MegapascalPerMinute, quantity05.Unit); - var quantity06 = PressureChangeRate.From(1, PressureChangeRateUnit.PascalPerSecond); - AssertEx.EqualTolerance(1, quantity06.PascalsPerSecond, PascalsPerSecondTolerance); - Assert.Equal(PressureChangeRateUnit.PascalPerSecond, quantity06.Unit); + var quantity06 = PressureChangeRate.From(1, PressureChangeRateUnit.MegapascalPerSecond); + AssertEx.EqualTolerance(1, quantity06.MegapascalsPerSecond, MegapascalsPerSecondTolerance); + Assert.Equal(PressureChangeRateUnit.MegapascalPerSecond, quantity06.Unit); + + var quantity07 = PressureChangeRate.From(1, PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute); + AssertEx.EqualTolerance(1, quantity07.MegapoundsForcePerSquareInchPerMinute, MegapoundsForcePerSquareInchPerMinuteTolerance); + Assert.Equal(PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute, quantity07.Unit); + + var quantity08 = PressureChangeRate.From(1, PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond); + AssertEx.EqualTolerance(1, quantity08.MegapoundsForcePerSquareInchPerSecond, MegapoundsForcePerSquareInchPerSecondTolerance); + Assert.Equal(PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond, quantity08.Unit); + + var quantity09 = PressureChangeRate.From(1, PressureChangeRateUnit.PascalPerMinute); + AssertEx.EqualTolerance(1, quantity09.PascalsPerMinute, PascalsPerMinuteTolerance); + Assert.Equal(PressureChangeRateUnit.PascalPerMinute, quantity09.Unit); + + var quantity10 = PressureChangeRate.From(1, PressureChangeRateUnit.PascalPerSecond); + AssertEx.EqualTolerance(1, quantity10.PascalsPerSecond, PascalsPerSecondTolerance); + Assert.Equal(PressureChangeRateUnit.PascalPerSecond, quantity10.Unit); + + var quantity11 = PressureChangeRate.From(1, PressureChangeRateUnit.PoundForcePerSquareInchPerMinute); + AssertEx.EqualTolerance(1, quantity11.PoundsForcePerSquareInchPerMinute, PoundsForcePerSquareInchPerMinuteTolerance); + Assert.Equal(PressureChangeRateUnit.PoundForcePerSquareInchPerMinute, quantity11.Unit); + + var quantity12 = PressureChangeRate.From(1, PressureChangeRateUnit.PoundForcePerSquareInchPerSecond); + AssertEx.EqualTolerance(1, quantity12.PoundsForcePerSquareInchPerSecond, PoundsForcePerSquareInchPerSecondTolerance); + Assert.Equal(PressureChangeRateUnit.PoundForcePerSquareInchPerSecond, quantity12.Unit); } @@ -189,10 +231,16 @@ public void As() AssertEx.EqualTolerance(AtmospheresPerSecondInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.AtmospherePerSecond), AtmospheresPerSecondTolerance); AssertEx.EqualTolerance(KilopascalsPerMinuteInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.KilopascalPerMinute), KilopascalsPerMinuteTolerance); AssertEx.EqualTolerance(KilopascalsPerSecondInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.KilopascalPerSecond), KilopascalsPerSecondTolerance); + AssertEx.EqualTolerance(KilopoundsForcePerSquareInchPerMinuteInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute), KilopoundsForcePerSquareInchPerMinuteTolerance); + AssertEx.EqualTolerance(KilopoundsForcePerSquareInchPerSecondInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond), KilopoundsForcePerSquareInchPerSecondTolerance); AssertEx.EqualTolerance(MegapascalsPerMinuteInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.MegapascalPerMinute), MegapascalsPerMinuteTolerance); AssertEx.EqualTolerance(MegapascalsPerSecondInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.MegapascalPerSecond), MegapascalsPerSecondTolerance); + AssertEx.EqualTolerance(MegapoundsForcePerSquareInchPerMinuteInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute), MegapoundsForcePerSquareInchPerMinuteTolerance); + AssertEx.EqualTolerance(MegapoundsForcePerSquareInchPerSecondInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond), MegapoundsForcePerSquareInchPerSecondTolerance); AssertEx.EqualTolerance(PascalsPerMinuteInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.PascalPerMinute), PascalsPerMinuteTolerance); AssertEx.EqualTolerance(PascalsPerSecondInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.PascalPerSecond), PascalsPerSecondTolerance); + AssertEx.EqualTolerance(PoundsForcePerSquareInchPerMinuteInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.PoundForcePerSquareInchPerMinute), PoundsForcePerSquareInchPerMinuteTolerance); + AssertEx.EqualTolerance(PoundsForcePerSquareInchPerSecondInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.PoundForcePerSquareInchPerSecond), PoundsForcePerSquareInchPerSecondTolerance); } [Fact] @@ -229,6 +277,14 @@ public void ToUnit() AssertEx.EqualTolerance(KilopascalsPerSecondInOnePascalPerSecond, (double)kilopascalpersecondQuantity.Value, KilopascalsPerSecondTolerance); Assert.Equal(PressureChangeRateUnit.KilopascalPerSecond, kilopascalpersecondQuantity.Unit); + var kilopoundforcepersquareinchperminuteQuantity = pascalpersecond.ToUnit(PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute); + AssertEx.EqualTolerance(KilopoundsForcePerSquareInchPerMinuteInOnePascalPerSecond, (double)kilopoundforcepersquareinchperminuteQuantity.Value, KilopoundsForcePerSquareInchPerMinuteTolerance); + Assert.Equal(PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute, kilopoundforcepersquareinchperminuteQuantity.Unit); + + var kilopoundforcepersquareinchpersecondQuantity = pascalpersecond.ToUnit(PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond); + AssertEx.EqualTolerance(KilopoundsForcePerSquareInchPerSecondInOnePascalPerSecond, (double)kilopoundforcepersquareinchpersecondQuantity.Value, KilopoundsForcePerSquareInchPerSecondTolerance); + Assert.Equal(PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond, kilopoundforcepersquareinchpersecondQuantity.Unit); + var megapascalperminuteQuantity = pascalpersecond.ToUnit(PressureChangeRateUnit.MegapascalPerMinute); AssertEx.EqualTolerance(MegapascalsPerMinuteInOnePascalPerSecond, (double)megapascalperminuteQuantity.Value, MegapascalsPerMinuteTolerance); Assert.Equal(PressureChangeRateUnit.MegapascalPerMinute, megapascalperminuteQuantity.Unit); @@ -237,6 +293,14 @@ public void ToUnit() AssertEx.EqualTolerance(MegapascalsPerSecondInOnePascalPerSecond, (double)megapascalpersecondQuantity.Value, MegapascalsPerSecondTolerance); Assert.Equal(PressureChangeRateUnit.MegapascalPerSecond, megapascalpersecondQuantity.Unit); + var megapoundforcepersquareinchperminuteQuantity = pascalpersecond.ToUnit(PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute); + AssertEx.EqualTolerance(MegapoundsForcePerSquareInchPerMinuteInOnePascalPerSecond, (double)megapoundforcepersquareinchperminuteQuantity.Value, MegapoundsForcePerSquareInchPerMinuteTolerance); + Assert.Equal(PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute, megapoundforcepersquareinchperminuteQuantity.Unit); + + var megapoundforcepersquareinchpersecondQuantity = pascalpersecond.ToUnit(PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond); + AssertEx.EqualTolerance(MegapoundsForcePerSquareInchPerSecondInOnePascalPerSecond, (double)megapoundforcepersquareinchpersecondQuantity.Value, MegapoundsForcePerSquareInchPerSecondTolerance); + Assert.Equal(PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond, megapoundforcepersquareinchpersecondQuantity.Unit); + var pascalperminuteQuantity = pascalpersecond.ToUnit(PressureChangeRateUnit.PascalPerMinute); AssertEx.EqualTolerance(PascalsPerMinuteInOnePascalPerSecond, (double)pascalperminuteQuantity.Value, PascalsPerMinuteTolerance); Assert.Equal(PressureChangeRateUnit.PascalPerMinute, pascalperminuteQuantity.Unit); @@ -244,6 +308,14 @@ public void ToUnit() var pascalpersecondQuantity = pascalpersecond.ToUnit(PressureChangeRateUnit.PascalPerSecond); AssertEx.EqualTolerance(PascalsPerSecondInOnePascalPerSecond, (double)pascalpersecondQuantity.Value, PascalsPerSecondTolerance); Assert.Equal(PressureChangeRateUnit.PascalPerSecond, pascalpersecondQuantity.Unit); + + var poundforcepersquareinchperminuteQuantity = pascalpersecond.ToUnit(PressureChangeRateUnit.PoundForcePerSquareInchPerMinute); + AssertEx.EqualTolerance(PoundsForcePerSquareInchPerMinuteInOnePascalPerSecond, (double)poundforcepersquareinchperminuteQuantity.Value, PoundsForcePerSquareInchPerMinuteTolerance); + Assert.Equal(PressureChangeRateUnit.PoundForcePerSquareInchPerMinute, poundforcepersquareinchperminuteQuantity.Unit); + + var poundforcepersquareinchpersecondQuantity = pascalpersecond.ToUnit(PressureChangeRateUnit.PoundForcePerSquareInchPerSecond); + AssertEx.EqualTolerance(PoundsForcePerSquareInchPerSecondInOnePascalPerSecond, (double)poundforcepersquareinchpersecondQuantity.Value, PoundsForcePerSquareInchPerSecondTolerance); + Assert.Equal(PressureChangeRateUnit.PoundForcePerSquareInchPerSecond, poundforcepersquareinchpersecondQuantity.Unit); } [Fact] @@ -260,10 +332,16 @@ public void ConversionRoundTrip() AssertEx.EqualTolerance(1, PressureChangeRate.FromAtmospheresPerSecond(pascalpersecond.AtmospheresPerSecond).PascalsPerSecond, AtmospheresPerSecondTolerance); AssertEx.EqualTolerance(1, PressureChangeRate.FromKilopascalsPerMinute(pascalpersecond.KilopascalsPerMinute).PascalsPerSecond, KilopascalsPerMinuteTolerance); AssertEx.EqualTolerance(1, PressureChangeRate.FromKilopascalsPerSecond(pascalpersecond.KilopascalsPerSecond).PascalsPerSecond, KilopascalsPerSecondTolerance); + AssertEx.EqualTolerance(1, PressureChangeRate.FromKilopoundsForcePerSquareInchPerMinute(pascalpersecond.KilopoundsForcePerSquareInchPerMinute).PascalsPerSecond, KilopoundsForcePerSquareInchPerMinuteTolerance); + AssertEx.EqualTolerance(1, PressureChangeRate.FromKilopoundsForcePerSquareInchPerSecond(pascalpersecond.KilopoundsForcePerSquareInchPerSecond).PascalsPerSecond, KilopoundsForcePerSquareInchPerSecondTolerance); AssertEx.EqualTolerance(1, PressureChangeRate.FromMegapascalsPerMinute(pascalpersecond.MegapascalsPerMinute).PascalsPerSecond, MegapascalsPerMinuteTolerance); AssertEx.EqualTolerance(1, PressureChangeRate.FromMegapascalsPerSecond(pascalpersecond.MegapascalsPerSecond).PascalsPerSecond, MegapascalsPerSecondTolerance); + AssertEx.EqualTolerance(1, PressureChangeRate.FromMegapoundsForcePerSquareInchPerMinute(pascalpersecond.MegapoundsForcePerSquareInchPerMinute).PascalsPerSecond, MegapoundsForcePerSquareInchPerMinuteTolerance); + AssertEx.EqualTolerance(1, PressureChangeRate.FromMegapoundsForcePerSquareInchPerSecond(pascalpersecond.MegapoundsForcePerSquareInchPerSecond).PascalsPerSecond, MegapoundsForcePerSquareInchPerSecondTolerance); AssertEx.EqualTolerance(1, PressureChangeRate.FromPascalsPerMinute(pascalpersecond.PascalsPerMinute).PascalsPerSecond, PascalsPerMinuteTolerance); AssertEx.EqualTolerance(1, PressureChangeRate.FromPascalsPerSecond(pascalpersecond.PascalsPerSecond).PascalsPerSecond, PascalsPerSecondTolerance); + AssertEx.EqualTolerance(1, PressureChangeRate.FromPoundsForcePerSquareInchPerMinute(pascalpersecond.PoundsForcePerSquareInchPerMinute).PascalsPerSecond, PoundsForcePerSquareInchPerMinuteTolerance); + AssertEx.EqualTolerance(1, PressureChangeRate.FromPoundsForcePerSquareInchPerSecond(pascalpersecond.PoundsForcePerSquareInchPerSecond).PascalsPerSecond, PoundsForcePerSquareInchPerSecondTolerance); } [Fact] @@ -423,10 +501,16 @@ public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture() Assert.Equal("1 atm/s", new PressureChangeRate(1, PressureChangeRateUnit.AtmospherePerSecond).ToString()); Assert.Equal("1 kPa/min", new PressureChangeRate(1, PressureChangeRateUnit.KilopascalPerMinute).ToString()); Assert.Equal("1 kPa/s", new PressureChangeRate(1, PressureChangeRateUnit.KilopascalPerSecond).ToString()); + Assert.Equal("1 ksi/min", new PressureChangeRate(1, PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute).ToString()); + Assert.Equal("1 ksi/s", new PressureChangeRate(1, PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond).ToString()); Assert.Equal("1 MPa/min", new PressureChangeRate(1, PressureChangeRateUnit.MegapascalPerMinute).ToString()); Assert.Equal("1 MPa/s", new PressureChangeRate(1, PressureChangeRateUnit.MegapascalPerSecond).ToString()); + Assert.Equal("1 Mpsi/min", new PressureChangeRate(1, PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute).ToString()); + Assert.Equal("1 Mpsi/s", new PressureChangeRate(1, PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond).ToString()); Assert.Equal("1 Pa/min", new PressureChangeRate(1, PressureChangeRateUnit.PascalPerMinute).ToString()); Assert.Equal("1 Pa/s", new PressureChangeRate(1, PressureChangeRateUnit.PascalPerSecond).ToString()); + Assert.Equal("1 psi/min", new PressureChangeRate(1, PressureChangeRateUnit.PoundForcePerSquareInchPerMinute).ToString()); + Assert.Equal("1 psi/s", new PressureChangeRate(1, PressureChangeRateUnit.PoundForcePerSquareInchPerSecond).ToString()); } finally { @@ -443,10 +527,16 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture Assert.Equal("1 atm/s", new PressureChangeRate(1, PressureChangeRateUnit.AtmospherePerSecond).ToString(swedishCulture)); Assert.Equal("1 kPa/min", new PressureChangeRate(1, PressureChangeRateUnit.KilopascalPerMinute).ToString(swedishCulture)); Assert.Equal("1 kPa/s", new PressureChangeRate(1, PressureChangeRateUnit.KilopascalPerSecond).ToString(swedishCulture)); + Assert.Equal("1 ksi/min", new PressureChangeRate(1, PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute).ToString(swedishCulture)); + Assert.Equal("1 ksi/s", new PressureChangeRate(1, PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond).ToString(swedishCulture)); Assert.Equal("1 MPa/min", new PressureChangeRate(1, PressureChangeRateUnit.MegapascalPerMinute).ToString(swedishCulture)); Assert.Equal("1 MPa/s", new PressureChangeRate(1, PressureChangeRateUnit.MegapascalPerSecond).ToString(swedishCulture)); + Assert.Equal("1 Mpsi/min", new PressureChangeRate(1, PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute).ToString(swedishCulture)); + Assert.Equal("1 Mpsi/s", new PressureChangeRate(1, PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond).ToString(swedishCulture)); Assert.Equal("1 Pa/min", new PressureChangeRate(1, PressureChangeRateUnit.PascalPerMinute).ToString(swedishCulture)); Assert.Equal("1 Pa/s", new PressureChangeRate(1, PressureChangeRateUnit.PascalPerSecond).ToString(swedishCulture)); + Assert.Equal("1 psi/min", new PressureChangeRate(1, PressureChangeRateUnit.PoundForcePerSquareInchPerMinute).ToString(swedishCulture)); + Assert.Equal("1 psi/s", new PressureChangeRate(1, PressureChangeRateUnit.PoundForcePerSquareInchPerSecond).ToString(swedishCulture)); } [Fact] diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/PressureTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/PressureTestsBase.g.cs index 42bf056e27..dd566c92bc 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/PressureTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/PressureTestsBase.g.cs @@ -922,7 +922,7 @@ public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture() Assert.Equal("1 kN/mm²", new Pressure(1, PressureUnit.KilonewtonPerSquareMillimeter).ToString()); Assert.Equal("1 kPa", new Pressure(1, PressureUnit.Kilopascal).ToString()); Assert.Equal("1 kipf/ft²", new Pressure(1, PressureUnit.KilopoundForcePerSquareFoot).ToString()); - Assert.Equal("1 kipf/in²", new Pressure(1, PressureUnit.KilopoundForcePerSquareInch).ToString()); + Assert.Equal("1 ksi", new Pressure(1, PressureUnit.KilopoundForcePerSquareInch).ToString()); Assert.Equal("1 Mbar", new Pressure(1, PressureUnit.Megabar).ToString()); Assert.Equal("1 MN/m²", new Pressure(1, PressureUnit.MeganewtonPerSquareMeter).ToString()); Assert.Equal("1 MPa", new Pressure(1, PressureUnit.Megapascal).ToString()); @@ -979,7 +979,7 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture Assert.Equal("1 kN/mm²", new Pressure(1, PressureUnit.KilonewtonPerSquareMillimeter).ToString(swedishCulture)); Assert.Equal("1 kPa", new Pressure(1, PressureUnit.Kilopascal).ToString(swedishCulture)); Assert.Equal("1 kipf/ft²", new Pressure(1, PressureUnit.KilopoundForcePerSquareFoot).ToString(swedishCulture)); - Assert.Equal("1 kipf/in²", new Pressure(1, PressureUnit.KilopoundForcePerSquareInch).ToString(swedishCulture)); + Assert.Equal("1 ksi", new Pressure(1, PressureUnit.KilopoundForcePerSquareInch).ToString(swedishCulture)); Assert.Equal("1 Mbar", new Pressure(1, PressureUnit.Megabar).ToString(swedishCulture)); Assert.Equal("1 MN/m²", new Pressure(1, PressureUnit.MeganewtonPerSquareMeter).ToString(swedishCulture)); Assert.Equal("1 MPa", new Pressure(1, PressureUnit.Megapascal).ToString(swedishCulture)); diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Force.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Force.g.cs index 20c760a228..bf829157ae 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Force.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Force.g.cs @@ -706,7 +706,7 @@ private double AsBaseUnit() case ForceUnit.KilogramForce: return _value*9.80665002864; case ForceUnit.Kilonewton: return (_value) * 1e3d; case ForceUnit.KiloPond: return _value*9.80665002864; - case ForceUnit.KilopoundForce: return _value*4448.2216152605095551842641431421; + case ForceUnit.KilopoundForce: return (_value*4.4482216152605095551842641431421) * 1e3d; case ForceUnit.Meganewton: return (_value) * 1e6d; case ForceUnit.Micronewton: return (_value) * 1e-6d; case ForceUnit.Millinewton: return (_value) * 1e-3d; @@ -735,7 +735,7 @@ private double AsBaseNumericType(ForceUnit unit) case ForceUnit.KilogramForce: return baseUnitValue/9.80665002864; case ForceUnit.Kilonewton: return (baseUnitValue) / 1e3d; case ForceUnit.KiloPond: return baseUnitValue/9.80665002864; - case ForceUnit.KilopoundForce: return baseUnitValue/4448.2216152605095551842641431421; + case ForceUnit.KilopoundForce: return (baseUnitValue/4.4482216152605095551842641431421) / 1e3d; case ForceUnit.Meganewton: return (baseUnitValue) / 1e6d; case ForceUnit.Micronewton: return (baseUnitValue) / 1e-6d; case ForceUnit.Millinewton: return (baseUnitValue) / 1e-3d; diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForceChangeRate.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForceChangeRate.g.cs index 479b9ae48c..faf17b0a1a 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForceChangeRate.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForceChangeRate.g.cs @@ -185,6 +185,16 @@ private ForceChangeRate(double value, ForceChangeRateUnit unit) /// public double KilonewtonsPerSecond => As(ForceChangeRateUnit.KilonewtonPerSecond); + /// + /// Get ForceChangeRate in KilopoundsForcePerMinute. + /// + public double KilopoundsForcePerMinute => As(ForceChangeRateUnit.KilopoundForcePerMinute); + + /// + /// Get ForceChangeRate in KilopoundsForcePerSecond. + /// + public double KilopoundsForcePerSecond => As(ForceChangeRateUnit.KilopoundForcePerSecond); + /// /// Get ForceChangeRate in MicronewtonsPerSecond. /// @@ -210,6 +220,16 @@ private ForceChangeRate(double value, ForceChangeRateUnit unit) /// public double NewtonsPerSecond => As(ForceChangeRateUnit.NewtonPerSecond); + /// + /// Get ForceChangeRate in PoundsForcePerMinute. + /// + public double PoundsForcePerMinute => As(ForceChangeRateUnit.PoundForcePerMinute); + + /// + /// Get ForceChangeRate in PoundsForcePerSecond. + /// + public double PoundsForcePerSecond => As(ForceChangeRateUnit.PoundForcePerSecond); + #endregion #region Static Methods @@ -301,6 +321,26 @@ public static ForceChangeRate FromKilonewtonsPerSecond(double kilonewtonsperseco return new ForceChangeRate(value, ForceChangeRateUnit.KilonewtonPerSecond); } /// + /// Get ForceChangeRate from KilopoundsForcePerMinute. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static ForceChangeRate FromKilopoundsForcePerMinute(double kilopoundsforceperminute) + { + double value = (double) kilopoundsforceperminute; + return new ForceChangeRate(value, ForceChangeRateUnit.KilopoundForcePerMinute); + } + /// + /// Get ForceChangeRate from KilopoundsForcePerSecond. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static ForceChangeRate FromKilopoundsForcePerSecond(double kilopoundsforcepersecond) + { + double value = (double) kilopoundsforcepersecond; + return new ForceChangeRate(value, ForceChangeRateUnit.KilopoundForcePerSecond); + } + /// /// Get ForceChangeRate from MicronewtonsPerSecond. /// /// If value is NaN or Infinity. @@ -350,6 +390,26 @@ public static ForceChangeRate FromNewtonsPerSecond(double newtonspersecond) double value = (double) newtonspersecond; return new ForceChangeRate(value, ForceChangeRateUnit.NewtonPerSecond); } + /// + /// Get ForceChangeRate from PoundsForcePerMinute. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static ForceChangeRate FromPoundsForcePerMinute(double poundsforceperminute) + { + double value = (double) poundsforceperminute; + return new ForceChangeRate(value, ForceChangeRateUnit.PoundForcePerMinute); + } + /// + /// Get ForceChangeRate from PoundsForcePerSecond. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static ForceChangeRate FromPoundsForcePerSecond(double poundsforcepersecond) + { + double value = (double) poundsforcepersecond; + return new ForceChangeRate(value, ForceChangeRateUnit.PoundForcePerSecond); + } /// /// Dynamically convert from value and unit enum to . @@ -647,11 +707,15 @@ private double AsBaseUnit() case ForceChangeRateUnit.DecinewtonPerSecond: return (_value) * 1e-1d; case ForceChangeRateUnit.KilonewtonPerMinute: return (_value/60) * 1e3d; case ForceChangeRateUnit.KilonewtonPerSecond: return (_value) * 1e3d; + case ForceChangeRateUnit.KilopoundForcePerMinute: return (_value*4.4482216152605095551842641431421/60) * 1e3d; + case ForceChangeRateUnit.KilopoundForcePerSecond: return (_value*4.4482216152605095551842641431421) * 1e3d; case ForceChangeRateUnit.MicronewtonPerSecond: return (_value) * 1e-6d; case ForceChangeRateUnit.MillinewtonPerSecond: return (_value) * 1e-3d; case ForceChangeRateUnit.NanonewtonPerSecond: return (_value) * 1e-9d; case ForceChangeRateUnit.NewtonPerMinute: return _value/60; case ForceChangeRateUnit.NewtonPerSecond: return _value; + case ForceChangeRateUnit.PoundForcePerMinute: return _value*4.4482216152605095551842641431421/60; + case ForceChangeRateUnit.PoundForcePerSecond: return _value*4.4482216152605095551842641431421; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -672,11 +736,15 @@ private double AsBaseNumericType(ForceChangeRateUnit unit) case ForceChangeRateUnit.DecinewtonPerSecond: return (baseUnitValue) / 1e-1d; case ForceChangeRateUnit.KilonewtonPerMinute: return (baseUnitValue*60) / 1e3d; case ForceChangeRateUnit.KilonewtonPerSecond: return (baseUnitValue) / 1e3d; + case ForceChangeRateUnit.KilopoundForcePerMinute: return (baseUnitValue/4.4482216152605095551842641431421*60) / 1e3d; + case ForceChangeRateUnit.KilopoundForcePerSecond: return (baseUnitValue/4.4482216152605095551842641431421) / 1e3d; case ForceChangeRateUnit.MicronewtonPerSecond: return (baseUnitValue) / 1e-6d; case ForceChangeRateUnit.MillinewtonPerSecond: return (baseUnitValue) / 1e-3d; case ForceChangeRateUnit.NanonewtonPerSecond: return (baseUnitValue) / 1e-9d; case ForceChangeRateUnit.NewtonPerMinute: return baseUnitValue*60; case ForceChangeRateUnit.NewtonPerSecond: return baseUnitValue; + case ForceChangeRateUnit.PoundForcePerMinute: return baseUnitValue/4.4482216152605095551842641431421*60; + case ForceChangeRateUnit.PoundForcePerSecond: return baseUnitValue/4.4482216152605095551842641431421; default: throw new NotImplementedException($"Can not convert {Unit} to {unit}."); } diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PressureChangeRate.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PressureChangeRate.g.cs index 28fe37c190..96e4882d2d 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PressureChangeRate.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PressureChangeRate.g.cs @@ -170,6 +170,16 @@ private PressureChangeRate(double value, PressureChangeRateUnit unit) /// public double KilopascalsPerSecond => As(PressureChangeRateUnit.KilopascalPerSecond); + /// + /// Get PressureChangeRate in KilopoundsForcePerSquareInchPerMinute. + /// + public double KilopoundsForcePerSquareInchPerMinute => As(PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute); + + /// + /// Get PressureChangeRate in KilopoundsForcePerSquareInchPerSecond. + /// + public double KilopoundsForcePerSquareInchPerSecond => As(PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond); + /// /// Get PressureChangeRate in MegapascalsPerMinute. /// @@ -180,6 +190,16 @@ private PressureChangeRate(double value, PressureChangeRateUnit unit) /// public double MegapascalsPerSecond => As(PressureChangeRateUnit.MegapascalPerSecond); + /// + /// Get PressureChangeRate in MegapoundsForcePerSquareInchPerMinute. + /// + public double MegapoundsForcePerSquareInchPerMinute => As(PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute); + + /// + /// Get PressureChangeRate in MegapoundsForcePerSquareInchPerSecond. + /// + public double MegapoundsForcePerSquareInchPerSecond => As(PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond); + /// /// Get PressureChangeRate in PascalsPerMinute. /// @@ -190,6 +210,16 @@ private PressureChangeRate(double value, PressureChangeRateUnit unit) /// public double PascalsPerSecond => As(PressureChangeRateUnit.PascalPerSecond); + /// + /// Get PressureChangeRate in PoundsForcePerSquareInchPerMinute. + /// + public double PoundsForcePerSquareInchPerMinute => As(PressureChangeRateUnit.PoundForcePerSquareInchPerMinute); + + /// + /// Get PressureChangeRate in PoundsForcePerSquareInchPerSecond. + /// + public double PoundsForcePerSquareInchPerSecond => As(PressureChangeRateUnit.PoundForcePerSquareInchPerSecond); + #endregion #region Static Methods @@ -251,6 +281,26 @@ public static PressureChangeRate FromKilopascalsPerSecond(double kilopascalspers return new PressureChangeRate(value, PressureChangeRateUnit.KilopascalPerSecond); } /// + /// Get PressureChangeRate from KilopoundsForcePerSquareInchPerMinute. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static PressureChangeRate FromKilopoundsForcePerSquareInchPerMinute(double kilopoundsforcepersquareinchperminute) + { + double value = (double) kilopoundsforcepersquareinchperminute; + return new PressureChangeRate(value, PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute); + } + /// + /// Get PressureChangeRate from KilopoundsForcePerSquareInchPerSecond. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static PressureChangeRate FromKilopoundsForcePerSquareInchPerSecond(double kilopoundsforcepersquareinchpersecond) + { + double value = (double) kilopoundsforcepersquareinchpersecond; + return new PressureChangeRate(value, PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond); + } + /// /// Get PressureChangeRate from MegapascalsPerMinute. /// /// If value is NaN or Infinity. @@ -271,6 +321,26 @@ public static PressureChangeRate FromMegapascalsPerSecond(double megapascalspers return new PressureChangeRate(value, PressureChangeRateUnit.MegapascalPerSecond); } /// + /// Get PressureChangeRate from MegapoundsForcePerSquareInchPerMinute. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static PressureChangeRate FromMegapoundsForcePerSquareInchPerMinute(double megapoundsforcepersquareinchperminute) + { + double value = (double) megapoundsforcepersquareinchperminute; + return new PressureChangeRate(value, PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute); + } + /// + /// Get PressureChangeRate from MegapoundsForcePerSquareInchPerSecond. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static PressureChangeRate FromMegapoundsForcePerSquareInchPerSecond(double megapoundsforcepersquareinchpersecond) + { + double value = (double) megapoundsforcepersquareinchpersecond; + return new PressureChangeRate(value, PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond); + } + /// /// Get PressureChangeRate from PascalsPerMinute. /// /// If value is NaN or Infinity. @@ -290,6 +360,26 @@ public static PressureChangeRate FromPascalsPerSecond(double pascalspersecond) double value = (double) pascalspersecond; return new PressureChangeRate(value, PressureChangeRateUnit.PascalPerSecond); } + /// + /// Get PressureChangeRate from PoundsForcePerSquareInchPerMinute. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static PressureChangeRate FromPoundsForcePerSquareInchPerMinute(double poundsforcepersquareinchperminute) + { + double value = (double) poundsforcepersquareinchperminute; + return new PressureChangeRate(value, PressureChangeRateUnit.PoundForcePerSquareInchPerMinute); + } + /// + /// Get PressureChangeRate from PoundsForcePerSquareInchPerSecond. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static PressureChangeRate FromPoundsForcePerSquareInchPerSecond(double poundsforcepersquareinchpersecond) + { + double value = (double) poundsforcepersquareinchpersecond; + return new PressureChangeRate(value, PressureChangeRateUnit.PoundForcePerSquareInchPerSecond); + } /// /// Dynamically convert from value and unit enum to . @@ -584,10 +674,16 @@ private double AsBaseUnit() case PressureChangeRateUnit.AtmospherePerSecond: return _value * 1.01325*1e5; case PressureChangeRateUnit.KilopascalPerMinute: return (_value/60) * 1e3d; case PressureChangeRateUnit.KilopascalPerSecond: return (_value) * 1e3d; + case PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute: return (_value*6.894757293168361e3/60) * 1e3d; + case PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond: return (_value*6.894757293168361e3) * 1e3d; case PressureChangeRateUnit.MegapascalPerMinute: return (_value/60) * 1e6d; case PressureChangeRateUnit.MegapascalPerSecond: return (_value) * 1e6d; + case PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute: return (_value*6.894757293168361e3/60) * 1e6d; + case PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond: return (_value*6.894757293168361e3) * 1e6d; case PressureChangeRateUnit.PascalPerMinute: return _value/60; case PressureChangeRateUnit.PascalPerSecond: return _value; + case PressureChangeRateUnit.PoundForcePerSquareInchPerMinute: return _value*6.894757293168361e3/60; + case PressureChangeRateUnit.PoundForcePerSquareInchPerSecond: return _value*6.894757293168361e3; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -605,10 +701,16 @@ private double AsBaseNumericType(PressureChangeRateUnit unit) case PressureChangeRateUnit.AtmospherePerSecond: return baseUnitValue / (1.01325*1e5); case PressureChangeRateUnit.KilopascalPerMinute: return (baseUnitValue*60) / 1e3d; case PressureChangeRateUnit.KilopascalPerSecond: return (baseUnitValue) / 1e3d; + case PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute: return (baseUnitValue/6.894757293168361e3*60) / 1e3d; + case PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond: return (baseUnitValue/6.894757293168361e3) / 1e3d; case PressureChangeRateUnit.MegapascalPerMinute: return (baseUnitValue*60) / 1e6d; case PressureChangeRateUnit.MegapascalPerSecond: return (baseUnitValue) / 1e6d; + case PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute: return (baseUnitValue/6.894757293168361e3*60) / 1e6d; + case PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond: return (baseUnitValue/6.894757293168361e3) / 1e6d; case PressureChangeRateUnit.PascalPerMinute: return baseUnitValue*60; case PressureChangeRateUnit.PascalPerSecond: return baseUnitValue; + case PressureChangeRateUnit.PoundForcePerSquareInchPerMinute: return baseUnitValue/6.894757293168361e3*60; + case PressureChangeRateUnit.PoundForcePerSquareInchPerSecond: return baseUnitValue/6.894757293168361e3; default: throw new NotImplementedException($"Can not convert {Unit} to {unit}."); } diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs index a26f6e5d3e..e4699f3c40 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs @@ -467,11 +467,15 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("en-US", typeof(ForceChangeRateUnit), (int)ForceChangeRateUnit.DecinewtonPerSecond, new string[]{"dN/s"}), ("en-US", typeof(ForceChangeRateUnit), (int)ForceChangeRateUnit.KilonewtonPerMinute, new string[]{"kN/min"}), ("en-US", typeof(ForceChangeRateUnit), (int)ForceChangeRateUnit.KilonewtonPerSecond, new string[]{"kN/s"}), + ("en-US", typeof(ForceChangeRateUnit), (int)ForceChangeRateUnit.KilopoundForcePerMinute, new string[]{"kipf/min", "kip/min", "k/min"}), + ("en-US", typeof(ForceChangeRateUnit), (int)ForceChangeRateUnit.KilopoundForcePerSecond, new string[]{"kipf/s", "kip/s", "k/s"}), ("en-US", typeof(ForceChangeRateUnit), (int)ForceChangeRateUnit.MicronewtonPerSecond, new string[]{"µN/s"}), ("en-US", typeof(ForceChangeRateUnit), (int)ForceChangeRateUnit.MillinewtonPerSecond, new string[]{"mN/s"}), ("en-US", typeof(ForceChangeRateUnit), (int)ForceChangeRateUnit.NanonewtonPerSecond, new string[]{"nN/s"}), ("en-US", typeof(ForceChangeRateUnit), (int)ForceChangeRateUnit.NewtonPerMinute, new string[]{"N/min"}), ("en-US", typeof(ForceChangeRateUnit), (int)ForceChangeRateUnit.NewtonPerSecond, new string[]{"N/s"}), + ("en-US", typeof(ForceChangeRateUnit), (int)ForceChangeRateUnit.PoundForcePerMinute, new string[]{"lbf/min"}), + ("en-US", typeof(ForceChangeRateUnit), (int)ForceChangeRateUnit.PoundForcePerSecond, new string[]{"lbf/s"}), ("en-US", typeof(ForcePerLengthUnit), (int)ForcePerLengthUnit.CentinewtonPerCentimeter, new string[]{"cN/cm"}), ("en-US", typeof(ForcePerLengthUnit), (int)ForcePerLengthUnit.CentinewtonPerMeter, new string[]{"cN/m"}), ("en-US", typeof(ForcePerLengthUnit), (int)ForcePerLengthUnit.CentinewtonPerMillimeter, new string[]{"cN/mm"}), @@ -1111,8 +1115,8 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("en-US", typeof(PressureUnit), (int)PressureUnit.Kilopascal, new string[]{"kPa"}), ("ru-RU", typeof(PressureUnit), (int)PressureUnit.Kilopascal, new string[]{"кПа"}), ("en-US", typeof(PressureUnit), (int)PressureUnit.KilopoundForcePerSquareFoot, new string[]{"kipf/ft²"}), - ("en-US", typeof(PressureUnit), (int)PressureUnit.KilopoundForcePerSquareInch, new string[]{"kipf/in²"}), - ("ru-RU", typeof(PressureUnit), (int)PressureUnit.KilopoundForcePerSquareInch, new string[]{"kipf/in²"}), + ("en-US", typeof(PressureUnit), (int)PressureUnit.KilopoundForcePerSquareInch, new string[]{"ksi", "kipf/in²"}), + ("ru-RU", typeof(PressureUnit), (int)PressureUnit.KilopoundForcePerSquareInch, new string[]{"ksi", "kipf/in²"}), ("en-US", typeof(PressureUnit), (int)PressureUnit.Megabar, new string[]{"Mbar"}), ("ru-RU", typeof(PressureUnit), (int)PressureUnit.Megabar, new string[]{"Мбар"}), ("en-US", typeof(PressureUnit), (int)PressureUnit.MeganewtonPerSquareMeter, new string[]{"MN/m²"}), @@ -1153,17 +1157,29 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("en-US", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.AtmospherePerSecond, new string[]{"atm/s"}), ("ru-RU", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.AtmospherePerSecond, new string[]{"атм/с"}), ("en-US", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.KilopascalPerMinute, new string[]{"kPa/min"}), - ("ru-RU", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.KilopascalPerMinute, new string[]{"кПа/с"}), + ("ru-RU", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.KilopascalPerMinute, new string[]{"кПа/мин"}), ("en-US", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.KilopascalPerSecond, new string[]{"kPa/s"}), ("ru-RU", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.KilopascalPerSecond, new string[]{"кПа/с"}), + ("en-US", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute, new string[]{"ksi/min", "kipf/in²/min"}), + ("ru-RU", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute, new string[]{"ksi/мин", "kipf/in²/мин"}), + ("en-US", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond, new string[]{"ksi/s", "kipf/in²/s"}), + ("ru-RU", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond, new string[]{"ksi/с", "kipf/in²/с"}), ("en-US", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.MegapascalPerMinute, new string[]{"MPa/min"}), - ("ru-RU", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.MegapascalPerMinute, new string[]{"МПа/с"}), + ("ru-RU", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.MegapascalPerMinute, new string[]{"МПа/мин"}), ("en-US", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.MegapascalPerSecond, new string[]{"MPa/s"}), ("ru-RU", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.MegapascalPerSecond, new string[]{"МПа/с"}), + ("en-US", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute, new string[]{"Mpsi/min", "Mlb/in²/min"}), + ("ru-RU", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute, new string[]{"Мpsi/мин", "Мlb/in²/мин"}), + ("en-US", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond, new string[]{"Mpsi/s", "Mlb/in²/s"}), + ("ru-RU", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond, new string[]{"Мpsi/с", "Мlb/in²/с"}), ("en-US", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.PascalPerMinute, new string[]{"Pa/min"}), - ("ru-RU", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.PascalPerMinute, new string[]{"Па/с"}), + ("ru-RU", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.PascalPerMinute, new string[]{"Па/мин"}), ("en-US", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.PascalPerSecond, new string[]{"Pa/s"}), ("ru-RU", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.PascalPerSecond, new string[]{"Па/с"}), + ("en-US", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.PoundForcePerSquareInchPerMinute, new string[]{"psi/min", "lb/in²/min"}), + ("ru-RU", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.PoundForcePerSquareInchPerMinute, new string[]{"psi/мин", "lb/in²/мин"}), + ("en-US", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.PoundForcePerSquareInchPerSecond, new string[]{"psi/s", "lb/in²/s"}), + ("ru-RU", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.PoundForcePerSquareInchPerSecond, new string[]{"psi/с", "lb/in²/с"}), ("en-US", typeof(RatioUnit), (int)RatioUnit.DecimalFraction, new string[]{""}), ("en-US", typeof(RatioUnit), (int)RatioUnit.PartPerBillion, new string[]{"ppb"}), ("en-US", typeof(RatioUnit), (int)RatioUnit.PartPerMillion, new string[]{"ppm"}), diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/ForceChangeRateUnit.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/ForceChangeRateUnit.g.cs index db444ea23a..989a72cf46 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/ForceChangeRateUnit.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/ForceChangeRateUnit.g.cs @@ -32,11 +32,15 @@ public enum ForceChangeRateUnit DecinewtonPerSecond, KilonewtonPerMinute, KilonewtonPerSecond, + KilopoundForcePerMinute, + KilopoundForcePerSecond, MicronewtonPerSecond, MillinewtonPerSecond, NanonewtonPerSecond, NewtonPerMinute, NewtonPerSecond, + PoundForcePerMinute, + PoundForcePerSecond, } #pragma warning restore 1591 diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/PressureChangeRateUnit.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/PressureChangeRateUnit.g.cs index 6bd31402a5..0bfb681ff4 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/PressureChangeRateUnit.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/PressureChangeRateUnit.g.cs @@ -29,10 +29,16 @@ public enum PressureChangeRateUnit AtmospherePerSecond, KilopascalPerMinute, KilopascalPerSecond, + KilopoundForcePerSquareInchPerMinute, + KilopoundForcePerSquareInchPerSecond, MegapascalPerMinute, MegapascalPerSecond, + MegapoundForcePerSquareInchPerMinute, + MegapoundForcePerSquareInchPerSecond, PascalPerMinute, PascalPerSecond, + PoundForcePerSquareInchPerMinute, + PoundForcePerSquareInchPerSecond, } #pragma warning restore 1591 diff --git a/UnitsNet/GeneratedCode/Quantities/Force.g.cs b/UnitsNet/GeneratedCode/Quantities/Force.g.cs index 336c8764de..616d290129 100644 --- a/UnitsNet/GeneratedCode/Quantities/Force.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Force.g.cs @@ -855,7 +855,7 @@ private double GetValueInBaseUnit() case ForceUnit.KilogramForce: return _value*9.80665002864; case ForceUnit.Kilonewton: return (_value) * 1e3d; case ForceUnit.KiloPond: return _value*9.80665002864; - case ForceUnit.KilopoundForce: return _value*4448.2216152605095551842641431421; + case ForceUnit.KilopoundForce: return (_value*4.4482216152605095551842641431421) * 1e3d; case ForceUnit.Meganewton: return (_value) * 1e6d; case ForceUnit.Micronewton: return (_value) * 1e-6d; case ForceUnit.Millinewton: return (_value) * 1e-3d; @@ -895,7 +895,7 @@ private double GetValueAs(ForceUnit unit) case ForceUnit.KilogramForce: return baseUnitValue/9.80665002864; case ForceUnit.Kilonewton: return (baseUnitValue) / 1e3d; case ForceUnit.KiloPond: return baseUnitValue/9.80665002864; - case ForceUnit.KilopoundForce: return baseUnitValue/4448.2216152605095551842641431421; + case ForceUnit.KilopoundForce: return (baseUnitValue/4.4482216152605095551842641431421) / 1e3d; case ForceUnit.Meganewton: return (baseUnitValue) / 1e6d; case ForceUnit.Micronewton: return (baseUnitValue) / 1e-6d; case ForceUnit.Millinewton: return (baseUnitValue) / 1e-3d; diff --git a/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs index c2ceb1cd53..d27c9c4a9d 100644 --- a/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs @@ -58,11 +58,15 @@ static ForceChangeRate() new UnitInfo(ForceChangeRateUnit.DecinewtonPerSecond, BaseUnits.Undefined), new UnitInfo(ForceChangeRateUnit.KilonewtonPerMinute, BaseUnits.Undefined), new UnitInfo(ForceChangeRateUnit.KilonewtonPerSecond, BaseUnits.Undefined), + new UnitInfo(ForceChangeRateUnit.KilopoundForcePerMinute, BaseUnits.Undefined), + new UnitInfo(ForceChangeRateUnit.KilopoundForcePerSecond, BaseUnits.Undefined), new UnitInfo(ForceChangeRateUnit.MicronewtonPerSecond, BaseUnits.Undefined), new UnitInfo(ForceChangeRateUnit.MillinewtonPerSecond, BaseUnits.Undefined), new UnitInfo(ForceChangeRateUnit.NanonewtonPerSecond, BaseUnits.Undefined), new UnitInfo(ForceChangeRateUnit.NewtonPerMinute, BaseUnits.Undefined), new UnitInfo(ForceChangeRateUnit.NewtonPerSecond, BaseUnits.Undefined), + new UnitInfo(ForceChangeRateUnit.PoundForcePerMinute, BaseUnits.Undefined), + new UnitInfo(ForceChangeRateUnit.PoundForcePerSecond, BaseUnits.Undefined), }, BaseUnit, Zero, BaseDimensions, QuantityType.ForceChangeRate); } @@ -208,6 +212,16 @@ public ForceChangeRate(double value, UnitSystem unitSystem) /// public double KilonewtonsPerSecond => As(ForceChangeRateUnit.KilonewtonPerSecond); + /// + /// Get ForceChangeRate in KilopoundsForcePerMinute. + /// + public double KilopoundsForcePerMinute => As(ForceChangeRateUnit.KilopoundForcePerMinute); + + /// + /// Get ForceChangeRate in KilopoundsForcePerSecond. + /// + public double KilopoundsForcePerSecond => As(ForceChangeRateUnit.KilopoundForcePerSecond); + /// /// Get ForceChangeRate in MicronewtonsPerSecond. /// @@ -233,6 +247,16 @@ public ForceChangeRate(double value, UnitSystem unitSystem) /// public double NewtonsPerSecond => As(ForceChangeRateUnit.NewtonPerSecond); + /// + /// Get ForceChangeRate in PoundsForcePerMinute. + /// + public double PoundsForcePerMinute => As(ForceChangeRateUnit.PoundForcePerMinute); + + /// + /// Get ForceChangeRate in PoundsForcePerSecond. + /// + public double PoundsForcePerSecond => As(ForceChangeRateUnit.PoundForcePerSecond); + #endregion #region Static Methods @@ -317,6 +341,24 @@ public static ForceChangeRate FromKilonewtonsPerSecond(QuantityValue kilonewtons return new ForceChangeRate(value, ForceChangeRateUnit.KilonewtonPerSecond); } /// + /// Get ForceChangeRate from KilopoundsForcePerMinute. + /// + /// If value is NaN or Infinity. + public static ForceChangeRate FromKilopoundsForcePerMinute(QuantityValue kilopoundsforceperminute) + { + double value = (double) kilopoundsforceperminute; + return new ForceChangeRate(value, ForceChangeRateUnit.KilopoundForcePerMinute); + } + /// + /// Get ForceChangeRate from KilopoundsForcePerSecond. + /// + /// If value is NaN or Infinity. + public static ForceChangeRate FromKilopoundsForcePerSecond(QuantityValue kilopoundsforcepersecond) + { + double value = (double) kilopoundsforcepersecond; + return new ForceChangeRate(value, ForceChangeRateUnit.KilopoundForcePerSecond); + } + /// /// Get ForceChangeRate from MicronewtonsPerSecond. /// /// If value is NaN or Infinity. @@ -361,6 +403,24 @@ public static ForceChangeRate FromNewtonsPerSecond(QuantityValue newtonspersecon double value = (double) newtonspersecond; return new ForceChangeRate(value, ForceChangeRateUnit.NewtonPerSecond); } + /// + /// Get ForceChangeRate from PoundsForcePerMinute. + /// + /// If value is NaN or Infinity. + public static ForceChangeRate FromPoundsForcePerMinute(QuantityValue poundsforceperminute) + { + double value = (double) poundsforceperminute; + return new ForceChangeRate(value, ForceChangeRateUnit.PoundForcePerMinute); + } + /// + /// Get ForceChangeRate from PoundsForcePerSecond. + /// + /// If value is NaN or Infinity. + public static ForceChangeRate FromPoundsForcePerSecond(QuantityValue poundsforcepersecond) + { + double value = (double) poundsforcepersecond; + return new ForceChangeRate(value, ForceChangeRateUnit.PoundForcePerSecond); + } /// /// Dynamically convert from value and unit enum to . @@ -796,11 +856,15 @@ private double GetValueInBaseUnit() case ForceChangeRateUnit.DecinewtonPerSecond: return (_value) * 1e-1d; case ForceChangeRateUnit.KilonewtonPerMinute: return (_value/60) * 1e3d; case ForceChangeRateUnit.KilonewtonPerSecond: return (_value) * 1e3d; + case ForceChangeRateUnit.KilopoundForcePerMinute: return (_value*4.4482216152605095551842641431421/60) * 1e3d; + case ForceChangeRateUnit.KilopoundForcePerSecond: return (_value*4.4482216152605095551842641431421) * 1e3d; case ForceChangeRateUnit.MicronewtonPerSecond: return (_value) * 1e-6d; case ForceChangeRateUnit.MillinewtonPerSecond: return (_value) * 1e-3d; case ForceChangeRateUnit.NanonewtonPerSecond: return (_value) * 1e-9d; case ForceChangeRateUnit.NewtonPerMinute: return _value/60; case ForceChangeRateUnit.NewtonPerSecond: return _value; + case ForceChangeRateUnit.PoundForcePerMinute: return _value*4.4482216152605095551842641431421/60; + case ForceChangeRateUnit.PoundForcePerSecond: return _value*4.4482216152605095551842641431421; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -832,11 +896,15 @@ private double GetValueAs(ForceChangeRateUnit unit) case ForceChangeRateUnit.DecinewtonPerSecond: return (baseUnitValue) / 1e-1d; case ForceChangeRateUnit.KilonewtonPerMinute: return (baseUnitValue*60) / 1e3d; case ForceChangeRateUnit.KilonewtonPerSecond: return (baseUnitValue) / 1e3d; + case ForceChangeRateUnit.KilopoundForcePerMinute: return (baseUnitValue/4.4482216152605095551842641431421*60) / 1e3d; + case ForceChangeRateUnit.KilopoundForcePerSecond: return (baseUnitValue/4.4482216152605095551842641431421) / 1e3d; case ForceChangeRateUnit.MicronewtonPerSecond: return (baseUnitValue) / 1e-6d; case ForceChangeRateUnit.MillinewtonPerSecond: return (baseUnitValue) / 1e-3d; case ForceChangeRateUnit.NanonewtonPerSecond: return (baseUnitValue) / 1e-9d; case ForceChangeRateUnit.NewtonPerMinute: return baseUnitValue*60; case ForceChangeRateUnit.NewtonPerSecond: return baseUnitValue; + case ForceChangeRateUnit.PoundForcePerMinute: return baseUnitValue/4.4482216152605095551842641431421*60; + case ForceChangeRateUnit.PoundForcePerSecond: return baseUnitValue/4.4482216152605095551842641431421; default: throw new NotImplementedException($"Can not convert {Unit} to {unit}."); } diff --git a/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs index 5d1a27c702..7153505191 100644 --- a/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs @@ -55,10 +55,16 @@ static PressureChangeRate() new UnitInfo(PressureChangeRateUnit.AtmospherePerSecond, BaseUnits.Undefined), new UnitInfo(PressureChangeRateUnit.KilopascalPerMinute, BaseUnits.Undefined), new UnitInfo(PressureChangeRateUnit.KilopascalPerSecond, BaseUnits.Undefined), + new UnitInfo(PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute, BaseUnits.Undefined), + new UnitInfo(PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond, BaseUnits.Undefined), new UnitInfo(PressureChangeRateUnit.MegapascalPerMinute, BaseUnits.Undefined), new UnitInfo(PressureChangeRateUnit.MegapascalPerSecond, BaseUnits.Undefined), + new UnitInfo(PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute, BaseUnits.Undefined), + new UnitInfo(PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond, BaseUnits.Undefined), new UnitInfo(PressureChangeRateUnit.PascalPerMinute, BaseUnits.Undefined), new UnitInfo(PressureChangeRateUnit.PascalPerSecond, BaseUnits.Undefined), + new UnitInfo(PressureChangeRateUnit.PoundForcePerSquareInchPerMinute, BaseUnits.Undefined), + new UnitInfo(PressureChangeRateUnit.PoundForcePerSquareInchPerSecond, BaseUnits.Undefined), }, BaseUnit, Zero, BaseDimensions, QuantityType.PressureChangeRate); } @@ -189,6 +195,16 @@ public PressureChangeRate(double value, UnitSystem unitSystem) /// public double KilopascalsPerSecond => As(PressureChangeRateUnit.KilopascalPerSecond); + /// + /// Get PressureChangeRate in KilopoundsForcePerSquareInchPerMinute. + /// + public double KilopoundsForcePerSquareInchPerMinute => As(PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute); + + /// + /// Get PressureChangeRate in KilopoundsForcePerSquareInchPerSecond. + /// + public double KilopoundsForcePerSquareInchPerSecond => As(PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond); + /// /// Get PressureChangeRate in MegapascalsPerMinute. /// @@ -199,6 +215,16 @@ public PressureChangeRate(double value, UnitSystem unitSystem) /// public double MegapascalsPerSecond => As(PressureChangeRateUnit.MegapascalPerSecond); + /// + /// Get PressureChangeRate in MegapoundsForcePerSquareInchPerMinute. + /// + public double MegapoundsForcePerSquareInchPerMinute => As(PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute); + + /// + /// Get PressureChangeRate in MegapoundsForcePerSquareInchPerSecond. + /// + public double MegapoundsForcePerSquareInchPerSecond => As(PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond); + /// /// Get PressureChangeRate in PascalsPerMinute. /// @@ -209,6 +235,16 @@ public PressureChangeRate(double value, UnitSystem unitSystem) /// public double PascalsPerSecond => As(PressureChangeRateUnit.PascalPerSecond); + /// + /// Get PressureChangeRate in PoundsForcePerSquareInchPerMinute. + /// + public double PoundsForcePerSquareInchPerMinute => As(PressureChangeRateUnit.PoundForcePerSquareInchPerMinute); + + /// + /// Get PressureChangeRate in PoundsForcePerSquareInchPerSecond. + /// + public double PoundsForcePerSquareInchPerSecond => As(PressureChangeRateUnit.PoundForcePerSquareInchPerSecond); + #endregion #region Static Methods @@ -266,6 +302,24 @@ public static PressureChangeRate FromKilopascalsPerSecond(QuantityValue kilopasc return new PressureChangeRate(value, PressureChangeRateUnit.KilopascalPerSecond); } /// + /// Get PressureChangeRate from KilopoundsForcePerSquareInchPerMinute. + /// + /// If value is NaN or Infinity. + public static PressureChangeRate FromKilopoundsForcePerSquareInchPerMinute(QuantityValue kilopoundsforcepersquareinchperminute) + { + double value = (double) kilopoundsforcepersquareinchperminute; + return new PressureChangeRate(value, PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute); + } + /// + /// Get PressureChangeRate from KilopoundsForcePerSquareInchPerSecond. + /// + /// If value is NaN or Infinity. + public static PressureChangeRate FromKilopoundsForcePerSquareInchPerSecond(QuantityValue kilopoundsforcepersquareinchpersecond) + { + double value = (double) kilopoundsforcepersquareinchpersecond; + return new PressureChangeRate(value, PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond); + } + /// /// Get PressureChangeRate from MegapascalsPerMinute. /// /// If value is NaN or Infinity. @@ -284,6 +338,24 @@ public static PressureChangeRate FromMegapascalsPerSecond(QuantityValue megapasc return new PressureChangeRate(value, PressureChangeRateUnit.MegapascalPerSecond); } /// + /// Get PressureChangeRate from MegapoundsForcePerSquareInchPerMinute. + /// + /// If value is NaN or Infinity. + public static PressureChangeRate FromMegapoundsForcePerSquareInchPerMinute(QuantityValue megapoundsforcepersquareinchperminute) + { + double value = (double) megapoundsforcepersquareinchperminute; + return new PressureChangeRate(value, PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute); + } + /// + /// Get PressureChangeRate from MegapoundsForcePerSquareInchPerSecond. + /// + /// If value is NaN or Infinity. + public static PressureChangeRate FromMegapoundsForcePerSquareInchPerSecond(QuantityValue megapoundsforcepersquareinchpersecond) + { + double value = (double) megapoundsforcepersquareinchpersecond; + return new PressureChangeRate(value, PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond); + } + /// /// Get PressureChangeRate from PascalsPerMinute. /// /// If value is NaN or Infinity. @@ -301,6 +373,24 @@ public static PressureChangeRate FromPascalsPerSecond(QuantityValue pascalsperse double value = (double) pascalspersecond; return new PressureChangeRate(value, PressureChangeRateUnit.PascalPerSecond); } + /// + /// Get PressureChangeRate from PoundsForcePerSquareInchPerMinute. + /// + /// If value is NaN or Infinity. + public static PressureChangeRate FromPoundsForcePerSquareInchPerMinute(QuantityValue poundsforcepersquareinchperminute) + { + double value = (double) poundsforcepersquareinchperminute; + return new PressureChangeRate(value, PressureChangeRateUnit.PoundForcePerSquareInchPerMinute); + } + /// + /// Get PressureChangeRate from PoundsForcePerSquareInchPerSecond. + /// + /// If value is NaN or Infinity. + public static PressureChangeRate FromPoundsForcePerSquareInchPerSecond(QuantityValue poundsforcepersquareinchpersecond) + { + double value = (double) poundsforcepersquareinchpersecond; + return new PressureChangeRate(value, PressureChangeRateUnit.PoundForcePerSquareInchPerSecond); + } /// /// Dynamically convert from value and unit enum to . @@ -733,10 +823,16 @@ private double GetValueInBaseUnit() case PressureChangeRateUnit.AtmospherePerSecond: return _value * 1.01325*1e5; case PressureChangeRateUnit.KilopascalPerMinute: return (_value/60) * 1e3d; case PressureChangeRateUnit.KilopascalPerSecond: return (_value) * 1e3d; + case PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute: return (_value*6.894757293168361e3/60) * 1e3d; + case PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond: return (_value*6.894757293168361e3) * 1e3d; case PressureChangeRateUnit.MegapascalPerMinute: return (_value/60) * 1e6d; case PressureChangeRateUnit.MegapascalPerSecond: return (_value) * 1e6d; + case PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute: return (_value*6.894757293168361e3/60) * 1e6d; + case PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond: return (_value*6.894757293168361e3) * 1e6d; case PressureChangeRateUnit.PascalPerMinute: return _value/60; case PressureChangeRateUnit.PascalPerSecond: return _value; + case PressureChangeRateUnit.PoundForcePerSquareInchPerMinute: return _value*6.894757293168361e3/60; + case PressureChangeRateUnit.PoundForcePerSquareInchPerSecond: return _value*6.894757293168361e3; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -765,10 +861,16 @@ private double GetValueAs(PressureChangeRateUnit unit) case PressureChangeRateUnit.AtmospherePerSecond: return baseUnitValue / (1.01325*1e5); case PressureChangeRateUnit.KilopascalPerMinute: return (baseUnitValue*60) / 1e3d; case PressureChangeRateUnit.KilopascalPerSecond: return (baseUnitValue) / 1e3d; + case PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute: return (baseUnitValue/6.894757293168361e3*60) / 1e3d; + case PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond: return (baseUnitValue/6.894757293168361e3) / 1e3d; case PressureChangeRateUnit.MegapascalPerMinute: return (baseUnitValue*60) / 1e6d; case PressureChangeRateUnit.MegapascalPerSecond: return (baseUnitValue) / 1e6d; + case PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute: return (baseUnitValue/6.894757293168361e3*60) / 1e6d; + case PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond: return (baseUnitValue/6.894757293168361e3) / 1e6d; case PressureChangeRateUnit.PascalPerMinute: return baseUnitValue*60; case PressureChangeRateUnit.PascalPerSecond: return baseUnitValue; + case PressureChangeRateUnit.PoundForcePerSquareInchPerMinute: return baseUnitValue/6.894757293168361e3*60; + case PressureChangeRateUnit.PoundForcePerSquareInchPerSecond: return baseUnitValue/6.894757293168361e3; default: throw new NotImplementedException($"Can not convert {Unit} to {unit}."); } diff --git a/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs b/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs index 80e0f3c0f4..69bb6f6077 100644 --- a/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs +++ b/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs @@ -467,11 +467,15 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("en-US", typeof(ForceChangeRateUnit), (int)ForceChangeRateUnit.DecinewtonPerSecond, new string[]{"dN/s"}), ("en-US", typeof(ForceChangeRateUnit), (int)ForceChangeRateUnit.KilonewtonPerMinute, new string[]{"kN/min"}), ("en-US", typeof(ForceChangeRateUnit), (int)ForceChangeRateUnit.KilonewtonPerSecond, new string[]{"kN/s"}), + ("en-US", typeof(ForceChangeRateUnit), (int)ForceChangeRateUnit.KilopoundForcePerMinute, new string[]{"kipf/min", "kip/min", "k/min"}), + ("en-US", typeof(ForceChangeRateUnit), (int)ForceChangeRateUnit.KilopoundForcePerSecond, new string[]{"kipf/s", "kip/s", "k/s"}), ("en-US", typeof(ForceChangeRateUnit), (int)ForceChangeRateUnit.MicronewtonPerSecond, new string[]{"µN/s"}), ("en-US", typeof(ForceChangeRateUnit), (int)ForceChangeRateUnit.MillinewtonPerSecond, new string[]{"mN/s"}), ("en-US", typeof(ForceChangeRateUnit), (int)ForceChangeRateUnit.NanonewtonPerSecond, new string[]{"nN/s"}), ("en-US", typeof(ForceChangeRateUnit), (int)ForceChangeRateUnit.NewtonPerMinute, new string[]{"N/min"}), ("en-US", typeof(ForceChangeRateUnit), (int)ForceChangeRateUnit.NewtonPerSecond, new string[]{"N/s"}), + ("en-US", typeof(ForceChangeRateUnit), (int)ForceChangeRateUnit.PoundForcePerMinute, new string[]{"lbf/min"}), + ("en-US", typeof(ForceChangeRateUnit), (int)ForceChangeRateUnit.PoundForcePerSecond, new string[]{"lbf/s"}), ("en-US", typeof(ForcePerLengthUnit), (int)ForcePerLengthUnit.CentinewtonPerCentimeter, new string[]{"cN/cm"}), ("en-US", typeof(ForcePerLengthUnit), (int)ForcePerLengthUnit.CentinewtonPerMeter, new string[]{"cN/m"}), ("en-US", typeof(ForcePerLengthUnit), (int)ForcePerLengthUnit.CentinewtonPerMillimeter, new string[]{"cN/mm"}), @@ -1111,8 +1115,8 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("en-US", typeof(PressureUnit), (int)PressureUnit.Kilopascal, new string[]{"kPa"}), ("ru-RU", typeof(PressureUnit), (int)PressureUnit.Kilopascal, new string[]{"кПа"}), ("en-US", typeof(PressureUnit), (int)PressureUnit.KilopoundForcePerSquareFoot, new string[]{"kipf/ft²"}), - ("en-US", typeof(PressureUnit), (int)PressureUnit.KilopoundForcePerSquareInch, new string[]{"kipf/in²"}), - ("ru-RU", typeof(PressureUnit), (int)PressureUnit.KilopoundForcePerSquareInch, new string[]{"kipf/in²"}), + ("en-US", typeof(PressureUnit), (int)PressureUnit.KilopoundForcePerSquareInch, new string[]{"ksi", "kipf/in²"}), + ("ru-RU", typeof(PressureUnit), (int)PressureUnit.KilopoundForcePerSquareInch, new string[]{"ksi", "kipf/in²"}), ("en-US", typeof(PressureUnit), (int)PressureUnit.Megabar, new string[]{"Mbar"}), ("ru-RU", typeof(PressureUnit), (int)PressureUnit.Megabar, new string[]{"Мбар"}), ("en-US", typeof(PressureUnit), (int)PressureUnit.MeganewtonPerSquareMeter, new string[]{"MN/m²"}), @@ -1153,17 +1157,29 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("en-US", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.AtmospherePerSecond, new string[]{"atm/s"}), ("ru-RU", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.AtmospherePerSecond, new string[]{"атм/с"}), ("en-US", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.KilopascalPerMinute, new string[]{"kPa/min"}), - ("ru-RU", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.KilopascalPerMinute, new string[]{"кПа/с"}), + ("ru-RU", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.KilopascalPerMinute, new string[]{"кПа/мин"}), ("en-US", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.KilopascalPerSecond, new string[]{"kPa/s"}), ("ru-RU", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.KilopascalPerSecond, new string[]{"кПа/с"}), + ("en-US", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute, new string[]{"ksi/min", "kipf/in²/min"}), + ("ru-RU", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute, new string[]{"ksi/мин", "kipf/in²/мин"}), + ("en-US", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond, new string[]{"ksi/s", "kipf/in²/s"}), + ("ru-RU", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond, new string[]{"ksi/с", "kipf/in²/с"}), ("en-US", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.MegapascalPerMinute, new string[]{"MPa/min"}), - ("ru-RU", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.MegapascalPerMinute, new string[]{"МПа/с"}), + ("ru-RU", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.MegapascalPerMinute, new string[]{"МПа/мин"}), ("en-US", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.MegapascalPerSecond, new string[]{"MPa/s"}), ("ru-RU", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.MegapascalPerSecond, new string[]{"МПа/с"}), + ("en-US", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute, new string[]{"Mpsi/min", "Mlb/in²/min"}), + ("ru-RU", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute, new string[]{"Мpsi/мин", "Мlb/in²/мин"}), + ("en-US", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond, new string[]{"Mpsi/s", "Mlb/in²/s"}), + ("ru-RU", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond, new string[]{"Мpsi/с", "Мlb/in²/с"}), ("en-US", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.PascalPerMinute, new string[]{"Pa/min"}), - ("ru-RU", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.PascalPerMinute, new string[]{"Па/с"}), + ("ru-RU", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.PascalPerMinute, new string[]{"Па/мин"}), ("en-US", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.PascalPerSecond, new string[]{"Pa/s"}), ("ru-RU", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.PascalPerSecond, new string[]{"Па/с"}), + ("en-US", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.PoundForcePerSquareInchPerMinute, new string[]{"psi/min", "lb/in²/min"}), + ("ru-RU", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.PoundForcePerSquareInchPerMinute, new string[]{"psi/мин", "lb/in²/мин"}), + ("en-US", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.PoundForcePerSquareInchPerSecond, new string[]{"psi/s", "lb/in²/s"}), + ("ru-RU", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.PoundForcePerSquareInchPerSecond, new string[]{"psi/с", "lb/in²/с"}), ("en-US", typeof(RatioUnit), (int)RatioUnit.DecimalFraction, new string[]{""}), ("en-US", typeof(RatioUnit), (int)RatioUnit.PartPerBillion, new string[]{"ppb"}), ("en-US", typeof(RatioUnit), (int)RatioUnit.PartPerMillion, new string[]{"ppm"}), diff --git a/UnitsNet/GeneratedCode/UnitConverter.g.cs b/UnitsNet/GeneratedCode/UnitConverter.g.cs index ea53f77c4b..2dba4b13b8 100644 --- a/UnitsNet/GeneratedCode/UnitConverter.g.cs +++ b/UnitsNet/GeneratedCode/UnitConverter.g.cs @@ -660,6 +660,10 @@ public static void RegisterDefaultConversions(UnitConverter unitConverter) unitConverter.SetConversionFunction(ForceChangeRateUnit.KilonewtonPerMinute, ForceChangeRate.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.KilonewtonPerSecond, q => q.ToUnit(ForceChangeRateUnit.KilonewtonPerSecond)); unitConverter.SetConversionFunction(ForceChangeRateUnit.KilonewtonPerSecond, ForceChangeRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.KilopoundForcePerMinute, q => q.ToUnit(ForceChangeRateUnit.KilopoundForcePerMinute)); + unitConverter.SetConversionFunction(ForceChangeRateUnit.KilopoundForcePerMinute, ForceChangeRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.KilopoundForcePerSecond, q => q.ToUnit(ForceChangeRateUnit.KilopoundForcePerSecond)); + unitConverter.SetConversionFunction(ForceChangeRateUnit.KilopoundForcePerSecond, ForceChangeRate.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.MicronewtonPerSecond, q => q.ToUnit(ForceChangeRateUnit.MicronewtonPerSecond)); unitConverter.SetConversionFunction(ForceChangeRateUnit.MicronewtonPerSecond, ForceChangeRate.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.MillinewtonPerSecond, q => q.ToUnit(ForceChangeRateUnit.MillinewtonPerSecond)); @@ -669,6 +673,10 @@ public static void RegisterDefaultConversions(UnitConverter unitConverter) unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.NewtonPerMinute, q => q.ToUnit(ForceChangeRateUnit.NewtonPerMinute)); unitConverter.SetConversionFunction(ForceChangeRateUnit.NewtonPerMinute, ForceChangeRate.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRate.BaseUnit, q => q); + unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.PoundForcePerMinute, q => q.ToUnit(ForceChangeRateUnit.PoundForcePerMinute)); + unitConverter.SetConversionFunction(ForceChangeRateUnit.PoundForcePerMinute, ForceChangeRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ForceChangeRate.BaseUnit, ForceChangeRateUnit.PoundForcePerSecond, q => q.ToUnit(ForceChangeRateUnit.PoundForcePerSecond)); + unitConverter.SetConversionFunction(ForceChangeRateUnit.PoundForcePerSecond, ForceChangeRate.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.CentinewtonPerCentimeter, q => q.ToUnit(ForcePerLengthUnit.CentinewtonPerCentimeter)); unitConverter.SetConversionFunction(ForcePerLengthUnit.CentinewtonPerCentimeter, ForcePerLength.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(ForcePerLength.BaseUnit, ForcePerLengthUnit.CentinewtonPerMeter, q => q.ToUnit(ForcePerLengthUnit.CentinewtonPerMeter)); @@ -1724,13 +1732,25 @@ public static void RegisterDefaultConversions(UnitConverter unitConverter) unitConverter.SetConversionFunction(PressureChangeRateUnit.KilopascalPerMinute, PressureChangeRate.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.KilopascalPerSecond, q => q.ToUnit(PressureChangeRateUnit.KilopascalPerSecond)); unitConverter.SetConversionFunction(PressureChangeRateUnit.KilopascalPerSecond, PressureChangeRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute, q => q.ToUnit(PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute)); + unitConverter.SetConversionFunction(PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute, PressureChangeRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond, q => q.ToUnit(PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond)); + unitConverter.SetConversionFunction(PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond, PressureChangeRate.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.MegapascalPerMinute, q => q.ToUnit(PressureChangeRateUnit.MegapascalPerMinute)); unitConverter.SetConversionFunction(PressureChangeRateUnit.MegapascalPerMinute, PressureChangeRate.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.MegapascalPerSecond, q => q.ToUnit(PressureChangeRateUnit.MegapascalPerSecond)); unitConverter.SetConversionFunction(PressureChangeRateUnit.MegapascalPerSecond, PressureChangeRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute, q => q.ToUnit(PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute)); + unitConverter.SetConversionFunction(PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute, PressureChangeRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond, q => q.ToUnit(PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond)); + unitConverter.SetConversionFunction(PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond, PressureChangeRate.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.PascalPerMinute, q => q.ToUnit(PressureChangeRateUnit.PascalPerMinute)); unitConverter.SetConversionFunction(PressureChangeRateUnit.PascalPerMinute, PressureChangeRate.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRate.BaseUnit, q => q); + unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.PoundForcePerSquareInchPerMinute, q => q.ToUnit(PressureChangeRateUnit.PoundForcePerSquareInchPerMinute)); + unitConverter.SetConversionFunction(PressureChangeRateUnit.PoundForcePerSquareInchPerMinute, PressureChangeRate.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.PoundForcePerSquareInchPerSecond, q => q.ToUnit(PressureChangeRateUnit.PoundForcePerSquareInchPerSecond)); + unitConverter.SetConversionFunction(PressureChangeRateUnit.PoundForcePerSquareInchPerSecond, PressureChangeRate.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Ratio.BaseUnit, Ratio.BaseUnit, q => q); unitConverter.SetConversionFunction(Ratio.BaseUnit, RatioUnit.PartPerBillion, q => q.ToUnit(RatioUnit.PartPerBillion)); unitConverter.SetConversionFunction(RatioUnit.PartPerBillion, Ratio.BaseUnit, q => q.ToBaseUnit()); diff --git a/UnitsNet/GeneratedCode/Units/ForceChangeRateUnit.g.cs b/UnitsNet/GeneratedCode/Units/ForceChangeRateUnit.g.cs index db444ea23a..989a72cf46 100644 --- a/UnitsNet/GeneratedCode/Units/ForceChangeRateUnit.g.cs +++ b/UnitsNet/GeneratedCode/Units/ForceChangeRateUnit.g.cs @@ -32,11 +32,15 @@ public enum ForceChangeRateUnit DecinewtonPerSecond, KilonewtonPerMinute, KilonewtonPerSecond, + KilopoundForcePerMinute, + KilopoundForcePerSecond, MicronewtonPerSecond, MillinewtonPerSecond, NanonewtonPerSecond, NewtonPerMinute, NewtonPerSecond, + PoundForcePerMinute, + PoundForcePerSecond, } #pragma warning restore 1591 diff --git a/UnitsNet/GeneratedCode/Units/PressureChangeRateUnit.g.cs b/UnitsNet/GeneratedCode/Units/PressureChangeRateUnit.g.cs index 6bd31402a5..0bfb681ff4 100644 --- a/UnitsNet/GeneratedCode/Units/PressureChangeRateUnit.g.cs +++ b/UnitsNet/GeneratedCode/Units/PressureChangeRateUnit.g.cs @@ -29,10 +29,16 @@ public enum PressureChangeRateUnit AtmospherePerSecond, KilopascalPerMinute, KilopascalPerSecond, + KilopoundForcePerSquareInchPerMinute, + KilopoundForcePerSquareInchPerSecond, MegapascalPerMinute, MegapascalPerSecond, + MegapoundForcePerSquareInchPerMinute, + MegapoundForcePerSquareInchPerSecond, PascalPerMinute, PascalPerSecond, + PoundForcePerSquareInchPerMinute, + PoundForcePerSquareInchPerSecond, } #pragma warning restore 1591