Метод Ньютона для СНУ на Visual C++

[Inna_07]

Привет! Очень нужна помощь. Необходимо написать программу, реализующую метод Ньютона для СНУ.
Программа написана, но в ней 1 ошибка, никак не могу от нее избавиться! Подскажите, пожалуйста, что не так!
Вот текст программы:

Используется синтаксис C++

#include "stdafx.h"
#include <math.h>
#include <conio.h>
// Количество уравнений
const int n = 2;
void GaussSolve (double *A,double *b,double *x);
double f1(double *x);
double f2(double *x);
double df1_dx(double *x); 
double df1_dy(double *x);
double df2_dx(double *x);
double df2_dy(double *x);
double norm (double *x);
double fun(double *x);
int main(int argc, char* argv[])
{
        int i, iter=0;
        double *xk;
        printf ("%s","Reshenie SNY metodom Newton\n");
        fun(xk);
        printf ("%s","Vektor resheniia: [ ");
        for (i=0;i<n;i++)
        {
                printf ("%f ",xk[i]);
        }
        printf ("%s","]\n");
        printf ("Reshenie nadeno za %i iterazii\n",iter);
        return 0;
}
double f1(double *x) 
{
        return x[0]*x[1]+x[1]*x[1]+2;
}
double f2(double *x) 
{
        return x[0]*x[1]*x[1]-3;
}
double df1_dx(double *x) 
{
        return x[1];
}
double df1_dy(double *x) 
{
        return x[0]+2*x[1];
}
double df2_dx(double *x) 
{
        return x[1]*x[1];
}
double df2_dy(double *x) 
{
        return 2*x[0]*x[1];
}
double norm (double *x)
{
        double sum = 0;
        for (int i=0;i<n;i++)
        {
                sum+=x[i]*x[i];
        }
        return sqrtf(sum);
}
double fun(double *x)
{
        int i, iter=0;
        // Точность
        double eps;
        // Матрица
        double **A;
        // Вектор правых частей
        double *b;
        // Вектор решения
        double *xk,*p;
        // начальное приближение
        xk[0]=1;xk[1]=1;
        do
        {
                iter++;
                for (i=0;i<n;i++)
                {
                        x[i] = xk[i];
                }
                // Заполнение матрицы A
                A[0][0]=df1_dx(x); A[0][1]=df1_dy(x);
                A[1][0]=df2_dx(x); A[1][1]=df2_dy(x);
                // Заполнение вектора правых частей
                b[0]=-f1(x); b[1]=-f2(x);
                GaussSolve (A,b,p);
                // Получаем следующее приближение,
                // складывая предыдущее и вновь полученное
                for (i=0;i<n;i++)
                {
                        xk[i] = x[i] + p[i];
                }
        }
        while (fabs(norm (x) - norm(xk))>=eps);
        return xk[i];
}
void GaussSolve (double **A,double *b,double *x)
// Решение СЛУ методом Гаусса 
{
        const double eps=0.0001f;
        double tmpValue;
        int i,j,k,z;
        double dblLeadElement;
        // Прямой ход
        for(i=0; i<n; i++)
        {
                  dblLeadElement=A[i][i];
                  // Находим строку, в которой элемент, стоящий под ведущим - наибольший
                  double tmpMax = dblLeadElement;
                  int tmpMaxNumber = i;
                  for (z=i;z<n;z++)
                  {
                          if (A[z][i]>tmpMax){tmpMax = A[z][i];tmpMaxNumber=z;}
                  }
                  // Меняем местами i-ю строку и строку tmpMaxNumber
                  for (z=i;z<n;z++)
                  {
                          tmpValue = A[i][z];
                          A[i][z] = A[tmpMaxNumber][z];
                          A[tmpMaxNumber][z] = tmpValue;
 
                  }
                  tmpValue = b[i];
                  b[i] = b[tmpMaxNumber];
                  b[tmpMaxNumber] = tmpValue;
                  dblLeadElement = tmpMax;
                  for(j=i; j<n; j++)
                        {
                                A[i][j]/=dblLeadElement;
                        }
                        b[i]/=dblLeadElement;
                  for(k=i+1; k<n; k++)
                        {
                           double dblToDivide=A[k][i]/A[i][i];
                                for(z=i;z<n; z++)
                                {
                                    A[k][z]-=A[i][z]*dblToDivide;
                                }               
                        
                                b[k]-=b[i]*dblToDivide;
                        }
        }
        // Обратный ход
        x[n-1]=b[n-1];
    for(k=n-2; k>=0; k--)
        {
          double sum=b[k];
          for(j=k+1; j<n; j++)
                {
                        sum-=A[k][j]*x[j];
                }
      x[k]=sum;
        }
}

А вот и ошибка!
error C2664: 'GaussSolve' : cannot convert parameter 1 from 'double **' to 'double *'

Очень надеюсь на вашу помощь!!!

[Maslov]

Бросается в глаза следующее:
1. Описание функции GaussSolve в строке 6 не соответствует её определению в строке 99 (лучше убрать все описания функций в начале программы, main поместить в самый низ, а fun -- сразу над ней).
2. Работать всё равно не будет, ибо память под массивы вообще нигде не выделяется.
(Более подробно не смотрел).

[venco]

Inna_07, у вас forward declaration функции GaussSolve:

void GaussSolve (double *A,double *b,double *x);

И определение самой функции:

void GaussSolve (double **A,double *b,double *x)
// Решение СЛУ методом Гаусса
{

не совпадают. Если это единственная ошибка, то достаточно будет исправить forward declaration (добавить звёздочку).
В следующий раз, если пишете про ошибку компиляции, то указывайте и номер строчки, где ошибка.

[Inna_07]

Спасибо большое!!!! :)
ошибка ушла)))
теперь все запускается! только вот все равно не работает(
а нельзя немного подробнее про выделение памяти под массивы, наверное проблема в этом теперь.
просто никогда раньше не писала матрицы и векторы через *, но преподаватель говорит так нужно и все.
до попытки исправления мной программы с использованием *, она работала.
Еще раз спасибо!)

[Circiter]

2Inna_07

Цитата:

а нельзя немного подробнее про выделение памяти под массивы

См. malloc(...) или calloc(...).

[Ed_Em]

Советую почитать "numerical receipes": там можно найти много чего полезного (уже готовые реализации наиболее популярных алгоритмов).

[OlegVY]

Inna_07 в сообщении #323507 писал(а):

а нельзя немного подробнее про выделение памяти под массивы, наверное проблема в этом теперь

С++ не поддерживает массивы как таковые, передача массивов не предусмотрена стандартами. Можно передать указатель на первый элемент, далее все определяет программист. Передать в функцию массив НЕЛЬЗЯ. Или можно, но строго определенного размера.
malloc(...), calloc(...) выделяют область памяти, что с ней делать и как работать - определяет программист.
Почитайте Страуструпа, либо задавайте более конкретные вопросы.

[Zealint]

Для начала я бы посоветовал написать программу со статическими массивами (когда сразу задается размер всех массивов и матриц). Вот, например, такая инструкция

dblLeadElement=A[i][i];

непонятно что делает, когда массив A имеет тип double **. Откуда компилятор знает, что такое A[i][j], если ему непонятно, какую длину имеют массивы A[i]? Это вообще не должно было компилироваться.

Также имейте в виду, что, передавая массив в качестве параметра, передается указатель на нулевой его элемент. Содержимое массива остаётся изменённым после выхода из функции. Если хотите передавать массив как локальную переменную, надо заводить новую структуру данных, в которой будет этот массив и конструктор копирования.

[venco]

Zealint в сообщении #324818 писал(а):

dblLeadElement=A[i][i];

непонятно что делает, когда массив A имеет тип double **. Откуда компилятор знает, что такое A[i][j], если ему непонятно, какую длину имеют массивы A[i]? Это вообще не должно было компилироваться.

Вполне легальная конструкция. A - массив указателей на массивы double. Соответственно, выделять такой массив надо в два этапа - сначала выделяем массив указателей, а потом в каждом элементе выделяем массив double. Кстати, в этим случае можно иметь строки разной длины, например - треугольную матрицу.

[Zealint]

venco в сообщении #324860 писал(а):

Вполне легальная конструкция. A - массив указателей на массивы double. Соответственно, выделять такой массив надо в два этапа - сначала выделяем массив указателей, а потом в каждом элементе выделяем массив double. Кстати, в этим случае можно иметь строки разной длины, например - треугольную матрицу.

Стойте-ка. Вот в данном конкретном случае откуда компилятор знает чему равно sizeof(A[i]), чтобы правильно определить то, где в памяти находится A[i][j]? Ведь автор программы нигде память не выделяет. Если автор задаст матрицу в виде double A[100][100], то, передавая её через double **, теряется информация о том, что каждая строка имеет размер 100*sizeof(double) байт. Я об этом пишу.

А в этом случае (как Вы пишите):

A = new double * [ N ];
for ( int i = 0; i < N; i ++ )
  A [ i ] = new double [ любое число ];

все понятно, здесь каждый указатель уже знает, куда указывает. Мы уже явно присвоили всем своё значение.

Кстати, многие неправильно освобождают память в таких случаях. Надо так:

for ( int i = 0; i < N; i ++ )
  delete [ ] A [ i ];
delete [ ] A;

[venco]

Zealint в сообщении #324910 писал(а):

Стойте-ка. Вот в данном конкретном случае откуда компилятор знает чему равно sizeof(A[i]), чтобы правильно определить то, где в памяти находится A[i][j]?

sizeof(A[i]) == sizeof(double*), и компилятор про это знает.

Zealint в сообщении #324910 писал(а):

Ведь автор программы нигде память не выделяет.

Ну, это проблема приведённой программы, а не конструкции double**.

Zealint в сообщении #324910 писал(а):

Если автор задаст матрицу в виде double A[100][100], то, передавая её через double **, теряется информация о том, что каждая строка имеет размер 100*sizeof(double) байт.

Если автор задаст матрицу в виде double A[100][100], то, передать её через double ** он не сможет ввиду несовместимости типов.

[Zealint]

venco в сообщении #324915 писал(а):

Если автор задаст матрицу в виде double A[100][100], то, передать её через double ** он не сможет ввиду несовместимости типов.

В общем-то, я об этом и говорю, только в другом контексте. Ошибка компиляции будет, так как типы разные, а я как раз и говорю, почему они разные, несмотря на кажущуюся одинаковость. Автору надо либо динамически массив выделять, либо передавать как double A [ ] [100]. Я просто удивился, что это может компилироваться, но теперь разобрался: автор вообще забыл выделить память.

Цитата:

sizeof(A[i]) == sizeof(double*), и компилятор про это знает.

Нет, не знает. Если double A[100][100], то sizeof(A[i]) == 100*sizeof(double). Мы сейчас друг друга запутаем, кажется : ) Короче, я за то, чтобы автор переписал все через статическую память и убрал двойные указатели. Так будет легче понять, что он сам хотел написать.

[venco]

Zealint в сообщении #324951 писал(а):

Цитата:

sizeof(A[i]) == sizeof(double*), и компилятор про это знает.

Нет, не знает. Если double A[100][100], то sizeof(A[i]) == 100*sizeof(double).

Но в программе-то double** A, поэтому sizeof(A[i]) == sizeof(double*).

Zealint в сообщении #324951 писал(а):

Короче, я за то, чтобы автор переписал все через статическую память и убрал двойные указатели. Так будет легче понять, что он сам хотел написать.

Вы, кажется, пропустили вот это:

Inna_07 в сообщении #323507 писал(а):

просто никогда раньше не писала матрицы и векторы через *, но преподаватель говорит так нужно и все.
до попытки исправления мной программы с использованием *, она работала.

[Zealint]

venco в сообщении #324961 писал(а):

Вы, кажется, пропустили вот это:

Inna_07 в сообщении #323507 писал(а):

просто никогда раньше не писала матрицы и векторы через *, но преподаватель говорит так нужно и все.
до попытки исправления мной программы с использованием *, она работала.

Точно, прошу прощения, удаляюсь...

А автору советую узнать, что такое функция malloc или оператор new (а также free и delete). Преподаватель, видимо, хочет, чтобы программа выделяла для работы столько памяти, сколько реально требуется. Напишите правильное выделение памяти, и если после этого не заработает, тогда Вам скажут, где ещё может быть ошибка.