Псевдографика на плюсах

#include <fstream>
#include <iostream>
#include <iomanip>
#include <math.h>
 
typedef double (*F)(double x);
 
double f1(double x) {
    return sin(x);
}
double f2(double x) {
    return cos(x);
}
double f3(double x) {
    if(x == 0){
        x += 0.1;
    }
    return  pow((2*sin(2/x)*cos(2/x)), 2);
}
double f4(double x) {
    if(x == 0){
        x += 0.1;
    }
    return sin(1/x);
}
double f5(double x) {
    return 0.5*x + 2;
}
double f6(double x) {
    if(x == 0){
        x += 0.01;
    }
    return sin(cos(x)) - x*x + 1/x + 5;
}
double f7(double x) {
    return abs(0.25*x+3*(cos(x*100))*sin(x));
}
double fdefault(double x){
    return x;
}
 
void prepare(double& xMin, double& xMax);
void buildGraphic(char** graphic, int h, int w,  double* vectorY,  double yMin, double xMin, double step, double scaleByY, char symbol);    
void saveStateToFile(char** graphic, int h, int w, double xMin, double xMax, double step, const char* file);
void drawGraphic(char** graphic, int h, int w, const int CHAR_SPACE);
void releseMemory(char** graphic, int h, double* vectorY);
double* calculateFunctionByStep(F f, double x0, int width, double step) ;                                            
double getScaleByYAndFindMinMax(double* vectorY, int length, const int HEIGHT_OF_GRAPHIC, double& yMin, double& yMax);
double getSizeOfStep(double xMin, double xMax, int n);
int getHeight(double scaleByY, double yMin, double yMax);
char** createGraphicMatrix(int h, int w, char filler);
int getWidth(double xMin, double xMax, double& step);
bool isBySizeOfStep();
bool isRepeate();
F setFunction();
 
 
int main(int argc, char* argv[])
{       
    const int HEIGHT_OF_GRAPHIC = 40;   /*Target height graphics in rows*/
    const int CHAR_SPACE = 1; 
    const char* FILE_NAME = "graphic.txt";
    const char FILLER = '.';
    const char SYMBOL = 'X';
 
    do{  
        system("cls");
        double xMin = 0;
        double xMax = 0;         
        prepare(xMin, xMax);    
 
        F function = setFunction();
 
        double yMin = 0;
        double yMax = 0;
 
        int    width = -1;
        double step  = -1;
 
        if(isBySizeOfStep()){
            width = getWidth(xMin, xMax, step);/*Width matrix values*/           
        } else {
            step = getSizeOfStep(xMin, xMax, width);        
        }
 
        double* vectorY  = calculateFunctionByStep(function, xMin, width, step);             
        double  scaleByY = getScaleByYAndFindMinMax(vectorY, width, HEIGHT_OF_GRAPHIC, yMin, yMax); 
        int     height   = getHeight(scaleByY, yMin, yMax);     
        char**  graphic  = createGraphicMatrix(height, width, FILLER);
 
        buildGraphic(graphic, height, width, vectorY, yMin, xMin, step, scaleByY, SYMBOL);
        drawGraphic (graphic, height, width, CHAR_SPACE);
        saveStateToFile(graphic, height, width, xMin, xMax, step, FILE_NAME);
        releseMemory(graphic, height, vectorY); 
    }while(isRepeate());
}
 
 
bool isRepeate(){
    char answer = 'n';
    std::cout << std::endl<< "Repeat?(y/n)";
    std::cin >> answer;
    return answer != 'n' && answer != 'N';
}
 
 
bool isBySizeOfStep() {
    std::cout << std::setw(50) <<"Set [size of step]{1} or [number of step]{2}? ";  
    int answer = 1;
    std::cin >> answer;
    return answer == 1 ? true : false;
}
 
 
F setFunction(){
    std::cout << std::endl      
        << "1. sin(x)"                               << std::endl
        << "2. cos(x)"                               << std::endl
        << "3. (2*sin(2/x)*cos(2/x))^2"              << std::endl
        << "4. sin(1/x)"                             << std::endl
        << "5. 0.5*x + 2"                            << std::endl
        << "6. sin(cos(x)) - x*x + 1/x + 5"          << std::endl
        << "7. abs(0.25*x+3*(cos(x*100))*sin(x))"    << std::endl
        << std::setw(50) << "Select number of function : ";
    int answer = 1;
    std::cin >> answer;
    switch (answer)
    {
    case 1: return f1;
    case 2: return f2;
    case 3: return f3;
    case 4: return f4;
    case 5: return f5;
    case 6: return f6;
    case 7: return f7;
    default: return fdefault;        
    }
}
 
 
void prepare(double& xMin, double& xMax) {
    std::cout << std::setw(50) << "Set initial value of 'x' : "; std::cin >> xMin;
    std::cout << std::setw(50) << "Set final   value of 'x' : "; std::cin >> xMax;
}
 
 
int getWidth(double xMin, double xMax, double& step) {   
    std::cout << std::setw(50)  << "Set    value  of 'step' : "; std::cin >> step; 
    return abs(xMax - xMin) / step;
}
 
 
double getSizeOfStep(double xMin, double xMax, int n) {  
    std::cout << std::setw(50)  << "Set    number of  steps : "; std::cin >> n; 
    return abs(xMax - xMin) / n;
}
 
 
double* calculateFunctionByStep(F f, double x0, int width, double step) {   
    double *vectorY = new double[width];      /*contains 'y'*/
    for(int index = 0; index < width; ++index) {                 
        vectorY[index] = f(x0 + index*step);             
    }
    return vectorY;
}
 
 
double getScaleByYAndFindMinMax(double* vectorY, int length, const int HEIGHT_OF_GRAPHIC, double& yMin, double& yMax) {
    yMin = 0;
    yMax = 0;
    for(int index = 0; index < length; ++index) {   
        if(vectorY[index] < yMin) { 
            yMin = vectorY[index]; 
        }
        if(vectorY[index] > yMax) { 
            yMax = vectorY[index]; 
        }
    }
    return HEIGHT_OF_GRAPHIC / abs(yMax - yMin);
}
 
 
int getHeight(double scaleByY, double yMin, double yMax){
    return scaleByY * abs(yMax - yMin);
}
 
 
char** createGraphicMatrix(int h, int w, char filler){
    char** graphic = new char*[h];
    for(int index = 0; index < h; ++index) {
        graphic[index] = new char[w];
    }   
    for(int y = 0; y < h; ++y) {
        for(int x = 0; x < w; ++x) {
            graphic[y][x] = filler;
        }
    }
    return graphic;
}
 
 
void buildGraphic(char** graphic, int h, int w, double* vectorY, double yMin, double xMin, double step, double scaleByY, const  char symbol) {   
    int row = 0;     
    int row0 = abs(yMin) * scaleByY;        
    for(int index = 0; index < w; ++index) {         
        row =  vectorY[index] * scaleByY;            
        row += row0;        
        if(row >= h){
            row = h - 1;            
        }    
        graphic[row][index] = symbol;            
    }
    int col0 = abs(xMin) / step;    
    for(int index = 0; index < w; ++index) {             
        graphic[row0][index] = '-';          
    }
    for(int index = 0; index < h; ++index) {          
        graphic[index][col0] = '|';          
    }
    graphic[row0][col0] = '+';  
}
 
 
void drawGraphic(char** graphic, int h, int w, const int CHAR_SPACE){   
    for(int y = 0; y < h; ++y) {
        for(int x = 0; x < w; ++x) {        
            std::cout << std::setw(CHAR_SPACE);
            std::cout << graphic[y][x];             
        }
        std::cout << std::endl;     
    }    
    std::cout << std::endl;
}
 
 
void saveStateToFile(char** graphic, int h, int w, double xMin, double xMax, double step, const char* file){
    std::ofstream out;
    out.open (file, std::ios_base::app); 
    out << std::endl;
    out << "_[" <<xMin<<" ; "<<xMax<<"]"
        << "_[size   of step  = " <<step<<"]" 
        << "_[number of steps = " <<w<<"]" << std::endl;     
    for(int y = 0; y < h; ++y) {
        for(int x = 0; x < w; ++x) {         
            out << graphic[y][x];
        }        
        out << std::endl;
    }
    out.close();     
}
 
 
void releseMemory(char** graphic, int h, double* vectorY){
    delete[] vectorY;
 
    for(int index = 0; index < h; ++index) {
        delete[] graphic[index];
    }
    delete[] graphic;
}