/*GM2D04.java 
Copyright 2008, R.G.Baldwin
Revised 02/08/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 
GM2D03.

This update added the following new capabilities:

Vector addition - Adds this Vector object to a Vector
object received as an incoming parameter and returns the
sum as a resultant Vector object.

Added a method named getLength that returns the length
of a vector as type double.

Added a method named addVectorToPoint to add a Vector to 
a Point producing a new Point.

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

public class GM2D04{

  //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 GM2D04.ColMatrix &&
         Math.abs(((GM2D04.ColMatrix)obj).getData(0) - 
                                 getData(0)) <= 0.00001 &&
         Math.abs(((GM2D04.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 GM2D04.ColMatrix add(GM2D04.ColMatrix matrix){
      return new GM2D04.ColMatrix(
                            getData(0)+matrix.getData(0),
                            getData(1)+matrix.getData(1));
    }//end subtract
    //--------------------------------------------------//
    
    //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 GM2D04.ColMatrix subtract(
                                 GM2D04.ColMatrix matrix){
      return new GM2D04.ColMatrix(
                            getData(0)-matrix.getData(0),
                            getData(1)-matrix.getData(1));
    }//end subtract
    //--------------------------------------------------//
  }//end class ColMatrix
  //====================================================//
  
  public static class Point{
    GM2D04.ColMatrix point;
    
    public Point(GM2D04.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 ColMatrix 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 GM2D04.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(((GM2D04.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 GM2D04.Vector getDisplacementVector(
                                      GM2D04.Point point){
      return new GM2D04.Vector(new GM2D04.ColMatrix(
                            point.getData(0)-getData(0),
                            point.getData(1)-getData(1)));
    }//end getDisplacementVector
    //--------------------------------------------------//
    
    //Adds a Vector to a Point producing a new Point.
    public GM2D04.Point addVectorToPoint(
                                      GM2D04.Vector vec){
      return new GM2D04.Point(new GM2D04.ColMatrix(
                          getData(0) + vec.getData(0),
                          getData(1) + vec.getData(1)));
    }//end addVectorToPoint
    //--------------------------------------------------//
  }//end class Point
  //====================================================//
  
  public static class Vector{
    GM2D04.ColMatrix vector;
    
    public Vector(GM2D04.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,GM2D04.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 GM2D04.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((
                     (GM2D04.Vector)obj).getColMatrix())){
        return true;
      }else{
        return false;
      }//end else
     
    }//end overridden equals method
    //--------------------------------------------------//
    
    //Adds this vector to a vector received as an incoming
    // parameter and returns the sum as a vector.
    public GM2D04.Vector add(GM2D04.Vector vec){
      return new GM2D04.Vector(new ColMatrix(
                       vec.getData(0)+vector.getData(0),
                       vec.getData(1)+vector.getData(1)));
    }//end add
    //--------------------------------------------------//
    
    //Returns the length of a Vector object.
    public double getLength(){
      return Math.sqrt(
           getData(0)*getData(0) + getData(1)*getData(1));
    }//end getLength
    //--------------------------------------------------//
  }//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{
    GM2D04.Point[] line = new GM2D04.Point[2];
    
    public Line(GM2D04.Point tail,GM2D04.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 GM2D04.ColMatrix(
                        tail.getData(0),tail.getData(1)));
      this.line[1] = new Point(new GM2D04.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 GM2D04.Point getTail(){
      return line[0];
    }//end getTail
    //--------------------------------------------------//
    
    public GM2D04.Point getHead(){
      return line[1];
    }//end getHead
    //--------------------------------------------------//
    
    public void setTail(GM2D04.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 GM2D04.ColMatrix(
              newPoint.getData(0),newPoint.getData(1)));
    }//end setTail
    //--------------------------------------------------//
    
    public void setHead(GM2D04.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 GM2D04.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 GM2D04
//======================================================//

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

This program illustrates the addition of two or more
vectors. It also illustrates the Head-to-Tail rule
described by Kjell.

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

class VectorAdd01{
  public static void main(String[] args){
    GUI guiObj = new GUI();
  }//end main
}//end controlling class VectorAdd01
//======================================================//

class GUI extends JFrame{
  //Specify the horizontal and vertical size of a JFrame
  // object.
  int hSize = 275;
  int vSize = 200;
  Image osi;//an off-screen image
  int osiWidth;//off-screen image width
  int osiHeight;//off-screen image height
  MyCanvas myCanvas;//a subclass of Canvas
  
  GUI(){//constructor
    //Set JFrame size, title, and close operation.
    setSize(hSize,vSize);
    setTitle("Copyright 2008,Baldwin");
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
    //Create a new drawing canvas and add it to the
    // center of the JFrame.
    myCanvas = new MyCanvas();
    this.getContentPane().add(myCanvas);
    
    //This object must be visible before you can get an
    // off-screen image.  It must also be visible before
    // you can compute the size of the canvas.
    setVisible(true);
    osiWidth = myCanvas.getWidth();
    osiHeight = myCanvas.getHeight();

    //Create an off-screen image and get a graphics
    // context on it.
    osi = createImage(osiWidth,osiHeight);
    Graphics2D g2D = (Graphics2D)(osi.getGraphics());
    
    //Draw some graphical objects on the off-screen
    // image that represent underlying data objects in
    // 2D space.
    drawOffScreen(g2D);

    //Cause the overridden paint method belonging to
    // myCanvas to be executed.
    myCanvas.repaint();

  }//end constructor
  //----------------------------------------------------//
  
  //The purpose of this method is to add some Vector
  // objects and to cause visual manifestations of the raw
  // Vector objects and the resultant Vector objects to be
  // drawn onto an off-screen image.
  void drawOffScreen(Graphics2D g2D){
    
    //Translate the origin on the off-screen
    // image and draw a pair of orthogonal axes on it.
    setCoordinateFrame(g2D);
    
    //Define two vectors.
    GM2D04.Vector vecA = new GM2D04.Vector(
                            new GM2D04.ColMatrix(50,100));
    GM2D04.Vector vecB = new GM2D04.Vector(
                             new GM2D04.ColMatrix(75,25));
                           
    //Define a third vector as the sum of the first
    // two vectors defined above.
    GM2D04.Vector sumOf2 = vecA.add(vecB);
    
    //Draw vecA in RED with its tail at the origin
    g2D.setColor(Color.RED);
    vecA.draw(g2D,new GM2D04.Point(
                              new GM2D04.ColMatrix(0,0)));
                              
    //Draw vecB in GREEN with its tail at the head of vecA
    g2D.setColor(Color.GREEN);
    vecB.draw(g2D,new GM2D04.Point(new GM2D04.ColMatrix(
                       vecA.getData(0),vecA.getData(1))));
                       
    //Draw sumOf2 in MAGENTA with its tail at the origin.
    // The head will coincide with the head of vecB.
    g2D.setColor(Color.MAGENTA);
    sumOf2.draw(g2D,new GM2D04.Point(new GM2D04.ColMatrix(
                       0.0,0.0)));

    //Now define another vector and add it to vecA and
    // vecB.
    GM2D04.Vector vecC = new GM2D04.Vector(
                           new GM2D04.ColMatrix(30,-150));
                           
    //Draw vecD in BLUE with its tail positioned at the
    // sum of vecA and vecB
    g2D.setColor(Color.BLUE);
    vecC.draw(g2D,new GM2D04.Point(new GM2D04.ColMatrix(
                   sumOf2.getData(0),sumOf2.getData(1))));
                       
    //Define a vector as the sum of vecA, vecB, and vecC
    GM2D04.Vector sumOf3 = (vecA.add(vecB)).add(vecC);

    //Draw sumOf3 in BLACK with its tail at the origin.
    g2D.setColor(Color.BLACK);
    sumOf3.draw(g2D,new GM2D04.Point(
                          new GM2D04.ColMatrix(0.0,0.0)));

  }//end drawOffScreen
  //----------------------------------------------------//

  //This method is used to set the origin to a point near
  // the upper-left corner of the off-screen image  and
  // draw orthogonal axes on the off-screen image. There
  // is no intention to perform mathematical operations on
  // the axes, so they are drawn independently of the
  // classes and methods in the game-math library using
  // the simplest method available for drawing a line.
  private void setCoordinateFrame(Graphics2D g2D){
    //Translate the origin.
    g2D.translate(0.2*osiWidth,0.2*osiHeight);
   
    //Draw new X and Y-axes in default BLACK
    g2D.drawLine(-(int)(0.2*osiWidth),0,
                 (int)(0.8*osiWidth),0);
                 
    g2D.drawLine(0,-(int)(0.2*osiHeight),
                 0,(int)(0.8*osiHeight));
        
  }//end setCoordinateFrame method
  //====================================================//
  
  
  //This is an inner class of the GUI class.
  class MyCanvas extends Canvas{
    //Override the paint() method. This method will be
    // called when the JFrame and the Canvas appear on the
    // screen or when the repaint method is called on the
    // Canvas object.
    //The purpose of this method is to display the
    // off-screen image on the screen.
    public void paint(Graphics g){
      g.drawImage(osi,0,0,this);
    }//end overridden paint()
    
  }//end inner class MyCanvas
    
}//end class GUI
//======================================================//

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

This program illustrates the relationship between the 
coordinate frame and a geometric object described in that 
coordinate frame. 

A GUI allows the user to move the origin of the coordinate 
frame. Proper mathematical corrections are made such that 
a geometric object described in that coordinate frame 
maintains its position relative to world coordinates even 
when the coordinate frame is changed. This causes its 
position relative to the coordinate frame to change.

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

class CoordinateFrame01{
  public static void main(String[] args){
    GUI guiObj = new GUI();
  }//end main
}//end controlling class CoordinateFrame01
//======================================================//

class GUI extends JFrame implements ActionListener{
  //Specify the horizontal and vertical size of a JFrame
  // object.
  int hSize = 400;
  int vSize = 400;
  Image osi;//an off-screen image
  int osiWidth;//off-screen image width
  int osiHeight;//off-screen image height
  MyCanvas myCanvas;//a subclass of Canvas
  
  //The following offset values are applied to the width
  // and the height of the off-screen image to modify the 
  // coordinate frame. They are used to store user input
  // values.
  double xOffsetFactor = 0.0;
  double yOffsetFactor = 0.0;
  
  //The following offset values are computed using the
  // user-specified offset factor values.
  double xOffset;
  double yOffset;
  
  Graphics2D g2D;//Off-screen graphics context.
  
  //User input fields.
  JTextField xOffsetField;
  JTextField yOffsetField;
  //----------------------------------------------------//
  
  GUI(){//constructor
    //Set JFrame size, title, and close operation.
    setSize(hSize,vSize);
    setTitle("Copyright 2008,R.G.Baldwin");
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
    //Create a new drawing canvas and add it to the
    // center of the content pane.
    myCanvas = new MyCanvas();
    this.getContentPane().add(
                            BorderLayout.CENTER,myCanvas);
    
    //Create and populate a JPanel to be used as a user-
    // input panel and add it to the SOUTH position on
    // the content pane.
    JPanel controlPanel = new JPanel();
    controlPanel.add(new JLabel("X-offset"));
    xOffsetField = new JTextField("0.0",3);
    controlPanel.add(xOffsetField);
    
    controlPanel.add(new JLabel("Y-offset"));
    yOffsetField = new JTextField("0.0",3);
    controlPanel.add(yOffsetField);
    
    JButton button = new JButton("Replot");
    controlPanel.add(button);
    this.getContentPane().add(
                         BorderLayout.SOUTH,controlPanel);
    
    //Register this object as an action listener on the
    // button.
    button.addActionListener(this);
    
    //This object must be visible before you can get an
    // off-screen image.  It must also be visible before
    // you can compute the size of the canvas.
    setVisible(true);
    
    //Make the size of the off-screen image match the
    // size of the canvas.
    osiWidth = myCanvas.getWidth();
    osiHeight = myCanvas.getHeight();

    //Create an off-screen image and get a graphics
    // context on it.
    osi = createImage(osiWidth,osiHeight);
    g2D = (Graphics2D)(osi.getGraphics());
    
    //Create some underlying data objects in
    // 2D space and draw visual manifestations of them.
    drawOffScreen(g2D);

    //Cause the overridden paint method belonging to
    // myCanvas to be executed.
    myCanvas.repaint();

  }//end constructor
  //----------------------------------------------------//
  
  //The purpose of this method is to create some Vector
  // objects and to cause visual manifestations of them to
  // be drawn onto an off-screen image.
  void drawOffScreen(Graphics2D g2D){
    
    //Establish the current coordinate frame and prepare
    // the off-screen image with axes, etc.
    setCoordinateFrame(g2D,xOffset,yOffset);

    //Define a Point that will be used to locate three
    // vectors that form a closed polygon. The physical
    // location of the polygon on the canvas (world)
    // remains the same regardless of how the coordinate
    // frame is changed.
    double startPointX = (196 - xOffset);
    double startPointY = (165 - yOffset);
    GM2D04.Point startPoint = new GM2D04.Point(
           new GM2D04.ColMatrix(startPointX,startPointY));

    //Instantiate three Vector objects that form a closed
    // polygon when drawn head-to-tail.
    double vecAx = 25;
    double vecAy = 50;
    GM2D04.Vector vecA = new GM2D04.Vector(
                       new GM2D04.ColMatrix(vecAx,vecAy));

    double vecBx = 37;
    double vecBy = -12;
    GM2D04.Vector vecB = new GM2D04.Vector(
                             new GM2D04.ColMatrix(37,12));
                             
    //Define vecC as the sum of vecA and vecB. It will be
    // of the correct length and direction to close the
    // polygon when drawn such that its tail coincides
    // with the tail of vecA.
    GM2D04.Vector vecC = vecA.add(vecB);
    
    //Draw vecA in red with its tail at startPoint.    
    g2D.setColor(Color.RED);
    vecA.draw(g2D,startPoint);
    
    //Compute the location of the head of vecA relative to
    // the current coordinate frame.
    double headX = 
                  vecA.getData(0) + startPoint.getData(0);
    double headY = 
                  vecA.getData(1) + startPoint.getData(1);
                              
    //Draw vecB in GREEN with its tail at the head of
    // vecA.
    g2D.setColor(Color.GREEN);
    vecB.draw(g2D,new GM2D04.Point(
                      new GM2D04.ColMatrix(headX,headY)));

    //Draw vecC in BLUE with its tail at startPoint,
    // coinciding with the tail of vecA. This forms a
    // closed polygon.
    g2D.setColor(Color.BLUE);
    vecC.draw(g2D,startPoint);

  }//end drawOffScreen
  //----------------------------------------------------//

  //This method is used to set the coordinate frame of
  // the off-screen image by setting the origin to the
  // specified offset values relative to origin of the
  // world. The origin of the world is the upper-left
  // corner of the off-screen image.
  //The method draws black orthogonal axes on the
  // off-screen image.
  //There is no intention to perform mathematical
  // operations on the axes, so they are drawn
  // independently of the classes and methods in the
  // game-math library.
  //The method paints the background white erasing
  // anything already there.
  private void setCoordinateFrame(
                  Graphics2D g2D,double xOff,double yOff){

    //Paint the background white
    g2D.setColor(Color.WHITE);
    g2D.fillRect(0,0,osiWidth,osiHeight);

    //Translate the origin by the specified amount
    g2D.translate((int)xOff,(int)yOff);

    //Draw new X and Y-axes in BLACK
    g2D.setColor(Color.BLACK);
    g2D.drawLine(-(int)xOff,0,(int)(osiWidth-xOff),0);
    g2D.drawLine(0,-(int)yOff,0,(int)((osiHeight-yOff)));

  }//end setCoordinateFrame method
  //----------------------------------------------------//
  
  //This method must be defined because the class 
  // implements the ActionListener interface. Because an
  // object of this class is registered as a listener on
  // the button, this method is called each time the user
  // presses the button.
  public void actionPerformed(ActionEvent e){
    //Reset the coordinate frame to world coordinates by
    // reversing the most recent translation.
    setCoordinateFrame(g2D,-xOffset,-yOffset);

    //Compute new translation offsets based on user input.
    xOffsetFactor = 
               Double.parseDouble(xOffsetField.getText());
    yOffsetFactor = 
               Double.parseDouble(yOffsetField.getText());

    xOffset = osiWidth*xOffsetFactor;
    yOffset = osiHeight*yOffsetFactor;

    //Draw a new off-screen image based on user inputs
    // and copy it to the canvas. Note that the
    // drawOffScreen method will call the
    // setCoordinateFrame method again with the new
    // offset values for the origin of the coordinate
    // frame.
    drawOffScreen(g2D);
    myCanvas.repaint();
  }//end actionPerformed
  //====================================================//
  
  
  //This is an inner class of the GUI class.
  class MyCanvas extends Canvas{
    //Override the paint() method. This method will be
    // called when the JFrame and the Canvas appear on the
    // screen or when the repaint method is called on the
    // Canvas object.
    //The purpose of this method is to display the
    // off-screen image on the screen.
    public void paint(Graphics g){
      g.drawImage(osi,0,0,this);
    }//end overridden paint()
    
  }//end inner class MyCanvas
    
}//end class GUI
//======================================================//

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

This program illustrates the addition of two vectors using
two different approaches that result in the parallelogram 
described by Kjell. It also illustrates the Head-to-Tail 
rule described by Kjell.

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

class VectorAdd02{
  public static void main(String[] args){
    GUI guiObj = new GUI();
  }//end main
}//end controlling class VectorAdd02
//======================================================//

class GUI extends JFrame{
  //Specify the horizontal and vertical size of a JFrame
  // object.
  int hSize = 225;
  int vSize = 225;
  Image osi;//an off-screen image
  int osiWidth;//off-screen image width
  int osiHeight;//off-screen image height
  MyCanvas myCanvas;//a subclass of Canvas
  
  GUI(){//constructor
    //Set JFrame size, title, and close operation.
    setSize(hSize,vSize);
    setTitle("Copyright 2008,R.G.Baldwin");
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
    //Create a new drawing canvas and add it to the
    // center of the JFrame.
    myCanvas = new MyCanvas();
    this.getContentPane().add(myCanvas);
    
    //This object must be visible before you can get an
    // off-screen image.  It must also be visible before
    // you can compute the size of the canvas.
    setVisible(true);
    osiWidth = myCanvas.getWidth();
    osiHeight = myCanvas.getHeight();

    //Create an off-screen image and get a graphics
    // context on it.
    osi = createImage(osiWidth,osiHeight);
    Graphics2D g2D = (Graphics2D)(osi.getGraphics());
    
    //Draw some graphical objects on the off-screen
    // image that represent underlying data objects in
    // 2D space.
    drawOffScreen(g2D);

    //Cause the overridden paint method belonging to
    // myCanvas to be executed.
    myCanvas.repaint();

  }//end constructor
  //----------------------------------------------------//
  
  //The purpose of this method is to add some Vector
  // objects and to cause visual manifestations of the raw
  // Vector objects and the resultant Vector objects to be
  // drawn onto an off-screen image.
  void drawOffScreen(Graphics2D g2D){
    
    //Translate the origin to a position near the bottom-
    // left corner of the off-screen image and draw a pair
    // of orthogonal axes that intersect at the origin.
    setCoordinateFrame(g2D);
    
    //Define two vectors.
    GM2D04.Vector vecA = new GM2D04.Vector(
                           new GM2D04.ColMatrix(50,-100));
    GM2D04.Vector vecB = new GM2D04.Vector(
                            new GM2D04.ColMatrix(75,-25));
                           
    //Draw vecA in RED with its tail at the origin
    g2D.setColor(Color.RED);
    vecA.draw(g2D,new GM2D04.Point(
                              new GM2D04.ColMatrix(0,0)));
                              
    //Draw vecB in GREEN with its tail at the head of vecA
    g2D.setColor(Color.GREEN);
    vecB.draw(g2D,new GM2D04.Point(new GM2D04.ColMatrix(
                       vecA.getData(0),vecA.getData(1))));
                       
    //Define a third vector as the sum of the first
    // two vectors defined above by adding vecB to vecA.
    GM2D04.Vector sumA = vecA.add(vecB);
    
    //Draw sumA in BLACK with its tail at the origin.
    // The head will coincide with the head of the
    // green vecB.
    g2D.setColor(Color.BLACK);
    sumA.draw(g2D,new GM2D04.Point(
                          new GM2D04.ColMatrix(0.0,0.0)));

    //Do the same operations but in a different order.

    //Draw vecB in GREEN with its tail at the origin.
    g2D.setColor(Color.GREEN);
    vecB.draw(g2D,new GM2D04.Point(
                              new GM2D04.ColMatrix(0,0)));

    //Draw vecA in RED with its tail at the head of vecB.
    g2D.setColor(Color.RED);
    vecA.draw(g2D,new GM2D04.Point(new GM2D04.ColMatrix(
                       vecB.getData(0),vecB.getData(1))));

    //Define a fourth vector as the sum of the first
    // two vectors defined above by adding vecA to vecB.
    GM2D04.Vector sumB = vecB.add(vecA);
    
    //Draw sumB in BLACK with its tail at the origin.
    // The head will coincide with the head of the
    // red vecA, and the visual manifestation of sumB will
    // overlay the visual manifestation of sumA
    g2D.setColor(Color.BLACK);
    sumB.draw(g2D,new GM2D04.Point(
                          new GM2D04.ColMatrix(0.0,0.0)));

  }//end drawOffScreen
  //----------------------------------------------------//

  //This method is used to set the origin of the
  // off-screen image to a location near the lower-left
  // corner and to draw orthogonal axes that intersect
  // at the origin.
  private void setCoordinateFrame(Graphics2D g2D){

    //Translate the origin to a point near the lower-left
    // corner of the off-screen image.
    g2D.translate(0.2*osiWidth,0.8*osiHeight);

    //Draw new X and Y-axes in default BLACK
    g2D.drawLine(-(int)(0.2*osiWidth),0,
                 (int)(0.8*osiWidth),0);
    
    g2D.drawLine(0,-(int)(0.8*osiHeight),
                 0,(int)(0.2*osiHeight));   
        
  }//end setCoordinateFrame method
  //====================================================//
  
  
  //This is an inner class of the GUI class.
  class MyCanvas extends Canvas{
    //Override the paint() method. This method will be
    // called when the JFrame and the Canvas appear on the
    // screen or when the repaint method is called on the
    // Canvas object.
    //The purpose of this method is to display the
    // off-screen image on the screen.
    public void paint(Graphics g){
      g.drawImage(osi,0,0,this);
    }//end overridden paint()
    
  }//end inner class MyCanvas
    
}//end class GUI
//======================================================//

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

This program illustrates the fact that the length of the 
sum of two vectors is not necessarily equal to the sum of 
the lengths of the two vectors. Two vectors are added such
and the length of the sum is much smaller than the length 
of either of the original vectors. The red and green 
vectors shown in the screen output are added producing the
black vector. The lengths of all three vectors are 
displayed on the command-line screen, demonstrating that 
the length of the black vector is much less than the 
length of either the red vector or the blue vector.

The only thing that is new in this program is the
getLength method of the GM2D04.Vector class.

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

class VectorAdd03{
  public static void main(String[] args){
    GUI guiObj = new GUI();
  }//end main
}//end controlling class VectorAdd03
//======================================================//

class GUI extends JFrame{
  //Specify the horizontal and vertical size of a JFrame
  // object.
  int hSize = 225;
  int vSize = 225;
  Image osi;//an off-screen image
  int osiWidth;//off-screen image width
  int osiHeight;//off-screen image height
  MyCanvas myCanvas;//a subclass of Canvas
  
  GUI(){//constructor
    //Set JFrame size, title, and close operation.
    setSize(hSize,vSize);
    setTitle("Copyright 2008,R.G.Baldwin");
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
    //Create a new drawing canvas and add it to the
    // center of the JFrame.
    myCanvas = new MyCanvas();
    this.getContentPane().add(myCanvas);
    
    //This object must be visible before you can get an
    // off-screen image.  It must also be visible before
    // you can compute the size of the canvas.
    setVisible(true);
    osiWidth = myCanvas.getWidth();
    osiHeight = myCanvas.getHeight();

    //Create an off-screen image and get a graphics
    // context on it.
    osi = createImage(osiWidth,osiHeight);
    Graphics2D g2D = (Graphics2D)(osi.getGraphics());
    
    //Draw some graphical objects on the off-screen
    // image that represent underlying data objects in
    // 2D space.
    drawOffScreen(g2D);

    //Cause the overridden paint method belonging to
    // myCanvas to be executed.
    myCanvas.repaint();

  }//end constructor
  //----------------------------------------------------//
  
  //The purpose of this method is to add some Vector
  // objects and to cause visual manifestations of the raw
  // Vector objects and the resultant Vector objects to be
  // drawn onto an off-screen image.
  void drawOffScreen(Graphics2D g2D){
    
    //Translate the origin and draw a pair of orthogonal
    // axes that intersect at the origin.
    setCoordinateFrame(g2D);
    
    //Define two vectors.
    GM2D04.Vector vecA = new GM2D04.Vector(
                           new GM2D04.ColMatrix(50,-100));
    GM2D04.Vector vecB = new GM2D04.Vector(
                           new GM2D04.ColMatrix(-35,110));
                           
    //Define a third vector as the sum of the first
    // two vectors defined above.
    GM2D04.Vector sumOf2 = vecA.add(vecB);
    
    //Draw vecA in RED with its tail at the origin
    g2D.setColor(Color.RED);
    vecA.draw(g2D,new GM2D04.Point(
                              new GM2D04.ColMatrix(0,0)));
                              
    //Draw vecB in GREEN with its tail at the head of vecA
    g2D.setColor(Color.GREEN);
    vecB.draw(g2D,new GM2D04.Point(new GM2D04.ColMatrix(
                       vecA.getData(0),vecA.getData(1))));
                       
    //Draw sumOf2 in BLACK with its tail at the origin.
    // The head will coincide with the head of vecB.
    g2D.setColor(Color.BLACK);
    sumOf2.draw(g2D,new GM2D04.Point(new GM2D04.ColMatrix(
                                               0.0,0.0)));
                       
    System.out.println(
                      "Red length = " + vecA.getLength());
    System.out.println(
                    "Green length = " + vecB.getLength());
    System.out.println(
                  "Black length = " + sumOf2.getLength());
  }//end drawOffScreen
  //----------------------------------------------------//

  //This method is used to set the origin of the
  // off-screen image and to draw orthogonal axes that
  // intersect at the origin.
  private void setCoordinateFrame(Graphics2D g2D){

    //Translate the origin to a point near the lower-left
    // corner of the off-screen image.
    g2D.translate(0.2*osiWidth,0.8*osiHeight);

    //Draw new X and Y-axes in default BLACK
    g2D.drawLine(-(int)(0.2*osiWidth),0,
                 (int)(0.8*osiWidth),0);
    
    g2D.drawLine(0,-(int)(0.8*osiHeight),
                 0,(int)(0.2*osiHeight));   
        
  }//end setCoordinateFrame method
  //====================================================//
  
  
  //This is an inner class of the GUI class.
  class MyCanvas extends Canvas{
    //Override the paint() method. This method will be
    // called when the JFrame and the Canvas appear on the
    // screen or when the repaint method is called on the
    // Canvas object.
    //The purpose of this method is to display the
    // off-screen image on the screen.
    public void paint(Graphics g){
      g.drawImage(osi,0,0,this);
    }//end overridden paint()
    
  }//end inner class MyCanvas
    
}//end class GUI
//======================================================//

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

This program illustrates the addition of a Vector to a 
Point producing a new Point. Both points and the vector
are drawn on the screen.

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

class VectorAdd04{
  public static void main(String[] args){
    GUI guiObj = new GUI();
  }//end main
}//end controlling class VectorAdd04
//======================================================//

class GUI extends JFrame{
  //Specify the horizontal and vertical size of a JFrame
  // object.
  int hSize = 225;
  int vSize = 225;
  Image osi;//an off-screen image
  int osiWidth;//off-screen image width
  int osiHeight;//off-screen image height
  MyCanvas myCanvas;//a subclass of Canvas
  
  GUI(){//constructor
    //Set JFrame size, title, and close operation.
    setSize(hSize,vSize);
    setTitle("Copyright 2008,R.G.Baldwin");
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
    //Create a new drawing canvas and add it to the
    // center of the JFrame.
    myCanvas = new MyCanvas();
    this.getContentPane().add(myCanvas);
    
    //This object must be visible before you can get an
    // off-screen image.  It must also be visible before
    // you can compute the size of the canvas.
    setVisible(true);
    osiWidth = myCanvas.getWidth();
    osiHeight = myCanvas.getHeight();

    //Create an off-screen image and get a graphics
    // context on it.
    osi = createImage(osiWidth,osiHeight);
    Graphics2D g2D = (Graphics2D)(osi.getGraphics());
    
    //Draw some graphical objects on the off-screen
    // image.
    drawOffScreen(g2D);

    //Cause the overridden paint method belonging to
    // myCanvas to be executed.
    myCanvas.repaint();

  }//end constructor
  //----------------------------------------------------//
  
  //The purpose of this method is to add a Vector object
  // to a Point object and to draw the result onto an
  // off-screen image..
  void drawOffScreen(Graphics2D g2D){
    
    //Translate the origin on the off-screen
    // image and draw a pair of orthogonal axes on it.
    setCoordinateFrame(g2D);

    //Define one point
    GM2D04.Point point = new GM2D04.Point(
                            new GM2D04.ColMatrix(50,-25));
    
    //Define one vector.
    GM2D04.Vector vecA = new GM2D04.Vector(
                            new GM2D04.ColMatrix(25,-50));
                           
    //Add the Vector object to the Point object producing
    // a new Point object
    GM2D04.Point newPoint = point.addVectorToPoint(vecA);
    
    //Draw vecA in RED with its tail at the original
    // point.
    g2D.setColor(Color.RED);
    vecA.draw(g2D,point);
    
    //Draw the original point in GREEN.
    g2D.setColor(Color.GREEN);
    point.draw(g2D);
    
    //Draw the new point in BLUE.
    g2D.setColor(Color.BLUE);
    newPoint.draw(g2D);

  }//end drawOffScreen
  //----------------------------------------------------//

  //This method is used to set the origin of the
  // off-screen image and to draw orthogonal axes on the
  // off-screen image that intersect at the origin.
  private void setCoordinateFrame(Graphics2D g2D){

    //Translate the origin to a point near the lower-left
    // corner of the off-screen image.
    g2D.translate(0.2*osiWidth,0.8*osiHeight);

    //Draw new X and Y-axes in default BLACK
    g2D.drawLine(-(int)(0.2*osiWidth),0,
                 (int)(0.8*osiWidth),0);
    
    g2D.drawLine(0,-(int)(0.8*osiHeight),
                 0,(int)(0.2*osiHeight));   
        
  }//end setCoordinateFrame method
  //====================================================//
  
  
  //This is an inner class of the GUI class.
  class MyCanvas extends Canvas{
    //Override the paint() method. This method will be
    // called when the JFrame and the Canvas appear on the
    // screen or when the repaint method is called on the
    // Canvas object.
    //The purpose of this method is to display the
    // off-screen image on the screen.
    public void paint(Graphics g){
      g.drawImage(osi,0,0,this);
    }//end overridden paint()
    
  }//end inner class MyCanvas
    
}//end class GUI
//======================================================//