Решение нелинейных алгебраических уравнений

}

 

double find(double infinum, double supremum, double epsilon)

{

    while (fabs(supremum - infinum) > epsilon)

    {

        infinum = supremum - (supremum - infinum) * func(supremum) / (func(

                supremum) - func(infinum));

        supremum = infinum - (infinum - supremum) * func(infinum) / (func(

                infinum) - func(supremum));

    }

 

    return supremum;

}

 

int main()

{

    double a = -5, b = 5;

    std::cout << find(a, b, 0.0001) << std::endl;

    return 0;

}

 

2. методом итераций

#include <iostream>

#include <iomanip>

#include <conio.h>

#include <math.h>

using namespace std;

 

double f1(double c)//новая функция фи

{

double z=7/(2*c+6);

return(pow(10, z)); 

}

 

int main()

{

int n=0;

double a,b,E,x,z,g;

 

cout<<"vvedite a"<<endl;

cin>>a;

cout<<"vvedite b"<<endl;

cin>>b;

cout<<"vvedite E"<<endl;

cin>>E;

 

 

x=(a+b)/2;

do

{

z=x;

x=f1(x);

n++;

}

while ((fabs(x-z))>=E);

 

cout<<endl;

cout<<"x="<<x<<endl;

cout<<"n="<<n<<endl;

getch ();

}

 

3. методом Горнера (уточнение корней).

#include <iostream>

#include <string>

#include <sstream>

#include <cstdlib>

#include <list>

 

typedef std::list<long> CoefList;

typedef CoefList RootList;

 

/* getRoots() возвращает список корней многочлена.

   В строке inputStr задаются коэффициенты многочлена - целые числа,

   разделенные пробельными  символами */

RootList getRoots(const std::string& inputStr);

// а сюда передается список  коэффициентов от самого страшего  к младшему

RootList getRoots(const CoefList& coefList);

// возвращает остаток от деления  многочлена с коэффициентами coefList на (x - x0)

long getRest(const CoefList& coefList, const long& x0);

 

int main()

{

   std::string coefStr;

   RootList rootList;

   int n = 0;

 

   std::cout << "введите коэфициенты при неизвестных: ";

   std::getline(std::cin, coefStr);

 

   rootList = getRoots(coefStr);

 

   if (rootList.empty())

   {

      std::cout << "Целых  корней нет." << std::endl;

   }

 

   n = 0;

   for (RootList::const_iterator i = rootList.begin(); i != rootList.end(); ++i)

   {

      n++;

      std::cout << "x" << n << " = " << *i << std::endl;

   }

 

   return 0;

}

 

RootList getRoots(const std::string& inputStr)

{

   std::istringstream strStream(inputStr);

   CoefList coefList;

   long tmp;

 

   while (strStream >> tmp)

   {

      coefList.push_back(tmp);

   }

 

   // избавляемся от лидирующих нулей

   while (!coefList.empty() && coefList.front() == 0)

      coefList.pop_front();

 

   return getRoots(coefList);

}

 

RootList getRoots(const CoefList& coefList)

{

   RootList rootsList; // список корней

   long a0 = abs(coefList.back()); // модуль свободного члена

   const long MAX_A0_DIVISOR = a0 / 2; // максимальный делитель свободного члена

 

   if (coefList.empty())

      // если пустое  уравнение

      return RootList();

 

   for (long a0_divisor = 1; a0_divisor <= MAX_A0_DIVISOR; ++a0_divisor)

   {

      if (a0 % a0_divisor != 0)

         // если  не делится нацело, то это не  корень

         continue;

 

      // проверка корней

      if (getRest(coefList, a0_divisor) == 0)

         rootsList.push_back(a0_divisor);

 

      if (getRest(coefList, -a0_divisor) == 0)

         rootsList.push_back(-a0_divisor);

   }

 

   // проверка на корень  самого коэффициента свободного  члена

 

   if (getRest(coefList, a0) == 0)

      rootsList.push_back(a0);

 

   if (getRest(coefList, -a0) == 0)

      rootsList.push_back(-a0);

 

   return rootsList;

}

 

long getRest(const CoefList& coefList, const long& x0)

{

   long rest = 0;

 

   for (CoefList::const_iterator i = coefList.begin(); i != coefList.end(); ++i)

   {

      rest = x0 * rest + (*i);

   }

 

   return rest;

}

 

Сеансы работы программы 

 

Заключение

При выполнении данной работы были рассмотрены теоретически и практически основные характеристики методов простой хорд, итерации и методом Горнера для решения систем нелинейных уравнений.

Результаты наших исследований таковы:

- метод простой итерации проще  в реализации, чем метод Ньютона  – он не требует, в частности, расчета матрицы Якоби на каждом шаге; 
- методы сходятся за небольшое количество итераций, если начальное приближение взято близко к точному решению

- при отдалении начального приближения  от точного решения, скорость  сходимости и число итераций  методов отличаются на порядки, метод хорт на сходится за гораздо меньшее время и число итераций;

- при очень сильном отдалении  от начального решения применение  метода простой итерации нецелесообразно  ввиду очень больших вычислительных  затрат;

- при уменьшении допустимой  ошибки вычислительные затраты метода простой итерации значительно больше, чем метода Ньютона, но не так велики, как при увеличении начальных приближений на тот же порядок – то есть изменение точности имеет меньшее влияние на параметры сходимости, чем изменение начального приближения;

Метод хорда для решения систем двух нелинейных уравнений оказался более эффективным, чем метод простой итерации по всем рассматриваемым параметрам.

 

Список источников

1. Демидович Б.П. и Марон И.А. Основы вычислительной математики. — Наука, 1970. — С. 664.
2. Бахвалов, Жидков, Кобельков. Численные методы. — Наука.
3. А.А.Самарский, А.В.Гулин. Численные методы. Москва «Наука», 1989.
4. Н.Н.Калиткин. Численные методы. Москва «Наука», 1978.
5. Герберт Шилдт. Полный справочник по C++ = C++: The Complete Reference. — 4-е изд. — М.: Вильямс, 2011