Реализация метода покоординатного спуска

// SLU_GAUS.cpp: определяет точку входа для консольного приложения.
//подключение заголовков
#include "stdafx.h"
#include "iostream"
#include "stdio.h"
 
//подключение пространства имен
using namespace std;
 
//функция решения СЛУ методом Гаусса
bool gauss(double **a, int size, double *x)
{
    try
    {
        for (int k = 0; k < size; k++)//перебираем уравнения
        {
            for (int i = size; i >= 0; i--)//перебираем индексы уравнения от последнего до первого
                a[k][i] = a[k][i] / a[k][k];//делим индексы уравнения К на К индекс этого уравнения, т.е. на диагональный индекс
            for (int i = k + 1; i < size; i++)//перебираем уравнения от К+1 уравнения
                for (int j = size; j >= k; j--)// перебираем индексы уравнения от последнего до К, т.е. до диагонального
                    a[i][j] = a[i][j] - a[k][j] * a[i][k];
        }
        for (int k = size - 1; k >= 0; k--)//перебираем от предпоследнего уравнения до первого
        {
            double m = a[k][size];
            for (int i = size - 1; i > k; i--)//перебираем индексы от предпоследнего до К
                m = m - a[k][i] * x[i];
            x[k] = m;
            //cout<<"X "<<(k + 1)<<" = "<<m<<endl;
        }
    }
    catch (char *msg)
    {
        cout << "ОШИБКА ИЛИ РЕШЕНИЙ НЕТ" << endl;
        cout << msg << endl;
        return false;
    }
    return true;
}
 
 
//Функция получения матрицы коэффициентов  СЛУ и соотв. свободных членов
bool getMatrixCoef(double **a, int size)
{
    try
    {
        for (int i = 0; i < size; i++)
        {
            for (int j = 0; j < size; j++)
            {
                cout << "Введите " << j + 1 << " коэффициент " << i + 1 << " уравнения: ";
                char vrem[256];
                cin >> vrem;
                while (!atof(vrem))
                {
                    cout << "Введена не цифра, повторите ввод:";
                    cin >> vrem;
                }
                a[i][j] = atof(vrem);
            }
            cout << "Введите  свободный член " << i + 1 << " уравнения: ";
            char vrem[256];
 
 
            cin >> vrem;
            while (!atof(vrem))
            {
                cout << "Введена не цифра, повторите ввод:";
                cin >> vrem;
            }
            a[i][size] = atof(vrem);
        }
    }
 
    catch (char *msg)
    {
        cout << "ВОЗНИКЛА ОШИБКА" << endl;
        cout << msg << endl;
        return false;
    }
    return true;
}
//Процедура вывода матрицы коэффициентов на экран
void showMatrixCoef(double **a, int size)
{
    cout << "Матрица коэффициентов СЛУ и соотв. свободные члены:" << endl;
    for (int i = 0; i < size; i++)
    {
        for (int j = 0; j < size + 1; j++)
            cout << a[i][j] << " ";
        cout << endl;
    }
}
//Процедура вывода решения СЛУ на экран
void showResult(double *x, int size)
{
    cout << "Решение СЛУ:" << endl;
    for (int i = 0; i < size; i++)
        cout << "X" << i + 1 << " = " << x[i] << endl;
}
 
void menu()
{
    cout << "1. Расчет" << endl;
    cout << "2. Информация о программе" << endl;
    cout << "3. Выход из программы" << endl;
}
 
void raschet()
{
    int size;
    char vrem[256];
    cin >> vrem;
    while (!atof(vrem))
    {
        cout << "Введена не цифра, повторите ввод:";
        cin >> vrem;
    }
    size = atof(vrem);
    //получаем количество уровнений введенное пользователем
    //определяем матрицу коэффициентов
    double **a = new double*[size];
    for (int i = 0; i < size; i++)
        a[i] = new double[size + 1];
    //определяем массив решений СЛУ
    double *x = new double[size];
    if (getMatrixCoef(a, size))//если получение прошло без ошибок
    {
        cout << endl << endl << endl;//делаем отступ пустыми строками
        showMatrixCoef(a, size);//выводим матрицу коеф. и свободные члены
        if (gauss(a, size, x))//если система имеет решение
            showResult(x, size);//выводим решение
    }
    cout << endl;
    system("pause");//выполенение системной команды "пауза"
}
 
//Основное тело программы
int _tmain(int argc, _TCHAR* argv[])
{
    setlocale(LC_CTYPE, "Russian");//подключаем русскую кодировку
    int xor=0;
    
    menu();
    while (xor != 3)
    {
        cin >> xor;
        switch (xor)
        {
        case 1:
            cout << "введите размерность матрицы" << endl;
            raschet();
            menu();
            break;
        case 2:
            cout << "Программа для того того" << endl;
            menu();
            break;
        case 3:
            exit(0);
        }
    }
 
    return 0;
}

// CoordinateDescent.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include <math.h>
#include <iostream>
#include <iomanip>
 
typedef double (*func_ptr)(double*);  
 
const int var_count = 3;
 
double function(double* variables);
double golden_section(func_ptr f, double* vars, int var_index, double eps, double a, double b, int max_steps_count);
void descent_method(func_ptr f, double* vars, double eps, int max_steps_count);
 
int menu();
int submenu();
void input_data(double* eps, int* max_steps, double* vars); 
void about();
 
int _tmain(int argc, _TCHAR* argv[])
{
    setlocale(LC_ALL,"RUSSIAN");
 
    double eps = 0.0;
    int max_steps_count = 0;
    double variables[var_count] = {0.0};
 
    while(int choice = menu())
    {
        switch(choice){
        case 1:
            input_data(&eps, &max_steps_count, variables);
            while(int subchoice = submenu())
            {
                switch(subchoice){
                case 1: 
                    input_data(&eps, &max_steps_count, variables);
                    break;
                case 2:
                    descent_method(function, variables, eps, max_steps_count);
                    break;
                default:
                    std::cout << "Неверный выбор. Попробуйте снова." << std::endl;
                    break;
                }
            }
            break;
        case 2:
            about();
            break;
        default:
            std::cout << "Неверный выбор. Попробуйте снова." << std::endl;
            break;
        }
    }
    
    return 0;
}
 
 
double function(double* variables)
{
    
    return (pow(variables[0], 2) + pow((variables[1] - 50), 2) + pow((variables[2] + 30), 2)) - 100;
}
 
 
double golden_section(func_ptr f, double* vars, int var_index, double eps, double a, double b, int max_steps_count)
{
    double res = 0.0;
    double phi = (1 + sqrt(5.0)) / 2.0;
    double A = 0.0f, B = 0.0f;
    double x1 = a + phi * (b - a), x2 = b - phi * (b - a);
 
    int step = 0;
 
    while((b - a > eps))
    {
        x1 = b - ((b - a) / phi); 
        vars[var_index] = x1;
        A = f(vars);
        x2 = a + ((b - a) / phi);       
        vars[var_index] = x2;
        B = f(vars);
        if(A > B)
            a = x1;
        else
            b = x2;
 
        step++;
        if(step > max_steps_count)
            break;
    }
 
    res = (a + b) / 2;
    return res;
}
 
void descent_method(func_ptr f, double* vars, double eps, int max_steps_count)
{
    double B = f(vars), A = 0;
    bool was_counted = false;
    int stpes_ellapsed = 0;
    double delta = 0.0;
    for(int i = 0; i < max_steps_count; i++){
        A = B;
 
        for(int var_index = 0; var_index < var_count; var_index++)
            vars[var_index] = golden_section(f, vars, var_index, eps, -5000, 5000, max_steps_count);
            
        B = f(vars);
 
        delta = fabs(A - B);
 
        if(delta <= eps)
        {
            stpes_ellapsed = i + 1;
            was_counted = true;
            break;
        }
    }
 
    std::cout << "Результат поиска минимума функции " << "exp(x1 + x2 + x3) / (x1 * x2^2 * x3^3)" << std::endl;
    
    if(!was_counted)
        std::cout << "За максимально указанное количество шагов ( " << max_steps_count << " ) минимум не был посчитан." << std::endl;
    else {
        std::cout << "Количество итераций: " << stpes_ellapsed << std::endl;
        std::cout << "Погрешность: " << delta << std::endl;
    }
    
    std::cout << "Точка: X(";
    for(int i = 0; i < var_count; i++){
        std::cout << vars[i] << ", ";
        
    }
 
    std::cout << "\b\b" << ")" << std::endl;
    std::cout << "Значение фукнции f(X): " << std::setprecision(10) << f(vars) << std::endl;
}
 
int menu()
{
    int choice = 0;
 
    std::cout << "*************************" << std::endl;
    std::cout << "1) Ввод данных..." << std::endl;
    std::cout << "2) О программе" << std::endl;
    std::cout << "0) Выход" << std::endl;
    std::cout << ": ";
    std::cin >> choice;
    std::cout << std::endl;
 
    return choice;
}
 
int submenu()
{
    int choice = 0;
 
    std::cout << "*************************" << std::endl;
    std::cout << "1) Ввод данных..." << std::endl;
    std::cout << "2) Найти минимум функции" << std::endl;
    std::cout << "0) Назад" << std::endl;
    std::cout << ": ";
    std::cin >> choice;
    std::cout << std::endl;
 
    return choice;
}
 
void input_data(double* eps, int* max_steps, double* vars)
{
    std::cout << "Введите значение погрешности: ";
    std::cin >> *eps;
 
    double step = 0;
    std::cout << "Введите величину шага: ";
    std::cin >> step;
 
    std::cout << "Введите максимальное количество шагов: ";
    std::cin >> *max_steps;
    for(int i = 0; i < var_count; i++){
        std::cout << "Введите начальное значение " << i+1 << " координаты: ";
        std::cin >> vars[i];
    }
    std::cout << std::endl;
}
 
void about()
{
    std::cout << "Программа для поиска минимума функции методом координатного спуска." << std::endl;
}