diff --git a/BodyMaths.java b/BodyMaths.java
new file mode 100644
index 0000000..8db887f
--- /dev/null
+++ b/BodyMaths.java
@@ -0,0 +1,187 @@
+/**
+* This logic class contains all of the equations for three body problems involving gravity or electrostatics.
+* This class also contains the formulae for gravitational Lagrange points.
+* @author Matthew Williams, Yulia Kosharych
+* @version 2018-05-16
+**/
+public class BodyMaths {
+
+
+  // import constants
+  public static final double G = SolarBody.G;
+
+
+  /**
+  * This method calculates the acceleration that one body causes on another due to gravity
+  * @param obj[][] double               these are the positions of the object that the acceleration is calculated on
+  * @param body[][] double              these are the positions of the body that causes the gravitional acceleration on the object
+  * @param massBody double              this is the mass of the body that causes the acceleration
+  * @param i int                        this is the current timestep
+  * @param axis int                     this is the axis that is currently being calculated (0=x, y=1)
+  * @return acceleration double         this is the value of acceleration along the selected axis
+  * @version 2018-04-25
+  **/
+  public static double gravityAccel(double obj[][], double body[][], double massBody, int i, int axis){
+    double acceleration;
+    acceleration = -G*massBody*(obj[axis][i]-body[axis][i])/Math.pow(radius(obj, body, i), 3);
+    return acceleration;
+  }//dualBodyAccel()
+
+
+
+  /**
+  * This method calculates the magnitude of a two dimensional vector
+  * @param x double         this is the x component of the vector
+  * @param y double         this is the y component of the vector
+  * @return norm double     this is the magnitude of the vector
+  * @version 2018-04-25
+  **/
+  public static double norm(double x, double y) {
+    double norm = Math.sqrt(x*x+y*y);
+    return norm;
+  }//norm()
+
+  /**
+  * This method calculates the distance between two bodies at a specific timestep
+  * @param body1[][] double       these are the positions of first body
+  * @param body2[][] double       these are the positions of second body
+  * @param i int                  this is the current timestep
+  * @return norm                  this is the magnitude of the distance between the two bodies
+  * @version 2018-04-25
+  **/
+  public static double radius(double body1[][], double body2[][], int i) {
+    double x = body1[0][i] - body2[0][i];
+    double y = body1[1][i] - body2[1][i];
+    return norm(x, y);
+  }//radius()
+
+  /**
+  * This method updates the velcity and positions for a timestep based on the acceleration
+  * @param obj[][][] double       these are the position, velocity, acceleration vectors for a body
+  * @param dt double              this is the timestep length
+  * @param i int                  this is the current timestep
+  * @version 2018-05-16
+  **/
+  public static void updateBody(double obj[][][], double dt, int i){
+    // velocity = vI + a*dt
+    obj[1][0][0]+=obj[2][0][i]*dt;
+    obj[1][1][0]+=obj[2][1][i]*dt;
+    // position = xI + v*dt
+    obj[0][0][i]=obj[0][0][i-1]+obj[1][0][0]*dt;
+    obj[0][1][i]=obj[0][1][i-1]+obj[1][1][0]*dt;
+  }//updateBody()
+
+
+
+  // Lagrange points
+  /**
+  * These methods give the distances to the legrange points. m1>m2
+  *
+  * @param distance double    this is the distance between the major bodies
+  * @param m1       double    this is the mass of the body that is much larger than m2
+  * @param m2       double    this is the mass of the body that is much smaller than m1
+  *
+  * @return r       double    for L1 this is the distance from the smaller object towards the larger object
+  *                           for L2 this is the distance from the smaller object away from the larger object
+  *                           for L3 this is the distance from the larger object away from the smaller object
+  * @version 2018-05-08
+  **/
+  public static double L1(double distance, double m1, double m2){
+    double r = Math.abs(distance)*Math.pow(m2/(3*m1), 1./3.);
+    return r;
+  }//L1()
+  public static double L2(double distance, double m1, double m2){
+    double r = distance*Math.pow(m2/(3*m1), 1./3.);
+    return r;
+  }//L2()
+  public static double L3(double distance, double m1, double m2){
+    double r = 7./12.*distance*m2/m1;
+    return r;
+  }//L3()
+
+
+
+  /**
+  * This method calculates the required orbital velocity for a circular orbit
+  * @param massBig double       this is the mass of the driving body
+  * @param dis double           this is the starting distance between the two bodies
+  * @return velocity double     this is velocity required for a circular orbit
+  * @version 2018-05-16
+  **/
+  public static double circleVelocityG(double massBig, double dis){
+    double velocity = Math.sqrt(G*massBig/dis);
+    return velocity;
+  }//circleVelocityG()
+
+  /**
+  * This method calculates the the angularVelocity of a body in circular gravitational motion
+  * @param massBig double       this is the mass of the driving body
+  * @param dis double           this is the distance between the two bodies
+  * @return omega double        this is the angular velocity of the body
+  * @version 2018-05-16
+  **/
+  public static double angularVelocity(double massBig, double dis){
+    double omega = circleVelocityG(massBig, dis)/dis;
+    return omega;
+  }//angularVelocity()
+
+  /**
+  * This method calculates the orbital period of two bodies in circular gravitational motion
+  * @param massBig double       this is the mass of the driving body
+  * @param dis double           this is the distance between the two bodies
+  * @return time double         this is the orbital period in hours
+  * @version 2018-05-16
+  **/
+  public static double orbitalPeriod(double massBig, double dis){
+    double time = 2*Math.PI/angularVelocity(massBig, dis);
+    return time;
+  }//orbitalPeriod()
+
+
+  /**
+  * This method converts the positions from cartesian to polar coordinates in order to make the plot relative to one body
+  * @param body[][][][] double    these are the position, velocity, acceleration vectors for a body
+  * @param inertiaNum int         this is the body number to use for the reference
+  * @version 2018-05-18
+  **/
+  public static void inertialReference(double body[][][][], int inertiaNum){
+    int bodies = body.length;
+    int imax = body[0][0][0].length;
+    double bodyTheta[][] = new double[bodies][imax];
+    double radial[][] = new double[bodies][imax];
+    for (int i=0;i<bodyTheta[0].length;i++) {
+      if (body[inertiaNum][0][0][i]==0) {
+        bodyTheta[inertiaNum][i]=Math.PI/2;
+      }
+      else {
+        bodyTheta[inertiaNum][i]=Math.atan(body[inertiaNum][0][1][i]/body[inertiaNum][0][0][i]);
+      }
+      if (body[inertiaNum][0][0][i]<0) {
+        bodyTheta[inertiaNum][i]+=Math.PI;
+      }
+      radial[inertiaNum][i]=BodyMaths.norm(body[inertiaNum][0][1][i],body[inertiaNum][0][0][i]);
+      body[inertiaNum][0][0][i]=radial[inertiaNum][i];
+      body[inertiaNum][0][1][i]=0;
+    }
+    for (int bodynum=1;bodynum<bodyTheta.length;bodynum++) {
+      if (bodynum!=inertiaNum) {
+        for (int i=0;i<bodyTheta[0].length;i++) {
+          if (body[bodynum][0][0][i]==0) {
+            bodyTheta[bodynum][i]=Math.PI/2;
+          }
+          else {
+            bodyTheta[bodynum][i]=Math.atan(body[bodynum][0][1][i]/body[bodynum][0][0][i]);
+          }
+          if (body[bodynum][0][0][i]<0) {
+            bodyTheta[bodynum][i]+=Math.PI;
+          }
+          bodyTheta[bodynum][i]-=bodyTheta[inertiaNum][i];
+          radial[bodynum][i]=BodyMaths.norm(body[bodynum][0][1][i],body[bodynum][0][0][i]);
+          body[bodynum][0][0][i]=radial[bodynum][i]*Math.cos(bodyTheta[bodynum][i]);
+          body[bodynum][0][1][i]=radial[bodynum][i]*Math.sin(bodyTheta[bodynum][i]);
+        }
+      }
+    }
+  }//inertialReference()
+
+}//class
diff --git a/ElectrostaticMaths.java b/ElectrostaticMaths.java
new file mode 100644
index 0000000..2e03891
--- /dev/null
+++ b/ElectrostaticMaths.java
@@ -0,0 +1,29 @@
+/**
+* This logic class contains all of the equations for three body problems involving electrostatics.
+* has BodyMaths.java as a dependency
+* @author Matthew Williams, Yulia Kosharych
+* @version 2018-05-16
+**/
+public class ElectrostaticMaths {
+
+  // import constants
+  public static final double Ke = Electrostatics.Ke;
+
+  /**
+  * This method calculates the acceleration that one body causes on another due to electrostatic forces
+  * @param obj[][] double               these are the positions of the object that the acceleration is calculated on
+  * @param body[][] double              these are the positions of the body that causes the electrostatic forces on the object
+  * @param qObj double                  this is the charge of the object that is acted apon
+  * @param qBody double                 this is the charge of the other body
+  * @param massObj double               this is the mass of the object whose acceleration is calculated
+  * @param i int                        this is the current timestep
+  * @param axis int                     this is the axis that is currently being calculated (0=x, y=1)
+  * @return acceleration double         this is the value of acceleration along the selected axis
+  * @version 2018-04-30
+  **/
+  public static double electrostaticAccel(double obj[][], double body[][], double qObj, double qBody, double massObj, int i, int axis){
+    double acceleration;
+    acceleration = Ke*qObj*qBody*(obj[axis][i]-body[axis][i])/Math.pow(BodyMaths.radius(obj, body, i), 3)/massObj;
+    return acceleration;
+  }//electrostaticAccel()
+}
diff --git a/Electrostatics.java b/Electrostatics.java
new file mode 100644
index 0000000..041eb65
--- /dev/null
+++ b/Electrostatics.java
@@ -0,0 +1,103 @@
+import java.util.Scanner;
+/**
+* This class contains premade values and situations for electrostatic objects.
+* more methods to easily add premades can easily be created.
+* @author Matthew Williams, Yulia Kosharych
+* @version 2018-05-16
+**/
+public class Electrostatics{
+  public static final double Ke = 8.9875*Math.pow(10, 9);//N*m^2/C^2
+
+  public String name;
+  public double mass;
+  public double charge;
+  public double radius;
+  public double centreDis;
+  public double vInitial;
+  public double theta;
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+  public Electrostatics(String name, double mass, double charge, double centreDis, double vInitial, double radius, double theta){
+    this.name=name;
+    this.mass=mass;
+    this.charge=charge;
+    this.centreDis=centreDis;
+    this.vInitial=vInitial;
+    this.radius=radius;
+    this.theta=theta;
+  }
+
+  public Electrostatics(String name){
+    this.name=name;
+    this.mass=-1;
+    setCharge();
+    this.centreDis=-1;
+    setVelocity();
+    this.radius=-1;
+    setTheta();
+  }//input constructor
+  public Electrostatics(double mass, double charge, double centreDis, double vInitial, double rad, String name){
+    this.name=name;
+    this.mass=mass;
+    this.charge=charge;
+    this.centreDis=centreDis;
+    this.vInitial=vInitial;
+    this.radius=rad;
+    setTheta();
+  }
+  public Electrostatics(double mass, double charge, double centreDis, String name, double rad, double theta){
+    this.name=name;
+    this.mass=mass;
+    this.charge=charge;
+    this.centreDis=centreDis;
+    setVelocity();
+    this.radius=rad;
+    this.theta=theta;
+  }//select a velocity constructor
+  public Electrostatics(String name, double mass, double charge, double centreDis, double rad){
+    this.name=name;
+    this.mass=mass;
+    this.charge=charge;
+    this.centreDis=centreDis;
+    setVelocity();
+    this.radius=rad;
+    setTheta();
+  }//select theta and velocity constructor
+
+
+
+
+
+
+
+  public void setPath(){
+    this.mass=0;
+    this.name=this.name+"'s path";
+  }
+  public void setTheta(){
+    Scanner kb = new Scanner(System.in);
+    System.out.println("desired theta for "+this.name+" in pi radians");
+    this.theta=kb.nextDouble()*Math.PI;
+  }
+  public void setVelocity(){
+    Scanner kb = new Scanner(System.in);
+    System.out.println("desired initial velocity for "+this.name+" in km/h");
+    double vInit = kb.nextDouble();
+    System.out.print("times 10^");
+    double power = Math.pow(10, kb.nextDouble());
+    this.vInitial=vInit*power;
+    System.out.println("initial velcity = "+this.vInitial);
+  }
+  public void setCharge(){
+    Scanner kb = new Scanner(System.in);
+    System.out.println("desired total charge for "+this.name+" in C");
+    double vInit = kb.nextDouble();
+    System.out.print("times 10^");
+    double power = Math.pow(10, kb.nextDouble());
+    this.vInitial=vInit*power;
+    System.out.println("charge = "+this.vInitial);
+  }
+
+
+}
diff --git a/Main.java b/Main.java
new file mode 100644
index 0000000..4369b66
--- /dev/null
+++ b/Main.java
@@ -0,0 +1,32 @@
+import java.awt.Dimension;
+import java.awt.Toolkit;
+
+import javax.swing.JFrame;
+
+public class Main {
+
+	static Dimension screenDim = Toolkit.getDefaultToolkit().getScreenSize();
+	static Dimension dim = new Dimension(1200,800);
+	static Dimension dim2 = new Dimension(1000,800);
+	static Dimension dim3 = new Dimension(800,600);
+	
+	static Dimension frameDim = screenDim;
+	
+	
+	
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+
+		
+		JFrame win = new JFrame("Realtime: Drawing of a Solar System [IN PROGRESS]");
+		
+		MainPanel mainPanel = new MainPanel();
+		
+		win.setSize(frameDim);
+		win.setLocationRelativeTo(null);
+		win.setContentPane(mainPanel);
+		win.setVisible(true);
+		
+	}
+
+}
diff --git a/MainPanel.java b/MainPanel.java
new file mode 100644
index 0000000..61b8a86
--- /dev/null
+++ b/MainPanel.java
@@ -0,0 +1,523 @@
+import java.awt.BasicStroke;
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.geom.Ellipse2D;
+import java.util.Arrays;
+import java.util.Scanner;
+import javax.swing.JPanel;
+
+
+
+public class MainPanel extends JPanel{
+
+	public static double scaling =350;
+
+	public static Dimension MainPanelDim = Main.frameDim;
+
+	Object sun;
+	Object sat;
+	Object earth;
+
+	public static final double x0 = MainPanelDim.getWidth()/2;
+	public static final double y0 = MainPanelDim.getHeight()/2;
+
+	final double sunR = 75;
+	final double satR = 35;
+	final double earthR = 35;
+
+	Color sunColor;
+	Color satColor;
+	Color earthColor;
+
+	double t = 0;
+
+	public static final double G = SolarBody.G;//gravitational constant (km^3/kg/h^2)
+	public static final double dt = 1.0; //delta t in hours
+	public static final double tmax = BodyMaths.orbitalPeriod(SolarBody.massSol, SolarBody.solDisEarth) ; //number of hours to run (1 year)
+	public static double time = 0; //initial time
+	public static final boolean graphing = true;
+	public static final double au = SolarBody.au;//initial distance of earth from the sun in km
+
+
+	// public static final double massEarth=SolarBody.massEarth; //kg
+	// public static final double velocityEarth = SolarBody.vEarth;// initial velocity of Earth
+
+	public static final double massEarth=SolarBody.massEarth; //kg
+	public static final double velocityEarth = SolarBody.vEarth;// initial velocity of Earth
+
+	public static final double massJupiter =SolarBody.massJupiter;//kg
+	public static final double velocityJupiter = SolarBody.vJupiter;//velocity jupiter
+
+
+	public static final double massL5 = SolarBody.SE_L5.mass; //kg
+
+	public static final double massSun=SolarBody.massSol;  //kg
+	public static double massSat; //kg
+
+	public static Scanner kb = new Scanner(System.in);
+	public static double [][][] object = new double[3][3][2];
+	public static double [] maxAccel, minPosSun, minPosEarth;
+
+	public static double massPlanet; //mass of the planet
+
+
+
+
+	double satX, satY, velInitialX, velInitialY;
+	double planetX, planetY, velInitialPlanetX, velInitialPlanetY;
+
+
+	public void initSunEarthLuna()
+	{
+		 scaling = 350;
+
+			//Sat Conditions
+		  massSat = SolarBody.massLuna;
+		  satX = SolarBody.solDisLuna;
+		  satY = 0;
+		  velInitialX = 0;
+		  velInitialY = SolarBody.vLuna;
+
+		  	//Earth Condition
+		  massPlanet = massEarth;
+		  planetX = au;
+		  planetY = 0;
+			velInitialPlanetX = 0;
+			velInitialPlanetY = velocityEarth;
+
+	}
+	public void initSunJupiterCallisto()
+	{
+		 scaling = 75;
+			//Sat Conditions
+			massSat = SolarBody.massCallisto;
+			satX = SolarBody.solDisCallisto+9*SolarBody.jupDisCallisto;
+			satY = 0;
+			velInitialX = 0;
+			velInitialY = SolarBody.vJupiter+BodyMaths.circleVelocityG(massEarth, 10*SolarBody.jupDisCallisto);
+
+				//Jupiter Condition
+			massPlanet = massJupiter;
+			planetX = SolarBody.solDisJupiter;
+			planetY = 0;
+			velInitialPlanetX = 0;
+			velInitialPlanetY = velocityJupiter;
+
+	}
+
+
+	public void initSunEarthL5()
+	{
+		 scaling = 350;
+			//Sat Conditions
+			double theta = -Math.PI/3;
+		  massSat = massL5;
+		  satX = au*Math.cos(theta);
+		  satY = au*Math.sin(theta);
+		  velInitialX = -velocityEarth*Math.sin(theta);
+		  velInitialY = velocityEarth*Math.cos(theta);
+
+		  	//Planet Condition
+		  massPlanet = massEarth;
+		  planetX = au;
+		  planetY = 0;
+		  velInitialPlanetX = 0;
+		  velInitialPlanetY =velocityEarth;
+
+	}
+
+	public void initSunJupiterProbe()
+	{
+		 scaling =75;
+			//Sat Conditions
+		 System.out.println("Please enter the mass of the satellite:");
+		  massSat = kb.nextDouble();
+
+		  System.out.println("Please enter the x position of the satellite:");
+		  satX = kb.nextDouble();
+		  System.out.println("Please enter the y position of the satellite:");
+		  satY = kb.nextDouble();
+		  System.out.println("Please enter the initial  x component of the velocity of satellite");
+		  velInitialX = kb.nextDouble();
+		  System.out.println("Please enter the initial  y component of the velocity of satellite");
+		  velInitialY = kb.nextDouble();
+
+		  	//Jupiter Condition
+		  massPlanet=massJupiter;
+		  planetX =SolarBody.solDisJupiter;
+		  planetY = 0;
+		  velInitialPlanetX = 0;
+		  velInitialPlanetY = velocityJupiter;
+
+
+	}
+
+	public void initHorseshoe()
+	{
+		 scaling = 75;
+			//Sat Conditions
+			double theta = SolarBody.Horseshoe.theta;
+		  massSat = SolarBody.Horseshoe.mass;
+		  satX = SolarBody.Horseshoe.solDis*Math.cos(theta);
+		  satY = SolarBody.Horseshoe.solDis*Math.sin(theta);
+		  velInitialX = -SolarBody.Horseshoe.vInitial*Math.sin(theta);
+		  velInitialY = SolarBody.Horseshoe.vInitial*Math.cos(theta);
+
+		  	//Planet Condition
+		  massPlanet = massJupiter;
+		  planetX = SolarBody.solDisJupiter;
+		  planetY = 0;
+		  velInitialPlanetX = 0;
+		  velInitialPlanetY =velocityJupiter;
+
+	}
+
+
+	public void Algorithm()
+	{
+		  //Earth
+		  object[0][0][0] = planetX;
+		  object[0][0][1] = planetY;
+
+		  object[0][1][0] = velInitialPlanetX;
+		  object[0][1][1] = velInitialPlanetY;
+
+		  object[0][2][0] = 0;
+		  object[0][2][1] = 0;
+
+		  //Sun
+		  object[1][0][0] = 0;
+		  object[1][0][1] = 0;
+
+		  object[1][1][0] = 0;
+		  object[1][1][1] = 0;
+
+		  object[1][2][0] = 0;
+		  object[1][2][1] = 0;
+
+		  //Sat
+		  object[2][0][0] = satX;
+		  object[2][0][1] = satY;
+
+		  object[2][1][0] = velInitialX;
+		  object[2][1][1] = velInitialY;
+
+		  object[2][2][0] = 0;
+		  object[2][2][1] = 0;
+
+
+	}
+
+	public MainPanel()
+	{
+
+
+		this.setSize(Main.dim2);
+		int sim;
+		System.out.println("Please enter the simulation number: ");
+		sim = kb.nextInt();
+
+		if(sim == 1) initSunEarthLuna();
+
+		if (sim == 2) initSunEarthL5();
+
+		if (sim == 3) initSunJupiterProbe();
+
+		if (sim == 4) initSunJupiterCallisto();
+
+		if (sim == 5) initHorseshoe();
+
+		Algorithm();
+
+
+
+		sunColor = new Color(255, 172, 0);
+		sun = new Object(object[1][0][0] + x0, object[1][0][1] +  y0, sunR);
+
+		satColor = new Color(211,211,211);
+		sat = new Object((scaling*object[2][0][0]/au) + x0, (275*object[2][0][1]/au) +  y0, satR);
+
+		earthColor = new Color(47,94,79);
+		earth = new Object((scaling*object[0][0][0]/au) + x0, (275*object[0][0][1]/au) +  y0, earthR);
+
+
+
+		  maxAccel = object[2][2];
+
+		  minPosSun = differencePos(object[2][0],object[1][0]);
+		  minPosEarth = differencePos(object[2][0],object[0][0]);
+
+	}
+
+
+	public double[] ellipticalOrbit(double[] initPos,double t,double radius, double speed, double kx, double ky)	{
+
+
+		double[] posVec = new double[2];
+
+
+
+		posVec[0] = kx*radius*Math.sin((speed*t)/70) + initPos[0];
+		posVec[1] = ky*radius*Math.cos((speed*t)/70) + initPos[1];
+
+
+		return posVec;
+
+	}
+
+	public void update()
+	{
+
+		  object[0][2] = accelSunAnyObj(massSun,object[0][0],object[1][0]);
+		  object[1][2] = accelSunAnyObj(massPlanet,object[1][0],object[0][0]);
+		  object[2][2] = accelSunAnyObj(massSun,object[2][0], object[1][0]);
+
+		  object[1][2] = add(object[1][2], accelSunAnyObj(massSat,object[1][0], object[2][0]));
+		  object[0][2] = add(object[0][2], accelSunAnyObj(massSat,object[0][0],object[2][0]));
+		  object[2][2] = add(object[2][2], accelSunAnyObj(massPlanet, object[2][0],object[0][0]));
+
+
+		  object[0][1] = add((mult(object[0][2])), object[0][1]);
+		  object[1][1] = add((mult(object[1][2])), object[1][1]);
+		  object[2][1] = add((mult(object[2][2])), object[2][1]);
+
+
+		  object[0][0] = add((mult(object[0][1])), object[0][0]);
+		  object[1][0] = add((mult(object[1][1])), object[1][0]);
+		  object[2][0] = add((mult(object[2][1])), object[2][0]);
+
+
+	}
+
+
+
+	public void paintChildren(Graphics g)
+	{
+
+		super.paintChildren(g);
+
+
+		  maxAccel = compareAccel(maxAccel,object[2][2]);
+		  // findMinDis(); //sun
+		minPosSun = comparePosition(minPosSun, differencePos(object[2][0],object[1][0]));
+
+		// findMinDis(); //earth
+		minPosEarth = comparePosition(minPosEarth, differencePos(object[2][0],object[0][0]));
+
+
+		Graphics2D g2 = (Graphics2D) g;
+
+		g2.setColor(Color.BLACK);
+		g2.fillRect(0, 0, MainPanelDim.width, MainPanelDim.height);
+
+
+
+
+		//Drawing Sun
+		sun.updateCelestialObj(object[1][0]);
+		sun.paintObj(g2, sunColor);
+
+
+		//Drawing Planet
+		earth.updateCelestialObj(object[0][0]);
+		earth.paintObj(g2, earthColor);
+
+
+
+
+		//Drawing Sat
+		sat.updateCelestialObj(object[2][0]);
+		sat.paintObj(g2, satColor);
+
+		update();
+
+		//adjust for DELAY
+
+
+		//Display Time
+
+		g2.setColor(Color.RED);
+		time += dt;
+
+		g2.setStroke(new BasicStroke(3));
+		g2.drawString("Number of hours : " + Double.toString(time), 10, 12);
+		g2.drawString("Number of years : " + Double.toString(time/8760), 10, 29);
+
+		//Acceleration Vectors
+
+		g2.drawLine((int) ((scaling*object[1][0][0]/au) + x0),(int) ((scaling*object[1][0][1]/au) + y0),  (int)(((scaling*object[1][0][0]/au) + x0 ) + (0.7*sunR)*getUnit(object[1][2], getMag(object[1][2]))[0]), (int)(((scaling*object[1][0][1]/au) + y0 ) + (0.7*sunR)*getUnit(object[1][2], getMag(object[1][2]))[1]));
+
+		g2.drawLine((int) ((scaling*object[0][0][0]/au) + x0),(int) ((scaling*object[0][0][1]/au) + y0 ),  (int)(((scaling*object[0][0][0]/au) + x0 ) + (0.7*earthR)*getUnit(object[0][2], getMag(object[0][2]))[0]), (int)(((scaling*object[0][0][1]/au) + y0 ) + (0.7*earthR)*getUnit(object[0][2], getMag(object[0][2]))[1]));
+
+		g2.drawLine((int) ((scaling*object[2][0][0]/au) + x0),(int) ((scaling*object[2][0][1]/au) + y0 ),  (int)(((scaling*object[2][0][0]/au) + x0 ) + (0.7*satR)*getUnit(object[2][2], getMag(object[2][2]))[0]), (int)(((scaling*object[2][0][1]/au) + y0 ) + (0.7*satR)*getUnit(object[2][2], getMag(object[2][2]))[1]));
+
+
+		repaint();
+
+
+		if(time==tmax) {
+			System.out.println("The maximim acceleration is: " +getMag(maxAccel));
+			System.out.println("The minimum position of the satellite to the planet is: "+getMag(minPosEarth));
+			System.out.println("The minimum position of the satellite to the Sun is: "+getMag(minPosSun));
+			System.exit(0);
+
+		}
+
+
+	}
+
+
+	//YuliaMethods
+
+public static double [] mult(double [] array) {
+
+	for(int i =0; i<array.length;i++) {
+
+		array[i] = array[i]*dt;
+	}
+
+
+	return array;
+
+
+}public static double [] add(double [] array1, double [] array2) {
+
+
+	double [] add = new double [array1.length];
+
+	for(int i = 0; i < array1.length; i++)
+	{
+		add[i] = array1[i] + array2[i];
+
+
+	}
+
+	return add;
+
+}
+public static double [] differencePos(double[] pos1, double [] pos2){
+
+			double [] result = new double[2];
+			for(int i =0; i<pos1.length;i++) {
+
+				result[i] = pos1[i]-pos2[i];
+
+
+			}
+			return result;
+
+		}
+public static double [] getR(double [] objPos1, double [] objPos2) {
+
+	double [] rVector = new double [2];
+
+	rVector[0]= objPos2[0] - objPos1[0];
+	rVector[1]= objPos2[1] - objPos1[1];
+
+	return rVector;
+	}
+public static double getMag(double [] rVector) {
+
+	double rMagnitude;
+	rMagnitude = Math.sqrt(Math.pow(rVector[0],2) + Math.pow(rVector[1], 2));
+	return rMagnitude;
+}
+public static double [] getUnit(double [] rVector, double rMagnitude ) {
+
+	double [] unit = new double[2];
+
+	unit[0] = rVector[0]/rMagnitude;
+	unit[1] = rVector[1]/rMagnitude;
+
+return unit;
+}
+public static double [] accelSunAnyObj( double mPullObj,double [] objPos1, double [] objPos2) {
+
+double rMagnitude;
+double [] rVector = new double [2];
+double [] unit = new double [2];
+double [] accelVector = new double [2];
+double accelMagnitude;
+
+rVector = getR(objPos1,objPos2);
+rMagnitude = getMag(rVector);
+unit = getUnit(rVector,rMagnitude);
+
+accelMagnitude= (G*mPullObj)/ Math.pow(rMagnitude, 2);
+accelVector[0] = accelMagnitude * unit[0];
+accelVector[1] = accelMagnitude * unit[1];
+
+  return accelVector;
+}
+public static double [] compareAccel(double [] accelInitial, double [] accelFinal) {
+
+	double accelMagIn = getMag(accelInitial);
+	double accelMagFin = getMag(accelFinal);
+
+
+
+	if (accelMagIn < accelMagFin) {
+
+		return accelFinal;
+
+	}else {
+
+		return accelInitial;
+	}
+
+
+}
+public static double [] updateVel(double [] velInitial, double [] accel) {
+
+
+	velInitial[0] = accel[0] *dt + velInitial[0];
+	velInitial[1] = accel[1] *dt + velInitial[1];
+
+
+	return velInitial;
+}
+public static double [] updatePos(double [] posInitial, double [] vel) {
+
+
+	posInitial[0] = vel[0] * dt + posInitial[0];
+	posInitial[1] = vel[1] * dt + posInitial[1];
+
+	return posInitial;
+
+}
+public static double[] comparePosition(double[] posInitial, double[] posFinal) {
+
+	double magPosIn = getMag(posInitial);
+	double magPosFin = getMag(posFinal);
+
+
+	if (magPosIn > magPosFin ) {
+
+		return posFinal;
+
+	}else {
+
+		return posInitial;
+	}
+
+}
+public static double compareVelocity(double[] velInitial, double[] velFinal) {
+
+	double magVelIn = getMag(velInitial);
+	double magVelFin = getMag(velFinal);
+
+
+	if (magVelIn < magVelFin ) {
+
+		return magVelFin;
+
+	}else {
+
+		return magVelIn;
+	}
+
+}
+
+}
diff --git a/NBody.java b/NBody.java
new file mode 100644
index 0000000..fdd22ce
--- /dev/null
+++ b/NBody.java
@@ -0,0 +1,324 @@
+import java.io.*;
+import java.awt.*;
+import javax.swing.*;
+import java.util.Scanner;
+
+/**
+* This is the driving class for the N body solution for the problem using the Euler computational analysis method.
+* not to be confused with the Euler general solution for 3 body problems involving two fixed bodies.
+* @author Matthew Williams, Yulia Kosharych
+* @version 2018-05-16
+**/
+public class NBody{
+  //presets
+  public static SolarBody body0 = SolarBody.Sol;
+  public static SolarBody body1 = SolarBody.Earth;
+  // public static SolarBody body1 = SolarBody.Jupiter;
+  // public static SolarBody body2 = new SolarBody("satellite", 100, SolarBody.au/7, SolarBody.vJupiter, 0.001, 3*Math.PI/2);
+  public static SolarBody body2 = SolarBody.PlanetX;
+  // public static SolarBody body2 = SolarBody.Horseshoe;
+  // public static SolarBody body2 = SolarBody.Luna;
+
+  // public static double dis = SolarBody.solDisJupiter+Math.pow(10, 5);
+  // public static SolarBody body2 = new SolarBody("Tadpole orbit", 10, dis, BodyMaths.circleVelocityG(body0.mass, dis), 0, -Math.PI/6);
+  // public static SolarBody body2 = SolarBody.IrregularTadpole;
+
+  // public static SolarBody body3 = new SolarBody("probe", -1, -1, SolarBody.vEarth, 0, 0);
+  public static SolarBody body3 = SolarBody.Jupiter;
+
+
+  // if set to true, it shows the path the body without exerting any gravity on other bodies
+  public static boolean setPath0 = false;
+  public static boolean setPath1 = false;
+  public static boolean setPath2 = false;
+  public static boolean setPath3 = false;
+  // useful to compare the affects of gravity on another object
+
+
+  public static final double dt = 1.;                            //delta t in hours
+  // public static final double tmax = 8765.82*5*3.54;                  //number of hours to run
+  public static final double tmax =0.1*BodyMaths.orbitalPeriod(body0.mass, body1.solDis); //number of "years" to run (in hours)
+  public static final int imax =(int) (tmax/dt);                   //number of time steps
+  // number of bodies to use
+  public static final int bodies = 3;
+
+  public static final double G = SolarBody.G;
+
+
+  // toggle outputs
+
+  public static final double timeStart = 6*BodyMaths.orbitalPeriod(body0.mass, body1.solDis);
+  public static final double timeEnd = 7*BodyMaths.orbitalPeriod(body0.mass, body1.solDis);;;
+  public static final boolean partial = false;
+
+
+  public static final boolean graphing = false;  //plots locations
+  public static final boolean print = false;    //prints all steps in calculations. not recommended.
+  public static final boolean verbose = true;   //provides details as to what the program is doing
+
+  public static final boolean inertialPlot = true;
+  public static final int inertiaNum = 1;          //which body the inertial frame is in reference to
+
+
+
+
+  public static void main(String[] args) {
+    final int maxJavaHeap = 55855815; //max number of points that java can handle
+    int nPoints=bodies*3*2*imax+bodies*5;
+    // System.out.println(nPoints);
+    if (nPoints>maxJavaHeap) {
+      System.out.println("WARNING. Datapoints exceed maximum acceptable number of points within java (trying to use "+nPoints+" with a maximum of "+maxJavaHeap+" points)\nConsider either lowering accuracy or lowering the max time of simulation");
+      // System.exit(0);
+    }
+    // body2.setName("Tadpole");
+    // body2.setDisAU();
+    // body2.addDis();
+    // body2.addVel();
+
+
+
+
+
+    if (setPath0) {
+      body0.setPath();
+    }
+    if (setPath1) {
+      body1.setPath();
+    }
+    if (setPath2) {
+      body2.setPath();
+    }
+    if (setPath3) {
+      body3.setPath();
+    }
+
+    Scanner kb = new Scanner(System.in);
+    double[] mass = new double[bodies];
+    double[][][][] body= new double[bodies][3][2][imax];//[body][pos][x/y][timestep]
+    String bodyName[] = new String[bodies];
+    double vInit[] = new double[bodies];
+    double radius[] = new double[bodies];
+    double theta[] = new double[bodies];
+    double distance;
+
+
+    for (int i =0;i<body.length;i++) {
+      body[i][1]=new double[2][1];
+    }
+    // System.out.println("multiple of vEarth");
+    // double n = kb.nextDouble();
+    // double l = 1;
+    // kb.nextDouble();
+    // for (;l<10;l+=0.1) {//long for(;;) loop
+    // SolarBody body2 = SolarBody.other("satellite", 100, SolarBody.au/7, SolarBody.vEarth*3.694, 0.001, (5+l/10)*Math.PI/4);
+
+    if (verbose) {
+    System.out.println("\nstarting input phase");
+    System.out.print("inputting names...");
+    }
+    // names
+    bodyName[0]=body0.name;
+    bodyName[1]=body1.name;
+    if (bodyName.length>2) {
+      bodyName[2]=body2.name;
+    }
+    if (bodyName.length>3) {
+      bodyName[3]=body3.name;
+    }
+    for (int i = 4;i<bodyName.length;i++) {
+      bodyName[i]="body "+(i+1);
+    }
+    if (verbose) {
+      System.out.print("done\ninputting mass...");
+    }
+    // masses
+    mass[0]=body0.mass;
+    mass[1]=body1.mass;
+    if (mass.length>2) {
+      mass[2]=body2.mass;
+    }
+    if (mass.length>3) {
+      mass[3]=body3.mass;
+    }
+    for (int i=4;i<mass.length;i++) {
+      mass[i] = -1;
+    }
+    for (int i=0;i<mass.length;i++) {
+      if (mass[i]<0) {
+        System.out.print("\nMass #"+i+":");
+        mass[i] = kb.nextDouble();
+      }
+    }
+    if (verbose) {
+      System.out.print("done\ninputting angles...");
+    }
+    // thetas
+    theta[0]=body0.theta;
+    theta[1]=body1.theta;
+    if (theta.length>2) {
+      theta[2]=body2.theta;
+    }
+    if (theta.length>3) {
+      theta[3]=body3.theta;
+    }
+    for (int i=4;i<theta.length;i++) {
+      System.out.print("\nTheta #"+i+":");
+      theta[i] = kb.nextDouble();
+    }
+    while (body0.solDis<0){
+      System.out.println("distance from centre for "+body0.name);
+      body0.solDis = kb.nextDouble();
+    }
+    while (body1.solDis<0) {
+      System.out.println("distance from centre for "+body1.name);
+      body1.solDis = kb.nextDouble();
+    }
+    if (verbose) {
+      System.out.print("done\ninputting initial positions...");
+    }
+    // initial position
+    body[0][0][0][0]=body0.solDis*Math.cos(theta[0]); //body 1 x
+    body[0][0][1][0]=body0.solDis*Math.sin(theta[0]); //body 1 y
+    body[1][0][0][0]=body1.solDis*Math.cos(theta[1]); //body 2 x
+    body[1][0][1][0]=body1.solDis*Math.sin(theta[1]); //body 2 y
+    if (body.length>2){
+      while (body2.solDis<0) {
+        System.out.println("distance from centre for "+body2.name);
+        body2.solDis = kb.nextDouble();
+      }
+      body[2][0][0][0]=body2.solDis*Math.cos(theta[2]);
+      body[2][0][1][0]=body2.solDis*Math.sin(theta[2]);
+    }
+    if (body.length>3){
+      while (body3.solDis<0) {
+        System.out.println("distance from centre for "+body3.name);
+        body3.solDis = kb.nextDouble();
+      }
+      body[3][0][0][0]=body3.solDis*Math.cos(theta[3]);
+      body[3][0][1][0]=body3.solDis*Math.sin(theta[3]);
+    }
+    for (int i = 4;i<body.length;i++) {
+      System.out.println("distance from centre");
+      distance = kb.nextDouble();
+      body[i][0][0][0]=distance*Math.cos(theta[i]);
+      body[i][0][1][0]=distance*Math.sin(theta[i]);
+    }
+    if (verbose) {
+      System.out.print("done\ninputting initial velocities...");
+    }
+    // while (body0.vInitial<0) {
+    //   System.out.println("initial velocity for "+body0.name);
+      // body0.vInitial = kb.nextDouble();
+    // }
+    body[0][1][0][0]=-body0.vInitial*Math.sin(theta[0]);
+    body[0][1][1][0]=body0.vInitial*Math.cos(theta[0]);
+
+    // while (body1.vInitial<0) {
+    //   System.out.println("initial velocity for "+body1.name);
+    //   body1.vInitial = kb.nextDouble();
+    // }
+    body[1][1][0][0]=-body1.vInitial*Math.sin(theta[1]);
+    body[1][1][1][0]=body1.vInitial*Math.cos(theta[1]);
+    if (body.length>2){
+      // while (body2.vInitial<0) {
+      //   System.out.println("initial velocity for "+body2.name);
+      //   body2.vInitial = kb.nextDouble();
+      // }
+      body[2][1][0][0]=-body2.vInitial*Math.sin(theta[2]);
+      body[2][1][1][0]=body2.vInitial*Math.cos(theta[2]);
+    }
+    if (body.length>3){
+      // while (body3.vInitial<0) {
+      //   System.out.println("initial velocity for "+body3.name);
+      //   body3.vInitial = kb.nextDouble();
+      // }
+      body[3][1][0][0]=-body3.vInitial*Math.sin(theta[3]);
+      body[3][1][1][0]=body3.vInitial*Math.cos(theta[3]);
+    }
+    for (int i = 4;i<body.length;i++) {
+      System.out.println("initial velocity");
+      distance = kb.nextDouble();
+      body[i][1][0][0]=-distance*Math.sin(theta[i]);
+      body[i][1][1][0]=distance*Math.cos(theta[i]);
+    }
+
+    vInit = null;
+    theta = null;
+    if (verbose) {
+      System.out.print("done\nFinished input\n");
+    }
+
+
+
+
+    if (verbose) {
+      System.out.println("\nStarting calculation...");
+    }
+    for (int t=1;t<imax;t++) {
+      for (int num=0;num<bodies;num++) {
+        for (int j=0;j<bodies;j++) {
+          // System.out.println("J:"+j+" num:"+num);
+          if (j!=num) {
+            // System.out.println("update accel x");
+            body[num][2][0][t]+=BodyMaths.gravityAccel(body[num][0], body[j][0], mass[j], t-1, 0);
+            // System.out.println("update accel y");
+            body[num][2][1][t]+=BodyMaths.gravityAccel(body[num][0], body[j][0], mass[j], t-1, 1);
+          }
+          else if (print) {
+           System.out.println("j=num");
+          }
+        }
+        BodyMaths.updateBody(body[num], dt, t);
+        if (print) {
+          System.out.println("body"+ (num+1) +" x,y");
+          System.out.println(body[num][0][0][t]+","+body[num][0][1][t]);
+        }
+      }
+    }
+    if (verbose) {
+      System.out.println("calculation complete");
+    }
+
+    if (partial) {
+      int partialLength = (int)((timeEnd-timeStart)/dt);
+      double partialBody[] = new double[partialLength];
+      for (int bodynum=0;bodynum<body.length;bodynum++) {
+        for (int axis=0;axis<2;axis++) {
+          for (int i=0,j=(int)(timeStart/dt);i<partialBody.length&&j<body[bodynum][0][1].length;i++,j++) {
+            partialBody[i]=body[bodynum][0][axis][j];
+          }
+          body[bodynum][0][axis]=partialBody;
+        }
+      }
+      partialBody = null;
+    }//partialLength
+
+    if (graphing) {
+      if (verbose) {
+        System.out.println("starting graph");
+      }
+      NBodyGraph.graphNBody(bodyName, body, "cartesian plot");
+      if (verbose) {
+        System.out.println("graph input complete");
+      }
+    }
+
+    else if (inertialPlot) {
+      if (verbose) {
+        System.out.println("calculating with respect to an inertial frame of reference");
+      }
+
+      BodyMaths.inertialReference(body, inertiaNum);
+
+      if (verbose) {
+        System.out.println("inertial calculations complete\nstarting inertial graph");
+      }
+      NBodyGraph.graphNBody(bodyName, body, "inertial Reference plot");
+      if (verbose) {
+        System.out.println("inertial graph input complete");
+      }
+    }
+
+// }//long for(;;) loop
+  }//main()
+}//class
diff --git a/NBodyGraph.java b/NBodyGraph.java
new file mode 100644
index 0000000..cf4b3af
--- /dev/null
+++ b/NBodyGraph.java
@@ -0,0 +1,45 @@
+import java.io.*;
+import java.awt.*;
+import javax.swing.*;
+import java.util.Scanner;
+import org.math.plot.*;
+import org.math.plot.plotObjects.*;
+import java.util.Arrays;
+
+/**
+* This class is used for the plotting tools
+* @author Matthew Williams, Yulia Kosharych, J. Summer, J.F. Briere
+* @version 2018-05-16
+**/
+
+public class NBodyGraph{
+
+  /**
+  * This method plots the positions of the bodies
+  * @param bodyName[] String        these are the names of the bodies
+  * @param body[][][][] double      these are the bodies that will be plotted
+  * @param graphtype String         this is the type of plot that is printed
+  **/
+  public static void graphNBody(String bodyName[], double body[][][][], String graphtype){
+    Plot2DPanel plot = new Plot2DPanel();
+
+    // Define the legend position
+    plot.addLegend("SOUTH");
+
+    // Add a line plot to the PlotPanel
+    for (int i=0;i<body.length;i++) {
+      plot.addLinePlot(bodyName[i], body[i][0][0], body[i][0][1]);
+    }
+    plot.setAxisLabel(0,"x position");
+    plot.getAxis(0).setLabelPosition(0.5,-0.1);
+    plot.setAxisLabel(1,"y postion");
+    BaseLabel title = new BaseLabel("N("+body.length+") body problem: "+graphtype, Color.BLACK, 0.5, 1.1);
+    title.setFont(new Font("Courier", Font.BOLD, 14));
+    plot.addPlotable(title);
+
+    JFrame frame = new JFrame("Output of NBody.java");
+    frame.setSize(525, 525);
+    frame.setContentPane(plot);
+    frame.setVisible(true);
+  }//graphNBody()
+}//class
diff --git a/Object.java b/Object.java
new file mode 100644
index 0000000..3056fc8
--- /dev/null
+++ b/Object.java
@@ -0,0 +1,75 @@
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.geom.Ellipse2D;
+
+public class Object {
+
+	
+	double[] initPosVec = new double[2];
+	double[] PosVec = new double[2];
+	
+	double radius;
+	
+	Ellipse2D object;
+	
+	public Object(double _x0, double _y0, double _radius)
+	{
+		
+		
+		radius = _radius;
+
+		initPosVec[0] = _x0 - radius/2;
+		initPosVec[1] = _y0 - radius/2;
+		
+		PosVec[0] = _x0 - radius/2;
+		PosVec[1] = _y0 - radius/2;
+		
+		
+		
+		object = new Ellipse2D.Double(initPosVec[0], initPosVec[1], radius, radius); //sets centered object at x0, y0
+	
+		
+	}
+	
+	public double[] getInitPosVec()
+	{
+		return initPosVec;
+		
+	}
+	
+	public void updateObj(double[] posVec)
+	{
+		
+		PosVec[0] = posVec[0];
+		PosVec[1] = posVec[1];
+		
+		object.setFrame(PosVec[0], PosVec[1], radius, radius);
+	}
+	
+	public void updateCelestialObj(double[] posVec)
+	{
+		
+		PosVec[0] = (MainPanel.scaling*posVec[0])/MainPanel.au + MainPanel.x0 - radius/2;
+		PosVec[1] = (MainPanel.scaling*posVec[1])/MainPanel.au + MainPanel.y0 - radius/2;
+		
+		object.setFrame(PosVec[0], PosVec[1], radius, radius);
+	}
+	
+	public void readObj(double[][] posVec, int t)
+	{
+		
+		PosVec[0] = posVec[0][t];
+		PosVec[1] = posVec[1][t];
+		
+		object.setFrame(posVec[0][t], posVec[1][t], radius, radius);
+	}
+	
+	public void paintObj(Graphics2D g, Color color)
+	{
+	
+		g.setColor(color);
+		g.fill(object);
+		
+	}
+	
+}
diff --git a/SolarBody.java b/SolarBody.java
new file mode 100644
index 0000000..36f2f87
--- /dev/null
+++ b/SolarBody.java
@@ -0,0 +1,236 @@
+import java.util.Scanner;
+
+/**
+* This class contains premade values and situations for gravitational objects.
+* It already contains several important sol system values.
+* This class also allows for easy reference to starting positions.
+* @author Matthew Williams, Yulia Kosharych
+* @version 2018-05-16
+**/
+public class SolarBody{
+  // mass*     = mass of the body (kg)
+  // v*        = initial velocity of body (km/h)
+  // solDis*   = distance from Sol (km)
+  // rad*      = radius of body (km)
+
+  // universal constants
+  public static double G = 8.64960768*Math.pow(10, -13);
+  public static double au = 1.49597870700*Math.pow(10,8);
+
+
+  // values for common objects
+  public static String nameSol = "Sol";
+  public static double massSol = 1.989*Math.pow(10, 30);
+  public static double solDisSol = 0;
+  public static double vSol = 0;
+  public static double radSol = 695508;
+
+  public static String nameEarth = "Earth";
+  public static double massEarth = 5.972*Math.pow(10, 24);
+  public static double solDisEarth = au;
+  public static double vEarth = BodyMaths.circleVelocityG(massSol,solDisEarth);
+  public static double radEarth = 6371;
+
+  public static String nameLuna = "Luna";
+  public static double massLuna = 7.342*Math.pow(10, 22);
+  public static double earthDisLuna = 384402;
+  public static double solDisLuna = solDisEarth+earthDisLuna;
+  public static double vLuna = vEarth+BodyMaths.circleVelocityG(massEarth,earthDisLuna);
+  public static double radLuna = 1737;
+
+  public static String nameJupiter = "Jupiter";
+  public static double massJupiter = 1.898*Math.pow(10, 27);
+  public static double solDisJupiter = 5.2*au;
+  public static double vJupiter = BodyMaths.circleVelocityG(massSol,solDisJupiter);
+  public static double radJupiter = 69911;
+
+  public static String nameCallisto = "Callisto";
+  public static double massCallisto = 1.076*Math.pow(10, 23);
+  public static double jupDisCallisto = 1880000;
+  public static double solDisCallisto = solDisJupiter+jupDisCallisto;
+  public static double vCallisto = vJupiter+BodyMaths.circleVelocityG(massSol, solDisJupiter);
+  public static double radCallisto = 2410.3;
+
+
+  public String name;       // name of the body
+  public double mass;       // mass of the body (kg)            strictly positive
+  public double solDis;     // distance from Sol (km)           strictly positive
+  public double vInitial;   // initial velocity of body (km/h)  positive/negative
+  public double rad;        // radius of body (km)              strictly positive
+  public double theta;      // starting angle (rad)             positive/negative
+  //replace velocity location or theta location with string location in constructor be able to select one of them. keep at beginning if removing both
+  // all other variables allow for adaption when set to a negative value
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+  /**
+  * This method constructs a Solarbody object
+  * @param name String         name of the body
+  * @param mass double        mass of the body (kg)
+  * @param solDis double      distance from Sol (km)
+  * @param vInitial double    initial velocity of body (km/h)
+  * @param rad double         radius of body (km)
+  * @param theta double       starting angle (rad)
+  * @version 2018-05-16
+  **/
+  public SolarBody(String name, double mass, double solDis, double vInitial, double rad, double theta){
+    this.name=name;
+    this.mass=mass;
+    this.solDis=solDis;
+    this.vInitial=vInitial;
+    this.rad=rad;
+    this.theta=theta;
+  }//specific body constructor
+
+  /**
+  * This method constructs a Solarbody with only a name and input values on all other variables
+  * @param name String         name of the body
+  * @version 2018-05-16
+  **/
+  public SolarBody(String name){
+    this.name=name;
+    this.mass=-1;
+    this.solDis=-1;
+    setVelocity();
+    this.rad=-1;
+    setTheta();
+  }//input constructor
+  public SolarBody(double mass, double solDis, double vInitial, double rad, String name){
+    this.name=name;
+    this.mass=mass;
+    this.solDis=solDis;
+    this.vInitial=vInitial;
+    this.rad=rad;
+    setTheta();
+  }
+  public SolarBody(double mass, double solDis, String name, double rad, double theta){
+    this.name=name;
+    this.mass=mass;
+    this.solDis=solDis;
+    setVelocity();
+    this.rad=rad;
+    this.theta=theta;
+  }//select a velocity constructor
+  public SolarBody(String name, double mass, double solDis, double rad){
+    this.name=name;
+    this.mass=mass;
+    this.solDis=solDis;
+    setVelocity();
+    this.rad=rad;
+    setTheta();
+  }//select theta and velocity constructor
+
+
+
+// premade starting objects that can be chosen
+  public static SolarBody Sol = new SolarBody(nameSol, massSol, solDisSol, vSol, radSol, 0);
+  public static SolarBody Jupiter = new SolarBody(nameJupiter, massJupiter, solDisJupiter, vJupiter, radJupiter, 0);
+  public static SolarBody Callisto = new SolarBody(nameCallisto, massCallisto, solDisCallisto, vCallisto, radCallisto, 0);
+  public static SolarBody Earth = new SolarBody(nameEarth, massEarth, solDisEarth, vEarth, radEarth, 0);
+  public static SolarBody Luna = new SolarBody(nameLuna, massLuna, solDisLuna, vLuna, radLuna, 0);
+  public static SolarBody SE_L5 = new SolarBody("SE_L5", 100, solDisEarth, vEarth, 0, -Math.PI/3);
+  public static SolarBody PlanetX = new SolarBody("PlanetX", massEarth, solDisEarth, vEarth, radEarth, Math.PI);
+  public static SolarBody Greeks = new SolarBody("Greeks", -1, solDisJupiter, vJupiter, 0, Math.PI/3);
+  public static SolarBody Trojans = new SolarBody("Trojans", 1000, solDisJupiter, vJupiter, 0, -Math.PI/3);
+  public static SolarBody Horseshoe = new SolarBody("Horseshoe orbit", 10, SolarBody.solDisJupiter-BodyMaths.L1(SolarBody.solDisJupiter, SolarBody.massSol, SolarBody.massJupiter), BodyMaths.circleVelocityG(SolarBody.massSol,(SolarBody.solDisJupiter-BodyMaths.L1(SolarBody.solDisJupiter, SolarBody.massSol, SolarBody.massJupiter))), 0, -Math.PI/9);
+  public static SolarBody IrregularTadpole = new SolarBody("Irregular Tadpole", 100, solDisJupiter+Math.pow(10, 7), vJupiter, 0, -Math.PI/3);
+  public static SolarBody Tadpole = new SolarBody("Tadpole", 100, solDisJupiter+Math.pow(10, 7), vJupiter-600, 0, -Math.PI/3);
+
+
+  /**
+  * This method sets the mass to 0 to show the path the body would take without influencing any other bodies as well as changing the name to reflect the change
+  * @version 2018-05-18
+  **/
+  public void setPath(){
+    this.mass=0;
+    this.name=this.name+"'s path";
+  }//setPath()
+
+  /**
+  * This method sets the theta value for an object
+  * @version 2018-05-18
+  **/
+  public void setTheta(){
+    Scanner kb = new Scanner(System.in);
+    System.out.println("desired theta for "+this.name+" in pi radians");
+    this.theta=kb.nextDouble()*Math.PI;
+  }//setTheta()
+
+  /**
+  * This method sets the velocity to a desired power of 10 from user input
+  * @version 2018-05-18
+  **/
+  public void setVelocity(){
+    Scanner kb = new Scanner(System.in);
+    System.out.println("desired initial velocity for "+this.name+" in km/h");
+    double vInit = kb.nextDouble();
+    System.out.print("times 10^");
+    double power = Math.pow(10, kb.nextDouble());
+    this.vInitial=vInit*power;
+    System.out.println("initial velcity = "+this.vInitial);
+  }//setVelocity()
+
+  /**
+  * This method sets the starting distance to a desired power of 10 from user input
+  * @version 2018-05-18
+  **/
+  public void setDis(){
+    Scanner kb = new Scanner(System.in);
+    System.out.println("desired initial distance for "+this.name+" in km");
+    double dis = kb.nextDouble();
+    System.out.print("times 10^");
+    double power = Math.pow(10, kb.nextDouble());
+    this.solDis=dis*power;
+    System.out.println("initial distance = "+this.solDis);
+  }//setDis()
+  /**
+  * This method sets the starting number of AUs from user input
+  * @version 2018-05-18
+  **/
+  public void setDisAU(){
+    Scanner kb = new Scanner(System.in);
+    System.out.println("desired initial distance for "+this.name+" in AUs");
+    double dis = kb.nextDouble();
+    this.solDis=dis*au;
+    System.out.println("initial distance = "+this.solDis);
+  }//setDisAU()
+  /**
+  * This method sets the name from user input
+  * @version 2018-05-18
+  **/
+  public void setName(String name){
+    // Scanner kb = new Scanner(System.in);
+    // System.out.println("name for the body");
+    // String name = kb.nextString();
+    this.name=name;
+    System.out.println("new name:"+this.name);
+  }//setnane()
+
+  /**
+  * This method adds to the starting distance to a desired power of 10 from user input
+  * @version 2018-05-18
+  **/
+  public void addDis(){
+    Scanner kb = new Scanner(System.in);
+    System.out.println("desired additional distance for "+this.name+" in km");
+    double dis = kb.nextDouble();
+    System.out.print("times 10^");
+    double power = Math.pow(10, kb.nextDouble());
+    this.solDis+=dis*power;
+    System.out.println("initial distance = "+this.solDis);
+  }//setDis()
+
+  /**
+  * This method adds to the starting velocity to a desired power of 10 from user input
+  * @version 2018-05-18
+  **/
+  public void addVel(){
+    Scanner kb = new Scanner(System.in);
+    System.out.println("desired additional velcity for "+this.name+" in km/h");
+    double vel = kb.nextDouble();
+    System.out.print("times 10^");
+    double power = Math.pow(10, kb.nextDouble());
+    this.vInitial+=vel*power;
+    System.out.println("initial velocity = "+this.solDis);
+  }//setDis()
+
+}//class
diff --git a/ThreeBody.java b/ThreeBody.java
deleted file mode 100644
index 9d1a20f..0000000
--- a/ThreeBody.java
+++ /dev/null
@@ -1,297 +0,0 @@
-import java.io.*;
-import java.awt.*;
-import javax.swing.*;
-import java.util.Scanner;
-import org.math.plot.*;
-import org.math.plot.plotObjects.*;
-import java.util.Arrays;
-
-// TODO: javadocs
-
-public class ThreeBody {
-public static final double G = 8.64960768*Math.pow(10, -13);//gravitational constant (km^3/kg/h^2)
-public static final double dt = 0.1; //delta t in hours
-public static final double tmax = 2190; //number of hours to run
-public static double time = 0; //initial time
-// public static final double tmax; //number of hours to run {inputs}
-public static final int imax =(int) (tmax/dt); //number of time steps
-// public static final double imax; //number of time steps {inputs}
-public static final boolean graphing = true;
-public static final double au = 1.49597870700*Math.pow(10,8);//initial distance of earth from the sun in km
-// public static final double radEarth=; //km
-// public static final double radSun=; //km
-
-public static final double massEarth=5.972*Math.pow(10, 24); //kg
-public static final double massSun=1.989*Math.pow(10, 30);  //kg
-public static final double massSat=50*Math.pow(10, 50); //kg
-
-public static Scanner kb = new Scanner(System.in);
-
-
-
-public static void main(String[] args) {
-//TODO: variable declaration, arrays
-	
- System.out.print("Please enter the duration of the simulation: ");
-	  tmax = kb.nextDouble();
-	  
-System.out.print("Please enter the mass of the satellite: ");
-	  massSat = kb.nextDouble();
-	  
-double satX, satY, velInitialX, velInitialY;
-  // earthX[0][0]=1.495978*Math.pow(10,16);
-  // earthX[1][0]=0;
-  // earthY[1][0]=108000;
-  // earthY[0][0]=0;
-  // System.out.println("please enter the mass of the satellite: ");
-  // massSat = kb.nextDouble();
-	
-  System.out.print("Please enter the initial x position of the satellite: ");
-  satX = kb.nextDouble();
-  System.out.print("Please enter the initial y position of the satellite: ");
-  satY = kb.nextDouble();
-  System.out.print("Please enter the initial x velocity of the satellite: ");
-  velInitialX = kb.nextDouble();
-  System.out.print("Please enter the initial y velocity of the satellite: ");
-  velInitialY = kb.nextDouble();
-
-
-  // System.out.println("please enter the time of the simulation in hours "); //{inputs}
-  // tmax = kb.nextDouble(); //{inputs}
-  // imax = tmax/dt; //{inputs}
-	
-	 double [][][] object = new double [3][3][2];
-  
- // object[a] : a = 0(Earth), a=1(Sun), a=2(Sat)
-// object[][b] : b = 0(position), b=1(velocity), b=2(acceleration)
-//object[][][c] : c = 0(x position), c=1(y position)
-  
-  //Earth
-  object[0][0][0] = au; 
-  object[0][0][1] = 0; 
-  
-  object[0][1][0] = 0; 
-  object[0][1][1] = velocityEarth; 
-  
-  object[0][2][0] = 0; 
-  object[0][2][1] = 0; 
-  
-  //Sun 
-  object[1][0][0] = 0; 
-  object[1][0][1] = 0; 
-  
-  object[1][1][0] = 0; 
-  object[1][1][1] = 0; 
-  
-  object[1][2][0] = 0; 
-  object[1][2][1] = 0; 
-  
-  //Sat
-  object[2][0][0] = satX; 
-  object[2][0][1] = satY; 
-  
-  object[2][0][0] = velInitialX; 
-  object[2][0][1] = velInitialY; 
-  
-  object[2][2][0] = 0; 
-  object[2][2][1] = 0; 
-
-  
-
-
-  System.out.println(Arrays.toString(accelSunAnyObj(massSun,object[0][0],object[1][0])));
-  
-while (time<tmax) {
-  
-  time = time+dt;
-
-  object[0][2] = accelSunAnyObj(massSun,object[0][0],object[1][0]);
-  object[1][2] = accelSunAnyObj(massEarth,object[1][0],object[0][0]);
-  object[2][2] = accelSunAnyObj(massSun,object[2][0], object[1][0]);
-  object[1][2] = add(object[1][2], accelSunAnyObj(massSat,object[1][0], object[2][0]));
-}
-
-
-//   for (int i=1;i<satX[0].length;i++) {
-//     satX = euler(satX, earthX[0][i-1], sunX[0][i-1], massEarth, massSun, i);
-//     satY = euler(satY, earthY[0][i-1], sunY[0][i-1], massEarth, massSun, i);
-//     earthX = euler(earthX, satX[0][i-1], sunX[0][i-1], massSat, massSun, i);
-//     earthY = euler(earthY, satY[0][i-1], sunY[0][i-1], massSat, massSun, i);
-//     sunX = euler(sunX, satX[0][i-1], earthX[0][i-1], massSat, massEarth, i);
-//     sunY = euler(sunY, satY[0][i-1], earthY[0][i-1], massSat, massEarth, i);
-//     System.out.println("finished i = "+i);
-//   }//end loop
-  System.out.println("finished calculating...");
-  System.out.println("current position of earth: ("+earthX[0][imax-1]+","+earthY[0][imax-1]+")");
-  // findMaxAcc();
-  // findMinDis(); //earth
-  // findMinDis(); //sun
-  //
-  // if (graphing) {
-  //   graph();
-  // }
-}//main()
-
-public static double[][] euler(double obj[][], double p1, double p2, double m1, double m2, int i) {
-  obj[2][i] = accel(obj[0][i-1], p1, p2, m1, m2);
-  obj[1][i] = obj[2][i]*dt+obj[1][i-1];
-  obj[0][i] = obj[1][i]*dt+obj[0][i-1];
-  return obj;
-}
-
-	
-public static double [] add(double [] array1, double [] array2) {
-	
-	
-	double [] add = new double [array1.length];
-	
-	for(int i = 0; i < array1.length; i++)
-	{
-		add[i] = array1[i] + array2[i];
-		
-		
-	}
-	
-	return add;
-			
-}
-	
-// calculate accel();
-
-public static double [] getR(double [] objPos1, double [] objPos2) {
-	 
-	double [] rVector = new double [2];
-	
-	rVector[0]= objPos2[0] - objPos1[0];
-	rVector[1]= objPos2[1] - objPos1[1];
-	
-	return rVector;
-	}
-
-
-public static double getMag(double [] rVector) {
-	
-	double rMagnitude;
-	rMagnitude = Math.sqrt(Math.pow(rVector[0],2) + Math.pow(rVector[1], 2));
-	return rMagnitude;
-}
-
-
-public static double [] getUnit(double [] rVector, double rMagnitude ) {
-	
-	double [] unit = new double[2];
-	
-	unit[0] = rVector[0]/rMagnitude;
-	unit[1] = rVector[1]/rMagnitude;
-	
-return unit;
-}
-
-public static double [] accelSunAnyObj( double mPullObj,double [] objPos1, double [] objPos2) {
-
-double rMagnitude;	
-double [] rVector = new double [2];
-double [] unit = new double [2];
-double [] accelVector = new double [2];
-double accelMagnitude;
-
-rVector = getR(objPos1,objPos2);
-rMagnitude = getMag(rVector);
-unit = getUnit(rVector,rMagnitude);
-
-accelMagnitude= (G*mPullObj)/ Math.pow(rMagnitude, 2);
-accelVector[0] = accelMagnitude * unit[0];
-accelVector[1] = accelMagnitude * unit[1];
-  
-  return accelVector;
-}
-public static double [] compareAccel(double [] accelInitial, double [] accelFinal) {
-	
-	double accelMagIn = getMag(accelInitial);
-	double accelMagFin = getMag(accelFinal);
-	
-	
-	
-	if (accelMagIn < accelMagFin) {
-		
-		return accelFinal;
-		
-	}else {
-		
-		return accelInitial;
-	}
-	
-	
-}
-
-public static double [] updateVel(double [] velInitial, double [] accel) {
-	
-	
-	velInitial[0] = accel[0] *dt + velInitial[0];
-	velInitial[1] = accel[1] *dt + velInitial[1];
-	
-	
-	return velInitial;
-}
-
-
-
-public static double [] updatePos(double [] posInitial, double [] vel) {
-	
-	
-	posInitial[0] = vel[0] * dt + posInitial[0];
-	posInitial[1] = vel[1] * dt + posInitial[1];
-	
-	return posInitial;
-		
-}
-
-public static double comparePosition(double[] posInitial, double[] posFinal) {
-	
-	double magPosIn = getMag(posInitial);
-	double magPosFin = getMag(posFinal);
-	
-	
-	if (magPosIn < magPosFin ) {
-		
-		return magPosFin;
-		
-	}else {
-		
-		return magPosIn;
-	}
-	
-}
-
-
-
-public static double compareVelocity(double[] velInitial, double[] velFinal) {
-	
-	double magVelIn = getMag(velInitial);
-	double magVelFin = getMag(velFinal);
-	
-	
-	if (magVelIn < magVelFin ) {
-		
-		return magVelFin;
-		
-	}else {
-		
-		return magVelIn;
-	}
-	
-}
-
-
-
-
-
-//TODO: findMinDis method
-// public static
-// void 
-
-//TODO: graphing method()
-// public static void graph(double[][] satX,double[][] satY,double[][] sunX,double[][] sunY,double[][] earthX,double[][] earthY)
-
-
-}//end class ThreeBody
diff --git a/ThreeBodyInstantaneousSimulationVersion b/ThreeBodyInstantaneousSimulationVersion
deleted file mode 100644
index 22ac7a1..0000000
--- a/ThreeBodyInstantaneousSimulationVersion
+++ /dev/null
@@ -1,329 +0,0 @@
-  import java.util.Scanner;
-  import java.util.Arrays;
-
-// TODO: javadocs
-
-
-  public class ThreeBody {
-  
-  //Final variables declaration
-  
-  public static final double G = 8.64960768*Math.pow(10, -13);//gravitational constant (km^3/kg/h^2)
-  public static final double dt = 0.1; //delta t in hours
-  public static double tmax ; //number of hours to run
-  public static double time = 0; //initial time
-  // public static final double tmax; //number of hours to run {inputs}
-  public static final int imax =(int) (tmax/dt); //number of time steps
-  // public static final double imax; //number of time steps {inputs}
-  public static final boolean graphing = true;
-  public static final double au = 1.49597870700*Math.pow(10,8);//initial distance of earth from the sun in km
-  // public static final double radEarth=; //km
-  // public static final double radSun=; //km
-
-  public static final double massEarth=5.972*Math.pow(10, 24); //kg
-  public static final double massSun=1.989*Math.pow(10, 30);  //kg
-  public static double massSat; //kg
-  public static final double velocityEarth = 1.08*Math.pow(10, 5);// initial velocity of Earth
-  public static Scanner kb = new Scanner(System.in);
-
-
-
-  public static void main(String[] args) {
-
-	
-  System.out.print("Please enter the duration of the simulation: ");
-	  tmax = kb.nextDouble();
-	  
-  System.out.print("Please enter the mass of the satellite: ");
-	  massSat = kb.nextDouble();
-	  
-  double satX, satY, velInitialX, velInitialY;
-
-  // earthX[0][0]=1.495978*Math.pow(10,16);
-  // earthX[1][0]=0;
-  // earthY[1][0]=108000;
-  // earthY[0][0]=0;
-  // System.out.println("please enter the mass of the satellite: ");
-  // massSat = kb.nextDouble();
-  System.out.print("Please enter the initial x position of the satellite: ");
-  satX = kb.nextDouble();
-  System.out.print("Please enter the initial y position of the satellite: ");
-  satY = kb.nextDouble();
-  System.out.print("Please enter the initial x velocity of the satellite: ");
-  velInitialX = kb.nextDouble();
-  System.out.print("Please enter the initial y velocity of the satellite: ");
-  velInitialY = kb.nextDouble();
-
-  
-  
-
-	
-	
-  double [][][] object = new double [3][3][2];
-  
- // object[a] : a = 0(Earth), a=1(Sun), a=2(Sat)
-// object[][b] : b = 0(position), b=1(velocity), b=2(acceleration)
-//object[][][c] : c = 0(x position), c=1(y position)
-  
-  //Earth
-  object[0][0][0] = au; 
-  object[0][0][1] = 0; 
-  
-  object[0][1][0] = 0; 
-  object[0][1][1] = velocityEarth; 
-  
-  object[0][2][0] = 0; 
-  object[0][2][1] = 0; 
-  
-  //Sun 
-  object[1][0][0] = 0; 
-  object[1][0][1] = 0; 
-  
-  object[1][1][0] = 0; 
-  object[1][1][1] = 0; 
-  
-  object[1][2][0] = 0; 
-  object[1][2][1] = 0; 
-  
-  //Sat
-  object[2][0][0] = satX; 
-  object[2][0][1] = satY; 
-  
-  object[2][0][0] = velInitialX; 
-  object[2][0][1] = velInitialY; 
-  
-  object[2][2][0] = 0; 
-  object[2][2][1] = 0; 
-
-  
-
-
-  System.out.println(Arrays.toString(accelSunAnyObj(massSun,object[0][0],object[1][0])));
-  
-  double [] maxAccel, minPosSun, minPosEarth;
-  maxAccel = object[2][2];
-  
-  minPosSun = differencePos(object[2][0],object[1][0]);
-  minPosEarth = differencePos(object[2][0],object[0][0]);
-
-  while (time<tmax) {
-  
-  time = time+dt;
-//get the instantaneous acceleration of each object
-  object[0][2] = accelSunAnyObj(massSun,object[0][0],object[1][0]);
-  object[1][2] = accelSunAnyObj(massEarth,object[1][0],object[0][0]);
-  object[2][2] = accelSunAnyObj(massSun,object[2][0], object[1][0]);
-  object[1][2] = add(object[1][2], accelSunAnyObj(massSat,object[1][0], object[2][0]));
-  object[0][2] = add(object[0][2], accelSunAnyObj(massSat,object[0][0],object[2][0]));
-  object[2][2] = add(object[2][2], accelSunAnyObj(massEarth, object[2][0],object[0][0]));
-  
-  //get the instantaneous velocity of each object
-  object[0][1] = add((mult(object[0][2])), object[0][1]);
-  object[1][1] = add((mult(object[1][2])), object[1][1]);
-  object[2][1] = add((mult(object[2][2])), object[2][1]);
-  
-  //get the instantaneous position of each object
-  object[0][0] = add((mult(object[0][1])), object[0][0]);
-  object[1][0] = add((mult(object[1][1])), object[1][0]);
-  object[2][0] = add((mult(object[2][1])), object[2][0]);
-  
-  maxAccel = compareAccel(maxAccel,object[2][2]);
-  // findMinDis(); //sun
-  minPosSun = comparePosition(minPosSun, differencePos(object[2][0],object[1][0]));
-
-// findMinDis(); //earth
-  minPosEarth = comparePosition(minPosEarth, differencePos(object[2][0],object[0][0]));
-
-  }
-
-  System.out.println("The maximum acceleration is : " + getMag(maxAccel));
-  System.out.println("The minimum distance to Earth is : " + getMag(minPosEarth));
-  System.out.println("The minimum distance to Sun is : " + getMag(minPosSun)); 
-  
-
-  
-  // if (graphing) {
-  //   graph();
-  // }
-}//main()
-
-
-
-
-  public static double [] mult(double [] array) {
-	
-	for(int i =0; i<array.length;i++) {
-		
-	array[i] = array[i]*dt;	
-	}
-	
-	
-	return array;
-	
-	
-}
-
-
-  public static double [] add(double [] array1, double [] array2) {
-	
-	
-	double [] add = new double [array1.length];
-	
-	for(int i = 0; i < array1.length; i++)
-	{
-	add[i] = array1[i] + array2[i];
-		
-		
-	}
-	
-	return add;
-			
-}
-		
-		
-	public static double [] differencePos(double[] pos1, double [] pos2){
-			
-	double [] result = new double[2];
-	for(int i =0; i<pos1.length;i++) {
-				
-	result[i] = pos1[i]-pos2[i];
-				
-				
-			}
-	return result;
-			
-		}
-		
-  public static double [] getR(double [] objPos1, double [] objPos2) {
-	 
-	double [] rVector = new double [2];
-	
-	rVector[0]= objPos2[0] - objPos1[0];
-	rVector[1]= objPos2[1] - objPos1[1];
-	
-	return rVector;
-	}
-
-
-  public static double getMag(double [] rVector) {
-	
-	double rMagnitude;
-	rMagnitude = Math.sqrt(Math.pow(rVector[0],2) + Math.pow(rVector[1], 2));
-	return rMagnitude;
-}
-
-
-  public static double [] getUnit(double [] rVector, double rMagnitude ) {
-	
-  double [] unit = new double[2];
-
-  unit[0] = rVector[0]/rMagnitude;
-  unit[1] = rVector[1]/rMagnitude;
-
-  return unit;
-  }
-
-  public static double [] accelSunAnyObj( double mPullObj,double [] objPos1, double [] objPos2) {
-
-  double rMagnitude;	
-  double [] rVector = new double [2];
-  double [] unit = new double [2];
-  double [] accelVector = new double [2];
-  double accelMagnitude;
-
-  rVector = getR(objPos1,objPos2);
-  rMagnitude = getMag(rVector);
-  unit = getUnit(rVector,rMagnitude);
-
-  accelMagnitude= (G*mPullObj)/ Math.pow(rMagnitude, 2);
-  accelVector[0] = accelMagnitude * unit[0];
-  accelVector[1] = accelMagnitude * unit[1];
-  
-  return accelVector;
-}
-
-  public static double [] compareAccel(double [] accelInitial, double [] accelFinal) {
-	
-	double accelMagIn = getMag(accelInitial);
-	double accelMagFin = getMag(accelFinal);
-	
-	
-	
-	if (accelMagIn < accelMagFin) {
-		
-	return accelFinal;
-		
-	}else {
-		
-	return accelInitial;
-	}
-	
-	
-}
-
-  public static double [] updateVel(double [] velInitial, double [] accel) {
-	
-	
-	velInitial[0] = accel[0] *dt + velInitial[0];
-	velInitial[1] = accel[1] *dt + velInitial[1];
-	
-	
-	return velInitial;
-}
-
-
-
-  public static double [] updatePos(double [] posInitial, double [] vel) {
-	
-	
-	posInitial[0] = vel[0] * dt + posInitial[0];
-	posInitial[1] = vel[1] * dt + posInitial[1];
-	
-	return posInitial;
-		
-}
-
-  public static double[] comparePosition(double[] posInitial, double[] posFinal) {
-	
-	double magPosIn = getMag(posInitial);
-	double magPosFin = getMag(posFinal);
-	
-	
-	if (magPosIn > magPosFin ) {
-		
-	return posFinal;
-		
-	}else {
-		
-	return posInitial;
-	}
-	
-}
-
-
-
-  public static double compareVelocity(double[] velInitial, double[] velFinal) {
-	
-	double magVelIn = getMag(velInitial);
-	double magVelFin = getMag(velFinal);
-	
-	
-	if (magVelIn < magVelFin ) {
-		
-	return magVelFin;
-		
-	}else {
-		
-	return magVelIn;
-	}
-	
-}
-
-
-//TODO: graphing method()
-// public static void graph(double[][] satX,double[][] satY,double[][] sunX,double[][] sunY,double[][] earthX,double[][] earthY)
-
-
-
-
-}//end class ThreeBody