From 7ac9e53644ed5e58f8feaa9ec85044737dfc13b9 Mon Sep 17 00:00:00 2001 From: Tristan Milnthorp Date: Mon, 29 Oct 2018 11:12:26 -0400 Subject: [PATCH 1/2] =?UTF-8?q?Adding=20dyn/cm=C2=B2=20and=20lbm/(in=C2=B7?= =?UTF-8?q?s=C2=B2)=20units=20for=20pressure?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../Quantities/Pressure.Common.g.cs | 42 +++++++++++++++++++ Common/UnitDefinitions/Pressure.json | 24 +++++++++++ UnitsNet.Tests/CustomCode/PressureTests.cs | 4 ++ .../GeneratedCode/PressureTestsBase.g.cs | 20 +++++++++ .../Number/NumberToPressureExtensions.g.cs | 22 ++++++++++ .../Quantities/Pressure.NetFramework.g.cs | 18 ++++++++ .../GeneratedCode/UnitSystem.Default.g.cs | 10 +++++ .../GeneratedCode/Units/PressureUnit.g.cs | 2 + 8 files changed, 142 insertions(+) diff --git a/Common/GeneratedCode/Quantities/Pressure.Common.g.cs b/Common/GeneratedCode/Quantities/Pressure.Common.g.cs index 3959f4452a..079726474d 100644 --- a/Common/GeneratedCode/Quantities/Pressure.Common.g.cs +++ b/Common/GeneratedCode/Quantities/Pressure.Common.g.cs @@ -186,6 +186,11 @@ public static BaseDimensions BaseDimensions /// public double Decibars => As(PressureUnit.Decibar); + /// + /// Get Pressure in DynesPerSquareCentimeter. + /// + public double DynesPerSquareCentimeter => As(PressureUnit.DynePerSquareCentimeter); + /// /// Get Pressure in FeetOfHead. /// @@ -321,6 +326,11 @@ public static BaseDimensions BaseDimensions /// public double PoundsForcePerSquareInch => As(PressureUnit.PoundForcePerSquareInch); + /// + /// Get Pressure in PoundsPerInchSecondSquared. + /// + public double PoundsPerInchSecondSquared => As(PressureUnit.PoundPerInchSecondSquared); + /// /// Get Pressure in Psi. /// @@ -431,6 +441,20 @@ public static Pressure FromDecibars(QuantityValue decibars) return new Pressure(value, PressureUnit.Decibar); } + /// + /// Get Pressure from DynesPerSquareCentimeter. + /// +#if WINDOWS_UWP + [Windows.Foundation.Metadata.DefaultOverload] + public static Pressure FromDynesPerSquareCentimeter(double dynespersquarecentimeter) +#else + public static Pressure FromDynesPerSquareCentimeter(QuantityValue dynespersquarecentimeter) +#endif + { + double value = (double) dynespersquarecentimeter; + return new Pressure(value, PressureUnit.DynePerSquareCentimeter); + } + /// /// Get Pressure from FeetOfHead. /// @@ -809,6 +833,20 @@ public static Pressure FromPoundsForcePerSquareInch(QuantityValue poundsforceper return new Pressure(value, PressureUnit.PoundForcePerSquareInch); } + /// + /// Get Pressure from PoundsPerInchSecondSquared. + /// +#if WINDOWS_UWP + [Windows.Foundation.Metadata.DefaultOverload] + public static Pressure FromPoundsPerInchSecondSquared(double poundsperinchsecondsquared) +#else + public static Pressure FromPoundsPerInchSecondSquared(QuantityValue poundsperinchsecondsquared) +#endif + { + double value = (double) poundsperinchsecondsquared; + return new Pressure(value, PressureUnit.PoundPerInchSecondSquared); + } + /// /// Get Pressure from Psi. /// @@ -1071,6 +1109,7 @@ private double AsBaseUnit() case PressureUnit.Centibar: return (_value*1e5) * 1e-2d; case PressureUnit.Decapascal: return (_value) * 1e1d; case PressureUnit.Decibar: return (_value*1e5) * 1e-1d; + case PressureUnit.DynePerSquareCentimeter: return _value*1.0e-1; case PressureUnit.FootOfHead: return _value*2989.0669; case PressureUnit.Gigapascal: return (_value) * 1e9d; case PressureUnit.Hectopascal: return (_value) * 1e2d; @@ -1098,6 +1137,7 @@ private double AsBaseUnit() case PressureUnit.Pascal: return _value; case PressureUnit.PoundForcePerSquareFoot: return _value*4.788025898033584e1; case PressureUnit.PoundForcePerSquareInch: return _value*6.894757293168361e3; + case PressureUnit.PoundPerInchSecondSquared: return _value*1.785796732283465e1; case PressureUnit.Psi: return _value*6.894757293168361e3; case PressureUnit.TechnicalAtmosphere: return _value*9.80680592331*1e4; case PressureUnit.TonneForcePerSquareCentimeter: return _value*9.80665e7; @@ -1123,6 +1163,7 @@ private double AsBaseNumericType(PressureUnit unit) case PressureUnit.Centibar: return (baseUnitValue/1e5) / 1e-2d; case PressureUnit.Decapascal: return (baseUnitValue) / 1e1d; case PressureUnit.Decibar: return (baseUnitValue/1e5) / 1e-1d; + case PressureUnit.DynePerSquareCentimeter: return baseUnitValue/1.0e-1; case PressureUnit.FootOfHead: return baseUnitValue*0.000334552565551; case PressureUnit.Gigapascal: return (baseUnitValue) / 1e9d; case PressureUnit.Hectopascal: return (baseUnitValue) / 1e2d; @@ -1150,6 +1191,7 @@ private double AsBaseNumericType(PressureUnit unit) case PressureUnit.Pascal: return baseUnitValue; case PressureUnit.PoundForcePerSquareFoot: return baseUnitValue/4.788025898033584e1; case PressureUnit.PoundForcePerSquareInch: return baseUnitValue/6.894757293168361e3; + case PressureUnit.PoundPerInchSecondSquared: return baseUnitValue/1.785796732283465e1; case PressureUnit.Psi: return baseUnitValue/6.894757293168361e3; case PressureUnit.TechnicalAtmosphere: return baseUnitValue/(9.80680592331*1e4); case PressureUnit.TonneForcePerSquareCentimeter: return baseUnitValue/9.80665e7; diff --git a/Common/UnitDefinitions/Pressure.json b/Common/UnitDefinitions/Pressure.json index 7651a70e07..e68ee1f79d 100644 --- a/Common/UnitDefinitions/Pressure.json +++ b/Common/UnitDefinitions/Pressure.json @@ -321,6 +321,30 @@ "Abbreviations": [ "inHg" ] } ] + }, + { + "SingularName": "DynePerSquareCentimeter", + "PluralName": "DynesPerSquareCentimeter", + "FromUnitToBaseFunc": "x*1.0e-1", + "FromBaseToUnitFunc": "x/1.0e-1", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "dyn/cm²" ] + } + ] + }, + { + "SingularName": "PoundPerInchSecondSquared", + "PluralName": "PoundsPerInchSecondSquared", + "FromUnitToBaseFunc": "x*1.785796732283465e1", + "FromBaseToUnitFunc": "x/1.785796732283465e1", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "lbm/(in·s²)", "lb/(in·s²)" ] + } + ] } ] } \ No newline at end of file diff --git a/UnitsNet.Tests/CustomCode/PressureTests.cs b/UnitsNet.Tests/CustomCode/PressureTests.cs index bf6b3d4bd2..79580b8c9f 100644 --- a/UnitsNet.Tests/CustomCode/PressureTests.cs +++ b/UnitsNet.Tests/CustomCode/PressureTests.cs @@ -101,6 +101,10 @@ public class PressureTests : PressureTestsBase protected override double InchesOfMercuryInOnePascal => 2.95299830714159e-4; + protected override double DynesPerSquareCentimeterInOnePascal => 1.0e1; + + protected override double PoundsPerInchSecondSquaredInOnePascal => 5.599741459495891e-2; + [Fact] public void AreaTimesPressureEqualsForce() { diff --git a/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs index fad6f6b86e..afff6b9819 100644 --- a/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs @@ -58,6 +58,7 @@ public abstract partial class PressureTestsBase protected abstract double CentibarsInOnePascal { get; } protected abstract double DecapascalsInOnePascal { get; } protected abstract double DecibarsInOnePascal { get; } + protected abstract double DynesPerSquareCentimeterInOnePascal { get; } protected abstract double FeetOfHeadInOnePascal { get; } protected abstract double GigapascalsInOnePascal { get; } protected abstract double HectopascalsInOnePascal { get; } @@ -85,6 +86,7 @@ public abstract partial class PressureTestsBase protected abstract double PascalsInOnePascal { get; } protected abstract double PoundsForcePerSquareFootInOnePascal { get; } protected abstract double PoundsForcePerSquareInchInOnePascal { get; } + protected abstract double PoundsPerInchSecondSquaredInOnePascal { get; } protected abstract double PsiInOnePascal { get; } protected abstract double TechnicalAtmospheresInOnePascal { get; } protected abstract double TonnesForcePerSquareCentimeterInOnePascal { get; } @@ -98,6 +100,7 @@ public abstract partial class PressureTestsBase protected virtual double CentibarsTolerance { get { return 1e-5; } } protected virtual double DecapascalsTolerance { get { return 1e-5; } } protected virtual double DecibarsTolerance { get { return 1e-5; } } + protected virtual double DynesPerSquareCentimeterTolerance { get { return 1e-5; } } protected virtual double FeetOfHeadTolerance { get { return 1e-5; } } protected virtual double GigapascalsTolerance { get { return 1e-5; } } protected virtual double HectopascalsTolerance { get { return 1e-5; } } @@ -125,6 +128,7 @@ public abstract partial class PressureTestsBase protected virtual double PascalsTolerance { get { return 1e-5; } } protected virtual double PoundsForcePerSquareFootTolerance { get { return 1e-5; } } protected virtual double PoundsForcePerSquareInchTolerance { get { return 1e-5; } } + protected virtual double PoundsPerInchSecondSquaredTolerance { get { return 1e-5; } } protected virtual double PsiTolerance { get { return 1e-5; } } protected virtual double TechnicalAtmospheresTolerance { get { return 1e-5; } } protected virtual double TonnesForcePerSquareCentimeterTolerance { get { return 1e-5; } } @@ -142,6 +146,7 @@ public void PascalToPressureUnits() AssertEx.EqualTolerance(CentibarsInOnePascal, pascal.Centibars, CentibarsTolerance); AssertEx.EqualTolerance(DecapascalsInOnePascal, pascal.Decapascals, DecapascalsTolerance); AssertEx.EqualTolerance(DecibarsInOnePascal, pascal.Decibars, DecibarsTolerance); + AssertEx.EqualTolerance(DynesPerSquareCentimeterInOnePascal, pascal.DynesPerSquareCentimeter, DynesPerSquareCentimeterTolerance); AssertEx.EqualTolerance(FeetOfHeadInOnePascal, pascal.FeetOfHead, FeetOfHeadTolerance); AssertEx.EqualTolerance(GigapascalsInOnePascal, pascal.Gigapascals, GigapascalsTolerance); AssertEx.EqualTolerance(HectopascalsInOnePascal, pascal.Hectopascals, HectopascalsTolerance); @@ -169,6 +174,7 @@ public void PascalToPressureUnits() AssertEx.EqualTolerance(PascalsInOnePascal, pascal.Pascals, PascalsTolerance); AssertEx.EqualTolerance(PoundsForcePerSquareFootInOnePascal, pascal.PoundsForcePerSquareFoot, PoundsForcePerSquareFootTolerance); AssertEx.EqualTolerance(PoundsForcePerSquareInchInOnePascal, pascal.PoundsForcePerSquareInch, PoundsForcePerSquareInchTolerance); + AssertEx.EqualTolerance(PoundsPerInchSecondSquaredInOnePascal, pascal.PoundsPerInchSecondSquared, PoundsPerInchSecondSquaredTolerance); AssertEx.EqualTolerance(PsiInOnePascal, pascal.Psi, PsiTolerance); AssertEx.EqualTolerance(TechnicalAtmospheresInOnePascal, pascal.TechnicalAtmospheres, TechnicalAtmospheresTolerance); AssertEx.EqualTolerance(TonnesForcePerSquareCentimeterInOnePascal, pascal.TonnesForcePerSquareCentimeter, TonnesForcePerSquareCentimeterTolerance); @@ -185,6 +191,7 @@ public void FromValueAndUnit() AssertEx.EqualTolerance(1, Pressure.From(1, PressureUnit.Centibar).Centibars, CentibarsTolerance); AssertEx.EqualTolerance(1, Pressure.From(1, PressureUnit.Decapascal).Decapascals, DecapascalsTolerance); AssertEx.EqualTolerance(1, Pressure.From(1, PressureUnit.Decibar).Decibars, DecibarsTolerance); + AssertEx.EqualTolerance(1, Pressure.From(1, PressureUnit.DynePerSquareCentimeter).DynesPerSquareCentimeter, DynesPerSquareCentimeterTolerance); AssertEx.EqualTolerance(1, Pressure.From(1, PressureUnit.FootOfHead).FeetOfHead, FeetOfHeadTolerance); AssertEx.EqualTolerance(1, Pressure.From(1, PressureUnit.Gigapascal).Gigapascals, GigapascalsTolerance); AssertEx.EqualTolerance(1, Pressure.From(1, PressureUnit.Hectopascal).Hectopascals, HectopascalsTolerance); @@ -212,6 +219,7 @@ public void FromValueAndUnit() AssertEx.EqualTolerance(1, Pressure.From(1, PressureUnit.Pascal).Pascals, PascalsTolerance); AssertEx.EqualTolerance(1, Pressure.From(1, PressureUnit.PoundForcePerSquareFoot).PoundsForcePerSquareFoot, PoundsForcePerSquareFootTolerance); AssertEx.EqualTolerance(1, Pressure.From(1, PressureUnit.PoundForcePerSquareInch).PoundsForcePerSquareInch, PoundsForcePerSquareInchTolerance); + AssertEx.EqualTolerance(1, Pressure.From(1, PressureUnit.PoundPerInchSecondSquared).PoundsPerInchSecondSquared, PoundsPerInchSecondSquaredTolerance); AssertEx.EqualTolerance(1, Pressure.From(1, PressureUnit.Psi).Psi, PsiTolerance); AssertEx.EqualTolerance(1, Pressure.From(1, PressureUnit.TechnicalAtmosphere).TechnicalAtmospheres, TechnicalAtmospheresTolerance); AssertEx.EqualTolerance(1, Pressure.From(1, PressureUnit.TonneForcePerSquareCentimeter).TonnesForcePerSquareCentimeter, TonnesForcePerSquareCentimeterTolerance); @@ -229,6 +237,7 @@ public void As() AssertEx.EqualTolerance(CentibarsInOnePascal, pascal.As(PressureUnit.Centibar), CentibarsTolerance); AssertEx.EqualTolerance(DecapascalsInOnePascal, pascal.As(PressureUnit.Decapascal), DecapascalsTolerance); AssertEx.EqualTolerance(DecibarsInOnePascal, pascal.As(PressureUnit.Decibar), DecibarsTolerance); + AssertEx.EqualTolerance(DynesPerSquareCentimeterInOnePascal, pascal.As(PressureUnit.DynePerSquareCentimeter), DynesPerSquareCentimeterTolerance); AssertEx.EqualTolerance(FeetOfHeadInOnePascal, pascal.As(PressureUnit.FootOfHead), FeetOfHeadTolerance); AssertEx.EqualTolerance(GigapascalsInOnePascal, pascal.As(PressureUnit.Gigapascal), GigapascalsTolerance); AssertEx.EqualTolerance(HectopascalsInOnePascal, pascal.As(PressureUnit.Hectopascal), HectopascalsTolerance); @@ -256,6 +265,7 @@ public void As() AssertEx.EqualTolerance(PascalsInOnePascal, pascal.As(PressureUnit.Pascal), PascalsTolerance); AssertEx.EqualTolerance(PoundsForcePerSquareFootInOnePascal, pascal.As(PressureUnit.PoundForcePerSquareFoot), PoundsForcePerSquareFootTolerance); AssertEx.EqualTolerance(PoundsForcePerSquareInchInOnePascal, pascal.As(PressureUnit.PoundForcePerSquareInch), PoundsForcePerSquareInchTolerance); + AssertEx.EqualTolerance(PoundsPerInchSecondSquaredInOnePascal, pascal.As(PressureUnit.PoundPerInchSecondSquared), PoundsPerInchSecondSquaredTolerance); AssertEx.EqualTolerance(PsiInOnePascal, pascal.As(PressureUnit.Psi), PsiTolerance); AssertEx.EqualTolerance(TechnicalAtmospheresInOnePascal, pascal.As(PressureUnit.TechnicalAtmosphere), TechnicalAtmospheresTolerance); AssertEx.EqualTolerance(TonnesForcePerSquareCentimeterInOnePascal, pascal.As(PressureUnit.TonneForcePerSquareCentimeter), TonnesForcePerSquareCentimeterTolerance); @@ -289,6 +299,10 @@ public void ToUnit() AssertEx.EqualTolerance(DecibarsInOnePascal, (double)decibarQuantity.Value, DecibarsTolerance); Assert.Equal(PressureUnit.Decibar, decibarQuantity.Unit); + var dynepersquarecentimeterQuantity = pascal.ToUnit(PressureUnit.DynePerSquareCentimeter); + AssertEx.EqualTolerance(DynesPerSquareCentimeterInOnePascal, (double)dynepersquarecentimeterQuantity.Value, DynesPerSquareCentimeterTolerance); + Assert.Equal(PressureUnit.DynePerSquareCentimeter, dynepersquarecentimeterQuantity.Unit); + var footofheadQuantity = pascal.ToUnit(PressureUnit.FootOfHead); AssertEx.EqualTolerance(FeetOfHeadInOnePascal, (double)footofheadQuantity.Value, FeetOfHeadTolerance); Assert.Equal(PressureUnit.FootOfHead, footofheadQuantity.Unit); @@ -397,6 +411,10 @@ public void ToUnit() AssertEx.EqualTolerance(PoundsForcePerSquareInchInOnePascal, (double)poundforcepersquareinchQuantity.Value, PoundsForcePerSquareInchTolerance); Assert.Equal(PressureUnit.PoundForcePerSquareInch, poundforcepersquareinchQuantity.Unit); + var poundperinchsecondsquaredQuantity = pascal.ToUnit(PressureUnit.PoundPerInchSecondSquared); + AssertEx.EqualTolerance(PoundsPerInchSecondSquaredInOnePascal, (double)poundperinchsecondsquaredQuantity.Value, PoundsPerInchSecondSquaredTolerance); + Assert.Equal(PressureUnit.PoundPerInchSecondSquared, poundperinchsecondsquaredQuantity.Unit); + var psiQuantity = pascal.ToUnit(PressureUnit.Psi); AssertEx.EqualTolerance(PsiInOnePascal, (double)psiQuantity.Value, PsiTolerance); Assert.Equal(PressureUnit.Psi, psiQuantity.Unit); @@ -431,6 +449,7 @@ public void ConversionRoundTrip() AssertEx.EqualTolerance(1, Pressure.FromCentibars(pascal.Centibars).Pascals, CentibarsTolerance); AssertEx.EqualTolerance(1, Pressure.FromDecapascals(pascal.Decapascals).Pascals, DecapascalsTolerance); AssertEx.EqualTolerance(1, Pressure.FromDecibars(pascal.Decibars).Pascals, DecibarsTolerance); + AssertEx.EqualTolerance(1, Pressure.FromDynesPerSquareCentimeter(pascal.DynesPerSquareCentimeter).Pascals, DynesPerSquareCentimeterTolerance); AssertEx.EqualTolerance(1, Pressure.FromFeetOfHead(pascal.FeetOfHead).Pascals, FeetOfHeadTolerance); AssertEx.EqualTolerance(1, Pressure.FromGigapascals(pascal.Gigapascals).Pascals, GigapascalsTolerance); AssertEx.EqualTolerance(1, Pressure.FromHectopascals(pascal.Hectopascals).Pascals, HectopascalsTolerance); @@ -458,6 +477,7 @@ public void ConversionRoundTrip() AssertEx.EqualTolerance(1, Pressure.FromPascals(pascal.Pascals).Pascals, PascalsTolerance); AssertEx.EqualTolerance(1, Pressure.FromPoundsForcePerSquareFoot(pascal.PoundsForcePerSquareFoot).Pascals, PoundsForcePerSquareFootTolerance); AssertEx.EqualTolerance(1, Pressure.FromPoundsForcePerSquareInch(pascal.PoundsForcePerSquareInch).Pascals, PoundsForcePerSquareInchTolerance); + AssertEx.EqualTolerance(1, Pressure.FromPoundsPerInchSecondSquared(pascal.PoundsPerInchSecondSquared).Pascals, PoundsPerInchSecondSquaredTolerance); AssertEx.EqualTolerance(1, Pressure.FromPsi(pascal.Psi).Pascals, PsiTolerance); AssertEx.EqualTolerance(1, Pressure.FromTechnicalAtmospheres(pascal.TechnicalAtmospheres).Pascals, TechnicalAtmospheresTolerance); AssertEx.EqualTolerance(1, Pressure.FromTonnesForcePerSquareCentimeter(pascal.TonnesForcePerSquareCentimeter).Pascals, TonnesForcePerSquareCentimeterTolerance); diff --git a/UnitsNet/GeneratedCode/Extensions/Number/NumberToPressureExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/Number/NumberToPressureExtensions.g.cs index 3a81e40518..7d4373bbca 100644 --- a/UnitsNet/GeneratedCode/Extensions/Number/NumberToPressureExtensions.g.cs +++ b/UnitsNet/GeneratedCode/Extensions/Number/NumberToPressureExtensions.g.cs @@ -99,6 +99,17 @@ public static class NumberToPressureExtensions #endregion + #region DynePerSquareCentimeter + + /// + public static Pressure DynesPerSquareCentimeter(this T value) => Pressure.FromDynesPerSquareCentimeter(Convert.ToDouble(value)); + + /// + [Obsolete("Nullable type support has been deprecated and will be removed in a future release.")] + public static Pressure? DynesPerSquareCentimeter(this T? value) where T : struct => Pressure.FromDynesPerSquareCentimeter(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + #region FootOfHead /// @@ -396,6 +407,17 @@ public static class NumberToPressureExtensions #endregion + #region PoundPerInchSecondSquared + + /// + public static Pressure PoundsPerInchSecondSquared(this T value) => Pressure.FromPoundsPerInchSecondSquared(Convert.ToDouble(value)); + + /// + [Obsolete("Nullable type support has been deprecated and will be removed in a future release.")] + public static Pressure? PoundsPerInchSecondSquared(this T? value) where T : struct => Pressure.FromPoundsPerInchSecondSquared(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + #region Psi /// diff --git a/UnitsNet/GeneratedCode/Quantities/Pressure.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Pressure.NetFramework.g.cs index 188b9fcdda..dde6e30647 100644 --- a/UnitsNet/GeneratedCode/Quantities/Pressure.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Pressure.NetFramework.g.cs @@ -107,6 +107,15 @@ public partial struct Pressure : IComparable, IComparable return decibars.HasValue ? FromDecibars(decibars.Value) : default(Pressure?); } + /// + /// Get nullable Pressure from nullable DynesPerSquareCentimeter. + /// + [Obsolete("Nullable type support is obsolete and will be removed in a future release.")] + public static Pressure? FromDynesPerSquareCentimeter(QuantityValue? dynespersquarecentimeter) + { + return dynespersquarecentimeter.HasValue ? FromDynesPerSquareCentimeter(dynespersquarecentimeter.Value) : default(Pressure?); + } + /// /// Get nullable Pressure from nullable FeetOfHead. /// @@ -350,6 +359,15 @@ public partial struct Pressure : IComparable, IComparable return poundsforcepersquareinch.HasValue ? FromPoundsForcePerSquareInch(poundsforcepersquareinch.Value) : default(Pressure?); } + /// + /// Get nullable Pressure from nullable PoundsPerInchSecondSquared. + /// + [Obsolete("Nullable type support is obsolete and will be removed in a future release.")] + public static Pressure? FromPoundsPerInchSecondSquared(QuantityValue? poundsperinchsecondsquared) + { + return poundsperinchsecondsquared.HasValue ? FromPoundsPerInchSecondSquared(poundsperinchsecondsquared.Value) : default(Pressure?); + } + /// /// Get nullable Pressure from nullable Psi. /// diff --git a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs index ff638eec87..730440c2d7 100644 --- a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs +++ b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs @@ -3212,6 +3212,11 @@ private static readonly ReadOnlyCollection DefaultLocalization new AbbreviationsForCulture("en-US", "dbar"), new AbbreviationsForCulture("ru-RU", "dбар"), }), + new CulturesForEnumValue((int) PressureUnit.DynePerSquareCentimeter, + new[] + { + new AbbreviationsForCulture("en-US", "dyn/cm²"), + }), new CulturesForEnumValue((int) PressureUnit.FootOfHead, new[] { @@ -3366,6 +3371,11 @@ private static readonly ReadOnlyCollection DefaultLocalization { new AbbreviationsForCulture("en-US", "psi", "lb/in²"), }), + new CulturesForEnumValue((int) PressureUnit.PoundPerInchSecondSquared, + new[] + { + new AbbreviationsForCulture("en-US", "lbm/(in·s²)", "lb/(in·s²)"), + }), new CulturesForEnumValue((int) PressureUnit.Psi, new[] { diff --git a/UnitsNet/GeneratedCode/Units/PressureUnit.g.cs b/UnitsNet/GeneratedCode/Units/PressureUnit.g.cs index dd3633fc11..3c57062171 100644 --- a/UnitsNet/GeneratedCode/Units/PressureUnit.g.cs +++ b/UnitsNet/GeneratedCode/Units/PressureUnit.g.cs @@ -50,6 +50,7 @@ public enum PressureUnit Centibar, Decapascal, Decibar, + DynePerSquareCentimeter, FootOfHead, Gigapascal, Hectopascal, @@ -77,6 +78,7 @@ public enum PressureUnit Pascal, PoundForcePerSquareFoot, PoundForcePerSquareInch, + PoundPerInchSecondSquared, [System.Obsolete("Deprecated due to github issue #215, please use PoundForcePerSquareInch instead")] Psi, TechnicalAtmosphere, From 6b00e8f022b22b70c2ea3fbb3dbec8b87f760680 Mon Sep 17 00:00:00 2001 From: Tristan Milnthorp Date: Mon, 29 Oct 2018 11:27:04 -0400 Subject: [PATCH 2/2] =?UTF-8?q?Adding=20microbars=20(=3D=201=20dyn/cm?= =?UTF-8?q?=C2=B2)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../Quantities/Pressure.Common.g.cs | 21 +++++++++++++++++++ Common/UnitDefinitions/Pressure.json | 2 +- UnitsNet.Tests/CustomCode/PressureTests.cs | 2 ++ .../GeneratedCode/PressureTestsBase.g.cs | 10 +++++++++ .../Number/NumberToPressureExtensions.g.cs | 11 ++++++++++ .../Quantities/Pressure.NetFramework.g.cs | 9 ++++++++ .../GeneratedCode/UnitSystem.Default.g.cs | 6 ++++++ .../GeneratedCode/Units/PressureUnit.g.cs | 1 + 8 files changed, 61 insertions(+), 1 deletion(-) diff --git a/Common/GeneratedCode/Quantities/Pressure.Common.g.cs b/Common/GeneratedCode/Quantities/Pressure.Common.g.cs index 079726474d..b8dae6eb76 100644 --- a/Common/GeneratedCode/Quantities/Pressure.Common.g.cs +++ b/Common/GeneratedCode/Quantities/Pressure.Common.g.cs @@ -281,6 +281,11 @@ public static BaseDimensions BaseDimensions /// public double MetersOfHead => As(PressureUnit.MeterOfHead); + /// + /// Get Pressure in Microbars. + /// + public double Microbars => As(PressureUnit.Microbar); + /// /// Get Pressure in Micropascals. /// @@ -707,6 +712,20 @@ public static Pressure FromMetersOfHead(QuantityValue metersofhead) return new Pressure(value, PressureUnit.MeterOfHead); } + /// + /// Get Pressure from Microbars. + /// +#if WINDOWS_UWP + [Windows.Foundation.Metadata.DefaultOverload] + public static Pressure FromMicrobars(double microbars) +#else + public static Pressure FromMicrobars(QuantityValue microbars) +#endif + { + double value = (double) microbars; + return new Pressure(value, PressureUnit.Microbar); + } + /// /// Get Pressure from Micropascals. /// @@ -1128,6 +1147,7 @@ private double AsBaseUnit() case PressureUnit.MeganewtonPerSquareMeter: return (_value) * 1e6d; case PressureUnit.Megapascal: return (_value) * 1e6d; case PressureUnit.MeterOfHead: return _value*9804.139432; + case PressureUnit.Microbar: return (_value*1e5) * 1e-6d; case PressureUnit.Micropascal: return (_value) * 1e-6d; case PressureUnit.Millibar: return (_value*1e5) * 1e-3d; case PressureUnit.MillimeterOfMercury: return _value/7.50061561302643e-3; @@ -1182,6 +1202,7 @@ private double AsBaseNumericType(PressureUnit unit) case PressureUnit.MeganewtonPerSquareMeter: return (baseUnitValue) / 1e6d; case PressureUnit.Megapascal: return (baseUnitValue) / 1e6d; case PressureUnit.MeterOfHead: return baseUnitValue*0.0001019977334; + case PressureUnit.Microbar: return (baseUnitValue/1e5) / 1e-6d; case PressureUnit.Micropascal: return (baseUnitValue) / 1e-6d; case PressureUnit.Millibar: return (baseUnitValue/1e5) / 1e-3d; case PressureUnit.MillimeterOfMercury: return baseUnitValue*7.50061561302643e-3; diff --git a/Common/UnitDefinitions/Pressure.json b/Common/UnitDefinitions/Pressure.json index e68ee1f79d..5487f8a9b9 100644 --- a/Common/UnitDefinitions/Pressure.json +++ b/Common/UnitDefinitions/Pressure.json @@ -47,7 +47,7 @@ "PluralName": "Bars", "FromUnitToBaseFunc": "x*1e5", "FromBaseToUnitFunc": "x/1e5", - "Prefixes": [ "Milli", "Centi", "Deci", "Kilo", "Mega" ], + "Prefixes": [ "Micro", "Milli", "Centi", "Deci", "Kilo", "Mega" ], "Localization": [ { "Culture": "en-US", diff --git a/UnitsNet.Tests/CustomCode/PressureTests.cs b/UnitsNet.Tests/CustomCode/PressureTests.cs index 79580b8c9f..5345aa5e8a 100644 --- a/UnitsNet.Tests/CustomCode/PressureTests.cs +++ b/UnitsNet.Tests/CustomCode/PressureTests.cs @@ -97,6 +97,8 @@ public class PressureTests : PressureTestsBase protected override double MillibarsInOnePascal => 1e-2; + protected override double MicrobarsInOnePascal => 1.0e1; + protected override double MillimetersOfMercuryInOnePascal => 7.50061561302643e-3; protected override double InchesOfMercuryInOnePascal => 2.95299830714159e-4; diff --git a/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs index afff6b9819..055ee9a4cf 100644 --- a/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs @@ -77,6 +77,7 @@ public abstract partial class PressureTestsBase protected abstract double MeganewtonsPerSquareMeterInOnePascal { get; } protected abstract double MegapascalsInOnePascal { get; } protected abstract double MetersOfHeadInOnePascal { get; } + protected abstract double MicrobarsInOnePascal { get; } protected abstract double MicropascalsInOnePascal { get; } protected abstract double MillibarsInOnePascal { get; } protected abstract double MillimetersOfMercuryInOnePascal { get; } @@ -119,6 +120,7 @@ public abstract partial class PressureTestsBase protected virtual double MeganewtonsPerSquareMeterTolerance { get { return 1e-5; } } protected virtual double MegapascalsTolerance { get { return 1e-5; } } protected virtual double MetersOfHeadTolerance { get { return 1e-5; } } + protected virtual double MicrobarsTolerance { get { return 1e-5; } } protected virtual double MicropascalsTolerance { get { return 1e-5; } } protected virtual double MillibarsTolerance { get { return 1e-5; } } protected virtual double MillimetersOfMercuryTolerance { get { return 1e-5; } } @@ -165,6 +167,7 @@ public void PascalToPressureUnits() AssertEx.EqualTolerance(MeganewtonsPerSquareMeterInOnePascal, pascal.MeganewtonsPerSquareMeter, MeganewtonsPerSquareMeterTolerance); AssertEx.EqualTolerance(MegapascalsInOnePascal, pascal.Megapascals, MegapascalsTolerance); AssertEx.EqualTolerance(MetersOfHeadInOnePascal, pascal.MetersOfHead, MetersOfHeadTolerance); + AssertEx.EqualTolerance(MicrobarsInOnePascal, pascal.Microbars, MicrobarsTolerance); AssertEx.EqualTolerance(MicropascalsInOnePascal, pascal.Micropascals, MicropascalsTolerance); AssertEx.EqualTolerance(MillibarsInOnePascal, pascal.Millibars, MillibarsTolerance); AssertEx.EqualTolerance(MillimetersOfMercuryInOnePascal, pascal.MillimetersOfMercury, MillimetersOfMercuryTolerance); @@ -210,6 +213,7 @@ public void FromValueAndUnit() AssertEx.EqualTolerance(1, Pressure.From(1, PressureUnit.MeganewtonPerSquareMeter).MeganewtonsPerSquareMeter, MeganewtonsPerSquareMeterTolerance); AssertEx.EqualTolerance(1, Pressure.From(1, PressureUnit.Megapascal).Megapascals, MegapascalsTolerance); AssertEx.EqualTolerance(1, Pressure.From(1, PressureUnit.MeterOfHead).MetersOfHead, MetersOfHeadTolerance); + AssertEx.EqualTolerance(1, Pressure.From(1, PressureUnit.Microbar).Microbars, MicrobarsTolerance); AssertEx.EqualTolerance(1, Pressure.From(1, PressureUnit.Micropascal).Micropascals, MicropascalsTolerance); AssertEx.EqualTolerance(1, Pressure.From(1, PressureUnit.Millibar).Millibars, MillibarsTolerance); AssertEx.EqualTolerance(1, Pressure.From(1, PressureUnit.MillimeterOfMercury).MillimetersOfMercury, MillimetersOfMercuryTolerance); @@ -256,6 +260,7 @@ public void As() AssertEx.EqualTolerance(MeganewtonsPerSquareMeterInOnePascal, pascal.As(PressureUnit.MeganewtonPerSquareMeter), MeganewtonsPerSquareMeterTolerance); AssertEx.EqualTolerance(MegapascalsInOnePascal, pascal.As(PressureUnit.Megapascal), MegapascalsTolerance); AssertEx.EqualTolerance(MetersOfHeadInOnePascal, pascal.As(PressureUnit.MeterOfHead), MetersOfHeadTolerance); + AssertEx.EqualTolerance(MicrobarsInOnePascal, pascal.As(PressureUnit.Microbar), MicrobarsTolerance); AssertEx.EqualTolerance(MicropascalsInOnePascal, pascal.As(PressureUnit.Micropascal), MicropascalsTolerance); AssertEx.EqualTolerance(MillibarsInOnePascal, pascal.As(PressureUnit.Millibar), MillibarsTolerance); AssertEx.EqualTolerance(MillimetersOfMercuryInOnePascal, pascal.As(PressureUnit.MillimeterOfMercury), MillimetersOfMercuryTolerance); @@ -375,6 +380,10 @@ public void ToUnit() AssertEx.EqualTolerance(MetersOfHeadInOnePascal, (double)meterofheadQuantity.Value, MetersOfHeadTolerance); Assert.Equal(PressureUnit.MeterOfHead, meterofheadQuantity.Unit); + var microbarQuantity = pascal.ToUnit(PressureUnit.Microbar); + AssertEx.EqualTolerance(MicrobarsInOnePascal, (double)microbarQuantity.Value, MicrobarsTolerance); + Assert.Equal(PressureUnit.Microbar, microbarQuantity.Unit); + var micropascalQuantity = pascal.ToUnit(PressureUnit.Micropascal); AssertEx.EqualTolerance(MicropascalsInOnePascal, (double)micropascalQuantity.Value, MicropascalsTolerance); Assert.Equal(PressureUnit.Micropascal, micropascalQuantity.Unit); @@ -468,6 +477,7 @@ public void ConversionRoundTrip() AssertEx.EqualTolerance(1, Pressure.FromMeganewtonsPerSquareMeter(pascal.MeganewtonsPerSquareMeter).Pascals, MeganewtonsPerSquareMeterTolerance); AssertEx.EqualTolerance(1, Pressure.FromMegapascals(pascal.Megapascals).Pascals, MegapascalsTolerance); AssertEx.EqualTolerance(1, Pressure.FromMetersOfHead(pascal.MetersOfHead).Pascals, MetersOfHeadTolerance); + AssertEx.EqualTolerance(1, Pressure.FromMicrobars(pascal.Microbars).Pascals, MicrobarsTolerance); AssertEx.EqualTolerance(1, Pressure.FromMicropascals(pascal.Micropascals).Pascals, MicropascalsTolerance); AssertEx.EqualTolerance(1, Pressure.FromMillibars(pascal.Millibars).Pascals, MillibarsTolerance); AssertEx.EqualTolerance(1, Pressure.FromMillimetersOfMercury(pascal.MillimetersOfMercury).Pascals, MillimetersOfMercuryTolerance); diff --git a/UnitsNet/GeneratedCode/Extensions/Number/NumberToPressureExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/Number/NumberToPressureExtensions.g.cs index 7d4373bbca..b22edc134f 100644 --- a/UnitsNet/GeneratedCode/Extensions/Number/NumberToPressureExtensions.g.cs +++ b/UnitsNet/GeneratedCode/Extensions/Number/NumberToPressureExtensions.g.cs @@ -308,6 +308,17 @@ public static class NumberToPressureExtensions #endregion + #region Microbar + + /// + public static Pressure Microbars(this T value) => Pressure.FromMicrobars(Convert.ToDouble(value)); + + /// + [Obsolete("Nullable type support has been deprecated and will be removed in a future release.")] + public static Pressure? Microbars(this T? value) where T : struct => Pressure.FromMicrobars(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + #region Micropascal /// diff --git a/UnitsNet/GeneratedCode/Quantities/Pressure.NetFramework.g.cs b/UnitsNet/GeneratedCode/Quantities/Pressure.NetFramework.g.cs index dde6e30647..dcb8c25be0 100644 --- a/UnitsNet/GeneratedCode/Quantities/Pressure.NetFramework.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Pressure.NetFramework.g.cs @@ -278,6 +278,15 @@ public partial struct Pressure : IComparable, IComparable return metersofhead.HasValue ? FromMetersOfHead(metersofhead.Value) : default(Pressure?); } + /// + /// Get nullable Pressure from nullable Microbars. + /// + [Obsolete("Nullable type support is obsolete and will be removed in a future release.")] + public static Pressure? FromMicrobars(QuantityValue? microbars) + { + return microbars.HasValue ? FromMicrobars(microbars.Value) : default(Pressure?); + } + /// /// Get nullable Pressure from nullable Micropascals. /// diff --git a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs index 730440c2d7..22457e814d 100644 --- a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs +++ b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs @@ -3320,6 +3320,12 @@ private static readonly ReadOnlyCollection DefaultLocalization { new AbbreviationsForCulture("en-US", "m of head"), }), + new CulturesForEnumValue((int) PressureUnit.Microbar, + new[] + { + new AbbreviationsForCulture("en-US", "µbar"), + new AbbreviationsForCulture("ru-RU", "µбар"), + }), new CulturesForEnumValue((int) PressureUnit.Micropascal, new[] { diff --git a/UnitsNet/GeneratedCode/Units/PressureUnit.g.cs b/UnitsNet/GeneratedCode/Units/PressureUnit.g.cs index 3c57062171..1336e8e6bf 100644 --- a/UnitsNet/GeneratedCode/Units/PressureUnit.g.cs +++ b/UnitsNet/GeneratedCode/Units/PressureUnit.g.cs @@ -69,6 +69,7 @@ public enum PressureUnit MeganewtonPerSquareMeter, Megapascal, MeterOfHead, + Microbar, Micropascal, Millibar, MillimeterOfMercury,