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

//==========================================================
// Name        : equation_newton.cpp
// Author      : Marat
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//==========================================================

#include <iostream>
using namespace std;

#include<math.h>

//Здесь описывается уравнение функции
double Equation (double x)
{
	return (10*pow(x,5)-exp(pow(x,2)));
}

//Здесь производится дифференцирование. Вызов функции
// Equation осуществляется через указатель.
//Определим тип указателя на функцию Equation
//dif - функция дифференцирования
typedef double(*dif)(double);
//Функция расчета производной
double root(dif F, double x)
{
int n=1000000;
double delta=2*x/n;
return ((*F)(x+delta)-(*F)(x))/delta;
}
//Вызов функции дифференцирования
double Derivative(double x)
{	double root(dif F, double x);
	return root(Equation, x);
}

int main() {
	double Equation(double x);
	double Derivative(double x);
	double t;
	alpha: cout<<"\nInput initial value, please ";
	cin>>t;
	gamma: double y=Equation(t);
	double y1=Derivative(t);
	if (fabs(y1)<1.0E-20) goto alpha;
	double t1=t-y/y1;
	if (fabs(t-t1)<fabs(t*1.0E-7)) goto beta;
	t=t1; goto gamma;
	beta: cout<<"\nThe root of equation is "<<(t+t1)/2;
	cout<<"\nFunction value is "<<y<<endl;
	return 0;
}

Input initial value, please 1
The root of equation is 0.694941
Function value is 2.23705e-007

//==========================================================
// Name        : deviding_chorda.cpp
// Author      : Marat
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//==========================================================

#include <iostream>
using namespace std;
#include<math.h>
#include<stdlib.h>

//Здесь задается уравнение
double Equation(double x)
{
	return 0.1*pow(x,5)+pow(x,4)-3*pow(x,3)+2*pow(x,2)-17*x+23;
}
//Определение указателя на функцию Equation
typedef double(*dev)(double);

//Функция решения уравнения методом половинного деления
double devide(dev F, double a,double e)
{
double ep=0.1;//Точность
double h,m,y3;
int n=10;
double y1=(*F)(a);
double y2=(*F)(e);
if (y1*y2<=0) goto alpha;
int i;
gamma: h=(e-a)/n;
for(i=1;i<n-1;i++)
{
	double y9=(*F)(a+i*h);
	if (y9*y1>=0) break;//Выход из цикла
	e=a+i*h;
	goto alpha;
}
n*=10;
if (n<=1000) goto gamma;
cout<<"\nRoots were not founded! ";exit(1);
alpha: //Начало процедуры деления отрезка пополам
y1=(*F)(a);
y2=(*F)(e);
if (fabs(a-e)<fabs(ep)) {return (e+a)/2;}
m=(a+e)/2;
y3=(*F)(m);
if (y3*y1>=0) goto epsilon;
e=m; goto alpha;
epsilon: a=m; goto alpha;
}

//Решение уравнений методом хорд
//(правило пропорциональных частей)
double chorda(dev G, double a,double e)
{
double x;
double x0=a;
double x1=e;
gamma: double y0=(*G)(x0);
double y1=(*G)(x1);
if (fabs(x0-x1)<fabs(x0*1.0E-7))
{
	return (x0+x1)/2;
}
x=x1-(x1-x0)*y1/(y1-y0);
x0=x1;
x1=x;
goto gamma;
}

int main() {
	double a; //Нижний предел
	double e; //Верхний предел
	//Прототип функции половинного деления
	double devide(dev F, double a,double e);
	//Прототип функции решения уравнеия
	//методом хорд
	double chorda(dev G, double a,double e);
	cout<<"\nInput lower level, please, a = ";
	cin>>a;
	cout<<"\nInput upper level, please, e = ";
	cin>>e;
	cout<<"\nRoot made by deviding method is "<<devide(Equation,a,e);
	cout<<"\nRoot made by chords   method is "<<chorda(Equation,a,e)<<endl;
	return 0;
}

Input lower level, please, a = 0
Input upper level, please, e = 2
Root made by deviding method is 1.34375
Root made by chords   method is 1.35508

//==========================================================
// Name        : pointer_array_function.cpp
// Author      : Marat
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//==========================================================

#include <iostream>
using namespace std;
#include<math.h>
#include<stdlib.h>

double function_sin(double x)
{
return -cos(x);
}

double function_cos(double x)
{
return sin(x);
}

double function_tg(double x)
{
return -log(fabs(cos(x)));
}

double function_ctg(double x)
{
return log(fabs(sin(x)));
}

double function_pow_x_2(double x)
{
return pow(x,3)/3;
}

typedef double(*menu)(double);
double root(menu F, double A, double B)
{
double s=(*F)(B)-(*F)(A);
return s;
}

int main() {
	double A;
	double B;
	//Нижний предел интегрирования
	cout<<"\nInput lower integrating level, A = ";
	cin>>A;
	//Верхний предел интегрирования
	cout<<"\nInput upper integrating level, B = ";
	cin>>B;

	cout<<"\nChoice the function to be integrated and type number!";
	cout<<"\n1: sin(x) ";
	cout<<"\n2: cos(x) ";
	cout<<"\n3: tg(x)  ";
	cout<<"\n4: ctg(x) ";
	cout<<"\n5: pow(x,2)"<<endl;

	int number;//Номер выбранной функции
	cin>>number;

	double root(menu,double,double);
	double result;

	switch (number)
		{
		case 1:result=root(function_sin,A,B); break;
		case 2:result=root(function_cos,A,B); break;
		case 3:result=root(function_tg, A,B); break;
		case 4:result=root(function_ctg,A,B); break;
		case 5:result=root(function_pow_x_2,A,B); break;
	default: cout<<"\nThis number is illegal!"<<endl;exit(1);
		}
	cout<<"\nThe answer is "<<result<<endl;
	return 0;
}

Input lower integrating level, A = 3.5
Input upper integrating level, B = 6.7
Choice the function to be integrated and type number!

1: sin(x)
2: cos(x)
3: tg(x)
4: ctg(x)
5: pow(x,2)

5

The answer is 85.9627

void qsort(void base, size_t nelem, size_t width, int (*fcmp)(const void *p1, const void *p2));

//==========================================================
// Name        : sort_ascending_descending.cpp
// Author      : Marat
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//==========================================================

#include <iostream>
using namespace std;
#include<stdlib.h>   //Для функции qsort

//Вызов функции упорядочивания:
//(void *)pc-Адрес начала сортируемой таблицы
//n - Количество элементов сортируемой таблицы
//sizeof(pc[0])- Размер одного элемента
//ascending - Имя функции сравнения (указатель) по возрастанию
//descending - Имя функции сравнения (указатель) по убыванию

//Функция сравнения при сортировке по возрастанию
int ascending (const void *a, const void *b)
{double *pa=(double *)a;
 double *pb=(double *)b;
 int c;
 *pa<*pb?c=-1:c=1;
 if(*pa==*pb){c=0;}
 return c;
}

//Функция сравнения при сортировке по убыванию
int descending (const void *a, const void *b)
{double *pa=(double *)a;
 double *pb=(double *)b;
 int c;
 *pa>*pb?c=-1:c=1;
 if(*pa==*pb){c=0;}
 return c;
}

void print(int n, double a[])
{
	for (int i=0;i<n;i++)
{
	cout<<"\na["<<i+1<<"]="<<a[i];
}
cout<<"\n"<<endl;
}

int main() {
	//Зададим вещественный массив
	double pc[]={2.64, 8.16, 0.23, -6.54, 3.25};

	//Определим количество его элементов
	int n=sizeof(pc)/sizeof(pc[0]) ;//Размер таблицы:

	//Выведем на экран неотсортированный массив

	cout<<"\nBefor sorting:";

	void print(int n, double a[]);
	print(n, pc);

	//Отсортируем массив по возрастанию
	qsort((void *)pc, n, sizeof(pc[0]), ascending);

	//Распечатаем массив после сортировки по возрастанию
	cout<<"\nAfter sorting by ascending:";
	print(n, pc);

	//Отсортируем массив по убыванию
	cout<<"\nAfter sorting by descending:";
	qsort((void *)pc, n, sizeof(pc[0]), descending);

	//Расчпечатаем массив после сортировки по убыванию
	print(n, pc);
	return 0;
}

Before sorting:

a[1]=2.64
a[2]=8.16
a[3]=0.23
a[4]=-6.54
a[5]=3.25

After sorting by ascending:
a[1]=-6.54
a[2]=0.23
a[3]=2.64
a[4]=3.25
a[5]=8.16

After sorting by descending:
a[1]=8.16
a[2]=3.25
a[3]=2.64
a[4]=0.23
a[5]=-6.54