[NBSDSP]-main

src/Cli.cpp

@@ -54,7 +54,7 @@ using namespace std;
     CliValidate valid;
 
     std::cout << "============"
-      << "The default display size is 80 characters by 30 characters."
+      << "The default display size is 64 characters by 32 characters."
       << " Do you want to adjust the size for your graph?";
     bool adjustDisplaySize;
     adjustDisplaySize = get.cliyesno();

src/Compute.cpp

@@ -4,20 +4,89 @@
 #include<vector>
 #include "Compute.h"
 #include "Settings.h"
+#include "../../Constants.h" // from nbsdsp repo containing this submodule
 using namespace std;
 
-  double Compute::execute(vector<double> polynomial, double x) {
+  double Compute::execute(vector<double> polynomial, double x) 
+  {
     double output = 0.0;
-    for (int i = polynomial.size()-1; i > -1; --i) { 
+    for (int i = polynomial.size()-1; i > -1; --i) 
+    { 
       output += polynomial.at(i) * pow(x, i);
     }
     return output;
   };
 
-  int Compute::minimumIndexWithinYPlusEpsilon(vector<double> imageOfX, double y, Settings settings) {
-    for (int i = 0; i < imageOfX.size(); i++) { 
+  double Compute::execute_a(double (*polynomial)[POLYNOMIAL_DEGREE_P1], double x) 
+  {
+    double output = 0.0;
+    for (int i = 0; i < POLYNOMIAL_DEGREE_P1; i++) 
+    { 
+      // printf("\npoly %i: %f", i, (*polynomial)[i]);
+      output += (*polynomial)[i] * pow(x, i);
+    }
+    return output;
+  };
+
+  bool Compute::withinEpsilon(vector<double> image, int i, double y, Settings *settings)
+  {
+    return abs(image[i] - y) < settings->epsilon;
+  };
+
+  bool Compute::withinEpsilon_a(double (*image)[EQ_IMAGE_WIDTH], int i, double y, Settings *settings)
+  {
+    return abs((*image)[i] - y) < settings->epsilon;
+  };
+
+  void Compute::piecewiseImage(
+    double (*polynomialArray)[POLYNOMIAL_ARRAY_LENGTH][POLYNOMIAL_DEGREE_P1], 
+    double (*image)[EQ_IMAGE_WIDTH], 
+    Settings *settings
+  )
+  {
+    {
+      int stepsPerPolynomial[POLYNOMIAL_ARRAY_LENGTH];
+      for (int i = 0; i < POLYNOMIAL_ARRAY_LENGTH; i++)
+      {
+        stepsPerPolynomial[i] = 5;
+      }
+
+      // compute which polynomial to use at each x step
+      int polynomialAtStep[EQ_IMAGE_WIDTH] = { 2 };
+      int pasIndex = 0;
+      for (int i = 0; i < POLYNOMIAL_ARRAY_LENGTH; i++)
+      {
+        for (int j = 0; j < stepsPerPolynomial[i]; j++)
+        {
+          if (pasIndex < EQ_IMAGE_WIDTH)
+          {
+            polynomialAtStep[pasIndex] = i;
+            pasIndex += 1;
+            // printf("\n pasIndex: %i", pasIndex);
+          }
+        }
+      }
+
+      // execute correct polynomial at each x step 
+      for (int i = 0; i < EQ_IMAGE_WIDTH; i++)
+      {
+        double x = settings->xMin + i * settings->stepWidth;
+        // for (int k = 0; k < POLYNOMIAL_DEGREE_P1; k++)
+        // {
+        //   printf("\npA paS %i: %f", i, (*polynomialArray)[polynomialAtStep[i]][k]);
+        // }
+        (*image)[i] = execute_a(&(*polynomialArray)[polynomialAtStep[i]], x);
+        // printf("\nimage i: %f", (*image)[i]);
+      }
+    }
+  };
+
+  int Compute::minimumIndexWithinYPlusEpsilon(vector<double> imageOfX, double y, Settings *settings) {
+    for (int i = 0; i < imageOfX.size(); i++) 
+    { 
       double pointOnGraph = imageOfX.at(i);
-      if (abs(pointOnGraph - y) < settings.epsilon) {
+      if (abs(pointOnGraph - y) < settings->epsilon)
+      {
         return i;
       }
     } 
@@ -27,14 +96,27 @@ using namespace std;
   vector<vector<double> > Compute::computeImageArray(vector<vector<double> > polynomialArray,
                                                      vector<vector<double> > imageArray,
                                                      Settings settings) {
-    double stepWidth = Settings::stepWidth(settings);
+    double stepWidth = Compute::stepWidth(&settings);
     for (int i = 0; i < polynomialArray.size(); i++) {
       vector<double> thisPolynomial = polynomialArray.at(i);
-      int xStepCount = Settings::xStepCount(settings);
+      int xStepCount = Compute::xStepCount(&settings);
       for (int j = 0; j <= xStepCount; j++) {
         double x = settings.xMin + j * stepWidth; // j = (x - xMin)/stepWidth
         imageArray.at(i).at(j) = execute(thisPolynomial, x);    
       }
     }
     return imageArray;
   };
+
+
+  double Compute::stepWidth(Settings *settings) {
+    return (settings->xMax - settings->xMin) / EQ_IMAGE_WIDTH;
+  }
+
+  double Compute::stepHeight(Settings *settings) {
+    return (settings->yMax - settings->yMin) / EQ_IMAGE_HEIGHT;
+  }
+
+  int Compute::xStepCount(Settings *settings) {
+    return (settings->xMax - settings->xMin) / EQ_IMAGE_WIDTH;
+  }

src/Compute.h

@@ -2,14 +2,30 @@
 #define Compute_H
 #include<vector>
 #include "Settings.h"
+#include "../../Constants.h" // from nbsdsp repo containing this submodule
 using namespace std;
 
 class Compute {
 
 	public:
 		static double execute(vector<double> polynomial, double x);
-		static vector<vector<double> > computeImageArray(vector<vector<double> > polynomialArray, vector<vector<double> > imageArray, Settings settings);
-		static int minimumIndexWithinYPlusEpsilon(vector<double> imageOfX, double y, Settings settings);
+    static double execute_a(double (*polynomial)[POLYNOMIAL_DEGREE_P1], double x);
+		static vector<vector<double> > computeImageArray(
+      vector<vector<double> > polynomialArray, 
+      vector<vector<double> > imageArray, 
+      Settings settings
+    );
+    static void piecewiseImage(
+      double (*polynomialArray)[POLYNOMIAL_ARRAY_LENGTH][POLYNOMIAL_DEGREE_P1], 
+      double (*image)[EQ_IMAGE_WIDTH], 
+      Settings *settings
+    );
+		static int minimumIndexWithinYPlusEpsilon(vector<double> imageOfX, double y, Settings *settings);
+    static bool withinEpsilon(vector<double> image, int i, double y, Settings *setting);
+    static bool withinEpsilon_a(double (*image)[EQ_IMAGE_WIDTH], int i, double y, Settings *setting);
+		static int xStepCount(Settings *settings);
+    static double stepWidth(Settings *settings);
+    static double stepHeight(Settings *settings);
 };
 
 #endif

src/Draw.cpp

@@ -5,64 +5,116 @@
 #include "Draw.h"
 #include "Compute.h"
 #include "Settings.h"
+#include "../../Constants.h" // from nbsdsp repo containing this submodule
 using namespace std;
 
-  std::string Draw::createRow(vector<vector<double> > imageArray, double y, Settings settings) {
+  std::string Draw::createRow(vector<vector<double> > imageArray, double y, Settings settings) 
+  {
 		double x;
 		std::string row = " ";
 
-    double stepWidth = Settings::stepWidth(settings);
-		for (int t = 0;  t < settings.displayWidth; t++) {
+    double stepWidth = Compute::stepWidth(&settings);
+		for (int t = 0;  t < settings.displayWidth; t++) 
+    {
 			x = (t * stepWidth) + settings.xMin;
 			vector<double> imageOfX(imageArray.size(), 0);
-			for (int k = 0; k < imageArray.size(); k++) {
+			for (int k = 0; k < imageArray.size(); k++) 
+      {
 				imageOfX.at(k) = imageArray.at(k).at(t);
 			}
 			row += determineCharacterToRender(imageOfX, x, y, settings);
 		}
 		return row + " \r\n";
 	};
+
+  void Draw::createRowPiecewise(
+    double (*image)[EQ_IMAGE_WIDTH], 
+    int rowIndex, 
+    Settings *settings,
+    char (*graphNext)[EQ_IMAGE_HEIGHT][EQ_IMAGE_WIDTH]
+  )
+  {
+    double x;
+    double y;
+    int idx = EQ_IMAGE_HEIGHT - rowIndex - 1;
+		y = ((double) idx * settings->stepHeight) + settings->yMin;
+    for (int j = 0; j < EQ_IMAGE_WIDTH; j++) // column
+    {
+      // printf("\n immm %f", (*image)[j]);
+      x = (j * settings->stepWidth) + settings->xMin;
+      (*graphNext)[rowIndex][j] = determineCharacterToRenderPiecewise(image, j, x, y, settings);
+    }
+  }
 
-  void Draw::render(vector<vector<double> > polynomialArray, Settings settings) {
+  void Draw::render(vector<vector<double> > polynomialArray, Settings settings) 
+  {
 		Compute compute;
 		double y;
 		std::string margin = " ";
 		std::string output;
 
-    int xStepCount = Settings::xStepCount(settings);
-		vector<double> imageOfZeroFunction(xStepCount+1, 0);
+    int xStepCount = settings.xStepCount;
+    vector<double> imageOfZeroFunction(xStepCount+1, 0);
 		vector<vector<double> > imageArray(polynomialArray.size(), imageOfZeroFunction);
 
 		imageArray = compute.computeImageArray(polynomialArray, imageArray, settings);
 
-    double stepHeight = Settings::stepHeight(settings);
+    double stepHeight = Compute::stepHeight(&settings);
 		for (int s = settings.displayHeight; s > -1; s--) {
 			y = (s * stepHeight) + settings.yMin;
 			std::cout << createRow(imageArray, y, settings);
 		}
 	};
 
-char Draw::determineCharacterToRender(vector<double> imageOfX, double x, double y, Settings settings) {
+  // void Draw::renderPiecewise(vector<vector<double> > polynomialArray, Settings *settings) 
+  // {
+		// double y;
+		// std::string margin = " ";
+		// std::string output;
+
+		// vector<double> image;
+		// image = Compute::piecewiseImage(polynomialArray, settings);
+		// 
+		// for (int j = settings->displayHeight; s > -1; s--) {
+		// 	y = (s * settings->stepHeight) + settings->yMin;
+  //     // TODO:
+  //     //   - store the result
+  //     //   - update changes
+		// 	std::cout << createRowPiecewise(image, y, settings);
+		// }
+  // }
+
+  char Draw::determineCharacterToRender(vector<double> imageOfX, double x, double y, Settings settings) 
+  {
 		Compute compute;
-    double stepWidth = Settings::stepWidth(settings);
-    double stepHeight = Settings::stepHeight(settings);
+    double stepWidth = settings.stepWidth; 
+    double stepHeight = settings.stepHeight;
 		for (int i = 0; i < imageOfX.size(); i++) {
 			char backgroundChar = settings.backgroundChar;
-			int indexToPrint = compute.minimumIndexWithinYPlusEpsilon(imageOfX, y, settings);
-			if (indexToPrint > -1) {
+			int indexToPrint;
+      indexToPrint = compute.minimumIndexWithinYPlusEpsilon(imageOfX, y, &settings);
+
+      if (indexToPrint > -1) 
+      {
 				return '0' + indexToPrint;
 			}
-			else {
-				if (abs(y) < stepHeight/2) {
-					if (abs(x) < stepWidth/2) {
+      else 
+      {
+				if (abs(y) < stepHeight/2) 
+        {
+					if (abs(x) < stepWidth/2) 
+          {
 						backgroundChar = settings.originChar;
 					}
-					else {
+					else 
+          {
 						backgroundChar = settings.xAxisChar;
 					}
 				}
-				else {
-					if (abs(x) < stepWidth/2) {
+				else 
+        {
+					if (abs(x) < stepWidth/2) 
+          {
 						backgroundChar = settings.yAxisChar;
 					}
 				}
@@ -71,3 +123,47 @@ char Draw::determineCharacterToRender(vector<double> imageOfX, double x, double
 		}	
 		return settings.backgroundChar;
 	};
+
+  char Draw::determineCharacterToRenderPiecewise(
+    double (*image)[EQ_IMAGE_WIDTH], 
+    int j, 
+    double x, 
+    double y, 
+    Settings *settings
+  ) 
+  {
+    // printf("\nim: %f", (*image)[j]);
+    // printf("\ny: %f", y);
+    // printf("\n === \n");
+    if ( Compute::withinEpsilon_a(image, j, y, settings) ) 
+    {
+      return '#';
+    }
+    else if ((*image)[j] < y)
+    {
+      return 'o';
+    }
+    else 
+    {
+      char backgroundChar = settings->backgroundChar;
+      if (abs(y) < settings->stepHeight/2) 
+      {
+        if (abs(x) < settings->stepWidth/2) 
+        {
+          backgroundChar = settings->originChar;
+        }
+        else 
+        {
+          backgroundChar = settings->xAxisChar;
+        }
+      }
+      else 
+      {
+        if (abs(x) < settings->stepWidth/2) 
+        {
+          backgroundChar = settings->yAxisChar;
+        }
+      }
+      return backgroundChar;
+    }
+  };

src/Draw.h

@@ -2,13 +2,28 @@
 #define Draw_H
 #include<vector>
 #include "Settings.h"
+#include "../../Constants.h" // from nbsdsp repo containing this submodule
 using namespace std;
 
 class Draw {
 	public:
 		static std::string createRow(vector<vector<double> > imageArray, double y, Settings settings);
+    static void createRowPiecewise(
+      double (*image)[EQ_IMAGE_WIDTH], 
+      int i, 
+      Settings *settings,
+      char (*graphNext)[EQ_IMAGE_HEIGHT][EQ_IMAGE_WIDTH]
+    );
 		static void render(vector<vector<double> > polynomialArray, Settings settings);
+    static void renderPiecewise(vector<vector<double> > polynomialArray, Settings *settings);
 		static char determineCharacterToRender(vector<double> imageOfX, double x, double y, Settings settings);
+    static char determineCharacterToRenderPiecewise(
+      double (*image)[EQ_IMAGE_WIDTH], 
+      int t, 
+      double x, 
+      double y, 
+      Settings *settings
+    );
 };
 
 #endif