The zero vector.

Vector2d.zero
--> Vector2d ( 0, 0 )

Construct a vector perpendicular to the given vector, by rotating the given vector 90 degrees counterclockwise. The constructed vector will have the same length as the given vector.

Vector2d.perpendicularTo (Vector2d ( 1, 0 ))
--> Vector2d ( 0, 1 )


Vector2d.perpendicularTo (Vector2d ( 0, 2 ))
--> Vector2d ( -2, 0 )


Vector2d.perpendicularTo (Vector2d ( 3, 1 ))
--> Vector2d ( -1, 3 )


Vector2d.perpendicularTo Vector2d.zero
--> Vector2d.zero

Extract the components of a vector.

Vector2d.components (Vector2d ( 2, 3 ))
--> ( 2, 3 )

This combined with Elm's built-in tuple destructuring provides a convenient way to extract both the X and Y components of a vector in one line of code:

( x, y ) =
    Vector2d.components vector

To get the polar components of a vector, you can use Elm's built-in toPolar function:

( radius, angle ) =
    toPolar (Vector2d.components vector)

Get the X component of a vector.

Vector2d.xComponent (Vector2d ( 2, 3 ))
--> 2

Get the Y component of a vector.

Vector2d.yComponent (Vector2d ( 2, 3 ))
--> 3

Find the component of a vector in an arbitrary direction, for example

forwardSpeed =
    Vector2d.componentIn forwardDirection velocity

This is more general and flexible than using xComponent or yComponent, both of which can be expressed in terms of componentIn; for example,

Vector2d.xComponent vector

is equivalent to

Vector2d.componentIn Direction2d.x vector

Compare two vectors within a tolerance. Returns true if the difference between the two given vectors has magnitude less than the given tolerance.

firstVector =
    Vector2d ( 1, 2 )


secondVector =
    Vector2d ( 0.9999, 2.0002 )


Vector2d.equalWithin 1e-3 firstVector secondVector
--> True


Vector2d.equalWithin 1e-6 firstVector secondVector
--> False

Get the length (magnitude) of a vector.

Vector2d.length (Vector2d ( 3, 4 ))
--> 5

Get the squared length of a vector. squaredLength is slightly faster than length, so for example

Vector2d.squaredLength vector > tolerance * tolerance

is equivalent to but slightly more efficient than

Vector2d.length vector > tolerance

since the latter requires a square root under the hood. In many cases, however, the speed difference will be negligible and using length is much more readable!

Attempt to find the direction of a vector. In the case of a zero vector, return Nothing.

Vector2d.direction (Vector2d ( 3, 4 ))
--> Just (Direction2d ( 0.6, 0.8 ))


Vector2d.direction (Vector2d ( 0, 0 ))
--> Nothing

Attempt to find the length and direction of a vector. In the case of a zero vector, returns Nothing.

vector =
    Vector2d ( 3, 4 )


Vector2d.lengthAndDirection vector
--> Just ( 5, Direction2d ( 0.6, 0.8 ) )


Vector2d.lengthAndDirection Vector2d.zero
--> Nothing

Find the sum of two vectors.

firstVector =
    Vector2d ( 1, 2 )


secondVector =
    Vector2d ( 3, 4 )


Vector2d.sum firstVector secondVector
--> Vector2d ( 4, 6 )

Find the difference between two vectors (the first vector minus the second).

firstVector =
    Vector2d ( 5, 6 )


secondVector =
    Vector2d ( 1, 3 )


Vector2d.difference firstVector secondVector
--> Vector2d ( 4, 3 )

Find the dot product of two vectors.

firstVector =
    Vector2d ( 1, 2 )


secondVector =
    Vector2d ( 3, 4 )


Vector2d.dotProduct firstVector secondVector
--> 11

Find the scalar 'cross product' of two vectors in 2D. This is defined as

crossProduct firstVector secondVector =
    let
        ( x1, y1 ) =
            components firstVector


        ( x2, y2 ) =
            components secondVector
    in
        x1 * y2 - y1 * x2

and is useful in many of the same ways as the 3D cross product:

• Its magnitude is equal to the product of the lengths of the two given vectors and the sine of the angle between them, so it can be used as a metric to determine if two vectors are nearly parallel.
• The sign of the result indicates the direction of rotation from the first vector to the second (positive indicates a counterclockwise rotation and negative indicates a clockwise rotation), similar to how the direction of the 3D cross product indicates the direction of rotation.

Some examples:

firstVector =
    Vector2d ( 2, 0 )


secondVector =
    Vector2d ( 0, 3 )


Vector2d.crossProduct firstVector secondVector
--> 6


Vector2d.crossProduct secondVector firstVector
--> -6


Vector2d.crossProduct firstVector firstVector
--> 0

Reverse the direction of a vector, negating its components.

Vector2d.flip (Vector2d ( -1, 2 ))
--> Vector2d ( 1, -2 )

Scale the length of a vector by a given scale.

Vector2d.scaleBy 3 (Vector2d ( 1, 2 ))
--> Vector2d ( 3, 6 )

Rotate a vector counterclockwise by a given angle (in radians).

Vector2d.rotateBy (degrees 45) (Vector2d ( 1, 1 ))
--> Vector2d ( 0, 1.4142 )


Vector2d.rotateBy pi (Vector2d ( 1, 0 ))
--> Vector2d ( -1, 0 )

Mirror a vector across a given axis.

vector =
    Vector2d ( 2, 3 )


Vector2d.mirrorAcross Axis2d.y vector
--> Vector2d ( -2, 3 )


horizontalAxis =
    Axis2d
        { originPoint = Point2d ( 100, 200 )
        , direction = Direction2d.x
        }


Vector2d.mirrorAcross horizontalAxis vector
--> Vector2d ( 2, -3 )

Find the projection of a vector in a particular direction. Conceptually, this means splitting the original vector into a portion parallel to the given direction and a portion perpendicular to it, then returning the parallel portion.

vector =
    Vector2d ( 2, 3 )


Vector2d.projectionIn Direction2d.x vector
--> Vector2d ( 2, 0 )


Vector2d.projectionIn Direction2d.y vector
--> Vector2d ( 0, 3 )

Project a vector onto an axis.

Vector2d.projectOnto Axis2d.y (Vector2d ( 3, 4 ))
--> Vector2d ( 0, 4 )


Vector2d.projectOnto Axis2d.x (Vector2d ( -1, 2 ))
--> Vector2d ( -1, 0 )

This is equivalent to finding the projection in the axis' direction.

Take a vector defined in global coordinates, and return it expressed in local coordinates relative to a given reference frame.

Vector2d.relativeTo rotatedFrame (Vector2d ( 2, 0 ))
--> Vector2d ( 1.732, -1 )

Take a vector defined in local coordinates relative to a given reference frame, and return that vector expressed in global coordinates.

Vector2d.placeIn rotatedFrame (Vector2d ( 2, 0 ))
--> Vector2d ( 1.732, 1 )

Take a vector defined in 2D coordinates within a particular sketch plane and return the corresponding vector in 3D.

vector =
    Vector2d ( 2, 3 )


Vector2d.placeOnto SketchPlane3d.xy vector
--> Vector3d ( 2, 3, 0 )


Vector2d.placeOnto SketchPlane3d.yz vector
--> Vector3d ( 0, 2, 3 )


Vector2d.placeOnto SketchPlane3d.zx vector
--> Vector3d ( 3, 0, 2 )

A slightly more complex example:

tiltedSketchPlane =
    SketchPlane3d.xy
        |> SketchPlane3d.rotateAround Axis3d.x (degrees 45)


Vector2d.placeOnto tiltedSketchPlane (Vector2d ( 1, 1 ))
--> Vector3d ( 1, 0.7071, 0.7071 )