From 54c85f446910ec7b515efbfae625add47ee31e23 Mon Sep 17 00:00:00 2001 From: Dirk Schuermans Date: Wed, 5 Feb 2020 16:47:02 +0100 Subject: [PATCH 1/2] Added KilopoundForceFeetPerDegrees variant to RotationalStiffness, along with PoundForceFeetPerDegrees --- .../UnitDefinitions/RotationalStiffness.json | 24 +++++++++++ .../CustomCode/RotationalStiffnessTests.cs | 2 + .../GeneratedCode/IQuantityTests.g.cs | 2 +- .../RotationalStiffnessTestsBase.g.cs | 42 ++++++++++++++++--- .../Quantities/RotationalStiffness.g.cs | 34 +++++++++++++++ .../GeneratedCode/UnitAbbreviationsCache.g.cs | 2 + .../Units/RotationalStiffnessUnit.g.cs | 2 + .../Quantities/RotationalStiffness.g.cs | 34 +++++++++++++++ .../GeneratedCode/UnitAbbreviationsCache.g.cs | 2 + UnitsNet/GeneratedCode/UnitConverter.g.cs | 4 ++ .../Units/RotationalStiffnessUnit.g.cs | 2 + 11 files changed, 143 insertions(+), 7 deletions(-) diff --git a/Common/UnitDefinitions/RotationalStiffness.json b/Common/UnitDefinitions/RotationalStiffness.json index 304dcd730a..f77d93c3e2 100644 --- a/Common/UnitDefinitions/RotationalStiffness.json +++ b/Common/UnitDefinitions/RotationalStiffness.json @@ -20,6 +20,30 @@ "Abbreviations": [ "N·m/rad", "Nm/rad" ] } ] + }, + { + "SingularName": "PoundForceFootPerDegrees", + "PluralName": "PoundForceFeetPerDegrees", + "FromUnitToBaseFunc": "x*77.6826", + "FromBaseToUnitFunc": "x/77.6826", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "lbf·ft/deg" ] + } + ] + }, + { + "SingularName": "KilopoundForceFootPerDegrees", + "PluralName": "KilopoundForceFeetPerDegrees", + "FromUnitToBaseFunc": "x*77682.6", + "FromBaseToUnitFunc": "x/77682.6", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "kipf·ft/deg" ] + } + ] } ] } diff --git a/UnitsNet.Tests/CustomCode/RotationalStiffnessTests.cs b/UnitsNet.Tests/CustomCode/RotationalStiffnessTests.cs index 953b1cf664..f73aef7d31 100644 --- a/UnitsNet.Tests/CustomCode/RotationalStiffnessTests.cs +++ b/UnitsNet.Tests/CustomCode/RotationalStiffnessTests.cs @@ -28,6 +28,8 @@ namespace UnitsNet.Tests.CustomCode public class RotationalStiffnessTests : RotationalStiffnessTestsBase { protected override double NewtonMetersPerRadianInOneNewtonMeterPerRadian => 1; + protected override double PoundForceFeetPerDegreesInOneNewtonMeterPerRadian => 0.0128729; + protected override double KilopoundForceFeetPerDegreesInOneNewtonMeterPerRadian => 0.0128729e-3; protected override double MeganewtonMetersPerRadianInOneNewtonMeterPerRadian => 1e-6; protected override double KilonewtonMetersPerRadianInOneNewtonMeterPerRadian => 1e-3; } diff --git a/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs b/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs index 8951cde1ea..ef93f8c218 100644 --- a/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs +++ b/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs @@ -113,7 +113,7 @@ void Assertion(int expectedValue, Enum expectedUnit, IQuantity quantity) Assertion(3, ReactivePowerUnit.VoltampereReactive, Quantity.From(3, ReactivePowerUnit.VoltampereReactive)); Assertion(3, RotationalAccelerationUnit.RevolutionPerSecondSquared, Quantity.From(3, RotationalAccelerationUnit.RevolutionPerSecondSquared)); Assertion(3, RotationalSpeedUnit.RevolutionPerSecond, Quantity.From(3, RotationalSpeedUnit.RevolutionPerSecond)); - Assertion(3, RotationalStiffnessUnit.NewtonMeterPerRadian, Quantity.From(3, RotationalStiffnessUnit.NewtonMeterPerRadian)); + Assertion(3, RotationalStiffnessUnit.PoundForceFootPerDegrees, Quantity.From(3, RotationalStiffnessUnit.PoundForceFootPerDegrees)); Assertion(3, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter, Quantity.From(3, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter)); Assertion(3, SolidAngleUnit.Steradian, Quantity.From(3, SolidAngleUnit.Steradian)); Assertion(3, SpecificEnergyUnit.WattHourPerKilogram, Quantity.From(3, SpecificEnergyUnit.WattHourPerKilogram)); diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessTestsBase.g.cs index acc0376a89..63b254afe7 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessTestsBase.g.cs @@ -37,13 +37,17 @@ namespace UnitsNet.Tests public abstract partial class RotationalStiffnessTestsBase { protected abstract double KilonewtonMetersPerRadianInOneNewtonMeterPerRadian { get; } + protected abstract double KilopoundForceFeetPerDegreesInOneNewtonMeterPerRadian { get; } protected abstract double MeganewtonMetersPerRadianInOneNewtonMeterPerRadian { get; } protected abstract double NewtonMetersPerRadianInOneNewtonMeterPerRadian { get; } + protected abstract double PoundForceFeetPerDegreesInOneNewtonMeterPerRadian { get; } // ReSharper disable VirtualMemberNeverOverriden.Global protected virtual double KilonewtonMetersPerRadianTolerance { get { return 1e-5; } } + protected virtual double KilopoundForceFeetPerDegreesTolerance { get { return 1e-5; } } protected virtual double MeganewtonMetersPerRadianTolerance { get { return 1e-5; } } protected virtual double NewtonMetersPerRadianTolerance { get { return 1e-5; } } + protected virtual double PoundForceFeetPerDegreesTolerance { get { return 1e-5; } } // ReSharper restore VirtualMemberNeverOverriden.Global [Fact] @@ -106,8 +110,10 @@ public void NewtonMeterPerRadianToRotationalStiffnessUnits() { RotationalStiffness newtonmeterperradian = RotationalStiffness.FromNewtonMetersPerRadian(1); AssertEx.EqualTolerance(KilonewtonMetersPerRadianInOneNewtonMeterPerRadian, newtonmeterperradian.KilonewtonMetersPerRadian, KilonewtonMetersPerRadianTolerance); + AssertEx.EqualTolerance(KilopoundForceFeetPerDegreesInOneNewtonMeterPerRadian, newtonmeterperradian.KilopoundForceFeetPerDegrees, KilopoundForceFeetPerDegreesTolerance); AssertEx.EqualTolerance(MeganewtonMetersPerRadianInOneNewtonMeterPerRadian, newtonmeterperradian.MeganewtonMetersPerRadian, MeganewtonMetersPerRadianTolerance); AssertEx.EqualTolerance(NewtonMetersPerRadianInOneNewtonMeterPerRadian, newtonmeterperradian.NewtonMetersPerRadian, NewtonMetersPerRadianTolerance); + AssertEx.EqualTolerance(PoundForceFeetPerDegreesInOneNewtonMeterPerRadian, newtonmeterperradian.PoundForceFeetPerDegrees, PoundForceFeetPerDegreesTolerance); } [Fact] @@ -117,13 +123,21 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() AssertEx.EqualTolerance(1, quantity00.KilonewtonMetersPerRadian, KilonewtonMetersPerRadianTolerance); Assert.Equal(RotationalStiffnessUnit.KilonewtonMeterPerRadian, quantity00.Unit); - var quantity01 = RotationalStiffness.From(1, RotationalStiffnessUnit.MeganewtonMeterPerRadian); - AssertEx.EqualTolerance(1, quantity01.MeganewtonMetersPerRadian, MeganewtonMetersPerRadianTolerance); - Assert.Equal(RotationalStiffnessUnit.MeganewtonMeterPerRadian, quantity01.Unit); + var quantity01 = RotationalStiffness.From(1, RotationalStiffnessUnit.KilopoundForceFootPerDegrees); + AssertEx.EqualTolerance(1, quantity01.KilopoundForceFeetPerDegrees, KilopoundForceFeetPerDegreesTolerance); + Assert.Equal(RotationalStiffnessUnit.KilopoundForceFootPerDegrees, quantity01.Unit); - var quantity02 = RotationalStiffness.From(1, RotationalStiffnessUnit.NewtonMeterPerRadian); - AssertEx.EqualTolerance(1, quantity02.NewtonMetersPerRadian, NewtonMetersPerRadianTolerance); - Assert.Equal(RotationalStiffnessUnit.NewtonMeterPerRadian, quantity02.Unit); + var quantity02 = RotationalStiffness.From(1, RotationalStiffnessUnit.MeganewtonMeterPerRadian); + AssertEx.EqualTolerance(1, quantity02.MeganewtonMetersPerRadian, MeganewtonMetersPerRadianTolerance); + Assert.Equal(RotationalStiffnessUnit.MeganewtonMeterPerRadian, quantity02.Unit); + + var quantity03 = RotationalStiffness.From(1, RotationalStiffnessUnit.NewtonMeterPerRadian); + AssertEx.EqualTolerance(1, quantity03.NewtonMetersPerRadian, NewtonMetersPerRadianTolerance); + Assert.Equal(RotationalStiffnessUnit.NewtonMeterPerRadian, quantity03.Unit); + + var quantity04 = RotationalStiffness.From(1, RotationalStiffnessUnit.PoundForceFootPerDegrees); + AssertEx.EqualTolerance(1, quantity04.PoundForceFeetPerDegrees, PoundForceFeetPerDegreesTolerance); + Assert.Equal(RotationalStiffnessUnit.PoundForceFootPerDegrees, quantity04.Unit); } @@ -145,8 +159,10 @@ public void As() { var newtonmeterperradian = RotationalStiffness.FromNewtonMetersPerRadian(1); AssertEx.EqualTolerance(KilonewtonMetersPerRadianInOneNewtonMeterPerRadian, newtonmeterperradian.As(RotationalStiffnessUnit.KilonewtonMeterPerRadian), KilonewtonMetersPerRadianTolerance); + AssertEx.EqualTolerance(KilopoundForceFeetPerDegreesInOneNewtonMeterPerRadian, newtonmeterperradian.As(RotationalStiffnessUnit.KilopoundForceFootPerDegrees), KilopoundForceFeetPerDegreesTolerance); AssertEx.EqualTolerance(MeganewtonMetersPerRadianInOneNewtonMeterPerRadian, newtonmeterperradian.As(RotationalStiffnessUnit.MeganewtonMeterPerRadian), MeganewtonMetersPerRadianTolerance); AssertEx.EqualTolerance(NewtonMetersPerRadianInOneNewtonMeterPerRadian, newtonmeterperradian.As(RotationalStiffnessUnit.NewtonMeterPerRadian), NewtonMetersPerRadianTolerance); + AssertEx.EqualTolerance(PoundForceFeetPerDegreesInOneNewtonMeterPerRadian, newtonmeterperradian.As(RotationalStiffnessUnit.PoundForceFootPerDegrees), PoundForceFeetPerDegreesTolerance); } [Fact] @@ -158,6 +174,10 @@ public void ToUnit() AssertEx.EqualTolerance(KilonewtonMetersPerRadianInOneNewtonMeterPerRadian, (double)kilonewtonmeterperradianQuantity.Value, KilonewtonMetersPerRadianTolerance); Assert.Equal(RotationalStiffnessUnit.KilonewtonMeterPerRadian, kilonewtonmeterperradianQuantity.Unit); + var kilopoundforcefootperdegreesQuantity = newtonmeterperradian.ToUnit(RotationalStiffnessUnit.KilopoundForceFootPerDegrees); + AssertEx.EqualTolerance(KilopoundForceFeetPerDegreesInOneNewtonMeterPerRadian, (double)kilopoundforcefootperdegreesQuantity.Value, KilopoundForceFeetPerDegreesTolerance); + Assert.Equal(RotationalStiffnessUnit.KilopoundForceFootPerDegrees, kilopoundforcefootperdegreesQuantity.Unit); + var meganewtonmeterperradianQuantity = newtonmeterperradian.ToUnit(RotationalStiffnessUnit.MeganewtonMeterPerRadian); AssertEx.EqualTolerance(MeganewtonMetersPerRadianInOneNewtonMeterPerRadian, (double)meganewtonmeterperradianQuantity.Value, MeganewtonMetersPerRadianTolerance); Assert.Equal(RotationalStiffnessUnit.MeganewtonMeterPerRadian, meganewtonmeterperradianQuantity.Unit); @@ -165,6 +185,10 @@ public void ToUnit() var newtonmeterperradianQuantity = newtonmeterperradian.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian); AssertEx.EqualTolerance(NewtonMetersPerRadianInOneNewtonMeterPerRadian, (double)newtonmeterperradianQuantity.Value, NewtonMetersPerRadianTolerance); Assert.Equal(RotationalStiffnessUnit.NewtonMeterPerRadian, newtonmeterperradianQuantity.Unit); + + var poundforcefootperdegreesQuantity = newtonmeterperradian.ToUnit(RotationalStiffnessUnit.PoundForceFootPerDegrees); + AssertEx.EqualTolerance(PoundForceFeetPerDegreesInOneNewtonMeterPerRadian, (double)poundforcefootperdegreesQuantity.Value, PoundForceFeetPerDegreesTolerance); + Assert.Equal(RotationalStiffnessUnit.PoundForceFootPerDegrees, poundforcefootperdegreesQuantity.Unit); } [Fact] @@ -172,8 +196,10 @@ public void ConversionRoundTrip() { RotationalStiffness newtonmeterperradian = RotationalStiffness.FromNewtonMetersPerRadian(1); AssertEx.EqualTolerance(1, RotationalStiffness.FromKilonewtonMetersPerRadian(newtonmeterperradian.KilonewtonMetersPerRadian).NewtonMetersPerRadian, KilonewtonMetersPerRadianTolerance); + AssertEx.EqualTolerance(1, RotationalStiffness.FromKilopoundForceFeetPerDegrees(newtonmeterperradian.KilopoundForceFeetPerDegrees).NewtonMetersPerRadian, KilopoundForceFeetPerDegreesTolerance); AssertEx.EqualTolerance(1, RotationalStiffness.FromMeganewtonMetersPerRadian(newtonmeterperradian.MeganewtonMetersPerRadian).NewtonMetersPerRadian, MeganewtonMetersPerRadianTolerance); AssertEx.EqualTolerance(1, RotationalStiffness.FromNewtonMetersPerRadian(newtonmeterperradian.NewtonMetersPerRadian).NewtonMetersPerRadian, NewtonMetersPerRadianTolerance); + AssertEx.EqualTolerance(1, RotationalStiffness.FromPoundForceFeetPerDegrees(newtonmeterperradian.PoundForceFeetPerDegrees).NewtonMetersPerRadian, PoundForceFeetPerDegreesTolerance); } [Fact] @@ -314,8 +340,10 @@ public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture() Thread.CurrentThread.CurrentUICulture = CultureInfo.GetCultureInfo("en-US"); try { Assert.Equal("1 kN·m/rad", new RotationalStiffness(1, RotationalStiffnessUnit.KilonewtonMeterPerRadian).ToString()); + Assert.Equal("1 kipf·ft/deg", new RotationalStiffness(1, RotationalStiffnessUnit.KilopoundForceFootPerDegrees).ToString()); Assert.Equal("1 MN·m/rad", new RotationalStiffness(1, RotationalStiffnessUnit.MeganewtonMeterPerRadian).ToString()); Assert.Equal("1 N·m/rad", new RotationalStiffness(1, RotationalStiffnessUnit.NewtonMeterPerRadian).ToString()); + Assert.Equal("1 lbf·ft/deg", new RotationalStiffness(1, RotationalStiffnessUnit.PoundForceFootPerDegrees).ToString()); } finally { @@ -330,8 +358,10 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture var swedishCulture = CultureInfo.GetCultureInfo("sv-SE"); Assert.Equal("1 kN·m/rad", new RotationalStiffness(1, RotationalStiffnessUnit.KilonewtonMeterPerRadian).ToString(swedishCulture)); + Assert.Equal("1 kipf·ft/deg", new RotationalStiffness(1, RotationalStiffnessUnit.KilopoundForceFootPerDegrees).ToString(swedishCulture)); Assert.Equal("1 MN·m/rad", new RotationalStiffness(1, RotationalStiffnessUnit.MeganewtonMeterPerRadian).ToString(swedishCulture)); Assert.Equal("1 N·m/rad", new RotationalStiffness(1, RotationalStiffnessUnit.NewtonMeterPerRadian).ToString(swedishCulture)); + Assert.Equal("1 lbf·ft/deg", new RotationalStiffness(1, RotationalStiffnessUnit.PoundForceFootPerDegrees).ToString(swedishCulture)); } [Fact] diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffness.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffness.g.cs index bb1ac04874..4fcc2518f9 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffness.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffness.g.cs @@ -160,6 +160,11 @@ private RotationalStiffness(double value, RotationalStiffnessUnit unit) /// public double KilonewtonMetersPerRadian => As(RotationalStiffnessUnit.KilonewtonMeterPerRadian); + /// + /// Get RotationalStiffness in KilopoundForceFeetPerDegrees. + /// + public double KilopoundForceFeetPerDegrees => As(RotationalStiffnessUnit.KilopoundForceFootPerDegrees); + /// /// Get RotationalStiffness in MeganewtonMetersPerRadian. /// @@ -170,6 +175,11 @@ private RotationalStiffness(double value, RotationalStiffnessUnit unit) /// public double NewtonMetersPerRadian => As(RotationalStiffnessUnit.NewtonMeterPerRadian); + /// + /// Get RotationalStiffness in PoundForceFeetPerDegrees. + /// + public double PoundForceFeetPerDegrees => As(RotationalStiffnessUnit.PoundForceFootPerDegrees); + #endregion #region Static Methods @@ -211,6 +221,16 @@ public static RotationalStiffness FromKilonewtonMetersPerRadian(double kilonewto return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMeterPerRadian); } /// + /// Get RotationalStiffness from KilopoundForceFeetPerDegrees. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static RotationalStiffness FromKilopoundForceFeetPerDegrees(double kilopoundforcefeetperdegrees) + { + double value = (double) kilopoundforcefeetperdegrees; + return new RotationalStiffness(value, RotationalStiffnessUnit.KilopoundForceFootPerDegrees); + } + /// /// Get RotationalStiffness from MeganewtonMetersPerRadian. /// /// If value is NaN or Infinity. @@ -230,6 +250,16 @@ public static RotationalStiffness FromNewtonMetersPerRadian(double newtonmetersp double value = (double) newtonmetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMeterPerRadian); } + /// + /// Get RotationalStiffness from PoundForceFeetPerDegrees. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static RotationalStiffness FromPoundForceFeetPerDegrees(double poundforcefeetperdegrees) + { + double value = (double) poundforcefeetperdegrees; + return new RotationalStiffness(value, RotationalStiffnessUnit.PoundForceFootPerDegrees); + } /// /// Dynamically convert from value and unit enum to . @@ -522,8 +552,10 @@ private double AsBaseUnit() switch(Unit) { case RotationalStiffnessUnit.KilonewtonMeterPerRadian: return (_value) * 1e3d; + case RotationalStiffnessUnit.KilopoundForceFootPerDegrees: return _value*77682.6; case RotationalStiffnessUnit.MeganewtonMeterPerRadian: return (_value) * 1e6d; case RotationalStiffnessUnit.NewtonMeterPerRadian: return _value; + case RotationalStiffnessUnit.PoundForceFootPerDegrees: return _value*77.6826; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -539,8 +571,10 @@ private double AsBaseNumericType(RotationalStiffnessUnit unit) switch(unit) { case RotationalStiffnessUnit.KilonewtonMeterPerRadian: return (baseUnitValue) / 1e3d; + case RotationalStiffnessUnit.KilopoundForceFootPerDegrees: return baseUnitValue/77682.6; case RotationalStiffnessUnit.MeganewtonMeterPerRadian: return (baseUnitValue) / 1e6d; case RotationalStiffnessUnit.NewtonMeterPerRadian: return baseUnitValue; + case RotationalStiffnessUnit.PoundForceFootPerDegrees: return baseUnitValue/77.6826; 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 c69a6aad28..2d0d75e5f0 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs @@ -997,8 +997,10 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("en-US", typeof(RotationalSpeedUnit), (int)RotationalSpeedUnit.RevolutionPerSecond, new string[]{"r/s"}), ("ru-RU", typeof(RotationalSpeedUnit), (int)RotationalSpeedUnit.RevolutionPerSecond, new string[]{"об/с"}), ("en-US", typeof(RotationalStiffnessUnit), (int)RotationalStiffnessUnit.KilonewtonMeterPerRadian, new string[]{"kN·m/rad", "kNm/rad"}), + ("en-US", typeof(RotationalStiffnessUnit), (int)RotationalStiffnessUnit.KilopoundForceFootPerDegrees, new string[]{"kipf·ft/deg"}), ("en-US", typeof(RotationalStiffnessUnit), (int)RotationalStiffnessUnit.MeganewtonMeterPerRadian, new string[]{"MN·m/rad", "MNm/rad"}), ("en-US", typeof(RotationalStiffnessUnit), (int)RotationalStiffnessUnit.NewtonMeterPerRadian, new string[]{"N·m/rad", "Nm/rad"}), + ("en-US", typeof(RotationalStiffnessUnit), (int)RotationalStiffnessUnit.PoundForceFootPerDegrees, new string[]{"lbf·ft/deg"}), ("en-US", typeof(RotationalStiffnessPerLengthUnit), (int)RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter, new string[]{"kN·m/rad/m", "kNm/rad/m"}), ("en-US", typeof(RotationalStiffnessPerLengthUnit), (int)RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter, new string[]{"MN·m/rad/m", "MNm/rad/m"}), ("en-US", typeof(RotationalStiffnessPerLengthUnit), (int)RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter, new string[]{"N·m/rad/m", "Nm/rad/m"}), diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/RotationalStiffnessUnit.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/RotationalStiffnessUnit.g.cs index a21f80ea73..dc84d5ae4b 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/RotationalStiffnessUnit.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/RotationalStiffnessUnit.g.cs @@ -27,8 +27,10 @@ public enum RotationalStiffnessUnit { Undefined = 0, KilonewtonMeterPerRadian, + KilopoundForceFootPerDegrees, MeganewtonMeterPerRadian, NewtonMeterPerRadian, + PoundForceFootPerDegrees, } #pragma warning restore 1591 diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs index 8f9e30e94c..d61ec8c16a 100644 --- a/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs @@ -51,8 +51,10 @@ static RotationalStiffness() Info = new QuantityInfo(QuantityType.RotationalStiffness, new UnitInfo[] { new UnitInfo(RotationalStiffnessUnit.KilonewtonMeterPerRadian, BaseUnits.Undefined), + new UnitInfo(RotationalStiffnessUnit.KilopoundForceFootPerDegrees, BaseUnits.Undefined), new UnitInfo(RotationalStiffnessUnit.MeganewtonMeterPerRadian, BaseUnits.Undefined), new UnitInfo(RotationalStiffnessUnit.NewtonMeterPerRadian, BaseUnits.Undefined), + new UnitInfo(RotationalStiffnessUnit.PoundForceFootPerDegrees, BaseUnits.Undefined), }, BaseUnit, Zero, BaseDimensions); } @@ -170,6 +172,11 @@ public RotationalStiffness(double value, UnitSystem unitSystem) /// public double KilonewtonMetersPerRadian => As(RotationalStiffnessUnit.KilonewtonMeterPerRadian); + /// + /// Get RotationalStiffness in KilopoundForceFeetPerDegrees. + /// + public double KilopoundForceFeetPerDegrees => As(RotationalStiffnessUnit.KilopoundForceFootPerDegrees); + /// /// Get RotationalStiffness in MeganewtonMetersPerRadian. /// @@ -180,6 +187,11 @@ public RotationalStiffness(double value, UnitSystem unitSystem) /// public double NewtonMetersPerRadian => As(RotationalStiffnessUnit.NewtonMeterPerRadian); + /// + /// Get RotationalStiffness in PoundForceFeetPerDegrees. + /// + public double PoundForceFeetPerDegrees => As(RotationalStiffnessUnit.PoundForceFootPerDegrees); + #endregion #region Static Methods @@ -219,6 +231,15 @@ public static RotationalStiffness FromKilonewtonMetersPerRadian(QuantityValue ki return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMeterPerRadian); } /// + /// Get RotationalStiffness from KilopoundForceFeetPerDegrees. + /// + /// If value is NaN or Infinity. + public static RotationalStiffness FromKilopoundForceFeetPerDegrees(QuantityValue kilopoundforcefeetperdegrees) + { + double value = (double) kilopoundforcefeetperdegrees; + return new RotationalStiffness(value, RotationalStiffnessUnit.KilopoundForceFootPerDegrees); + } + /// /// Get RotationalStiffness from MeganewtonMetersPerRadian. /// /// If value is NaN or Infinity. @@ -236,6 +257,15 @@ public static RotationalStiffness FromNewtonMetersPerRadian(QuantityValue newton double value = (double) newtonmetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMeterPerRadian); } + /// + /// Get RotationalStiffness from PoundForceFeetPerDegrees. + /// + /// If value is NaN or Infinity. + public static RotationalStiffness FromPoundForceFeetPerDegrees(QuantityValue poundforcefeetperdegrees) + { + double value = (double) poundforcefeetperdegrees; + return new RotationalStiffness(value, RotationalStiffnessUnit.PoundForceFootPerDegrees); + } /// /// Dynamically convert from value and unit enum to . @@ -666,8 +696,10 @@ private double GetValueInBaseUnit() switch(Unit) { case RotationalStiffnessUnit.KilonewtonMeterPerRadian: return (_value) * 1e3d; + case RotationalStiffnessUnit.KilopoundForceFootPerDegrees: return _value*77682.6; case RotationalStiffnessUnit.MeganewtonMeterPerRadian: return (_value) * 1e6d; case RotationalStiffnessUnit.NewtonMeterPerRadian: return _value; + case RotationalStiffnessUnit.PoundForceFootPerDegrees: return _value*77.6826; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -694,8 +726,10 @@ private double GetValueAs(RotationalStiffnessUnit unit) switch(unit) { case RotationalStiffnessUnit.KilonewtonMeterPerRadian: return (baseUnitValue) / 1e3d; + case RotationalStiffnessUnit.KilopoundForceFootPerDegrees: return baseUnitValue/77682.6; case RotationalStiffnessUnit.MeganewtonMeterPerRadian: return (baseUnitValue) / 1e6d; case RotationalStiffnessUnit.NewtonMeterPerRadian: return baseUnitValue; + case RotationalStiffnessUnit.PoundForceFootPerDegrees: return baseUnitValue/77.6826; 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 efb2b4eba8..ae333a979c 100644 --- a/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs +++ b/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs @@ -997,8 +997,10 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("en-US", typeof(RotationalSpeedUnit), (int)RotationalSpeedUnit.RevolutionPerSecond, new string[]{"r/s"}), ("ru-RU", typeof(RotationalSpeedUnit), (int)RotationalSpeedUnit.RevolutionPerSecond, new string[]{"об/с"}), ("en-US", typeof(RotationalStiffnessUnit), (int)RotationalStiffnessUnit.KilonewtonMeterPerRadian, new string[]{"kN·m/rad", "kNm/rad"}), + ("en-US", typeof(RotationalStiffnessUnit), (int)RotationalStiffnessUnit.KilopoundForceFootPerDegrees, new string[]{"kipf·ft/deg"}), ("en-US", typeof(RotationalStiffnessUnit), (int)RotationalStiffnessUnit.MeganewtonMeterPerRadian, new string[]{"MN·m/rad", "MNm/rad"}), ("en-US", typeof(RotationalStiffnessUnit), (int)RotationalStiffnessUnit.NewtonMeterPerRadian, new string[]{"N·m/rad", "Nm/rad"}), + ("en-US", typeof(RotationalStiffnessUnit), (int)RotationalStiffnessUnit.PoundForceFootPerDegrees, new string[]{"lbf·ft/deg"}), ("en-US", typeof(RotationalStiffnessPerLengthUnit), (int)RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter, new string[]{"kN·m/rad/m", "kNm/rad/m"}), ("en-US", typeof(RotationalStiffnessPerLengthUnit), (int)RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter, new string[]{"MN·m/rad/m", "MNm/rad/m"}), ("en-US", typeof(RotationalStiffnessPerLengthUnit), (int)RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter, new string[]{"N·m/rad/m", "Nm/rad/m"}), diff --git a/UnitsNet/GeneratedCode/UnitConverter.g.cs b/UnitsNet/GeneratedCode/UnitConverter.g.cs index 217f59c0f4..9581a19f6d 100644 --- a/UnitsNet/GeneratedCode/UnitConverter.g.cs +++ b/UnitsNet/GeneratedCode/UnitConverter.g.cs @@ -1549,9 +1549,13 @@ public static void RegisterDefaultConversions(UnitConverter unitConverter) unitConverter.SetConversionFunction(RotationalSpeedUnit.RevolutionPerSecond, RotationalSpeed.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.KilonewtonMeterPerRadian, q => q.ToUnit(RotationalStiffnessUnit.KilonewtonMeterPerRadian)); unitConverter.SetConversionFunction(RotationalStiffnessUnit.KilonewtonMeterPerRadian, RotationalStiffness.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.KilopoundForceFootPerDegrees, q => q.ToUnit(RotationalStiffnessUnit.KilopoundForceFootPerDegrees)); + unitConverter.SetConversionFunction(RotationalStiffnessUnit.KilopoundForceFootPerDegrees, RotationalStiffness.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.MeganewtonMeterPerRadian, q => q.ToUnit(RotationalStiffnessUnit.MeganewtonMeterPerRadian)); unitConverter.SetConversionFunction(RotationalStiffnessUnit.MeganewtonMeterPerRadian, RotationalStiffness.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(RotationalStiffness.BaseUnit, RotationalStiffness.BaseUnit, q => q); + unitConverter.SetConversionFunction(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.PoundForceFootPerDegrees, q => q.ToUnit(RotationalStiffnessUnit.PoundForceFootPerDegrees)); + unitConverter.SetConversionFunction(RotationalStiffnessUnit.PoundForceFootPerDegrees, RotationalStiffness.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(RotationalStiffnessPerLength.BaseUnit, RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter, q => q.ToUnit(RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter)); unitConverter.SetConversionFunction(RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter, RotationalStiffnessPerLength.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(RotationalStiffnessPerLength.BaseUnit, RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter, q => q.ToUnit(RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter)); diff --git a/UnitsNet/GeneratedCode/Units/RotationalStiffnessUnit.g.cs b/UnitsNet/GeneratedCode/Units/RotationalStiffnessUnit.g.cs index a21f80ea73..dc84d5ae4b 100644 --- a/UnitsNet/GeneratedCode/Units/RotationalStiffnessUnit.g.cs +++ b/UnitsNet/GeneratedCode/Units/RotationalStiffnessUnit.g.cs @@ -27,8 +27,10 @@ public enum RotationalStiffnessUnit { Undefined = 0, KilonewtonMeterPerRadian, + KilopoundForceFootPerDegrees, MeganewtonMeterPerRadian, NewtonMeterPerRadian, + PoundForceFootPerDegrees, } #pragma warning restore 1591 From 86258c867e5cbd4e20dfed5aad2e9a035e879822 Mon Sep 17 00:00:00 2001 From: Dirk Schuermans Date: Fri, 7 Feb 2020 10:31:28 +0100 Subject: [PATCH 2/2] Updated abbreviations according to PR remarks --- Common/UnitDefinitions/RotationalStiffness.json | 2 +- .../GeneratedCode/TestsBase/RotationalStiffnessTestsBase.g.cs | 4 ++-- .../GeneratedCode/UnitAbbreviationsCache.g.cs | 2 +- UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs | 2 +- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/Common/UnitDefinitions/RotationalStiffness.json b/Common/UnitDefinitions/RotationalStiffness.json index f77d93c3e2..c55bd71fd9 100644 --- a/Common/UnitDefinitions/RotationalStiffness.json +++ b/Common/UnitDefinitions/RotationalStiffness.json @@ -41,7 +41,7 @@ "Localization": [ { "Culture": "en-US", - "Abbreviations": [ "kipf·ft/deg" ] + "Abbreviations": [ "kipf·ft/°", "kip·ft/°g", "k·ft/°", "kipf·ft/deg", "kip·ft/deg", "k·ft/deg" ] } ] } diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessTestsBase.g.cs index 63b254afe7..1186bc4c6c 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessTestsBase.g.cs @@ -340,7 +340,7 @@ public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture() Thread.CurrentThread.CurrentUICulture = CultureInfo.GetCultureInfo("en-US"); try { Assert.Equal("1 kN·m/rad", new RotationalStiffness(1, RotationalStiffnessUnit.KilonewtonMeterPerRadian).ToString()); - Assert.Equal("1 kipf·ft/deg", new RotationalStiffness(1, RotationalStiffnessUnit.KilopoundForceFootPerDegrees).ToString()); + Assert.Equal("1 kipf·ft/°", new RotationalStiffness(1, RotationalStiffnessUnit.KilopoundForceFootPerDegrees).ToString()); Assert.Equal("1 MN·m/rad", new RotationalStiffness(1, RotationalStiffnessUnit.MeganewtonMeterPerRadian).ToString()); Assert.Equal("1 N·m/rad", new RotationalStiffness(1, RotationalStiffnessUnit.NewtonMeterPerRadian).ToString()); Assert.Equal("1 lbf·ft/deg", new RotationalStiffness(1, RotationalStiffnessUnit.PoundForceFootPerDegrees).ToString()); @@ -358,7 +358,7 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture var swedishCulture = CultureInfo.GetCultureInfo("sv-SE"); Assert.Equal("1 kN·m/rad", new RotationalStiffness(1, RotationalStiffnessUnit.KilonewtonMeterPerRadian).ToString(swedishCulture)); - Assert.Equal("1 kipf·ft/deg", new RotationalStiffness(1, RotationalStiffnessUnit.KilopoundForceFootPerDegrees).ToString(swedishCulture)); + Assert.Equal("1 kipf·ft/°", new RotationalStiffness(1, RotationalStiffnessUnit.KilopoundForceFootPerDegrees).ToString(swedishCulture)); Assert.Equal("1 MN·m/rad", new RotationalStiffness(1, RotationalStiffnessUnit.MeganewtonMeterPerRadian).ToString(swedishCulture)); Assert.Equal("1 N·m/rad", new RotationalStiffness(1, RotationalStiffnessUnit.NewtonMeterPerRadian).ToString(swedishCulture)); Assert.Equal("1 lbf·ft/deg", new RotationalStiffness(1, RotationalStiffnessUnit.PoundForceFootPerDegrees).ToString(swedishCulture)); diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs index 2d0d75e5f0..e6d11ff8d5 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs @@ -997,7 +997,7 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("en-US", typeof(RotationalSpeedUnit), (int)RotationalSpeedUnit.RevolutionPerSecond, new string[]{"r/s"}), ("ru-RU", typeof(RotationalSpeedUnit), (int)RotationalSpeedUnit.RevolutionPerSecond, new string[]{"об/с"}), ("en-US", typeof(RotationalStiffnessUnit), (int)RotationalStiffnessUnit.KilonewtonMeterPerRadian, new string[]{"kN·m/rad", "kNm/rad"}), - ("en-US", typeof(RotationalStiffnessUnit), (int)RotationalStiffnessUnit.KilopoundForceFootPerDegrees, new string[]{"kipf·ft/deg"}), + ("en-US", typeof(RotationalStiffnessUnit), (int)RotationalStiffnessUnit.KilopoundForceFootPerDegrees, new string[]{"kipf·ft/°", "kip·ft/°g", "k·ft/°", "kipf·ft/deg", "kip·ft/deg", "k·ft/deg"}), ("en-US", typeof(RotationalStiffnessUnit), (int)RotationalStiffnessUnit.MeganewtonMeterPerRadian, new string[]{"MN·m/rad", "MNm/rad"}), ("en-US", typeof(RotationalStiffnessUnit), (int)RotationalStiffnessUnit.NewtonMeterPerRadian, new string[]{"N·m/rad", "Nm/rad"}), ("en-US", typeof(RotationalStiffnessUnit), (int)RotationalStiffnessUnit.PoundForceFootPerDegrees, new string[]{"lbf·ft/deg"}), diff --git a/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs b/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs index ae333a979c..bb3ef4ae62 100644 --- a/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs +++ b/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs @@ -997,7 +997,7 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("en-US", typeof(RotationalSpeedUnit), (int)RotationalSpeedUnit.RevolutionPerSecond, new string[]{"r/s"}), ("ru-RU", typeof(RotationalSpeedUnit), (int)RotationalSpeedUnit.RevolutionPerSecond, new string[]{"об/с"}), ("en-US", typeof(RotationalStiffnessUnit), (int)RotationalStiffnessUnit.KilonewtonMeterPerRadian, new string[]{"kN·m/rad", "kNm/rad"}), - ("en-US", typeof(RotationalStiffnessUnit), (int)RotationalStiffnessUnit.KilopoundForceFootPerDegrees, new string[]{"kipf·ft/deg"}), + ("en-US", typeof(RotationalStiffnessUnit), (int)RotationalStiffnessUnit.KilopoundForceFootPerDegrees, new string[]{"kipf·ft/°", "kip·ft/°g", "k·ft/°", "kipf·ft/deg", "kip·ft/deg", "k·ft/deg"}), ("en-US", typeof(RotationalStiffnessUnit), (int)RotationalStiffnessUnit.MeganewtonMeterPerRadian, new string[]{"MN·m/rad", "MNm/rad"}), ("en-US", typeof(RotationalStiffnessUnit), (int)RotationalStiffnessUnit.NewtonMeterPerRadian, new string[]{"N·m/rad", "Nm/rad"}), ("en-US", typeof(RotationalStiffnessUnit), (int)RotationalStiffnessUnit.PoundForceFootPerDegrees, new string[]{"lbf·ft/deg"}),