org.jagatoo.util.arrays
Class ArrayVector

java.lang.Object
  extended by org.jagatoo.util.arrays.ArrayVector

public final class ArrayVector
extends java.lang.Object

Utility class, that provides vector-arithmetic methods to be applied to float arrays.


Constructor Summary
ArrayVector()
           
 
Method Summary
static void absolute(float[] v1)
          Sets each compnent of the given vector v1 to its absolute.
static void add(float[] a, float[] b, float[] o)
          Adds the array a componentwise to the array b and puts the result into o.
static float angle(float[] v1, float[] v2)
          Returns the angle in radians between vector v1 and v2;
The return value is constrained to the range [0, PI].
static void clamp(float min, float max, float[] v)
          Clamps the trg vector to the range [min, max].
static void clamp(float min, float max, float[] src, float[] trg)
          Clamps the src vector parameter to the range [min, max] and places the values into the trg vector.
static void clampMax(float max, float[] v)
          Clamps the maximum value of the given vector to the max parameter.
static void clampMax(float max, float[] src, float[] trg)
          Clamps the maximum value of the tuple parameter to the max parameter and places the values into the trg vector.
static void clampMin(float min, float[] v)
          Clamps the minimum value of the given vector to the min parameter.
static void clampMin(float min, float[] src, float[] trg)
          Clamps the minimum value of the tuple parameter to the min parameter and places the values into the trg vector.
static float[] clone(float[] v)
          Creates a new instance of this float array and copies all values.
static void cross(float[] v1, float[] v2, float[] o)
          Sets vector o to be the vector cross product of vectors v1 and v2.
static float distance(float[] p1, float[] p2)
          Returns the distance between points p1 and p2.
static float distanceSquared(float[] p1, float[] p2)
          Computes the square of the distance between points p1 and p2.
static float dot(float[] v1, float[] v2)
          Computes the dot product of the vectors v1 and v2.
static void interpolate(float[] v1, float[] v2, float alpha)
          Linearly interpolates between vector v1 and t2 and places the result into v1: v1 = (1 - alpha) * v1 + alpha * v2.
static void interpolate(float[] v1, float[] v2, float alpha, float[] o)
          Linearly interpolates between vectors v1 and v2 and places the result into vector o: o = (1 - alpha) * v1 + alpha * v2.
static float length(float[] vector)
          Returns the length of the given vector.
static float lengthSquared(float[] vector)
          Returns the squared length of the given vector.
static void negate(float[] v1)
          Negates the given vector v1.
static void normalize(float[] v1)
          Normalizes the given vector v1.
static void round(float[] v, int decPlaces)
          Rounds the vector to the given number of decimal places.
static void scale(float factor, float[] vector)
          Sets the value of the given vector to the scalar multiplication of vector v1.
static void set(float[] src, float[] trg)
          Sets the elements of dst to src.
static void sub(float[] a, float[] b, float[] o)
          Subtracts the array b componentwise from the array a and puts the result into o.
static java.lang.String toString(float[] vector)
          Creates a String representation of the given vector.
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

ArrayVector

public ArrayVector()
Method Detail

sub

public static final void sub(float[] a,
                             float[] b,
                             float[] o)
Subtracts the array b componentwise from the array a and puts the result into o.

Parameters:
a -
b -
o -

add

public static final void add(float[] a,
                             float[] b,
                             float[] o)
Adds the array a componentwise to the array b and puts the result into o.

Parameters:
a -
b -
o -

lengthSquared

public static final float lengthSquared(float[] vector)
Returns the squared length of the given vector.

Returns:
the squared length of the given vector

length

public static final float length(float[] vector)
Returns the length of the given vector.

Returns:
the length of the given vector

distanceSquared

public static final float distanceSquared(float[] p1,
                                          float[] p2)
Computes the square of the distance between points p1 and p2.

Parameters:
p1 - the first point
p2 - the other point
Returns:
the square of distance between these two points as a float

distance

public static final float distance(float[] p1,
                                   float[] p2)
Returns the distance between points p1 and p2.

Parameters:
p1 - the first point
p2 - the other point
Returns:
the distance between these two points

cross

public static final void cross(float[] v1,
                               float[] v2,
                               float[] o)
Sets vector o to be the vector cross product of vectors v1 and v2.

Parameters:
v1 - the first vector
v2 - the second vector
o - the output vector

dot

public static final float dot(float[] v1,
                              float[] v2)
Computes the dot product of the vectors v1 and v2.

Parameters:
v1 - the first vector
v2 - the other vector

set

public static final void set(float[] src,
                             float[] trg)
Sets the elements of dst to src.

Parameters:
src - the source vector
trg - the target vector

clone

public static final float[] clone(float[] v)
Creates a new instance of this float array and copies all values.

Parameters:
v - the source float array
Returns:
the new equal instance

normalize

public static final void normalize(float[] v1)
Normalizes the given vector v1.

Parameters:
v1 - the input vector

scale

public static final void scale(float factor,
                               float[] vector)
Sets the value of the given vector to the scalar multiplication of vector v1.

Parameters:
factor - the scalar value
vector - the vector to be scaled

negate

public static final void negate(float[] v1)
Negates the given vector v1.

Parameters:
v1 - the input vector

absolute

public static final void absolute(float[] v1)
Sets each compnent of the given vector v1 to its absolute.

Parameters:
v1 - the input vector

angle

public static final float angle(float[] v1,
                                float[] v2)
Returns the angle in radians between vector v1 and v2;
The return value is constrained to the range [0, PI].

Parameters:
v1 - the first vector
v2 - the seconds vector
Returns:
the angle in radians in the range [0, PI]

clampMin

public static final void clampMin(float min,
                                  float[] v)
Clamps the minimum value of the given vector to the min parameter.

Parameters:
min - the lowest value in the vector after clamping
v - teh vector to clamp (modify)

clampMin

public static final void clampMin(float min,
                                  float[] src,
                                  float[] trg)
Clamps the minimum value of the tuple parameter to the min parameter and places the values into the trg vector.

Parameters:
min - the lowest value in the tuple after clamping
src - the source tuple, which will not be modified
trg - the target tuple, which will be modified

clampMax

public static final void clampMax(float max,
                                  float[] v)
Clamps the maximum value of the given vector to the max parameter.

Parameters:
max - the largest value in the vector after clamping
v - the vector to clamp (modify)

clampMax

public static final void clampMax(float max,
                                  float[] src,
                                  float[] trg)
Clamps the maximum value of the tuple parameter to the max parameter and places the values into the trg vector.

Parameters:
max - the lowest value in the tuple after clamping
src - the source tuple, which will not be modified
trg - the target tuple, which will be modified

clamp

public static final void clamp(float min,
                               float max,
                               float[] v)
Clamps the trg vector to the range [min, max].

Parameters:
min - the lowest value in the vector after clamping
max - the highest value in the vector after clamping

clamp

public static final void clamp(float min,
                               float max,
                               float[] src,
                               float[] trg)
Clamps the src vector parameter to the range [min, max] and places the values into the trg vector.

Parameters:
min - the lowest value in the vector after clamping
max - the highest value in the vector after clamping
src - the source vector, which will not be modified
trg - the target vector, which will be modified

round

public static void round(float[] v,
                         int decPlaces)
Rounds the vector to the given number of decimal places.

Parameters:
v -
decPlaces -

interpolate

public static final void interpolate(float[] v1,
                                     float[] v2,
                                     float alpha)
Linearly interpolates between vector v1 and t2 and places the result into v1: v1 = (1 - alpha) * v1 + alpha * v2.

Parameters:
v1 - the first vector
v2 - the second vector
alpha - the alpha interpolation parameter

interpolate

public static final void interpolate(float[] v1,
                                     float[] v2,
                                     float alpha,
                                     float[] o)
Linearly interpolates between vectors v1 and v2 and places the result into vector o: o = (1 - alpha) * v1 + alpha * v2.

Parameters:
v1 - the first vector
v2 - the second vector
alpha - the alpha interpolation parameter

toString

public static final java.lang.String toString(float[] vector)
Creates a String representation of the given vector.

Parameters:
vector -
Returns:
the String