diff --git a/UnitsNet.Tests/CustomCode/PressureTests.cs b/UnitsNet.Tests/CustomCode/PressureTests.cs index bd43734b56..6ce07cb3c2 100644 --- a/UnitsNet.Tests/CustomCode/PressureTests.cs +++ b/UnitsNet.Tests/CustomCode/PressureTests.cs @@ -142,5 +142,50 @@ protected override double TorrsInOnePascal { get { return 7.5006*1E-3; } } + + protected override double CentibarsInOnePascal + { + get { return 1e-3; } + } + + protected override double DecapascalsInOnePascal + { + get { return 1e-1; } + } + + protected override double DecibarsInOnePascal + { + get { return 1e-4; } + } + + protected override double GigapascalsInOnePascal + { + get { return 1e-9; } + } + + protected override double HectopascalsInOnePascal + { + get { return 1e-2; } + } + + protected override double KilobarsInOnePascal + { + get { return 1e-8; } + } + + protected override double MegabarsInOnePascal + { + get { return 1e-11; } + } + + protected override double MicropascalsInOnePascal + { + get { return 1e-3; } + } + + protected override double MillibarsInOnePascal + { + get { return 1e-2; } + } } } \ No newline at end of file diff --git a/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs index 5d6a085b03..eae1a76114 100644 --- a/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs @@ -38,6 +38,12 @@ public abstract partial class PressureTestsBase { protected abstract double AtmospheresInOnePascal { get; } protected abstract double BarsInOnePascal { get; } + protected abstract double CentibarsInOnePascal { get; } + protected abstract double DecapascalsInOnePascal { get; } + protected abstract double DecibarsInOnePascal { get; } + protected abstract double GigapascalsInOnePascal { get; } + protected abstract double HectopascalsInOnePascal { get; } + protected abstract double KilobarsInOnePascal { get; } protected abstract double KilogramsForcePerSquareCentimeterInOnePascal { get; } protected abstract double KilogramsForcePerSquareMeterInOnePascal { get; } protected abstract double KilogramsForcePerSquareMillimeterInOnePascal { get; } @@ -47,7 +53,10 @@ public abstract partial class PressureTestsBase protected abstract double KilopascalsInOnePascal { get; } protected abstract double KilopoundsForcePerSquareFootInOnePascal { get; } protected abstract double KilopoundsForcePerSquareInchInOnePascal { get; } + protected abstract double MegabarsInOnePascal { get; } protected abstract double MegapascalsInOnePascal { get; } + protected abstract double MicropascalsInOnePascal { get; } + protected abstract double MillibarsInOnePascal { get; } protected abstract double NewtonsPerSquareCentimeterInOnePascal { get; } protected abstract double NewtonsPerSquareMeterInOnePascal { get; } protected abstract double NewtonsPerSquareMillimeterInOnePascal { get; } @@ -64,6 +73,12 @@ public abstract partial class PressureTestsBase // ReSharper disable VirtualMemberNeverOverriden.Global protected virtual double AtmospheresTolerance { get { return 1e-5; } } protected virtual double BarsTolerance { get { return 1e-5; } } + 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 GigapascalsTolerance { get { return 1e-5; } } + protected virtual double HectopascalsTolerance { get { return 1e-5; } } + protected virtual double KilobarsTolerance { get { return 1e-5; } } protected virtual double KilogramsForcePerSquareCentimeterTolerance { get { return 1e-5; } } protected virtual double KilogramsForcePerSquareMeterTolerance { get { return 1e-5; } } protected virtual double KilogramsForcePerSquareMillimeterTolerance { get { return 1e-5; } } @@ -73,7 +88,10 @@ public abstract partial class PressureTestsBase protected virtual double KilopascalsTolerance { get { return 1e-5; } } protected virtual double KilopoundsForcePerSquareFootTolerance { get { return 1e-5; } } protected virtual double KilopoundsForcePerSquareInchTolerance { get { return 1e-5; } } + protected virtual double MegabarsTolerance { get { return 1e-5; } } protected virtual double MegapascalsTolerance { get { return 1e-5; } } + protected virtual double MicropascalsTolerance { get { return 1e-5; } } + protected virtual double MillibarsTolerance { get { return 1e-5; } } protected virtual double NewtonsPerSquareCentimeterTolerance { get { return 1e-5; } } protected virtual double NewtonsPerSquareMeterTolerance { get { return 1e-5; } } protected virtual double NewtonsPerSquareMillimeterTolerance { get { return 1e-5; } } @@ -94,6 +112,12 @@ public void PascalToPressureUnits() Pressure pascal = Pressure.FromPascals(1); Assert.AreEqual(AtmospheresInOnePascal, pascal.Atmospheres, AtmospheresTolerance); Assert.AreEqual(BarsInOnePascal, pascal.Bars, BarsTolerance); + Assert.AreEqual(CentibarsInOnePascal, pascal.Centibars, CentibarsTolerance); + Assert.AreEqual(DecapascalsInOnePascal, pascal.Decapascals, DecapascalsTolerance); + Assert.AreEqual(DecibarsInOnePascal, pascal.Decibars, DecibarsTolerance); + Assert.AreEqual(GigapascalsInOnePascal, pascal.Gigapascals, GigapascalsTolerance); + Assert.AreEqual(HectopascalsInOnePascal, pascal.Hectopascals, HectopascalsTolerance); + Assert.AreEqual(KilobarsInOnePascal, pascal.Kilobars, KilobarsTolerance); Assert.AreEqual(KilogramsForcePerSquareCentimeterInOnePascal, pascal.KilogramsForcePerSquareCentimeter, KilogramsForcePerSquareCentimeterTolerance); Assert.AreEqual(KilogramsForcePerSquareMeterInOnePascal, pascal.KilogramsForcePerSquareMeter, KilogramsForcePerSquareMeterTolerance); Assert.AreEqual(KilogramsForcePerSquareMillimeterInOnePascal, pascal.KilogramsForcePerSquareMillimeter, KilogramsForcePerSquareMillimeterTolerance); @@ -103,7 +127,10 @@ public void PascalToPressureUnits() Assert.AreEqual(KilopascalsInOnePascal, pascal.Kilopascals, KilopascalsTolerance); Assert.AreEqual(KilopoundsForcePerSquareFootInOnePascal, pascal.KilopoundsForcePerSquareFoot, KilopoundsForcePerSquareFootTolerance); Assert.AreEqual(KilopoundsForcePerSquareInchInOnePascal, pascal.KilopoundsForcePerSquareInch, KilopoundsForcePerSquareInchTolerance); + Assert.AreEqual(MegabarsInOnePascal, pascal.Megabars, MegabarsTolerance); Assert.AreEqual(MegapascalsInOnePascal, pascal.Megapascals, MegapascalsTolerance); + Assert.AreEqual(MicropascalsInOnePascal, pascal.Micropascals, MicropascalsTolerance); + Assert.AreEqual(MillibarsInOnePascal, pascal.Millibars, MillibarsTolerance); Assert.AreEqual(NewtonsPerSquareCentimeterInOnePascal, pascal.NewtonsPerSquareCentimeter, NewtonsPerSquareCentimeterTolerance); Assert.AreEqual(NewtonsPerSquareMeterInOnePascal, pascal.NewtonsPerSquareMeter, NewtonsPerSquareMeterTolerance); Assert.AreEqual(NewtonsPerSquareMillimeterInOnePascal, pascal.NewtonsPerSquareMillimeter, NewtonsPerSquareMillimeterTolerance); @@ -123,6 +150,12 @@ public void FromValueAndUnit() { Assert.AreEqual(1, Pressure.From(1, PressureUnit.Atmosphere).Atmospheres, AtmospheresTolerance); Assert.AreEqual(1, Pressure.From(1, PressureUnit.Bar).Bars, BarsTolerance); + Assert.AreEqual(1, Pressure.From(1, PressureUnit.Centibar).Centibars, CentibarsTolerance); + Assert.AreEqual(1, Pressure.From(1, PressureUnit.Decapascal).Decapascals, DecapascalsTolerance); + Assert.AreEqual(1, Pressure.From(1, PressureUnit.Decibar).Decibars, DecibarsTolerance); + Assert.AreEqual(1, Pressure.From(1, PressureUnit.Gigapascal).Gigapascals, GigapascalsTolerance); + Assert.AreEqual(1, Pressure.From(1, PressureUnit.Hectopascal).Hectopascals, HectopascalsTolerance); + Assert.AreEqual(1, Pressure.From(1, PressureUnit.Kilobar).Kilobars, KilobarsTolerance); Assert.AreEqual(1, Pressure.From(1, PressureUnit.KilogramForcePerSquareCentimeter).KilogramsForcePerSquareCentimeter, KilogramsForcePerSquareCentimeterTolerance); Assert.AreEqual(1, Pressure.From(1, PressureUnit.KilogramForcePerSquareMeter).KilogramsForcePerSquareMeter, KilogramsForcePerSquareMeterTolerance); Assert.AreEqual(1, Pressure.From(1, PressureUnit.KilogramForcePerSquareMillimeter).KilogramsForcePerSquareMillimeter, KilogramsForcePerSquareMillimeterTolerance); @@ -132,7 +165,10 @@ public void FromValueAndUnit() Assert.AreEqual(1, Pressure.From(1, PressureUnit.Kilopascal).Kilopascals, KilopascalsTolerance); Assert.AreEqual(1, Pressure.From(1, PressureUnit.KilopoundForcePerSquareFoot).KilopoundsForcePerSquareFoot, KilopoundsForcePerSquareFootTolerance); Assert.AreEqual(1, Pressure.From(1, PressureUnit.KilopoundForcePerSquareInch).KilopoundsForcePerSquareInch, KilopoundsForcePerSquareInchTolerance); + Assert.AreEqual(1, Pressure.From(1, PressureUnit.Megabar).Megabars, MegabarsTolerance); Assert.AreEqual(1, Pressure.From(1, PressureUnit.Megapascal).Megapascals, MegapascalsTolerance); + Assert.AreEqual(1, Pressure.From(1, PressureUnit.Micropascal).Micropascals, MicropascalsTolerance); + Assert.AreEqual(1, Pressure.From(1, PressureUnit.Millibar).Millibars, MillibarsTolerance); Assert.AreEqual(1, Pressure.From(1, PressureUnit.NewtonPerSquareCentimeter).NewtonsPerSquareCentimeter, NewtonsPerSquareCentimeterTolerance); Assert.AreEqual(1, Pressure.From(1, PressureUnit.NewtonPerSquareMeter).NewtonsPerSquareMeter, NewtonsPerSquareMeterTolerance); Assert.AreEqual(1, Pressure.From(1, PressureUnit.NewtonPerSquareMillimeter).NewtonsPerSquareMillimeter, NewtonsPerSquareMillimeterTolerance); @@ -153,6 +189,12 @@ public void As() var pascal = Pressure.FromPascals(1); Assert.AreEqual(AtmospheresInOnePascal, pascal.As(PressureUnit.Atmosphere), AtmospheresTolerance); Assert.AreEqual(BarsInOnePascal, pascal.As(PressureUnit.Bar), BarsTolerance); + Assert.AreEqual(CentibarsInOnePascal, pascal.As(PressureUnit.Centibar), CentibarsTolerance); + Assert.AreEqual(DecapascalsInOnePascal, pascal.As(PressureUnit.Decapascal), DecapascalsTolerance); + Assert.AreEqual(DecibarsInOnePascal, pascal.As(PressureUnit.Decibar), DecibarsTolerance); + Assert.AreEqual(GigapascalsInOnePascal, pascal.As(PressureUnit.Gigapascal), GigapascalsTolerance); + Assert.AreEqual(HectopascalsInOnePascal, pascal.As(PressureUnit.Hectopascal), HectopascalsTolerance); + Assert.AreEqual(KilobarsInOnePascal, pascal.As(PressureUnit.Kilobar), KilobarsTolerance); Assert.AreEqual(KilogramsForcePerSquareCentimeterInOnePascal, pascal.As(PressureUnit.KilogramForcePerSquareCentimeter), KilogramsForcePerSquareCentimeterTolerance); Assert.AreEqual(KilogramsForcePerSquareMeterInOnePascal, pascal.As(PressureUnit.KilogramForcePerSquareMeter), KilogramsForcePerSquareMeterTolerance); Assert.AreEqual(KilogramsForcePerSquareMillimeterInOnePascal, pascal.As(PressureUnit.KilogramForcePerSquareMillimeter), KilogramsForcePerSquareMillimeterTolerance); @@ -162,7 +204,10 @@ public void As() Assert.AreEqual(KilopascalsInOnePascal, pascal.As(PressureUnit.Kilopascal), KilopascalsTolerance); Assert.AreEqual(KilopoundsForcePerSquareFootInOnePascal, pascal.As(PressureUnit.KilopoundForcePerSquareFoot), KilopoundsForcePerSquareFootTolerance); Assert.AreEqual(KilopoundsForcePerSquareInchInOnePascal, pascal.As(PressureUnit.KilopoundForcePerSquareInch), KilopoundsForcePerSquareInchTolerance); + Assert.AreEqual(MegabarsInOnePascal, pascal.As(PressureUnit.Megabar), MegabarsTolerance); Assert.AreEqual(MegapascalsInOnePascal, pascal.As(PressureUnit.Megapascal), MegapascalsTolerance); + Assert.AreEqual(MicropascalsInOnePascal, pascal.As(PressureUnit.Micropascal), MicropascalsTolerance); + Assert.AreEqual(MillibarsInOnePascal, pascal.As(PressureUnit.Millibar), MillibarsTolerance); Assert.AreEqual(NewtonsPerSquareCentimeterInOnePascal, pascal.As(PressureUnit.NewtonPerSquareCentimeter), NewtonsPerSquareCentimeterTolerance); Assert.AreEqual(NewtonsPerSquareMeterInOnePascal, pascal.As(PressureUnit.NewtonPerSquareMeter), NewtonsPerSquareMeterTolerance); Assert.AreEqual(NewtonsPerSquareMillimeterInOnePascal, pascal.As(PressureUnit.NewtonPerSquareMillimeter), NewtonsPerSquareMillimeterTolerance); @@ -183,6 +228,12 @@ public void ConversionRoundTrip() Pressure pascal = Pressure.FromPascals(1); Assert.AreEqual(1, Pressure.FromAtmospheres(pascal.Atmospheres).Pascals, AtmospheresTolerance); Assert.AreEqual(1, Pressure.FromBars(pascal.Bars).Pascals, BarsTolerance); + Assert.AreEqual(1, Pressure.FromCentibars(pascal.Centibars).Pascals, CentibarsTolerance); + Assert.AreEqual(1, Pressure.FromDecapascals(pascal.Decapascals).Pascals, DecapascalsTolerance); + Assert.AreEqual(1, Pressure.FromDecibars(pascal.Decibars).Pascals, DecibarsTolerance); + Assert.AreEqual(1, Pressure.FromGigapascals(pascal.Gigapascals).Pascals, GigapascalsTolerance); + Assert.AreEqual(1, Pressure.FromHectopascals(pascal.Hectopascals).Pascals, HectopascalsTolerance); + Assert.AreEqual(1, Pressure.FromKilobars(pascal.Kilobars).Pascals, KilobarsTolerance); Assert.AreEqual(1, Pressure.FromKilogramsForcePerSquareCentimeter(pascal.KilogramsForcePerSquareCentimeter).Pascals, KilogramsForcePerSquareCentimeterTolerance); Assert.AreEqual(1, Pressure.FromKilogramsForcePerSquareMeter(pascal.KilogramsForcePerSquareMeter).Pascals, KilogramsForcePerSquareMeterTolerance); Assert.AreEqual(1, Pressure.FromKilogramsForcePerSquareMillimeter(pascal.KilogramsForcePerSquareMillimeter).Pascals, KilogramsForcePerSquareMillimeterTolerance); @@ -192,7 +243,10 @@ public void ConversionRoundTrip() Assert.AreEqual(1, Pressure.FromKilopascals(pascal.Kilopascals).Pascals, KilopascalsTolerance); Assert.AreEqual(1, Pressure.FromKilopoundsForcePerSquareFoot(pascal.KilopoundsForcePerSquareFoot).Pascals, KilopoundsForcePerSquareFootTolerance); Assert.AreEqual(1, Pressure.FromKilopoundsForcePerSquareInch(pascal.KilopoundsForcePerSquareInch).Pascals, KilopoundsForcePerSquareInchTolerance); + Assert.AreEqual(1, Pressure.FromMegabars(pascal.Megabars).Pascals, MegabarsTolerance); Assert.AreEqual(1, Pressure.FromMegapascals(pascal.Megapascals).Pascals, MegapascalsTolerance); + Assert.AreEqual(1, Pressure.FromMicropascals(pascal.Micropascals).Pascals, MicropascalsTolerance); + Assert.AreEqual(1, Pressure.FromMillibars(pascal.Millibars).Pascals, MillibarsTolerance); Assert.AreEqual(1, Pressure.FromNewtonsPerSquareCentimeter(pascal.NewtonsPerSquareCentimeter).Pascals, NewtonsPerSquareCentimeterTolerance); Assert.AreEqual(1, Pressure.FromNewtonsPerSquareMeter(pascal.NewtonsPerSquareMeter).Pascals, NewtonsPerSquareMeterTolerance); Assert.AreEqual(1, Pressure.FromNewtonsPerSquareMillimeter(pascal.NewtonsPerSquareMillimeter).Pascals, NewtonsPerSquareMillimeterTolerance); diff --git a/UnitsNet/GeneratedCode/Enums/PressureUnit.g.cs b/UnitsNet/GeneratedCode/Enums/PressureUnit.g.cs index fc4a543301..22101d45f5 100644 --- a/UnitsNet/GeneratedCode/Enums/PressureUnit.g.cs +++ b/UnitsNet/GeneratedCode/Enums/PressureUnit.g.cs @@ -27,6 +27,12 @@ public enum PressureUnit Undefined = 0, Atmosphere, Bar, + Centibar, + Decapascal, + Decibar, + Gigapascal, + Hectopascal, + Kilobar, KilogramForcePerSquareCentimeter, KilogramForcePerSquareMeter, KilogramForcePerSquareMillimeter, @@ -36,7 +42,10 @@ public enum PressureUnit Kilopascal, KilopoundForcePerSquareFoot, KilopoundForcePerSquareInch, + Megabar, Megapascal, + Micropascal, + Millibar, NewtonPerSquareCentimeter, NewtonPerSquareMeter, NewtonPerSquareMillimeter, diff --git a/UnitsNet/GeneratedCode/UnitClasses/Pressure.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Pressure.g.cs index 73c9ee5345..2c0030051f 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Pressure.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Pressure.g.cs @@ -64,6 +64,54 @@ public double Bars get { return _pascals/1e5; } } + /// + /// Get Pressure in Centibars. + /// + public double Centibars + { + get { return (_pascals/1e5) / 1e-2d; } + } + + /// + /// Get Pressure in Decapascals. + /// + public double Decapascals + { + get { return (_pascals) / 1e1d; } + } + + /// + /// Get Pressure in Decibars. + /// + public double Decibars + { + get { return (_pascals/1e5) / 1e-1d; } + } + + /// + /// Get Pressure in Gigapascals. + /// + public double Gigapascals + { + get { return (_pascals) / 1e9d; } + } + + /// + /// Get Pressure in Hectopascals. + /// + public double Hectopascals + { + get { return (_pascals) / 1e2d; } + } + + /// + /// Get Pressure in Kilobars. + /// + public double Kilobars + { + get { return (_pascals/1e5) / 1e3d; } + } + /// /// Get Pressure in KilogramsForcePerSquareCentimeter. /// @@ -136,6 +184,14 @@ public double KilopoundsForcePerSquareInch get { return (_pascals*0.000145037725185479) / 1e3d; } } + /// + /// Get Pressure in Megabars. + /// + public double Megabars + { + get { return (_pascals/1e5) / 1e6d; } + } + /// /// Get Pressure in Megapascals. /// @@ -144,6 +200,22 @@ public double Megapascals get { return (_pascals) / 1e6d; } } + /// + /// Get Pressure in Micropascals. + /// + public double Micropascals + { + get { return (_pascals) / 1e-6d; } + } + + /// + /// Get Pressure in Millibars. + /// + public double Millibars + { + get { return (_pascals/1e5) / 1e-3d; } + } + /// /// Get Pressure in NewtonsPerSquareCentimeter. /// @@ -265,6 +337,54 @@ public static Pressure FromBars(double bars) return new Pressure(bars*1e5); } + /// + /// Get Pressure from Centibars. + /// + public static Pressure FromCentibars(double centibars) + { + return new Pressure((centibars*1e5) * 1e-2d); + } + + /// + /// Get Pressure from Decapascals. + /// + public static Pressure FromDecapascals(double decapascals) + { + return new Pressure((decapascals) * 1e1d); + } + + /// + /// Get Pressure from Decibars. + /// + public static Pressure FromDecibars(double decibars) + { + return new Pressure((decibars*1e5) * 1e-1d); + } + + /// + /// Get Pressure from Gigapascals. + /// + public static Pressure FromGigapascals(double gigapascals) + { + return new Pressure((gigapascals) * 1e9d); + } + + /// + /// Get Pressure from Hectopascals. + /// + public static Pressure FromHectopascals(double hectopascals) + { + return new Pressure((hectopascals) * 1e2d); + } + + /// + /// Get Pressure from Kilobars. + /// + public static Pressure FromKilobars(double kilobars) + { + return new Pressure((kilobars*1e5) * 1e3d); + } + /// /// Get Pressure from KilogramsForcePerSquareCentimeter. /// @@ -337,6 +457,14 @@ public static Pressure FromKilopoundsForcePerSquareInch(double kilopoundsforcepe return new Pressure((kilopoundsforcepersquareinch*6894.75788951576) * 1e3d); } + /// + /// Get Pressure from Megabars. + /// + public static Pressure FromMegabars(double megabars) + { + return new Pressure((megabars*1e5) * 1e6d); + } + /// /// Get Pressure from Megapascals. /// @@ -345,6 +473,22 @@ public static Pressure FromMegapascals(double megapascals) return new Pressure((megapascals) * 1e6d); } + /// + /// Get Pressure from Micropascals. + /// + public static Pressure FromMicropascals(double micropascals) + { + return new Pressure((micropascals) * 1e-6d); + } + + /// + /// Get Pressure from Millibars. + /// + public static Pressure FromMillibars(double millibars) + { + return new Pressure((millibars*1e5) * 1e-3d); + } + /// /// Get Pressure from NewtonsPerSquareCentimeter. /// @@ -456,6 +600,18 @@ public static Pressure From(double value, PressureUnit fromUnit) return FromAtmospheres(value); case PressureUnit.Bar: return FromBars(value); + case PressureUnit.Centibar: + return FromCentibars(value); + case PressureUnit.Decapascal: + return FromDecapascals(value); + case PressureUnit.Decibar: + return FromDecibars(value); + case PressureUnit.Gigapascal: + return FromGigapascals(value); + case PressureUnit.Hectopascal: + return FromHectopascals(value); + case PressureUnit.Kilobar: + return FromKilobars(value); case PressureUnit.KilogramForcePerSquareCentimeter: return FromKilogramsForcePerSquareCentimeter(value); case PressureUnit.KilogramForcePerSquareMeter: @@ -474,8 +630,14 @@ public static Pressure From(double value, PressureUnit fromUnit) return FromKilopoundsForcePerSquareFoot(value); case PressureUnit.KilopoundForcePerSquareInch: return FromKilopoundsForcePerSquareInch(value); + case PressureUnit.Megabar: + return FromMegabars(value); case PressureUnit.Megapascal: return FromMegapascals(value); + case PressureUnit.Micropascal: + return FromMicropascals(value); + case PressureUnit.Millibar: + return FromMillibars(value); case PressureUnit.NewtonPerSquareCentimeter: return FromNewtonsPerSquareCentimeter(value); case PressureUnit.NewtonPerSquareMeter: @@ -637,6 +799,18 @@ public double As(PressureUnit unit) return Atmospheres; case PressureUnit.Bar: return Bars; + case PressureUnit.Centibar: + return Centibars; + case PressureUnit.Decapascal: + return Decapascals; + case PressureUnit.Decibar: + return Decibars; + case PressureUnit.Gigapascal: + return Gigapascals; + case PressureUnit.Hectopascal: + return Hectopascals; + case PressureUnit.Kilobar: + return Kilobars; case PressureUnit.KilogramForcePerSquareCentimeter: return KilogramsForcePerSquareCentimeter; case PressureUnit.KilogramForcePerSquareMeter: @@ -655,8 +829,14 @@ public double As(PressureUnit unit) return KilopoundsForcePerSquareFoot; case PressureUnit.KilopoundForcePerSquareInch: return KilopoundsForcePerSquareInch; + case PressureUnit.Megabar: + return Megabars; case PressureUnit.Megapascal: return Megapascals; + case PressureUnit.Micropascal: + return Micropascals; + case PressureUnit.Millibar: + return Millibars; case PressureUnit.NewtonPerSquareCentimeter: return NewtonsPerSquareCentimeter; case PressureUnit.NewtonPerSquareMeter: diff --git a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs index 12b995b38c..e833e086d8 100644 --- a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs +++ b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs @@ -972,6 +972,42 @@ private static readonly ReadOnlyCollection DefaultLocalization new AbbreviationsForCulture("en-US", "bar"), new AbbreviationsForCulture("ru-RU", "бар"), }), + new CulturesForEnumValue((int) PressureUnit.Centibar, + new[] + { + new AbbreviationsForCulture("en-US", "cbar"), + new AbbreviationsForCulture("ru-RU", "cбар"), + }), + new CulturesForEnumValue((int) PressureUnit.Decapascal, + new[] + { + new AbbreviationsForCulture("en-US", "daPa"), + new AbbreviationsForCulture("ru-RU", "МПа"), + }), + new CulturesForEnumValue((int) PressureUnit.Decibar, + new[] + { + new AbbreviationsForCulture("en-US", "dbar"), + new AbbreviationsForCulture("ru-RU", "dбар"), + }), + new CulturesForEnumValue((int) PressureUnit.Gigapascal, + new[] + { + new AbbreviationsForCulture("en-US", "GPa"), + new AbbreviationsForCulture("ru-RU", ""), + }), + new CulturesForEnumValue((int) PressureUnit.Hectopascal, + new[] + { + new AbbreviationsForCulture("en-US", "hPa"), + new AbbreviationsForCulture("ru-RU", ""), + }), + new CulturesForEnumValue((int) PressureUnit.Kilobar, + new[] + { + new AbbreviationsForCulture("en-US", "kbar"), + new AbbreviationsForCulture("ru-RU", "kбар"), + }), new CulturesForEnumValue((int) PressureUnit.KilogramForcePerSquareCentimeter, new[] { @@ -1012,7 +1048,7 @@ private static readonly ReadOnlyCollection DefaultLocalization new[] { new AbbreviationsForCulture("en-US", "kPa"), - new AbbreviationsForCulture("ru-RU", "кПа"), + new AbbreviationsForCulture("ru-RU", ""), }), new CulturesForEnumValue((int) PressureUnit.KilopoundForcePerSquareFoot, new[] @@ -1024,11 +1060,29 @@ private static readonly ReadOnlyCollection DefaultLocalization { new AbbreviationsForCulture("en-US", "kipf/in²"), }), + new CulturesForEnumValue((int) PressureUnit.Megabar, + new[] + { + new AbbreviationsForCulture("en-US", "Mbar"), + new AbbreviationsForCulture("ru-RU", "Mбар"), + }), new CulturesForEnumValue((int) PressureUnit.Megapascal, new[] { new AbbreviationsForCulture("en-US", "MPa"), - new AbbreviationsForCulture("ru-RU", "МПа"), + new AbbreviationsForCulture("ru-RU", ""), + }), + new CulturesForEnumValue((int) PressureUnit.Micropascal, + new[] + { + new AbbreviationsForCulture("en-US", "μPa"), + new AbbreviationsForCulture("ru-RU", "кПа"), + }), + new CulturesForEnumValue((int) PressureUnit.Millibar, + new[] + { + new AbbreviationsForCulture("en-US", "mbar"), + new AbbreviationsForCulture("ru-RU", "mбар"), }), new CulturesForEnumValue((int) PressureUnit.NewtonPerSquareCentimeter, new[] diff --git a/UnitsNet/Scripts/UnitDefinitions/Pressure.json b/UnitsNet/Scripts/UnitDefinitions/Pressure.json index 4fbaa7ba28..ae04ea4633 100644 --- a/UnitsNet/Scripts/UnitDefinitions/Pressure.json +++ b/UnitsNet/Scripts/UnitDefinitions/Pressure.json @@ -8,7 +8,7 @@ "PluralName": "Pascals", "FromUnitToBaseFunc": "x", "FromBaseToUnitFunc": "x", - "Prefixes": ["Kilo","Mega"], + "Prefixes": ["Micro","Deca","Hecto","Kilo","Mega","Giga"], "Localization": [ { "Culture": "en-US", @@ -42,6 +42,7 @@ "PluralName": "Bars", "FromUnitToBaseFunc": "x*1e5", "FromBaseToUnitFunc": "x/1e5", + "Prefixes": ["Milli","Centi","Deci","Kilo","Mega"], "Localization": [ { "Culture": "en-US",