Vector2D (Revolution Systems Open Library TRUNK-SNAPSHOT API)

java.lang.Object
- com.revolsys.jts.math.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(double x, double y)

Vector2D(Point v)

Vector2D(Point from, Point to)

Vector2D(Vector2D v)

Constructors
Constructor and Description
`Vector2D()`
`Vector2D(double x, double y)`
`Vector2D(Point v)`
`Vector2D(Point from, Point to)`
`Vector2D(Vector2D v)`

Method Summary

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(double x, double y)` Creates a new vector with given X and Y components.
`static Vector2D`	`create(Point coord)` Creates a vector from a `Coordinates`.
`static Vector2D`	`create(Point from, Point to)` Creates a vector with the direction and magnitude of the difference between the `to` and `from` `Coordinates`s.
`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)`
`Point`	`toCoordinate()`
`String`	`toString()` Gets a string representation of this vector
`Point`	`translate(Point 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
finalize, getClass, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - Vector2D
```
public Vector2D()
```
  - Vector2D
```
public Vector2D(double x,
        double y)
```
  - Vector2D
```
public Vector2D(Point v)
```
  - Vector2D
```
public Vector2D(Point from,
        Point to)
```
  - Vector2D
```
public Vector2D(Vector2D 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(Point coord)
```
    Creates a vector from a Coordinates.
    
    Parameters:
    coord - the Point to copy
    
    Returns:
    a new vector
  - create
```
public static Vector2D create(Point from,
              Point to)
```
    Creates a vector with the direction and magnitude of the difference between the to and from Coordinatess.
    
    Parameters:
    from - the origin Coordinate
    to - the destination Coordinate
    
    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
  - add
```
public Vector2D add(Vector2D v)
```
  - angle
```
public double angle()
```
  - angle
```
public double angle(Vector2D v)
```
  - angleTo
```
public double angleTo(Vector2D v)
```
  - average
```
public Vector2D average(Vector2D v)
```
  - clone
```
public Object clone()
```
    Creates a copy of this vector
    
    Overrides:
    
    clone in class Object
    
    Returns:
    a copy of this vector
  - 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
  - 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
  - dot
```
public double dot(Vector2D v)
```
    Computes the dot-product of two vectors
    
    Parameters:
    v - a vector
    
    Returns:
    the dot product of the vectors
  - 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.
  - getComponent
```
public double getComponent(int index)
```
  - getX
```
public double getX()
```
  - getY
```
public double getY()
```
  - hashCode
```
public int hashCode()
```
    Gets a hashcode for this vector.
    
    Overrides:
    
    hashCode in class Object
    
    Returns:
    a hashcode for this vector
  - isParallel
```
public boolean isParallel(Vector2D v)
```
  - length
```
public double length()
```
  - lengthSquared
```
public double lengthSquared()
```
  - 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
  - negate
```
public Vector2D negate()
```
  - normalize
```
public Vector2D normalize()
```
  - 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.
  - subtract
```
public Vector2D subtract(Vector2D v)
```
  - toCoordinate
```
public Point toCoordinate()
```
  - toString
```
public String toString()
```
    Gets a string representation of this vector
    
    Overrides:
    
    toString in class Object
    
    Returns:
    a string representing this vector
  - translate
```
public Point translate(Point coord)
```
  - 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

Class Vector2D

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Vector2D

Vector2D

Vector2D

Vector2D

Vector2D

Method Detail

create

create

create

create

add

angle

angle

angleTo

average

clone

distance

divide

dot

equals

getComponent

getX

getY

hashCode

isParallel

length

lengthSquared

multiply

negate

normalize

rotate

rotateByQuarterCircle

subtract

toCoordinate

toString

translate

weightedSum