[Cdk-commits] CVS: cdk/gcj/vecmath/javax/vecmath AxisAngle4d.java,NONE,1.1 AxisAngle4f.java,NONE,1.1

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 454-5900

Update of /cvsroot/cdk/cdk/gcj/vecmath/javax/vecmath
In directory usw-pr-cvs1:/tmp/cvs-serv21671/vecmath/javax/vecmath

Added Files:
	AxisAngle4d.java AxisAngle4f.java Color3b.java Color3f.java 
	Color4b.java Color4f.java GMatrix.java GVector.java 
	Matrix3d.java Matrix3f.java Matrix4d.java Matrix4f.java 
	MismatchedSizeException.java Point2d.java Point2f.java 
	Point3d.java Point3f.java Point3i.java Point4d.java 
	Point4f.java Point4i.java Quat4d.java Quat4f.java 
	SingularMatrixException.java TexCoord2f.java TexCoord3f.java 
	Tuple2d.java Tuple2f.java Tuple3b.java Tuple3d.java 
	Tuple3f.java Tuple3i.java Tuple4b.java Tuple4d.java 
	Tuple4f.java Tuple4i.java VecmathTest.java Vector2d.java 
	Vector2f.java Vector3d.java Vector3f.java Vector4d.java 
	Vector4f.java 
Log Message:
Lots of new files. Amongst which the source code of vecmath.jar.
The latter has been changed to compile with gcj-3.0.4.
Actually, CDK does now compile, i.e. at least the classes mentioned
in core.classes and extra.classes. *And* a binary executable can get
generated that works!

--- NEW FILE: AxisAngle4d.java ---
/*
   Copyright (C) 1997,1998,1999
   Kenji Hiranabe, Eiwa System Management, Inc.

   This program is free software.
   Implemented by Kenji Hiranabe(hir...@es...),
   conforming to the Java(TM) 3D API specification by Sun Microsystems.

   Permission to use, copy, modify, distribute and sell this software
   and its documentation for any purpose is hereby granted without fee,
   provided that the above copyright notice appear in all copies and
   that both that copyright notice and this permission notice appear
   in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc.
   makes no representations about the suitability of this software for any
   purpose.  It is provided "AS IS" with NO WARRANTY.
*/

package javax.vecmath;

import java.io.Serializable;

/**
  * A 4 element axis angle represented by double precision floating point
  * x,y,z,angle components. An axis angle is a rotation of angle (radians) about
  * the vector (x,y,z).
  * @version specification 1.1, implementation $Revision: 1.1 $, $Date: 2002/08/22 20:01:14 $
  * @author Kenji hiranabe
  */
public class AxisAngle4d implements Serializable {

/*
 * $Log: AxisAngle4d.java,v $
 * Revision 1.1  2002/08/22 20:01:14  egonw
 * Lots of new files. Amongst which the source code of vecmath.jar.
 * The latter has been changed to compile with gcj-3.0.4.
 * Actually, CDK does now compile, i.e. at least the classes mentioned
 * in core.classes and extra.classes. *And* a binary executable can get
 * generated that works!
 *
 * Revision 1.11  1999/10/05  07:03:50  hiranabe
 * copyright change
 *
 * Revision 1.11  1999/10/05  07:03:50  hiranabe
 * copyright change
 *
 * Revision 1.10  1999/10/05  04:52:58  hiranabe
 * Java3D 1.2 support.
 * addition of AxisAngle4d(Vector3d,double) constructor and
 * set(Vvector3d,double)
 *
 * Revision 1.9  1999/03/04  09:16:33  hiranabe
 * small bug fix and copyright change
 *
 * Revision 1.8  1999/02/28  05:14:57  hiranabe
 * default constructor comment (0,0,1,0)
 *
 * Revision 1.7  1998/10/14  00:49:10  hiranabe
 * API1.1 Beta02
 *
 * Revision 1.6  1998/07/27  04:28:13  hiranabe
 * API1.1Alpha01 ->API1.1Alpha03
 *
 * Revision 1.5  1998/04/17  10:30:46  hiranabe
 * null check for equals
 *
 * Revision 1.4  1998/04/09  08:18:15  hiranabe
 * minor comment change
 *
 * Revision 1.3  1998/04/09  07:04:31  hiranabe
 * *** empty log message ***
 *
 * Revision 1.2  1998/01/05  06:29:31  hiranabe
 * copyright 98
 *
 * Revision 1.1  1997/11/26  03:00:44  hiranabe
 * Initial revision
 *
 */

/*
 * I assumed that the length of the axis vector is not significant.
 */

    /**
      * The x coordinate.
      */
    public double x;

    /**
      * The y coordinate.
      */
    public double y;

    /**
      * The z coordinate.
      */
    public double z;

    /**
      * The angle.
      */
    public double angle;

    /**
      * Constructs and initializes an AxisAngle4d from the specified x, y, z,
      * and angle.
      * @param x the x coordinate
      * @param y the y coordinate
      * @param z the z coordinate
      * @param angle the angle.
      */
    public AxisAngle4d(double x, double y, double z, double angle) {
	set(x, y, z, angle);
    }

    /**
      * Constructs and initializes an AxisAngle4d from the components contained
      * in the array.
      * @param a the array of length 4 containing x,y,z,angle in order
      */
    public AxisAngle4d(double a[]) {
	set(a);
    }

    /**
      * Constructs and initializes a AxisAngle4d from the specified AxisAngle4d.
      * @param a1 the AxisAngle4d containing the initialization x y z angle data
      */
    public AxisAngle4d(AxisAngle4d a1) {
	set(a1);
    }

    /**
      * Constructs and initializes a AxisAngle4d from the specified AxisAngle4f.
      * @param a1 the AxisAngle4f containing the initialization x y z angle data
      */
    public AxisAngle4d(AxisAngle4f a1) {
	set(a1);
    }

    /**
      * Constructs and initializes a AxisAngle4d to (0,0,1,0).
      */
    public AxisAngle4d() {
	x = 0.0;
	y = 0.0;
	z = 1.0;
	angle = 0.0;
    }

    /**
     * Constructs and initializes an AxisAngle4d from the specified axis
     * and angle.
     *
     * @param axis the axis
     * @param angle the angle
     * @since Java 3D 1.2
     */
    public AxisAngle4d(Vector3d axis, double angle) {
        x = axis.x;
        y = axis.y;
        z = axis.z;
        this.angle = angle;
    }

    /**
     * Sets the value of this AxisAngle4d to the specified axis and
     * angle.
     * @param axis the axis
     * @param angle the angle
     * @since Java 3D 1.2
     */
    public final void set(Vector3d axis, double angle) {
        x = axis.x;
        y = axis.y;
        z = axis.z;
        this.angle = angle;
    }

    /**
      * Sets the value of this axis angle to the specified x,y,z,angle.
      * @param x the x coordinate
      * @param y the y coordinate
      * @param z the z coordinate
      * @param angle the angle
      */
    public final void set(double x, double y, double z, double angle) {
	this.x = x;
	this.y = y;
	this.z = z;
	this.angle = angle;
    }

    /**
      * Sets the value of this axis angle from the 4 values specified in the array.
      * @param a the array of length 4 containing x,y,z,angle in order
      */
    public final void set(double a[]) {
	// ArrayIndexOutOfBounds is thrown if t.length < 4
	x = a[0];
	y = a[1];
	z = a[2];
	angle = a[3];
    }

    /**
      * Sets the value of this axis angle to the value of axis angle t1.
      * @param t1 the axis angle to be copied
      */
    public final void set(AxisAngle4d a1) {
	x = a1.x;
	y = a1.y;
	z = a1.z;
	angle = a1.angle;
    }

    /**
      * Sets the value of this axis angle to the value of axis angle t1.
      * @param t1 the axis angle to be copied
      */
    public final void set(AxisAngle4f a1) {
	x = (float)(a1.x);
	y = (float)(a1.y);
	z = (float)(a1.z);
	angle = (float)(a1.angle);
    }

    /**
      * Gets the value of this axis angle into the array a of
      * length four in x,y,z,angle order.
      * @param a the array of length four
      */
    public final void get(double a[]) {
	// ArrayIndexOutOfBounds is thrown if a.length < 4
	a[0] = x;
	a[1] = y;
	a[2] = z;
	a[3] = angle;
    }

    /**
      * Sets the value of this axis-angle to the rotational component of the
      * passed matrix.
      * @param m1 the matrix4f
      */
    public final void set(Matrix4f m1) {
	setFromMat(
	    m1.m00, m1.m01, m1.m02,
	    m1.m10, m1.m11, m1.m12,
	    m1.m20, m1.m21, m1.m22
	    );
    }

    /**
      * Sets the value of this axis-angle to the rotational component of the
      * passed matrix.
      * @param m1 the matrix4d
      */
    public final void set(Matrix4d m1) {
	setFromMat(
	    m1.m00, m1.m01, m1.m02,
	    m1.m10, m1.m11, m1.m12,
	    m1.m20, m1.m21, m1.m22
	    );
    }

    /**
      * Sets the value of this axis-angle to the rotational component of the
      * passed matrix.
      * @param m1 the matrix3f
      */
    public final void set(Matrix3f m1) {
	setFromMat(
	    m1.m00, m1.m01, m1.m02,
	    m1.m10, m1.m11, m1.m12,
	    m1.m20, m1.m21, m1.m22
	    );
    }

    /**
      * Sets the value of this axis-angle to the rotational component of the
      * passed matrix.
      * @param m1 the matrix3d
      */
    public final void set(Matrix3d m1) {
	setFromMat(
	    m1.m00, m1.m01, m1.m02,
	    m1.m10, m1.m11, m1.m12,
	    m1.m20, m1.m21, m1.m22
	    );
    }

    /**
      * Sets the value of this axis-angle to the rotational equivalent of the
      * passed quaternion.
      * @param q1 the Quat4f
      */
    public final void set(Quat4f q1) {
	setFromQuat(q1.x, q1.y, q1.z, q1.w);
    }

    /**
      * Sets the value of this axis-angle to the rotational equivalent of the
      * passed quaternion.
      * @param q1 the Quat4d
      */
    public final void set(Quat4d q1) {
	setFromQuat(q1.x, q1.y, q1.z, q1.w);
    }

    // helper method
    private void setFromMat(double m00, double m01, double m02,
		       double m10, double m11, double m12,
		       double m20, double m21, double m22) {

	// assuming M is normalized.

	double cos = (m00 + m11 + m22 - 1.0)*0.5;
	x = m21 - m12;
	y = m02 - m20;
	z = m10 - m01;
	double sin = 0.5*Math.sqrt(x*x + y*y + z*z);
	angle = Math.atan2(sin, cos);

	// no need to normalize
	// x /= n;
	// y /= n;
	// z /= n;

    }

    // helper method
    private void setFromQuat(double x, double y, double z, double w) {
	// This logic can calculate angle without normalization.
	// The direction of (x,y,z) and the sign of rotation cancel
	// each other to calculate a right answer.

	double sin_a2 = Math.sqrt(x*x + y*y + z*z);  // |sin a/2|, w = cos a/2
	this.angle = 2.0*Math.atan2(sin_a2, w); // 0 <= angle <= PI , because 0 < sin_a2
	this.x = x;
	this.y = y;
	this.z = z;

//	double sin = 2.0*Math.abs(w)*Math.sqrt(x*x + y*y + z*z);
//	double cos = 2*w*w - 1;
//
//	angle = Math.atan2(sin, cos);
//	if (Math.sin(angle/2.0) < 0) {
//	    this.x = -x;
//	    this.y = -y;
//	    this.z = -z;
//	} else {
//	    this.x = x;
//	    this.y = y;
//	    this.z = z;
//	}
    }

    /**
      * Returns a string that contains the values of this AxisAngle4d. The form is (x,y,z,angle).
      * @return the String representation
      */
    public String toString() {
	    return "(" + x + ", " + y + ", " + z +", " + angle + ")";
    }

    /**
      * Returns true if all of the data members of AxisAngle4d t1 are equal to the corresponding
      * data members in this
      * @param a1 the vector with which the comparison is made.
      */
    public boolean equals(AxisAngle4d a1) {
	return a1 != null && x == a1.x && y == a1.y && z == a1.z && angle == a1.angle;
    }

    /**
      * Returns true if the Object o1 is of type AxisAngle4d and all of the data
      * members of t1 are equal to the corresponding data members in this
      * AxisAngle4d.
      * @param o1 the object with which the comparison is made.
      */
    public boolean equals(Object o1) {
	return o1 != null && (o1 instanceof AxisAngle4d) && equals((AxisAngle4d)o1);
    }

    /**
      * Returns true if the L-infinite distance between this axis-angle and axis-angle t1 is
      * less than or equal to the epsilon parameter, otherwise returns false. The L-infinite
      * distance is equal to MAX[abs(x1-x2), abs(y1-y2), abs(z1-z2), abs(angle1-angle2)].
      * @param a1 the axis-angle to be compared to this axis-angle
      * @param epsilon the threshold value
      */
    public boolean epsilonEquals(AxisAngle4d a1, double epsilon) {
	return (Math.abs(a1.x - this.x) <= epsilon) &&
	    (Math.abs(a1.y - this.y) <= epsilon) &&
	    (Math.abs(a1.z - this.z) <= epsilon) &&
	    (Math.abs(a1.angle - this.angle) <= epsilon);
    }

    /**
      * Returns a hash number based on the data values in this object. 
      * Two different AxisAngle4d objects with identical data  values
      * (ie, returns true for equals(AxisAngle4d) ) will return the same hash number.
      * Two vectors with different data members may return the same hash value,
      * although this is not likely.
      */
      public int hashCode() {
	  long xbits = Double.doubleToLongBits(x);
	  long ybits = Double.doubleToLongBits(y);
	  long zbits = Double.doubleToLongBits(z);
	  long abits = Double.doubleToLongBits(angle);
	  return (int)(xbits ^ (xbits >> 32) ^
		  ybits ^ (ybits >> 32) ^
		  zbits ^ (zbits >> 32) ^
		  abits ^ (abits >> 32));
      }
}

--- NEW FILE: AxisAngle4f.java ---
/*
   Copyright (C) 1997,1998,1999
   Kenji Hiranabe, Eiwa System Management, Inc.

   This program is free software.
   Implemented by Kenji Hiranabe(hir...@es...),
   conforming to the Java(TM) 3D API specification by Sun Microsystems.

   Permission to use, copy, modify, distribute and sell this software
   and its documentation for any purpose is hereby granted without fee,
   provided that the above copyright notice appear in all copies and
   that both that copyright notice and this permission notice appear
   in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc.
   makes no representations about the suitability of this software for any
   purpose.  It is provided "AS IS" with NO WARRANTY.
*/
package javax.vecmath;

import java.io.Serializable;

/**
  * A 4 element axis angle represented by single precision floating point
  * x,y,z,angle components. An axis angle is a rotation of angle (radians) about
  * the vector (x,y,z).
  * @version specification 1.1, implementation $Revision: 1.1 $, $Date: 2002/08/22 20:01:14 $
  * @author Kenji hiranabe
  */
public class AxisAngle4f implements Serializable {
/*
 * $Log: AxisAngle4f.java,v $
 * Revision 1.1  2002/08/22 20:01:14  egonw
 * Lots of new files. Amongst which the source code of vecmath.jar.
 * The latter has been changed to compile with gcj-3.0.4.
 * Actually, CDK does now compile, i.e. at least the classes mentioned
 * in core.classes and extra.classes. *And* a binary executable can get
 * generated that works!
 *
 * Revision 1.11  1999/10/05  07:03:50  hiranabe
 * copyright change
 *
 * Revision 1.11  1999/10/05  07:03:50  hiranabe
 * copyright change
 *
 * Revision 1.10  1999/10/05  04:53:58  hiranabe
 * Java3D 1.2 support
 * AxisAngle4f(Vector3f axis, float angle) constructor and
 * set(Vector3f axis, float angle)
 *
 * Revision 1.9  1999/03/04  09:16:33  hiranabe
 * small bug fix and copyright change
 *
 * Revision 1.8  1999/02/28  05:15:08  hiranabe
 * default constructor comment (0,0,1,0)
 *
 * Revision 1.7  1998/10/14  00:49:10  hiranabe
 * API1.1 Beta02
 *
 * Revision 1.6  1998/07/27  04:28:13  hiranabe
 * API1.1Alpha01 ->API1.1Alpha03
 *
 * Revision 1.5  1998/04/17  10:30:46  hiranabe
 * null check for equals
 *
 * Revision 1.4  1998/04/09  08:18:15  hiranabe
 * minor comment change
 *
 * Revision 1.3  1998/04/09  07:04:31  hiranabe
 * *** empty log message ***
 *
 * Revision 1.2  1998/01/05  06:29:31  hiranabe
 * copyright 98
 *
 * Revision 1.1  1997/11/26  03:00:44  hiranabe
 * Initial revision
 *
 */

/*
 * I assumed that the length of the axis vector is not significant.
 */

    /**
      * The x coordinate.
      */
    public float x;

    /**
      * The y coordinate.
      */
    public float y;

    /**
      * The z coordinate.
      */
    public float z;

    /**
      * The angle.
      */
    public float angle;

    /**
      * Constructs and initializes an AxisAngle4f from the specified x, y, z,
      * and angle.
      * @param x the x coordinate
      * @param y the y coordinate
      * @param z the z coordinate
      * @param angle the angle.
      */
    public AxisAngle4f(float x, float y, float z, float angle) {
	set(x, y, z, angle);
    }

    /**
      * Constructs and initializes an AxisAngle4f from the components contained
      * in the array.
      * @param a the array of length 4 containing x,y,z,angle in order
      */
    public AxisAngle4f(float a[]) {
	set(a);
    }

    /**
      * Constructs and initializes a AxisAngle4f from the specified AxisAngle4f.
      * @param a1 the AxisAngle4f containing the initialization x y z angle data
      */
    public AxisAngle4f(AxisAngle4f a1) {
	set(a1);
    }

    /**
      * Constructs and initializes a AxisAngle4f from the specified AxisAngle4f.
      * @param a1 the AxisAngle4d containing the initialization x y z angle data
      */
    public AxisAngle4f(AxisAngle4d a1) {
	set(a1);
    }

    /**
      * Constructs and initializes a AxisAngle4f to (0,0,1,0).
      */
    public AxisAngle4f() {
	x = 0.0f;
	y = 0.0f;
	z = 1.0f;
	angle = 0.0f;
    }

    /**
     * Constructs and initializes an AxisAngle4f from the specified axis
     * and angle.
     *
     * @param axis the axis
     * @param angle the angle
     * @since Java 3D 1.2
     */
    public AxisAngle4f(Vector3f axis, float angle) {
        x = axis.x;
        y = axis.y;
        z = axis.z;
        this.angle = angle;
    }

    /**
     * Sets the value of this AxisAngle4f to the specified axis and
     * angle.
     * @param axis the axis
     * @param angle the angle
     * @since Java 3D 1.2
     */
    public final void set(Vector3f axis, float angle) {
        x = axis.x;
        y = axis.y;
        z = axis.z;
        this.angle = angle;
    }

    /**
      * Sets the value of this axis angle to the specified x,y,z,angle.
      * @param x the x coordinate
      * @param y the y coordinate
      * @param z the z coordinate
      * @param angle the angle
      */
    public final void set(float x, float y, float z, float angle) {
	this.x = x;
	this.y = y;
	this.z = z;
	this.angle = angle;
    }

    /**
      * Sets the value of this axis angle from the 4 values specified in the array.
      * @param a the array of length 4 containing x,y,z,angle in order
      */
    public final void set(float a[]) {
	// ArrayIndexOutOfBounds is thrown if t.length < 4
	x = a[0];
	y = a[1];
	z = a[2];
	angle = a[3];
    }

    /**
      * Sets the value of this axis angle to the value of axis angle t1.
      * @param t1 the axis angle to be copied
      */
    public final void set(AxisAngle4f a1) {
	x = a1.x;
	y = a1.y;
	z = a1.z;
	angle = a1.angle;
    }

    /**
      * Sets the value of this axis angle to the value of axis angle t1.
      * @param t1 the axis angle to be copied
      */
    public final void set(AxisAngle4d a1) {
	x = (float)(a1.x);
	y = (float)(a1.y);
	z = (float)(a1.z);
	angle = (float)(a1.angle);
    }

    /**
      * Gets the value of this axis angle into the array a of
      * length four in x,y,z,angle order.
      * @param a the array of length four
      */
    public final void get(float a[]) {
	// ArrayIndexOutOfBounds is thrown if a.length < 4
	a[0] = x;
	a[1] = y;
	a[2] = z;
	a[3] = angle;
    }

    /**
      * Sets the value of this axis-angle to the rotational component of the
      * passed matrix.
      * @param m1 the matrix4f
      */
    public final void set(Matrix4f m1) {
	setFromMat(
	    m1.m00, m1.m01, m1.m02,
	    m1.m10, m1.m11, m1.m12,
	    m1.m20, m1.m21, m1.m22
	    );
    }

    /**
      * Sets the value of this axis-angle to the rotational component of the
      * passed matrix.
      * @param m1 the matrix4d
      */
    public final void set(Matrix4d m1) {
	setFromMat(
	    m1.m00, m1.m01, m1.m02,
	    m1.m10, m1.m11, m1.m12,
	    m1.m20, m1.m21, m1.m22
	    );
    }

    /**
      * Sets the value of this axis-angle to the rotational component of the
      * passed matrix.
      * @param m1 the matrix3f
      */
    public final void set(Matrix3f m1) {
	setFromMat(
	    m1.m00, m1.m01, m1.m02,
	    m1.m10, m1.m11, m1.m12,
	    m1.m20, m1.m21, m1.m22
	    );
    }

    /**
      * Sets the value of this axis-angle to the rotational component of the
      * passed matrix.
      * @param m1 the matrix3d
      */
    public final void set(Matrix3d m1) {
	setFromMat(
	    m1.m00, m1.m01, m1.m02,
	    m1.m10, m1.m11, m1.m12,
	    m1.m20, m1.m21, m1.m22
	    );
    }

    /**
      * Sets the value of this axis-angle to the rotational equivalent of the
      * passed quaternion.
      * @param q1 the Quat4f
      */
    public final void set(Quat4f q1) {
	setFromQuat(q1.x, q1.y, q1.z, q1.w);
    }

    /**
      * Sets the value of this axis-angle to the rotational equivalent of the
      * passed quaternion.
      * @param q1 the Quat4d
      */
    public final void set(Quat4d q1) {
	setFromQuat(q1.x, q1.y, q1.z, q1.w);
    }

    // helper method
    private void setFromMat(double m00, double m01, double m02,
		       double m10, double m11, double m12,
		       double m20, double m21, double m22) {
	// assuming M is normalized.

	double cos = (m00 + m11 + m22 - 1.0)*0.5;
	x = (float)(m21 - m12);
	y = (float)(m02 - m20);
	z = (float)(m10 - m01);
	double sin = 0.5*Math.sqrt(x*x + y*y + z*z);
	angle = (float)Math.atan2(sin, cos);

	// no need to normalize
	// x /= n;
	// y /= n;
	// z /= n;
    }

    // helper method
    private void setFromQuat(double x, double y, double z, double w) {
	// This logic can calculate angle without normalization.
	// The direction of (x,y,z) and the sign of rotation cancel
	// each other to calculate a right answer.

	double sin_a2 = Math.sqrt(x*x + y*y + z*z);  // |sin a/2|, w = cos a/2
	this.angle = (float)(2.0*Math.atan2(sin_a2, w)); // 0 <= angle <= PI , because 0 < sin_a2
	this.x = (float)x;
	this.y = (float)y;
	this.z = (float)z;
    }

    /**
      * Returns a string that contains the values of this AxisAngle4f. The form is (x,y,z,angle).
      * @return the String representation
      */
    public String toString() {
	    return "(" + x + ", " + y + ", " + z +", " + angle + ")";
    }

    /**
      * Returns true if all of the data members of AxisAngle4f t1 are equal to the corresponding
      * data members in this
      * @param a1 the vector with which the comparison is made.
      */
    public boolean equals(AxisAngle4f a1) {
	return a1 != null && x == a1.x && y == a1.y && z == a1.z && angle == a1.angle;
    }

    /**
      * Returns true if the Object o1 is of type AxisAngle4f and all of the data
      * members of o1 are equal to the corresponding data members in this
      * AxisAngle4f.
      * @param o1 the object with which the comparison is made.
      */
    public boolean equals(Object o1) {
	return o1 != null && (o1 instanceof AxisAngle4f) && equals((AxisAngle4f)o1);
    }

    /**
      * Returns true if the L-infinite distance between this axis-angle and axis-angle t1 is
      * less than or equal to the epsilon parameter, otherwise returns false. The L-infinite
      * distance is equal to MAX[abs(x1-x2), abs(y1-y2), abs(z1-z2), abs(angle1-angle2)].
      * @param a1 the axis-angle to be compared to this axis-angle
      * @param epsilon the threshold value
      */
    public boolean epsilonEquals(AxisAngle4f a1, float epsilon) {
	return (Math.abs(a1.x - this.x) <= epsilon) &&
	    (Math.abs(a1.y - this.y) <= epsilon) &&
	    (Math.abs(a1.z - this.z) <= epsilon) &&
	    (Math.abs(a1.angle - this.angle) <= epsilon);
    }

    /**
      * Returns a hash number based on the data values in this object. 
      * Two different AxisAngle4f objects with identical data  values
      * (ie, returns true for equals(AxisAngle4f) ) will return the same hash number.
      * Two vectors with different data members may return the same hash value,
      * although this is not likely.
      */
      public int hashCode() {
	  return Float.floatToIntBits(x) ^
                 Float.floatToIntBits(y) ^
	         Float.floatToIntBits(z) ^
                 Float.floatToIntBits(angle);
      }
}

--- NEW FILE: Color3b.java ---
/*
   Copyright (C) 1997,1998,1999
   Kenji Hiranabe, Eiwa System Management, Inc.

   This program is free software.
   Implemented by Kenji Hiranabe(hir...@es...),
   conforming to the Java(TM) 3D API specification by Sun Microsystems.

   Permission to use, copy, modify, distribute and sell this software
   and its documentation for any purpose is hereby granted without fee,
   provided that the above copyright notice appear in all copies and
   that both that copyright notice and this permission notice appear
   in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc.
   makes no representations about the suitability of this software for any
   purpose.  It is provided "AS IS" with NO WARRANTY.
*/
package javax.vecmath;

import java.io.Serializable;

/**
  * A three byte vector used for colors.
  * @version specification 1.2, implementation $Revision: 1.1 $, $Date: 2002/08/22 20:01:14 $
  * @author Kenji hiranabe
  */
public class Color3b extends Tuple3b implements Serializable {
/*
 * $Log: Color3b.java,v $
 * Revision 1.1  2002/08/22 20:01:14  egonw
 * Lots of new files. Amongst which the source code of vecmath.jar.
 * The latter has been changed to compile with gcj-3.0.4.
 * Actually, CDK does now compile, i.e. at least the classes mentioned
 * in core.classes and extra.classes. *And* a binary executable can get
 * generated that works!
 *
 * Revision 1.9  1999/11/25  10:55:01  hiranabe
 * awt.Color conversion
 *
 * Revision 1.8  1999/10/05  07:03:50  hiranabe
 * copyright change
 *
 * Revision 1.7  1999/03/04  09:16:33  hiranabe
 * small bug fix and copyright change
 *
 * Revision 1.6  1998/10/14  00:49:10  hiranabe
 * API1.1 Beta02
 *
 * Revision 1.5  1998/04/10  04:52:14  hiranabe
 * API1.0 -> API1.1 (added constructors, methods)
 *
 * Revision 1.4  1998/04/09  08:18:15  hiranabe
 * minor comment change
 *
 * Revision 1.3  1998/04/09  07:04:31  hiranabe
 * *** empty log message ***
 *
 * Revision 1.2  1998/01/05  06:29:31  hiranabe
 * copyright 98
 *
 * Revision 1.1  1997/11/26  03:00:44  hiranabe
 * Initial revision
 *
 */

    /**
      * Constructs and initializes a Color3b from the specified three values.
      * @param c1 the first value
      * @param c2 the second value
      * @param c3 the third value
      */
    public Color3b(byte c1, byte c2, byte c3) {
	super(c1, c2, c3);
    }

    /**
      * Constructs and initializes a Color3b from input array of length 3.
      * @param t the array of length 3 containing c1 c2 c3 in order
      */
    public Color3b(byte c[]) {
	// ArrayIndexOutOfBounds is thrown if t.length < 3
	super(c);
    }

    /**
      * Constructs and initializes a Color3b from the specified Color3b.
      * @param c the Color3b containing the initialization x y z data
      */
    public Color3b(Color3b c1) {
	super(c1);
    }

    /**
      * Constructs and initializes a Color3b from the specified Tuple3b.
      * @param t1 the Tuple3b containing the initialization x y z data
      */
    public Color3b(Tuple3b t1) {
	super(t1);
    }

    /**
      * Constructs and initializes a Color3b to (0,0,0).
      */
    public Color3b() {
	// super(); called implicitly
    }

    /**
     * Constructs color from awt.Color.
     *
     * @param color awt color
     */
    public Color3b(java.awt.Color color) {
        x = (byte)color.getRed();
        y = (byte)color.getGreen();
        z = (byte)color.getBlue();
    }

    /**
     * Sets color from awt.Color.
     * @param color awt color
     */
    public final void set(java.awt.Color color) {
        x = (byte)color.getRed();
        y = (byte)color.getGreen();
        z = (byte)color.getBlue();
    }

    /**
     * Gets awt.Color.
     *
     * @return color awt color
     */
    public final java.awt.Color get() {
        return new java.awt.Color(x, y, z);
    }
}

--- NEW FILE: Color3f.java ---
/*
   Copyright (C) 1997,1998,1999
   Kenji Hiranabe, Eiwa System Management, Inc.

   This program is free software.
   Implemented by Kenji Hiranabe(hir...@es...),
   conforming to the Java(TM) 3D API specification by Sun Microsystems.

   Permission to use, copy, modify, distribute and sell this software
   and its documentation for any purpose is hereby granted without fee,
   provided that the above copyright notice appear in all copies and
   that both that copyright notice and this permission notice appear
   in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc.
   makes no representations about the suitability of this software for any
   purpose.  It is provided "AS IS" with NO WARRANTY.
*/
package javax.vecmath;

import java.io.Serializable;

/**
  * A 3 element color represented by single precision floating point x,y,z
  * coordinates. Color components should be in the range of zero to one.
  * @version specification 1.2, implementation $Revision: 1.1 $, $Date: 2002/08/22 20:01:14 $
  * @author Kenji hiranabe
  */
public class Color3f extends Tuple3f implements Serializable {
/*
 * $Log: Color3f.java,v $
 * Revision 1.1  2002/08/22 20:01:14  egonw
 * Lots of new files. Amongst which the source code of vecmath.jar.
 * The latter has been changed to compile with gcj-3.0.4.
 * Actually, CDK does now compile, i.e. at least the classes mentioned
 * in core.classes and extra.classes. *And* a binary executable can get
 * generated that works!
 *
 * Revision 1.9  1999/11/25  10:55:01  hiranabe
 * awt.Color conversion
 *
 * Revision 1.8  1999/10/05  07:03:50  hiranabe
 * copyright change
 *
 * Revision 1.7  1999/03/04  09:16:33  hiranabe
 * small bug fix and copyright change
 *
 * Revision 1.6  1998/10/14  00:49:10  hiranabe
 * API1.1 Beta02
 *
 * Revision 1.5  1998/04/10  04:52:14  hiranabe
 * API1.0 -> API1.1 (added constructors, methods)
 *
 * Revision 1.4  1998/04/09  08:18:15  hiranabe
 * minor comment change
 *
 * Revision 1.3  1998/04/09  07:04:31  hiranabe
 * *** empty log message ***
 *
 * Revision 1.2  1998/01/05  06:29:31  hiranabe
 * copyright 98
 *
 * Revision 1.1  1997/11/26  03:00:44  hiranabe
 * Initial revision
 *
 */

    /**
      * Constructs and initializes a Color3f from the specified xyz
      * @param x the x coordinate
      * @param y the y coordinate
      * @param z the z coordinate
      */
    public Color3f(float x, float y, float z) {
	super(x, y, z);
    }

    /**
      * Constructs and initializes a Color3f from input array of length 3.
      * @param c the array of length 3 containing xyz in order
      */
    public Color3f(float c[]) {
	// ArrayIndexOutOfBounds is thrown if t.length < 3
	super(c);
    }

    /**
      * Constructs and initializes a Color3f from the specified Color3f.
      * @param c the Color3f containing the initialization x y z data
      */
    public Color3f(Color3f c1) {
	super(c1);
    }

    /**
      * Constructs and initializes a Color3f from the specified Tuple3d.
      * @param t1 the Tuple3d containing the initialization x y z data
      */
    public Color3f(Tuple3d t1) {
	super(t1);
    }

    /**
      * Constructs and initializes a Color3f from the specified Tuple3f.
      * @param t1 the Tuple3f containing the initialization x y z data
      */
    public Color3f(Tuple3f t1) {
	super(t1);
    }

    /**
      * Constructs and initializes a Color3f to (0,0,0).
      */
    public Color3f() {
	// super(); called implicitly.
    }

    /**
     * Constructs color from awt.Color.
     *
     * @param color awt color
     */
    public Color3f(java.awt.Color color) {
        x = ((float)color.getRed())/255;
        y = ((float)color.getGreen())/255;
        z = ((float)color.getBlue())/255;
    }

    /**
     * Sets color from awt.Color.
     * @param color awt color
     */
    public final void set(java.awt.Color color) {
        x = ((float)color.getRed())/255;
        y = ((float)color.getGreen())/255;
        z = ((float)color.getBlue())/255;
    }

    /**
     * Gets awt.Color.
     *
     * @return color awt color
     */
    // Not implemented in gcj 3.0.3/3.0.4.
    //public final java.awt.Color get() {
    //    return new java.awt.Color(x, y, z);
    //}
}

--- NEW FILE: Color4b.java ---
/*
   Copyright (C) 1997,1998,1999
   Kenji Hiranabe, Eiwa System Management, Inc.

   This program is free software.
   Implemented by Kenji Hiranabe(hir...@es...),
   conforming to the Java(TM) 3D API specification by Sun Microsystems.

   Permission to use, copy, modify, distribute and sell this software
   and its documentation for any purpose is hereby granted without fee,
   provided that the above copyright notice appear in all copies and
   that both that copyright notice and this permission notice appear
   in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc.
   makes no representations about the suitability of this software for any
   purpose.  It is provided "AS IS" with NO WARRANTY.
*/
package javax.vecmath;

import java.io.Serializable;

/**
  * A four byte colors  (mostly used for colors with alpha).
  * @version specification 1.2, implementation $Revision: 1.1 $, $Date: 2002/08/22 20:01:14 $
  * @author Kenji hiranabe
  */
public class Color4b extends Tuple4b implements Serializable {
/*
 * $Log: Color4b.java,v $
 * Revision 1.1  2002/08/22 20:01:14  egonw
 * Lots of new files. Amongst which the source code of vecmath.jar.
 * The latter has been changed to compile with gcj-3.0.4.
 * Actually, CDK does now compile, i.e. at least the classes mentioned
 * in core.classes and extra.classes. *And* a binary executable can get
 * generated that works!
 *
 * Revision 1.9  1999/11/25  10:55:01  hiranabe
 * awt.Color conversion
 *
 * Revision 1.8  1999/10/05  07:03:50  hiranabe
 * copyright change
 *
 * Revision 1.7  1999/03/04  09:16:33  hiranabe
 * small bug fix and copyright change
 *
 * Revision 1.6  1998/10/14  00:49:10  hiranabe
 * API1.1 Beta02
 *
 * Revision 1.5  1998/04/10  04:52:14  hiranabe
 * API1.0 -> API1.1 (added constructors, methods)
 *
 * Revision 1.4  1998/04/09  08:18:15  hiranabe
 * minor comment change
 *
 * Revision 1.3  1998/04/09  07:05:18  hiranabe
 * API 1.1
 *
 * Revision 1.2  1998/01/05  06:29:31  hiranabe
 * copyright 98
 *
 * Revision 1.1  1997/11/26  03:00:44  hiranabe
 * Initial revision
 *
 */

    /**
      * Constructs and initializes a Color4b from the specified four values.
      * @param c1 the first value
      * @param c2 the second value
      * @param c3 the third value
      * @param c4 the fourth value
      */
    public Color4b(byte c1, byte c2, byte c3, byte c4) {
	super(c1, c2, c3, c4);
    }

    /**
      * Constructs and initializes a Color4b from input array of length 4.
      * @param c the array of length 4 containing c1 c2 c3 c4 in order
      */
    public Color4b(byte c[]) {
	// ArrayIndexOutOfBounds is thrown if t.length < 4
	super(c);
    }

    /**
      * Constructs and initializes a Color4b from the specified Color4b.
      * @param c the Color4b containing the initialization x y z w data
      */
    public Color4b(Color4b c1) {
	super(c1);
    }

    /**
      * Constructs and initializes a Color4b from the specified Tuple4b.
      * @param t1 the Tuple4b containing the initialization x y z w data
      */
    public Color4b(Tuple4b t1) {
	super(t1);
    }

    /**
      * Constructs and initializes a Color4b to (0,0,0,0).
      */
    public Color4b() {
	// super(); called implicitly.
    }

    /**
     * Constructs color from awt.Color.
     *
     * @param color awt color
     */
    public Color4b(java.awt.Color color) {
        x = (byte)color.getRed();
        y = (byte)color.getGreen();
        z = (byte)color.getBlue();
        w = (byte)color.getAlpha();
    }

    /**
     * Sets color from awt.Color.
     * @param color awt color
     */
    public final void set(java.awt.Color color) {
        x = (byte)color.getRed();
        y = (byte)color.getGreen();
        z = (byte)color.getBlue();
        w = (byte)color.getAlpha();
    }

    /**
     * Gets awt.Color.
     *
     * @return color awt color
     */
    public final java.awt.Color get() {
        return new java.awt.Color(x, y, z, w);
    }
}

--- NEW FILE: Color4f.java ---
/*
   Copyright (C) 1997,1998,1999
   Kenji Hiranabe, Eiwa System Management, Inc.

   This program is free software.
   Implemented by Kenji Hiranabe(hir...@es...),
   conforming to the Java(TM) 3D API specification by Sun Microsystems.

   Permission to use, copy, modify, distribute and sell this software
   and its documentation for any purpose is hereby granted without fee,
   provided that the above copyright notice appear in all copies and
   that both that copyright notice and this permission notice appear
   in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc.
   makes no representations about the suitability of this software for any
   purpose.  It is provided "AS IS" with NO WARRANTY.
*/
package javax.vecmath;

import java.io.Serializable;

/**
  * A 4 element color represented by single precision floating point x,y,z,w
  * coordinates. Color and alpha components should be in the range of zero to one.
  * @version specification 1.2, implementation 1.0 $Revision: 1.1 $, $Date: 2002/08/22 20:01:14 $
  * @author Kenji hiranabe
  */
public class Color4f extends Tuple4f implements Serializable {
/*
 * $Log: Color4f.java,v $
 * Revision 1.1  2002/08/22 20:01:14  egonw
 * Lots of new files. Amongst which the source code of vecmath.jar.
 * The latter has been changed to compile with gcj-3.0.4.
 * Actually, CDK does now compile, i.e. at least the classes mentioned
 * in core.classes and extra.classes. *And* a binary executable can get
 * generated that works!
 *
 * Revision 1.8  1999/11/25  10:55:01  hiranabe
 * awt.Color conversion
 *
 * Revision 1.7  1999/10/05  07:03:50  hiranabe
 * copyright change
 *
 * Revision 1.6  1999/03/04  09:16:33  hiranabe
 * small bug fix and copyright change
 *
 * Revision 1.5  1998/10/14  00:49:10  hiranabe
 * API1.1 Beta02
 *
 * Revision 1.4  1998/04/10  04:52:14  hiranabe
 * API1.0 -> API1.1 (added constructors, methods)
 *
 * Revision 1.3  1998/04/09  07:05:18  hiranabe
 * API 1.1
 *
 * Revision 1.2  1998/01/05  06:29:31  hiranabe
 * copyright 98
 *
 * Revision 1.1  1997/11/26  03:00:44  hiranabe
 * Initial revision
 *
 */

    /**
      * Constructs and initializes a Color4f from the specified xyzw
      * @param x the x coordinate
      * @param y the y coordinate
      * @param z the z coordinate
      * @param w the w coordinate
      */
    public Color4f(float x, float y, float z, float w) {
	super(x, y, z, w);
    }

    /**
      * Constructs and initializes a Color4f from input array of length 4.
      * @param c the array of length 4 containing xyzw in order
      */
    public Color4f(float c[]) {
	// ArrayIndexOutOfBounds is thrown if t.length < 4
	super(c);
    }

    /**
      * Constructs and initializes a Color4f from the specified Color4f.
      * @param c the Color4f containing the initialization x y z w data
      */
    public Color4f(Color4f c1) {
	super(c1);
    }

    /**
      * Constructs and initializes a Color4f from the specified Tuple4d.
      * @param t1 the Tuple4d containing the initialization x y z w data
      */
    public Color4f(Tuple4d t1) {
	super(t1);
    }

    /**
      * Constructs and initializes a Color4f from the specified Tuple4f.
      * @param t1 the Tuple4f containing the initialization x y z w data
      */
    public Color4f(Tuple4f t1) {
	super(t1);
    }

    /**
      * Constructs and initializes a Color4f to (0,0,0,0).
      */
    public Color4f() {
	// super(); called implicitly.
    }

    /**
     * Constructs color from awt.Color.
     *
     * @param color awt color
     */
    public Color4f(java.awt.Color color) {
        x = ((float)color.getRed())/255;
        y = ((float)color.getGreen())/255;
        z = ((float)color.getBlue())/255;
        w = ((float)color.getAlpha())/255;
    }

    /**
     * Sets color from awt.Color.
     * @param color awt color
     */
    public final void set(java.awt.Color color) {
        x = ((float)color.getRed())/255;
        y = ((float)color.getGreen())/255;
        z = ((float)color.getBlue())/255;
        w = ((float)color.getAlpha())/255;
    }

    /**
     * Gets awt.Color.
     *
     * @return color awt color
     */
    // not implemented in gcj 3.0.3/3.0.4.
    //public final java.awt.Color get() {
    //    return new java.awt.Color(x, y, z, w);
    //}
}

--- NEW FILE: GMatrix.java ---
/*
   Copyright (C) 1997,1998,1999
   Kenji Hiranabe, Eiwa System Management, Inc.

   This program is free software.
   Implemented by Kenji Hiranabe(hir...@es...),
   conforming to the Java(TM) 3D API specification by Sun Microsystems.

   Permission to use, copy, modify, distribute and sell this software
   and its documentation for any purpose is hereby granted without fee,
   provided that the above copyright notice appear in all copies and
   that both that copyright notice and this permission notice appear
   in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc.
   makes no representations about the suitability of this software for any
   purpose.  It is provided "AS IS" with NO WARRANTY.
*/
package javax.vecmath;

import java.io.Serializable;
[...1397 lines suppressed...]
		permutation.setElement(imax, permutation.getElement(j));
		permutation.setElement(j, tmp);
		even = -even;
	    }

	    // zero-div occurs.
	    // if (a[j][j] == 0.0) 

	    if (j != n - 1) {
		dum = 1.0 / a[j*n + j];
		for (int i = j + 1; i < n; i++) 
		    a[i*n + j] *= dum;
	    }

	} // end of for j

	return even;

    }
}

--- NEW FILE: GVector.java ---
/*
   Copyright (C) 1997,1998,1999
   Kenji Hiranabe, Eiwa System Management, Inc.

   This program is free software.
   Implemented by Kenji Hiranabe(hir...@es...),
   conforming to the Java(TM) 3D API specification by Sun Microsystems.

   Permission to use, copy, modify, distribute and sell this software
   and its documentation for any purpose is hereby granted without fee,
   provided that the above copyright notice appear in all copies and
   that both that copyright notice and this permission notice appear
   in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc.
   makes no representations about the suitability of this software for any
   purpose.  It is provided "AS IS" with NO WARRANTY.
*/
package javax.vecmath;

import java.io.Serializable;

/**
 * A double precision, general, and dynamically resizeable one 
 * dimensional vector class. Index numbering begins with zero.
 * @version specification 1.1, implementation $Revision: 1.1 $, $Date: 2002/08/22 20:01:14 $
 * @author Kenji hiranabe
 */
public class GVector implements Serializable {
/*
 * $Log: GVector.java,v $
 * Revision 1.1  2002/08/22 20:01:14  egonw
 * Lots of new files. Amongst which the source code of vecmath.jar.
 * The latter has been changed to compile with gcj-3.0.4.
 * Actually, CDK does now compile, i.e. at least the classes mentioned
 * in core.classes and extra.classes. *And* a binary executable can get
 * generated that works!
 *
 * Revision 1.10  1999/10/05  07:03:50  hiranabe
 * copyright change
 *
 * Revision 1.10  1999/10/05  07:03:50  hiranabe
 * copyright change
 *
 * Revision 1.9  1999/03/04  09:16:33  hiranabe
 * small bug fix and copyright change
 *
 * Revision 1.8  1998/10/14  00:49:10  hiranabe
 * API1.1 Beta02
 *
 * Revision 1.7  1998/07/27  04:28:13  hiranabe
 * API1.1Alpha01 ->API1.1Alpha03
 *
 * Revision 1.6  1998/04/17  10:30:46  hiranabe
 * null check for equals
 *
 * Revision 1.5  1998/04/10  04:52:14  hiranabe
 * API1.0 -> API1.1 (added constructors, methods)
 *
 * Revision 1.4  1998/04/09  08:18:15  hiranabe
 * minor comment change
 *
 * Revision 1.3  1998/04/09  07:05:18  hiranabe
 * API 1.1
 *
 * Revision 1.2  1998/01/05  06:29:31  hiranabe
 * copyright 98
 *
 * Revision 1.1  1997/11/26  03:00:44  hiranabe
 * Initial revision
 *
 */

    // note: only elementCount data in elementData are valid.
    // elementData.length is the allocated size.
    // invariant: elementData.length >= elementCount.
    private int elementCount;
    private double elementData[];

    /**
     * Constructs a new generalized mathematic Vector with zero
     * elements; length reprents the number of elements in the
     * vector.
     * @param   length number of elements in this vector. 
     */
    public GVector(int length) {
	elementCount = length;
        elementData = new double[length];  // will be initialized to 0.0
    }

    /**
     * Constructs a new generalized mathematic Vector with zero 
     * elements; length reprents the number of elements in the 
     * vector. !! this comment is a bug in Sun's API !!
     * @param   vector the values for the new vector. 
     */
    public GVector(double vector[]) {
	this(vector.length);
        System.arraycopy(vector, 0, elementData, 0, elementCount);
    }

    /**
     * Constructs a new GVector and copies the initial values from 
     * the parameter vector.  
     * @param   vector the source for the new GVector's initial values 
     */
    public GVector(GVector vector) {
	this(vector.elementCount);
        System.arraycopy(vector.elementData, 0, elementData, 0, elementCount);
    }

    /**
     * Constructs a new GVector and copies the initial values from 
     * the Tuple 
     *
     * @param   vector the source for the new GVector's initial values 
     */
    public GVector(Tuple2f tuple) {
	this(2);
	set(tuple);
    }

    /**
     * Constructs a new GVector and copies the initial values from 
     * the Tuple 
     * @param   vector the source for the new GVector's initial values 
     */
    public GVector(Tuple3f tuple) {
	this(3);
	set(tuple);
    }

    /**
     * Constructs a new GVector and copies the initial values from 
     * the Tuple 
     * @param   vector the source for the new GVector's initial values 
     */
    public GVector(Tuple3d tuple)  {
	this(3);
	set(tuple);
    }

    /**
     * Constructs a new GVector and copies the initial values from 
     * the Tuple 
     * @param   vector the source for the new GVector's initial values 
     */
    public GVector(Tuple4f tuple) {
	this(4);
	set(tuple);
    }

    /**
     * Constructs a new GVector and copies the initial values from 
     * the Tuple 
     * @param   vector the source for the new GVector's initial values 
     */
    public GVector(Tuple4d tuple) {
	this(4);
	set(tuple);
    }

    /**
      * Constructs a new GVector by copying length elements from the 
      * array parameter.  The parameter length must be less than or 
      * equal to vector.length.
      * @param vector The array from which the values will be copied.
      * @param length The number of values copied from the array.
     */
    public GVector(double vector[], int length) {
	// ArrayIndexOutOfBounds occur if length > vector.legnth
	this(length);
        System.arraycopy(vector, 0, elementData, 0, elementCount);
    }

    /**
     * Returns the square root of the sum of the squares of this 
     * vector (its length in n-dimensional space). 
     *
     * @return  length of this vector 
     */
    public final double norm() {
	return Math.sqrt(normSquared());
    }

    /**
     * Returns the sum of the squares of this vector (its length 
     * sqaured in n-dimensional space). <p>
     * @return  length squared of this vector 
     */
    public final double normSquared() {
        double s = 0.0;
        for (int i = 0; i < elementCount; i++) {
            s += elementData[i] * elementData[i];
        }
        return s;
    }

    /**
     * Sets the value of this vector to the normalization of 
     * vector v1. 
     * @param   v1 the un-normalized vector 
     */
    public final void normalize(GVector v1) {
	set(v1);
	normalize();
    }

    /**
     * Normalizes this vector in place. 
     */
    public final void normalize() {
        double len = norm();
	// zero-div may happen.
        for (int i = 0; i < elementCount; i++)
	    elementData[i] /= len;
    }

    /**
     * Sets the value of this vector to the scalar multiplication of 
     * the scale factor with the vector v1.
     * @param   s the scalar value 
     * @param   v1 the source vector 
     */
    public final void scale(double s, GVector v1) {
	set(v1);
	scale(s);
    }

    /**
     * Scales this vector by the scale factor s. 
     * @param   s the scalar value 
     */
    public final void scale(double s) {
        for (int i = 0; i < elementCount; i++)
            elementData[i] *= s;
    }

    /** 
     * Sets the value of this vector to the scalar multiplication by 
     * s of vector v1 plus vector v2 (this = s*v1 + v2).
     * @param   s the scalar value 
     * @param   v1 the vector to be multiplied 
     * @param   v2 the vector to be added 
     */
    public final void scaleAdd(double s, GVector v1, GVector v2)  {
        double [] v1data = v1.elementData;
        double [] v2data = v2.elementData;

        if (elementCount != v1.elementCount)
            throw new ArrayIndexOutOfBoundsException("this.size:"+elementCount+" != v1's size:"+v1.elementCount);
        if (elementCount != v2.elementCount)
            throw new ArrayIndexOutOfBoundsException("this.size:"+elementCount+" != v2's size:"+v2.elementCount);

        for (int i = 0; i < elementCount; i++) {
            elementData[i] = s * v1data[i] + v2data[i];
	}
    }

    /**
     * Sets the value of this vector to sum of itself and the 
     * specified vector 
     * @param   vector the second vector 
     */
    public final void add(GVector vector) {
        double [] v1data = vector.elementData;

        if (elementCount != vector.elementCount)
            throw new ArrayIndexOutOfBoundsException("this.size:"+elementCount+" != v2's size:"+vector.elementCount);

        for (int i = 0; i < elementCount; i++) {
            elementData[i] += v1data[i];
	}
    }

    /**
     * Sets the value of this vector to the vector sum of vectors 
     * vector1 and vector2.
     * @param   vector1 the first vector 
     * @param   vector2 the second vector 
     */
    public final void add(GVector vector1, GVector vector2) {
	set(vector1);
	add(vector2);
    }

    /**
     * Sets the value of this vector to the vector difference of 
     * itself and vector (this = this - vector).
     * @param   vector - the other vector 
     */
    public final void sub(GVector vector)  {
        double [] v1data = vector.elementData;
        if (elementCount != vector.elementCount)
            throw new ArrayIndexOutOfBoundsException("this.size:"+elementCount+" != vector's size:"+vector.elementCount);

        for (int i = 0; i < elementCount; i++) {
            elementData[i] -= v1data[i];
	}
    }

    /**
     * Sets the value of this vector to the vector difference of 
     * vectors vector1 and vector2 (this = vector1 - vector2). 
     * @param   vector1 the first vector 
     * @param   vector2 the second vector 
     */
    public final void sub(GVector vector1,GVector vector2) {
	set(vector1);
	sub(vector2);
    }

    /**
     * Multiplies matrix m1 times Vector v1 and places the result 
     * into this vector (this = m1*v1).
     * @param   m1 The matrix in the multiplication 
     * @param   v1 The vector that is multiplied 
     */
    public final void mul(GMatrix m1, GVector v1) {
	// note: this implementatin is NOT alias-safe!
	// i.e. v.mul(M,v) does not comutes right.

	// note: no 'auto-grow' policy.

        double [] v1data = v1.elementData;
        int v1size = v1.elementCount;
	int nCol = m1.getNumCol();
	int nRow = m1.getNumRow();

        if (v1size != nCol)
            throw new IllegalArgumentException("v1.size:"+v1size+" != m1.nCol:" + nCol);
	if (elementCount != nRow)
            throw new IllegalArgumentException("this.size:"+elementCount+" != m1.nRow:" + nRow);

        for (int i = 0; i < elementCount; i++) {
	    double sum = 0.0;
            for (int j = 0; j < nCol; j++) {
	            sum += m1.getElement(i, j) * v1data[j];
            }
            elementData[i] = sum;
        }

	/*
	 * if auto-grow, will be like;
	 * 
	 * elementCount = m1.getNumRow();
	 * if (elementData.length < elementCount)
	 *     elementData = new double [elementCount];
	 *     // then above implementation.
	 */
    }

    /**
     * Multiplies the transpose of vector v1 (ie, v1 becomes a row 
     * vector with respect to the multiplication) times matrix m1 
     * and places the result into this vector 
     * (this = transpose(v1)*m1). The result is technically a row 
     * vector, but the GVector class only knows about column vectors, 
     * and so the result is stored as a column vector. 
     * @param   m1 The matrix in the multiplication 
     * @param   v1 The vector that is temporarily transposed 
     */
    public final void mul(GVector v1, GMatrix m1) {
	// note: this implementatin is NOT alias-safe!
	// i.e. v.mul(M,v) does not comutes right.

	// note: no 'auto-grow' policy.

        double [] v1data = v1.elementData;
        int v1size = v1.elementCount;
	int nCol = m1.getNumCol();
	int nRow = m1.getNumRow();

        if (v1size != nRow)
            throw new IllegalArgumentException("v1.size:"+v1size+" != m1.nRow:" + nRow);
	if (elementCount != nCol)
            throw new IllegalArgumentException("this.size:"+elementCount+" != m1.nCol:" + nCol);

        for (int i = 0; i < elementCount; i++) {
	    double sum = 0.0;
            for (int j = 0; j < nRow; j++) {
	            sum += m1.getElement(j, i) * v1data[j];
            }
            elementData[i] = sum;
        }
    }

    /**
     * Negates the value of this vector: this = -this. 
     */
    public final void negate() {
        for (int i = 0; i < elementCount; i++)
            elementData[i] = -elementData[i];
    }

    /**
     * Sets all the values in this vector to zero. 
     */
    public final void zero() {
	// seZero may be more consistent name.
        for (int i = 0; i < elementCount; i++)
            elementData[i] = 0.0;
    }

    /**
     * Changes the size of this vector dynamically. If the size is 
     * increased no data values will be lost. If the size is 
     * decreased, only those data values whose vector positions 
     * were eliminated will be lost.
     * @param   length number of desired elements in this vector 
     */
    public final void setSize(int newSize) {
        if (newSize < 0)
            throw new NegativeArraySizeException("newSize:"+newSize +" < 0");

	if (elementCount < newSize) {
	    double [] oldData = elementData;
	    elementData = new double[newSize];
	    System.arraycopy(oldData, 0, elementData, 0, elementCount);
	}

	elementCount = newSize;
    }

    /**
     * Sets the value of this vector to the values found in the 
     * array parameter. The array should be at least equal in 
     * length to the number of elements in the vector. 
     * @param   vector the source array 
     */
    public final void set(double vector[]) {
	// note: only this.elementCount data is copied.(no auto-grow)
        System.arraycopy(vector, 0, elementData, 0, elementCount);
    }

    /**
     * Sets the value of this vector to the values found in 
     * vector vector. 
     * @param   vector the source vector 
     */
    public final void set(GVector vector) {
	// note: only this.elementCount data is copied.(no auto-grow)
        System.arraycopy(vector.elementData, 0, elementData, 0, elementCount);
    }

    /**
     * Sets the value of this vector to the values in tuple.
     * @param   tuple the source for the new GVector's new values 
     */
    public final void set(Tuple2f tuple)  {
        elementData[0] = (double)tuple.x;
        elementData[1] = (double)tuple.y;
    }

    /**
     * Sets the value of this vector to the values in tuple.
     * @param   tuple the source for the new GVector's new values 
     */
    public final void set(Tuple3f tuple) {
        elementData[0] = (double)tuple.x;
        elementData[1] = (double)tuple.y;
        elementData[2] = (double)tuple.z;
    }

    /**
     * Sets the value of this vector to the values in tuple.
     * @param   tuple the source for the new GVector's new values 
     */
    public final void set(Tuple3d tuple) {
        elementData[0] = tuple.x;
        elementData[1] = tuple.y;
        elementData[2] = tuple.z;
    }

    /**
     * Sets the value of this vector to the values in tuple.
     * @param   tuple the source for the new GVector's new values 
     */
    public final void set(Tuple4f tuple) {
        elementData[0] = (double)tuple.x;
        elementData[1] = (double)tuple.y;
        elementData[2] = (double)tuple.z;
        elementData[3] = (double)tuple.w;
    }

    /**
     * Sets the value of this vector to the values in tuple.
     * @param   tuple the source for the new GVector's new values 
     */
    public final void set(Tuple4d tuple) {
        elementData[0] = tuple.x;
        elementData[1] = tuple.y;
        elementData[2] = tuple.z;
        elementData[3] = tuple.w;
    }

    /**
     * Returns the number of elements in this vector. 
     * @return  number of elements in this vector 
     */
    public final int getSize() {
        return elementCount;
    }

    /**
     * Retrieves the value at the specified index value of this 
     * vector.
     * @param   index the index of the element to retrieve (zero indexed) 
     * @return  the value at the indexed element 
     */
    public final double getElement(int index) {
	try {
	    return elementData[index];
	} catch (ArrayIndexOutOfBoundsException e) {
	    throw new ArrayIndexOutOfBoundsException("index:"+index+ 
                "must be in [0, " + (elementCount-1) + "]");
	}
    }

    /**
     * Modifies the value at the specified index of this vector. 
     * @param   index the index if the element to modify (zero indexed) 
     * @param   value the new vector element value 
     */
    public final void setElement(int index,  double value) {
	try {
            elementData[index] = value;
	} catch (ArrayIndexOutOfBoundsException e) {
	    throw new ArrayIndexOutOfBoundsException("index:"+index+
		 " must be in [0, " + (elementCount-1) + "]");
	}
    }

    /**
     * Returns a string that contains the values of this GVector.
     * @return  the String representation 
     */
    public String toString() {
	StringBuffer buf = new StringBuffer();
	buf.append("(");
	for (int i = 0 ; i < elementCount-1 ; i++) {
	    buf.append(elementData[i]);
	    buf.append(",");
	}
	buf.append(elementData[elementCount-1]);
	buf.append(")");
	return buf.toString();
    }

    /**
     * Returns a hash number based on the data values in this
     * object.  Two different GMatrix objects with identical data values
     * (ie, returns true for equals(GMatrix) ) will return the same hash
     * number.  Two objects with different data members may return the
     * same hash value, although this is not likely.
     * @return the integer hash value
     */
    public int hashCode() {
	int hash = 0;
	for (int i = 0; i < elementCount; i++) {
	    long bits = Double.doubleToLongBits(elementData[i]);
	    hash ^= (int)(bits ^ (bits >> 32));
	}
	return hash;
    }

    /**
     * Returns true if all of the data members of GVector vector1 
     * are equal to the corresponding data members in this GVector.
     * @param   vector1 The vector with which the comparison is made. 
     * @return  true or false 
     */
    public boolean equals(GVector vector1) {
	if (vector1 == null)
	    return false;
        if (elementCount != vector1.elementCount)
	    return false;
	double [] v1data = vector1.elementData;
        for (int i = 0; i < elementCount; i++) {
            if (elementData[i] != v1data[i])
		return false;
        }
        return true;
    }

    /**
      * Returns true if the Object o1 is of type GVector and all of the data
      * members of t1 are equal to the corresponding data members in this
      * GVector.
      * @param o1 the object with which the comparison is made.
      */
    public boolean equals(Object o1) {
	return o1 != null && (o1 instanceof GVector) && equals((GVector)o1);
    }

    /**
     * Returns true if the L-infinite distance between this vector 
     * and vector v1 is less than or equal to the epsilon parameter, 
     * otherwise returns false. The L-infinite distance is equal 
     * to MAX[abs(x1-x2), abs(y1-y2), . . . ]. <p>
     * @param   v1 The vector to be compared to this vector 
     * @param   epsilon the threshold value 
     */
    public boolean epsilonEquals(GVector v1, double epsilon) {
        if (elementCount != v1.elementCount)
	    return false;
	double [] v1data = v1.elementData;
        for (int i = 0; i < elementCount; i++) {
            if (Math.abs(elem...

[truncated message content]