Updated code files 20 July 2018

Cartesian.cpp

@@ -92,6 +92,22 @@ Cartesian Cartesian::operator/(const Cartesian &carte1, const Cartesian &carte2)
 	concordanceDouble();
 	return *this; }
 
+bool Cartesian::operator==(const Cartesian &carteEqual1, const Cartesian &carteEqual2) {
+	bool equality = false;
+	if (carteEqual1.concordance())
+		if (carteEqual2.concordance())
+			if (carteEqual1.xx == carteEqual2.xx)
+				if (carteEqual1.yy == carteEqual2.yy) equality = true;
+	return equality; }
+
+bool Cartesian::operator!=(const Cartesian &carteUnequal1, const Cartesian &carteUnequal2) {
+	bool inequality = false;
+	if !(carteUnequal1.concordance()) inequality = true;
+	else if !(carteUnequal2.concordance()) inequality = true;
+	else if (carteUnequal1.xx != carteUnequal2.xx) inequality = true;
+	else if (carteUnequal1.yy != carteUnequal2.yy) inequality = true;
+	return inequality; }
+
 Cartesian::~Cartesian() { }
 
 int Cartesian::X(void) { return x; }
@@ -378,6 +394,18 @@ int Cartesian::quadrant(void) {
 	else if ((xx == 0.0) && (yy < 0.0)) q = -4;
 	return q; }
 
+int Cartesian::quadrant(int w, int z) {
+	int q = 0;
+	if ((w > 0) && (z > 0)) q = 1;
+	else if ((w < 0) && (z > 0)) q = 2;
+	else if ((w < 0) && (z < 0)) q = 3;
+	else if ((w > 0) && (z < 0)) q = 4;
+	else if ((w > 0) && (z == 0)) q = -1;
+	else if ((ww == 0) && (zz > 0)) q = -2;
+	else if ((ww < 0) && (zz == 0)) q = -3;
+	else if ((ww == 0) && (zz < 0)) q = -4;
+	return q; }
+
 int Cartesian::quadrant(double ww, double zz) {
 	int q = 0;
 	if ((ww > 0.0) && (zz > 0.0)) q = 1;
@@ -390,6 +418,72 @@ int Cartesian::quadrant(double ww, double zz) {
 	else if ((ww == 0.0) && (zz < 0.0)) q = -4;
 	return q; }
 
+int Cartesian::rectangularX(int r, int thetaDeg) {
+	int w = 0;
+	double ww = 0.0;
+	double rr = (double) r;
+	double theta = (((double) thetaDeg) / DEGPI) * PI;
+	w = rr * cos(theta);
+	w = (int) round(xx);
+	return w; }
+
+double Cartesian::rectagularXX(double rr, double thetaRad) {
+	double ww = rr * cos(thetaRad);
+	return ww; }
+
+int Cartesian::rectangularY(int r, int thetaDeg) {
+	int z = 0;
+	double zz = 0.0;
+	double rr = (double) r;
+	double theta = (((double) thetaDeg) / DEGPI) * PI;
+	zz = rr * sin(theta);
+	z = (int) round(zz);
+	return z; }
+
+double Cartesian::rectangularYY(double rr, double thetaRad) {
+	double zz = rr * sin(thetaRad);
+	return zz; }
+
+Cartesian Cartesian::rectangularC(int r, int thetaDeg) {
+	Cartesian point;
+	double ww = 0.0;
+	double zz = 0.0;
+	double rr = (double) r;
+	double theta = (((double) thetaDeg) / DEGPI) * PI;
+	ww = rr * cos(theta);
+	zz = rr * sin(theta);
+	point.xx = ww;
+	point.yy = zz;
+	point.concordanceDouble();
+	return point; }
+
+Cartesian Cartesian::rectangularC(double rr, double thetaRad) {
+	Cartesian point;
+	double ww = rr * cos(thetaRad);
+	double zz = rr * sin(thetaRad);
+	point.xx = ww;
+	point.yy = zz;
+	point.concordanceDouble();
+	return point; }
+
+void Cartesian::rectangular(int r, int thetaDeg) {
+	double ww = 0.0;
+	double zz = 0.0;
+	double rr = (double) r;
+	double theta = (((double) thetaDeg) / DEGPI) * PI;
+	ww = rr * cos(theta);
+	zz = rr * sin(theta);
+	xx = ww;  yy = zz;
+	concordanceDouble();
+	return; }
+
+void Cartesian::rectangular(double rr, double thetaRad) {
+	double ww = rr * cos(thetaRad);
+	double zz = rr * sin(thetaRad);
+	xx = ww;  yy = zz;
+	concordanceDouble();
+	return; }
+
 bool Cartesian::concordance(void) {
 	int a = (int) round(xx);
 	int b = (int) round(yy);

Cartesian.hpp

@@ -50,6 +50,8 @@ class Cartesian
 		operator-(const Cartesian &carte1, const Cartesian &carte2);
 		operator*(const Cartesian &carte1, const Cartesian &carte2); // complex product
 		operator/(const Cartesian &carte1, const Cartesian &carte2); // complex quotient
+		bool operator==(const Cartesian &carteEqual1, const Cartesian &carteEqual2);
+		bool operator!=(const Cartesian &carteUnequal1, const Cartesian &carteUnequal2);
 		~Cartesian();
 
 		// Read current position
@@ -104,8 +106,24 @@ class Cartesian
 		                               // -1 for positive x-axis	-2 for positive y-axis
 									   // -3 for negative x-axis	-4 for negative y-axis
 									   // 0 for origin
+		int quadrant(int w, int z);         // same as above but coordinates given by (w, z)
 		int quadrant(double ww, double zz); // same as above but coordinates given by (ww, zz)
 
+
+		// Convert polar coordinates to rectangular (Cartesian) coordinates
+		int rectangularX(int r, int thetaDeg);
+		double rectagularXX(double rr, double thetaRad);
+		int rectangularY(int r, int thetaDeg);
+		double rectangularYY(double rr, double thetaRad);
+
+		Cartesian rectangularC(int r, int thetaDeg);        // These functions return an
+		Cartesian rectangularC(double rr, double thetaRad); // external Cartesian object
+		                                                    // with (x, y) coordinates.
+		void rectangular(int r, int thetaDeg);       // These functions set the current
+		void rectangular(double rr, double ThetaRad) // Cartesian object to the (x, y)
+		                                             // coordinates.
+
+
 		// Check or force concordance between int coordinates and double coorindates
 		bool concordance(void); // Check concordance, return TRUE if concordant
 		void concordanceInt(void); // Force concordance, doubles must agree w/ ints

GravitationalBody.cpp

@@ -24,7 +24,7 @@
 #include "GravitationalBody.hpp"
 
 #define GSI 9.80665      // Standard gravity on Earth in SI units = 9.80665 m/sec/sec
-#define GCGS 980.665     // Standard gravity on Earth in CGS units = 980.665 cm/Sec/sec
+#define GCGS 980.665     // Standard gravity on Earth in CGS units = 980.665 cm/sec/sec
 #define GMS2 9 806 650   // Standard gravity on Earth in microns/sec/sec
 #define GUS 32.1740      // Standard gravity on Earth in US units = 32.1740 ft/sec/sec
 #define GIS2 386.088     // Standard gravity on Earth in inches/sec/sec = 386.088 in/s/s
@@ -37,7 +37,7 @@ GravitationalBody::GravitationalBody(void) {
 
 	velocity.x  = velocity.y  = 0;
 	velocity.xx = velocity.yy = 0.0;
-	_at_rest = TRUE;
+	_at_rest = true;
 
 	initialPosition.x  = initialPosition.y  = 0;
 	initialPosition.xx = initialPosition.yy = 0.0;
@@ -58,7 +58,7 @@ GravitationalBody::GravitationalBody(int a, int b) {
 
 	velocity.x  = velocity.y  = 0;
 	velocity.xx = velocity.yy = 0.0;
-	_at_rest = TRUE;
+	_at_rest = true;
 
 	initialPosition.x  = initialPosition.y  = 0;
 	initialPosition.xx = initialPosition.yy = 0.0;
@@ -79,7 +79,7 @@ GravitationalBody::GravitationalBody(double aa, double bb) {
 
 	velocity.x  = velocity.y  = 0;
 	velocity.xx = velocity.yy = 0.0;
-	_at_rest = TRUE;
+	_at_rest = true;
 
 	initialPosition.x  = initialPosition.y  = 0;
 	initialPosition.xx = initialPosition.yy = 0.0;
@@ -100,7 +100,7 @@ GravitationalBody::GravitationalBody(Cartesian pos) {
 
 	velocity.x  = velocity.y  = 0;
 	velocity.xx = velocity.yy = 0.0;
-	_at_rest = TRUE;
+	_at_rest = true;
 
 	initialPosition.x  = initialPosition.y  = 0;
 	initialPosition.xx = initialPosition.yy = 0.0;
@@ -623,7 +623,7 @@ GravitationalBody::GravitationalBody(const GravitationalBody &gravbodCopy) {
 	_groundOn = gravbodCopy._groundOn;
 	_gravOn = gravbodCopy._gravOn;  }
 
-GravitationalBody::operator=(const GravitationalBody &gravbodAssignment) {
+GravitationalBody GravitationalBody::operator=(const GravitationalBody &gravbodAssignment) {
 	if (this != &gravbodAssignment) {
 		position.xx = gravbodAssignment.position.xx;
 		position.yy = gravbodAssignment.position.yy;
@@ -653,6 +653,49 @@ GravitationalBody::operator=(const GravitationalBody &gravbodAssignment) {
 
 	return *this; }
 
+bool GravitationalBody::operator==(const GravitationalBody &gravbodEqual1,
+		const GravitationalBody &gravbodEqual2) {
+	bool concordcheck = false;
+	bool equality = false;
+	if (gravbodEqual1.position.concordance())
+		if (gravbodEqual2.position.concordance())
+			if (gravbodEqual1.velocity.concordance())
+				if (gravbodEqual2.velocity.concordance())
+					if (gravbodEqual1.initialPosition.concordance())
+						if (gravbodEqual2.initialPosition.concordance())
+							if (gravbodEqual1.initialVelocity.concordance())
+								if (gravbodEqual2.initialVelocity.concordance())
+									concordcheck = true;
+	if (concordcheck)
+		if (gravbodEqual1.position == gravbodEqual2.position)
+			if (gravbodEqual1.velocity == gravbodEqual2.velocity)
+				if (gravbodEqual1.initialPosition == gravbodEqual2.initialPosition)
+					if (gravbodEqual1.initialVelocity == gravbodEqual2.initialVelocity)
+						equality = true;
+	return equality; }
+
+bool GravitationalBody::operator!=(const GravitationalBody &gravbodUnequal1,
+		const GravitationalBody &gravbodUnequal2) {
+	bool concordcheck = true;
+	bool inequality = false;
+	if !(gravbodUnequal1.position.concordance()) concordcheck = false;
+	else if !(gravbodUnequal2.position.concordance()) concordcheck = false;
+	else if !(gravbodUnequal1.velocity.concordance()) concordcheck = false;
+	else if !(gravbodUnequal2.velocity.concordance()) concordcheck = false;
+	else if !(gravbodUnequal1.initialPosition.concordance()) concordcheck = false;
+	else if !(gravbodUnequal2.initialPosition.concordance()) concordcheck = false;
+	else if !(gravbodUnequal1.initialVelocity.concordance()) concordcheck = false;
+	else if !(gravbodUnequal2.initialVelocity.concordance()) concordcheck = false;
+	if (concordcheck) {
+		if (gravbodUnequal1.position != gravbodUnequal2.position) inequality = true;
+		else if (gravbodUnequal1.velocity != gravbodUnequal2.velocity) inequality = true;
+		else if (gravbodUnequal1.initialPosition != gravbodUnequal2.initialPosition)
+			inequality = true;
+		else if (gravbodUnequal1.initialVelocity != gravbodUnequal2.initialVelocity)
+			inequality = true; }
+	else inequality = true;
+	return inequality; }
+
 GravitationalBody::~GravitationalBody(void) {
 	delete position;
 	delete velocity;
@@ -791,7 +834,7 @@ void GravitationalBody::_G(long int ag) {
 	_concordanceInt();
 	return; }
 
-void GravitationalBody::_GG(double aag) {
+void GravitationalBody::_G(double aag) {
 	_aaccgrav = aag;
 	_concordanceDouble();
 	return; }
@@ -878,7 +921,7 @@ void GravitationalBody::_concordanceInt(void) {
 
 void GravitationalBody::_concordanceDouble(void) {
 	_ground = (int) round(_gground);
-	_accgrav = (int) round(_aacgrav);
+	_accgrav = (long int) round(_aacgrav);
 	_cor100 = (int) round(_ccor * 100.0);
 	return; }
 

GravitationalBody.hpp

@@ -77,7 +77,11 @@ class GravitationalBody : protected InertBody
 		GravitationalBody(Cartesian pos, Cartesian vel, Cartesian ipos, Cartesian ivel,
 		    double ggrnd, double aagv, double epsilon);
 		GravitationalBody(const GravitationBody &gravbodCopy);
-		operator=(const GravitationalBody &gravbodAssignment);
+		GravitationalBody operator=(const GravitationalBody &gravbodAssignment);
+		bool operator==(const GravitationalBody &gravbodEqual1,
+				const GravitationalBody &gravbodEqual2);
+		bool operator!=(const GravitationalBody &gravbodUnequal1,
+				const GravitationalBody &gravbodUnequal2);
 		~GravitationalBody(void);
 
 		// read current position and current velocity of object
@@ -138,13 +142,13 @@ class GravitationalBody : protected InertBody
 		int _cor100, double _ccor, bool _groundOn, bool _gravOn;    // variable members
 		// int _ground and double _gground are horizontal y/yy-level ground
 		// long int _accgrav and double _aacgrav are acceleration of gravity
-		// int _cor100 is percentage of coefficient of restitution (bouceback from ground)
+		// int _cor100 is percentage of coefficient of restitution (bounceback from ground)
 		// double _ccor is same expressed as pure decimal
 		// _groundOn switches the horizonal ground on (or off)
 		// _gravOn switches the gravity on (or off)
 
 		void _G(long int ag);      // assign acceleration of gravity in int
-		void _GG(double aag); // assign acceleration of gravity in double
+		void _G(double aag); // assign acceleration of gravity in double
 		void _GMS2(void);     // assign acceleration of gravity to micron/sec/sec
 		void _GGSI(void);     // assign acceleration of gravity to SI units
 		void _GGCGS(void);    // assign acceleration of gravity to CGS units

InertBody.cpp

@@ -35,7 +35,7 @@ InertBody::InertBody(void) {
 	position.atOrigin();
 	velocity.atOrigin();
 	initialPosition.atOrigin();
-	_at_rest = TRUE;
+	_at_rest = true;
 	_n = 0; _t = _DEFAULT_TIME; }
 
 InertBody::InertBody(int a, int b) {
@@ -45,7 +45,7 @@ InertBody::InertBody(int a, int b) {
 
 	velocity.atOrigin();
 	Position();
-	_at_rest = TRUE;
+	_at_rest = true;
 	_n = 0; _t = _DEFAULT_TIME; }
 
 InertBody::InertBody(double aa, double bb) {
@@ -55,7 +55,7 @@ InertBody::InertBody(double aa, double bb) {
 
 	velocity.atOrigin();
 	Position();
-	_at_rest = TRUE;
+	_at_rest = true;
 	_n = 0; _t = _DEFAULT_TIME; }
 
 InertBody::InertBody(Cartesian pos) {
@@ -65,7 +65,7 @@ InertBody::InertBody(Cartesian pos) {
 
 	velocity.atOrigin();
 	Position();
-	_at_rest = TRUE;
+	_at_rest = true;
 	_n = 0; _t = _DEFAULT_TIME; }
 
 InertBody::InertBody(int a, int b, int vx, int vy) {
@@ -293,6 +293,21 @@ InertBody::operator=(const InertBody &bodyAssignment) {
 		_t = bodyAssignment._t; }
 	return *this; }
 
+bool InertBody::operator==(const InertBody &bodyEqual1, const InertBody &bodyEqual2) {
+	bool equality = false;
+	if (bodyEqual1.position == bodyEqual2.position)
+		if (bodyEqual1.velocity == bodyEqual2.velocity)
+			if (bodyEqual1.initialPosition == bodyEqual2.initialPosition)
+				equality = true;
+	return equality; }
+
+bool InertBody::operator!=(const InertBody &bodyUnequal1, const InertBody &bodyUnequal2) {
+	bool inequality = false;
+	if (bodyUnequal1.position != bodyUnequal2.position) inequality = true;
+	else if (bodyUnequal1.velocity != bodyUnequal2.velocity) inequality = true;
+	else if (bodyUnequal1.initialPosition != bodyUnequal2.initialPosition) inequality = true;
+	return inequality; }
+
 InertBody::~InertBody(void) {
 	delete position;
 	delete velocity;
@@ -485,7 +500,7 @@ void InertBody::initPosition(Cartesian ipos) {
 	return; }
 
 
- // assigns current position to initial position
+ // assigns current position as initial position
 void InertBody::initPosition(void) {
 	position.xx = initialPosition.xx;
 	position.yy = initialPosition.yy;
@@ -596,14 +611,14 @@ Cartesian InertBody::prevPosition(void) {
 
 
 // Timeslice size and number of slices
+int InertBody::TimeSlice(void) { return _t; }
+
+int InertBody::NumberOfSlices(void) { return _n }
+
 void InertBody::TimeSlice(int time) {
 	_t = time;
 	return; }
 
 void InertBody::NumberOfSlices(int num) {
 	_n = num;
 	return; }
-
-int InertBody::TimeSlice(void) { return _t; }
-
-int InertBody::NumberOfSlices(void) { return _n }

InertBody.hpp

@@ -64,6 +64,8 @@ class InertBody
 		InertBody(Cartesian pos, Cartesian vel, Cartesian ipos, int time);
 		InertBody(const InertBody &bodyCopy);
 		operator=(const InertBody &bodyAssignment);
+		bool operator==(const InertBody &bodyEqual1, const InertBody &bodyEqual2);
+		bool operator!=(const InertBody &bodyUnequal1, const InertBody &bodyUnequal2);
 		~InertBody(void);
 
 		// Read current position