All Known Implementing Classes:
Circle, Ellipse, Ray2D, Vec2D

`public interface ReadonlyVec2D`

Readonly, immutable interface wrapper for Vec2D instances. Used throughout the library for safety purposes.

Method Summary
` Vec2D` ```add(float a, float b)```
Adds vector {a,b,c} and returns result as new vector.
` Vec2D` `add(ReadonlyVec2D v)`
Add vector v and returns result as new vector.
` float` `angleBetween(ReadonlyVec2D v)`
Computes the angle between this vector and vector V.
` float` ```angleBetween(ReadonlyVec2D v, boolean forceNormalize)```
Computes the angle between this vector and vector V
` Vec3D` `bisect(Vec2D p)`
Computes the perpendicular bisector of two points.
` int` `compareTo(ReadonlyVec2D v)`
Compares the length of the vector with another one.
` Vec2D` `copy()`

` float` `cross(ReadonlyVec2D v)`
Calculates the cross-product with the given vector.
` float` `distanceTo(ReadonlyVec2D v)`
Calculates distance to another vector
` float` `distanceToSquared(ReadonlyVec2D v)`
Calculates the squared distance to another vector
` float` `dot(ReadonlyVec2D v)`
Computes the scalar product (dot product) with the given vector.
` boolean` `equals(java.lang.Object obj)`

` boolean` ```equalsWithTolerance(ReadonlyVec2D v, float tolerance)```
Compares this vector with the one given.
` Vec2D` `getAbs()`

` float` `getComponent(int id)`

` float` `getComponent(Vec2D.Axis id)`

` Vec2D` `getConstrained(Rect r)`
Creates a copy of the vector which forcefully fits in the given rectangle.
` Vec2D` `getFloored()`
Creates a new vector whose components are the integer value of their current values
` Vec2D` `getFrac()`
Creates a new vector whose components are the fractional part of their current values
` Vec2D` `getInverted()`
Scales vector uniformly by factor -1 ( v = -v )
` Vec2D` `getLimited(float lim)`
Creates a copy of the vector with its magnitude limited to the length given
` Vec2D` `getNormalized()`
Produces the normalized version as a new vector
` Vec2D` `getNormalizedTo(float len)`
Produces a new vector normalized to the given length.
` Vec2D` `getPerpendicular()`

` Vec2D` `getReciprocal()`

` Vec2D` `getReflected(ReadonlyVec2D normal)`

` Vec2D` `getRotated(float theta)`
Creates a new vector rotated by the given angle around the Z axis.
` Vec2D` `getSignum()`
Creates a new vector in which all components are replaced with the signum of their original values.
` float` `heading()`
Computes the vector's direction in the XY plane (for example for 2D points).
` Vec2D` ```interpolateTo(ReadonlyVec2D v, float f)```
Interpolates the vector towards the given target vector, using linear interpolation
` Vec2D` ```interpolateTo(ReadonlyVec2D v, float f, InterpolateStrategy s)```
Interpolates the vector towards the given target vector, using the given `InterpolateStrategy`
` boolean` ```isInCircle(ReadonlyVec2D sO, float sR)```
Checks if the point is inside the given sphere.
` boolean` `isInRectangle(Rect r)`
Checks if the point is inside the given rectangle.
` boolean` ```isInTriangle(Vec2D a, Vec2D b, Vec2D c)```
Checks if point vector is inside the triangle created by the points a, b and c.
` boolean` `isMajorAxis(float tolerance)`
Checks if the vector is parallel with either the X or Y axis (any direction).
` boolean` `isZeroVector()`
Checks if vector has a magnitude equals or close to zero (tolerance used is `MathUtils.EPS`).
` float` `magnitude()`
Calculates the magnitude/eucledian length of the vector
` float` `magSquared()`
Calculates only the squared magnitude/length of the vector.
` Vec2D` `max(Vec2D v)`
Constructs a new vector consisting of the largest components of both vectors.
` Vec2D` `min(Vec2D v)`
Constructs a new vector consisting of the smallest components of both vectors.
` Vec2D` `scale(float s)`
Scales vector uniformly and returns result as new vector.
` Vec2D` ```scale(float a, float b)```
Scales vector non-uniformly and returns result as new vector.
` Vec2D` `scale(ReadonlyVec2D s)`

` Vec2D` `scale(Vec2D s)`
Scales vector non-uniformly by vector v and returns result as new vector
` Vec2D` ```sub(float a, float b)```
Subtracts vector {a,b,c} and returns result as new vector.
` Vec2D` `sub(ReadonlyVec2D v)`

` Vec2D` `sub(Vec2D v)`
Subtracts vector v and returns result as new vector.
` Vec2D` ```tangentNormalOfEllipse(Vec2D eO, Vec2D eR)```
Calculates the normal vector on the given ellipse in the direction of the current point.
` Vec3D` `to3DXY()`
Creates a 3D version of this vector in the XY plane.
` Vec3D` `to3DXZ()`
Creates a 3D version of this vector in the XZ plane.
` Vec3D` `to3DYZ()`
Creates a 3D version of this vector in the YZ plane.
` float[]` `toArray()`

` Vec2D` `toCartesian()`
Converts the vector from polar to Cartesian space.
` Vec2D` `toPolar()`
Converts the current vector into polar coordinates.
` float` `x()`

` float` `y()`

Method Detail

```Vec2D add(float a,
float b)```
Adds vector {a,b,c} and returns result as new vector.

Parameters:
`a` - X coordinate
`b` - Y coordinate
Returns:
result as new vector

`Vec2D add(ReadonlyVec2D v)`
Add vector v and returns result as new vector.

Parameters:
`v` - vector to add
Returns:
result as new vector

### angleBetween

`float angleBetween(ReadonlyVec2D v)`
Computes the angle between this vector and vector V. This function assumes both vectors are normalized, if this can't be guaranteed, use the alternative implementation `angleBetween(ReadonlyVec2D, boolean)`

Parameters:
`v` - vector
Returns:
angle in radians, or NaN if vectors are parallel

### angleBetween

```float angleBetween(ReadonlyVec2D v,
boolean forceNormalize)```
Computes the angle between this vector and vector V

Parameters:
`v` - vector
`forceNormalize` - true, if normalized versions of the vectors are to be used (Note: only copies will be used, original vectors will not be altered by this method)
Returns:
angle in radians, or NaN if vectors are parallel

### bisect

`Vec3D bisect(Vec2D p)`
Computes the perpendicular bisector of two points.

Parameters:
`p` - other point
Returns:
bisector coefficients as `Vec3D`

### compareTo

`int compareTo(ReadonlyVec2D v)`
Compares the length of the vector with another one.

Parameters:
`v` - vector to compare with
Returns:
-1 if other vector is longer, 0 if both are equal or else +1

### copy

`Vec2D copy()`
Returns:
a new independent instance/copy of a given vector

### cross

`float cross(ReadonlyVec2D v)`
Calculates the cross-product with the given vector.

Parameters:
`v` - vector
Returns:
the magnitude of the vector that would result from a regular 3D cross product of the input vectors, taking their Z values implicitly as 0 (i.e. treating the 2D space as a plane in the 3D space). The 3D cross product will be perpendicular to that plane, and thus have 0 X & Y components (thus the scalar returned is the Z value of the 3D cross product vector).
Stackoverflow entry

### distanceTo

`float distanceTo(ReadonlyVec2D v)`
Calculates distance to another vector

Parameters:
`v` - non-null vector
Returns:
distance or Float.NaN if v=null

### distanceToSquared

`float distanceToSquared(ReadonlyVec2D v)`
Calculates the squared distance to another vector

Parameters:
`v` - non-null vector
Returns:
distance or NaN if v=null
`magSquared()`

### dot

`float dot(ReadonlyVec2D v)`
Computes the scalar product (dot product) with the given vector.

Parameters:
`v` -
Returns:
dot product
Wikipedia entry< /a>

### equals

`boolean equals(java.lang.Object obj)`
Overrides:
`equals` in class `java.lang.Object`

### equalsWithTolerance

```boolean equalsWithTolerance(ReadonlyVec2D v,
float tolerance)```
Compares this vector with the one given. The vectors are deemed equal if the individual differences of all component values are within the given tolerance.

Parameters:
`v` - the v
`tolerance` - the tolerance
Returns:
true, if equal

### getAbs

`Vec2D getAbs()`

### getComponent

`float getComponent(Vec2D.Axis id)`

### getComponent

`float getComponent(int id)`

### getConstrained

`Vec2D getConstrained(Rect r)`
Creates a copy of the vector which forcefully fits in the given rectangle.

Parameters:
`r` -
Returns:
fitted vector

### getFloored

`Vec2D getFloored()`
Creates a new vector whose components are the integer value of their current values

Returns:
result as new vector

### getFrac

`Vec2D getFrac()`
Creates a new vector whose components are the fractional part of their current values

Returns:
result as new vector

### getInverted

`Vec2D getInverted()`
Scales vector uniformly by factor -1 ( v = -v )

Returns:
result as new vector

### getLimited

`Vec2D getLimited(float lim)`
Creates a copy of the vector with its magnitude limited to the length given

Parameters:
`lim` - new maximum magnitude
Returns:
result as new vector

### getNormalized

`Vec2D getNormalized()`
Produces the normalized version as a new vector

Returns:
new vector

### getNormalizedTo

`Vec2D getNormalizedTo(float len)`
Produces a new vector normalized to the given length.

Parameters:
`len` - new desired length
Returns:
new vector

### getPerpendicular

`Vec2D getPerpendicular()`

### getReciprocal

`Vec2D getReciprocal()`

### getReflected

`Vec2D getReflected(ReadonlyVec2D normal)`

### getRotated

`Vec2D getRotated(float theta)`
Creates a new vector rotated by the given angle around the Z axis.

Parameters:
`theta` -
Returns:
rotated vector

### getSignum

`Vec2D getSignum()`
Creates a new vector in which all components are replaced with the signum of their original values. In other words if a components value was negative its new value will be -1, if zero => 0, if positive => +1

Returns:
result vector

`float heading()`
Computes the vector's direction in the XY plane (for example for 2D points). The positive X axis equals 0 degrees.

Returns:
rotation angle

### interpolateTo

```Vec2D interpolateTo(ReadonlyVec2D v,
float f)```
Interpolates the vector towards the given target vector, using linear interpolation

Parameters:
`v` - target vector
`f` - interpolation factor (should be in the range 0..1)
Returns:
result as new vector

### interpolateTo

```Vec2D interpolateTo(ReadonlyVec2D v,
float f,
InterpolateStrategy s)```
Interpolates the vector towards the given target vector, using the given `InterpolateStrategy`

Parameters:
`v` - target vector
`f` - interpolation factor (should be in the range 0..1)
`s` - InterpolateStrategy instance
Returns:
result as new vector

### isInCircle

```boolean isInCircle(ReadonlyVec2D sO,
float sR)```
Checks if the point is inside the given sphere.

Parameters:
`sO` - circle origin/centre
`sR` - circle radius
Returns:
true, if point is in sphere

### isInRectangle

`boolean isInRectangle(Rect r)`
Checks if the point is inside the given rectangle.

Parameters:
`r` - bounding rectangle
Returns:
true, if point is inside

### isInTriangle

```boolean isInTriangle(Vec2D a,
Vec2D b,
Vec2D c)```
Checks if point vector is inside the triangle created by the points a, b and c. These points will create a plane and the point checked will have to be on this plane in the region between a,b,c. Note: The triangle must be defined in clockwise order a,b,c

Returns:
true, if point is in triangle.

### isMajorAxis

`boolean isMajorAxis(float tolerance)`
Checks if the vector is parallel with either the X or Y axis (any direction).

Parameters:
`tolerance` -
Returns:
true, if parallel within the given tolerance

### isZeroVector

`boolean isZeroVector()`
Checks if vector has a magnitude equals or close to zero (tolerance used is `MathUtils.EPS`).

Returns:
true, if zero vector

### magnitude

`float magnitude()`
Calculates the magnitude/eucledian length of the vector

Returns:
vector length

### magSquared

`float magSquared()`
Calculates only the squared magnitude/length of the vector. Useful for inverse square law applications and/or for speed reasons or if the real eucledian distance is not required (e.g. sorting). Please note the vector should contain cartesian (not polar) coordinates in order for this function to work. The magnitude of polar vectors is stored in the x component.

Returns:
squared magnitude (x^2 + y^2)

### max

`Vec2D max(Vec2D v)`
Constructs a new vector consisting of the largest components of both vectors.

Parameters:
`v` -
Returns:
result as new vector

### min

`Vec2D min(Vec2D v)`
Constructs a new vector consisting of the smallest components of both vectors.

Parameters:
`v` - comparing vector
Returns:
result as new vector

### scale

`Vec2D scale(float s)`
Scales vector uniformly and returns result as new vector.

Parameters:
`s` - scale factor
Returns:
new vector

### scale

```Vec2D scale(float a,
float b)```
Scales vector non-uniformly and returns result as new vector.

Parameters:
`a` - scale factor for X coordinate
`b` - scale factor for Y coordinate
Returns:
new vector

### scale

`Vec2D scale(ReadonlyVec2D s)`

### scale

`Vec2D scale(Vec2D s)`
Scales vector non-uniformly by vector v and returns result as new vector

Parameters:
`s` - scale vector
Returns:
new vector

### sub

```Vec2D sub(float a,
float b)```
Subtracts vector {a,b,c} and returns result as new vector.

Parameters:
`a` - X coordinate
`b` - Y coordinate
Returns:
result as new vector

### sub

`Vec2D sub(ReadonlyVec2D v)`

### sub

`Vec2D sub(Vec2D v)`
Subtracts vector v and returns result as new vector.

Parameters:
`v` - vector to be subtracted
Returns:
result as new vector

### tangentNormalOfEllipse

```Vec2D tangentNormalOfEllipse(Vec2D eO,
Vec2D eR)```
Calculates the normal vector on the given ellipse in the direction of the current point.

Parameters:
`eO` - ellipse origin/centre
`eR` - ellipse radii
Returns:
a unit normal vector to the tangent plane of the ellipsoid in the point.

### to3DXY

`Vec3D to3DXY()`
Creates a 3D version of this vector in the XY plane.

Returns:
3D vector

### to3DXZ

`Vec3D to3DXZ()`
Creates a 3D version of this vector in the XZ plane. (The 2D Y coordinate interpreted as Z)

Returns:
3D vector

### to3DYZ

`Vec3D to3DYZ()`
Creates a 3D version of this vector in the YZ plane. (The 2D X coordinate interpreted as Y & 2D Y as Z)

Returns:
3D vector

### toArray

`float[] toArray()`

### toCartesian

`Vec2D toCartesian()`
Converts the vector from polar to Cartesian space. Assumes this order: x=radius, y=theta

Returns:
itself as Cartesian vector

### toPolar

`Vec2D toPolar()`
Converts the current vector into polar coordinates. After the conversion the x component of the vector contains the radius (magnitude) and y the rotation angle.

Returns:
itself as polar vector

### x

`float x()`

### y

`float y()`