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" ]
}
]
},