/// <summary> /// Initializes a new instance of the <see cref="OrientedBox"/> class using given center point, axes and extents. /// </summary> /// <param name="center">The center of the box.</param> /// <param name="axis1">The first axis.</param> /// <param name="axis2">The second axis.</param> /// <param name="extent1">The extent on the first axis.</param> /// <param name="extent2">The extent on the second axis.</param> public OrientedBox(Vector2F center, Vector2F axis1, Vector2F axis2, float extent1, float extent2) { _center = center; _axis1 = axis1; _axis2 = axis2; _extent1 = extent1; _extent2 = extent2; }
/// <summary> /// Initializes a new instance of the <see cref="OrientedBox"/> class using given center point, axes and extents. /// </summary> /// <param name="center">The center of the box.</param> /// <param name="axes">The axes of the box.</param> /// <param name="extents">The extent values of the box..</param> public OrientedBox(Vector2F center, Vector2F[] axes, float[] extents) { Debug.Assert(axes.Length >= 2); Debug.Assert(extents.Length >= 2); _center = center; _axis1 = axes[0]; _axis2 = axes[1]; _extent1 = extents[0]; _extent2 = extents[1]; }
/// <summary> /// Subtracts a vector from a scalar. /// </summary> /// <param name="v">A <see cref="Vector2F"/> instance.</param> /// <param name="s">A scalar.</param> /// <returns>A new <see cref="Vector2F"/> instance containing the difference.</returns> /// <remarks> /// result[i] = s - v[i] /// </remarks> public static Vector2F Subtract(float s, Vector2F v) { return(new Vector2F(s - v.X, s - v.Y)); }
/// <summary> /// convert a float version Vector2F into a double version Vector2D /// </summary> /// <param name="vec">Vector2F to convert</param> /// <returns>Vector2D</returns> static public Vector2D Vector2FToVector2D(Vector2F vec) { return new Vector2D((double)vec.X, (double)vec.Y); }
/// <summary> /// Tests whether two vectors are approximately equal given a tolerance value. /// </summary> /// <param name="left">A <see cref="Vector2F"/> instance.</param> /// <param name="right">A <see cref="Vector2F"/> instance.</param> /// <param name="tolerance">The tolerance value used to test approximate equality.</param> /// <returns><see langword="true"/> if the two vectors are approximately equal; otherwise, <see langword="false"/>.</returns> public static bool ApproxEqual(Vector2F left, Vector2F right, float tolerance) { return ( (System.Math.Abs(left.X - right.X) <= tolerance) && (System.Math.Abs(left.Y - right.Y) <= tolerance) ); }
/// <summary> /// Calculates the dot product of two vectors. /// </summary> /// <param name="left">A <see cref="Vector2F"/> instance.</param> /// <param name="right">A <see cref="Vector2F"/> instance.</param> /// <returns>The dot product value.</returns> public static float DotProduct(Vector2F left, Vector2F right) { return (left.X * right.X) + (left.Y * right.Y); }
/// <summary> /// Divides a vector by a scalar. /// </summary> /// <param name="vector">A <see cref="Vector2F"/> instance.</param> /// <param name="scalar">A scalar</param> /// <param name="result">A <see cref="Vector2F"/> instance to hold the result.</param> /// <remarks> /// result[i] = vector[i] / scalar /// </remarks> public static void Divide(Vector2F vector, float scalar, ref Vector2F result) { result.X = vector.X / scalar; result.Y = vector.Y / scalar; }
/// <summary> /// Divides a vector by another vector. /// </summary> /// <param name="left">A <see cref="Vector2F"/> instance.</param> /// <param name="right">A <see cref="Vector2F"/> instance.</param> /// <returns>A new <see cref="Vector2F"/> containing the quotient.</returns> /// <remarks> /// result[i] = left[i] / right[i]. /// </remarks> public static Vector2F Divide(Vector2F left, Vector2F right) { return new Vector2F(left.X / right.X, left.Y / right.Y); }
/// <summary> /// Divides a vector by another vector. /// </summary> /// <param name="u">A <see cref="Vector2F"/> instance.</param> /// <param name="v">A <see cref="Vector2F"/> instance.</param> /// <param name="w">A <see cref="Vector2F"/> instance to hold the result.</param> /// <remarks> /// w[i] = u[i] / v[i] /// </remarks> public static void Divide(Vector2F u, Vector2F v, ref Vector2F w) { w.X = u.X / v.X; w.Y = u.Y / v.Y; }
/// <summary> /// Divides a scalar by a vector. /// </summary> /// <param name="v">A <see cref="Vector2F"/> instance.</param> /// <param name="s">A scalar</param> /// <returns>A new <see cref="Vector2F"/> containing the quotient.</returns> /// <remarks> /// result[i] = s / v[i] /// </remarks> public static Vector2F Divide(float s, Vector2F v) { return(new Vector2F(s / v.X, s / v.Y)); }
/// <summary> /// Divides a vector by a scalar. /// </summary> /// <param name="v">A <see cref="Vector2F"/> instance.</param> /// <param name="s">A scalar</param> /// <returns>A new <see cref="Vector2F"/> containing the quotient.</returns> /// <remarks> /// result[i] = v[i] / s; /// </remarks> public static Vector2F Divide(Vector2F v, float s) { return(new Vector2F(v.X / s, v.Y / s)); }
/// <summary> /// Divides a vector by another vector. /// </summary> /// <param name="u">A <see cref="Vector2F"/> instance.</param> /// <param name="v">A <see cref="Vector2F"/> instance.</param> /// <returns>A new <see cref="Vector2F"/> containing the quotient.</returns> /// <remarks> /// result[i] = u[i] / v[i]. /// </remarks> public static Vector2F Divide(Vector2F u, Vector2F v) { return(new Vector2F(u.X / v.X, u.Y / v.Y)); }
/// <summary> /// Subtracts a scalar from a vector and put the result into another vector. /// </summary> /// <param name="u">A <see cref="Vector2F"/> instance.</param> /// <param name="s">A scalar.</param> /// <param name="v">A <see cref="Vector2F"/> instance to hold the result.</param> /// <remarks> /// v[i] = s - u[i] /// </remarks> public static void Subtract(float s, Vector2F u, ref Vector2F v) { v.X = s - u.X; v.Y = s - u.Y; }
/// <summary> /// Subtracts a vector from a scalar and put the result into another vector. /// </summary> /// <param name="u">A <see cref="Vector2F"/> instance.</param> /// <param name="s">A scalar.</param> /// <param name="v">A <see cref="Vector2F"/> instance to hold the result.</param> /// <remarks> /// v[i] = u[i] - s /// </remarks> public static void Subtract(Vector2F u, float s, ref Vector2F v) { v.X = u.X - s; v.Y = u.Y - s; }
/// <summary> /// Subtracts a vector from a second vector and puts the result into a third vector. /// </summary> /// <param name="u">A <see cref="Vector2F"/> instance.</param> /// <param name="v">A <see cref="Vector2F"/> instance</param> /// <param name="w">A <see cref="Vector2F"/> instance to hold the result.</param> /// <remarks> /// w[i] = v[i] - w[i]. /// </remarks> public static void Subtract(Vector2F u, Vector2F v, ref Vector2F w) { w.X = u.X - v.X; w.Y = u.Y - v.Y; }
/// <summary> /// Subtracts a vector from a scalar. /// </summary> /// <param name="vector">A <see cref="Vector2F"/> instance.</param> /// <param name="scalar">A single-precision floating-point number.</param> /// <returns>A new <see cref="Vector2F"/> instance containing the difference.</returns> /// <remarks> /// result[i] = scalar - vector[i] /// </remarks> public static Vector2F Subtract(float scalar, Vector2F vector) { return new Vector2F(scalar - vector.X, scalar - vector.Y); }
/// <summary> /// Subtracts a vector from a scalar and put the result into another vector. /// </summary> /// <param name="vector">A <see cref="Vector2F"/> instance.</param> /// <param name="scalar">A single-precision floating-point number.</param> /// <param name="result">A <see cref="Vector2F"/> instance to hold the result.</param> /// <remarks> /// result[i] = vector[i] - scalar /// </remarks> public static void Subtract(Vector2F vector, float scalar, ref Vector2F result) { result.X = vector.X - scalar; result.Y = vector.Y - scalar; }
/// <summary> /// Divides a vector by a scalar. /// </summary> /// <param name="u">A <see cref="Vector2F"/> instance.</param> /// <param name="s">A scalar</param> /// <param name="v">A <see cref="Vector2F"/> instance to hold the result.</param> /// <remarks> /// v[i] = u[i] / s /// </remarks> public static void Divide(Vector2F u, float s, ref Vector2F v) { v.X = u.X / s; v.Y = u.Y / s; }
/// <summary> /// Divides a scalar by a vector. /// </summary> /// <param name="vector">A <see cref="Vector2F"/> instance.</param> /// <param name="scalar">A scalar</param> /// <returns>A new <see cref="Vector2F"/> containing the quotient.</returns> /// <remarks> /// result[i] = scalar / vector[i] /// </remarks> public static Vector2F Divide(float scalar, Vector2F vector) { return new Vector2F(scalar / vector.X, scalar / vector.Y); }
/// <summary> /// Divides a scalar by a vector. /// </summary> /// <param name="u">A <see cref="Vector2F"/> instance.</param> /// <param name="s">A scalar</param> /// <param name="v">A <see cref="Vector2F"/> instance to hold the result.</param> /// <remarks> /// v[i] = s / u[i] /// </remarks> public static void Divide(float s, Vector2F u, ref Vector2F v) { v.X = s / u.X; v.Y = s / u.Y; }
/// <summary> /// Multiplies a vector by a scalar. /// </summary> /// <param name="vector">A <see cref="Vector2F"/> instance.</param> /// <param name="scalar">A single-precision floating-point number.</param> /// <returns>A new <see cref="Vector2F"/> containing the result.</returns> public static Vector2F Multiply(Vector2F vector, float scalar) { return new Vector2F(vector.X * scalar, vector.Y * scalar); }
/// <summary> /// Multiplies a vector by a scalar. /// </summary> /// <param name="u">A <see cref="Vector2F"/> instance.</param> /// <param name="s">A scalar.</param> /// <returns>A new <see cref="Vector2F"/> containing the result.</returns> public static Vector2F Multiply(Vector2F u, float s) { return(new Vector2F(u.X * s, u.Y * s)); }
/// <summary> /// Negates a vector. /// </summary> /// <param name="vector">A <see cref="Vector2F"/> instance.</param> /// <returns>A new <see cref="Vector2F"/> instance containing the negated values.</returns> public static Vector2F Negate(Vector2F vector) { return new Vector2F(-vector.X, -vector.Y); }
/// <summary> /// Multiplies a vector by a scalar and put the result in another vector. /// </summary> /// <param name="u">A <see cref="Vector2F"/> instance.</param> /// <param name="s">A scalar.</param> /// <param name="v">A <see cref="Vector2F"/> instance to hold the result.</param> public static void Multiply(Vector2F u, float s, ref Vector2F v) { v.X = u.X * s; v.Y = u.Y * s; }
/// <summary> /// Computes the box vertices. /// </summary> /// <returns>An array of <see cref="Vector2F"/> containing the box vertices.</returns> public Vector2F[] ComputeVertices() { Vector2F[] vertices = new Vector2F[4]; Vector2F[] AxisExtents = new Vector2F[2] { Axis1*Extent1, Axis2*Extent2 }; vertices[0] = Center - AxisExtents[0] - AxisExtents[1]; vertices[1] = Center + AxisExtents[0] - AxisExtents[1]; vertices[2] = Center + AxisExtents[0] + AxisExtents[1]; vertices[3] = Center - AxisExtents[0] + AxisExtents[1]; return vertices; }
/// <summary> /// Calculates the dot product of two vectors. /// </summary> /// <param name="u">A <see cref="Vector2F"/> instance.</param> /// <param name="v">A <see cref="Vector2F"/> instance.</param> /// <returns>The dot product value.</returns> public static float DotProduct(Vector2F u, Vector2F v) { return((u.X * v.X) + (u.Y * v.Y)); }
/// <summary> /// Initializes a new instance of the <see cref="Circle"/> class using center and radius values. /// </summary> /// <param name="center">The circle's center point.</param> /// <param name="radius">The circle's radius.</param> public Circle(Vector2F center, float radius) { _c = center; _r = radius; }
/// <summary> /// Calculates the Kross product of two vectors. /// </summary> /// <param name="u">A <see cref="Vector2D"/> instance.</param> /// <param name="v">A <see cref="Vector2D"/> instance.</param> /// <returns>The Kross product value.</returns> /// <remarks> /// <p> /// The Kross product is defined as: /// Kross(u,v) = u.X*v.Y - u.Y*v.X. /// </p> /// <p> /// The operation is related to the cross product in 3D given by (x0, y0, 0) X (x1, y1, 0) = (0, 0, Kross((x0, y0), (x1, y1))). /// The operation has the property that Kross(u, v) = -Kross(v, u). /// </p> /// </remarks> public static float KrossProduct(Vector2F u, Vector2F v) { return(u.X * v.Y - u.Y * v.X); }
/// <summary> /// Transforms a given vector by a matrix and put the result in a vector. /// </summary> /// <param name="matrix">A <see cref="Matrix2F"/> instance.</param> /// <param name="vector">A <see cref="Vector2F"/> instance.</param> /// <param name="result">A <see cref="Vector2F"/> instance to hold the result.</param> public static void Transform(Matrix2F matrix, Vector2F vector, ref Vector2F result) { result.X = (matrix.M11 * vector.X) + (matrix.M12 * vector.Y); result.Y = (matrix.M21 * vector.X) + (matrix.M22 * vector.Y); }
/// <summary> /// Negates a vector. /// </summary> /// <param name="v">A <see cref="Vector2F"/> instance.</param> /// <returns>A new <see cref="Vector2F"/> instance containing the negated values.</returns> public static Vector2F Negate(Vector2F v) { return(new Vector2F(-v.X, -v.Y)); }
/// <summary> /// Subtracts a scalar from a vector. /// </summary> /// <param name="vector">A <see cref="Vector2F"/> instance.</param> /// <param name="scalar">A single-precision floating-point number.</param> /// <returns>A new <see cref="Vector2F"/> instance containing the difference.</returns> /// <remarks> /// result[i] = vector[i] - scalar /// </remarks> public static Vector2F Subtract(Vector2F vector, float scalar) { return new Vector2F(vector.X - scalar, vector.Y - scalar); }
/// <summary> /// Tests whether two vectors are approximately equal using default tolerance value. /// </summary> /// <param name="v">A <see cref="Vector2F"/> instance.</param> /// <param name="u">A <see cref="Vector2F"/> instance.</param> /// <returns><see langword="true"/> if the two vectors are approximately equal; otherwise, <see langword="false"/>.</returns> public static bool ApproxEqual(Vector2F v, Vector2F u) { return(ApproxEqual(v, u, MathFunctions.EpsilonF)); }
/// <summary> /// Subtracts a vector from a second vector and puts the result into a third vector. /// </summary> /// <param name="left">A <see cref="Vector2F"/> instance.</param> /// <param name="right">A <see cref="Vector2F"/> instance</param> /// <param name="result">A <see cref="Vector2F"/> instance to hold the result.</param> /// <remarks> /// result[i] = left[i] - right[i]. /// </remarks> public static void Subtract(Vector2F left, Vector2F right, ref Vector2F result) { result.X = left.X - right.X; result.Y = left.Y - right.Y; }
/// <summary> /// Negates the values of the vector. /// </summary> /// <param name="v">A <see cref="Vector2F"/> instance.</param> /// <returns>A new <see cref="Vector2F"/> instance containing the negated values.</returns> public static Vector2F operator-(Vector2F v) { return(Vector2F.Negate(v)); }
/// <summary> /// Subtracts a scalar from a vector and put the result into another vector. /// </summary> /// <param name="vector">A <see cref="Vector2F"/> instance.</param> /// <param name="scalar">A single-precision floating-point number.</param> /// <param name="result">A <see cref="Vector2F"/> instance to hold the result.</param> /// <remarks> /// result[i] = scalar - vector[i] /// </remarks> public static void Subtract(float scalar, Vector2F vector, ref Vector2F result) { result.X = scalar - vector.X; result.Y = scalar - vector.Y; }
/// <summary> /// Adds two vectors. /// </summary> /// <param name="u">A <see cref="Vector2F"/> instance.</param> /// <param name="v">A <see cref="Vector2F"/> instance.</param> /// <returns>A new <see cref="Vector2F"/> instance containing the sum.</returns> public static Vector2F operator+(Vector2F u, Vector2F v) { return(Vector2F.Add(u, v)); }
/// <summary> /// Divides a vector by a scalar. /// </summary> /// <param name="vector">A <see cref="Vector2F"/> instance.</param> /// <param name="scalar">A scalar</param> /// <returns>A new <see cref="Vector2F"/> containing the quotient.</returns> /// <remarks> /// result[i] = vector[i] / scalar; /// </remarks> public static Vector2F Divide(Vector2F vector, float scalar) { return new Vector2F(vector.X / scalar, vector.Y / scalar); }
/// <summary> /// Adds a vector and a scalar. /// </summary> /// <param name="v">A <see cref="Vector2F"/> instance.</param> /// <param name="s">A scalar.</param> /// <returns>A new <see cref="Vector2F"/> instance containing the sum.</returns> public static Vector2F operator+(float s, Vector2F v) { return(Vector2F.Add(v, s)); }
/// <summary> /// Divides a vector by another vector. /// </summary> /// <param name="left">A <see cref="Vector2F"/> instance.</param> /// <param name="right">A <see cref="Vector2F"/> instance.</param> /// <param name="result">A <see cref="Vector2F"/> instance to hold the result.</param> /// <remarks> /// result[i] = left[i] / right[i] /// </remarks> public static void Divide(Vector2F left, Vector2F right, ref Vector2F result) { result.X = left.X / right.X; result.Y = left.Y / right.Y; }
/// <summary> /// Subtracts a vector from a vector. /// </summary> /// <param name="u">A <see cref="Vector2F"/> instance.</param> /// <param name="v">A <see cref="Vector2F"/> instance.</param> /// <returns>A new <see cref="Vector2F"/> instance containing the difference.</returns> /// <remarks> /// result[i] = v[i] - w[i]. /// </remarks> public static Vector2F operator-(Vector2F u, Vector2F v) { return(Vector2F.Subtract(u, v)); }
/// <summary> /// Divides a scalar by a vector. /// </summary> /// <param name="vector">A <see cref="Vector2F"/> instance.</param> /// <param name="scalar">A scalar</param> /// <param name="result">A <see cref="Vector2F"/> instance to hold the result.</param> /// <remarks> /// result[i] = scalar / vector[i] /// </remarks> public static void Divide(float scalar, Vector2F vector, ref Vector2F result) { result.X = scalar / vector.X; result.Y = scalar / vector.Y; }
/// <summary> /// Subtracts a scalar from a vector. /// </summary> /// <param name="v">A <see cref="Vector2F"/> instance.</param> /// <param name="s">A scalar.</param> /// <returns>A new <see cref="Vector2F"/> instance containing the difference.</returns> /// <remarks> /// result[i] = v[i] - s /// </remarks> public static Vector2F operator-(Vector2F v, float s) { return(Vector2F.Subtract(v, s)); }
/// <summary> /// Multiplies a vector by a scalar and put the result in another vector. /// </summary> /// <param name="vector">A <see cref="Vector2F"/> instance.</param> /// <param name="scalar">A single-precision floating-point number.</param> /// <param name="result">A <see cref="Vector2F"/> instance to hold the result.</param> public static void Multiply(Vector2F vector, float scalar, ref Vector2F result) { result.X = vector.X * scalar; result.Y = vector.Y * scalar; }
/// <summary> /// Subtracts a vector from a scalar. /// </summary> /// <param name="v">A <see cref="Vector2F"/> instance.</param> /// <param name="s">A scalar.</param> /// <returns>A new <see cref="Vector2F"/> instance containing the difference.</returns> /// <remarks> /// result[i] = s - v[i] /// </remarks> public static Vector2F operator-(float s, Vector2F v) { return(Vector2F.Subtract(s, v)); }
/// <summary> /// Calculates the Kross product of two vectors. /// </summary> /// <param name="left">A <see cref="Vector2F"/> instance.</param> /// <param name="right">A <see cref="Vector2F"/> instance.</param> /// <returns>The Kross product value.</returns> /// <remarks> /// <p> /// The Kross product is defined as: /// Kross(u,v) = u.X*v.Y - u.Y*v.X. /// </p> /// <p> /// The operation is related to the cross product in 3D given by (x0, y0, 0) X (x1, y1, 0) = (0, 0, Kross((x0, y0), (x1, y1))). /// The operation has the property that Kross(u, v) = -Kross(v, u). /// </p> /// </remarks> public static float KrossProduct(Vector2F left, Vector2F right) { return (left.X * right.Y) - (left.Y * right.X); }
/// <summary> /// Multiplies a vector by a scalar. /// </summary> /// <param name="v">A <see cref="Vector2F"/> instance.</param> /// <param name="s">A scalar.</param> /// <returns>A new <see cref="Vector2F"/> containing the result.</returns> public static Vector2F operator*(float s, Vector2F v) { return(Vector2F.Multiply(v, s)); }
/// <summary> /// Tests whether two vectors are approximately equal using default tolerance value. /// </summary> /// <param name="left">A <see cref="Vector2F"/> instance.</param> /// <param name="right">A <see cref="Vector2F"/> instance.</param> /// <returns><see langword="true"/> if the two vectors are approximately equal; otherwise, <see langword="false"/>.</returns> public static bool ApproxEqual(Vector2F left, Vector2F right) { return ApproxEqual(left, right, MathFunctions.EpsilonF); }
/// <summary> /// Divides a vector by a scalar. /// </summary> /// <param name="v">A <see cref="Vector2F"/> instance.</param> /// <param name="s">A scalar</param> /// <returns>A new <see cref="Vector2F"/> containing the quotient.</returns> /// <remarks> /// result[i] = v[i] / s; /// </remarks> public static Vector2F operator/(Vector2F v, float s) { return(Vector2F.Divide(v, s)); }
/// <summary> /// Initializes a new instance of the <see cref="Vector2F"/> class using coordinates from a given <see cref="Vector2F"/> instance. /// </summary> /// <param name="vector">A <see cref="Vector2F"/> to get the coordinates from.</param> public Vector2F(Vector2F vector) { _x = vector.X; _y = vector.Y; }
/// <summary> /// Divides a scalar by a vector. /// </summary> /// <param name="v">A <see cref="Vector2F"/> instance.</param> /// <param name="s">A scalar</param> /// <returns>A new <see cref="Vector2F"/> containing the quotient.</returns> /// <remarks> /// result[i] = s / v[i] /// </remarks> public static Vector2F operator/(float s, Vector2F v) { return(Vector2F.Divide(s, v)); }
/// <summary> /// Transforms a given vector by a matrix. /// </summary> /// <param name="matrix">A <see cref="Matrix2F"/> instance.</param> /// <param name="vector">A <see cref="Vector2F"/> instance.</param> /// <returns>A new <see cref="Vector2F"/> instance containing the result.</returns> public static Vector2F Transform(Matrix2F matrix, Vector2F vector) { return(new Vector2F( (matrix.M11 * vector.X) + (matrix.M12 * vector.Y), (matrix.M21 * vector.X) + (matrix.M22 * vector.Y))); }
/// <summary> /// Initializes a new instance of the <see cref="OrientedBox"/> class using given values from another box instance. /// </summary> /// <param name="box">A <see cref="OrientedBox"/> instance to take values from.</param> public OrientedBox(OrientedBox box) { _center = box.Center; _axis1 = box.Axis1; _axis2 = box.Axis2; _extent1 = box.Extent1; _extent2 = box.Extent2; }
/// <summary> /// Initializes a new instance of the <see cref="Circle"/> class using values from another circle instance. /// </summary> /// <param name="circle">A <see cref="Circle"/> instance to take values from.</param> public Circle(Circle circle) { _c = circle._c; _r = circle._r; }
/// <summary> /// Initializes a new instance of the <see cref="Matrix2F"/> structure with the specified values. /// </summary> /// <param name="column1">A <see cref="Vector2F"/> instance holding values for the first column.</param> /// <param name="column2">A <see cref="Vector2F"/> instance holding values for the second column.</param> public Matrix2F(Vector2F column1, Vector2F column2) { _m11 = column1.X; _m12 = column2.X; _m21 = column1.Y; _m22 = column2.Y; }
/// <summary> /// Transforms a given vector by a matrix. /// </summary> /// <param name="matrix">A <see cref="Matrix2F"/> instance.</param> /// <param name="vector">A <see cref="Vector2F"/> instance.</param> /// <returns>A new <see cref="Vector2F"/> instance containing the result.</returns> public static Vector2F Transform(Matrix2F matrix, Vector2F vector) { return new Vector2F( (matrix.M11 * vector.X) + (matrix.M12 * vector.Y), (matrix.M21 * vector.X) + (matrix.M22 * vector.Y)); }
/// <summary> /// Subtracts a vector from a vector. /// </summary> /// <param name="left">A <see cref="Vector2F"/> instance.</param> /// <param name="right">A <see cref="Vector2F"/> instance.</param> /// <returns>A new <see cref="Vector2F"/> instance containing the difference.</returns> /// <remarks> /// result[i] = left[i] - right[i]. /// </remarks> public static Vector2F Subtract(Vector2F left, Vector2F right) { return new Vector2F(left.X - right.X, left.Y - right.Y); }
/// <summary> /// Subtracts a scalar from a vector. /// </summary> /// <param name="v">A <see cref="Vector2F"/> instance.</param> /// <param name="s">A scalar.</param> /// <returns>A new <see cref="Vector2F"/> instance containing the difference.</returns> /// <remarks> /// result[i] = v[i] - s /// </remarks> public static Vector2F Subtract(Vector2F v, float s) { return(new Vector2F(v.X - s, v.Y - s)); }