Skip to content

Add mega force and torque #342

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 3 commits into from
Dec 16, 2017
Merged

Add mega force and torque #342

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
9aa9c3c
update json files
Dec 12, 2017
a4cc078
regenerate code and create missing test constants
Dec 12, 2017
b26dee4
add missing abreviations for pounds based torque units
Dec 13, 2017
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 1 addition & 0 deletions UnitsNet.Tests/CustomCode/ForceTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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;
Expand Down
12 changes: 11 additions & 1 deletion UnitsNet.Tests/CustomCode/TorqueTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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;

Expand Down
6 changes: 6 additions & 0 deletions UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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; }
Expand All @@ -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; } }
Expand All @@ -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);
Expand All @@ -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);
Expand All @@ -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);
Expand All @@ -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);
Expand Down
30 changes: 30 additions & 0 deletions UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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; }
Expand All @@ -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; } }
Expand All @@ -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);
Expand All @@ -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);
Expand All @@ -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);
Expand All @@ -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);
Expand Down
34 changes: 34 additions & 0 deletions UnitsNet/GeneratedCode/Extensions/Number/NumberToForceExtensions.g.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -214,6 +214,40 @@ public static class NumberToForceExtensions

#endregion

#region Meganewton

/// <inheritdoc cref="Force.FromMeganewtons(double)"/>
public static Force Meganewtons(this int value) => Force.FromMeganewtons(value);

/// <inheritdoc cref="Force.FromMeganewtons(double?)"/>
public static Force? Meganewtons(this int? value) => Force.FromMeganewtons(value);

/// <inheritdoc cref="Force.FromMeganewtons(double)"/>
public static Force Meganewtons(this long value) => Force.FromMeganewtons(value);

/// <inheritdoc cref="Force.FromMeganewtons(double?)"/>
public static Force? Meganewtons(this long? value) => Force.FromMeganewtons(value);

/// <inheritdoc cref="Force.FromMeganewtons(double)"/>
public static Force Meganewtons(this double value) => Force.FromMeganewtons(value);

/// <inheritdoc cref="Force.FromMeganewtons(double?)"/>
public static Force? Meganewtons(this double? value) => Force.FromMeganewtons(value);

/// <inheritdoc cref="Force.FromMeganewtons(double)"/>
public static Force Meganewtons(this float value) => Force.FromMeganewtons(value);

/// <inheritdoc cref="Force.FromMeganewtons(double?)"/>
public static Force? Meganewtons(this float? value) => Force.FromMeganewtons(value);

/// <inheritdoc cref="Force.FromMeganewtons(double)"/>
public static Force Meganewtons(this decimal value) => Force.FromMeganewtons(Convert.ToDouble(value));

/// <inheritdoc cref="Force.FromMeganewtons(double?)"/>
public static Force? Meganewtons(this decimal? value) => Force.FromMeganewtons(value == null ? (double?)null : Convert.ToDouble(value.Value));

#endregion

#region Newton

/// <inheritdoc cref="Force.FromNewtons(double)"/>
Expand Down
Loading