решение СЛАУ с переменными, заданными рациональными дробями

#include <iostream>
#include <fstream>
#include <iomanip>
#include <conio.h>
#include <cmath>
using namespace std;
//Cама программа (для целых чисел)
void inp(double**A, double*B, double**C, double **R, int m, int n);
double determ(double**A, int n);
int rang_mat(double**A, int m, int n);
void Kramer(double**A, double*B, double**C, double*d, int n);
void Gauss(double**A, double*B, double**C, double*X, int n);
int l_min(int a, int b);
void obshee(double**A, double*B, int m, int n);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    setlocale(LC_ALL, "Russian");
    int n, m;
    cout << "Введите количество уравнений СЛАУ:\n";
    cin >> m;
    cout << "\nВведите количество неизвестных СЛАУ:\n";
    cin >> n;
    double**A = new double*[m];
    for (int i = 0; i<m; i++)
        A[i] = new double[n];
    double *B = new double[m];
    char q;
    double**C = new double*[m];
    for (int i = 0; i<m; i++)
        C[i] = new double[n];
    double *d = new double[n];
    double *X = new double[n];
    double *M = new double[n];
    double **R = new double*[m];
    for (int i = 0; i<m; i++)
        R[i] = new double[n + 1];
 
    inp(A, B, C, R, m, n);
    int count = 0;
 
    if (m == n)
    {
        cout << "Определитель матрицы равен " << determ(A, n) << "\n";
        for (int i = 0; i<n; i++)
            if (B[i] == 0)
                count++;
        if (determ(A, n) != 0)
        {
            if (count == m)
                for (int i = 0; i<n; i++)
                    cout << "x" << i + 1 << " = " << 0 << "\n";
            for (int i = 0; i<n; i++)
                if (A[i][i] == 0)
                {
                    cout << "Эту СЛАУ невозможно решить методом Гаусса(на диагонали есть 0).";
                    return 0;
                }
            int p;
            cout << "Для того чтобы решить эту систему методом Крамера введите 1, методом Гаусса - 2\n ";
            cin >> p;
            if (p == 1)
                Kramer(A, B, C, d, n);
            if (p == 2)
                Gauss(A, B, C, X, n);
 
        }
        else {
            cout << "Ранг матрицы СЛАУ:" << rang_mat(A, m, n) << "\n";
            cout << "Ранг расширенной матрицы СЛАУ:" << rang_mat(R, m, n + 1) << "\n";
            if (rang_mat(A, m, n) != rang_mat(R, m, n + 1))
                cout << "СЛАУ не имеет решений";
            if (rang_mat(A, m, n) == rang_mat(R, m, n + 1))
            {
                if (rang_mat(A, m, n) == n)
                    cout << "СЛАУ имеет одно решение";
                if (rang_mat(A, m, n)<n)
                {
                    cout << "СЛАУ имеет множество решений ";
                    obshee(A, B, m, n);
                }
            }
        }
        cout << endl;
    }
    else
    {
        cout << "Ранг матрицы равен:" << rang_mat(A, m, n) << rang_mat(R, m, n + 1);
        if (rang_mat(A, m, n) != rang_mat(R, m, n + 1))
            cout << "СЛАУ уравнений не имеет решений ";
        if (rang_mat(A, m, n) == rang_mat(R, m, n + 1))
        {
            if (rang_mat(A, m, n) == n)
                cout << "СЛАУ имеет одно решение";
            if (rang_mat(A, m, n)<n)
                cout << "СЛАУ имеет множество решений ";
        }
        if (count == m)
            cout << "в том числе и 0 \n\n";
        return 0;
    }
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void inp(double**A, double*B, double**C, double**R, int m, int n)
{
    int i, j;
    {
        cout << "Введите коефициенты при неизвестных СЛАУ: \n";
        for (i = 0; i<m; i++)
            for (j = 0; j<n; j++)
                cin >> A[i][j];
    }
 
    for (i = 0; i<m; i++)
        for (j = 0; j<n; j++)
            C[i][j] = A[i][j];
 
    cout << ("Введите столбец свободных членов: \n");
    for (i = 0; i<m; i++)
    {
        cin >> B[i];
    }
 
    for (i = 0; i<m; i++)//Расширенная матрица СЛАУ
        for (j = 0; j<n + 1; j++)
        {
            R[i][j] = A[i][j];
            R[i][n] = B[i];
        }
    cout << "\n";
 
    cout << "Cистема уравнений: \n\n";
    for (int i = 0; i<m; i++)
    {
        for (int j = 0; j<n; j++)
        {
            if (A[i][j]<0) cout << "(" << A[i][j] << ")" << "x" << j + 1;
            else cout << A[i][j] << "x" << j + 1 << " ";
            if (j != (n - 1)) cout << " + ";
        }
        cout << " = " << B[i] << "\n";
    }
 
    cout << ("\n Матрица СЛАУ: \n");
    for (i = 0; i<m; i++)
    {
        for (j = 0; j < n; j++)
            cout << A[i][j] << "\t";
        cout << "\n";
    }
 
    cout << "\n Столбец свободных членов: \n";
    for (i = 0; i<m; i++)
    {
        cout << B[i] << "\t";
        cout << "\n";
    }
    cout << "Расширенная матрица СЛАУ: \n\n";
    for (int i = 0; i<m; i++)
    {
        for (int j = 0; j<n + 1; j++)
            cout << R[i][j] << "\t";
        cout << "\n";
    }
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int mypow(int n){
    int y = 1;
    for (int z = 1; z <= n; z++){
        y *= -1;
    }
    return y;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
double determ(double** A, int n)
{
    int i, j;
    double det = 0;
    double** D;
    if (n == 1)
    {
        det = A[0][0];
    }
    else if (n == 2)
    {
        det = A[0][0] * A[1][1] - A[0][1] * A[1][0];
    }
    else
    {
        D = new double*[n - 1];
        for (i = 0; i<n; i++)
        {
            for (j = 0; j<n - 1; j++)
            {
                if (j<i)
                    D[j] = A[j];
                else
                    D[j] = A[j + 1];
            }
            det = det + mypow(n)*determ(D, n - 1)*A[i][n - 1];
        }
        delete[] D;
    }
    return det;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Kramer(double**A, double*B, double**C, double*d, int n)
{
    int i, j;
    for (int i = 0; i<n; i++)
        for (int j = 0; j<n; j++)
            A[i][j] = C[i][j];
    for (j = 0; j<n; j++)
    {
        cout << "\nЗамена в матрице СЛАУ " << j + 1 << " столбца на столбец свободных членов\n";
        for (i = 0; i<n; i++)
            A[i][j] = B[i];
        for (int i = 0; i<n; i++)
        {
            for (int j = 0; j<n; j++)
                cout << A[i][j] << "\t";
            cout << endl;
        }
        cout << "Определитель равен -  " << determ(A, n) << "\n";
        d[j] = determ(A, n);
        for (int i = 0; i<n; i++)
            for (int j = 0; j<n; j++)
                A[i][j] = C[i][j];
    }
    for (int i = 0; i<n; i++)
        cout << "x" << i + 1 << " = " << d[i] / determ(A, n) << "\n";
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Gauss(double**A, double*B, double**C, double*X, int n)
{
    int i, j, k; double kf;
    for (int i = 0; i<n; i++)
        for (int j = 0; j<n; j++)
            A[i][j] = C[i][j];
    double s = 0;
    for (i = 0; i<n - 1; i++)
        for (k = i + 1; k<n; k++)
        {
            kf = A[k][i] / A[i][i];
            A[k][i] = 0;
            for (j = i + 1; j<n; j++)
            {
                A[k][j] = A[k][j] - kf*A[i][j];
            }    B[k] = B[k] - kf*B[i];
        }
    cout << "\nМатрица преобразованная до треугольной: \n";
    for (i = 0; i<n; i++)
    {
        for (j = 0; j<n; j++)
            cout << A[i][j] << '\t';
        cout << endl;
    }
    cout << "\nПреобразованный столбец свободных членов: \n";
    for (i = 0; i<n; i++)
    {
        cout << B[i] << '\t';
        cout << endl;
    }
    for (int m = n - 1; m >= 0; m--)
    {
        double sum = 0;
 
        for (int i = n - 1; i > m; i--){
            sum += X[i] * A[m][i];
        }
        X[m] = (B[m] - sum) / A[m][m];
    }
    for (int i = 0; i<n; i++)
        cout << "x" << i + 1 << " = " << X[i] << "\n";
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int rang_mat(double**A, int m, int n)
{
    int r = 0;
    int q = 1;
 
    while (q <= l_min(m, n))
    {
        double **B = new double*[q]; //новaя матрица 
        for (int w = 0; w<q; w++) B[w] = new double[q];
 
        for (int a = 0; a<(m - (q - 1)); a++)
        {
            for (int b = 0; b<(n - (q - 1)); b++)
            {
                for (int c = 0; c<q; c++)
                {
                    for (int d = 0; d<q; d++)
                    {
                        B[c][d] = A[a + c][b + d];
                    }
                }
 
                if (!(determ(B, q) == 0))
                {
                    r = q;
                }
            }
        }
        q++;
    }
    return r;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int l_min(int a, int b)
{
    if (a >= b) return b;
    else return a;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void obshee(double**A, double*B, int m, int n)
{
    int l = m - rang_mat(A, m, n);
    for (int i = 0; i<l; i++)
    {
        cout << "\n";
        for (int j = 0; j<n; j++)
        {
            cout << A[i][j] << "x" << j + 1;
            if (j != (n - 1)) cout << " + ";
        }
        cout << " = " << B[i] << "\n";
    }
}

//Ввод дробей
void input(int **nom, int **denom, int m, int n, int*B, int **R);
 
int main()
{
    setlocale(LC_ALL, "Russian");
    int n, m;
    cout << "Введите количество уравнений СЛАУ:\n";
    cin >> m;
    cout << "\nВведите количество неизвестных СЛАУ:\n";
    cin >> n;
    //int **nom = new int *[m*n]; //динамический массив для числителя
    //int **denom = new int *[m*n]; //для знаменателя
 
    int**nom = new int*[m];
    for (int i = 0; i<m; i++)
        nom[i] = new int[n];
 
    int**denom = new int*[m];
    for (int i = 0; i<m; i++)
        denom[i] = new int[n];
 
    int *B = new int[m];
 
    int **R = new int*[m];
    for (int i = 0; i<m; i++)
        R[i] = new int[n + 2];
 
    input(nom, denom, m, n, B,R);
}
 
void input(int **nom, int **denom, int m, int n, int*B, int **R)
    {
        int i,j;  char ch;
        {
            cout << "\nBведите коефициенты при неизвестных СЛАУ: \n";
            for ( i = 0; i < m; i++)
            {
                /*nom[i] = new int[n];
                denom[i] = new int[n];*/
                for (int j = 0; j < n; j++)
                {
                    cin >> nom[i][j]; //числитель
                    cin >> ch;  // дробь
                    cin >> denom[i][j];  //знаменатель
                }
            }
        }
        cout << ("Введите столбец свободных членов: \n");
        for (i = 0; i < m; i++)
        {
            cin >> B[i];
        }
 
        cout << "Cистема уравнений: \n\n";
        for (int i = 0; i<m; i++)
        {
            for (int j = 0; j<n; j++)
            {
                if (nom[i][j]<0 || denom[i][j]<0) cout << "(" << nom[i][j] << ch << denom[i][j] << ")" << "x" << j + 1;
                else cout << nom[i][j] << ch << denom[i][j] << "x" << j + 1 << " ";
                if (j != (n - 1)) cout << " + ";
            }
            cout << " = " << B[i] << "\n";
        }
 
 
        cout << "Mатрица системы: \n" << endl;
        for ( i = 0; i < m; i++)
        {
            for (j = 0; j < n; j++)
                cout << nom[i][j] << ch << denom[i][j] << "\t";
                cout << endl;
        }
 
        cout << "\n Столбец свободных членов: \n";
        for (i = 0; i<m; i++)
        {
            cout << B[i] << "\t";
            cout << "\n";
        }
    }