/// <summary> /// Returns a regular polygon sized by the inradius. /// </summary> /// <param name="numberOfSides">The number of sides.</param> /// <param name="inRadius">The inradius.</param> /// <returns>RegularPolygon.</returns> public static RegularPolygon RegularPolygonByInradius(int numberOfSides, double inRadius) { numberOfSides = NMath.Max(_minNumberOfSides, numberOfSides.Abs()); double circumRadius = inRadius.Abs() * Trig.Sec(Numbers.Pi / numberOfSides); return(new RegularPolygon(numberOfSides, circumRadius)); }
/// <summary> /// Initializes a new instance of the <see cref="IsoscelesTriangle" /> class. /// </summary> /// <param name="lengthB">The length b, of the base of the triangle. This is the unequal length.</param> /// <param name="anglesEqualAlpha">The two angles of equal magnitude, α, which are opposite of the two sides of equal length.</param> public IsoscelesTriangle(double lengthB, Angle anglesEqualAlpha) { _sidesEqual = 0.5 * lengthB / Trig.Cos(anglesEqualAlpha.Radians); _sideUnequal = lengthB; SetCoordinates(LocalCoordinates()); setCenterCoordinates(); }
/// <summary> /// Rotates the specified coordinate by the specifed angle about the origin. /// </summary> /// <param name="coordinate">The coordinate.</param> /// <param name="angleRadians">The angle [radians], where counter-clockwise is positive.</param> /// <returns>MPT.Math.Coordinates.CartesianCoordinate.</returns> public static CartesianCoordinate Rotate(CartesianCoordinate coordinate, double angleRadians) { double xRotated = coordinate.X * Trig.Cos(angleRadians) - coordinate.Y * Trig.Sin(angleRadians); double yRotated = coordinate.X * Trig.Sin(angleRadians) + coordinate.Y * Trig.Cos(angleRadians); return(new CartesianCoordinate(xRotated, yRotated)); }
/// <summary> /// Converts to Cartesian coordinates. /// </summary> /// <returns>CartesianCoordinate.</returns> public static CartesianCoordinate ToCartesian(PolarCoordinate coordinate) { double x = coordinate.Radius * Trig.Cos(coordinate.Azimuth.Radians); double y = coordinate.Radius * Trig.Sin(coordinate.Azimuth.Radians); return(new CartesianCoordinate(x, y, coordinate.Tolerance)); }
/// <summary> /// Sets the orthocenter. /// </summary> protected void setOrthocenter() { // If any angle is 90 degrees, the orthocenter lies at the vertex at that angle double angleA = getAngleA(); if (angleA.IsEqualTo(Num.PiOver2, 10E-10)) { OrthoCenter = PointA; return; } double angleB = getAngleB(); if (angleB.IsEqualTo(Num.PiOver2, 10E-10)) { OrthoCenter = PointB; return; } double angleC = getAngleC(); if (angleC.IsEqualTo(Num.PiOver2, 10E-10)) { OrthoCenter = PointC; return; } double denominator = Trig.Tan(angleA) + Trig.Tan(angleB) + Trig.Tan(angleC); OrthoCenter = new CartesianCoordinate( (PointA.X * Trig.Tan(angleA) + PointB.X * Trig.Tan(angleB) + PointC.X * Trig.Tan(angleC)) / denominator, (PointA.Y * Trig.Tan(angleA) + PointB.Y * Trig.Tan(angleB) + PointC.Y * Trig.Tan(angleC)) / denominator ); }
/// <summary> /// Returns the positive angle [radians] from the x-axis, counter-clockwise, of the coordinates. /// </summary> /// <param name="x">The x-coordinate.</param> /// <param name="y">The y-coordinate.</param> /// <returns>System.Double.</returns> public static double AsRadians(double x, double y) { if (x.IsZeroSign()) { if (y.IsPositiveSign()) { return(Numbers.Pi / 2); } // 90 deg if (y.IsNegativeSign()) { return((3d / 2) * Numbers.Pi); } // 270 deg return(0); // Assume 0 degrees for origin } double angleOffset = 0; if (x.IsNegativeSign()) // 2nd or 3rd quadrant { angleOffset = Numbers.Pi; } else if (y.IsNegativeSign()) // 4th quadrant { angleOffset = 2 * Numbers.Pi; } return(angleOffset + Trig.ArcTan(y / x)); }
// If a curve is defined in polar coordinates by the radius expressed as a function of the polar angle, that is r is a function of θ /// <summary> /// Slope of the curve based on all differentiated components being the polar radius at θ differentiated by θ. /// <a href="https://socratic.org/questions/how-do-you-find-the-slope-of-a-polar-curve">Reference</a>. /// </summary> /// <param name="thetaRadians">The position θ, in radians.</param> /// <param name="radius">The polar radius at position θ.</param> /// <param name="radiusPrime">The first differential of the polar radius w.r.t. θ.</param> /// <returns>System.Double.</returns> public static double SlopePolar(double thetaRadians, double radius, double radiusPrime) { if ((radius == 0 && radiusPrime == 0) || (thetaRadians == 0 && radiusPrime == 0)) { throw new DivideByZeroException("radius & radiusPrime cannot both be zero."); } return((radiusPrime * Trig.Sin(thetaRadians) + radius * Trig.Cos(thetaRadians)) / (radiusPrime * Trig.Cos(thetaRadians) - radius * Trig.Sin(thetaRadians))); }
/// <summary> /// Initializes a new instance of the <see cref="IsoscelesTriangle" /> class. /// </summary> /// <param name="apexCoordinate">The apex coordinate.</param> public IsoscelesTriangle(CartesianCoordinate apexCoordinate) { double alphaRadians = getAlpha(apexCoordinate.X, apexCoordinate.Y); _sidesEqual = apexCoordinate.X / Trig.Cos(alphaRadians); _sideUnequal = 2 * apexCoordinate.X; SetCoordinates(LocalCoordinates()); setCenterCoordinates(); }
/// <summary> /// Formulates the local coordinates for the shape. /// </summary> /// <returns>IList<CartesianCoordinate>.</returns> public IList <CartesianCoordinate> LocalCoordinates() { double theta; double circumRadius = CircumRadius; List <CartesianCoordinate> coordinates = new List <CartesianCoordinate>(); for (int i = 0; i < _numberOfSides; i++) { theta = i * Numbers.TwoPi / _numberOfSides; coordinates.Add( new CartesianCoordinate( circumRadius * Trig.Cos(theta), circumRadius * Trig.Sin(theta) ) ); } return(coordinates); }
/// <summary> /// Returns a new coordinate offset from the provided coordinate. /// </summary> /// <param name="distance">The distance to offset.</param> /// <param name="center">The center.</param> /// <param name="rotation">The rotation.</param> /// <returns>CartesianCoordinate.</returns> public static CartesianCoordinate OffsetCoordinate(CartesianCoordinate center, double distance, Angle rotation) { double x = center.X + distance * Trig.Cos(rotation.Radians); if (x.IsZeroSign(center.Tolerance)) { x = 0; } double y = center.Y + distance * Trig.Sin(rotation.Radians); if (y.IsZeroSign(center.Tolerance)) { y = 0; } return(new CartesianCoordinate( x, y, center.Tolerance)); }
/// <summary> /// Gets the angle gamma. /// </summary> /// <returns>System.Double.</returns> protected double getAngleC() { return(Trig.ArcCos((SideLengthA().Squared() + SideLengthB().Squared() - SideLengthC().Squared()) / (2 * SideLengthA() * SideLengthB()))); }
/// <summary> /// The differential change in radius corresponding with a differential change in the angle, measured from the focus as a function of the angle in local coordinates. /// </summary> /// <param name="angleRadians">The angle in radians in local coordinates.</param> /// <returns>System.Double.</returns> public override double PrimeByParameter(double angleRadians) { return(-1 * _parent.Eccentricity.Squared() * _parent.DistanceFromFocusToDirectrix * Trig.Sin(angleRadians) / (1 - _parent.Eccentricity * Trig.Cos(angleRadians))); }
/// <summary> /// The radius measured from the focus as a function of the angle in local coordinates. /// <a href="https://web.ma.utexas.edu/users/m408s/m408d/CurrentWeb/LM10-6-3.php">Reference</a> /// </summary> /// <param name="angleRadians">The angle in radians in local coordinates.</param> /// <returns>System.Double.</returns> public override double BaseByParameter(double angleRadians) { return(_parent.Eccentricity * _parent.DistanceFromFocusToDirectrix / (1 - _parent.Eccentricity * Trig.Cos(angleRadians))); }
/// <summary> /// Initializes a new instance of the <see cref="RegularPolygon"/> class. /// </summary> /// <param name="numberOfSides">The number of sides, >= 5</param> /// <param name="circumRadius">The circumradius.</param> public RegularPolygon(int numberOfSides, double circumRadius) { _numberOfSides = NMath.Max(_minNumberOfSides, numberOfSides.Abs()); _lengthOfSides = 2 * circumRadius.Abs() * Trig.Sin(Numbers.Pi / _numberOfSides); SetCoordinates(LocalCoordinates()); }
/// <summary> /// Angle between the tangent of the curve and the radius connecting the origin to the point considered. /// This is in local coordinates about the local origin that corresponds to the parametric coordinate given. /// </summary> /// <param name="angleRadians">Parametric coordinate in radians.</param> /// <returns>System.Double.</returns> public double PolarTangentialAngleAboutOriginByAngle(double angleRadians) { return(Trig.ArcTan(1 / RadiusChangeWithRotation)); }
/// <summary> /// Gets the alpha angle. /// </summary> /// <param name="halfBase">Half of the base width.</param> /// <param name="height">The height.</param> /// <returns>System.Double.</returns> private static double getAlpha(double halfBase, double height) { return(Trig.ArcTan(height / halfBase)); }
/// <summary> /// Primes the double by angle. /// </summary> /// <param name="angleRadians">The angle radians.</param> /// <returns>System.Double.</returns> public override double PrimeDoubleByParameter(double angleRadians) { return(_parent.RadiusAtOrigin * Numbers.E.Pow(_parent.RadiusChangeWithRotation * angleRadians) * 2 * Trig.Cos(angleRadians)); }
/// <summary> /// The coordinate of the handle tip. /// </summary> /// <returns>CartesianCoordinate.</returns> public CartesianCoordinate GetHandleTip() { return(ControlPoint + new CartesianCoordinate(Radius * Trig.Cos(Rotation.Radians), Radius * Trig.Sin(Rotation.Radians), ControlPoint.Tolerance)); }
/// <summary> /// Returns a decagon sized by the inradius. /// </summary> /// <param name="inRadius">The inradius.</param> /// <returns>RegularPolygon.</returns> public static Decagon DecagonByInradius(double inRadius) { double circumRadius = inRadius * Trig.Sec(Numbers.Pi / _setNumberOfSides); return(new Decagon(circumRadius)); }
/// <summary> /// Gets the alpha angle. /// </summary> /// <param name="width">The width.</param> /// <param name="height">The height.</param> /// <returns>System.Double.</returns> protected double getAlpha(double width, double height) { return(Trig.ArcTan(height / width)); }