/// <summary> /// Returns a list of regular polygon's vertices, which has a /// specified amount of sides and is inscribed into /// a circle of certain radius and center point. /// /// The first vertice will be located at specified angle (counting counterclockwise) /// from the circle's rightmost point. /// </summary> /// <param name="sideCount">The total amount of polygon's sides. May be equal to 2 (then the resulting vertices will make up a line).</param> /// <param name="circleCenter">The center of the surrounding circle.</param> /// <param name="circleRadius">The radius of the surrounding circle.</param> /// <param name="initialAngle">The angle (in radians, counting counterclockwise from the circle's rightmost point) at which the first vertice will be located.</param> /// <returns>The list of regular polygon's vertices.</returns> public static List <PointD> RegularPolygonInscribedIntoCircle(int sideCount, PointD circleCenter, double circleRadius, double initialAngle = 0) { // Вектор в ноль градусов. VectorD initialVector = new VectorD(circleCenter, new PointD(circleCenter.X + circleRadius, circleCenter.Y)); List <PointD> points = new List <PointD>(sideCount); // Вектор установлен на начальный угол. if (initialAngle != 0) { initialVector = initialVector.VectorRotatedNewStartPoint(initialAngle, initialVector.StartPoint); } points.Add(initialVector.EndPoint); double rotationAngle = 2 * Math.PI / sideCount; VectorD currentVector; for (int i = 1; i < sideCount; i++) { currentVector = initialVector.VectorRotatedNewStartPoint(i * rotationAngle, initialVector.StartPoint); points.Add(currentVector.EndPoint); } return(points); }
/// <summary> /// Returns a list of regular polygon's vertices, which has a /// specified amount of sides and is inscribed into /// a circle of certain radius and center point. /// /// The first vertice will be located at specified angle (counting counterclockwise) /// from the circle's rightmost point. /// </summary> /// <param name="sideCount">The total amount of polygon's sides. May be equal to 2 (then the resulting vertices will make up a line).</param> /// <param name="circleCenter">The center of the surrounding circle.</param> /// <param name="circleRadius">The radius of the surrounding circle.</param> /// <param name="initialAngle">The angle (in radians, counting counterclockwise from the circle's rightmost point) at which the first vertice will be located.</param> /// <returns>The list of regular polygon's vertices.</returns> public static List<PointD> RegularPolygonInscribedIntoCircle(int sideCount, PointD circleCenter, double circleRadius, double initialAngle = 0) { // Вектор в ноль градусов. VectorD initialVector = new VectorD(circleCenter, new PointD(circleCenter.X + circleRadius, circleCenter.Y)); List<PointD> points = new List<PointD>(sideCount); // Вектор установлен на начальный угол. if(initialAngle != 0) initialVector = initialVector.VectorRotatedNewStartPoint(initialAngle, initialVector.StartPoint); points.Add(initialVector.EndPoint); double rotationAngle = 2 * Math.PI / sideCount; VectorD currentVector; for(int i=1; i<sideCount; i++) { currentVector = initialVector.VectorRotatedNewStartPoint(i * rotationAngle, initialVector.StartPoint); points.Add(currentVector.EndPoint); } return points; }
/// <summary> /// Returns the angle, in radians, that is required by the first vector /// to be rotated counterclockwise to become collinear with the second. /// </summary> /// <param name="first">The first vector.</param> /// <param name="second">The second vector.</param> /// <returns> /// The angle, in radians, that is required by the first vector /// to be rotated counterclockwise to become collinear with the second. /// </returns> public static double angleBetweenVectors(VectorD first, VectorD second) { double x1 = first.X; double y1 = first.Y; double x2 = second.X; double y2 = second.Y; return(Math.Atan2(x1 * y2 - y1 * x2, x1 * x2 + y1 * y2)); }
/// <summary> /// Returns the Matrix for the Affine transformation that /// transforms one vector to another taking their starting points into account. /// </summary> /// <param name="firstVector">The first vector.</param> /// <param name="secondVector">The second vector.</param> /// <param name="equationSystemSolverFunction">The function that, being provided with matrix /// square matrix of size N (containing the unknown parameters' coefficients) and a vector of /// free terms having length N, will return the vector of unknown parameters. /// May be null, an internal function will be used in this case. /// </param> /// <param name="c">The first free term of transformation matrix. Can be set to any value, affects the inverse matrix calculation precision.</param> /// <param name="d">THe second free term of transformation matrix. Can be set to any value, affects the inverse matrix calculation precision.</param> /// <returns>An affine transform matrix that would convert the <paramref name="firstVector"/> to the <paramref name="secondVector"/>.</returns> public static Matrix_SDA<double, CalcDouble> GetAffineTransformMatrix( VectorD firstVector, VectorD secondVector, double c = 0, double d = 0, Func<DoubleMatrix, DoubleVector, DoubleVector> equationSystemSolverFunction = null) { if(equationSystemSolverFunction == null) equationSystemSolverFunction = delegate(DoubleMatrix matrix, DoubleVector f) { // Используется алгоритм нахождения обратной матрицы. DoubleMatrix inverse = matrix.inverseMatrix_LUP_Factorization(); return null; }; return null; }
/// <summary> /// Returns the Matrix for the Affine transformation that /// transforms one vector to another taking their starting points into account. /// </summary> /// <param name="firstVector">The first vector.</param> /// <param name="secondVector">The second vector.</param> /// <param name="equationSystemSolverFunction">The function that, being provided with matrix /// square matrix of size N (containing the unknown parameters' coefficients) and a vector of /// free terms having length N, will return the vector of unknown parameters. /// May be null, an internal function will be used in this case. /// </param> /// <param name="c">The first free term of transformation matrix. Can be set to any value, affects the inverse matrix calculation precision.</param> /// <param name="d">THe second free term of transformation matrix. Can be set to any value, affects the inverse matrix calculation precision.</param> /// <returns>An affine transform matrix that would convert the <paramref name="firstVector"/> to the <paramref name="secondVector"/>.</returns> public static Matrix_SDA <double, CalcDouble> GetAffineTransformMatrix( VectorD firstVector, VectorD secondVector, double c = 0, double d = 0, Func <DoubleMatrix, DoubleVector, DoubleVector> equationSystemSolverFunction = null) { if (equationSystemSolverFunction == null) { equationSystemSolverFunction = delegate(DoubleMatrix matrix, DoubleVector f) { // Используется алгоритм нахождения обратной матрицы. DoubleMatrix inverse = matrix.inverseMatrix_LUP_Factorization(); return(null); } } ; return(null); } }
/// <summary> /// Returns the sine of the angle between two vectors. /// </summary> /// <param name="first">The first vector.</param> /// <param name="second">The second vector.</param> /// <returns> /// The sine of the angle that is required by the first vector to be /// rotated counterclockwise to become collinear with the second. /// </returns> public static double angleSinBetweenVectors(VectorD first, VectorD second) { return((first.multiplyWedge(second)) / (first.Length * second.Length)); }
// -------------------------------------------- // ---------------- STATIC MATHS -------------- /// <summary> /// Returns the cosine of the angle between two vectors. /// </summary> /// <param name="first">The first vector.</param> /// <param name="second">The second vector.</param> /// <returns>The cosine of the angle between vectors.</returns> public static double angleCosBetweenVectors(VectorD first, VectorD second) { return((first.multiplyScalar(second)) / (first.Length * second.Length)); }
/// <summary> /// Returns the wedge product of /// two vectors. /// /// The wedge product of vectors A and B is equal to the value |A|*|B|*sin(phi), /// where phi is the angle of rotating A to B counterclockwise to become collinear. /// </summary> /// <param name="another">Another vector to find the wedge product between the current vector and the specified.</param> /// <returns>The wedge product of two vectors.</returns> public double multiplyWedge(VectorD another) { return(this.X * another.Y - this.Y * another.X); }
// --------------------------------- // ---------- multiplication ------- // --------------------------------- /// <summary> /// Returns the scalar product of two vectors. /// /// The scalar product of vectors A and B is equal to the value |A|*|B|*sin(phi), /// where phi is the angle between A to B. /// </summary> /// <param name="another">Another vector to find the scalar product to find the scalar product between the current vector and the specified.</param> /// <returns>The scalar product of two vectors.</returns> public double multiplyScalar(VectorD another) { return(this.X * another.X + this.Y * another.Y); }
/// <summary> /// Returns the angle, in radians, that is required by the first vector /// to be rotated counterclockwise to become collinear with the second. /// </summary> /// <param name="first">The first vector.</param> /// <param name="second">The second vector.</param> /// <returns> /// The angle, in radians, that is required by the first vector /// to be rotated counterclockwise to become collinear with the second. /// </returns> public static double angleBetweenVectors(VectorD first, VectorD second) { double x1 = first.X; double y1 = first.Y; double x2 = second.X; double y2 = second.Y; return Math.Atan2(x1 * y2 - y1 * x2, x1 * x2 + y1 * y2); }
/// <summary> /// Returns the sine of the angle between two vectors. /// </summary> /// <param name="first">The first vector.</param> /// <param name="second">The second vector.</param> /// <returns> /// The sine of the angle that is required by the first vector to be /// rotated counterclockwise to become collinear with the second. /// </returns> public static double angleSinBetweenVectors(VectorD first, VectorD second) { return (first.multiplyWedge(second)) / (first.Length * second.Length); }
// -------------------------------------------- // ---------------- STATIC MATHS -------------- /// <summary> /// Returns the cosine of the angle between two vectors. /// </summary> /// <param name="first">The first vector.</param> /// <param name="second">The second vector.</param> /// <returns>The cosine of the angle between vectors.</returns> public static double angleCosBetweenVectors(VectorD first, VectorD second) { return (first.multiplyScalar(second)) / (first.Length * second.Length); }
/// <summary> /// Returns the wedge product of /// two vectors. /// /// The wedge product of vectors A and B is equal to the value |A|*|B|*sin(phi), /// where phi is the angle of rotating A to B counterclockwise to become collinear. /// </summary> /// <param name="another">Another vector to find the wedge product between the current vector and the specified.</param> /// <returns>The wedge product of two vectors.</returns> public double multiplyWedge(VectorD another) { return this.X * another.Y - this.Y * another.X; }
// --------------------------------- // ---------- multiplication ------- // --------------------------------- /// <summary> /// Returns the scalar product of two vectors. /// /// The scalar product of vectors A and B is equal to the value |A|*|B|*sin(phi), /// where phi is the angle between A to B. /// </summary> /// <param name="another">Another vector to find the scalar product to find the scalar product between the current vector and the specified.</param> /// <returns>The scalar product of two vectors.</returns> public double multiplyScalar(VectorD another) { return this.X * another.X + this.Y * another.Y; }