Калькулятор нечетких чисел

#include "pch.h"
#include <iostream>
#include <cmath>
#include <cstring>
 
// ограничения диапазона
const double cdMinimumPrice = 0;
const double cdMaximumPrice = 70;
 
using namespace std;
 
class FuzzyFunction {
protected:
    double dLeft, dRight; // интервал
    char   cType; // тип функции, "t" для треугольника
 
public:
    CFuzzyFunction() {};
    virtual ~CFuzzyFunction() { }
 
    // получание границы значений
    virtual void setInterval(double l, double r) {
        dLeft = l; dRight = r;
    }
 
    // для трапециевидной формы, получение двух точек между границами
    virtual void setMiddle(double dL = 0, double dR = 0) = 0;
 
    // для установки типа функции:
    // t - треугольник, r - трапеция
    virtual void setType(char c) {
        cType = c;
    }
 
    // используется для проверки принадлежности точек интервалу
    bool isDotInInterval(double t) {
        if ((t >= dLeft) && (t <= dRight)) return true; 
        else return false;
    }
 
    // получение типа нечеткой функции
    char getType(void)const { return cType; }
 
    //вычисляемое значение
    virtual double getValue(double t) = 0;
};
 
class Trapezoid : public FuzzyFunction {
private:
    double dLeftMiddle, dRightMiddle;
 
public:
    void setMiddle(double dL, double dR) {
        dLeftMiddle = dL; dRightMiddle = dR;
    }
 
    double getValue(double t) {
        if (t <= dLeft || t >= dRight)
            return 0;
        else if (dLeft < t < dLeftMiddle)
            return (t - dLeft) / (dLeftMiddle - dLeft);
        else if (dLeftMiddle <= t <= dRightMiddle)
            return 1.0;
        else if (dRightMiddle < t < dRight)
            return (dRight - t) / (dRight - dRightMiddle);
    }
};
 
int main(void) {
    FuzzyFunction *FuzzySet[4];
 
    FuzzySet[0] = new Trapezoid;
    FuzzySet[1] = new Trapezoid;
 
    FuzzySet[0]->setInterval(1, 4);
    FuzzySet[0]->setMiddle(2,3);
    FuzzySet[0]->setType('r');
 
    FuzzySet[1]->setInterval(2, 8);
    FuzzySet[1]->setMiddle(3, 4);
    FuzzySet[1]->setType('r');
 
    system("pause");
    return 0;
}

#include "pch.h"
#include <iostream>
#include <cmath>
#include <cstring>
#include <vector>
 
using namespace std;
 
#define N 10
 
//функция принадлежности
double func_mu(double t, double left, double right, double leftMiddle, double rightMiddle) {
    if (t <= left || t >= right)
        return 0;
    else if ((left <= t) && (t <= leftMiddle))
        return (t - left) / (leftMiddle - left);
    else if ((leftMiddle <= t) && (t <= rightMiddle))
        return 1.0;
    else if ((rightMiddle <= t) && (t <= right))
        return (right - t) / (right - rightMiddle);
}
 
double min(int m, int n) {
    return (m < n) ? m : n;
}
 
//дефазиффикация центр тяжести
void deffuzification(double t, double a, double b, double step, double result,
                     double leftMiddle, double rightMiddle) {
    double sum1, sum2, mu;
    for (double i = a; i < b; i = i + step) {
        mu = func_mu(i, a, b, leftMiddle, rightMiddle);
        sum1 = 0;
        sum1 += mu * i;
        sum2 = 0;
        sum2 += mu;
    }
    result = sum1 / sum2;
}
int main() {
    setlocale(LC_ALL, "Russian");
    double a1, b1, leftMiddle1, rightMiddle1;
    double x1, x2;
    double a2, b2, leftMiddle2, rightMiddle2;
    
    cout << "Введите х1:\n";
    cin >> x1;
    cout <<"Введите x2:\n";
    cin >> x2;
 
    // задаем области для функций принадлежности
    cout << "Введите границы области для х1:\n";
    cin >> a1 >> b1;
    cout << "Введите внутренние точки для х1:\n";
    cin >> leftMiddle1 >> rightMiddle1;
 
    cout << "Введите границы области для x2:\n";
    cin >> a2 >> b2;
    cout << "Введите внутренние точки для х2:\n";
    cin >> leftMiddle2 >> rightMiddle2;
 
    //// функция принадлежности для х1
    //double mu_x1;
    //vector<double> vect_mu_x1;
    //for (double i = a1; i <= b1; i += 0.5) {
    //  mu_x1 = func_mu(i, a1, b1, leftMiddle1, rightMiddle1);
    //  vect_mu_x1.push_back(mu_x1);
    //  mu_x1 = 0;
    //}
    //for (int i = 0; i < vect_mu_x1.size(); i++) {
    //  cout << vect_mu_x1[i] << " ";
    //}
    //cout << endl;
 
    //// функция принадлежности для х2
    //double mu_x2;
    //vector<double> vect_mu_x2;
    //for (double i = a2; i <= b2; i += 0.5) {
    //  mu_x2 = func_mu(i, a2, b2, leftMiddle2, rightMiddle2);
    //  vect_mu_x2.push_back(mu_x2);
    //  mu_x2 = 0;
    //}
    //for (int i = 0; i < vect_mu_x2.size(); i++) {
    //  cout << vect_mu_x2[i] << " ";
    //}
    //cout << endl;
 
    double mu_x1, mu_x2;
    mu_x1 = func_mu(x1, a1, b1, leftMiddle1, rightMiddle1);
    mu_x2 = func_mu(x2, a2, b2, leftMiddle2, rightMiddle2);
 
    double mu_y = min(mu_x1, mu_x2);
    cout << mu_y << " ";
    cout << endl;
 
    system("pause");
    return 0;
}