diff --git a/UnitsNet.Tests/CustomCode/ForceTests.cs b/UnitsNet.Tests/CustomCode/ForceTests.cs index 62d54285af..67bea8715b 100644 --- a/UnitsNet.Tests/CustomCode/ForceTests.cs +++ b/UnitsNet.Tests/CustomCode/ForceTests.cs @@ -30,6 +30,7 @@ public class ForceTests : ForceTestsBase protected override double KilogramsForceInOneNewton => 0.101972; + protected override double MeganewtonsInOneNewton => 1E-6; protected override double KilonewtonsInOneNewton => 1E-3; protected override double KiloPondsInOneNewton => 0.101972; diff --git a/UnitsNet.Tests/CustomCode/TorqueTests.cs b/UnitsNet.Tests/CustomCode/TorqueTests.cs index ed289295a2..2c78af380a 100644 --- a/UnitsNet.Tests/CustomCode/TorqueTests.cs +++ b/UnitsNet.Tests/CustomCode/TorqueTests.cs @@ -31,15 +31,25 @@ public class TorqueTests : TorqueTestsBase protected override double KilogramForceMillimetersInOneNewtonMeter => 101.971621; + protected override double MeganewtonCentimetersInOneNewtonMeter => 1E-4; + protected override double KilonewtonCentimetersInOneNewtonMeter => 0.1; + protected override double MeganewtonMetersInOneNewtonMeter => 1E-6; + protected override double KilonewtonMetersInOneNewtonMeter => 0.001; + protected override double MeganewtonMillimetersInOneNewtonMeter => 1E-3; + protected override double KilonewtonMillimetersInOneNewtonMeter => 1; + protected override double MegapoundForceFeetInOneNewtonMeter => 7.376e-7; + protected override double KilopoundForceFeetInOneNewtonMeter => 7.376e-4; - protected override double KilopoundForceInchesInOneNewtonMeter => 0.008851; + protected override double MegapoundForceInchesInOneNewtonMeter => 8.8516E-6; + + protected override double KilopoundForceInchesInOneNewtonMeter => 8.8516E-3; protected override double NewtonCentimetersInOneNewtonMeter => 100; diff --git a/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs index 776c8eea19..5f6b11da1c 100644 --- a/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs @@ -57,6 +57,7 @@ public abstract partial class ForceTestsBase protected abstract double KilogramsForceInOneNewton { get; } protected abstract double KilonewtonsInOneNewton { get; } protected abstract double KiloPondsInOneNewton { get; } + protected abstract double MeganewtonsInOneNewton { get; } protected abstract double NewtonsInOneNewton { get; } protected abstract double PoundalsInOneNewton { get; } protected abstract double PoundsForceInOneNewton { get; } @@ -68,6 +69,7 @@ public abstract partial class ForceTestsBase protected virtual double KilogramsForceTolerance { get { return 1e-5; } } protected virtual double KilonewtonsTolerance { get { return 1e-5; } } protected virtual double KiloPondsTolerance { get { return 1e-5; } } + protected virtual double MeganewtonsTolerance { get { return 1e-5; } } protected virtual double NewtonsTolerance { get { return 1e-5; } } protected virtual double PoundalsTolerance { get { return 1e-5; } } protected virtual double PoundsForceTolerance { get { return 1e-5; } } @@ -83,6 +85,7 @@ public void NewtonToForceUnits() AssertEx.EqualTolerance(KilogramsForceInOneNewton, newton.KilogramsForce, KilogramsForceTolerance); AssertEx.EqualTolerance(KilonewtonsInOneNewton, newton.Kilonewtons, KilonewtonsTolerance); AssertEx.EqualTolerance(KiloPondsInOneNewton, newton.KiloPonds, KiloPondsTolerance); + AssertEx.EqualTolerance(MeganewtonsInOneNewton, newton.Meganewtons, MeganewtonsTolerance); AssertEx.EqualTolerance(NewtonsInOneNewton, newton.Newtons, NewtonsTolerance); AssertEx.EqualTolerance(PoundalsInOneNewton, newton.Poundals, PoundalsTolerance); AssertEx.EqualTolerance(PoundsForceInOneNewton, newton.PoundsForce, PoundsForceTolerance); @@ -97,6 +100,7 @@ public void FromValueAndUnit() AssertEx.EqualTolerance(1, Force.From(1, ForceUnit.KilogramForce).KilogramsForce, KilogramsForceTolerance); AssertEx.EqualTolerance(1, Force.From(1, ForceUnit.Kilonewton).Kilonewtons, KilonewtonsTolerance); AssertEx.EqualTolerance(1, Force.From(1, ForceUnit.KiloPond).KiloPonds, KiloPondsTolerance); + AssertEx.EqualTolerance(1, Force.From(1, ForceUnit.Meganewton).Meganewtons, MeganewtonsTolerance); AssertEx.EqualTolerance(1, Force.From(1, ForceUnit.Newton).Newtons, NewtonsTolerance); AssertEx.EqualTolerance(1, Force.From(1, ForceUnit.Poundal).Poundals, PoundalsTolerance); AssertEx.EqualTolerance(1, Force.From(1, ForceUnit.PoundForce).PoundsForce, PoundsForceTolerance); @@ -112,6 +116,7 @@ public void As() AssertEx.EqualTolerance(KilogramsForceInOneNewton, newton.As(ForceUnit.KilogramForce), KilogramsForceTolerance); AssertEx.EqualTolerance(KilonewtonsInOneNewton, newton.As(ForceUnit.Kilonewton), KilonewtonsTolerance); AssertEx.EqualTolerance(KiloPondsInOneNewton, newton.As(ForceUnit.KiloPond), KiloPondsTolerance); + AssertEx.EqualTolerance(MeganewtonsInOneNewton, newton.As(ForceUnit.Meganewton), MeganewtonsTolerance); AssertEx.EqualTolerance(NewtonsInOneNewton, newton.As(ForceUnit.Newton), NewtonsTolerance); AssertEx.EqualTolerance(PoundalsInOneNewton, newton.As(ForceUnit.Poundal), PoundalsTolerance); AssertEx.EqualTolerance(PoundsForceInOneNewton, newton.As(ForceUnit.PoundForce), PoundsForceTolerance); @@ -127,6 +132,7 @@ public void ConversionRoundTrip() AssertEx.EqualTolerance(1, Force.FromKilogramsForce(newton.KilogramsForce).Newtons, KilogramsForceTolerance); AssertEx.EqualTolerance(1, Force.FromKilonewtons(newton.Kilonewtons).Newtons, KilonewtonsTolerance); AssertEx.EqualTolerance(1, Force.FromKiloPonds(newton.KiloPonds).Newtons, KiloPondsTolerance); + AssertEx.EqualTolerance(1, Force.FromMeganewtons(newton.Meganewtons).Newtons, MeganewtonsTolerance); AssertEx.EqualTolerance(1, Force.FromNewtons(newton.Newtons).Newtons, NewtonsTolerance); AssertEx.EqualTolerance(1, Force.FromPoundals(newton.Poundals).Newtons, PoundalsTolerance); AssertEx.EqualTolerance(1, Force.FromPoundsForce(newton.PoundsForce).Newtons, PoundsForceTolerance); diff --git a/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs index b19ed678d0..38f95cdc19 100644 --- a/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs @@ -60,6 +60,11 @@ public abstract partial class TorqueTestsBase protected abstract double KilonewtonMillimetersInOneNewtonMeter { get; } protected abstract double KilopoundForceFeetInOneNewtonMeter { get; } protected abstract double KilopoundForceInchesInOneNewtonMeter { get; } + protected abstract double MeganewtonCentimetersInOneNewtonMeter { get; } + protected abstract double MeganewtonMetersInOneNewtonMeter { get; } + protected abstract double MeganewtonMillimetersInOneNewtonMeter { get; } + protected abstract double MegapoundForceFeetInOneNewtonMeter { get; } + protected abstract double MegapoundForceInchesInOneNewtonMeter { get; } protected abstract double NewtonCentimetersInOneNewtonMeter { get; } protected abstract double NewtonMetersInOneNewtonMeter { get; } protected abstract double NewtonMillimetersInOneNewtonMeter { get; } @@ -78,6 +83,11 @@ public abstract partial class TorqueTestsBase protected virtual double KilonewtonMillimetersTolerance { get { return 1e-5; } } protected virtual double KilopoundForceFeetTolerance { get { return 1e-5; } } protected virtual double KilopoundForceInchesTolerance { get { return 1e-5; } } + protected virtual double MeganewtonCentimetersTolerance { get { return 1e-5; } } + protected virtual double MeganewtonMetersTolerance { get { return 1e-5; } } + protected virtual double MeganewtonMillimetersTolerance { get { return 1e-5; } } + protected virtual double MegapoundForceFeetTolerance { get { return 1e-5; } } + protected virtual double MegapoundForceInchesTolerance { get { return 1e-5; } } protected virtual double NewtonCentimetersTolerance { get { return 1e-5; } } protected virtual double NewtonMetersTolerance { get { return 1e-5; } } protected virtual double NewtonMillimetersTolerance { get { return 1e-5; } } @@ -100,6 +110,11 @@ public void NewtonMeterToTorqueUnits() AssertEx.EqualTolerance(KilonewtonMillimetersInOneNewtonMeter, newtonmeter.KilonewtonMillimeters, KilonewtonMillimetersTolerance); AssertEx.EqualTolerance(KilopoundForceFeetInOneNewtonMeter, newtonmeter.KilopoundForceFeet, KilopoundForceFeetTolerance); AssertEx.EqualTolerance(KilopoundForceInchesInOneNewtonMeter, newtonmeter.KilopoundForceInches, KilopoundForceInchesTolerance); + AssertEx.EqualTolerance(MeganewtonCentimetersInOneNewtonMeter, newtonmeter.MeganewtonCentimeters, MeganewtonCentimetersTolerance); + AssertEx.EqualTolerance(MeganewtonMetersInOneNewtonMeter, newtonmeter.MeganewtonMeters, MeganewtonMetersTolerance); + AssertEx.EqualTolerance(MeganewtonMillimetersInOneNewtonMeter, newtonmeter.MeganewtonMillimeters, MeganewtonMillimetersTolerance); + AssertEx.EqualTolerance(MegapoundForceFeetInOneNewtonMeter, newtonmeter.MegapoundForceFeet, MegapoundForceFeetTolerance); + AssertEx.EqualTolerance(MegapoundForceInchesInOneNewtonMeter, newtonmeter.MegapoundForceInches, MegapoundForceInchesTolerance); AssertEx.EqualTolerance(NewtonCentimetersInOneNewtonMeter, newtonmeter.NewtonCentimeters, NewtonCentimetersTolerance); AssertEx.EqualTolerance(NewtonMetersInOneNewtonMeter, newtonmeter.NewtonMeters, NewtonMetersTolerance); AssertEx.EqualTolerance(NewtonMillimetersInOneNewtonMeter, newtonmeter.NewtonMillimeters, NewtonMillimetersTolerance); @@ -121,6 +136,11 @@ public void FromValueAndUnit() AssertEx.EqualTolerance(1, Torque.From(1, TorqueUnit.KilonewtonMillimeter).KilonewtonMillimeters, KilonewtonMillimetersTolerance); AssertEx.EqualTolerance(1, Torque.From(1, TorqueUnit.KilopoundForceFoot).KilopoundForceFeet, KilopoundForceFeetTolerance); AssertEx.EqualTolerance(1, Torque.From(1, TorqueUnit.KilopoundForceInch).KilopoundForceInches, KilopoundForceInchesTolerance); + AssertEx.EqualTolerance(1, Torque.From(1, TorqueUnit.MeganewtonCentimeter).MeganewtonCentimeters, MeganewtonCentimetersTolerance); + AssertEx.EqualTolerance(1, Torque.From(1, TorqueUnit.MeganewtonMeter).MeganewtonMeters, MeganewtonMetersTolerance); + AssertEx.EqualTolerance(1, Torque.From(1, TorqueUnit.MeganewtonMillimeter).MeganewtonMillimeters, MeganewtonMillimetersTolerance); + AssertEx.EqualTolerance(1, Torque.From(1, TorqueUnit.MegapoundForceFoot).MegapoundForceFeet, MegapoundForceFeetTolerance); + AssertEx.EqualTolerance(1, Torque.From(1, TorqueUnit.MegapoundForceInch).MegapoundForceInches, MegapoundForceInchesTolerance); AssertEx.EqualTolerance(1, Torque.From(1, TorqueUnit.NewtonCentimeter).NewtonCentimeters, NewtonCentimetersTolerance); AssertEx.EqualTolerance(1, Torque.From(1, TorqueUnit.NewtonMeter).NewtonMeters, NewtonMetersTolerance); AssertEx.EqualTolerance(1, Torque.From(1, TorqueUnit.NewtonMillimeter).NewtonMillimeters, NewtonMillimetersTolerance); @@ -143,6 +163,11 @@ public void As() AssertEx.EqualTolerance(KilonewtonMillimetersInOneNewtonMeter, newtonmeter.As(TorqueUnit.KilonewtonMillimeter), KilonewtonMillimetersTolerance); AssertEx.EqualTolerance(KilopoundForceFeetInOneNewtonMeter, newtonmeter.As(TorqueUnit.KilopoundForceFoot), KilopoundForceFeetTolerance); AssertEx.EqualTolerance(KilopoundForceInchesInOneNewtonMeter, newtonmeter.As(TorqueUnit.KilopoundForceInch), KilopoundForceInchesTolerance); + AssertEx.EqualTolerance(MeganewtonCentimetersInOneNewtonMeter, newtonmeter.As(TorqueUnit.MeganewtonCentimeter), MeganewtonCentimetersTolerance); + AssertEx.EqualTolerance(MeganewtonMetersInOneNewtonMeter, newtonmeter.As(TorqueUnit.MeganewtonMeter), MeganewtonMetersTolerance); + AssertEx.EqualTolerance(MeganewtonMillimetersInOneNewtonMeter, newtonmeter.As(TorqueUnit.MeganewtonMillimeter), MeganewtonMillimetersTolerance); + AssertEx.EqualTolerance(MegapoundForceFeetInOneNewtonMeter, newtonmeter.As(TorqueUnit.MegapoundForceFoot), MegapoundForceFeetTolerance); + AssertEx.EqualTolerance(MegapoundForceInchesInOneNewtonMeter, newtonmeter.As(TorqueUnit.MegapoundForceInch), MegapoundForceInchesTolerance); AssertEx.EqualTolerance(NewtonCentimetersInOneNewtonMeter, newtonmeter.As(TorqueUnit.NewtonCentimeter), NewtonCentimetersTolerance); AssertEx.EqualTolerance(NewtonMetersInOneNewtonMeter, newtonmeter.As(TorqueUnit.NewtonMeter), NewtonMetersTolerance); AssertEx.EqualTolerance(NewtonMillimetersInOneNewtonMeter, newtonmeter.As(TorqueUnit.NewtonMillimeter), NewtonMillimetersTolerance); @@ -165,6 +190,11 @@ public void ConversionRoundTrip() AssertEx.EqualTolerance(1, Torque.FromKilonewtonMillimeters(newtonmeter.KilonewtonMillimeters).NewtonMeters, KilonewtonMillimetersTolerance); AssertEx.EqualTolerance(1, Torque.FromKilopoundForceFeet(newtonmeter.KilopoundForceFeet).NewtonMeters, KilopoundForceFeetTolerance); AssertEx.EqualTolerance(1, Torque.FromKilopoundForceInches(newtonmeter.KilopoundForceInches).NewtonMeters, KilopoundForceInchesTolerance); + AssertEx.EqualTolerance(1, Torque.FromMeganewtonCentimeters(newtonmeter.MeganewtonCentimeters).NewtonMeters, MeganewtonCentimetersTolerance); + AssertEx.EqualTolerance(1, Torque.FromMeganewtonMeters(newtonmeter.MeganewtonMeters).NewtonMeters, MeganewtonMetersTolerance); + AssertEx.EqualTolerance(1, Torque.FromMeganewtonMillimeters(newtonmeter.MeganewtonMillimeters).NewtonMeters, MeganewtonMillimetersTolerance); + AssertEx.EqualTolerance(1, Torque.FromMegapoundForceFeet(newtonmeter.MegapoundForceFeet).NewtonMeters, MegapoundForceFeetTolerance); + AssertEx.EqualTolerance(1, Torque.FromMegapoundForceInches(newtonmeter.MegapoundForceInches).NewtonMeters, MegapoundForceInchesTolerance); AssertEx.EqualTolerance(1, Torque.FromNewtonCentimeters(newtonmeter.NewtonCentimeters).NewtonMeters, NewtonCentimetersTolerance); AssertEx.EqualTolerance(1, Torque.FromNewtonMeters(newtonmeter.NewtonMeters).NewtonMeters, NewtonMetersTolerance); AssertEx.EqualTolerance(1, Torque.FromNewtonMillimeters(newtonmeter.NewtonMillimeters).NewtonMeters, NewtonMillimetersTolerance); diff --git a/UnitsNet/GeneratedCode/Extensions/Number/NumberToForceExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/Number/NumberToForceExtensions.g.cs index 2e775573eb..23121f258a 100644 --- a/UnitsNet/GeneratedCode/Extensions/Number/NumberToForceExtensions.g.cs +++ b/UnitsNet/GeneratedCode/Extensions/Number/NumberToForceExtensions.g.cs @@ -214,6 +214,40 @@ public static class NumberToForceExtensions #endregion + #region Meganewton + + /// + public static Force Meganewtons(this int value) => Force.FromMeganewtons(value); + + /// + public static Force? Meganewtons(this int? value) => Force.FromMeganewtons(value); + + /// + public static Force Meganewtons(this long value) => Force.FromMeganewtons(value); + + /// + public static Force? Meganewtons(this long? value) => Force.FromMeganewtons(value); + + /// + public static Force Meganewtons(this double value) => Force.FromMeganewtons(value); + + /// + public static Force? Meganewtons(this double? value) => Force.FromMeganewtons(value); + + /// + public static Force Meganewtons(this float value) => Force.FromMeganewtons(value); + + /// + public static Force? Meganewtons(this float? value) => Force.FromMeganewtons(value); + + /// + public static Force Meganewtons(this decimal value) => Force.FromMeganewtons(Convert.ToDouble(value)); + + /// + public static Force? Meganewtons(this decimal? value) => Force.FromMeganewtons(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + #region Newton /// diff --git a/UnitsNet/GeneratedCode/Extensions/Number/NumberToTorqueExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/Number/NumberToTorqueExtensions.g.cs index 1e60f414a7..2564dd1e43 100644 --- a/UnitsNet/GeneratedCode/Extensions/Number/NumberToTorqueExtensions.g.cs +++ b/UnitsNet/GeneratedCode/Extensions/Number/NumberToTorqueExtensions.g.cs @@ -316,6 +316,176 @@ public static class NumberToTorqueExtensions #endregion + #region MeganewtonCentimeter + + /// + public static Torque MeganewtonCentimeters(this int value) => Torque.FromMeganewtonCentimeters(value); + + /// + public static Torque? MeganewtonCentimeters(this int? value) => Torque.FromMeganewtonCentimeters(value); + + /// + public static Torque MeganewtonCentimeters(this long value) => Torque.FromMeganewtonCentimeters(value); + + /// + public static Torque? MeganewtonCentimeters(this long? value) => Torque.FromMeganewtonCentimeters(value); + + /// + public static Torque MeganewtonCentimeters(this double value) => Torque.FromMeganewtonCentimeters(value); + + /// + public static Torque? MeganewtonCentimeters(this double? value) => Torque.FromMeganewtonCentimeters(value); + + /// + public static Torque MeganewtonCentimeters(this float value) => Torque.FromMeganewtonCentimeters(value); + + /// + public static Torque? MeganewtonCentimeters(this float? value) => Torque.FromMeganewtonCentimeters(value); + + /// + public static Torque MeganewtonCentimeters(this decimal value) => Torque.FromMeganewtonCentimeters(Convert.ToDouble(value)); + + /// + public static Torque? MeganewtonCentimeters(this decimal? value) => Torque.FromMeganewtonCentimeters(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + + #region MeganewtonMeter + + /// + public static Torque MeganewtonMeters(this int value) => Torque.FromMeganewtonMeters(value); + + /// + public static Torque? MeganewtonMeters(this int? value) => Torque.FromMeganewtonMeters(value); + + /// + public static Torque MeganewtonMeters(this long value) => Torque.FromMeganewtonMeters(value); + + /// + public static Torque? MeganewtonMeters(this long? value) => Torque.FromMeganewtonMeters(value); + + /// + public static Torque MeganewtonMeters(this double value) => Torque.FromMeganewtonMeters(value); + + /// + public static Torque? MeganewtonMeters(this double? value) => Torque.FromMeganewtonMeters(value); + + /// + public static Torque MeganewtonMeters(this float value) => Torque.FromMeganewtonMeters(value); + + /// + public static Torque? MeganewtonMeters(this float? value) => Torque.FromMeganewtonMeters(value); + + /// + public static Torque MeganewtonMeters(this decimal value) => Torque.FromMeganewtonMeters(Convert.ToDouble(value)); + + /// + public static Torque? MeganewtonMeters(this decimal? value) => Torque.FromMeganewtonMeters(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + + #region MeganewtonMillimeter + + /// + public static Torque MeganewtonMillimeters(this int value) => Torque.FromMeganewtonMillimeters(value); + + /// + public static Torque? MeganewtonMillimeters(this int? value) => Torque.FromMeganewtonMillimeters(value); + + /// + public static Torque MeganewtonMillimeters(this long value) => Torque.FromMeganewtonMillimeters(value); + + /// + public static Torque? MeganewtonMillimeters(this long? value) => Torque.FromMeganewtonMillimeters(value); + + /// + public static Torque MeganewtonMillimeters(this double value) => Torque.FromMeganewtonMillimeters(value); + + /// + public static Torque? MeganewtonMillimeters(this double? value) => Torque.FromMeganewtonMillimeters(value); + + /// + public static Torque MeganewtonMillimeters(this float value) => Torque.FromMeganewtonMillimeters(value); + + /// + public static Torque? MeganewtonMillimeters(this float? value) => Torque.FromMeganewtonMillimeters(value); + + /// + public static Torque MeganewtonMillimeters(this decimal value) => Torque.FromMeganewtonMillimeters(Convert.ToDouble(value)); + + /// + public static Torque? MeganewtonMillimeters(this decimal? value) => Torque.FromMeganewtonMillimeters(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + + #region MegapoundForceFoot + + /// + public static Torque MegapoundForceFeet(this int value) => Torque.FromMegapoundForceFeet(value); + + /// + public static Torque? MegapoundForceFeet(this int? value) => Torque.FromMegapoundForceFeet(value); + + /// + public static Torque MegapoundForceFeet(this long value) => Torque.FromMegapoundForceFeet(value); + + /// + public static Torque? MegapoundForceFeet(this long? value) => Torque.FromMegapoundForceFeet(value); + + /// + public static Torque MegapoundForceFeet(this double value) => Torque.FromMegapoundForceFeet(value); + + /// + public static Torque? MegapoundForceFeet(this double? value) => Torque.FromMegapoundForceFeet(value); + + /// + public static Torque MegapoundForceFeet(this float value) => Torque.FromMegapoundForceFeet(value); + + /// + public static Torque? MegapoundForceFeet(this float? value) => Torque.FromMegapoundForceFeet(value); + + /// + public static Torque MegapoundForceFeet(this decimal value) => Torque.FromMegapoundForceFeet(Convert.ToDouble(value)); + + /// + public static Torque? MegapoundForceFeet(this decimal? value) => Torque.FromMegapoundForceFeet(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + + #region MegapoundForceInch + + /// + public static Torque MegapoundForceInches(this int value) => Torque.FromMegapoundForceInches(value); + + /// + public static Torque? MegapoundForceInches(this int? value) => Torque.FromMegapoundForceInches(value); + + /// + public static Torque MegapoundForceInches(this long value) => Torque.FromMegapoundForceInches(value); + + /// + public static Torque? MegapoundForceInches(this long? value) => Torque.FromMegapoundForceInches(value); + + /// + public static Torque MegapoundForceInches(this double value) => Torque.FromMegapoundForceInches(value); + + /// + public static Torque? MegapoundForceInches(this double? value) => Torque.FromMegapoundForceInches(value); + + /// + public static Torque MegapoundForceInches(this float value) => Torque.FromMegapoundForceInches(value); + + /// + public static Torque? MegapoundForceInches(this float? value) => Torque.FromMegapoundForceInches(value); + + /// + public static Torque MegapoundForceInches(this decimal value) => Torque.FromMegapoundForceInches(Convert.ToDouble(value)); + + /// + public static Torque? MegapoundForceInches(this decimal? value) => Torque.FromMegapoundForceInches(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + #region NewtonCentimeter /// diff --git a/UnitsNet/GeneratedCode/Quantities/Force.g.cs b/UnitsNet/GeneratedCode/Quantities/Force.g.cs index ec90aa2f37..4787f72af6 100644 --- a/UnitsNet/GeneratedCode/Quantities/Force.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Force.g.cs @@ -169,6 +169,14 @@ public double KiloPonds get { return _newtons/9.80665002864; } } + /// + /// Get Force in Meganewtons. + /// + public double Meganewtons + { + get { return (_newtons) / 1e6d; } + } + /// /// Get Force in Newtons. /// @@ -300,6 +308,24 @@ public static Force FromKiloPonds(QuantityValue kiloponds) } #endif + /// + /// Get Force from Meganewtons. + /// +#if WINDOWS_UWP + [Windows.Foundation.Metadata.DefaultOverload] + public static Force FromMeganewtons(double meganewtons) + { + double value = (double) meganewtons; + return new Force((value) * 1e6d); + } +#else + public static Force FromMeganewtons(QuantityValue meganewtons) + { + double value = (double) meganewtons; + return new Force(((value) * 1e6d)); + } +#endif + /// /// Get Force from Newtons. /// @@ -449,6 +475,21 @@ public static Force FromTonnesForce(QuantityValue tonnesforce) } } + /// + /// Get nullable Force from nullable Meganewtons. + /// + public static Force? FromMeganewtons(QuantityValue? meganewtons) + { + if (meganewtons.HasValue) + { + return FromMeganewtons(meganewtons.Value); + } + else + { + return null; + } + } + /// /// Get nullable Force from nullable Newtons. /// @@ -537,6 +578,8 @@ public static Force From(QuantityValue value, ForceUnit fromUnit) return FromKilonewtons(value); case ForceUnit.KiloPond: return FromKiloPonds(value); + case ForceUnit.Meganewton: + return FromMeganewtons(value); case ForceUnit.Newton: return FromNewtons(value); case ForceUnit.Poundal: @@ -577,6 +620,8 @@ public static Force From(QuantityValue value, ForceUnit fromUnit) return FromKilonewtons(value.Value); case ForceUnit.KiloPond: return FromKiloPonds(value.Value); + case ForceUnit.Meganewton: + return FromMeganewtons(value.Value); case ForceUnit.Newton: return FromNewtons(value.Value); case ForceUnit.Poundal: @@ -768,6 +813,8 @@ public double As(ForceUnit unit) return Kilonewtons; case ForceUnit.KiloPond: return KiloPonds; + case ForceUnit.Meganewton: + return Meganewtons; case ForceUnit.Newton: return Newtons; case ForceUnit.Poundal: diff --git a/UnitsNet/GeneratedCode/Quantities/Torque.g.cs b/UnitsNet/GeneratedCode/Quantities/Torque.g.cs index 347bf2e764..f19a153070 100644 --- a/UnitsNet/GeneratedCode/Quantities/Torque.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Torque.g.cs @@ -193,6 +193,46 @@ public double KilopoundForceInches get { return (_newtonMeters*8.85074502580075) / 1e3d; } } + /// + /// Get Torque in MeganewtonCentimeters. + /// + public double MeganewtonCentimeters + { + get { return (_newtonMeters*100) / 1e6d; } + } + + /// + /// Get Torque in MeganewtonMeters. + /// + public double MeganewtonMeters + { + get { return (_newtonMeters) / 1e6d; } + } + + /// + /// Get Torque in MeganewtonMillimeters. + /// + public double MeganewtonMillimeters + { + get { return (_newtonMeters*1000) / 1e6d; } + } + + /// + /// Get Torque in MegapoundForceFeet. + /// + public double MegapoundForceFeet + { + get { return (_newtonMeters*0.737562085483396) / 1e6d; } + } + + /// + /// Get Torque in MegapoundForceInches. + /// + public double MegapoundForceInches + { + get { return (_newtonMeters*8.85074502580075) / 1e6d; } + } + /// /// Get Torque in NewtonCentimeters. /// @@ -410,6 +450,96 @@ public static Torque FromKilopoundForceInches(QuantityValue kilopoundforceinches } #endif + /// + /// Get Torque from MeganewtonCentimeters. + /// +#if WINDOWS_UWP + [Windows.Foundation.Metadata.DefaultOverload] + public static Torque FromMeganewtonCentimeters(double meganewtoncentimeters) + { + double value = (double) meganewtoncentimeters; + return new Torque((value*0.01) * 1e6d); + } +#else + public static Torque FromMeganewtonCentimeters(QuantityValue meganewtoncentimeters) + { + double value = (double) meganewtoncentimeters; + return new Torque(((value*0.01) * 1e6d)); + } +#endif + + /// + /// Get Torque from MeganewtonMeters. + /// +#if WINDOWS_UWP + [Windows.Foundation.Metadata.DefaultOverload] + public static Torque FromMeganewtonMeters(double meganewtonmeters) + { + double value = (double) meganewtonmeters; + return new Torque((value) * 1e6d); + } +#else + public static Torque FromMeganewtonMeters(QuantityValue meganewtonmeters) + { + double value = (double) meganewtonmeters; + return new Torque(((value) * 1e6d)); + } +#endif + + /// + /// Get Torque from MeganewtonMillimeters. + /// +#if WINDOWS_UWP + [Windows.Foundation.Metadata.DefaultOverload] + public static Torque FromMeganewtonMillimeters(double meganewtonmillimeters) + { + double value = (double) meganewtonmillimeters; + return new Torque((value*0.001) * 1e6d); + } +#else + public static Torque FromMeganewtonMillimeters(QuantityValue meganewtonmillimeters) + { + double value = (double) meganewtonmillimeters; + return new Torque(((value*0.001) * 1e6d)); + } +#endif + + /// + /// Get Torque from MegapoundForceFeet. + /// +#if WINDOWS_UWP + [Windows.Foundation.Metadata.DefaultOverload] + public static Torque FromMegapoundForceFeet(double megapoundforcefeet) + { + double value = (double) megapoundforcefeet; + return new Torque((value*1.3558180656) * 1e6d); + } +#else + public static Torque FromMegapoundForceFeet(QuantityValue megapoundforcefeet) + { + double value = (double) megapoundforcefeet; + return new Torque(((value*1.3558180656) * 1e6d)); + } +#endif + + /// + /// Get Torque from MegapoundForceInches. + /// +#if WINDOWS_UWP + [Windows.Foundation.Metadata.DefaultOverload] + public static Torque FromMegapoundForceInches(double megapoundforceinches) + { + double value = (double) megapoundforceinches; + return new Torque((value*0.1129848388) * 1e6d); + } +#else + public static Torque FromMegapoundForceInches(QuantityValue megapoundforceinches) + { + double value = (double) megapoundforceinches; + return new Torque(((value*0.1129848388) * 1e6d)); + } +#endif + /// /// Get Torque from NewtonCentimeters. /// @@ -676,6 +806,81 @@ public static Torque FromTonneForceMillimeters(QuantityValue tonneforcemillimete } } + /// + /// Get nullable Torque from nullable MeganewtonCentimeters. + /// + public static Torque? FromMeganewtonCentimeters(QuantityValue? meganewtoncentimeters) + { + if (meganewtoncentimeters.HasValue) + { + return FromMeganewtonCentimeters(meganewtoncentimeters.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable Torque from nullable MeganewtonMeters. + /// + public static Torque? FromMeganewtonMeters(QuantityValue? meganewtonmeters) + { + if (meganewtonmeters.HasValue) + { + return FromMeganewtonMeters(meganewtonmeters.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable Torque from nullable MeganewtonMillimeters. + /// + public static Torque? FromMeganewtonMillimeters(QuantityValue? meganewtonmillimeters) + { + if (meganewtonmillimeters.HasValue) + { + return FromMeganewtonMillimeters(meganewtonmillimeters.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable Torque from nullable MegapoundForceFeet. + /// + public static Torque? FromMegapoundForceFeet(QuantityValue? megapoundforcefeet) + { + if (megapoundforcefeet.HasValue) + { + return FromMegapoundForceFeet(megapoundforcefeet.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable Torque from nullable MegapoundForceInches. + /// + public static Torque? FromMegapoundForceInches(QuantityValue? megapoundforceinches) + { + if (megapoundforceinches.HasValue) + { + return FromMegapoundForceInches(megapoundforceinches.Value); + } + else + { + return null; + } + } + /// /// Get nullable Torque from nullable NewtonCentimeters. /// @@ -830,6 +1035,16 @@ public static Torque From(QuantityValue value, TorqueUnit fromUnit) return FromKilopoundForceFeet(value); case TorqueUnit.KilopoundForceInch: return FromKilopoundForceInches(value); + case TorqueUnit.MeganewtonCentimeter: + return FromMeganewtonCentimeters(value); + case TorqueUnit.MeganewtonMeter: + return FromMeganewtonMeters(value); + case TorqueUnit.MeganewtonMillimeter: + return FromMeganewtonMillimeters(value); + case TorqueUnit.MegapoundForceFoot: + return FromMegapoundForceFeet(value); + case TorqueUnit.MegapoundForceInch: + return FromMegapoundForceInches(value); case TorqueUnit.NewtonCentimeter: return FromNewtonCentimeters(value); case TorqueUnit.NewtonMeter: @@ -884,6 +1099,16 @@ public static Torque From(QuantityValue value, TorqueUnit fromUnit) return FromKilopoundForceFeet(value.Value); case TorqueUnit.KilopoundForceInch: return FromKilopoundForceInches(value.Value); + case TorqueUnit.MeganewtonCentimeter: + return FromMeganewtonCentimeters(value.Value); + case TorqueUnit.MeganewtonMeter: + return FromMeganewtonMeters(value.Value); + case TorqueUnit.MeganewtonMillimeter: + return FromMeganewtonMillimeters(value.Value); + case TorqueUnit.MegapoundForceFoot: + return FromMegapoundForceFeet(value.Value); + case TorqueUnit.MegapoundForceInch: + return FromMegapoundForceInches(value.Value); case TorqueUnit.NewtonCentimeter: return FromNewtonCentimeters(value.Value); case TorqueUnit.NewtonMeter: @@ -1089,6 +1314,16 @@ public double As(TorqueUnit unit) return KilopoundForceFeet; case TorqueUnit.KilopoundForceInch: return KilopoundForceInches; + case TorqueUnit.MeganewtonCentimeter: + return MeganewtonCentimeters; + case TorqueUnit.MeganewtonMeter: + return MeganewtonMeters; + case TorqueUnit.MeganewtonMillimeter: + return MeganewtonMillimeters; + case TorqueUnit.MegapoundForceFoot: + return MegapoundForceFeet; + case TorqueUnit.MegapoundForceInch: + return MegapoundForceInches; case TorqueUnit.NewtonCentimeter: return NewtonCentimeters; case TorqueUnit.NewtonMeter: diff --git a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs index 0f1ec3aa7e..7ebd445a2d 100644 --- a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs +++ b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs @@ -1176,6 +1176,12 @@ private static readonly ReadOnlyCollection DefaultLocalization new AbbreviationsForCulture("en-US", "kp"), new AbbreviationsForCulture("ru-RU", "кгс"), }), + new CulturesForEnumValue((int) ForceUnit.Meganewton, + new[] + { + new AbbreviationsForCulture("en-US", "MN"), + new AbbreviationsForCulture("ru-RU", ""), + }), new CulturesForEnumValue((int) ForceUnit.Newton, new[] { @@ -3214,6 +3220,32 @@ private static readonly ReadOnlyCollection DefaultLocalization { new AbbreviationsForCulture("en-US", "kipf·in"), }), + new CulturesForEnumValue((int) TorqueUnit.MeganewtonCentimeter, + new[] + { + new AbbreviationsForCulture("en-US", "MN·cm"), + }), + new CulturesForEnumValue((int) TorqueUnit.MeganewtonMeter, + new[] + { + new AbbreviationsForCulture("en-US", "MN·m"), + new AbbreviationsForCulture("ru-RU", ""), + }), + new CulturesForEnumValue((int) TorqueUnit.MeganewtonMillimeter, + new[] + { + new AbbreviationsForCulture("en-US", "MN·mm"), + }), + new CulturesForEnumValue((int) TorqueUnit.MegapoundForceFoot, + new[] + { + new AbbreviationsForCulture("en-US", "Mlbf·ft"), + }), + new CulturesForEnumValue((int) TorqueUnit.MegapoundForceInch, + new[] + { + new AbbreviationsForCulture("en-US", "Mlbf·in"), + }), new CulturesForEnumValue((int) TorqueUnit.NewtonCentimeter, new[] { diff --git a/UnitsNet/GeneratedCode/Units/ForceUnit.g.cs b/UnitsNet/GeneratedCode/Units/ForceUnit.g.cs index c0e5a4bec8..d6d1e77657 100644 --- a/UnitsNet/GeneratedCode/Units/ForceUnit.g.cs +++ b/UnitsNet/GeneratedCode/Units/ForceUnit.g.cs @@ -47,6 +47,7 @@ public enum ForceUnit KilogramForce, Kilonewton, KiloPond, + Meganewton, Newton, Poundal, PoundForce, diff --git a/UnitsNet/GeneratedCode/Units/TorqueUnit.g.cs b/UnitsNet/GeneratedCode/Units/TorqueUnit.g.cs index 015ab2375d..96cf2c8a59 100644 --- a/UnitsNet/GeneratedCode/Units/TorqueUnit.g.cs +++ b/UnitsNet/GeneratedCode/Units/TorqueUnit.g.cs @@ -50,6 +50,11 @@ public enum TorqueUnit KilonewtonMillimeter, KilopoundForceFoot, KilopoundForceInch, + MeganewtonCentimeter, + MeganewtonMeter, + MeganewtonMillimeter, + MegapoundForceFoot, + MegapoundForceInch, NewtonCentimeter, NewtonMeter, NewtonMillimeter, diff --git a/UnitsNet/UnitDefinitions/Force.json b/UnitsNet/UnitDefinitions/Force.json index 99ccb37056..99b3b7b01a 100644 --- a/UnitsNet/UnitDefinitions/Force.json +++ b/UnitsNet/UnitDefinitions/Force.json @@ -56,7 +56,7 @@ "PluralName": "Newtons", "FromUnitToBaseFunc": "x", "FromBaseToUnitFunc": "x", - "Prefixes": [ "Deca", "Kilo" ], + "Prefixes": [ "Deca", "Kilo", "Mega" ], "Localization": [ { "Culture": "en-US", diff --git a/UnitsNet/UnitDefinitions/Torque.json b/UnitsNet/UnitDefinitions/Torque.json index 665bff8234..1df8f20d84 100644 --- a/UnitsNet/UnitDefinitions/Torque.json +++ b/UnitsNet/UnitDefinitions/Torque.json @@ -8,7 +8,7 @@ "PluralName": "NewtonMillimeters", "FromUnitToBaseFunc": "x*0.001", "FromBaseToUnitFunc": "x*1000", - "Prefixes": [ "Kilo" ], + "Prefixes": [ "Kilo", "Mega" ], "Localization": [ { "Culture": "en-US", @@ -21,7 +21,7 @@ "PluralName": "NewtonCentimeters", "FromUnitToBaseFunc": "x*0.01", "FromBaseToUnitFunc": "x*100", - "Prefixes": [ "Kilo" ], + "Prefixes": [ "Kilo", "Mega" ], "Localization": [ { "Culture": "en-US", @@ -34,7 +34,7 @@ "PluralName": "NewtonMeters", "FromUnitToBaseFunc": "x", "FromBaseToUnitFunc": "x", - "Prefixes": [ "Kilo" ], + "Prefixes": [ "Kilo", "Mega" ], "Localization": [ { "Culture": "en-US", @@ -52,12 +52,12 @@ "PluralName": "PoundForceInches", "FromUnitToBaseFunc": "x*0.1129848388", "FromBaseToUnitFunc": "x*8.85074502580075", - "Prefixes": [ "Kilo" ], + "Prefixes": [ "Kilo", "Mega" ], "Localization": [ { "Culture": "en-US", "Abbreviations": [ "lbf·in" ], - "AbbreviationsWithPrefixes": [ "kipf·in" ] + "AbbreviationsWithPrefixes": [ "kipf·in", "Mlbf·in"] } ] }, @@ -66,12 +66,12 @@ "PluralName": "PoundForceFeet", "FromUnitToBaseFunc": "x*1.3558180656", "FromBaseToUnitFunc": "x*0.737562085483396", - "Prefixes": [ "Kilo" ], + "Prefixes": [ "Kilo", "Mega" ], "Localization": [ { "Culture": "en-US", "Abbreviations": [ "lbf·ft" ], - "AbbreviationsWithPrefixes": [ "kipf·ft" ] + "AbbreviationsWithPrefixes": [ "kipf·ft", "Mlbf·ft" ] } ] },