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; }); }