From 41bb12db8fe71f5fda3c18110f8d66b4d9b2fa17 Mon Sep 17 00:00:00 2001 From: Ray Arias Date: Wed, 2 May 2018 14:59:04 -0500 Subject: [PATCH] Uploaded C++ classes to implement TerrestrialGravitation --- Cartesian.cpp | 181 +++++++++++++++++ Cartesian.hpp | 65 ++++++ GravitationalBody.cpp | 55 +++++ GravitationalBody.hpp | 54 +++++ InertBody.cpp | 285 ++++++++++++++++++++++++++ InertBody.hpp | 70 +++++++ TerrestrialGravitation.cpp | 403 +++++++++++++++++++++++++++++++++++++ TerrestrialGravitation.dev | 132 ++++++++++++ TerrestrialGravitation.hpp | 94 +++++++++ 9 files changed, 1339 insertions(+) create mode 100644 Cartesian.cpp create mode 100644 Cartesian.hpp create mode 100644 GravitationalBody.cpp create mode 100644 GravitationalBody.hpp create mode 100644 InertBody.cpp create mode 100644 InertBody.hpp create mode 100644 TerrestrialGravitation.cpp create mode 100644 TerrestrialGravitation.dev create mode 100644 TerrestrialGravitation.hpp diff --git a/Cartesian.cpp b/Cartesian.cpp new file mode 100644 index 0000000..a909a4b --- /dev/null +++ b/Cartesian.cpp @@ -0,0 +1,181 @@ +#include "Cartesian.h" + +Cartesian::Cartesian() { + atOrigin(); } + +Cartesian::Cartesian(int a, int b) { + x = a; + y = b; + xx = (double) a; + yy = (double) b; } + +Cartesian::Cartesian(const Cartesian &cartecopy) { + xx = cartecopy.xx; + yy = cartecopy.yy; + x = (int) xx; + y = (int) yy; } + +Cartesian Cartesian::operator=(const Cartesian &carteassignment) { + if (cartesianassignment != this) { + xx = cartesianassignment.xx; + yy = cartesianassignment.yy; + x = (int) xx; + y = (int) yy; + } + return *this; } + +Cartesian Cartesian::operator+(const Cartesian &carte1, const Cartesian &carte2) { + xx = carte1.xx + carte2.xx; + yy = carte1.yy + carte2.yy; + concordanceDouble(); + return *this; } + +Cartesian Cartesian::operator-(const Cartesian &carte1, const Cartesian &carte2) { + xx = carte1.xx - carte2.xx; + yy = carte1.yy - carte2.yy; + concordanceDouble(); + return *this; } + +Cartesian::~Cartesian() { +} + +int Cartesian::X(void) { return x; } + +int Cartesian::Y(void) { return y; } + +Cartesian Cartesian::Position(void) { + if !(concordance(*this)) concordanceDouble(); + return *this; } + +void Cartesian::X(int a) { + x = a; + concordanceInt(); + return; } + +void Cartesian::Y(int b) { + y = b; + concordanceInt(); + return; } + +void Cartesian::XX(double aa) { + xx = aa; + concordanceDouble(); + return; } + +void Cartesian::YY(double bb) { + yy = bb; + concordanceDouble(); + return; } + +void Cartesian::Position(Cartesian pos) { + xx = pos.xx; + yy = pos.yy; + concordanceDouble(); + return; } + +double Cartesian::distanceDouble(void) { + double dd = sqrt((xx * xx) + (yy * yy)); + return dd; } + +int Cartesian::distanceInt(void) { + double dd = distanceDouble(); + int d = (int) dd; + return d; } + +double Cartesian::distance(void) { + double dd = distanceDouble(void); + return dd; } + +double Castesian::distance(double aa, double bb) { + double ee = aa - xx; + double ff = bb - yy; + double dd = sqrt((ee * ee) + (ff * ff)); + return dd; } + +int Cartesian::distance(int a, int b) { + double aa = (double) a; + double bb = (double) b; + double dd = distance(aa, bb); + int d = (int) dd; + return d; } + +double Cartesian::distanceDouble(Cartesian carte) { + double ee = catre.xx - xx; + double ff = carte.yy - yy; + double dd = sqrt((ee * ee) + (ff * ff)); + return dd; } + +int Cartesian::distanceInt(Cartesian carte) { + double dd = distanceDouble(carte); + int d = (int) d; + return d; } + +double Cartesian::distance(Catesian carte) { + double dd = distanceDouble(carte); + return dd; } + +double Cartesian::angleDouble(void) { + double aa = arctan(yy / xx)); + return aa; } + +int Cartesian::angleInt(void) { + double aa = angleDouble(); + int a = (int) aa; + return a; } + +double Cartesian::angle(void) { + double aa = angleDouble(void); + return aa; } + +double Castesian::angle(double ww, double zz) { + double ee = ww - xx; + double ff = zz - yy; + double aa = actan(ff / ee); + return aa; } + +int Cartesian::angle(int w, int z) { + double ww = (double) w; + double zz = (double) z; + double aa = angle(ww, zz); + int a = (int) aa; + return a; } + +double Cartesian::angleDouble(Cartesian carte) { + double ee = catre.xx - xx; + double ff = carte.yy - yy; + double aa = arctan(ff / ee); + return aa; } + +int Cartesian::angleInt(Cartesian carte) { + double aa = angleDouble(carte); + int a = (int) aa; + return a; } + +double Cartesian::angle(Catesian carte) { + double aa = angleDouble(carte); + return aa; } + +bool Cartesian::concordance(void) { + int a = (int) xx; + int b = (int) yy; + double aa = (double) x; + double bb = (double) y; + bool pass = ((a == x) && (b == y)); + if (pass) pass = ((aa == xx) && (bb == yy)); + return pass; } + +void Cartesian::concordanceDouble(void) { + x = (int) xx; + y = (int) yy; + return; } + +void Cartesian::concordanceInt(void) { + xx = (double) x; + yy = (double) y; + return; } + +Cartesian Cartesian::atOrigin(void) { + xx = yy = 0.0F; + x = y = 0; + return *this; } + diff --git a/Cartesian.hpp b/Cartesian.hpp new file mode 100644 index 0000000..af0faf8 --- /dev/null +++ b/Cartesian.hpp @@ -0,0 +1,65 @@ +#ifndef CARTESIAN_H +#define CARTESIAN_H + +#include + +class Cartesian +{ + public: + int x, y; + double xx, yy; + Cartesian(); + Cartesian(int a, b); + Cartesian(double aa, bb); + Cartesian(const Cartesian &cartecopy); + operator=(const Cartesian &carteassignment); + operator+(const Cartesian &carte1, const Cartesian &carte2); + operator-(const Cartesian &carte1, const Cartesian &carte2); + ~Cartesian(); + + // Read current position + int X(void); + int Y(void); + double XX(void); + double YY(void); + Cartesian Position(void); + + //Set current position + void X(int a); + void Y(int b); + void XY(int a, int b); + void XXYY(double aa, double bb); + void XX(double aa); + void YY(double bb); + void Position(Cartesian pos); + + // Calculate distance from current position to... + int distanceInt(void); // origin + double distanceDouble(void); + double distance (void); // same as distanceDouble(void) + int distance(int a, int b); // point given by (a, b) + double distance(double aa, double bb); + int distanceInt(Cartesian carte); // point given by carte + double distanceDouble(Cartesian carte); + double distance(Cartesian carte); + + // Calculate the degree angle from current position to... + int angleInt(void); // origin + double angleDouble(void); + double angle(void); // same as angleDouble(void) + int angle(int w, int z); // point given by (w, z) + double angle(double ww, double zz); + int angleInt(Cartesian carte); // point given by carte + double angleDouble(Cartesian carte); + double angle(Cartesian carte); + + // 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 + void concordanceDouble(void); // Force concordance, ints must agree w/ doubles + + Cartesian atOrigin(void); // Assign to be at origin (0, 0) and return +}; + + +#endif diff --git a/GravitationalBody.cpp b/GravitationalBody.cpp new file mode 100644 index 0000000..7f88e7d --- /dev/null +++ b/GravitationalBody.cpp @@ -0,0 +1,55 @@ +#include "GravitationalBody.h" + + + Cartesian initialPosition, Cartesian initialVelocity; + GravitationalBody(void); + GravitationalBody(int a, int b); + GravitationalBody(double aa, double bb); + GravitationalBody(Cartesian pos); + GravitationalBody(int a, int b, int vx, int vy); + GravitationalBody(double aa, double bb, double vxx, double vyy); + GravitationalBody(Cartesian pos, Cartesian vel); + GravitationalBody(int a, int b, int vx, int vy, int ix, int iy); + GravitationalBody(double aa, double bb, double vxx, double vyy, + double ixx, double iyy); + GravitationalBody(Cartesian pos, Cartesian vel, Cartesian ipos); + GravitationalBody(int a, int b, int vx, int vy, int ix, int iy, int ivx, int ivy); + GravitationalBody(double aa, double bb, double vxx, double vyy, + double ixx, double iyy, double ivxx, double ivyy); + GravitationalBody(Cartesian pos, Cartesian vel, Cartesian ipos, Cartesian ivel); + GravitationalBody(const &gravbodCopy); + operator=(const &gravbodAssignment); + ~GravitationalBody(void); + + Cartesian bodyPos(void); + Cartesian bodyVel(void); + + void placeBody(int a, int b); + void placeBody(double aa, double bb); + void placeBody(Cartesian pos); + + void giveVelocity(int vx, int vy); + void giveVelocity(double vxx, double vyy); + void giveVelocity(Cartesian vel); + + void initPosition(int ix, int iy); + void initPosition(double ixx, double iyy); + void initPosition(Cartesian ipos); + + void initVelocity(int ivx, int ivy); + void initVelocity(double ivxx, double ivyy); + void initVelocity(Cartesian ivel); + + void initPosition(void); // assign current position to initialPosition + void initVelocity(void); // assign current velocity to initialVelocity + void beginMotion(void); // same as initVelocity() + void haltMotion(void); // call veloity.atOrigin() and halt motion of body + + +GravitationalBody::GravitationalBody(Cartesian position, Cartesian velocity, bool at_rest) +{ +} + +GravitationalBody::~GravitationalBody() +{ +} diff --git a/GravitationalBody.hpp b/GravitationalBody.hpp new file mode 100644 index 0000000..99fc12e --- /dev/null +++ b/GravitationalBody.hpp @@ -0,0 +1,54 @@ +#ifndef GRAVITATIONALBODY_H +#define GRAVITATIONALBODY_H + +#include "InertBody.hpp" + +class GravitationalBody : public InertBody +{ + public: + Cartesian initialPosition, Cartesian initialVelocity; + GravitationalBody(void); + GravitationalBody(int a, int b); + GravitationalBody(double aa, double bb); + GravitationalBody(Cartesian pos); + GravitationalBody(int a, int b, int vx, int vy); + GravitationalBody(double aa, double bb, double vxx, double vyy); + GravitationalBody(Cartesian pos, Cartesian vel); + GravitationalBody(int a, int b, int vx, int vy, int ix, int iy); + GravitationalBody(double aa, double bb, double vxx, double vyy, + double ixx, double iyy); + GravitationalBody(Cartesian pos, Cartesian vel, Cartesian ipos); + GravitationalBody(int a, int b, int vx, int vy, int ix, int iy, int ivx, int ivy); + GravitationalBody(double aa, double bb, double vxx, double vyy, + double ixx, double iyy, double ivxx, double ivyy); + GravitationalBody(Cartesian pos, Cartesian vel, Cartesian ipos, Cartesian ivel); + GravitationalBody(const &gravbodCopy); + operator=(const &gravbodAssignment); + ~GravitationalBody(void); + + Cartesian bodyPos(void); + Cartesian bodyVel(void); + + void placeBody(int a, int b); + void placeBody(double aa, double bb); + void placeBody(Cartesian pos); + + void giveVelocity(int vx, int vy); + void giveVelocity(double vxx, double vyy); + void giveVelocity(Cartesian vel); + + void initPosition(int ix, int iy); + void initPosition(double ixx, double iyy); + void initPosition(Cartesian ipos); + + void initVelocity(int ivx, int ivy); + void initVelocity(double ivxx, double ivyy); + void initVelocity(Cartesian ivel); + + void initPosition(void); // assign current position to initialPosition + void initVelocity(void); // assign current velocity to initialVelocity + void beginMotion(void); // same as initVelocity() + void haltMotion(void); // call veloity.atOrigin() and halt motion of body +}; + +#endif diff --git a/InertBody.cpp b/InertBody.cpp new file mode 100644 index 0000000..65f0e24 --- /dev/null +++ b/InertBody.cpp @@ -0,0 +1,285 @@ +#include "InertBody.h" + + +InertBody::InertBody(void) { + position.atOrigin(); + velocity.atOrigin(); + _at_rest = TRUE; } + +InertBody::InertBody(int a, int b) { + position.x = a; + position.y = b; + position.concordanceInt(); + + velocity.atOrigin(); + _at_rest = TRUE; } + +InertBody::InertBody(double aa, double bb) { + position.xx = aa; + position.yy = bb; + position.concordanceDouble(); + + velocity.atOrigin(); + _at_rest = TRUE; } + +InertBody::InertBody(Cartesian pos) { + position.xx = pos.xx; + position.yy = pos.yy; + position.concordanceDouble(); + + velocity.atOrigin(); + _at_rest = TRUE; } + +InertBody::InertBody(int a, int b, int vx, int vy) { + position.x = a; + position.y = b; + position.concordanceInt(); + + velocity.x = vx; + velocity.y = vy; + velocity.concordanceInt(); + + Cartesian Zero; + Zero.atOrigin(); + _at_rest = (velocity == Zero); } + +InertBody::InertBody(double aa, double bb, double vxx, double vyy) { + position.xx = aa; + position.yy = bb; + position.concordanceDouble(); + + velocity.xx = vxx; + velocity.yy = vyy; + velocity.concordanceDouble(); + + Cartesian Zero; + Zero.atOrigin(); + _at_rest = (velocity == Zero); } + +InertBody::InertBody(Cartesian pos, Cartesian vel) { + position.xx = pos.xx; + position.yy = pos.yy; + position.concordanceDouble(); + + velocity.xx = vel.xx; + velocity.yy = vel.yy; + velocity.concordanceDouble(); + + Cartesian Zero; + Zero.atOrigin(); + _at_rest = (velocity == Zero); } + +InertBody::InertBody(const InertBody &bodyCopy) { + position.xx = bodyCopy.position.xx; + position.yy = bodyCopy.position.yy; + position.concordanceDouble(); + + velocity.xx = bodyCopy.velocity.xx; + velocity.yy = bodyCopy.velocity.yy; + velocity.concordanceDouble(); + + Catesian Zero; + Zero.atOrigin(); + _at_rest = (velocity == Zero); } + +InertBody::operator=(const InertBody &bodyAssignment) { + if !(this == bodyAssignment) { + position.xx = bodyAssignment.position.xx; + position.yy = bodyAssignment.position.yy; + position.concordanceDouble(); + + velocity.xx = bodyAssignment.velocity.xx; + velocity.yy = bodyAssignment.velocity.yy; + velocity.concordanceDouble(); + + Cartesian Zero; + Zero.atOrigin(); + _at_rest = (velocity == Zero); } + return *this; } + +InertBody::~InertBody(void) { + delete position; + delete velocity; } + + +// Read current position +int InertBody::X(void) { return position.x; } + +int InertBody::Y(void) { return position.y; } + +double InertBody::XX(void) { return position.xx; } + +double InertBody::YY(void) { return postion.yy; } + +Cartesian InertBody::Position(void) { return position; } + + +//Set current position +void InertBody::X(int a) { + position.x = a; + position.concordanceInt(); + return; } + +void InertBody::Y(int b) { + position.y = b; + postion.concordanceInt(); + return; } + +void InertBody::X_Y(int a, int b) { + position.x = a; + position.y = b; + position.concordanceInt(); + return; } + +void InertBody::XX_YY(double aa, double bb) { + position.xx = aa; + position.yy = bb; + position.concordanceDouble(); + return; } + +void InertBody::XX(double aa) { + position.xx = aa; + position.concordanceDouble(); + return; } + +void InertBody::YY(double bb) { + position.yy = bb; + position.concordanceDouble(); + return; } + +void InertBody::Position(Cartesian pos) { + position.xx = pos.xx; + position.yy = pos.yy; + position.concordanceDouble(); + return; } + + +// Read current velocity +int InertBody::VX(void) { return velocity.x; } + +int InertBody::VY(void) { return velocity.y; } + +double InertBody::VXX(void) { return velocity.xx; } + +double InertBody::VYY(void) { return velocity.yy; } + +Cartesian InertBody::Velocity(void) { return velocity; } + +bool InertBody::AtRest(void) { + bool BodyIsAtRest; + Catesian Zero; + Zero.atOrigin(); + BodyIsAtRest = (velocity == Zero); + _at_rest = BodyIsAtRest; + return BodyIsAtRest; } + + +//Set current velocity +void InertBody::VX(int vx) { + velocity.x = vx; + velocity.concordanceInt(); + Cartesian Zero.atOrigin(); + _at_rest = (velocity == Zero); + return; } + +void InertBody::VY(int vy) { + velocity.y = vy; + velocity.concordanceInt(); + Cartesian Zero.atOrigin(); + _at_rest = (velocity == Zero); + return; } + +void InertBody::VX_VY(int vx, int vy) { + velocity.x = vx; + velocity.y = vy; + velocity.concordanceInt(); + Cartesian Zero.atOrigin(); + _at_rest = (velocity == Zero); + return; } + +void InertBody::VXX_VYY(double vxx, double vyy) { + velocity.xx = vxx; + velocity.yy = vyy; + velocity.concordanceDouble(); + Certesian Zero.atOrigin(); + _at_rest = (velocity == Zero); + return; } + +void InertBody::VXX(double vxx) { + velocity.xx = vxx; + velocity.concordanceDouble(); + Cartesian Zero.atOrigin(); + _at_rest = (velocity == Zero); + return; } + +void InertBody::VYY(double vyy) { + velocity.yy = vyy; + velocity.concordanceDouble(); + Cartesian Zero.atOrigin(); + _at_rest = (velocity == Zero); + return; } + +void InertBody::Velocity(Cartesian vel) { + velocity.xx = vel.xx; + velocity.yy = vel.yy; + velocity.concordanceDouble(); + Cartesian Zero.atOrigin(); + _at_rest = (velocity == Zero); + return; } + + +// Read next position +int InertBody::nextX(void) { + position.x = position.x + velocity.x; + position.concordanceInt(); + return position.x; } + +int InertBody::nextY(void) { + position.y = position.y + velocity.y; + position.concordanceInt(); + return position.y; } + +double InertBody::nextXX(void) { + position.xx = position.xx + velocity.xx; + position.concordanceDouble(); + return position.xx; } + +double InertBody::nextYY(void) { + position.yy = position.yy + velocity.yy; + position.concordanceDouble(); + return position.yy; } + +Cartesian InertBody::nextPosition(void) { + position.xx = position.xx + velocity.xx; + position.yy = position.yy + velocity.yy; + position.concordanceDouble(); + return position; } + + +// Read previous position +int InertBody::prevX(void) { + position.x = position.x - velocity.x; + position.concordanceInt(); + return position.x; } + +int InertBody::prevY(void) { + position.y = position.y - velocity.y; + position.concordanceInt(); + return position.y; } + +double InertBody::prevXX(void) { + position.xx = position.xx - velocity.xx; + position.concordanceDouble(); + return position.xx; } + +double InertBody::prevYY(void) { + position.yy = position.yy - velocity.yy; + position.concordanceDouble(); + return position.yy; } + +Cartesian InertBody::prevPosition(void) { + position.xx = position.xx - velocity.xx; + position.yy = position.yy - velocity.yy; + position.concordanceDouble(); + return position; } + diff --git a/InertBody.hpp b/InertBody.hpp new file mode 100644 index 0000000..78e9692 --- /dev/null +++ b/InertBody.hpp @@ -0,0 +1,70 @@ +#ifndef INERTBODY_H +#define INERTBODY_H + +class InertBody +{ + public: + Cartesian position, Cartesian velocity; + InertBody(void); + InertBody(int a, int b); + InertBody(double aa, double bb); + InertBody(Cartesian pos); + InertBody(int a, int b, int vx, int vy); + InertBody(double aa, double bb, double vxx, double vyy); + InertBody(Cartesian pos, Cartesian vel); + InertBody(const InertBody &bodyCopy); + operator=(const InertBody &bodyAssignment); + ~InertBody(void); + + // Read current position + int X(void); + int Y(void); + double XX(void); + double YY(void); + Cartesian Position(void); + + //Set current position + void X(int a); + void Y(int b); + void X_Y(int a, int b); + void XX_YY(double aa, double bb); + void XX(double aa); + void YY(double bb); + void Position(Cartesian pos); + + // Read current velocity + int VX(void); + int VY(void); + double VXX(void); + double VYY(void); + Cartesian Velocity(void); + bool AtRest(void); + + //Set current velocity + void VX(int vx); + void VY(int vy); + void VX_VY(int vx, int vy); + void VXX_VYY(double vxx, double vyy); + void VXX(double vxx); + void VYY(double vyy); + void Velocity(Cartesian vel); + + // Read next position + int nextX(void); + int nextY(void); + double nextXX(void); + double nextYY(void); + Cartesian nextPosition(void); + + // Read previous position + int prevX(void); + int prevY(void); + double prevXX(void); + double prevYY(void); + Cartesian prevPosition(void); + + protected: + bool _at_rest; +}; + +#endif diff --git a/TerrestrialGravitation.cpp b/TerrestrialGravitation.cpp new file mode 100644 index 0000000..9418e00 --- /dev/null +++ b/TerrestrialGravitation.cpp @@ -0,0 +1,403 @@ + + +#include "TerrestrialGravitation.h" + +#define _DEFAULT_TIME 30 +#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 GMS2 9806650 // 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 +#define G1000IS2 386088 // Standard gravity on Earth in 1000ths of inches/sec/sec + + +TerrestrialGravitation::TerrestrialGravitation() { + position.xx = velocity.xx = 0.0F; + position.yy = velocity.yy = 0.0F; + position.x = velocity.x = 0; + position.y = velocity.y = 0; + time = _DEFAULT_TIME; + _at_rest = TRUE; } + +TerrestrialGravitation::TerrestrialGravitation(int a, int b) { + position.x = a; + position.y = b; + position.xx = (double) a; + position.yy = (double) b; + + velocity.xx = velocity.yy = 0.0F; + velocity.x = velocity.y = 0; + + time = _DEFAULT_TIME; + _at_rest = TRUE; } + +TerrestrialGravitation::TerrestrialGravitation(int a, int b, int t) { + position.x = a; + position.y = b; + position.xx = (double) a; + position.yy = (double) b; + + velocity.xx = velocity.yy = 0.0F; + velocity.x = velocity.y = 0; + + time = t; + _at_rest = TRUE; } + +TerrestrialGravitation::TerrestrialGravitation(double aa, double bb, + double vxx, double vyy) { + position.xx = aa; + position.yy = bb; + position.x = (int) aa; + position.y = (int) bb; + + velocity.xx = vxx; + velocity.yy = vyy; + velocity.x = (int) vxx; + velocity.y = (int) vyy; + + time = _DEFAULT_TIME; + _at_rest = ((vxx == vyy) == 0.0F); } + + + +TerrestrialGravitation::TerrestrialGravitation(double aa, double bb, + double vxx, double vyy, int t) { + position.xx = aa; + position.yy = bb; + position.x = (int) aa; + position.y = (int) bb; + + velocity.xx = vxx; + velocity.yy = vyy; + velocity.x = (int) vxx; + velocity.y = (int) vyy; + + time = t; + _at_rest = ((vxx == vyy) == 0.0F); } + +TerrestrialGravitation::TerrestrialGravitation(int a, int b, int vx, int vy) { + position.x = a; + position.y = b; + position.xx = (double) a; + position.yy = (double) b; + + velocity.x = vx; + velocity.y = vy; + velocity.xx = (double) vx; + velocity.yy = (double) vy; + + time = _DEFAULT_TIME; + _at_rest = ((vxx == vyy) == 0.0F); } + +TerrestrialGravitation::TerrestrialGravitation(int a, int b, int vx, int vy, int t) { + position.x = a; + position.y = b; + position.xx = (double) a; + position.yy = (double) b; + + velocity.x = vx; + velocity.y = vy; + velocity.xx = (double) vx; + velocity.yy = (double) vy; + + time = t; + _at_rest = ((vx == vy) == 0); } + +TerrestrialGravitation::TerrestrialGravitation(Cartesian pos) { + position.xx = pos.xx; + position.yy = pos.yy; + position.concordanceDouble(); + + velocity.xx = velocity.yy = 0.0F; + velocity.x = velocity.y = 0; + + time = _DEFAULT_TIME; + _at_rest = TRUE; } + +TerrestrialGravitation::TerrestrialGravitation(Cartesian pos, int t) { + position.xx = pos.xx; + position.yy = pos.yy; + position.concordanceDouble(); + + velocity.xx = velocity.yy = 0.0F; + velocity.x = velocity.y = 0; + + time = t; + _at_rest = TRUE; } + + +TerrestrialGravitation::TerrestrialGravitation(Cartesian pos, Cartesian vel) { + position.xx = pos.xx; + position.yy = pos.yy; + position.concordanceDouble(); + + velocity.xx = vel.xx; + velocity.yy = vel.yy; + velocity.concordanceDouble(); + + time = _DEFAULT_TIME; + _at_rest = ((vel.xx == vel.yy) == 0.0F); } + +TerrestrialGravitation::TerrestrialGravitation(Cartesian pos, Cartesian vel, int t) { + position.xx = pos.xx; + position.yy = pos.yy; + position.concordanceDouble(); + + velocity.xx = vel.xx; + velocity.yy = vel.yy; + velocity.concordanceDouble(); + + time = t; + _at_rest = ((vel.xx == vel.yy) == 0.0F); } + +TerrestrialGravitation::TerrestrialGravitation( + const TerrestrialGravitation &terrgravCopy) { + position.xx = terrgravCopy.position.xx; + position.yy = terrgravCopy.position.yy; + position.concordanceDouble(); + + velocity.xx = terrgravCopy.velocity.xx; + velocity.yy = terrgravCopy.velocity.yy; + velocity.concordanceDouble(); + + time = terrgravCopy.time; + _at_rest = ((velocity.xx == velocity.yy) == 0.0F; } + +TerrestrialGravitation::operator=(const TerrestrialGravitation &terrgravAssignment) { + if (this != terrgravAssignment) { + position.xx = terrgravAssignment.position.xx; + position.yy = terrgravAssignment.position.yy; + position.concordanceDouble(); + + velocity.xx = terrgravAssignment.velocity.xx; + velocity.yy = terrgravAssignment.velocity.yy; + velocity.concordanceDouble(); + + time = terrgravAssignment.time; + _at_rest = ((velocity.xx == velocity.yy) == 0.0F); } + return *this; } + + +TerrestrialGravitation::~TerrestrialGravitation() { + delete position; + delete velocity; +} + +int TerrestrialGravitation::X(void) { return position.x; } + +double TerrestrialGravitation::XX(void) { return position.xx; } + +int TerrestrialGravitation::Y(void) { return position.y; } + +double TerrestrialGravitation::YY(void) { return position.yy; } + +Cartesian TerrestrialGravitation::Position(void) { return position; } + +int TerrestrialGravitation::VX(void) { return velocity.x; } + +double TerrestrialGravitation::VXX(void) { return velocity.xx; } + +int TerrestrialGravitation::VY(void) { return velocity.y; } + +double TerrestrialGravitation::VYY(void) { return velocity.yy; } + +Cartesian TerrestrialGravitation::Velocity(void) { return velocity; } + +void TerrestrialGravitation::T(int t) { // Set fineness of time division + time = t; + return; } + +int TerrestrialGravitation::T(void) { return time; } + +void TerrestrialGravitation::X(int a) { + position.x = a; + position.xx = (double) a; + return; } + +void TerrestrialGravitation::Y(int b) { + position.y = b; + position.yy = (double) b; + return; } + +void TerrestrialGravitation::XX(double aa) { + position.xx = aa; + position.x = (int) aa; + return; } + +void TerrestrialGravitation::YY(double bb) { + position.yy = bb; + position.y = (int) bb; + return; +} + +void TerrestrialGravitation::posConcordInt(void) { + position.xx = (double) position.x; + position.yy = (double) position.y; + return; } + +void TerrestrialGravitation::posConcordDoub(void) { + position.x = (int) position.xx; + position.y = (int) position.yy; + return; } + +bool TerrestrialGravitation::posConcord(void) { + bool pass = (position.x == (int) position.xx); + if (pass) pass = (position.y == (int) position.yy); + return pass; } + +void TerrestrialGravitation::Position(int a, int b) { + position.x = a; + position.y = b; + position.concordanceInt(); + return; } + +void TerrestrialGravitation::Position(double aa, double bb) { + position.xx = aa; + position.yy = bb; + position.concordanceDouble(); + return; } + +void TerrestrialGravitation::Position(Cartesian pos) { + position.xx = pos.xx; + position.yy = pos.yy; + position.concordanceDouble(); + return; } + +void TerrestrialGravitation::VX(int vx) { + velocity.x = vx; + velocity.xx = (double) vx; + _at_rest = ((vx == velocity.y) == 0); + return; } + +void TerrestrialGravitation::VY(int vy) { + velocity.y = vy; + velocity.yy = (double) vy; + _at_rest = ((vy == velocity.x) == 0); + return; } + +void TerrestrialGravitation::VXX(double vxx) { + velocity.xx = vxx; + velocity.x = (int) vxx; + _at_rest = ((vxx == velocity.yy) == 0.0F); + return; } + +void TerrestrialGravitation::VYY(double vyy) { + velocity.yy = vyy; + velocity.y = (int) vyy; + _at_rest = ((vyy == velocity.xx) == 0.0F); + return; } + +void TerrestrialGravitation::velConcordInt(void) { + velocity.xx = (double) velocity.x; + velocity.yy = (double) velocity.y; + _at_rest = ((velocity.x == velocity.y) ==0); + return; } + +void TerrestrialGravitation::velConcordDoub(void) { + velocity.x = (int) velocity.xx; + velocity.y = (int) velocity.yy; + _at_rest = ((velocity.xx == velocity.yy) == 0.0F); + return; } + +bool TerrestrialGravitation::velConcord(void) { + bool pass = (velocity.x == (int) velocity.xx); + if (pass) pass = (velocity.y == (int) velocity.yy); + return pass; } + +void TerrestrialGravitation::Velocity(int vx, int vy) { + velocity.x = vx; + velocity.y = vy; + velocity.concordanceInt(); + _at_rest = ((vx == vy) == 0); + return; } + +void TerrestrialGravitation::Velocity(double vxx, double vyy) { + velocity.xx = vxx; + velocity.yy = vyy; + velocity.concordanceDouble(); + _at_rest = ((vxx == vyy) == 0.0F) + return; } + +void TerrestrialGravitation::Velocity(Cartesian vel) { + velocity.xx = vel.xx; + velocity.yy = vel.yy; + velocity.concordanceDouble(); + _at_rest = ((vel.xx == vel.yy) == 0.0F); + return; } + +void TerrestrialGravitation::StartX(int a) { + X(a); + XX((double) a); + return; } + +void TerrestrialGravitation::StartY(int y) { + Y(b); + YY((double) b); + return; } + +void TerrestrialGravitation::StartXX(double aa) { + XX(aa); + X((int) aa); + return; } + +void TerrestrialGravitation::StartYY(double bb) { + YY(bb); + Y((int) bb); + return; } + +void TerrestrialGravitation::StartPosition(Cartesian pos) { + Position(pos); + return; } + +void TerrestrialGravitation::StartVX(int vx) { + VX(vx); + _at_rest = ((vx == velocity.y) == 0); + return; } + +void TerrestrialGravitation::StartVY(int vy) { + VY(vy); + _at_rest = ((vy == velocity.x) == 0); + return; } + +void TerrestrialGravitation::StartVXX(double vxx) { + VXX(vxx); + _at_rest = ((vxx == velocity.yy) == 0.0F); + return; } + +void TerrestrialGravitation::StartVYY(double vyy) { + VYY(vyy); + _at_rest = ((vyy == velocity.x) == 0.0F) + return; } + +void TerrestrialGravitation::StartVelocity(Cartesian vel) { + Velocity(vel); + _at_rest = ((vel.xx == vel.yy) ==0.0F); + return; } + +void TerrestrialGravitation::BeginMotion(void) { // Begin object motion + _at_rest = FALSE; +} + +void TerrestrialGravitation::PrevPos(void) { // Move object to previous position + velocity.yy = velocity.yy + (GG / (double) t); + position.yy = position.yy - (velocity.yy / (double) t); + position.xx = position.xx - (velocity.xx / (double) t); + position.concordanceDouble(); + velocity.concordanceDouble(); + _at_rest = ((velocity.xx == velocity.yy) == 0.0F); } + +void TerrestrialGravitation::NextPos(void) { // Move object to next position + velocity.yy = velocity.yy - (GG / (double) t); + position.yy = position.yy + (velocity.yy / (double) t); + position.xx = position.xx + (velocity.xx / (double) t); + position.concordanceDouble(); + velocity.concordanceDouble(); + _at_rest = ((velocity.xx == velocity.yy) == 0.0F); } + +void TerrestrialGravitation::HaltMotion(void) { // Halt motion at current position + _at_rest = TRUE; + velocity.xx = 0.0F; + velocity.yy = 0.0F; + velocity.concordanceDouble(); +} + diff --git a/TerrestrialGravitation.dev b/TerrestrialGravitation.dev new file mode 100644 index 0000000..58d561c --- /dev/null +++ b/TerrestrialGravitation.dev @@ -0,0 +1,132 @@ +[Project] +FileName=TerrestrialGravitation.dev +Name=TerrestrialGravitation +Type=2 +Ver=2 +ObjFiles= +Includes= +Libs= +PrivateResource= +ResourceIncludes= +MakeIncludes= +Compiler= +CppCompiler= +Linker= +IsCpp=1 +Icon= +ExeOutput= +ObjectOutput= +LogOutput= +LogOutputEnabled=0 +OverrideOutput=0 +OverrideOutputName=TerrestrialGravitation.a +HostApplication= +UseCustomMakefile=0 +CustomMakefile= +CommandLine= +Folders= +IncludeVersionInfo=1 +SupportXPThemes=0 +CompilerSet=0 +CompilerSettings=1000000000000000000000000 +UnitCount=8 + +[VersionInfo] +Major=0 +Minor=7 +Release=0 +Build=0 +LanguageID=1033 +CharsetID=1252 +CompanyName=Arias Concepts & Solutions/The Trashcan Software & Media Publication +FileVersion=0.7.0.0 +FileDescription=Developed using the Dev-C++ IDE, Coded by Ray Arias +InternalName= +LegalCopyright=(C) 2018 Raymond Arias, Jr. Released under GPL +LegalTrademarks= +OriginalFilename=Terrestrial Gravitation Library +ProductName=Terrestrial Gravitation Library +ProductVersion=0.7.0.0 +AutoIncBuildNr=0 +SyncProduct=1 + +[Unit4] +FileName=Cartesian.cpp +CompileCpp=1 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit2] +FileName=TerrestrialGravitation.hpp +CompileCpp=1 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit3] +FileName=Cartesian.hpp +CompileCpp=1 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit5] +FileName=GravitationalBody.hpp +CompileCpp=1 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit1] +FileName=TerrestrialGravitation.cpp +CompileCpp=1 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit7] +FileName=InertBody.hpp +CompileCpp=1 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit6] +FileName=GravitationalBody.cpp +CompileCpp=1 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit8] +FileName=InertBody.cpp +CompileCpp=1 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/TerrestrialGravitation.hpp b/TerrestrialGravitation.hpp new file mode 100644 index 0000000..2abf581 --- /dev/null +++ b/TerrestrialGravitation.hpp @@ -0,0 +1,94 @@ +// TerrestrialGravitation Class for Use in Anything Requiring +// Terrestrial Gravitational Motion + +#ifndef TERRESTRIALGRAVITATION_H +#define TERRESTRIALGRAVITATION_H + +class TerrestrialGravitation +{ + public: + int numberOfGravBodies; + InertBody gravBodies[numberofGravBodies]; + int time, bool at_rest; + int groundInt, double groundDouble, int gInt, double gDouble; + TerrestrialGravitation(); + TerrestrialGravitation(int a, int b); + TerrestrialGravitation(int a, int b, int t); + TerrestrialGravitation(double aa, double bb); + TerrestrialGravitation(double aa, double bb, int t); + TerrestrialGravitation(int a, int b, int vx, int vy); + TerrestrialGravitation(int a, int b, int vx, int vy, int t); + TerrestrialGravitation(double aa, double bb, double vxx, double vyy); + TerrestrialGravitation(double aa, double bb, double vxx, double vyy, int t); + TerrestrialGravitation(Cartesian pos); + TerrestrialGravitation(Cartesian pos, int t); + TerrestrialGravitation(Cartesian pos, Cartesian vel); + TerrestrialGravitation(Cartesian pos, Cartesian vel, int t); + TerrestrialGravitation(const TerrestrialGravitation &terrgravCopy); + operator=(const TerrestrialGravitation &terrgravAssignment); + ~TerrestrialGravitation(); + + void T(int t); + int T(void); + + // Read current position of TerrestrialGravitation object + int X(void); + int Y(void); + double XX(void); + double YY(void); + Cartesian Position(void); + + // Read current velocity of TerrestrialGravitation object + int VX(void); + int VY(void); + double VXX(void); + double VYY(void); + Cartesian Velocity(void); + + void T(int t); // Set fineness of time division + + // Set current position of TerrestrialGravitation object + void X(int a); + void Y(int b); + void XX(double aa); + void YY(double bb); + void Position(int a, int b); + void Position(double aa, double bb); + void Position(Cartesian pos); + + // Set current velocity of TerrestrialGravitation object + void VX(int vx); + void VY(int vy); + void VXX(double vxx); + void VYY(double vyy); + void Velocity(int vx, int vy); + void Velocity(double vxx, double vyy); + void Velocity(Cartesian vel); + + // Set starting position of TerrestrianGravitation object + void StartX(int a); + void StartY(int b); + void StartXX(double aa); + void StartYY(double bb); + void StartPosition(Cartesian pos); + + // Set starting velocity of TerrestrialGravitation object + void StartVX(int vx); + void StartVY(int vy); + void StartVXX(double vxx); + void StartVYY(double vyy); + void StartVelocity(Cartesian vel); + + void PlaceGround(int b); + void PlaceGround(double bb); + + void BeginMotion(void); // Begin object motion + void PrevPos(void); // Move object to previous position + void NextPos(void); // Move object to next position + void HaltMotion(void); // Halt motion at current position + + private: + bool _at_rest; +}; + +#endif