org.locationtech.jts:jts-core 1.17.0
org.locationtech.jts.math

## Class Vector2D

• ```public class Vector2D
extends Object```
A 2-dimensional mathematical vector represented by double-precision X and Y components.
Author:
mbdavis
• ### Constructor Summary

Constructors
Constructor and Description
`Vector2D()`
`Vector2D(Coordinate v)`
```Vector2D(Coordinate from, Coordinate to)```
```Vector2D(double x, double y)```
`Vector2D(Vector2D v)`
• ### Method Summary

All Methods
Modifier and Type Method and Description
`Vector2D` `add(Vector2D v)`
`double` `angle()`
`double` `angle(Vector2D v)`
`double` `angleTo(Vector2D v)`
`Vector2D` `average(Vector2D v)`
`Object` `clone()`
Creates a copy of this vector
`static Vector2D` `create(Coordinate coord)`
Creates a vector from a `Coordinate`.
`static Vector2D` ```create(Coordinate from, Coordinate to)```
Creates a vector with the direction and magnitude of the difference between the to and from `Coordinate`s.
`static Vector2D` ```create(double x, double y)```
Creates a new vector with given X and Y components.
`static Vector2D` `create(Vector2D v)`
Creates a new vector from an existing one.
`double` `distance(Vector2D v)`
Computes the distance between this vector and another one.
`Vector2D` `divide(double d)`
Divides the vector by a scalar value.
`double` `dot(Vector2D v)`
Computes the dot-product of two vectors
`boolean` `equals(Object o)`
Tests if a vector o has the same values for the x and y components.
`double` `getComponent(int index)`
`double` `getX()`
`double` `getY()`
`int` `hashCode()`
Gets a hashcode for this vector.
`boolean` `isParallel(Vector2D v)`
`double` `length()`
`double` `lengthSquared()`
`Vector2D` `multiply(double d)`
Multiplies the vector by a scalar value.
`Vector2D` `negate()`
`Vector2D` `normalize()`
`Vector2D` `rotate(double angle)`
`Vector2D` `rotateByQuarterCircle(int numQuarters)`
Rotates a vector by a given number of quarter-circles (i.e.
`Vector2D` `subtract(Vector2D v)`
`Coordinate` `toCoordinate()`
`String` `toString()`
Gets a string representation of this vector
`Coordinate` `translate(Coordinate coord)`
`Vector2D` ```weightedSum(Vector2D v, double frac)```
Computes the weighted sum of this vector with another vector, with this vector contributing a fraction of frac to the total.
• ### Methods inherited from class java.lang.Object

`getClass, notify, notifyAll, wait, wait, wait`
• ### Constructor Detail

• #### Vector2D

`public Vector2D()`
• #### Vector2D

```public Vector2D(double x,
double y)```
• #### Vector2D

`public Vector2D(Vector2D v)`
• #### Vector2D

```public Vector2D(Coordinate from,
Coordinate to)```
• #### Vector2D

`public Vector2D(Coordinate v)`
• ### Method Detail

• #### create

```public static Vector2D create(double x,
double y)```
Creates a new vector with given X and Y components.
Parameters:
`x` - the x component
`y` - the y component
Returns:
a new vector
• #### create

`public static Vector2D create(Vector2D v)`
Creates a new vector from an existing one.
Parameters:
`v` - the vector to copy
Returns:
a new vector
• #### create

`public static Vector2D create(Coordinate coord)`
Creates a vector from a `Coordinate`.
Parameters:
`coord` - the Coordinate to copy
Returns:
a new vector
• #### create

```public static Vector2D create(Coordinate from,
Coordinate to)```
Creates a vector with the direction and magnitude of the difference between the to and from `Coordinate`s.
Parameters:
`from` - the origin Coordinate
`to` - the destination Coordinate
Returns:
a new vector
• #### getX

`public double getX()`
• #### getY

`public double getY()`
• #### getComponent

`public double getComponent(int index)`

`public Vector2D add(Vector2D v)`
• #### subtract

`public Vector2D subtract(Vector2D v)`
• #### multiply

`public Vector2D multiply(double d)`
Multiplies the vector by a scalar value.
Parameters:
`d` - the value to multiply by
Returns:
a new vector with the value v * d
• #### divide

`public Vector2D divide(double d)`
Divides the vector by a scalar value.
Parameters:
`d` - the value to divide by
Returns:
a new vector with the value v / d
• #### negate

`public Vector2D negate()`
• #### length

`public double length()`
• #### lengthSquared

`public double lengthSquared()`
• #### normalize

`public Vector2D normalize()`
• #### average

`public Vector2D average(Vector2D v)`
• #### weightedSum

```public Vector2D weightedSum(Vector2D v,
double frac)```
Computes the weighted sum of this vector with another vector, with this vector contributing a fraction of frac to the total.

In other words,

``` sum = frac * this + (1 - frac) * v
```
Parameters:
`v` - the vector to sum
`frac` - the fraction of the total contributed by this vector
Returns:
the weighted sum of the two vectors
• #### distance

`public double distance(Vector2D v)`
Computes the distance between this vector and another one.
Parameters:
`v` - a vector
Returns:
the distance between the vectors
• #### dot

`public double dot(Vector2D v)`
Computes the dot-product of two vectors
Parameters:
`v` - a vector
Returns:
the dot product of the vectors
• #### angle

`public double angle()`
• #### angle

`public double angle(Vector2D v)`
• #### angleTo

`public double angleTo(Vector2D v)`
• #### rotate

`public Vector2D rotate(double angle)`
• #### rotateByQuarterCircle

`public Vector2D rotateByQuarterCircle(int numQuarters)`
Rotates a vector by a given number of quarter-circles (i.e. multiples of 90 degrees or Pi/2 radians). A positive number rotates counter-clockwise, a negative number rotates clockwise. Under this operation the magnitude of the vector and the absolute values of the ordinates do not change, only their sign and ordinate index.
Parameters:
`numQuarters` - the number of quarter-circles to rotate by
Returns:
the rotated vector.
• #### isParallel

`public boolean isParallel(Vector2D v)`
• #### translate

`public Coordinate translate(Coordinate coord)`
• #### toCoordinate

`public Coordinate toCoordinate()`
• #### clone

`public Object clone()`
Creates a copy of this vector
Overrides:
`clone` in class `Object`
Returns:
a copy of this vector
• #### toString

`public String toString()`
Gets a string representation of this vector
Overrides:
`toString` in class `Object`
Returns:
a string representing this vector
• #### equals

`public boolean equals(Object o)`
Tests if a vector o has the same values for the x and y components.
Overrides:
`equals` in class `Object`
Parameters:
`o` - a Vector2D with which to do the comparison.
Returns:
true if other is a Vector2D with the same values for the x and y components.
• #### hashCode

`public int hashCode()`
Gets a hashcode for this vector.
Overrides:
`hashCode` in class `Object`
Returns:
a hashcode for this vector