Skip to content

Commit 0afe5ce

Browse files
CGrisselinangularsen
CGrisselin
authored and
angularsen
committed
Add kilo/mega units to Force and Torque (#342)
1 parent c00ba1c commit 0afe5ce

File tree

13 files changed

+580
-9
lines changed

13 files changed

+580
-9
lines changed

‎UnitsNet.Tests/CustomCode/ForceTests.cs

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -30,6 +30,7 @@ public class ForceTests : ForceTestsBase
3030

3131
protected override double KilogramsForceInOneNewton => 0.101972;
3232

33+
protected override double MeganewtonsInOneNewton => 1E-6;
3334
protected override double KilonewtonsInOneNewton => 1E-3;
3435

3536
protected override double KiloPondsInOneNewton => 0.101972;

‎UnitsNet.Tests/CustomCode/TorqueTests.cs

Lines changed: 11 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -31,15 +31,25 @@ public class TorqueTests : TorqueTestsBase
3131

3232
protected override double KilogramForceMillimetersInOneNewtonMeter => 101.971621;
3333

34+
protected override double MeganewtonCentimetersInOneNewtonMeter => 1E-4;
35+
3436
protected override double KilonewtonCentimetersInOneNewtonMeter => 0.1;
3537

38+
protected override double MeganewtonMetersInOneNewtonMeter => 1E-6;
39+
3640
protected override double KilonewtonMetersInOneNewtonMeter => 0.001;
3741

42+
protected override double MeganewtonMillimetersInOneNewtonMeter => 1E-3;
43+
3844
protected override double KilonewtonMillimetersInOneNewtonMeter => 1;
3945

46+
protected override double MegapoundForceFeetInOneNewtonMeter => 7.376e-7;
47+
4048
protected override double KilopoundForceFeetInOneNewtonMeter => 7.376e-4;
4149

42-
protected override double KilopoundForceInchesInOneNewtonMeter => 0.008851;
50+
protected override double MegapoundForceInchesInOneNewtonMeter => 8.8516E-6;
51+
52+
protected override double KilopoundForceInchesInOneNewtonMeter => 8.8516E-3;
4353

4454
protected override double NewtonCentimetersInOneNewtonMeter => 100;
4555

‎UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -57,6 +57,7 @@ public abstract partial class ForceTestsBase
5757
protected abstract double KilogramsForceInOneNewton { get; }
5858
protected abstract double KilonewtonsInOneNewton { get; }
5959
protected abstract double KiloPondsInOneNewton { get; }
60+
protected abstract double MeganewtonsInOneNewton { get; }
6061
protected abstract double NewtonsInOneNewton { get; }
6162
protected abstract double PoundalsInOneNewton { get; }
6263
protected abstract double PoundsForceInOneNewton { get; }
@@ -68,6 +69,7 @@ public abstract partial class ForceTestsBase
6869
protected virtual double KilogramsForceTolerance { get { return 1e-5; } }
6970
protected virtual double KilonewtonsTolerance { get { return 1e-5; } }
7071
protected virtual double KiloPondsTolerance { get { return 1e-5; } }
72+
protected virtual double MeganewtonsTolerance { get { return 1e-5; } }
7173
protected virtual double NewtonsTolerance { get { return 1e-5; } }
7274
protected virtual double PoundalsTolerance { get { return 1e-5; } }
7375
protected virtual double PoundsForceTolerance { get { return 1e-5; } }
@@ -83,6 +85,7 @@ public void NewtonToForceUnits()
8385
AssertEx.EqualTolerance(KilogramsForceInOneNewton, newton.KilogramsForce, KilogramsForceTolerance);
8486
AssertEx.EqualTolerance(KilonewtonsInOneNewton, newton.Kilonewtons, KilonewtonsTolerance);
8587
AssertEx.EqualTolerance(KiloPondsInOneNewton, newton.KiloPonds, KiloPondsTolerance);
88+
AssertEx.EqualTolerance(MeganewtonsInOneNewton, newton.Meganewtons, MeganewtonsTolerance);
8689
AssertEx.EqualTolerance(NewtonsInOneNewton, newton.Newtons, NewtonsTolerance);
8790
AssertEx.EqualTolerance(PoundalsInOneNewton, newton.Poundals, PoundalsTolerance);
8891
AssertEx.EqualTolerance(PoundsForceInOneNewton, newton.PoundsForce, PoundsForceTolerance);
@@ -97,6 +100,7 @@ public void FromValueAndUnit()
97100
AssertEx.EqualTolerance(1, Force.From(1, ForceUnit.KilogramForce).KilogramsForce, KilogramsForceTolerance);
98101
AssertEx.EqualTolerance(1, Force.From(1, ForceUnit.Kilonewton).Kilonewtons, KilonewtonsTolerance);
99102
AssertEx.EqualTolerance(1, Force.From(1, ForceUnit.KiloPond).KiloPonds, KiloPondsTolerance);
103+
AssertEx.EqualTolerance(1, Force.From(1, ForceUnit.Meganewton).Meganewtons, MeganewtonsTolerance);
100104
AssertEx.EqualTolerance(1, Force.From(1, ForceUnit.Newton).Newtons, NewtonsTolerance);
101105
AssertEx.EqualTolerance(1, Force.From(1, ForceUnit.Poundal).Poundals, PoundalsTolerance);
102106
AssertEx.EqualTolerance(1, Force.From(1, ForceUnit.PoundForce).PoundsForce, PoundsForceTolerance);
@@ -112,6 +116,7 @@ public void As()
112116
AssertEx.EqualTolerance(KilogramsForceInOneNewton, newton.As(ForceUnit.KilogramForce), KilogramsForceTolerance);
113117
AssertEx.EqualTolerance(KilonewtonsInOneNewton, newton.As(ForceUnit.Kilonewton), KilonewtonsTolerance);
114118
AssertEx.EqualTolerance(KiloPondsInOneNewton, newton.As(ForceUnit.KiloPond), KiloPondsTolerance);
119+
AssertEx.EqualTolerance(MeganewtonsInOneNewton, newton.As(ForceUnit.Meganewton), MeganewtonsTolerance);
115120
AssertEx.EqualTolerance(NewtonsInOneNewton, newton.As(ForceUnit.Newton), NewtonsTolerance);
116121
AssertEx.EqualTolerance(PoundalsInOneNewton, newton.As(ForceUnit.Poundal), PoundalsTolerance);
117122
AssertEx.EqualTolerance(PoundsForceInOneNewton, newton.As(ForceUnit.PoundForce), PoundsForceTolerance);
@@ -127,6 +132,7 @@ public void ConversionRoundTrip()
127132
AssertEx.EqualTolerance(1, Force.FromKilogramsForce(newton.KilogramsForce).Newtons, KilogramsForceTolerance);
128133
AssertEx.EqualTolerance(1, Force.FromKilonewtons(newton.Kilonewtons).Newtons, KilonewtonsTolerance);
129134
AssertEx.EqualTolerance(1, Force.FromKiloPonds(newton.KiloPonds).Newtons, KiloPondsTolerance);
135+
AssertEx.EqualTolerance(1, Force.FromMeganewtons(newton.Meganewtons).Newtons, MeganewtonsTolerance);
130136
AssertEx.EqualTolerance(1, Force.FromNewtons(newton.Newtons).Newtons, NewtonsTolerance);
131137
AssertEx.EqualTolerance(1, Force.FromPoundals(newton.Poundals).Newtons, PoundalsTolerance);
132138
AssertEx.EqualTolerance(1, Force.FromPoundsForce(newton.PoundsForce).Newtons, PoundsForceTolerance);

‎UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs

Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -60,6 +60,11 @@ public abstract partial class TorqueTestsBase
6060
protected abstract double KilonewtonMillimetersInOneNewtonMeter { get; }
6161
protected abstract double KilopoundForceFeetInOneNewtonMeter { get; }
6262
protected abstract double KilopoundForceInchesInOneNewtonMeter { get; }
63+
protected abstract double MeganewtonCentimetersInOneNewtonMeter { get; }
64+
protected abstract double MeganewtonMetersInOneNewtonMeter { get; }
65+
protected abstract double MeganewtonMillimetersInOneNewtonMeter { get; }
66+
protected abstract double MegapoundForceFeetInOneNewtonMeter { get; }
67+
protected abstract double MegapoundForceInchesInOneNewtonMeter { get; }
6368
protected abstract double NewtonCentimetersInOneNewtonMeter { get; }
6469
protected abstract double NewtonMetersInOneNewtonMeter { get; }
6570
protected abstract double NewtonMillimetersInOneNewtonMeter { get; }
@@ -78,6 +83,11 @@ public abstract partial class TorqueTestsBase
7883
protected virtual double KilonewtonMillimetersTolerance { get { return 1e-5; } }
7984
protected virtual double KilopoundForceFeetTolerance { get { return 1e-5; } }
8085
protected virtual double KilopoundForceInchesTolerance { get { return 1e-5; } }
86+
protected virtual double MeganewtonCentimetersTolerance { get { return 1e-5; } }
87+
protected virtual double MeganewtonMetersTolerance { get { return 1e-5; } }
88+
protected virtual double MeganewtonMillimetersTolerance { get { return 1e-5; } }
89+
protected virtual double MegapoundForceFeetTolerance { get { return 1e-5; } }
90+
protected virtual double MegapoundForceInchesTolerance { get { return 1e-5; } }
8191
protected virtual double NewtonCentimetersTolerance { get { return 1e-5; } }
8292
protected virtual double NewtonMetersTolerance { get { return 1e-5; } }
8393
protected virtual double NewtonMillimetersTolerance { get { return 1e-5; } }
@@ -100,6 +110,11 @@ public void NewtonMeterToTorqueUnits()
100110
AssertEx.EqualTolerance(KilonewtonMillimetersInOneNewtonMeter, newtonmeter.KilonewtonMillimeters, KilonewtonMillimetersTolerance);
101111
AssertEx.EqualTolerance(KilopoundForceFeetInOneNewtonMeter, newtonmeter.KilopoundForceFeet, KilopoundForceFeetTolerance);
102112
AssertEx.EqualTolerance(KilopoundForceInchesInOneNewtonMeter, newtonmeter.KilopoundForceInches, KilopoundForceInchesTolerance);
113+
AssertEx.EqualTolerance(MeganewtonCentimetersInOneNewtonMeter, newtonmeter.MeganewtonCentimeters, MeganewtonCentimetersTolerance);
114+
AssertEx.EqualTolerance(MeganewtonMetersInOneNewtonMeter, newtonmeter.MeganewtonMeters, MeganewtonMetersTolerance);
115+
AssertEx.EqualTolerance(MeganewtonMillimetersInOneNewtonMeter, newtonmeter.MeganewtonMillimeters, MeganewtonMillimetersTolerance);
116+
AssertEx.EqualTolerance(MegapoundForceFeetInOneNewtonMeter, newtonmeter.MegapoundForceFeet, MegapoundForceFeetTolerance);
117+
AssertEx.EqualTolerance(MegapoundForceInchesInOneNewtonMeter, newtonmeter.MegapoundForceInches, MegapoundForceInchesTolerance);
103118
AssertEx.EqualTolerance(NewtonCentimetersInOneNewtonMeter, newtonmeter.NewtonCentimeters, NewtonCentimetersTolerance);
104119
AssertEx.EqualTolerance(NewtonMetersInOneNewtonMeter, newtonmeter.NewtonMeters, NewtonMetersTolerance);
105120
AssertEx.EqualTolerance(NewtonMillimetersInOneNewtonMeter, newtonmeter.NewtonMillimeters, NewtonMillimetersTolerance);
@@ -121,6 +136,11 @@ public void FromValueAndUnit()
121136
AssertEx.EqualTolerance(1, Torque.From(1, TorqueUnit.KilonewtonMillimeter).KilonewtonMillimeters, KilonewtonMillimetersTolerance);
122137
AssertEx.EqualTolerance(1, Torque.From(1, TorqueUnit.KilopoundForceFoot).KilopoundForceFeet, KilopoundForceFeetTolerance);
123138
AssertEx.EqualTolerance(1, Torque.From(1, TorqueUnit.KilopoundForceInch).KilopoundForceInches, KilopoundForceInchesTolerance);
139+
AssertEx.EqualTolerance(1, Torque.From(1, TorqueUnit.MeganewtonCentimeter).MeganewtonCentimeters, MeganewtonCentimetersTolerance);
140+
AssertEx.EqualTolerance(1, Torque.From(1, TorqueUnit.MeganewtonMeter).MeganewtonMeters, MeganewtonMetersTolerance);
141+
AssertEx.EqualTolerance(1, Torque.From(1, TorqueUnit.MeganewtonMillimeter).MeganewtonMillimeters, MeganewtonMillimetersTolerance);
142+
AssertEx.EqualTolerance(1, Torque.From(1, TorqueUnit.MegapoundForceFoot).MegapoundForceFeet, MegapoundForceFeetTolerance);
143+
AssertEx.EqualTolerance(1, Torque.From(1, TorqueUnit.MegapoundForceInch).MegapoundForceInches, MegapoundForceInchesTolerance);
124144
AssertEx.EqualTolerance(1, Torque.From(1, TorqueUnit.NewtonCentimeter).NewtonCentimeters, NewtonCentimetersTolerance);
125145
AssertEx.EqualTolerance(1, Torque.From(1, TorqueUnit.NewtonMeter).NewtonMeters, NewtonMetersTolerance);
126146
AssertEx.EqualTolerance(1, Torque.From(1, TorqueUnit.NewtonMillimeter).NewtonMillimeters, NewtonMillimetersTolerance);
@@ -143,6 +163,11 @@ public void As()
143163
AssertEx.EqualTolerance(KilonewtonMillimetersInOneNewtonMeter, newtonmeter.As(TorqueUnit.KilonewtonMillimeter), KilonewtonMillimetersTolerance);
144164
AssertEx.EqualTolerance(KilopoundForceFeetInOneNewtonMeter, newtonmeter.As(TorqueUnit.KilopoundForceFoot), KilopoundForceFeetTolerance);
145165
AssertEx.EqualTolerance(KilopoundForceInchesInOneNewtonMeter, newtonmeter.As(TorqueUnit.KilopoundForceInch), KilopoundForceInchesTolerance);
166+
AssertEx.EqualTolerance(MeganewtonCentimetersInOneNewtonMeter, newtonmeter.As(TorqueUnit.MeganewtonCentimeter), MeganewtonCentimetersTolerance);
167+
AssertEx.EqualTolerance(MeganewtonMetersInOneNewtonMeter, newtonmeter.As(TorqueUnit.MeganewtonMeter), MeganewtonMetersTolerance);
168+
AssertEx.EqualTolerance(MeganewtonMillimetersInOneNewtonMeter, newtonmeter.As(TorqueUnit.MeganewtonMillimeter), MeganewtonMillimetersTolerance);
169+
AssertEx.EqualTolerance(MegapoundForceFeetInOneNewtonMeter, newtonmeter.As(TorqueUnit.MegapoundForceFoot), MegapoundForceFeetTolerance);
170+
AssertEx.EqualTolerance(MegapoundForceInchesInOneNewtonMeter, newtonmeter.As(TorqueUnit.MegapoundForceInch), MegapoundForceInchesTolerance);
146171
AssertEx.EqualTolerance(NewtonCentimetersInOneNewtonMeter, newtonmeter.As(TorqueUnit.NewtonCentimeter), NewtonCentimetersTolerance);
147172
AssertEx.EqualTolerance(NewtonMetersInOneNewtonMeter, newtonmeter.As(TorqueUnit.NewtonMeter), NewtonMetersTolerance);
148173
AssertEx.EqualTolerance(NewtonMillimetersInOneNewtonMeter, newtonmeter.As(TorqueUnit.NewtonMillimeter), NewtonMillimetersTolerance);
@@ -165,6 +190,11 @@ public void ConversionRoundTrip()
165190
AssertEx.EqualTolerance(1, Torque.FromKilonewtonMillimeters(newtonmeter.KilonewtonMillimeters).NewtonMeters, KilonewtonMillimetersTolerance);
166191
AssertEx.EqualTolerance(1, Torque.FromKilopoundForceFeet(newtonmeter.KilopoundForceFeet).NewtonMeters, KilopoundForceFeetTolerance);
167192
AssertEx.EqualTolerance(1, Torque.FromKilopoundForceInches(newtonmeter.KilopoundForceInches).NewtonMeters, KilopoundForceInchesTolerance);
193+
AssertEx.EqualTolerance(1, Torque.FromMeganewtonCentimeters(newtonmeter.MeganewtonCentimeters).NewtonMeters, MeganewtonCentimetersTolerance);
194+
AssertEx.EqualTolerance(1, Torque.FromMeganewtonMeters(newtonmeter.MeganewtonMeters).NewtonMeters, MeganewtonMetersTolerance);
195+
AssertEx.EqualTolerance(1, Torque.FromMeganewtonMillimeters(newtonmeter.MeganewtonMillimeters).NewtonMeters, MeganewtonMillimetersTolerance);
196+
AssertEx.EqualTolerance(1, Torque.FromMegapoundForceFeet(newtonmeter.MegapoundForceFeet).NewtonMeters, MegapoundForceFeetTolerance);
197+
AssertEx.EqualTolerance(1, Torque.FromMegapoundForceInches(newtonmeter.MegapoundForceInches).NewtonMeters, MegapoundForceInchesTolerance);
168198
AssertEx.EqualTolerance(1, Torque.FromNewtonCentimeters(newtonmeter.NewtonCentimeters).NewtonMeters, NewtonCentimetersTolerance);
169199
AssertEx.EqualTolerance(1, Torque.FromNewtonMeters(newtonmeter.NewtonMeters).NewtonMeters, NewtonMetersTolerance);
170200
AssertEx.EqualTolerance(1, Torque.FromNewtonMillimeters(newtonmeter.NewtonMillimeters).NewtonMeters, NewtonMillimetersTolerance);

‎UnitsNet/GeneratedCode/Extensions/Number/NumberToForceExtensions.g.cs

Lines changed: 34 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -214,6 +214,40 @@ public static class NumberToForceExtensions
214214

215215
#endregion
216216

217+
#region Meganewton
218+
219+
/// <inheritdoc cref="Force.FromMeganewtons(double)"/>
220+
public static Force Meganewtons(this int value) => Force.FromMeganewtons(value);
221+
222+
/// <inheritdoc cref="Force.FromMeganewtons(double?)"/>
223+
public static Force? Meganewtons(this int? value) => Force.FromMeganewtons(value);
224+
225+
/// <inheritdoc cref="Force.FromMeganewtons(double)"/>
226+
public static Force Meganewtons(this long value) => Force.FromMeganewtons(value);
227+
228+
/// <inheritdoc cref="Force.FromMeganewtons(double?)"/>
229+
public static Force? Meganewtons(this long? value) => Force.FromMeganewtons(value);
230+
231+
/// <inheritdoc cref="Force.FromMeganewtons(double)"/>
232+
public static Force Meganewtons(this double value) => Force.FromMeganewtons(value);
233+
234+
/// <inheritdoc cref="Force.FromMeganewtons(double?)"/>
235+
public static Force? Meganewtons(this double? value) => Force.FromMeganewtons(value);
236+
237+
/// <inheritdoc cref="Force.FromMeganewtons(double)"/>
238+
public static Force Meganewtons(this float value) => Force.FromMeganewtons(value);
239+
240+
/// <inheritdoc cref="Force.FromMeganewtons(double?)"/>
241+
public static Force? Meganewtons(this float? value) => Force.FromMeganewtons(value);
242+
243+
/// <inheritdoc cref="Force.FromMeganewtons(double)"/>
244+
public static Force Meganewtons(this decimal value) => Force.FromMeganewtons(Convert.ToDouble(value));
245+
246+
/// <inheritdoc cref="Force.FromMeganewtons(double?)"/>
247+
public static Force? Meganewtons(this decimal? value) => Force.FromMeganewtons(value == null ? (double?)null : Convert.ToDouble(value.Value));
248+
249+
#endregion
250+
217251
#region Newton
218252

219253
/// <inheritdoc cref="Force.FromNewtons(double)"/>

0 commit comments

Comments
 (0)