maspack.matrix
Class Vector3d

java.lang.Object
  extended by maspack.matrix.VectorBase
      extended by maspack.matrix.Vector3d
All Implemented Interfaces:
java.io.Serializable, java.lang.Cloneable, Vector, Clonable
Direct Known Subclasses:
Point3d

public class Vector3d
extends VectorBase
implements java.io.Serializable, Clonable

Implements a 3 element vector, along with its most commonly used operations.

The size of these vectors is fixed.

See Also:
Serialized Form

Field Summary
static Vector3d NEG_X_UNIT
          Global unit vector along the negative x axis.
static Vector3d NEG_Y_UNIT
          Global unit vector along the negative y axis.
static Vector3d NEG_Z_UNIT
          Global unit vector along the negative z axis.
 double x
          First element
static Vector3d X_UNIT
          Global unit vector along the x axis.
 double y
          Second element
static Vector3d Y_UNIT
          Global unit vector along the y axis.
 double z
          Third element
static Vector3d Z_UNIT
          Global unit vector along the z axis.
static Vector3d ZERO
          Global zero vector.
 
Constructor Summary
Vector3d()
          Creates a 3-vector and initializes its elements to 0.
Vector3d(double[] values)
          Creates a 3-vector with the supplied element values.
Vector3d(double x, double y, double z)
          Creates a 3-vector with the supplied element values.
Vector3d(Vector3d v)
          Creates a 3-vector by copying an existing one.
 
Method Summary
 void absolute()
          Sets the elements of this vector to their absolute values.
 void absolute(Vector3d v1)
          Sets the elements of this vector to the absolute value of v1.
 void add(double dx, double dy, double dz)
          Adds specified increments to the components of this vector.
 void add(Vector3d v1)
          Adds this vector to v1 and places the result in this vector.
 void add(Vector3d v1, Vector3d v2)
          Adds vector v1 to v2 and places the result in this vector.
 double angle(Vector3d v1)
          Returns the angle between this vector and v1.
 void angleWeightedCross(Vector3d p0, Vector3d p1, Vector3d p2)
          Computes the cross product v2 x v1, where v2 = p1 - p2 and v1 = p1 - p0, and then sets the length of the result to the angle between v1 and v2.
 void angleWeightedCrossAdd(Vector3d p0, Vector3d p1, Vector3d p2)
          Computes the cross product v2 x v1, where v2 = p1 - p2 and v1 = p1 - p0, and then sets the length of the result to the angle between v1 and v2.
 Vector3d clone()
           
 void combine(double s1, Vector3d v1, double s2, Vector3d v2)
          Computes s1 v1 + s2 v2 and places the result in this vector.
 void cross(Vector3d v1)
          Computes the cross product of this vector and v1, and places the result in this vector.
 void cross(Vector3d v1, Vector3d v2)
          Computes the cross product of v1 and v2 and places the result in this vector.
 void crossAdd(Vector3d v1, Vector3d v2, Vector3d v3)
          Computes the cross product of v1 and v2, adds this to v3, and places the result in this vector.
 double distance(Vector3d v)
          Returns the Euclidean distance between this vector and vector v.
 double distanceSquared(Vector3d v)
          Returns the squared of the Euclidean distance between this vector and vector v.
 double dot(Vector3d v1)
          Returns the dot product of this vector and v1.
 boolean epsilonEquals(Vector3d v1, double eps)
          Returns true if the elements of this vector equal those of vector v1within a prescribed tolerance epsilon.
 boolean equals(Vector3d v1)
          Returns true if the elements of this vector exactly equal those of vector v1.
 void get(double[] values)
          Copies the elements of this vector into an array of doubles.
 void get(float[] values)
          Copies the elements of this vector into an array of floats.
 double get(int i)
          Gets a single element of this vector.
 void get(Matrix3x1 M)
          Copies the elements of this vector into a Matrix3x1.
 void get(VectorNd v1, int idx)
          Copies the values of this vector into a general length vector v1, starting at a specified index.
 boolean greater(Vector3d v1)
          Returns true if all the elements of this vector are greater than those of vectorv1.
 boolean greaterEquals(Vector3d v1)
          Returns true if all the elements of this vector are greater than or equal to those of vectorv1.
static void hermiteInterpolate(Vector3d pr, Vector3d p0, Vector3d v0, Vector3d p1, Vector3d v1, double s, double h)
          Interpolates the value at a location along a cubic Hermite spline.
static void hermiteVelocity(Vector3d vr, Vector3d p0, Vector3d v0, Vector3d p1, Vector3d v1, double s, double h)
          Interpolates velocity at a location along a cubic Hermite spline.
 double infinityNorm()
          Returns the infinity norm of this vector.
 void interpolate(double s, Vector3d v1)
          Computes the interpolation (1-s) this + s v1 and places the result in this vector.
 void interpolate(Vector3d v1, double s, Vector3d v2)
          Computes the interpolation (1-s) v1 + s v2 and places the result in this vector.
 void inverseTransform(AffineTransform3dBase X)
          Applies an inverse affine transformation to this vector, in place.
 void inverseTransform(AffineTransform3dBase X, Vector3d v1)
          Applies an inverse affine transformation to the vector v1, and places the result in this vector.
 void inverseTransform(RotationMatrix3d R)
          Applies an inverse rotational transformation to this vector, in place.
 void inverseTransform(RotationMatrix3d R, Vector3d v1)
          Applies an inverse rotational transformation to the vector v1, and stores the result in this vector.
static void main(java.lang.String[] args)
           
 void max(Vector3d v)
          Computes the element-wise maximum of this vector and vector v and places the result in this vector.
 int maxAbsIndex()
          Returns the index (0, 1, or 2) of the element of this vector with the largest absolute value.
 double maxElement()
          Returns the maximum element value of this vector.
 void min(Vector3d v)
          Computes the element-wise minimum of this vector and vector v and places the result in this vector.
 int minAbsIndex()
          Returns the index (0, 1, or 2) of the element of this vector with the smallest absolute value.
 double minElement()
          Returns the minimum element value of this vector.
 void mul(Matrix3dBase X, Vector3d v1)
          Multiplies matrix X by vector v1 and places the result in this vector.
 void mulAdd(Matrix3dBase X, Vector3d v1, Vector3d v2)
          Multiplies matrix X by vector v1, adds vector v2, and places the result in this vector.
 void mulTranspose(Matrix3dBase X, Vector3d v1)
          Multiplies the transpose of matrix X by vector v1 and places the result in this vector.
 void mulTransposeAdd(Matrix3dBase X, Vector3d v1, Vector3d v2)
          Multiplies the transpose of matrix X by vector v1, adds vector v2, and places the result in this vector.
 void negate()
          Negates this vector in place.
 void negate(Vector3d v1)
          Sets this vector to the negative of v1.
 double norm()
          Returns the 2 norm of this vector.
 void normalize()
          Normalizes this vector in place.
 void normalize(Vector3d v1)
          Computes a unit vector in the direction of v1 and places the result in this vector.
 double normSquared()
          Returns the square of the 2 norm of this vector.
 double oneNorm()
          Returns the 1 norm of this vector.
 void perpendicular(Vector3d v1)
          Sets this vector to one which is perpendicular to v1.
 void scale(double s)
          Scales the elements of this vector by s.
 void scale(double sx, double sy, double sz)
          Scales the elements of this vector by the values in the given direction.
 void scale(double s, Vector3d v1)
          Scales the elements of vector v1 by s and places the results in this vector.
 void scaledAdd(double s, Vector3d v1)
          Computes s v1 and adds the result to this vector.
 void scaledAdd(double s, Vector3d v1, Vector3d v2)
          Computes s v1 + v2 and places the result in this vector.
 void scan(ReaderTokenizer rtok)
          Sets the contents of this vector to values read from a ReaderTokenizer.
 void set(double[] values)
          Sets the elements of this vector from an array of doubles.
 void set(double x, double y, double z)
          Sets the elements of this vector to the prescribed values.
 void set(int i, double value)
          Sets a single element of this vector.
 void set(Matrix3x1 M)
          Sets the elements of this vector from a Matrix3x1.
 void set(Vector3d v1)
          Sets the values of this vector to those of v1.
 void set(VectorNd v1, int idx)
          Sets the values of this vector from the elements of a general length vector v1, starting at a specified index.
 void setFromHomogeneous(Vector4d v1)
          Sets the values of this vector from a homogeneous representation stored in the 4-vector v1.
 void setRandom()
          Sets the elements of this vector to uniformly distributed random values in the range -0.5 (inclusive) to 0.5 (exclusive).
 void setRandom(double lower, double upper)
          Sets the elements of this vector to uniformly distributed random values in a specified range.
 void setRandom(double lower, double upper, java.util.Random generator)
          Sets the elements of this vector to uniformly distributed random values in a specified range, using a supplied random number generator.
 void setZero()
          Sets the elements of this vector to zero.
 int size()
          Returns the size of this vector (which is always 3)
 void sort()
          Sorts the contents of this vector by element value, with x being set to the largest value and z being set to the smallest value.
 void sort(Vector3d v1)
          Sorts the contents of vector v1 by element value, with x being set to the largest value and z being set to the smallest value, and places the results in this vector.
 void sortAbsolute()
          Sorts the contents of this vector by absolute element value, with x being set to the largest value and z being set to the smallest value.
 void sub(Vector3d v1)
          Subtracts v1 from this vector and places the result in this vector.
 void sub(Vector3d v1, Vector3d v2)
          Subtracts vector v2 from v1 and places the result in this vector.
 void transform(AffineTransform3dBase X)
          Applies a affine transformation to this vector, in place.
 void transform(AffineTransform3dBase X, Vector3d v1)
          Applies an affine transformation to the vector v1, and places the result in this vector.
 void transform(RotationMatrix3d R)
          Applies a rotational transformation to this vector, in place.
 void transform(RotationMatrix3d R, Vector3d v1)
          Applies a rotational transformation to the vector v1 and stores the result in this vector.
 double triangleArea(Vector3d v1, Vector3d v2)
          Returns the area of the triangle whose vertices are formed by this vector, and the vectors v1 and v2.
 void updateBounds(Vector3d vmin, Vector3d vmax)
          Updates a bounding box to include this vector.
 void write(java.io.PrintWriter pw, NumberFormat fmt, boolean withBrackets)
          Writes the contents of this vector to a PrintWriter.
 
Methods inherited from class maspack.matrix.VectorBase
containsNaN, copy, copyAndAdd, copyAndNegate, copyAndScale, copyAndSub, copyAndSubLeft, dot, epsilonEquals, equals, get, getDefaultFormat, hasNaN, isColumnVectorStringsVertical, isFixedSize, isRowVector, set, set, setColumnVectorStringsVertical, setDefaultFormat, setRowVector, setSize, toString, toString, toString, write
 
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, wait, wait, wait
 

Field Detail

ZERO

public static final Vector3d ZERO
Global zero vector. Should not be modified.


X_UNIT

public static final Vector3d X_UNIT
Global unit vector along the x axis. Should not be modified.


Y_UNIT

public static final Vector3d Y_UNIT
Global unit vector along the y axis. Should not be modified.


Z_UNIT

public static final Vector3d Z_UNIT
Global unit vector along the z axis. Should not be modified.


NEG_X_UNIT

public static final Vector3d NEG_X_UNIT
Global unit vector along the negative x axis. Should not be modified.


NEG_Y_UNIT

public static final Vector3d NEG_Y_UNIT
Global unit vector along the negative y axis. Should not be modified.


NEG_Z_UNIT

public static final Vector3d NEG_Z_UNIT
Global unit vector along the negative z axis. Should not be modified.


x

public double x
First element


y

public double y
Second element


z

public double z
Third element

Constructor Detail

Vector3d

public Vector3d()
Creates a 3-vector and initializes its elements to 0.


Vector3d

public Vector3d(Vector3d v)
Creates a 3-vector by copying an existing one.

Parameters:
v - vector to be copied

Vector3d

public Vector3d(double x,
                double y,
                double z)
Creates a 3-vector with the supplied element values.

Parameters:
x - first element
y - second element
z - third element

Vector3d

public Vector3d(double[] values)
Creates a 3-vector with the supplied element values.

Parameters:
values - element values
Method Detail

size

public int size()
Returns the size of this vector (which is always 3)

Specified by:
size in interface Vector
Specified by:
size in class VectorBase
Returns:
3

get

public double get(int i)
Gets a single element of this vector. Elements 0, 1, and 2 correspond to x, y, and z.

Specified by:
get in interface Vector
Specified by:
get in class VectorBase
Parameters:
i - element index
Returns:
element value throws ArrayIndexOutOfBoundsException if i is not in the range 0 to 2.

get

public void get(double[] values)
Copies the elements of this vector into an array of doubles.

Specified by:
get in interface Vector
Overrides:
get in class VectorBase
Parameters:
values - array into which values are copied

get

public void get(float[] values)
Copies the elements of this vector into an array of floats.

Parameters:
values - array into which values are copied

get

public void get(VectorNd v1,
                int idx)
Copies the values of this vector into a general length vector v1, starting at a specified index.

Parameters:
v1 - vector into which values are to be copied
idx - starting index for copying values
Throws:
ArrayIndexOfOutBoundsException - if idx specifies a region within v1 that exceeds its bounds

get

public void get(Matrix3x1 M)
Copies the elements of this vector into a Matrix3x1.

Parameters:
M - matrix into which values are copied

set

public void set(int i,
                double value)
Sets a single element of this vector. Elements 0, 1, and 2 correspond to x, y, and z.

Specified by:
set in interface Vector
Specified by:
set in class VectorBase
Parameters:
i - element index
value - element value
Throws:
java.lang.ArrayIndexOutOfBoundsException - if i is not in the range 0 to 2.

set

public void set(double[] values)
Sets the elements of this vector from an array of doubles.

Specified by:
set in interface Vector
Overrides:
set in class VectorBase
Parameters:
values - array from which values are copied

set

public void set(Vector3d v1)
Sets the values of this vector to those of v1.

Parameters:
v1 - vector whose values are copied

set

public void set(VectorNd v1,
                int idx)
Sets the values of this vector from the elements of a general length vector v1, starting at a specified index.

Parameters:
v1 - vector from which new values are copied
idx - starting index for new values
Throws:
ArrayIndexOfOutBoundsException - if idx specifies a region within v1 that exceeds its bounds

set

public void set(Matrix3x1 M)
Sets the elements of this vector from a Matrix3x1.

Parameters:
M - matrix from which values are taken

setFromHomogeneous

public void setFromHomogeneous(Vector4d v1)
Sets the values of this vector from a homogeneous representation stored in the 4-vector v1. This involves dividing the x, y, and z elements of v1 by its w element.

Parameters:
v1 - homogenous vector

add

public void add(Vector3d v1,
                Vector3d v2)
Adds vector v1 to v2 and places the result in this vector.

Parameters:
v1 - left-hand vector
v2 - right-hand vector

add

public void add(Vector3d v1)
Adds this vector to v1 and places the result in this vector.

Parameters:
v1 - right-hand vector

add

public void add(double dx,
                double dy,
                double dz)
Adds specified increments to the components of this vector.

Parameters:
dx - x increment
dy - y increment
dz - z increment

sub

public void sub(Vector3d v1,
                Vector3d v2)
Subtracts vector v2 from v1 and places the result in this vector.

Parameters:
v1 - left-hand vector
v2 - right-hand vector

sub

public void sub(Vector3d v1)
Subtracts v1 from this vector and places the result in this vector.

Parameters:
v1 - right-hand vector

negate

public void negate(Vector3d v1)
Sets this vector to the negative of v1.

Parameters:
v1 - vector to negate

negate

public void negate()
Negates this vector in place.


scale

public void scale(double s)
Scales the elements of this vector by s.

Parameters:
s - scaling factor

scale

public void scale(double sx,
                  double sy,
                  double sz)
Scales the elements of this vector by the values in the given direction.

Parameters:
sx - scaling factor in the x direction
sy - scaling factor in the y direction
sz - scaling factor in the z direction

scale

public void scale(double s,
                  Vector3d v1)
Scales the elements of vector v1 by s and places the results in this vector.

Parameters:
s - scaling factor
v1 - vector to be scaled

interpolate

public void interpolate(Vector3d v1,
                        double s,
                        Vector3d v2)
Computes the interpolation (1-s) v1 + s v2 and places the result in this vector.

Parameters:
v1 - left-hand vector
s - interpolation factor
v2 - right-hand vector

interpolate

public void interpolate(double s,
                        Vector3d v1)
Computes the interpolation (1-s) this + s v1 and places the result in this vector.

Parameters:
s - interpolation factor
v1 - right-hand vector

scaledAdd

public void scaledAdd(double s,
                      Vector3d v1,
                      Vector3d v2)
Computes s v1 + v2 and places the result in this vector.

Parameters:
s - scaling factor
v1 - vector to be scaled
v2 - vector to be added

scaledAdd

public void scaledAdd(double s,
                      Vector3d v1)
Computes s v1 and adds the result to this vector.

Parameters:
s - scaling factor
v1 - vector to be scaled and added

combine

public void combine(double s1,
                    Vector3d v1,
                    double s2,
                    Vector3d v2)
Computes s1 v1 + s2 v2 and places the result in this vector.

Parameters:
s1 - left-hand scaling factor
v1 - left-hand vector
s2 - right-hand scaling factor
v2 - right-hand vector

norm

public double norm()
Returns the 2 norm of this vector. This is the square root of the sum of the squares of the elements.

Specified by:
norm in interface Vector
Overrides:
norm in class VectorBase
Returns:
vector 2 norm

normSquared

public double normSquared()
Returns the square of the 2 norm of this vector. This is the sum of the squares of the elements.

Specified by:
normSquared in interface Vector
Overrides:
normSquared in class VectorBase
Returns:
square of the 2 norm

distance

public double distance(Vector3d v)
Returns the Euclidean distance between this vector and vector v.

Returns:
distance between this vector and v

distanceSquared

public double distanceSquared(Vector3d v)
Returns the squared of the Euclidean distance between this vector and vector v.

Returns:
squared distance between this vector and v

maxElement

public double maxElement()
Returns the maximum element value of this vector.

Specified by:
maxElement in interface Vector
Overrides:
maxElement in class VectorBase
Returns:
maximal element

minElement

public double minElement()
Returns the minimum element value of this vector.

Specified by:
minElement in interface Vector
Overrides:
minElement in class VectorBase
Returns:
minimal element

infinityNorm

public double infinityNorm()
Returns the infinity norm of this vector. This is the maximum absolute value over all elements.

Specified by:
infinityNorm in interface Vector
Overrides:
infinityNorm in class VectorBase
Returns:
vector infinity norm

oneNorm

public double oneNorm()
Returns the 1 norm of this vector. This is the sum of the absolute values of the elements.

Specified by:
oneNorm in interface Vector
Overrides:
oneNorm in class VectorBase
Returns:
vector 1 norm

dot

public double dot(Vector3d v1)
Returns the dot product of this vector and v1.

Parameters:
v1 - right-hand vector
Returns:
dot product

angle

public double angle(Vector3d v1)
Returns the angle between this vector and v1. The angle is defined as acos(c), where c is the dot product of unit vectors parallel to this vector and v1.

Parameters:
v1 - right-hand vector
Returns:
angle between vectors, in radians

normalize

public void normalize()
Normalizes this vector in place.


normalize

public void normalize(Vector3d v1)
Computes a unit vector in the direction of v1 and places the result in this vector.

Parameters:
v1 - vector to normalize

perpendicular

public void perpendicular(Vector3d v1)
Sets this vector to one which is perpendicular to v1. The resulting vector will not be normalized.

Parameters:
v1 - perpendicular reference vector

epsilonEquals

public boolean epsilonEquals(Vector3d v1,
                             double eps)
Returns true if the elements of this vector equal those of vector v1within a prescribed tolerance epsilon.

Parameters:
v1 - vector to compare with
eps - comparison tolerance
Returns:
false if the vectors are not equal within the specified tolerance

equals

public boolean equals(Vector3d v1)
Returns true if the elements of this vector exactly equal those of vector v1.

Parameters:
v1 - vector to compare with
Returns:
false if the vectors are not equal

greater

public boolean greater(Vector3d v1)
Returns true if all the elements of this vector are greater than those of vectorv1.

Parameters:
v1 -
Returns:
true if all elements of this vector are greater

greaterEquals

public boolean greaterEquals(Vector3d v1)
Returns true if all the elements of this vector are greater than or equal to those of vectorv1.

Parameters:
v1 -
Returns:
true if all elements of this vector are greater or equal

setZero

public void setZero()
Sets the elements of this vector to zero.


set

public void set(double x,
                double y,
                double z)
Sets the elements of this vector to the prescribed values.

Parameters:
x - value for first element
y - value for second element
z - value for third element

absolute

public void absolute()
Sets the elements of this vector to their absolute values.


absolute

public void absolute(Vector3d v1)
Sets the elements of this vector to the absolute value of v1.

Parameters:
v1 - vector to take the absolute value of

sortAbsolute

public void sortAbsolute()
Sorts the contents of this vector by absolute element value, with x being set to the largest value and z being set to the smallest value.


maxAbsIndex

public int maxAbsIndex()
Returns the index (0, 1, or 2) of the element of this vector with the largest absolute value.

Returns:
index of largest absolute value

minAbsIndex

public int minAbsIndex()
Returns the index (0, 1, or 2) of the element of this vector with the smallest absolute value.

Returns:
index of smallest absolute value

sort

public void sort(Vector3d v1)
Sorts the contents of vector v1 by element value, with x being set to the largest value and z being set to the smallest value, and places the results in this vector.

Parameters:
v1 - vector to sort

sort

public void sort()
Sorts the contents of this vector by element value, with x being set to the largest value and z being set to the smallest value.


cross

public void cross(Vector3d v1,
                  Vector3d v2)
Computes the cross product of v1 and v2 and places the result in this vector.

Parameters:
v1 - left-hand vector
v2 - right-hand vector

cross

public void cross(Vector3d v1)
Computes the cross product of this vector and v1, and places the result in this vector.

Parameters:
v1 - right-hand vector

crossAdd

public void crossAdd(Vector3d v1,
                     Vector3d v2,
                     Vector3d v3)
Computes the cross product of v1 and v2, adds this to v3, and places the result in this vector.

Parameters:
v1 - left-hand vector for cross product
v2 - right-hand vector for cross product
v3 - vector to add

angleWeightedCross

public void angleWeightedCross(Vector3d p0,
                               Vector3d p1,
                               Vector3d p2)
Computes the cross product v2 x v1, where v2 = p1 - p2 and v1 = p1 - p0, and then sets the length of the result to the angle between v1 and v2. The result is returned in this vector.

Parameters:
p0 - tail point for vector v1
p1 - head point for vectors v1 and v2
p2 - tail point for vector v2

angleWeightedCrossAdd

public void angleWeightedCrossAdd(Vector3d p0,
                                  Vector3d p1,
                                  Vector3d p2)
Computes the cross product v2 x v1, where v2 = p1 - p2 and v1 = p1 - p0, and then sets the length of the result to the angle between v1 and v2. The result is added to this vector.

Parameters:
p0 - tail point for vector v1
p1 - head point for vectors v1 and v2
p2 - tail point for vector v2

triangleArea

public double triangleArea(Vector3d v1,
                           Vector3d v2)
Returns the area of the triangle whose vertices are formed by this vector, and the vectors v1 and v2.

Parameters:
v1 - second vertex
v2 - third vertex
Returns:
area of the triangle

transform

public void transform(RotationMatrix3d R)
Applies a rotational transformation to this vector, in place. This is equivalent to multiplying the rotation matrix by this vector.

Parameters:
R - rotational transformation matrix

transform

public void transform(RotationMatrix3d R,
                      Vector3d v1)
Applies a rotational transformation to the vector v1 and stores the result in this vector. This is equivalent to multiplying the rotation matrix by v1.

Parameters:
R - rotational transformation matrix
v1 - vector to transform

inverseTransform

public void inverseTransform(RotationMatrix3d R)
Applies an inverse rotational transformation to this vector, in place. This is equivalent to multiplying the transpose (or inverse) of the rotation matrix by this vector.

Parameters:
R - rotational transformation matrix

inverseTransform

public void inverseTransform(RotationMatrix3d R,
                             Vector3d v1)
Applies an inverse rotational transformation to the vector v1, and stores the result in this vector. This is equivalent to multiplying the transpose (or inverse) of the rotation matrix by this v1.

Parameters:
R - rotational transformation matrix
v1 - vector to transform

transform

public void transform(AffineTransform3dBase X)
Applies a affine transformation to this vector, in place.

Parameters:
X - affine transformation

transform

public void transform(AffineTransform3dBase X,
                      Vector3d v1)
Applies an affine transformation to the vector v1, and places the result in this vector.

Parameters:
X - affine transformation
v1 - vector to be transformed

inverseTransform

public void inverseTransform(AffineTransform3dBase X)
Applies an inverse affine transformation to this vector, in place.

Parameters:
X - affine transformation

inverseTransform

public void inverseTransform(AffineTransform3dBase X,
                             Vector3d v1)
Applies an inverse affine transformation to the vector v1, and places the result in this vector.

Parameters:
X - affine transformation
v1 - vector to be transformed

mul

public void mul(Matrix3dBase X,
                Vector3d v1)
Multiplies matrix X by vector v1 and places the result in this vector.

Parameters:
X - matrix
v1 - vector

mulAdd

public void mulAdd(Matrix3dBase X,
                   Vector3d v1,
                   Vector3d v2)
Multiplies matrix X by vector v1, adds vector v2, and places the result in this vector.

Parameters:
X - matrix
v1 - vector to multiply
v2 - vector to add

mulTranspose

public void mulTranspose(Matrix3dBase X,
                         Vector3d v1)
Multiplies the transpose of matrix X by vector v1 and places the result in this vector.

Parameters:
X - matrix
v1 - vector to multiply

mulTransposeAdd

public void mulTransposeAdd(Matrix3dBase X,
                            Vector3d v1,
                            Vector3d v2)
Multiplies the transpose of matrix X by vector v1, adds vector v2, and places the result in this vector.

Parameters:
X - matrix
v1 - vector to multiply
v2 - vector to add

setRandom

public void setRandom()
Sets the elements of this vector to uniformly distributed random values in the range -0.5 (inclusive) to 0.5 (exclusive).


setRandom

public void setRandom(double lower,
                      double upper)
Sets the elements of this vector to uniformly distributed random values in a specified range.

Parameters:
lower - lower random value (inclusive)
upper - upper random value (exclusive)

setRandom

public void setRandom(double lower,
                      double upper,
                      java.util.Random generator)
Sets the elements of this vector to uniformly distributed random values in a specified range, using a supplied random number generator.

Parameters:
lower - lower random value (inclusive)
upper - upper random value (exclusive)
generator - random number generator

updateBounds

public void updateBounds(Vector3d vmin,
                         Vector3d vmax)
Updates a bounding box to include this vector. The box is described by minimum and maximum corner points, which are changed if necessary. This method will only grow bounds, not shrink them.

Parameters:
vmin - minimum corner of the bounding box
vmax - maximum corner of the bounding box

max

public void max(Vector3d v)
Computes the element-wise maximum of this vector and vector v and places the result in this vector.

Parameters:
v - vector to compare with

min

public void min(Vector3d v)
Computes the element-wise minimum of this vector and vector v and places the result in this vector.

Parameters:
v - vector to compare with

hermiteInterpolate

public static void hermiteInterpolate(Vector3d pr,
                                      Vector3d p0,
                                      Vector3d v0,
                                      Vector3d p1,
                                      Vector3d v1,
                                      double s,
                                      double h)
Interpolates the value at a location along a cubic Hermite spline. The spline itself is defined by position and velocities at interval end-points. The location is defined by the parameter s in the range [0,1], and the actual time duration of the interval is given by h.

Parameters:
pr - returns interpolated position
p0 - position at the interval beginning
v0 - velocity at the interval beginning
p1 - position at the interval end
v1 - velocity at the interval end
s - interpolation location on the interval (in the range [0,1])
h - interval time duration

hermiteVelocity

public static void hermiteVelocity(Vector3d vr,
                                   Vector3d p0,
                                   Vector3d v0,
                                   Vector3d p1,
                                   Vector3d v1,
                                   double s,
                                   double h)
Interpolates velocity at a location along a cubic Hermite spline. The spline itself is defined by position and velocities at interval end-points. The location is defined by the parameter s in the range [0,1], and the actual time duration of the interval is given by h.

Parameters:
vr - returns interpolated velocity
p0 - position at the interval beginning
v0 - velocity at the interval beginning
p1 - position at the interval end
v1 - velocity at the interval end
s - interpolation location on the interval (in the range [0,1])
h - interval time duration

clone

public Vector3d clone()
Specified by:
clone in interface Clonable
Overrides:
clone in class VectorBase

write

public void write(java.io.PrintWriter pw,
                  NumberFormat fmt,
                  boolean withBrackets)
           throws java.io.IOException
Writes the contents of this vector to a PrintWriter. Element values are separated by spaces, and optionally surrounded by square brackets [ ] if withBrackets is set true. Each element is formatted using a C printf style as decribed by the parameter NumberFormat.

Specified by:
write in interface Vector
Overrides:
write in class VectorBase
Parameters:
pw - PrintWriter to write this vector to
fmt - numeric format
withBrackets - if true, causes the output to be surrounded by square brackets.
Throws:
java.io.IOException

scan

public void scan(ReaderTokenizer rtok)
          throws java.io.IOException
Sets the contents of this vector to values read from a ReaderTokenizer. The input should consist of a sequence of numbers, separated by white space and optionally surrounded by square brackets [ ].

If the input is not surrounded by square brackets, then the number of values should equal the current size of this vector.

If the input is surrounded by square brackets, then all values up to the closing bracket are read, and the resulting number of values should either equal the current size of this vector, or this vector should be resizeable to fit the input. For example,

 [ 1.2 4 5 3.1 ]
 
defines a vector of size 4.

Specified by:
scan in interface Vector
Overrides:
scan in class VectorBase
Parameters:
rtok - Tokenizer from which vector values are read. Number parsing should be enabled.
Throws:
java.io.IOException

main

public static void main(java.lang.String[] args)