Design of The VMath Class

Details

Encapsulating Vectors:

You must not create a class that encapsulates a vector. Instead, you must use a double[] to hold the elements.

Vectors of Different Size:

As you know, many operations on two vectors require that they be the same size. When implementing such operations there are several things that you can do when passed methods of different size, including:
• Return null.
• Throw an exception.
• Assume that the samller vector is the "correct" size and that the larger is filled-out with "garbage".

While the second approach is probably the best in many respects, the third will be more convenient for rendering. Hence, you must use the third approach.

For example, if the add() method is passed to vectors, one with 4 elements and the other with 2, it should use the first two elements of both and return a vector with 2 elements.

Side Effects:

The methods in this class must NOT change the vectors they are passed.

Attributes:

This class must include the following attribute:

  private static final double TOL = 0.000000001;
  

The cross() Method:

This class must include an implementation of the following method:

    /**
     * Calculate the cross product of two vectors
     * in RxRxR
     *
     * @param a   One vector
     * @param b   The other vector
     * @return    The cross product
     */
    public static double[] cross(double[] a, double[] b)
  

For this method, both vectors must have exactly three elements.

The diff() Method:

This class must include an implementation of the following method:

    /**
     * Calculate the difference between two vectors
     * (i.e., a-b)
     *
     * @param a   One vector
     * @param b   The other vector
     * @return    a - b
     */
    public static double[] diff(double[] a, double[] b)
  

The dot() Method:

This class must include an implementation of the following method:

    /**
     * Calculate the dot/inner product of two vectors
     *
     * @param a   One vector
     * @param b   The other vector
     * @return    a . b
     */
    public static double dot(double[] a, double[] b)
  

The equals() Method:

This class must include an implementation of the following method:

    /**
     * Determines if two vectors are equal (within a given tolerance)
     *
     * @param p  One vector
     * @param q  Another vector
     * @return   true if all of the elements are the same
     */
    public static boolean equals(double[] p, double[] q)
  

This method must use TOL as the tolerance.

The norm() Method:

This class must include an implementation of the following method:

    /**
     * Calculate the Euclidean norm of a vector
     *
     * @param p   The vector
     * @return    ||p||
     */
    public static double norm(double[] p)
  

The normalized() Method:

This class must include an implementation of the following method:

    /**
     * Calculate the normalized version of a vector
     *
     * @param p   The vector
     * @return    p/||p||
     */
    public static double[] normalized(double[] p)
  

The perp() Method:

This class must include an implementation of the following method:

    /**
     * Find a perpindicular to the given 2D vector
     *
     * @param p   The vector
     * @return    The perpendicular [-p[1], p[0]]
     */
    public static double[] perp(double[] p)
  

This method must return a vector with two elements.

The sum() Method:

This class must include an implementation of the following method:

    /**
     * Calculate the sum of two vectors
     * (i.e., a+b)
     *
     * @param a   One vector
     * @param b   The other vector
     * @return    a + b
     */
    public static double[] sum(double[] a, double[] b)
  

The times() Method:

This class must include an implementation of the following method:

    /**
     * Multiply a vector by a scalar
     *
     * @param alpha  The scalar
     * @param p      The vector
     * @return       alpha p
     */
    public static double[] times(double alpha, double[] p)