/*GM2D03.java 
Copyright 2008, R.G.Baldwin
Revised 02/10/08

The name GM2Dnn is an abbreviation for GameMath2Dnn.

See the file named GM2D01.java for a general description 
of this game-math library file. This file is an update of 
GM2D02.

This update added the following new capabilities:

Compare two ColMatrix objects for equality by implementing
Kjell's rules for equality given in his Chapter 1, topic
"Column Matrix Equality." The equality test does not test 
for absolute equality.  Rather, It compares the values 
stored in two matrices and returns true if the values are 
equal or almost equal and returns false otherwise.

Get a reference to the ColMatrix object that defines
a Point object.

Compare two Point objects for equality based on a 
comparison of the ColMatrix objects that define them.

Get a reference to the ColMatrix object that defines
a Vector object.

Compare two Vector objects for equality based on a 
comparison of the ColMatrix objects that define them.

Add one ColMatrix object to a second ColMatrix object, 
returning a ColMatrix object.

Subtract one ColMatrix object from a second ColMatrix 
object, returning a ColMatrix object.

Get a displacement vector from one Point object to a 
second Point object. The vector points from the object
on which the getDisplacementVector method is called to the
object passed as a parameter to the method.

Tested using JDK 1.6 under WinXP.
*********************************************************/
import java.awt.geom.*;
import java.awt.*;

public class GM2D03{

  //An object of this class represents a 2D column matrix.
  // An object of this class is the fundamental building
  // block for several of the other classes in the
  // library.
  public static class ColMatrix{
    double[] data = new double[2];
    
    public ColMatrix(double data0,double data1){
      data[0] = data0;
      data[1] = data1;
    }//end constructor
    //--------------------------------------------------//
    
    public String toString(){
      return data[0] + "," + data[1];
    }//end overridden toString method
    //--------------------------------------------------//
    
    public double getData(int index){
      if((index < 0) || (index > 1)){ 
        throw new IndexOutOfBoundsException();
      }else{
        return data[index];
      }//end else
    }//end getData method
    //--------------------------------------------------//
    
    public void setData(int index,double data){
      if((index < 0) || (index > 1)){ 
        throw new IndexOutOfBoundsException();
      }else{
        this.data[index] = data;
      }//end else
    }//end setData method
    //--------------------------------------------------//
    
    //This method overrides the equals method inherited
    // from the class named Object. It compares the values
    // stored in two matrices and returns true if the
    // values are equal or almost equal and returns false
    // otherwise. 
    public boolean equals(Object obj){
      if(obj instanceof GM2D03.ColMatrix &&
         Math.abs(((GM2D03.ColMatrix)obj).getData(0) - 
                                 getData(0)) <= 0.00001 &&
         Math.abs(((GM2D03.ColMatrix)obj).getData(1) - 
                                  getData(1)) <= 0.00001){
        return true;
      }else{
        return false;
      }//end else
     
    }//end overridden equals method
    //--------------------------------------------------//

    //Adds one ColMatrix object to another ColMatrix
    // object, returning a ColMatrix object.
    public GM2D03.ColMatrix add(GM2D03.ColMatrix matrix){
      return new GM2D03.ColMatrix(
                            getData(0)+matrix.getData(0),
                            getData(1)+matrix.getData(1));
    }//end add
    //--------------------------------------------------//
    
    //Subtracts one ColMatrix object from another
    // ColMatrix object, returning a ColMatrix object. The
    // object that is received as an incoming parameter 
    // is subtracted from the object on which the method
    // is called.
    public GM2D03.ColMatrix subtract(
                                 GM2D03.ColMatrix matrix){
      return new GM2D03.ColMatrix(
                            getData(0)-matrix.getData(0),
                            getData(1)-matrix.getData(1));
    }//end subtract
    //--------------------------------------------------//
  }//end class ColMatrix
  //====================================================//
  
  public static class Point{
    GM2D03.ColMatrix point;
    
    public Point(GM2D03.ColMatrix point){//constructor
      //Create and save a clone of the ColMatrix object
      // used to define the point to prevent the point
      // from being corrupted by a later change in the
      // values stored in the original ColVector object
      // through use of its set method.
      this.point = 
         new ColMatrix(point.getData(0),point.getData(1));
    }//end constructor
    //--------------------------------------------------//

    public String toString(){
      return point.getData(0) + "," + point.getData(1);
    }//end toString
    //--------------------------------------------------//
    
    public double getData(int index){
      if((index < 0) || (index > 1)){ 
        throw new IndexOutOfBoundsException();
      }else{
        return point.getData(index);
      }//end else
    }//end getData
    //--------------------------------------------------//
    
    public void setData(int index,double data){
      if((index < 0) || (index > 1)){ 
        throw new IndexOutOfBoundsException();
      }else{
        point.setData(index,data);
      }//end else
    }//end setData
    //--------------------------------------------------//
    
    //This method draws a small circle around the location
    // of the point on the specified graphics context.
    public void draw(Graphics2D g2D){
      Ellipse2D.Double circle = 
                        new Ellipse2D.Double(getData(0)-3,
                                             getData(1)-3,
                                             6,
                                             6);
      g2D.draw(circle);
    }//end draw
    //--------------------------------------------------//
    
    //Returns a reference to the ColMatrix object that
    // defines this Point object.
    public GM2D03.ColMatrix getColMatrix(){
      return point;
    }//end getColMatrix
    //--------------------------------------------------//

    //This method overrides the equals method inherited
    // from the class named Object. It compares the values
    // stored in the ColMatrix objects that define two
    // Point objects and returns true if they are equal
    // and false otherwise. 
    public boolean equals(Object obj){
      if(point.equals(((GM2D03.Point)obj).
                                         getColMatrix())){
        return true;
      }else{
        return false;
      }//end else
     
    }//end overridden equals method
    //--------------------------------------------------//

    //Gets a displacement vector from one Point object to
    // a second Point object. The vector points from the
    // object on which the method is called to the object
    // passed as a parameter to the method. Kjell
    // describes this as the distance you would have to
    // walk along the x and then the y axes to get from
    // the first point to the second point.
    public GM2D03.Vector getDisplacementVector(
                                      GM2D03.Point point){
      return new GM2D03.Vector(new GM2D03.ColMatrix(
                            point.getData(0)-getData(0),
                            point.getData(1)-getData(1)));
    }//end getDisplacementVector
    //--------------------------------------------------//
  }//end class Point
  //====================================================//
  
  public static class Vector{
    GM2D03.ColMatrix vector;
    
    public Vector(GM2D03.ColMatrix vector){//constructor
      //Create and save a clone of the ColMatrix object
      // used to define the vector to prevent the vector
      // from being corrupted by a later change in the
      // values stored in the original ColVector object.
      this.vector = new ColMatrix(
                     vector.getData(0),vector.getData(1));
    }//end constructor
    //--------------------------------------------------//

    public String toString(){
      return vector.getData(0) + "," + vector.getData(1);
    }//end toString
    //--------------------------------------------------//
    
    public double getData(int index){
      if((index < 0) || (index > 1)){
        throw new IndexOutOfBoundsException();
      }else{
        return vector.getData(index);
      }//end else
    }//end getData
    //--------------------------------------------------//
    
    public void setData(int index,double data){
      if((index < 0) || (index > 1)){ 
        throw new IndexOutOfBoundsException();
      }else{
        vector.setData(index,data);
      }//end else
    }//end setData
    //--------------------------------------------------//
    
    //This method draws a vector on the specified graphics
    // context, with the tail of the vector located at a
    // specified point, and with a small circle at the
    // head.
    public void draw(Graphics2D g2D,GM2D03.Point tail){
      Line2D.Double line = new Line2D.Double(
                       tail.getData(0),
                       tail.getData(1),
                       tail.getData(0)+vector.getData(0),
                       tail.getData(1)+vector.getData(1));

    //Draw a small circle to identify the head.
      Ellipse2D.Double circle = new Ellipse2D.Double(
                      tail.getData(0)+vector.getData(0)-2,
                      tail.getData(1)+vector.getData(1)-2,
                      4,
                      4);
      g2D.draw(circle);
      g2D.draw(line);
    }//end draw
    //--------------------------------------------------//
    
    //Returns a reference to the ColMatrix object that
    // defines this Vector object.
    public GM2D03.ColMatrix getColMatrix(){
      return vector;
    }//end getColMatrix
    //--------------------------------------------------//

    //This method overrides the equals method inherited
    // from the class named Object. It compares the values
    // stored in the ColMatrix objects that define two
    // Vector objects and returns true if they are equal
    // and false otherwise. 
    public boolean equals(Object obj){
      if(vector.equals((
                     (GM2D03.Vector)obj).getColMatrix())){
        return true;
      }else{
        return false;
      }//end else
     
    }//end overridden equals method
    //--------------------------------------------------//
  }//end class Vector
  //====================================================//
  
  //A line is defined by two points. One is called the
  // tail and the other is called the head.
  public static class Line{
    GM2D03.Point[] line = new GM2D03.Point[2];
    
    public Line(GM2D03.Point tail,GM2D03.Point head){
      //Create and save clones of the points used to
      // define the line to prevent the line from being 
      // corrupted by a later change in the coordinate
      // values of the points.
      this.line[0] = new Point(new GM2D03.ColMatrix(
                        tail.getData(0),tail.getData(1)));
      this.line[1] = new Point(new GM2D03.ColMatrix(
                        head.getData(0),head.getData(1)));
    }//end constructor
    //--------------------------------------------------//

    public String toString(){
      return "Tail = " + line[0].getData(0) + "," 
             + line[0].getData(1) + "\nHead = " 
             + line[1].getData(0) + "," 
             + line[1].getData(1);
    }//end toString
    //--------------------------------------------------//

    public GM2D03.Point getTail(){
      return line[0];
    }//end getTail
    //--------------------------------------------------//
    
    public GM2D03.Point getHead(){
      return line[1];
    }//end getHead
    //--------------------------------------------------//
    
    public void setTail(GM2D03.Point newPoint){
      //Create and save a clone of the new point to
      // prevent the line from being corrupted by a
      // later change in the coordinate values of the
      // point.
      this.line[0] = new Point(new GM2D03.ColMatrix(
              newPoint.getData(0),newPoint.getData(1)));
    }//end setTail
    //--------------------------------------------------//
    
    public void setHead(GM2D03.Point newPoint){
      //Create and save a clone of the new point to
      // prevent the line from being corrupted by a
      // later change in the coordinate values of the
      // point.
      this.line[1] = new Point(new GM2D03.ColMatrix(
              newPoint.getData(0),newPoint.getData(1)));
    }//end setHead
    //--------------------------------------------------//
    
    public void draw(Graphics2D g2D){
      Line2D.Double line = new Line2D.Double(
                                    getTail().getData(0),
                                    getTail().getData(1),
                                    getHead().getData(0),
                                    getHead().getData(1));
      g2D.draw(line);
    }//end draw
    //--------------------------------------------------//
  }//end class Line
  //====================================================//

}//end class GM2D03

/*ColMatrixEquals01.java 
Copyright 2008, R.G.Baldwin
Revised 02/08/08

The purpose of this program is to confirm the behavior of
the equals methods of the GM2D03.ColMatrix, Point, and
Vector classes.

Tested using JDK 1.6 under WinXP.
*********************************************************/

public class ColMatrixEquals01{
  public static void main(String[] args){
    GM2D03.ColMatrix matA = 
                           new GM2D03.ColMatrix(1.5,-2.6);
    GM2D03.ColMatrix matB = 
                           new GM2D03.ColMatrix(1.5,-2.6);
    GM2D03.ColMatrix matC = 
                 new GM2D03.ColMatrix(1.500001,-2.600001);
    GM2D03.ColMatrix matD = 
                   new GM2D03.ColMatrix(1.50001,-2.60001);
    System.out.println(matA.equals(matA));
    System.out.println(matA.equals(matB));
    System.out.println(matA.equals(matC));
    System.out.println(matA.equals(matD));
    
    GM2D03.Point pointA = new GM2D03.Point(
                       new GM2D03.ColMatrix(15.6,-10.11));
    GM2D03.Point pointB = new GM2D03.Point(
                       new GM2D03.ColMatrix(15.6,-10.11));
    GM2D03.Point pointC = new GM2D03.Point(
                       new GM2D03.ColMatrix(-15.6,10.11));
    System.out.println(/*Blank line*/);
    System.out.println(pointA.equals(pointA));
    System.out.println(pointA.equals(pointB));
    System.out.println(pointA.equals(pointC));
    
    GM2D03.Vector vecA = new GM2D03.Vector(
                       new GM2D03.ColMatrix(15.6,-10.11));
    GM2D03.Vector vecB = new GM2D03.Vector(
                       new GM2D03.ColMatrix(15.6,-10.11));
    GM2D03.Vector vecC = new GM2D03.Vector(
                       new GM2D03.ColMatrix(-15.6,10.11));
    System.out.println(/*Blank line*/);
    System.out.println(vecA.equals(vecA));
    System.out.println(vecA.equals(vecB));
    System.out.println(vecA.equals(vecC));

  }//end main
}//end ColMatrixEquals01 class

/*DisplacementVector01.java 
Copyright 2008, R.G.Baldwin
Revised 02/08/08

The purpose of this program is to confirm the behavior of
the getDisplacementVector method of the GM2D03.Point
class.

Tested using JDK 1.6 under WinXP.
*********************************************************/

public class DisplacementVector01{
  public static void main(String[] args){
    GM2D03.Point pointA = new GM2D03.Point(
                          new GM2D03.ColMatrix(6.5,-9.7));
    GM2D03.Point pointB = new GM2D03.Point(
                          new GM2D03.ColMatrix(-6.0,9.0));
    
    System.out.println(pointA.getDisplacementVector(
                                                 pointB));
    System.out.println(pointB.getDisplacementVector(
                                                 pointA));

  }//end main
}//end DisplacementVector01 class

/*ColMatrixAddSubtract01.java 
Copyright 2008, R.G.Baldwin
Revised 02/08/08

The purpose of this program is to confirm the behavior of
the add and subtract methods of the GM2D03.ColMatrix 
class.

Tested using JDK 1.6 under WinXP.
*********************************************************/

public class ColMatrixAddSubtract01{
  public static void main(String[] args){
  
    GM2D03.ColMatrix matrixA = 
                         new GM2D03.ColMatrix(3.14,-6.01);
    GM2D03.ColMatrix matrixB = 
                        new GM2D03.ColMatrix(-14.0,-12.2);
    
    GM2D03.ColMatrix matrixC = matrixA.add(matrixB);
    GM2D03.ColMatrix matrixD = matrixC.subtract(matrixA);
    GM2D03.ColMatrix matrixE = matrixD.subtract(matrixB);
    
    System.out.println(matrixC);
    System.out.println(matrixD);
    System.out.println(matrixE);
  }//end main

}//end class ColMatrixAddSubtract01