public static void ImplicitOperator()
{
double angleRadians = Numbers.PiOver4;
AngularOffset offset = new AngularOffset(new Angle(0), new Angle(angleRadians));
Assert.AreEqual(angleRadians, (double)offset);
}
public static void DivideOverride_Divides_Coordinate_by_a_Scaling_Factor(double angleRadians, double factor, double scaledAngle)
{
AngularOffset offset = new AngularOffset(new Angle(), new Angle(angleRadians));
AngularOffset offsetNew = offset / factor;
Assert.AreEqual(scaledAngle, offsetNew.Delta().Radians, Tolerance);
}
public static void LengthArc_Returns_Curve_Line_Distance_Between_Offset_Points_of_Specified_Radius(double angleRadians, double radius, double expectedResult)
{
Angle angle1 = new Angle(0);
Angle angle2 = new Angle(angleRadians);
AngularOffset offset = new AngularOffset(angle1, angle2);
Assert.AreEqual(expectedResult, offset.LengthArc(radius), Tolerance);
}
//TODO Useful? Not used yet
///// <summary>
///// The length between the provided points along a circular curve, assumed to be about the origin.
///// </summary>
///// <param name="pointI">Point i.</param>
///// <param name="pointJ">Point j.</param>
///// <returns>System.Double.</returns>
//public static double LengthBetween(CartesianCoordinate pointI, CartesianCoordinate pointJ)
//{
// AngularOffset angle = AngularOffset.CreateFromPoints(pointI, CartesianCoordinate.Origin(), pointJ);
// double radius = pointI.OffsetFrom(CartesianCoordinate.Origin()).Length();
// return LengthBetween(angle, radius);
//}
///// <summary>
///// The length between the provided points along a circular curve.
///// </summary>
///// <param name="pointI">Point i.</param>
///// <param name="pointJ">Point j.</param>
///// <param name="radius">Arc radius</param>
///// <returns>System.Double.</returns>
//public static double LengthBetween(CartesianCoordinate pointI, CartesianCoordinate pointJ, double radius)
//{
// IntersectionCircularCircular intersection = new IntersectionCircularCircular(
// new CircularCurve(radius, pointI),
// new CircularCurve(radius, pointJ));
// // Shape is symmetric, so it doesn't matter if the 1st or 2nd intersection coordinate is taken.
// CartesianCoordinate center = intersection.IntersectionCoordinates()[0];
// AngularOffset angle = AngularOffset.CreateFromPoints(pointI, center, pointJ);
// return LengthBetween(angle, radius);
//}
/// <summary>
/// The length within the provided rotation along a circular curve.
/// </summary>
/// <param name="rotation">Rotation to get arc length between.</param>
/// <param name="radius">Arc radius</param>
/// <returns>System.Double.</returns>
public static double LengthBetween(AngularOffset rotation, double radius)
{
double length = rotation.LengthArc(radius);
return((length.IsZeroSign(rotation.Tolerance) && !rotation.Delta().Radians.IsZeroSign(rotation.Tolerance)) ?
Numbers.TwoPi * radius :
length);
}
public static void LengthChord_Returns_Straight_Line_Distance_Between_Offset_Points_of_Unit_Radius(double angleRadians, double expectedResult)
{
Angle angle1 = new Angle(0);
Angle angle2 = new Angle(angleRadians);
AngularOffset offset = new AngularOffset(angle1, angle2);
Assert.AreEqual(expectedResult, offset.LengthChord(), Tolerance);
}
public static void AngularOffset_Initialization_with_Offsets()
{
double tolerance = 0.5;
AngularOffset offset = new AngularOffset(2, tolerance);
Assert.AreEqual(0, offset.I.Radians);
Assert.AreEqual(2, offset.J.Radians);
Assert.AreEqual(tolerance, offset.Tolerance);
}
public static void OffsetFrom_Returns_Offset_Coordinate(double radiansI, double radiansJ)
{
Angle angle1 = new Angle(radiansJ);
Angle angle2 = new Angle(radiansI);
AngularOffset offset = angle1.OffsetFrom(angle2);
Assert.AreEqual(radiansI, offset.I.Radians, Tolerance);
Assert.AreEqual(radiansJ, offset.J.Radians, Tolerance);
}
public static void Hashcode_Matches_for_Object_with_Identical_Angles()
{
double angleRadians = 5.3;
double tolerance = 0.0002;
AngularOffset offset1 = new AngularOffset(new Angle(), new Angle(angleRadians), tolerance);
AngularOffset offset2 = new AngularOffset(new Angle(), new Angle(angleRadians), tolerance);
Assert.AreEqual(offset1.GetHashCode(), offset2.GetHashCode());
}
public static void Delta_Returns_Angle_of_Rotation_Difference()
{
Angle angle1 = new Angle(Numbers.PiOver2);
Angle angle2 = new Angle(Numbers.PiOver4);
AngularOffset offset = new AngularOffset(angle1, angle2);
Angle angleFromOffset = offset.Delta();
Assert.AreEqual(-Numbers.PiOver4, angleFromOffset.Radians, Tolerance);
}
public static void ToAngle_Returns_Angle_of_Offset()
{
Angle angle1 = new Angle(Numbers.PiOver2);
Angle angle2 = new Angle(Numbers.PiOver4);
AngularOffset offset = new AngularOffset(angle1, angle2);
Angle angleFromOffset = offset.ToAngle();
Assert.AreEqual(-Numbers.PiOver4, angleFromOffset.Radians, Tolerance);
}
public static void AngularOffset_InitializationWithDefaultTolerance()
{
Angle angle1 = new Angle(1);
Angle angle2 = new Angle(3);
AngularOffset offset = new AngularOffset(angle1, angle2);
Assert.AreEqual(angle1.Radians, offset.I.Radians);
Assert.AreEqual(angle2.Radians, offset.J.Radians);
Assert.AreEqual(Numbers.ZeroTolerance, offset.Tolerance);
}
public static void AngularOffset_Initialization_with_Coordinates()
{
Angle angle1 = new Angle(1);
Angle angle2 = new Angle(3);
double tolerance = 0.5;
AngularOffset offset = new AngularOffset(angle1, angle2, tolerance);
Assert.AreEqual(angle1.Radians, offset.I.Radians);
Assert.AreEqual(angle2.Radians, offset.J.Radians);
Assert.AreEqual(tolerance, offset.Tolerance);
}
public static void NotEqualsOverride_Is_True_for_Object_with_Differing_Angles()
{
double angleRadians = Numbers.PiOver4;
double angleRadiansDiff = Numbers.PiOver2;
double tolerance = 0.0002;
AngularOffset offset = new AngularOffset(new Angle(), new Angle(angleRadians), tolerance);
AngularOffset angleDiff = new AngularOffset(new Angle(), new Angle(angleRadiansDiff), tolerance);
Assert.IsTrue(offset != angleDiff);
Assert.IsTrue(offset != angleRadiansDiff);
Assert.IsTrue(angleRadiansDiff != offset);
}
public static void MultiplyOverride_Multiplies_Coordinate_by_a_Scaling_Factor(double angleRadians, double factor, double scaledAngle)
{
AngularOffset offset = new AngularOffset(new Angle(), new Angle(angleRadians));
AngularOffset offsetNew1 = offset * factor;
Assert.AreEqual(scaledAngle, offsetNew1.Delta().Radians, Tolerance);
AngularOffset offsetNew2 = factor * offset;
Assert.AreEqual(scaledAngle, offsetNew2.Delta().Radians, Tolerance);
}
public static void EqualsOverride_Is_True_for_Object_with_Identical_Angles()
{
double angleRadians = Numbers.PiOver4;
double tolerance = 0.0002;
AngularOffset offset1 = new AngularOffset(new Angle(), new Angle(angleRadians), tolerance);
AngularOffset offset2 = new AngularOffset(new Angle(), new Angle(angleRadians), tolerance);
Assert.IsTrue(offset1.Equals(offset2));
Assert.IsTrue(offset1.Equals((object)offset2));
Assert.IsTrue(offset1 == offset2);
Assert.IsTrue(offset1 == angleRadians);
Assert.IsTrue(angleRadians == offset1);
}
[TestCase(4, 3, 3, 2, 1, 2, 45)] // obtuse deg rotated
public static void CreateFromPoints_Creates_Angular_Offset_Formed_by_3_Points(
double x1, double y1,
double x2, double y2,
double x3, double y3,
double expectedAngleDegrees)
{
CartesianCoordinate point1 = new CartesianCoordinate(x1, y1);
CartesianCoordinate point2 = new CartesianCoordinate(x2, y2);
CartesianCoordinate point3 = new CartesianCoordinate(x3, y3);
AngularOffset offset = AngularOffset.CreateFromPoints(point1, point2, point3);
Assert.AreEqual(expectedAngleDegrees, offset.ToAngle().Degrees, Tolerance);
}
public static void Initialization_with_Coordinates_Results_in_Object_with_Immutable_Coordinates_Properties_List()
{
CartesianCoordinate localOriginInGlobal = new CartesianCoordinate(3, 2);
CartesianCoordinate localAxisXPtInGlobal = new CartesianCoordinate(5, 4);
Transformations transformations = new Transformations(localOriginInGlobal, localAxisXPtInGlobal);
AngularOffset angularOffset = new AngularOffset(Numbers.Pi / 4);
CartesianOffset offset = localOriginInGlobal.OffsetFrom(CartesianCoordinate.Origin());
Assert.AreEqual(localOriginInGlobal, transformations.LocalOrigin);
Assert.AreEqual(localAxisXPtInGlobal, transformations.LocalAxisX);
Assert.AreEqual(offset, transformations.Displacement);
Assert.AreEqual(angularOffset.ToAngle().Degrees, transformations.Rotation.ToAngle().Degrees, Tolerance);
}
public static void Hashcode_Differs_for_Object_with_Differing_Angles()
{
double angleRadians1 = 5.3;
double angleRadians2 = -2;
double tolerance = 0.0002;
AngularOffset offset1 = new AngularOffset(new Angle(), new Angle(angleRadians1), tolerance);
AngularOffset offset2 = new AngularOffset(new Angle(), new Angle(angleRadians2), tolerance);
Assert.AreNotEqual(offset1.GetHashCode(), offset2.GetHashCode());
offset2 = new AngularOffset(new Angle(), new Angle(angleRadians1), 2 * tolerance);
Assert.AreEqual(offset1.GetHashCode(), offset2.GetHashCode());
}
public static void CompareTo_Double()
{
double angleEqual = Numbers.PiOver2;
AngularOffset offset = new AngularOffset(new Angle(0), new Angle(angleEqual));
Assert.AreEqual(0, offset.CompareTo(angleEqual));
double angleGreater = Numbers.Pi;
Assert.AreEqual(-1, offset.CompareTo(angleGreater));
double angleLesser = Numbers.PiOver4;
Assert.AreEqual(1, offset.CompareTo(angleLesser));
}
public static void CompareTo_Angle()
{
AngularOffset offset = new AngularOffset(new Angle(), new Angle(Numbers.PiOver2));
AngularOffset angleEqual = new AngularOffset(new Angle(), new Angle(Numbers.PiOver2));
Assert.AreEqual(0, offset.CompareTo(angleEqual));
AngularOffset angleGreater = new AngularOffset(new Angle(), new Angle(Numbers.Pi));
Assert.AreEqual(-1, offset.CompareTo(angleGreater));
AngularOffset angleLesser = new AngularOffset(new Angle(), new Angle(Numbers.PiOver4));
Assert.AreEqual(1, offset.CompareTo(angleLesser));
}
public static void EqualsOverride_Is_False_for_Object_with_Differing_Angles()
{
double angleRadians = Numbers.PiOver4;
double tolerance = 0.0002;
AngularOffset offset = new AngularOffset(new Angle(), new Angle(angleRadians), tolerance);
AngularOffset offsetDiff = new AngularOffset(new Angle(), new Angle(Numbers.PiOver2), tolerance);
Assert.IsFalse(offset == offsetDiff);
AngularOffset offsetDiffT = new AngularOffset(new Angle(), new Angle(angleRadians), 0.001);
Assert.IsTrue(offset == offsetDiffT);
object obj = new object();
Assert.IsFalse(offset.Equals(obj));
}
public static void SubtractOverride_Returns_Difference_of_Coordinates(double angleRadians1, double angleRadians2, double angleResult)
{
AngularOffset offset1 = new AngularOffset(new Angle(), new Angle(angleRadians1));
AngularOffset offset2 = new AngularOffset(new Angle(), new Angle(angleRadians2));
AngularOffset offset3 = offset1 - offset2;
Assert.AreEqual(angleResult, offset3.Delta().Radians, Tolerance);
AngularOffset offset4 = offset1 - angleRadians2;
Assert.AreEqual(angleResult, offset4.Delta().Radians, Tolerance);
AngularOffset offset5 = angleRadians1 - offset2;
Assert.AreEqual(angleResult, offset5.Delta().Radians, Tolerance);
}
public static void AddOverride_Returns_Combined_Coordinates(double angleRadians1, double angleRadians2, double angleResult)
{
AngularOffset offset1 = new AngularOffset(new Angle(), new Angle(angleRadians1));
AngularOffset offset2 = new AngularOffset(new Angle(), new Angle(angleRadians2));
AngularOffset offset3 = offset1 + offset2;
Assert.AreEqual(angleResult, offset3.Delta().Radians, Tolerance);
AngularOffset offset4 = offset1 + angleRadians2;
Assert.AreEqual(angleResult, offset4.Delta().Radians, Tolerance);
AngularOffset offset5 = angleRadians1 + offset2;
Assert.AreEqual(angleResult, offset5.Delta().Radians, Tolerance);
}
/// <summary>
/// Initializes a new instance of the <see cref="Transformations"/> class.
/// </summary>
/// <param name="localOriginInGlobal">The local origin in global coordinates.</param>
/// <param name="localAxisXPtInGlobal">Any point along the local x-axis in global coordinates.</param>
public Transformations(CartesianCoordinate localOriginInGlobal, CartesianCoordinate localAxisXPtInGlobal)
{
LocalOrigin = localOriginInGlobal;
LocalAxisX = localAxisXPtInGlobal;
Displacement = localOriginInGlobal.OffsetFrom(CartesianCoordinate.Origin());
if (localAxisXPtInGlobal.Y == localOriginInGlobal.Y)
{
Rotation = new AngularOffset();
}
else
{
Rotation = AngularOffset.CreateFromPoints(
localAxisXPtInGlobal,
localOriginInGlobal,
new CartesianCoordinate(localOriginInGlobal.X - 1, localOriginInGlobal.Y)
);
}
}
public static void LesserThanOrEqualToOverride()
{
double angleRadiansEqual = Numbers.PiOver2;
AngularOffset offset = new AngularOffset(new Angle(), new Angle(angleRadiansEqual));
AngularOffset angleEqual = new AngularOffset(new Angle(), new Angle(angleRadiansEqual));
Assert.IsTrue(offset <= angleEqual);
Assert.IsTrue(offset <= angleRadiansEqual);
Assert.IsTrue(angleRadiansEqual <= offset);
double angleRadiansGreater = Numbers.Pi;
AngularOffset angleGreater = new AngularOffset(new Angle(), new Angle(angleRadiansGreater));
Assert.IsTrue(offset <= angleGreater);
Assert.IsFalse(angleRadiansGreater <= offset);
Assert.IsFalse(angleRadiansGreater <= offset);
double angleRadiansLesser = Numbers.PiOver4;
AngularOffset angleLesser = new AngularOffset(new Angle(), new Angle(angleRadiansLesser));
Assert.IsFalse(offset <= angleLesser);
Assert.IsFalse(offset <= angleRadiansLesser);
Assert.IsTrue(angleRadiansLesser <= offset);
}
/// <summary> /// The length within the provided rotation along an elliptical curve. /// </summary> /// <param name="rotation">Rotation to get arc length between.</param> /// <returns>System.Double.</returns> public abstract double LengthBetween(AngularOffset rotation);
/// <summary>
/// The length within the provided rotation along a circular curve.
/// </summary>
/// <param name="rotation">Rotation to get arc length between.</param>
/// <returns>System.Double.</returns>
public override double LengthBetween(AngularOffset rotation)
{
return(LengthBetween(rotation, Radius));
}
public static void ToString_Returns_Overridden_Value()
{
AngularOffset offset = new AngularOffset(new Angle(0.1), new Angle(0.5));
Assert.AreEqual("MPT.Math.Coordinates.AngularOffset - Radians_i: 0.1 - Radians_j: 0.5", offset.ToString());
}
/// <summary>
/// The length within the provided rotation along a circular curve.
/// </summary>
/// <param name="rotation">Rotation to get arc length between.</param>
/// <returns>System.Double.</returns>
public double LengthBetween(AngularOffset rotation)
{
return(LengthTo(rotation.J.RadiansRaw) - LengthTo(rotation.I.RadiansRaw));
}
public static void DivideOverride_Throws_Exception_when_Dividing_by_Zero()
{
AngularOffset offset = new AngularOffset(new Angle(1), new Angle(2));
Assert.Throws <DivideByZeroException>(() => { AngularOffset offsetNew = offset / 0; });
}
