public void ConversionRoundTrip()
{
RotationalAcceleration radianpersecondsquared = RotationalAcceleration.FromRadiansPerSecondSquared(1);
AssertEx.EqualTolerance(1, RotationalAcceleration.FromDegreesPerSecondSquared(radianpersecondsquared.DegreesPerSecondSquared).RadiansPerSecondSquared, DegreesPerSecondSquaredTolerance);
AssertEx.EqualTolerance(1, RotationalAcceleration.FromRadiansPerSecondSquared(radianpersecondsquared.RadiansPerSecondSquared).RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
AssertEx.EqualTolerance(1, RotationalAcceleration.FromRevolutionsPerMinutePerSecond(radianpersecondsquared.RevolutionsPerMinutePerSecond).RadiansPerSecondSquared, RevolutionsPerMinutePerSecondTolerance);
AssertEx.EqualTolerance(1, RotationalAcceleration.FromRevolutionsPerSecondSquared(radianpersecondsquared.RevolutionsPerSecondSquared).RadiansPerSecondSquared, RevolutionsPerSecondSquaredTolerance);
}
public void As()
{
var radianpersecondsquared = RotationalAcceleration.FromRadiansPerSecondSquared(1);
AssertEx.EqualTolerance(DegreesPerSecondSquaredInOneRadianPerSecondSquared, radianpersecondsquared.As(RotationalAccelerationUnit.DegreePerSecondSquared), DegreesPerSecondSquaredTolerance);
AssertEx.EqualTolerance(RadiansPerSecondSquaredInOneRadianPerSecondSquared, radianpersecondsquared.As(RotationalAccelerationUnit.RadianPerSecondSquared), RadiansPerSecondSquaredTolerance);
AssertEx.EqualTolerance(RevolutionsPerMinutePerSecondInOneRadianPerSecondSquared, radianpersecondsquared.As(RotationalAccelerationUnit.RevolutionPerMinutePerSecond), RevolutionsPerMinutePerSecondTolerance);
AssertEx.EqualTolerance(RevolutionsPerSecondSquaredInOneRadianPerSecondSquared, radianpersecondsquared.As(RotationalAccelerationUnit.RevolutionPerSecondSquared), RevolutionsPerSecondSquaredTolerance);
}
public void Equals_QuantityAsObject_IsImplemented()
{
object a = RotationalAcceleration.FromRadiansPerSecondSquared(1);
object b = RotationalAcceleration.FromRadiansPerSecondSquared(2);
Assert.True(a.Equals(a));
Assert.False(a.Equals(b));
Assert.False(a.Equals((object)null));
}
public void EqualsIsImplemented()
{
var a = RotationalAcceleration.FromRadiansPerSecondSquared(1);
var b = RotationalAcceleration.FromRadiansPerSecondSquared(2);
Assert.True(a.Equals(a));
Assert.False(a.Equals(b));
Assert.False(a.Equals(null));
}
public void ArithmeticOperators()
{
RotationalAcceleration v = RotationalAcceleration.FromRadiansPerSecondSquared(1);
AssertEx.EqualTolerance(-1, -v.RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
AssertEx.EqualTolerance(2, (RotationalAcceleration.FromRadiansPerSecondSquared(3) - v).RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
AssertEx.EqualTolerance(2, (v + v).RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
AssertEx.EqualTolerance(10, (v * 10).RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
AssertEx.EqualTolerance(10, (10 * v).RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
AssertEx.EqualTolerance(2, (RotationalAcceleration.FromRadiansPerSecondSquared(10) / 5).RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
AssertEx.EqualTolerance(2, RotationalAcceleration.FromRadiansPerSecondSquared(10) / RotationalAcceleration.FromRadiansPerSecondSquared(5), RadiansPerSecondSquaredTolerance);
}
public void EqualityOperators()
{
RotationalAcceleration a = RotationalAcceleration.FromRadiansPerSecondSquared(1);
RotationalAcceleration b = RotationalAcceleration.FromRadiansPerSecondSquared(2);
// ReSharper disable EqualExpressionComparison
Assert.True(a == a);
Assert.True(a != b);
Assert.False(a == b);
Assert.False(a != a);
// ReSharper restore EqualExpressionComparison
}
public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
{
var quantity = new RotationalAcceleration(value: 1, unit: RotationalAcceleration.BaseUnit);
Func <object> AsWithSIUnitSystem = () => quantity.As(UnitSystem.SI);
if (SupportsSIUnitSystem)
{
var value = (double)AsWithSIUnitSystem();
Assert.Equal(1, value);
}
else
{
Assert.Throws <ArgumentException>(AsWithSIUnitSystem);
}
}
public void ComparisonOperators()
{
RotationalAcceleration oneRadianPerSecondSquared = RotationalAcceleration.FromRadiansPerSecondSquared(1);
RotationalAcceleration twoRadiansPerSecondSquared = RotationalAcceleration.FromRadiansPerSecondSquared(2);
Assert.True(oneRadianPerSecondSquared < twoRadiansPerSecondSquared);
Assert.True(oneRadianPerSecondSquared <= twoRadiansPerSecondSquared);
Assert.True(twoRadiansPerSecondSquared > oneRadianPerSecondSquared);
Assert.True(twoRadiansPerSecondSquared >= oneRadianPerSecondSquared);
Assert.False(oneRadianPerSecondSquared > twoRadiansPerSecondSquared);
Assert.False(oneRadianPerSecondSquared >= twoRadiansPerSecondSquared);
Assert.False(twoRadiansPerSecondSquared < oneRadianPerSecondSquared);
Assert.False(twoRadiansPerSecondSquared <= oneRadianPerSecondSquared);
}
public void RotationalAcceleration_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
{
var quantity = new RotationalAcceleration(1, RotationalAccelerationUnit.RadianPerSecondSquared);
QuantityInfo <RotationalAccelerationUnit> quantityInfo = quantity.QuantityInfo;
Assert.Equal(RotationalAcceleration.Zero, quantityInfo.Zero);
Assert.Equal("RotationalAcceleration", quantityInfo.Name);
Assert.Equal(QuantityType.RotationalAcceleration, quantityInfo.QuantityType);
var units = EnumUtils.GetEnumValues <RotationalAccelerationUnit>().Except(new[] { RotationalAccelerationUnit.Undefined }).ToArray();
var unitNames = units.Select(x => x.ToString());
// Obsolete members
Assert.Equal(units, quantityInfo.Units);
Assert.Equal(unitNames, quantityInfo.UnitNames);
}
public void ToUnit()
{
var radianpersecondsquared = RotationalAcceleration.FromRadiansPerSecondSquared(1);
var degreepersecondsquaredQuantity = radianpersecondsquared.ToUnit(RotationalAccelerationUnit.DegreePerSecondSquared);
AssertEx.EqualTolerance(DegreesPerSecondSquaredInOneRadianPerSecondSquared, (double)degreepersecondsquaredQuantity.Value, DegreesPerSecondSquaredTolerance);
Assert.Equal(RotationalAccelerationUnit.DegreePerSecondSquared, degreepersecondsquaredQuantity.Unit);
var radianpersecondsquaredQuantity = radianpersecondsquared.ToUnit(RotationalAccelerationUnit.RadianPerSecondSquared);
AssertEx.EqualTolerance(RadiansPerSecondSquaredInOneRadianPerSecondSquared, (double)radianpersecondsquaredQuantity.Value, RadiansPerSecondSquaredTolerance);
Assert.Equal(RotationalAccelerationUnit.RadianPerSecondSquared, radianpersecondsquaredQuantity.Unit);
var revolutionperminutepersecondQuantity = radianpersecondsquared.ToUnit(RotationalAccelerationUnit.RevolutionPerMinutePerSecond);
AssertEx.EqualTolerance(RevolutionsPerMinutePerSecondInOneRadianPerSecondSquared, (double)revolutionperminutepersecondQuantity.Value, RevolutionsPerMinutePerSecondTolerance);
Assert.Equal(RotationalAccelerationUnit.RevolutionPerMinutePerSecond, revolutionperminutepersecondQuantity.Unit);
}
public void EqualityOperators()
{
var a = RotationalAcceleration.FromRadiansPerSecondSquared(1);
var b = RotationalAcceleration.FromRadiansPerSecondSquared(2);
#pragma warning disable CS8073
// ReSharper disable EqualExpressionComparison
Assert.True(a == a);
Assert.False(a != a);
Assert.True(a != b);
Assert.False(a == b);
Assert.False(a == null);
Assert.False(null == a);
// ReSharper restore EqualExpressionComparison
#pragma warning restore CS8073
}
/// <summary>
/// The standard description of motion including hydrodynamics.
/// </summary>
/// <param name="gravity">
/// The gravity (volume forces) acting on the particle.
/// </param>
/// <param name="density">
/// The density of the particle.
/// </param>
public Motion(Vector gravity, double density)
{
if (gravity.IsNullOrEmpty())
{
gravity = new Vector(0, 0);
}
Gravity = new Vector(gravity);
Density = density;
for (int i = 0; i < NumberOfHistoryEntries; i++)
{
Position.Add(new Vector(SpatialDim));
TranslationalVelocity.Add(new Vector(SpatialDim));
TranslationalAcceleration.Add(new Vector(SpatialDim));
HydrodynamicForces.Add(new Vector(SpatialDim));
Angle.Add(new double());
RotationalVelocity.Add(new double());
RotationalAcceleration.Add(new double());
HydrodynamicTorque.Add(new double());
}
}
public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
{
var quantity00 = RotationalAcceleration.From(1, RotationalAccelerationUnit.DegreePerSecondSquared);
AssertEx.EqualTolerance(1, quantity00.DegreesPerSecondSquared, DegreesPerSecondSquaredTolerance);
Assert.Equal(RotationalAccelerationUnit.DegreePerSecondSquared, quantity00.Unit);
var quantity01 = RotationalAcceleration.From(1, RotationalAccelerationUnit.RadianPerSecondSquared);
AssertEx.EqualTolerance(1, quantity01.RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
Assert.Equal(RotationalAccelerationUnit.RadianPerSecondSquared, quantity01.Unit);
var quantity02 = RotationalAcceleration.From(1, RotationalAccelerationUnit.RevolutionPerMinutePerSecond);
AssertEx.EqualTolerance(1, quantity02.RevolutionsPerMinutePerSecond, RevolutionsPerMinutePerSecondTolerance);
Assert.Equal(RotationalAccelerationUnit.RevolutionPerMinutePerSecond, quantity02.Unit);
var quantity03 = RotationalAcceleration.From(1, RotationalAccelerationUnit.RevolutionPerSecondSquared);
AssertEx.EqualTolerance(1, quantity03.RevolutionsPerSecondSquared, RevolutionsPerSecondSquaredTolerance);
Assert.Equal(RotationalAccelerationUnit.RevolutionPerSecondSquared, quantity03.Unit);
}
public void Convert_ToUInt64_EqualsValueAsSameType()
{
var quantity = RotationalAcceleration.FromRadiansPerSecondSquared(1.0);
Assert.Equal((ulong)quantity.Value, Convert.ToUInt64(quantity));
}
public void Convert_ToSingle_EqualsValueAsSameType()
{
var quantity = RotationalAcceleration.FromRadiansPerSecondSquared(1.0);
Assert.Equal((float)quantity.Value, Convert.ToSingle(quantity));
}
public void NegationOperator_ReturnsQuantity_WithNegatedValue(double value)
{
var quantity = RotationalAcceleration.FromRadiansPerSecondSquared(value);
Assert.Equal(RotationalAcceleration.FromRadiansPerSecondSquared(-value), -quantity);
}
public void FromRadiansPerSecondSquared_WithNanValue_ThrowsArgumentException()
{
Assert.Throws <ArgumentException>(() => RotationalAcceleration.FromRadiansPerSecondSquared(double.NaN));
}
public void Convert_ChangeType_InvalidType_ThrowsInvalidCastException()
{
var quantity = RotationalAcceleration.FromRadiansPerSecondSquared(1.0);
Assert.Throws <InvalidCastException>(() => Convert.ChangeType(quantity, typeof(QuantityFormatter)));
}
public void GetHashCode_Equals()
{
var quantity = RotationalAcceleration.FromRadiansPerSecondSquared(1.0);
Assert.Equal(new { RotationalAcceleration.Info.Name, quantity.Value, quantity.Unit }.GetHashCode(), quantity.GetHashCode());
}
public void Convert_ChangeType_BaseDimensions_EqualsBaseDimensions()
{
var quantity = RotationalAcceleration.FromRadiansPerSecondSquared(1.0);
Assert.Equal(RotationalAcceleration.BaseDimensions, Convert.ChangeType(quantity, typeof(BaseDimensions)));
}
public void Convert_ToString_EqualsToString()
{
var quantity = RotationalAcceleration.FromRadiansPerSecondSquared(1.0);
Assert.Equal(quantity.ToString(), Convert.ToString(quantity));
}
public void FromValueAndUnit()
{
AssertEx.EqualTolerance(1, RotationalAcceleration.From(1, RotationalAccelerationUnit.DegreePerSecondSquared).DegreesPerSecondSquared, DegreesPerSecondSquaredTolerance);
AssertEx.EqualTolerance(1, RotationalAcceleration.From(1, RotationalAccelerationUnit.RadianPerSecondSquared).RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
AssertEx.EqualTolerance(1, RotationalAcceleration.From(1, RotationalAccelerationUnit.RevolutionPerMinutePerSecond).RevolutionsPerMinutePerSecond, RevolutionsPerMinutePerSecondTolerance);
}
public void EqualsReturnsFalseOnTypeMismatch()
{
RotationalAcceleration radianpersecondsquared = RotationalAcceleration.FromRadiansPerSecondSquared(1);
Assert.False(radianpersecondsquared.Equals(new object()));
}
public void CompareToThrowsOnTypeMismatch()
{
RotationalAcceleration radianpersecondsquared = RotationalAcceleration.FromRadiansPerSecondSquared(1);
Assert.Throws <ArgumentException>(() => radianpersecondsquared.CompareTo(new object()));
}
public void CompareToThrowsOnNull()
{
RotationalAcceleration radianpersecondsquared = RotationalAcceleration.FromRadiansPerSecondSquared(1);
Assert.Throws <ArgumentNullException>(() => radianpersecondsquared.CompareTo(null));
}
public void Convert_ChangeType_SelfType_EqualsSelf()
{
var quantity = RotationalAcceleration.FromRadiansPerSecondSquared(1.0);
Assert.Equal(quantity, Convert.ChangeType(quantity, typeof(RotationalAcceleration)));
}
public void EqualsReturnsFalseOnNull()
{
RotationalAcceleration radianpersecondsquared = RotationalAcceleration.FromRadiansPerSecondSquared(1);
Assert.False(radianpersecondsquared.Equals(null));
}
public void Convert_ChangeType_UnitType_EqualsUnit()
{
var quantity = RotationalAcceleration.FromRadiansPerSecondSquared(1.0);
Assert.Equal(quantity.Unit, Convert.ChangeType(quantity, typeof(RotationalAccelerationUnit)));
}
public void FromRadiansPerSecondSquared_WithInfinityValue_ThrowsArgumentException()
{
Assert.Throws <ArgumentException>(() => RotationalAcceleration.FromRadiansPerSecondSquared(double.PositiveInfinity));
Assert.Throws <ArgumentException>(() => RotationalAcceleration.FromRadiansPerSecondSquared(double.NegativeInfinity));
}
public void Convert_ChangeType_QuantityInfo_EqualsQuantityInfo()
{
var quantity = RotationalAcceleration.FromRadiansPerSecondSquared(1.0);
Assert.Equal(RotationalAcceleration.Info, Convert.ChangeType(quantity, typeof(QuantityInfo)));
}
