Метод Гаусса - C++ - Ответ 4239707

#ifndef SYSTEMEQUATION_H
#define SYSTEMEQUATION_H

#include <math.h>
#include <iostream>

//Родительский класс. Система из трех линейных уравнений с тремя неизвестными x , y , z .
//Данные – коэффициенты, решение системы.
//Методы – ввод данных, вывод данных, нахождение решения методом Крамера.

using namespace std;

class SystemEquation
{
protected:
    //коофициенты
    int x,  y,  z;
    int x1, y1, z1;
    int x2, y2, z2;

    //переменные
    double resultX,  resultY,  resultZ;

    //результат каждого уравнения
    double result;
    double result1;
    double result2;

protected:
    double multiplication(const int &_x, const int &_y, const int &_z)
    {
        return _x * _y * _z;
    }

public:
    SystemEquation(const int &_x  = 0, const int &_y  = 0, const int &_z  = 0, const double &_result  = 0,
                   const int &_x1 = 0, const int &_y1 = 0, const int &_z1 = 0, const double &_result1 = 0,
                   const int &_x2 = 0, const int &_y2 = 0, const int &_z2 = 0, const double &_result2 = 0)
    {
        setEquation (_x,   _y,  _z, _result );
        setEquation1(_x1, _y1, _z1, _result1);
        setEquation2(_x2, _y2, _z2, _result2);
    }

    void setEquation(const int &_x, const int &_y, const int &_z, const double &_result)
    {
        x = _x;
        y = _y;
        z = _z;
        result = _result;
    }

    void setEquation1(const int &_x, const int &_y, const int &_z, const double &_result)
    {
        x1 = _x;
        y1 = _y;
        z1 = _z;
        result1 = _result;
    }

    void setEquation2(const int &_x, const int &_y, const int &_z, const double &_result)
    {
        x2 = _x;
        y2 = _y;
        z2 = _z;
        result2 = _result;
    }

    //возврат значений переменных
    double getResultX()
    {
        return resultX;
    }

    double getResultY()
    {
        return resultY;
    }

    double getResultZ()
    {
        return resultZ;
    }

    double calculationDeterminant()
    {
        return (multiplication(x, y1, z2) + multiplication(x2, y, z1) + multiplication(x1, y2, z)) -
                (multiplication(x2, y1, z) + multiplication(z2, x1, y) + multiplication(x, z1, y2));
    }

    double calculationDeterminant(const int &_x , const int &_y , const int &_z ,
                                          const int &_x1, const int &_y1, const int &_z1,
                                          const int &_x2, const int &_y2, const int &_z2)
    {
        return (multiplication(_x, _y1, _z2) + multiplication(_x2, _y, _z1) + multiplication(_x1, _y2, _z)) -
                (multiplication(_x2, _y1, _z) + multiplication(_z2, _x1, _y) + multiplication(_x, _z1, _y2));
    }

    virtual void calculation()
    {
        double determinant = calculationDeterminant();
        if(fabs(determinant) < 0.000001) //при методе Крамера определитель != 0
            return;

        double determinantX = calculationDeterminant(result, y, z,
                                                     result1, y1, z1,
                                                     result2, y2, z2);
        resultX = determinantX / determinant;

        double determinantY = calculationDeterminant(x, result, z,
                                                     x1, result1, z1,
                                                     x2, result2, z2);
        resultY = determinantY / determinant;

        double determinantZ = calculationDeterminant(x, y, result,
                                                     x1, y1, result1,
                                                     x2, y2, result2);
        resultZ = determinantZ / determinant;
    }

    void inputToStream()
    {
        cout << "x: " << resultX << endl;
        cout << "y: " << resultY << endl;
        cout << "z: " << resultZ << endl << endl;
    }

};

#endif // SYSTEMEQUATION_H

#ifndef SYSTEMEQUATION1_H
#define SYSTEMEQUATION1_H

#include "systemTriangleEquation.h"


//Методы – нахождение решения
//(делением коэффициентов в каждом уравнении).

class SystemEquation1:public SystemEquation
{
public:
    SystemEquation1(const int &_x  = 0, const int &_y  = 0, const int &_z  = 0, const double &_result  = 0,
                    const int &_x1 = 0, const int &_y1 = 0, const int &_z1 = 0, const double &_result1 = 0,
                    const int &_x2 = 0, const int &_y2 = 0, const int &_z2 = 0, const double &_result2 = 0):
        SystemEquation(_x, _y, _z, _result,
                       _x1, _y1, _z1, _result1,
                       _x2, _y2, _z2, _result2){}

    void setEquation(const int &_x, const int &_y, const int &_z, const double &_result)
    {
        this->SystemEquation::setEquation(_x, _y, _z, _result);
    }

    void setEquation1(const int &_x, const int &_y, const int &_z, const double &_result)
    {
        SystemEquation::setEquation1(_x, _y, _z, _result);
    }

    void setEquation2(const int &_x, const int &_y, const int &_z, const double &_result)
    {
        SystemEquation::setEquation2(_x, _y, _z, _result);
    }


    void calculation()
    {
        double _x = x, _y = y, _z = z;
        double _x1 = x1, _y1 = y1, _z1 = z1;
        double _x2 = x2, _y2 = y2, _z2 = z2;
        double factor;

        //сократим х

        factor = _x1 / _x;
        _x1 = 0;
        _y1 = _y1 - _y * factor;
        _z1 = _z1 - _z * factor;
        result1 = result1  - factor * result;

        factor = _x2 / _x;
        _x2 = 0;
        _y2 = _y2 - _y * factor;
        _z2 = _z2 - factor * _z;
        result2 = result2 - factor * result;


        //сократим у
        factor = _y2 / _y1;

        _y2 = 0;
        _z2 = _z2 - factor * _z1;
        result2 = result2 - factor * result1;


        //привели к треугольному виду

        resultZ = result2 / _z2;
        resultY = (result1 - _z1 * resultZ) / _y1;
        resultX = (result - _y * resultY - _z * resultZ ) / _x;
    }
};

#endif // SYSTEMEQUATION1_H