public void FromKilogramSquareMeters_WithNanValue_ThrowsArgumentException()
{
Assert.Throws <ArgumentException>(() => MassMomentOfInertia.FromKilogramSquareMeters(double.NaN));
}
public static MassMomentOfInertia?KilogramSquareCentimeters <T>(this T?value) where T : struct => MassMomentOfInertia.FromKilogramSquareCentimeters(value == null ? (double?)null : Convert.ToDouble(value.Value));
public static MassMomentOfInertia MilligramSquareMillimeters <T>(this T value) => MassMomentOfInertia.FromMilligramSquareMillimeters(Convert.ToDecimal(value));
/// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareMeters(UnitsNet.QuantityValue)" /> public static MassMomentOfInertia TonneSquareMeters <T>(this T value) => MassMomentOfInertia.FromTonneSquareMeters(Convert.ToDouble(value));
/// <inheritdoc cref="MassMomentOfInertia.FromGramSquareMillimeters(UnitsNet.QuantityValue)" /> public static MassMomentOfInertia GramSquareMillimeters <T>(this T value) => MassMomentOfInertia.FromGramSquareMillimeters(Convert.ToDouble(value));
/// <inheritdoc cref="MassMomentOfInertia.FromPoundSquareFeet(UnitsNet.QuantityValue)" /> public static MassMomentOfInertia PoundSquareFeet <T>(this T value) => MassMomentOfInertia.FromPoundSquareFeet(Convert.ToDouble(value));
/// <inheritdoc cref="MassMomentOfInertia.FromSlugSquareInches(UnitsNet.QuantityValue)" /> public static MassMomentOfInertia SlugSquareInches <T>(this T value) => MassMomentOfInertia.FromSlugSquareInches(Convert.ToDouble(value));
public void EqualsReturnsFalseOnNull()
{
MassMomentOfInertia kilogramsquaremeter = MassMomentOfInertia.FromKilogramSquareMeters(1);
Assert.False(kilogramsquaremeter.Equals(null));
}
public void NumberToPoundSquareInchesTest() => Assert.Equal(MassMomentOfInertia.FromPoundSquareInches(2), 2.PoundSquareInches());
public void CompareToThrowsOnNull()
{
MassMomentOfInertia kilogramsquaremeter = MassMomentOfInertia.FromKilogramSquareMeters(1);
Assert.Throws <ArgumentNullException>(() => kilogramsquaremeter.CompareTo(null));
}
public void EqualsReturnsFalseOnTypeMismatch()
{
MassMomentOfInertia kilogramsquaremeter = MassMomentOfInertia.FromKilogramSquareMeters(1);
Assert.False(kilogramsquaremeter.Equals(new object()));
}
public void CompareToThrowsOnTypeMismatch()
{
MassMomentOfInertia kilogramsquaremeter = MassMomentOfInertia.FromKilogramSquareMeters(1);
Assert.Throws <ArgumentException>(() => kilogramsquaremeter.CompareTo(new object()));
}
public void ArithmeticOperators()
{
MassMomentOfInertia v = MassMomentOfInertia.FromKilogramSquareMeters(1);
AssertEx.EqualTolerance(-1, -v.KilogramSquareMeters, KilogramSquareMetersTolerance);
AssertEx.EqualTolerance(2, (MassMomentOfInertia.FromKilogramSquareMeters(3) - v).KilogramSquareMeters, KilogramSquareMetersTolerance);
AssertEx.EqualTolerance(2, (v + v).KilogramSquareMeters, KilogramSquareMetersTolerance);
AssertEx.EqualTolerance(10, (v * 10).KilogramSquareMeters, KilogramSquareMetersTolerance);
AssertEx.EqualTolerance(10, (10 * v).KilogramSquareMeters, KilogramSquareMetersTolerance);
AssertEx.EqualTolerance(2, (MassMomentOfInertia.FromKilogramSquareMeters(10) / 5).KilogramSquareMeters, KilogramSquareMetersTolerance);
AssertEx.EqualTolerance(2, MassMomentOfInertia.FromKilogramSquareMeters(10) / MassMomentOfInertia.FromKilogramSquareMeters(5), KilogramSquareMetersTolerance);
}
public void ToUnit()
{
var kilogramsquaremeter = MassMomentOfInertia.FromKilogramSquareMeters(1);
var gramsquarecentimeterQuantity = kilogramsquaremeter.ToUnit(MassMomentOfInertiaUnit.GramSquareCentimeter);
AssertEx.EqualTolerance(GramSquareCentimetersInOneKilogramSquareMeter, (double)gramsquarecentimeterQuantity.Value, GramSquareCentimetersTolerance);
Assert.Equal(MassMomentOfInertiaUnit.GramSquareCentimeter, gramsquarecentimeterQuantity.Unit);
var gramsquaredecimeterQuantity = kilogramsquaremeter.ToUnit(MassMomentOfInertiaUnit.GramSquareDecimeter);
AssertEx.EqualTolerance(GramSquareDecimetersInOneKilogramSquareMeter, (double)gramsquaredecimeterQuantity.Value, GramSquareDecimetersTolerance);
Assert.Equal(MassMomentOfInertiaUnit.GramSquareDecimeter, gramsquaredecimeterQuantity.Unit);
var gramsquaremeterQuantity = kilogramsquaremeter.ToUnit(MassMomentOfInertiaUnit.GramSquareMeter);
AssertEx.EqualTolerance(GramSquareMetersInOneKilogramSquareMeter, (double)gramsquaremeterQuantity.Value, GramSquareMetersTolerance);
Assert.Equal(MassMomentOfInertiaUnit.GramSquareMeter, gramsquaremeterQuantity.Unit);
var gramsquaremillimeterQuantity = kilogramsquaremeter.ToUnit(MassMomentOfInertiaUnit.GramSquareMillimeter);
AssertEx.EqualTolerance(GramSquareMillimetersInOneKilogramSquareMeter, (double)gramsquaremillimeterQuantity.Value, GramSquareMillimetersTolerance);
Assert.Equal(MassMomentOfInertiaUnit.GramSquareMillimeter, gramsquaremillimeterQuantity.Unit);
var kilogramsquarecentimeterQuantity = kilogramsquaremeter.ToUnit(MassMomentOfInertiaUnit.KilogramSquareCentimeter);
AssertEx.EqualTolerance(KilogramSquareCentimetersInOneKilogramSquareMeter, (double)kilogramsquarecentimeterQuantity.Value, KilogramSquareCentimetersTolerance);
Assert.Equal(MassMomentOfInertiaUnit.KilogramSquareCentimeter, kilogramsquarecentimeterQuantity.Unit);
var kilogramsquaredecimeterQuantity = kilogramsquaremeter.ToUnit(MassMomentOfInertiaUnit.KilogramSquareDecimeter);
AssertEx.EqualTolerance(KilogramSquareDecimetersInOneKilogramSquareMeter, (double)kilogramsquaredecimeterQuantity.Value, KilogramSquareDecimetersTolerance);
Assert.Equal(MassMomentOfInertiaUnit.KilogramSquareDecimeter, kilogramsquaredecimeterQuantity.Unit);
var kilogramsquaremeterQuantity = kilogramsquaremeter.ToUnit(MassMomentOfInertiaUnit.KilogramSquareMeter);
AssertEx.EqualTolerance(KilogramSquareMetersInOneKilogramSquareMeter, (double)kilogramsquaremeterQuantity.Value, KilogramSquareMetersTolerance);
Assert.Equal(MassMomentOfInertiaUnit.KilogramSquareMeter, kilogramsquaremeterQuantity.Unit);
var kilogramsquaremillimeterQuantity = kilogramsquaremeter.ToUnit(MassMomentOfInertiaUnit.KilogramSquareMillimeter);
AssertEx.EqualTolerance(KilogramSquareMillimetersInOneKilogramSquareMeter, (double)kilogramsquaremillimeterQuantity.Value, KilogramSquareMillimetersTolerance);
Assert.Equal(MassMomentOfInertiaUnit.KilogramSquareMillimeter, kilogramsquaremillimeterQuantity.Unit);
var kilotonnesquarecentimeterQuantity = kilogramsquaremeter.ToUnit(MassMomentOfInertiaUnit.KilotonneSquareCentimeter);
AssertEx.EqualTolerance(KilotonneSquareCentimetersInOneKilogramSquareMeter, (double)kilotonnesquarecentimeterQuantity.Value, KilotonneSquareCentimetersTolerance);
Assert.Equal(MassMomentOfInertiaUnit.KilotonneSquareCentimeter, kilotonnesquarecentimeterQuantity.Unit);
var kilotonnesquaredecimeterQuantity = kilogramsquaremeter.ToUnit(MassMomentOfInertiaUnit.KilotonneSquareDecimeter);
AssertEx.EqualTolerance(KilotonneSquareDecimetersInOneKilogramSquareMeter, (double)kilotonnesquaredecimeterQuantity.Value, KilotonneSquareDecimetersTolerance);
Assert.Equal(MassMomentOfInertiaUnit.KilotonneSquareDecimeter, kilotonnesquaredecimeterQuantity.Unit);
var kilotonnesquaremeterQuantity = kilogramsquaremeter.ToUnit(MassMomentOfInertiaUnit.KilotonneSquareMeter);
AssertEx.EqualTolerance(KilotonneSquareMetersInOneKilogramSquareMeter, (double)kilotonnesquaremeterQuantity.Value, KilotonneSquareMetersTolerance);
Assert.Equal(MassMomentOfInertiaUnit.KilotonneSquareMeter, kilotonnesquaremeterQuantity.Unit);
var kilotonnesquaremilimeterQuantity = kilogramsquaremeter.ToUnit(MassMomentOfInertiaUnit.KilotonneSquareMilimeter);
AssertEx.EqualTolerance(KilotonneSquareMilimetersInOneKilogramSquareMeter, (double)kilotonnesquaremilimeterQuantity.Value, KilotonneSquareMilimetersTolerance);
Assert.Equal(MassMomentOfInertiaUnit.KilotonneSquareMilimeter, kilotonnesquaremilimeterQuantity.Unit);
var megatonnesquarecentimeterQuantity = kilogramsquaremeter.ToUnit(MassMomentOfInertiaUnit.MegatonneSquareCentimeter);
AssertEx.EqualTolerance(MegatonneSquareCentimetersInOneKilogramSquareMeter, (double)megatonnesquarecentimeterQuantity.Value, MegatonneSquareCentimetersTolerance);
Assert.Equal(MassMomentOfInertiaUnit.MegatonneSquareCentimeter, megatonnesquarecentimeterQuantity.Unit);
var megatonnesquaredecimeterQuantity = kilogramsquaremeter.ToUnit(MassMomentOfInertiaUnit.MegatonneSquareDecimeter);
AssertEx.EqualTolerance(MegatonneSquareDecimetersInOneKilogramSquareMeter, (double)megatonnesquaredecimeterQuantity.Value, MegatonneSquareDecimetersTolerance);
Assert.Equal(MassMomentOfInertiaUnit.MegatonneSquareDecimeter, megatonnesquaredecimeterQuantity.Unit);
var megatonnesquaremeterQuantity = kilogramsquaremeter.ToUnit(MassMomentOfInertiaUnit.MegatonneSquareMeter);
AssertEx.EqualTolerance(MegatonneSquareMetersInOneKilogramSquareMeter, (double)megatonnesquaremeterQuantity.Value, MegatonneSquareMetersTolerance);
Assert.Equal(MassMomentOfInertiaUnit.MegatonneSquareMeter, megatonnesquaremeterQuantity.Unit);
var megatonnesquaremilimeterQuantity = kilogramsquaremeter.ToUnit(MassMomentOfInertiaUnit.MegatonneSquareMilimeter);
AssertEx.EqualTolerance(MegatonneSquareMilimetersInOneKilogramSquareMeter, (double)megatonnesquaremilimeterQuantity.Value, MegatonneSquareMilimetersTolerance);
Assert.Equal(MassMomentOfInertiaUnit.MegatonneSquareMilimeter, megatonnesquaremilimeterQuantity.Unit);
var milligramsquarecentimeterQuantity = kilogramsquaremeter.ToUnit(MassMomentOfInertiaUnit.MilligramSquareCentimeter);
AssertEx.EqualTolerance(MilligramSquareCentimetersInOneKilogramSquareMeter, (double)milligramsquarecentimeterQuantity.Value, MilligramSquareCentimetersTolerance);
Assert.Equal(MassMomentOfInertiaUnit.MilligramSquareCentimeter, milligramsquarecentimeterQuantity.Unit);
var milligramsquaredecimeterQuantity = kilogramsquaremeter.ToUnit(MassMomentOfInertiaUnit.MilligramSquareDecimeter);
AssertEx.EqualTolerance(MilligramSquareDecimetersInOneKilogramSquareMeter, (double)milligramsquaredecimeterQuantity.Value, MilligramSquareDecimetersTolerance);
Assert.Equal(MassMomentOfInertiaUnit.MilligramSquareDecimeter, milligramsquaredecimeterQuantity.Unit);
var milligramsquaremeterQuantity = kilogramsquaremeter.ToUnit(MassMomentOfInertiaUnit.MilligramSquareMeter);
AssertEx.EqualTolerance(MilligramSquareMetersInOneKilogramSquareMeter, (double)milligramsquaremeterQuantity.Value, MilligramSquareMetersTolerance);
Assert.Equal(MassMomentOfInertiaUnit.MilligramSquareMeter, milligramsquaremeterQuantity.Unit);
var milligramsquaremillimeterQuantity = kilogramsquaremeter.ToUnit(MassMomentOfInertiaUnit.MilligramSquareMillimeter);
AssertEx.EqualTolerance(MilligramSquareMillimetersInOneKilogramSquareMeter, (double)milligramsquaremillimeterQuantity.Value, MilligramSquareMillimetersTolerance);
Assert.Equal(MassMomentOfInertiaUnit.MilligramSquareMillimeter, milligramsquaremillimeterQuantity.Unit);
var poundsquarefootQuantity = kilogramsquaremeter.ToUnit(MassMomentOfInertiaUnit.PoundSquareFoot);
AssertEx.EqualTolerance(PoundSquareFeetInOneKilogramSquareMeter, (double)poundsquarefootQuantity.Value, PoundSquareFeetTolerance);
Assert.Equal(MassMomentOfInertiaUnit.PoundSquareFoot, poundsquarefootQuantity.Unit);
var poundsquareinchQuantity = kilogramsquaremeter.ToUnit(MassMomentOfInertiaUnit.PoundSquareInch);
AssertEx.EqualTolerance(PoundSquareInchesInOneKilogramSquareMeter, (double)poundsquareinchQuantity.Value, PoundSquareInchesTolerance);
Assert.Equal(MassMomentOfInertiaUnit.PoundSquareInch, poundsquareinchQuantity.Unit);
var tonnesquarecentimeterQuantity = kilogramsquaremeter.ToUnit(MassMomentOfInertiaUnit.TonneSquareCentimeter);
AssertEx.EqualTolerance(TonneSquareCentimetersInOneKilogramSquareMeter, (double)tonnesquarecentimeterQuantity.Value, TonneSquareCentimetersTolerance);
Assert.Equal(MassMomentOfInertiaUnit.TonneSquareCentimeter, tonnesquarecentimeterQuantity.Unit);
var tonnesquaredecimeterQuantity = kilogramsquaremeter.ToUnit(MassMomentOfInertiaUnit.TonneSquareDecimeter);
AssertEx.EqualTolerance(TonneSquareDecimetersInOneKilogramSquareMeter, (double)tonnesquaredecimeterQuantity.Value, TonneSquareDecimetersTolerance);
Assert.Equal(MassMomentOfInertiaUnit.TonneSquareDecimeter, tonnesquaredecimeterQuantity.Unit);
var tonnesquaremeterQuantity = kilogramsquaremeter.ToUnit(MassMomentOfInertiaUnit.TonneSquareMeter);
AssertEx.EqualTolerance(TonneSquareMetersInOneKilogramSquareMeter, (double)tonnesquaremeterQuantity.Value, TonneSquareMetersTolerance);
Assert.Equal(MassMomentOfInertiaUnit.TonneSquareMeter, tonnesquaremeterQuantity.Unit);
var tonnesquaremilimeterQuantity = kilogramsquaremeter.ToUnit(MassMomentOfInertiaUnit.TonneSquareMilimeter);
AssertEx.EqualTolerance(TonneSquareMilimetersInOneKilogramSquareMeter, (double)tonnesquaremilimeterQuantity.Value, TonneSquareMilimetersTolerance);
Assert.Equal(MassMomentOfInertiaUnit.TonneSquareMilimeter, tonnesquaremilimeterQuantity.Unit);
}
/// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareDecimeters(UnitsNet.QuantityValue)" /> public static MassMomentOfInertia KilotonneSquareDecimeters <T>(this T value) => MassMomentOfInertia.FromKilotonneSquareDecimeters(Convert.ToDouble(value));
public void NumberToSlugSquareInchesTest() => Assert.Equal(MassMomentOfInertia.FromSlugSquareInches(2), 2.SlugSquareInches());
/// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareMilimeters(UnitsNet.QuantityValue)" /> public static MassMomentOfInertia MegatonneSquareMilimeters <T>(this T value) => MassMomentOfInertia.FromMegatonneSquareMilimeters(Convert.ToDouble(value));
public void NumberToTonneSquareDecimetersTest() => Assert.Equal(MassMomentOfInertia.FromTonneSquareDecimeters(2), 2.TonneSquareDecimeters());
public static MassMomentOfInertia?PoundSquareFeet <T>(this T?value) where T : struct => MassMomentOfInertia.FromPoundSquareFeet(value == null ? (double?)null : Convert.ToDouble(value.Value));
public void NumberToGramSquareDecimetersTest() => Assert.Equal(MassMomentOfInertia.FromGramSquareDecimeters(2), 2.GramSquareDecimeters());
public static MassMomentOfInertia?SlugSquareInches <T>(this T?value) where T : struct => MassMomentOfInertia.FromSlugSquareInches(value == null ? (double?)null : Convert.ToDouble(value.Value));
public void NumberToKilogramSquareMillimetersTest() => Assert.Equal(MassMomentOfInertia.FromKilogramSquareMillimeters(2), 2.KilogramSquareMillimeters());
public static MassMomentOfInertia?TonneSquareMilimeters <T>(this T?value) where T : struct => MassMomentOfInertia.FromTonneSquareMilimeters(value == null ? (double?)null : Convert.ToDouble(value.Value));
public void NumberToKilotonneSquareMetersTest() => Assert.Equal(MassMomentOfInertia.FromKilotonneSquareMeters(2), 2.KilotonneSquareMeters());
/// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareCentimeters(UnitsNet.QuantityValue)" /> public static MassMomentOfInertia KilogramSquareCentimeters <T>(this T value) => MassMomentOfInertia.FromKilogramSquareCentimeters(Convert.ToDouble(value));
public void NumberToMegatonneSquareMilimetersTest() => Assert.Equal(MassMomentOfInertia.FromMegatonneSquareMilimeters(2), 2.MegatonneSquareMilimeters());
static void Main(string[] args)
{
// nema17 - 24v datasheet
var MOTOR_TYPE = "nema17";
var MOTOR_VOLTAGE = ElectricPotentialDc.FromVoltsDc(24);
var SPEED_MAX = RotationalSpeed.FromRevolutionsPerMinute(200);
var TORQUE_MAX = Torque.FromNewtonMeters(0.4);
// problem data
var MASS = Mass.FromKilograms(2);
var LEVER_ARM_LEN = Length.FromCentimeters(1);
var ROUND_CNT = Angle.FromRevolutions(1d);
var EXECUTION_TIME = Duration.FromSeconds(2);
// config
var TIME_STEP = Duration.FromMilliseconds(1);
// speed required to achieve given ROUND_CNT in EXECUTION_TIME without cruise
var minTargetSpeed = 2 * ROUND_CNT / EXECUTION_TIME;
if (minTargetSpeed > SPEED_MAX)
{
System.Console.WriteLine($"W: given position {ROUND_CNT} round cannot established due to speed_max:{SPEED_MAX.RevolutionsPerSecond} rps vs actual required target speed:{minTargetSpeed.RevolutionsPerSecond} rps");
return;
}
// s:target speed
var s = minTargetSpeed;
// d:duration
var d = EXECUTION_TIME;
var minHoldingTorque = Torque.FromKilogramForceCentimeters(MASS.Kilograms * LEVER_ARM_LEN.Centimeters);
if (minHoldingTorque > TORQUE_MAX)
{
System.Console.WriteLine($"W: given mass {MASS} at lever arm distance {LEVER_ARM_LEN} generate {minHoldingTorque.KilogramForceCentimeters} kgfcm torque versus max {TORQUE_MAX.KilogramForceCentimeters} kgfcm");
return;
}
var minDynAccel = RotationalAcceleration.FromRevolutionsPerSecondSquared(4 * s.RevolutionsPerSecond / d.Seconds);
var I = MassMomentOfInertia.FromKilogramSquareCentimeters(MASS.Kilograms * Pow(LEVER_ARM_LEN.Centimeters, 2));
// torque = inertia * angularaccel
// F:[M*L*T-2]*r:[L] = I:[M*L2]*a:[T-2]
// [M*L2*T-2] = [M*L2*T-2]
var minDynTorque = Torque.FromKilogramForceMeters(I.KilogramSquareMeters * minDynAccel.RadiansPerSecondSquared);
if (minDynTorque > TORQUE_MAX)
{
System.Console.WriteLine($"W: accelerating given mass {MASS} at angaccel {minDynAccel} generates torque {minDynTorque.NewtonCentimeters} Ncm great than max {TORQUE_MAX.NewtonCentimeters} Ncm");
return;
}
var srcPathfilename = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "template.xlsx");
var dstPathfilename = "output.xlsx";
File.Copy(srcPathfilename, dstPathfilename, true);
using (var wb = new ClosedXML.Excel.XLWorkbook(dstPathfilename))
{
var ws = wb.Worksheets.First();
IXLCell cell = null;
Action <int, int, object> setCell = (r, c, val) =>
{
cell = ws.Cell(r, c);
cell.Value = val;
};
Action <int, int, object> setCellBold = (r, c, val) =>
{
cell = ws.Cell(r, c);
cell.Value = val;
cell.Style.Font.SetBold();
};
var row = 1;
int col = 1;
var colTime = col++;
var colAccel = col++;
var colSpeed = col++;
var colPosRot = col++;
setCellBold(row, colTime, "TIME (s)");
setCellBold(row, colAccel, "ACCEL (rps2)");
setCellBold(row, colSpeed, "SPEED (rps)");
setCellBold(row, colPosRot, "POS (rot)");
++row;
var t = Duration.FromSeconds(0);
var tMax = t + EXECUTION_TIME;
var halfTMax = tMax / 2;
ws.Cell("MotorType").Value = MOTOR_TYPE;
ws.Cell("MotorSpeedMax").Value = SPEED_MAX;
ws.Cell("MotorTorqueMaxAtSpeedMax").Value = TORQUE_MAX;
ws.Cell("MotorVoltage").Value = MOTOR_VOLTAGE;
ws.Cell("ProblemDuration").Value = EXECUTION_TIME;
ws.Cell("ProblemLoadLeverArmLength").Value = LEVER_ARM_LEN;
ws.Cell("ProblemLoadMass").Value = MASS;
ws.Cell("ProblemRevolutions").Value = ROUND_CNT;
ws.Cell("ResultingTorque").Value = minDynTorque.ToUnit(TorqueUnit.NewtonMeter);
ws.Cell("ResultingAccel").Value = minDynAccel;
ws.Cell("ResultingSpeedMax").Value = minTargetSpeed.ToUnit(RotationalSpeedUnit.RevolutionPerMinute);
var tEps = Duration.FromNanoseconds(1);
while (t.LessThanOrEqualsTol(tEps, tMax))
{
setCell(row, colTime, t.Seconds);
var accel = RotationalAcceleration.FromRevolutionsPerSecondSquared(0);
var speed = RotationalSpeed.FromRevolutionsPerSecond(0);
var pos = Angle.FromRevolutions(0);
if (t.LessThanOrEqualsTol(tEps, halfTMax))
{
accel = RotationalAcceleration.FromRevolutionsPerSecondSquared(
2 * s.RevolutionsPerSecond / d.Seconds * (1 - Cos(4 * PI * t / d)));
speed = RotationalSpeed.FromRevolutionsPerSecond(
2 * s.RevolutionsPerSecond / d.Seconds * (t - d * Sin(4 * PI * t / d) / (4 * PI)).Seconds);
pos = s * d * (Cos(4 * PI * t / d) - 1) / (8 * Pow(PI, 2)) + (s * t) * (t / d);
}
if (t.GreatThanOrEqualsTol(tEps, halfTMax))
{
var th = t - d / 2;
accel = RotationalAcceleration.FromRevolutionsPerSecondSquared(
2 * s.RevolutionsPerSecond / d.Seconds * (Cos(4 * PI * th / d) - 1));
speed = RotationalSpeed.FromRevolutionsPerSecond(
2 * s.RevolutionsPerSecond * Sin(4 * PI * th / d) / (4 * PI)
- (2 * s * th / d - s).RevolutionsPerSecond);
pos = s * d * (1 - Cos(4 * PI * th / d)) / (8 * Pow(PI, 2)) - (s * th) * (th / d) + s * th + s * d / 4;
}
setCell(row, colAccel, accel.RevolutionsPerSecondSquared);
setCell(row, colSpeed, speed.RevolutionsPerSecond);
setCell(row, colPosRot, pos.Revolutions);
++row;
t += TIME_STEP;
}
wb.Save();
}
}
public void NumberToMilligramSquareMetersTest() => Assert.Equal(MassMomentOfInertia.FromMilligramSquareMeters(2), 2.MilligramSquareMeters());
public static MassMomentOfInertia PoundSquareInches <T>(this T value) => MassMomentOfInertia.FromPoundSquareInches(Convert.ToDecimal(value));
public void FromKilogramSquareMeters_WithInfinityValue_ThrowsArgumentException()
{
Assert.Throws <ArgumentException>(() => MassMomentOfInertia.FromKilogramSquareMeters(double.PositiveInfinity));
Assert.Throws <ArgumentException>(() => MassMomentOfInertia.FromKilogramSquareMeters(double.NegativeInfinity));
}