Vec (Javadocs: proscene)

java.lang.Object
- remixlab.dandelion.geom.Vec

All Implemented Interfaces:

Linkable, Copyable
```
public class Vec
extends Object
implements Linkable
```
A class to describe a two or three dimensional vector. This class API aims to conform that of the great Processing PVector.
The result of all functions are applied to the vector itself, with the exception of cross(), which returns a new Vec (or writes to a specified 'target' Vec). That is, add() will add the contents of one vector to this one. Using add() with additional parameters allows you to put the result into a new Vec. Functions that act on multiple vectors also include static versions. Because creating new objects can be computationally expensive, most functions include an optional 'target' Vec, so that a new Vec object is not created with each operation.
Initially based on the Processing PVector class.

Field Summary

Fields
Modifier and Type Field and Description

float[] vec
The x, y and z coordinates of the Vec.

Fields
Modifier and Type	Field and Description
`float[]`	`vec` The x, y and z coordinates of the Vec.

Constructor Summary

Constructors
Constructor and Description
`Vec()` Constructor for an empty vector: x, y, and z are set to 0.
`Vec(float x, float y)` Constructor for a 2D vector: z coordinate is set to 0.
`Vec(float x, float y, float z)` Constructor for a 3D vector.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`add(float x, float y, float z)`
`void`	`add(Vec v)` Add a vector to this vector
`static Vec`	`add(Vec v1, Vec v2)` Add two vectors
`static Vec`	`add(Vec v1, Vec v2, Vec target)` Add two vectors into a target vector
`static float`	`angleBetween(Vec v1, Vec v2)` Calculate the angle between two vectors, using the dot product.
`Vec`	`cross(Vec v)` Return a vector composed of the cross product between this and another.
`Vec`	`cross(Vec v, Vec target)` Perform cross product between this and another vector, and store the result in 'target'.
`static Vec`	`cross(Vec v1, Vec v2, Vec target)`
`float`	`distance(Vec v)` Calculate the Euclidean distance between two points (considering a point as a vector object)
`static float`	`distance(Vec v1, Vec v2)` Calculate the Euclidean distance between two points (considering a point as a vector object)
`void`	`divide(float n)` Divide this vector by a scalar
`static Vec`	`divide(Vec v, float n)` Divide a vector by a scalar and return the result in a new vector.
`static Vec`	`divide(Vec v, float n, Vec target)` Divide a vector by a scalar and store the result in another vector.
`float`	`dot(float x, float y, float z)`
`float`	`dot(Vec v)` Calculate the dot product with another vector
`static float`	`dot(Vec v1, Vec v2)`
`boolean`	`equals(Object obj)`
`static Vec`	`fromAngle(float angle)` Make a new 2D unit vector from an angle.
`static Vec`	`fromAngle(float angle, Vec target)` Make a new 2D unit vector from an angle
`Vec`	`get()` Get a copy of this vector.
`float[]`	`get(float[] target)` Gets data as an array
`int`	`hashCode()`
`float`	`heading()` Calculate the angle of rotation for this vector (only 2D vectors)
`void`	`lerp(float x, float y, float z, float amt)` Linear interpolate the vector to x,y,z values.
`void`	`lerp(Vec v, float amt)` Linear interpolate the vector to another vector
`static Vec`	`lerp(Vec v1, Vec v2, float amt)` Linear interpolate between two vectors (returns a new Vec object).
`void`	`limit(float max)` Limit the magnitude of this vector
`void`	`link(float[] src)` Share the src array data.
`float`	`magnitude()` Calculate the magnitude (length) of the vector
`void`	`multiply(float n)` Multiply this vector by a scalar
`static Vec`	`multiply(Vec v, float n)` Multiply a vector by a scalar
`static Vec`	`multiply(Vec v, float n, Vec target)` Multiply a vector by a scalar, and write the result into a target Vec.
`void`	`normalize()` Normalize the vector to length 1 (make it a unit vector)
`Vec`	`normalize(Vec target)` Normalize this vector, storing the result in another vector.
`Vec`	`orthogonalVector()` Same as `return orthogonalVector(this)`.
`static Vec`	`orthogonalVector(Vec v)` Utility function that returns a Vec orthogonal to `v`.
`void`	`print()`
`Vec`	`projectVectorOnAxis(Vec direction)` Same as `return projectVectorOnAxis(this, direction)`.
`static Vec`	`projectVectorOnAxis(Vec src, Vec direction)` Projects the `src` Vec on the axis defined by `direction` (which does not need to be normalized, but must be non null) that passes through the origin.
`Vec`	`projectVectorOnPlane(Vec normal)` Same as `projectVectorOnPlane(this, normal)`.
`static Vec`	`projectVectorOnPlane(Vec src, Vec normal)` Projects `src` on the plane defined by `normal` (which does not need to be normalized, but must be non null) that passes through the origin.
`void`	`reset()` Sets all Vec components to 0.
`void`	`rotate(float theta)` Rotate the vector by an angle (only 2D vectors), magnitude remains the same
`void`	`set(float[] source)` Set the x, y (and maybe z) coordinates using a float[] array as the source.
`void`	`set(float x, float y, float z)` Set x, y, and z coordinates.
`void`	`set(Linkable v)` Set x, y, and z coordinates from a Vec object.
`void`	`set(Vec v)`
`void`	`setMagnitude(float len)` Sets the magnitude of the vector to an arbitrary amount.
`Vec`	`setMagnitude(Vec target, float len)` Sets the magnitude of this vector, storing the result in another vector.
`void`	`setX(float x)` Sets the x component of the Vec.
`void`	`setY(float y)` Sets the y component of the Vec.
`void`	`setZ(float z)` Sets the z component of the Vec.
`float`	`squaredMagnitude()` Calculate the squared magnitude of the vector Faster if the real length is not required in the case of comparing vectors, etc.
`float`	`squaredNorm()` Same as `return squaredNorm(this)`.
`static float`	`squaredNorm(Vec v)` Utility function that returns the squared norm of the Vec.
`void`	`subtract(float x, float y, float z)`
`void`	`subtract(Vec v)` Subtract a vector from this vector
`static Vec`	`subtract(Vec v1, Vec v2)` Subtract one vector from another
`static Vec`	`subtract(Vec v1, Vec v2, Vec target)` Subtract one vector from another and store in another vector
`String`	`toString()`
`void`	`unLink()` Stop sharing data with the source
`float`	`x()` Returns the x component of the Vec.
`float`	`y()` Returns the y component of the Vec.
`float`	`z()` Returns the z component of the Vec.

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - vec
```
public float[] vec
```
    The x, y and z coordinates of the Vec.
- Constructor Detail
  - Vec
```
public Vec()
```
    Constructor for an empty vector: x, y, and z are set to 0.
  - Vec
```
public Vec(float x,
           float y,
           float z)
```
    Constructor for a 3D vector.
    
    Parameters:
    
    x - the x coordinate.
    
    y - the y coordinate.
    
    z - the y coordinate.
  - Vec
```
public Vec(float x,
           float y)
```
    Constructor for a 2D vector: z coordinate is set to 0.
    
    Parameters:
    
    x - the x coordinate.
    
    y - the y coordinate.
- Method Detail
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - equals
```
public boolean equals(Object obj)
```
    Overrides:
    
    equals in class Object
  - x
```
public float x()
```
    Returns the x component of the Vec.
  - y
```
public float y()
```
    Returns the y component of the Vec.
  - z
```
public float z()
```
    Returns the z component of the Vec.
  - setX
```
public void setX(float x)
```
    Sets the x component of the Vec.
  - setY
```
public void setY(float y)
```
    Sets the y component of the Vec.
  - setZ
```
public void setZ(float z)
```
    Sets the z component of the Vec.
  - projectVectorOnAxis
```
public Vec projectVectorOnAxis(Vec direction)
```
    Same as return projectVectorOnAxis(this, direction).
    
    See Also:
    
    projectVectorOnAxis(Vec, Vec)
  - projectVectorOnAxis
```
public static Vec projectVectorOnAxis(Vec src,
                                      Vec direction)
```
    Projects the src Vec on the axis defined by direction (which does not need to be normalized, but must be non null) that passes through the origin.
  - projectVectorOnPlane
```
public Vec projectVectorOnPlane(Vec normal)
```
    Same as projectVectorOnPlane(this, normal).
    
    See Also:
    
    projectVectorOnPlane(Vec, Vec)
  - projectVectorOnPlane
```
public static Vec projectVectorOnPlane(Vec src,
                                       Vec normal)
```
    Projects src on the plane defined by normal (which does not need to be normalized, but must be non null) that passes through the origin.
  - squaredNorm
```
public float squaredNorm()
```
    Same as return squaredNorm(this).
    
    See Also:
    
    squaredNorm(Vec)
  - squaredNorm
```
public static float squaredNorm(Vec v)
```
    Utility function that returns the squared norm of the Vec.
  - orthogonalVector
```
public Vec orthogonalVector()
```
    Same as return orthogonalVector(this).
    
    See Also:
    
    orthogonalVector(Vec)
  - orthogonalVector
```
public static Vec orthogonalVector(Vec v)
```
    Utility function that returns a Vec orthogonal to v. Its mag() depends on the Vec, but is zero only for a null Vec. Note that the function that associates an orthogonalVector() to a Vec is not continuous.
  - link
```
public void link(float[] src)
```
    Description copied from interface: Linkable
    
    Share the src array data.
    
    Specified by:
    
    link in interface Linkable
  - unLink
```
public void unLink()
```
    Description copied from interface: Linkable
    
    Stop sharing data with the source
    
    Specified by:
    
    unLink in interface Linkable
  - reset
```
public void reset()
```
    Sets all Vec components to 0.
    
    Specified by:
    
    reset in interface Linkable
  - set
```
public void set(float x,
                float y,
                float z)
```
    Set x, y, and z coordinates.
    
    Parameters:
    
    x - the x coordinate.
    
    y - the y coordinate.
    
    z - the z coordinate.
  - set
```
public void set(Linkable v)
```
    Set x, y, and z coordinates from a Vec object.
    
    Specified by:
    
    set in interface Linkable
    
    Parameters:
    
    v - the Vec object to be copied
  - set
```
public void set(Vec v)
```
  - set
```
public void set(float[] source)
```
    Set the x, y (and maybe z) coordinates using a float[] array as the source.
    
    Specified by:
    
    set in interface Linkable
    
    Parameters:
    
    source - array to copy from
  - get
```
public Vec get()
```
    Get a copy of this vector.
    
    Specified by:
    
    get in interface Linkable
    
    Specified by:
    
    get in interface Copyable
  - get
```
public float[] get(float[] target)
```
    Description copied from interface: Linkable
    
    Gets data as an array
    
    Specified by:
    
    get in interface Linkable
  - magnitude
```
public float magnitude()
```
    Calculate the magnitude (length) of the vector
    
    Returns:
    
    the magnitude of the vector
  - squaredMagnitude
```
public float squaredMagnitude()
```
    Calculate the squared magnitude of the vector Faster if the real length is not required in the case of comparing vectors, etc.
    
    Returns:
    
    squared magnitude of the vector
  - add
```
public void add(Vec v)
```
    Add a vector to this vector
    
    Parameters:
    
    v - the vector to be added
  - add
```
public void add(float x,
                float y,
                float z)
```
    Parameters:
    
    x - x component of the vector
    
    y - y component of the vector
    
    z - z component of the vector
  - add
```
public static Vec add(Vec v1,
                      Vec v2)
```
    Add two vectors
    
    Parameters:
    
    v1 - a vector
    
    v2 - another vector
    
    Returns:
    
    a new vector that is the sum of v1 and v2
  - add
```
public static Vec add(Vec v1,
                      Vec v2,
                      Vec target)
```
    Add two vectors into a target vector
    
    Parameters:
    
    v1 - a vector
    
    v2 - another vector
    
    target - the target vector (if null, a new vector will be created)
    
    Returns:
    
    a new vector that is the sum of v1 and v2
  - subtract
```
public void subtract(Vec v)
```
    Subtract a vector from this vector
    
    Parameters:
    
    v - the vector to be subtracted
  - subtract
```
public void subtract(float x,
                     float y,
                     float z)
```
    Parameters:
    
    x - the x component of the vector
    
    y - the y component of the vector
    
    z - the z component of the vector
  - subtract
```
public static Vec subtract(Vec v1,
                           Vec v2)
```
    Subtract one vector from another
    
    Parameters:
    
    v1 - a vector
    
    v2 - another vector
    
    Returns:
    
    a new vector that is v1 - v2
  - subtract
```
public static Vec subtract(Vec v1,
                           Vec v2,
                           Vec target)
```
    Subtract one vector from another and store in another vector
    
    Parameters:
    
    v1 - the x, y, and z components of a Vec object
    
    v2 - the x, y, and z components of a Vec object
    
    target - Vec in which to store the result
  - multiply
```
public void multiply(float n)
```
    Multiply this vector by a scalar
    
    Parameters:
    
    n - the value to multiply by
  - multiply
```
public static Vec multiply(Vec v,
                           float n)
```
    Multiply a vector by a scalar
    
    Parameters:
    
    v - a vector
    
    n - scalar
    
    Returns:
    
    a new vector that is v1 * n
  - multiply
```
public static Vec multiply(Vec v,
                           float n,
                           Vec target)
```
    Multiply a vector by a scalar, and write the result into a target Vec.
    
    Parameters:
    
    v - a vector
    
    n - scalar
    
    target - Vec to store the result
    
    Returns:
    
    the target vector, now set to v1 * n
  - divide
```
public void divide(float n)
```
    Divide this vector by a scalar
    
    Parameters:
    
    n - the value to divide by
  - divide
```
public static Vec divide(Vec v,
                         float n)
```
    Divide a vector by a scalar and return the result in a new vector.
    
    Parameters:
    
    v - a vector
    
    n - scalar
    
    Returns:
    
    a new vector that is v1 / n
  - divide
```
public static Vec divide(Vec v,
                         float n,
                         Vec target)
```
    Divide a vector by a scalar and store the result in another vector.
    
    Parameters:
    
    target - Vec in which to store the result
  - distance
```
public float distance(Vec v)
```
    Calculate the Euclidean distance between two points (considering a point as a vector object)
    
    Parameters:
    
    v - another vector
    
    Returns:
    
    the Euclidean distance between
  - distance
```
public static float distance(Vec v1,
                             Vec v2)
```
    Calculate the Euclidean distance between two points (considering a point as a vector object)
    
    Parameters:
    
    v1 - a vector
    
    v2 - another vector
    
    Returns:
    
    the Euclidean distance between v1 and v2
  - dot
```
public float dot(Vec v)
```
    Calculate the dot product with another vector
    
    Returns:
    
    the dot product
  - dot
```
public float dot(float x,
                 float y,
                 float z)
```
    Parameters:
    
    x - x component of the vector
    
    y - y component of the vector
    
    z - z component of the vector
  - dot
```
public static float dot(Vec v1,
                        Vec v2)
```
    Parameters:
    
    v1 - any variable of type Vec
    
    v2 - any variable of type Vec
  - cross
```
public Vec cross(Vec v)
```
    Return a vector composed of the cross product between this and another.
  - cross
```
public Vec cross(Vec v,
                 Vec target)
```
    Perform cross product between this and another vector, and store the result in 'target'. If target is null, a new vector is created.
  - cross
```
public static Vec cross(Vec v1,
                        Vec v2,
                        Vec target)
```
    Parameters:
    
    v1 - any variable of type Vec
    
    v2 - any variable of type Vec
    
    target - Vec to store the result
  - normalize
```
public void normalize()
```
    Normalize the vector to length 1 (make it a unit vector)
  - normalize
```
public Vec normalize(Vec target)
```
    Normalize this vector, storing the result in another vector.
    
    Parameters:
    
    target - Set to null to create a new vector
    
    Returns:
    
    a new vector (if target was null), or target
  - limit
```
public void limit(float max)
```
    Limit the magnitude of this vector
    
    Parameters:
    
    max - the maximum length to limit this vector
  - setMagnitude
```
public void setMagnitude(float len)
```
    Sets the magnitude of the vector to an arbitrary amount.
    
    Parameters:
    
    len - the new length for this vector
  - setMagnitude
```
public Vec setMagnitude(Vec target,
                        float len)
```
    Sets the magnitude of this vector, storing the result in another vector.
    
    Parameters:
    
    target - Set to null to create a new vector
    
    len - the new length for the new vector
    
    Returns:
    
    a new vector (if target was null), or target
  - heading
```
public float heading()
```
    Calculate the angle of rotation for this vector (only 2D vectors)
    
    Returns:
    
    the angle of rotation
  - rotate
```
public void rotate(float theta)
```
    Rotate the vector by an angle (only 2D vectors), magnitude remains the same
    
    Parameters:
    
    theta - the angle of rotation
  - lerp
```
public void lerp(Vec v,
                 float amt)
```
    Linear interpolate the vector to another vector
    
    Parameters:
    
    v - the vector to lerp to
    
    amt - The amt parameter is the amount to interpolate between the two vectors where 1.0 equal to the new vector 0.1 is very near the new vector, 0.5 is half-way in between.
  - lerp
```
public static Vec lerp(Vec v1,
                       Vec v2,
                       float amt)
```
    Linear interpolate between two vectors (returns a new Vec object).
    
    Parameters:
    
    v1 - the vector to start from
    
    v2 - the vector to lerp to
  - lerp
```
public void lerp(float x,
                 float y,
                 float z,
                 float amt)
```
    Linear interpolate the vector to x,y,z values.
    
    Parameters:
    
    x - the x component to lerp to
    
    y - the y component to lerp to
    
    z - the z component to lerp to
  - angleBetween
```
public static float angleBetween(Vec v1,
                                 Vec v2)
```
    Calculate the angle between two vectors, using the dot product.
    
    Parameters:
    
    v1 - a vector
    
    v2 - another vector
    
    Returns:
    
    the angle between the vectors
  - fromAngle
```
public static Vec fromAngle(float angle)
```
    Make a new 2D unit vector from an angle.
    
    Parameters:
    
    angle - the angle
    
    Returns:
    
    the new unit PVec
  - fromAngle
```
public static Vec fromAngle(float angle,
                            Vec target)
```
    Make a new 2D unit vector from an angle
    
    Parameters:
    
    angle - the angle
    
    target - the target vector (if null, a new vector will be created)
    
    Returns:
    
    the Vec
  - print
```
public void print()
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class Vec

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

vec

Constructor Detail

Vec

Vec

Vec

Method Detail

hashCode

equals

x

y

z

setX

setY

setZ

projectVectorOnAxis

projectVectorOnAxis

projectVectorOnPlane

projectVectorOnPlane

squaredNorm

squaredNorm

orthogonalVector

orthogonalVector

link

unLink

reset

set

set

set

set

get

get

magnitude

squaredMagnitude

add

add

add

add

subtract

subtract

subtract

subtract

multiply

multiply

multiply

divide

divide

divide

distance

distance

dot

dot

dot

cross

cross

cross

normalize

normalize

limit

setMagnitude

setMagnitude

heading

rotate

lerp

lerp

lerp

angleBetween

fromAngle

fromAngle

print

toString