РГР Ананьев3

МИНИСТЕРСТВО НАУКИ И ВЫСШЕГО ОБРАЗОВАНИЯ РФ
ФЕДЕРАЛЬНОЕ ГОСУДАРСТВЕННОЕ БЮДЖЕТНОЕ ОБРАЗОВАТЕЛЬНОЕ

УЧРЕЖДЕНИЕ ВЫСШЕГО ОБРАЗОВАНИЯ
«МОСКОВСКИЙ АВИАЦИОННЫЙ ИНСТИТУТ»
(национальный исследовательский университет)»
Институт № 8 «Информационные технологии и прикладная математика»

Кафедра 806 «Вычислительная математика и программирование»
Вычислительная математика
Отчет по расчётно-графическим работам
Вариант 5
Выполнил студент группы М3О-319Бк-18:

Ананьев В.В
Проверили:
Сеченых П.А.
Кринецкий О.Е.
Москва 2020
Содержание отчёта
1. Метод Гаусса.......................................................................................................................................................4
Блок схема:..........................................................................................................................................................4
Код программы:..................................................................................................................................................5
Вывод программы:.............................................................................................................................................6
2. Метод прогонки:.................................................................................................................................................7
Блок схема:..........................................................................................................................................................8
Код программы:..................................................................................................................................................8
Вывод программы:...........................................................................................................................................10
3. Итерационные методы(СЛАУ):.....................................................................................................................11
Блок схемы:.......................................................................................................................................................12
Код программы:................................................................................................................................................14
Вывод программы:...........................................................................................................................................14
4. Метод вращений:..............................................................................................................................................21
Блок схема:........................................................................................................................................................22
Код программы:................................................................................................................................................22
Вывод программы:...........................................................................................................................................22
5. Нелинейные уравнения:..................................................................................................................................29
Блок схема:........................................................................................................................................................29
Графики:............................................................................................................................................................32
Код программы:................................................................................................................................................33
Вывод программы:...........................................................................................................................................33
6. Нелинейные системы:......................................................................................................................................34
Блок схема:........................................................................................................................................................36
График:..............................................................................................................................................................37
Код программы:................................................................................................................................................37
Вывод программы:...........................................................................................................................................41
7. Полиномы Лагранжа и Ньютона:.................................................................................................................43
Блок схема:........................................................................................................................................................43
Графики:............................................................................................................................................................44
Код программы:................................................................................................................................................44
Вывод программы:...........................................................................................................................................44
8. Сплайн-интерполяция:....................................................................................................................................46
Блок схема:........................................................................................................................................................47
Графики:............................................................................................................................................................48
Код программы:................................................................................................................................................48
2
Вывод программы:...........................................................................................................................................50
9. Метод наименьших квадратов:......................................................................................................................51
Блок схема:........................................................................................................................................................52
Графики:............................................................................................................................................................52
Код программы:................................................................................................................................................53
Вывод программы:...........................................................................................................................................57
10. Численное дифференцирование:..................................................................................................................57
Блок схема:........................................................................................................................................................58
Код программы:................................................................................................................................................58
Вывод программы:...........................................................................................................................................58
11. Численное интегрирование:.........................................................................................................................60
Блок схема:........................................................................................................................................................61
Код программы:................................................................................................................................................61
Вывод программы:...........................................................................................................................................64
12. Задача Коши(ДУ1п):......................................................................................................................................65
Блок схема:........................................................................................................................................................66
Графики:............................................................................................................................................................66
Код программы:................................................................................................................................................67
Вывод программы:...........................................................................................................................................70
13. Краевая задача:...............................................................................................................................................71
Блок схема:........................................................................................................................................................71
Графики:............................................................................................................................................................72
Код программы:................................................................................................................................................72
Вывод программы:...........................................................................................................................................72
3
1. Метод Гаусса
Решить СЛАУ методом Гаусса.
Блок схема:
4
Код программы:
package com.company;
import java.util.Scanner;
import static java.lang.Math.round;
public class Main {
public static void main(String[] args) {

int systemSize = 4;
double Temp;
double[][] a = {{3, -8, 1, -7},

{6, 4, 8, 5},
{-1, 1, -9, -3},
{-6, 6, 9, -4}};
double[] b = {96, -13, -54, 82};
//Вывод изменённой системы
System.out.println("Расширенная матрица: ");

System.out.println();
for (int i = 0; i < systemSize; i++) {

for (int j = 0; j < systemSize; j++) {
System.out.print(" " + a[i][j]);
}
System.out.print("| " + b[i]);
}

Temp = a[j][j];
for (int m = 0; m < systemSize; m++) {
a[j][m] /= Temp;
}
b[j] /= Temp;
for (int i = j + 1; i < systemSize; i++) {
Temp = -1 * a[i][j];
for (int k = 0; k < systemSize; k++) {
a[i][k] += a[j][k] * Temp;
}
b[i] += b[j] * Temp;
}
}
System.out.println("Закончился прямой ход метода Гаусса: ");


System.out.print(" " + a[i][j]);
}
System.out.print(" = " + b[i]);
5
}
//Вывод
for (int i = systemSize - 2; i >= 0; i--) {

for (int j = systemSize - 1; j > i; j--) {
a[i][j] *= b[j];
b[i] -= a[i][j];
}
for (int i = 0; i < systemSize; i++){

System.out.println("X" + (i+1) + " = " + round(b[i]));
}
}
}
Вывод программы:
6
2. Метод прогонки:
Решить СЛАУ методом прогонки.
7
import static java.lang.Math.round;
public class Main {
double[][] sys = { {8, 4, 0, 0, 0},
{-5, 22, 8, 0, 0},
{0, -5, -11, 1, 0},
{0, 0, -9, -15, 1},
8
{0, 0, 0, 1, 7} };
double[] d = { 48, 125, -43, 18, -23 };
Double[] x = new Double[5];

Double[] a = new Double[5];
Double[] b = new Double[5];
Double[] c = new Double[5];
double[] P = new double[6];

double[] Q = new double[6];
/*double[] x = { 0 };
double[] a = { 0 };
double[] b = { 0 };
double[] c = { 0 };
//double P[5 + 1] = { 0 }, Q[5 + 1] = { 0 };

double[] P = { 0 };
double[] Q = { 0 };*/
for (int i = 0; i < 5; i++) {

if (i == 0) {
a[i] = 0.0;
b[i] = sys[i][i];
c[i] = sys[i][i + 1];
}
if (i == 5 - 1) {
a[i] = sys[i][i - 1];
b[i] = sys[i][i];
c[i] = 0.0;
}
if (i != 0 && i != 5 - 1) {
a[i] = sys[i][i - 1];
b[i] = sys[i][i];
c[i] = sys[i][i + 1];
}
}
for (int i = 0; i < 5; i++) {

System.out.println("a" + (i+1) + " = "+a[i]);
System.out.println("b" + (i+1) + " = "+b[i]);
System.out.println("c" + (i+1) + " = "+c[i]);
System.out.println("d" + (i+1) + " = "+d[i]);
for (int i = 1; i < 5 + 1; i++) {

P[i] = (-1 * c[i - 1]) / (b[i - 1] + a[i - 1] * P[i - 1]);
System.out.println("P" + i + " = "+P[i]);
Q[i] = (d[i - 1] - a[i - 1] * Q[i - 1]) / (b[i - 1] + a[i - 1] * P[i -
1]);
System.out.println("Q" + i + " = " + Q[i]);
}
9
x[5 - 1] = Q[5];
for (int i = 5 - 2; i >= 0; i--) {

x[i] = Q[i + 1] + P[i + 1] * x[i + 1];
}
for (int i = 0; i < 5; i++) {

System.out.println("X" + (i+1) + " = "+round(x[i]));
}
}
}
10
3. Итерационные методы(СЛАУ):
Решить СЛАУ с точностью 0.01, используя метод простых итераций и метод Зейделя.
Проанализировать количество итераций, необходимое для достижения заданной точности.
11
Блок схемы:
Рис. 1 Метод простых итераций
12
Рис. 2 Метод Зейделя
13
import static java.lang.Math.*;
public class Main {

//Метод простых итераций
System.out.println("Метод простых итераций");

int systemSize = 4;
double EPS_CONST = 0.01;
double Temp = 0.0, Norm, ESP, delta = Integer.MAX_VALUE;
int n = 1; //Номер итерации
double[] Norma_1 = new double[systemSize];
double[] Norma_2 = new double[systemSize];
double[] Norma_b = new double[systemSize];
double[] B = new double[systemSize];
double[][] Iterations = new double[50][systemSize];
double[][] a = { {20, 5, 7, 1},

{-1, 13, 0, -7},
{4, -6, 17, 5},
{-9, 8, 4, -25} };
double[] b = { -117, -1, 49, -21 };

//Перестановка
B[i] = -1 * b[i];;
b[i] = -1 * a[i][i];
a[i][i] = 0;
}
//Привидение к виду

a[i][j] /= b[i];
}
B[i] /= b[i];
b[i] /= b[i];
}
//Вывод системы
System.out.println("Система");

System.out.print(b[i] + "*X" + (i+1) + " = ");
System.out.print(" " + ceil(a[i][j] * 100000)/100000 + "* X"
+ (j+1) + " + ");
}
System.out.print(" " + ceil(B[i] * 100000)/100000);
}
//Вычисление нормы
14
Norma_1[i] += abs(a[i][j]);
Norma_2[i] += abs(a[j][i]);
Norma_b[i] = abs(B[i]);
}
}
//Поиск максимума среди норм
double max_1 = Norma_1[0];

double max_2 = Norma_2[0];
double max_b = Norma_b[0];
if (Norma_1[i] > max_1) {

max_1 = Norma_1[i];
}

max_2 = Norma_2[i];
}
if (Norma_b[i] > max_b) {

max_b = Norma_b[i];
}
}
Norm = min(max_1, max_2); //Минимальная из норм

System.out.println("Норма В: " + Norm);
System.out.println("Норма бэтта: " + max_b);
if (Norm < 1) //Так как ||B|| < 1, то итерационный процесс будет сходиться к
точному решению системы
{
System.out.println(" ");

System.out.print(" " + "x" + (i+1));
}
System.out.println(" " + "ESP" + " " +

"Delta");
//За начальный вектор
System.out.print("Итерация №1: ");

Iterations[0][i] = B[i];
System.out.print(" " + ceil(Iterations[0][i] * 100000) /
100000);
ESP = pow(Norm, 1) / (1 - Norm) * max_b; //Вычисление погрешности
15
while (delta > EPS_CONST) {
ESP = pow(Norm, n) / (1 - Norm) * max_b; //Вычисление погрешности
System.out.print("Итерация N" + (n+1) + ": ");

Temp += a[i][j] * Iterations[n - 1][j];
}
Iterations[n][i] += (Temp + B[i]);

System.out.print(" " + ceil(Iterations[n][i] *
100000)/100000);
Temp = 0;
if (n != 0) {
delta = max(max(abs(Iterations[n][0] - Iterations[n - 1][0]),
abs(Iterations[n][1] - Iterations[n - 1][1])), abs(Iterations[n][2] - Iterations[n -
1][2]));
}
n++;
System.out.print(" " + ceil(ESP * 100000)/100000);
System.out.print(" " + ceil(delta * 100000)/100000);
System.out.print("\nКоличество требуемых итераций: ");

System.out.print(n);
System.out.print("\n\n");
System.out.print("___________________________________________________________________
________\n");
System.out.print("Метод Зейделя:\n");
//Метод Зейделя
Temp = 0;
n = 1; //Номер итерации
int Zeidel;
double[][] A = { {20, 5, 7, 1},

{-1, 13, 0, -7},
{4, -6, 17, 5},
{-9, 8, 4, -25} };
double[] C = { -117, -1, 49, -21 };
//Обнуляем все элементы из предыдущего метода
for (int j = 0; j < 50; j++) {

B[i] = 0;
Iterations[j][i] = 0;
Norma_1[i] = 0;
Norma_2[i] = 0;
16
Norma_b[i] = 0;
}
}
//Перестановка

B[i] = -1 * C[i];
C[i] = -1 * A[i][i];
A[i][i] = 0;
}
//Привидение к виду

A[i][j] /= C[i];
}
B[i] /= C[i];
C[i] /= C[i];
}
System.out.print("Система:\n\n");
//Вывод системы

System.out.print(C[i]);
System.out.print("*X");
System.out.print(i + 1);
System.out.print(" = ");
System.out.print(" " + ceil(A[i][j] * 10000)/10000 + " * X" +
(j+1) + " + ");
}
System.out.print(" " + ceil(B[i]*10000)/10000);
}
//Вычисление нормы

Norma_1[i] += abs(a[i][j]);
Norma_2[i] += abs(a[j][i]);
Norma_b[i] = abs(B[i]);
}
//Поиск максимума среди норм
max_1 = Norma_1[0];
max_2 = Norma_2[0];
max_b = Norma_b[0];
for (int i = 1; i < systemSize; i++)
17
max_1 = Norma_1[i];
}

max_2 = Norma_2[i];
}
if (Norma_b[i] > max_b) {

max_b = Norma_b[i];
}
Norm = min(max_1, max_2); //Минимальная из норм
System.out.print("Норма B: ");
System.out.print(Norm);
System.out.print("\n");
System.out.print("Норма бэтта: ");
System.out.print(max_b);
if (Norm < 1) //Так как ||B|| < 1, то итерационный процесс будет сходиться к
точному решению системы
{
System.out.print(" ");
for (int i = 0; i < systemSize; i++)
{
System.out.printf("%15s", "x");
System.out.printf("%s", i + 1);
}
System.out.printf("%17s", "ESP");
System.out.printf("%17s", "Delta");
//Начальный вектор
System.out.printf("%s", "Итерация N1: ");

Iterations[0][i] = B[i];
System.out.printf("%15s", ceil(Iterations[0][i] * 10000000)/10000000
+ " ");
ESP = pow(Norm, 1) / (1 - Norm) * max_b;
delta = Integer.MAX_VALUE;
while (delta > EPS_CONST) {

ESP = pow(Norm, n) / (1 - Norm) * max_b; //Вычисление погрешности
System.out.print("Итерация N");
System.out.print(n + 1);
System.out.print(": ");
18
if (j >= i) Zeidel = n - 1;
else Zeidel = n;
Temp += A[i][j] * Iterations[Zeidel][j];
}
Iterations[n][i] += (Temp + B[i]);
System.out.printf("%15f", Iterations[n][i]);
Temp = 0;
}
if (n != 0) {
delta = max(max(abs(Iterations[n][0] - Iterations[n - 1][0]),
abs(Iterations[n][1] - Iterations[n - 1][1])), abs(Iterations[n][2] - Iterations[n -
1][2]));
}
n++;
System.out.printf("%15f", ESP);
System.out.printf("%15f", delta);
}
}
System.out.print("\nКоличество требуемых итераций: ");

}
}
19
20
4. Метод вращений:
Используя метод вращений, найти собственные значения и собственные векторы
симметрических матриц с точностью 0.05.
21
#include "stdio.h"
#include <iostream>
#include "math.h"
const double PI = 3.1415926536;
bool isSimmetrial(double** coefficients, int numberOfEquation) {

bool result = true;
int i, j;
for (i = 0; i < numberOfEquation; i++) {
for (j = i + 1; j < numberOfEquation; j++) {
if (coefficients[i][j] != coefficients[j][i]) {
22
result = false;
break;
}
}
if (!result) { break; }
}
return result;
}
int wrachenie(double** coefficients, int numberOfEquation,
double** solution, double precision) {
int result = 1;
int i, j, k;
int maxI, maxJ;
double max, fi;
double** matricaPoworota;
matricaPoworota = new double* [numberOfEquation];
matricaPoworota[i] = new double[numberOfEquation];
}
double** temp;
temp = new double* [numberOfEquation];
temp[i] = new double[numberOfEquation];
}
double fault = 0.0;
fault = fault + coefficients[i][j] * coefficients[i][j];
}
}
fault = sqrt(2 * fault);
while (fault > precision) {
max = 0.0;
if (coefficients[i][j] > 0 && coefficients[i][j] > max) {
max = coefficients[i][j];
maxI = i;
maxJ = j;
}
else if (coefficients[i][j] < 0 && -coefficients[i][j] > max) {
max = -coefficients[i][j];
maxI = i;
maxJ = j;
}
}
}
for (j = 0; j < numberOfEquation; j++) {
matricaPoworota[i][j] = 0;
}
matricaPoworota[i][i] = 1;
}
if (coefficients[maxI][maxI] == coefficients[maxJ][maxJ]) {
matricaPoworota[maxI][maxI] = matricaPoworota[maxJ][maxJ] =
matricaPoworota[maxJ][maxI] = sqrt(2.0) / 2.0;
matricaPoworota[maxI][maxJ] = -sqrt(2.0) / 2.0;
}
else {
fi = 0.5 * atan((2.0 * coefficients[maxI][maxJ]) /
(coefficients[maxI][maxI] - coefficients[maxJ][maxJ]));
matricaPoworota[maxI][maxI] = matricaPoworota[maxJ][maxJ] = cos(fi);
matricaPoworota[maxI][maxJ] = -sin(fi);
matricaPoworota[maxJ][maxI] = sin(fi);
}
23
temp[i][j] = 0.0;
}
}
for (k = 0; k < numberOfEquation; k++) {
temp[i][j] = temp[i][j] + matricaPoworota[k][i] *
coefficients[k][j];
}
}
}
coefficients[i][j] = 0.0;
}
}
coefficients[i][j] = coefficients[i][j] +
temp[i][k] * matricaPoworota[k][j];
}
}
}
fault = 0.0;
fault = fault + coefficients[i][j] * coefficients[i][j];
}
}
fault = sqrt(2 * fault);
temp[i][j] = 0.0;
}
}
temp[i][j] = temp[i][j] + solution[i][k] * matricaPoworota[k]
[j];
}
}
}
solution[i][j] = temp[i][j];
}
}
result++;
}
return result;
}
using namespace std;
void main()
{
setlocale(LC_ALL, "rus");
int i, j;
int size = 3;
double** coefficients, ** solution, precision;
24
coefficients = new double* [size];
solution = new double* [size];
for (i = 0; i < size; i++) {
coefficients[i] = new double[size];
solution[i] = new double[size];
}
for (i = 0; i < size; i++) {
for (j = 0; j < size; j++) {
solution[i][j] = 0;
}
solution[i][i] = 1;
}
coefficients[0][0] = 0;
coefficients[0][1] = -7;
precision = 0.05;
if (!isSimmetrial(coefficients, size)) {
cout << "Матрица не симметричная";
}
else {
int steps = wrachenie(coefficients, size, solution, precision);
for (i = 0; i < size; i++) {
cout << "\nСобственный вектор лямбда " << i + 1 << ":\n";
for (j = 0; j < size; j++) {
cout << solution[j][i] << "\n";
}
}
cout << "\nСобственные значения:\n";
for (i = 0; i < size; i++) {
cout << coefficients[i][i] << "\n";
}
cout << "\nОбщее число шагов: " << steps;
}
cout << "\nPress \"Enter\" to continue..." << endl;
getchar();
}
25
26
5. Нелинейные уравнения:
Найти один из корней уравнения f(x)=0, используя метод простой итерации, метод секущих
и метод Ньютона, с точностью 0.001. Построить графики функций f(x), f’(x), f”(x) а также ϕ(x) и
ϕ’(x). Начальное приближение и границы отрезка определить графически.
Рис. 1 Метод Ньютона
27
Рис. 2 Метод простых итераций
28
Рис. 3 Метод секущих
29
Графики:
30
public class Main {

public static double EPS = 0.001;
static double function(double x) { return cos(x) + 0.25 * x - 0.5; }
static double function_derivative(double x) { return -sin(x) + 0.25; }
//метод простых итераций

double a = -1.0;
double b = -0.7;
double x, x0;
//Метод Ньютона
x = a;
while (abs(function(x)) > EPS)
x = x - (function(x) / function_derivative(x));
System.out.print("Метод Ньютона: ");
System.out.print(x);
//Метод простых итераций
a = 1;
b = 2;
x = acos(0.5 - 0.25*x);
while (abs(function(x)) > EPS)
x = acos(0.5 - 0.25*x);
System.out.print("Метод простых итераций: ");
a = -1.0;
b = -0.7;
//Метод секущих
x0 = a;
x = b;
while (abs(function(x)) > EPS) {
x = x - ((function(x) * (x - x0)) / (function(x) - function(x0)));
}
System.out.print("Метод хорд и секущих: ");
}
}
31
Для метода простых итераций ищем корень на отрезке [1;2]
Для метода Ньютона и хорд и секущих ищем корень на отрезке [-1;-0.7]
Нахождение начального приближения для метода секущих: f(-1)*f(-0.7) =
-0.2*0.089 <0 следовательно с = ( -1 * f(-0.7) + 0.7 * f(-1) ) / ( f(-0.7) - f(-1) )
Нахождение начального приближения для метода Ньютона:
f (-1) * f ”(-1) = -0.2 * (-cos(-1)) >0 следовательно с = -1
32
6. Нелинейные системы:
Решить систему нелинейных уравнений с точностью 0.0001, используя метод Ньютона,
метод простой итерации и метод Зейделя. Построить графики функций. Начальное приближение
определить графически.
Вариант Значение параметра a Система уравнений
5 2
33
34
График:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace RGR6
{
public partial class Graphics : Form
{
double x;
public Graphics()
{
InitializeComponent();
for (double x = 0; x < 1; x += 0.001)
{
this.x = Math.Round(x * 1000) / 1000;
chart1.Series[0].Points.AddXY(F2(this.x), this.x);
}
for (double y = -1; y < 3; y += 0.001)
{
this.x= Math.Round(y * 1000) / 1000;
chart1.Series[1].Points.AddXY(this.x, F1(this.x));
}
Form1 form = new Form1();
form.Show();
double F1(double y)
{
return Math.Cos(y) + 1;
35
}
double F2(double x)
{
return Math.Log10(x + 1) + 2;
}
private void chart1_Click(object sender, EventArgs e)

{
}
}
}
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Xml.Linq;
using System.Globalization;
namespace RGR6
{
public partial class Form1 : Form
{
const int SIZE = 2;
double[][] J =new double[SIZE][];
double EPS_CONST = 0.0001;
int tab = 15;
public Form1()
{
InitializeComponent();
for (int i = 0; i < SIZE; i++)
J[i] = new double[SIZE];
Newton();
richTextBox1.AppendText("\n----------------------------------------------------------------------
---------------------\n");
Iter();
richTextBox1.AppendText("\n----------------------------------------------------------------------
---------------------\n");
Zeidel();
}
double F1(double x, double y)

{
return x - Math.Cos(y) - 1;
}
double F2(double x, double y)

{
return y - Math.Log10(x+1) - 2;
}
double F11(double y)
{
return Math.Cos(y)+1;
36
}
double F22(double x)
{
return Math.Log10(x + 1) + 2;
}
double DF1_dx()
{
return 1;
}
double DF1_dy(double y)
{
return -Math.Sin(y);
}
double DF2_dx(double x)
{
return -1/((x+1)*Math.Log(10));
}
double DF2_dy()
{
return 1;
}
void Newton()
{
richTextBox1.AppendText("Метод Ньютона:\n");
int iter = 0;
double xo, xn, yo, yn, def;
xo = xn = 0.8;
yo = yn = 2;
double[] vs = new double[SIZE];
double[] tt = new double[SIZE];
richTextBox1.AppendText(" i".PadLeft(2) + "x1(n)".PadLeft(tab + 2) + "x1(n-
1)".PadLeft(tab + 3) + "x2(n)".PadLeft(tab + 1)
+ "x2(n-1)".PadLeft(tab + 3) + "\n");
while (true)
{
J[0][0] = DF2_dy();
J[0][1] = (-1) * DF2_dx(xo);
J[1][0] = (-1) * DF1_dy(yo);
J[1][1] = DF1_dx();
def = DF1_dx() * DF2_dy() - DF2_dx(xo) * DF1_dy(yo);
vs[0] = F1(xo, yo);
vs[1] = F2(xo, yo);
{
tt[i] = 0;
for (int j = 0; j < SIZE; j++)
tt[i] += vs[j] * J[j][i];
tt[i] /= def;
}
xn = xo - tt[0];
yn = yo - tt[1];
richTextBox1.AppendText((iter + 1).ToString().PadLeft(2) + " " +
(xo).ToString("0.00000", CultureInfo.InvariantCulture).PadLeft(tab) +
(xn).ToString("0.00000", CultureInfo.InvariantCulture).PadLeft(tab) +
(yo).ToString("0.00000", CultureInfo.InvariantCulture).PadLeft(tab) +
(yn).ToString("0.00000", CultureInfo.InvariantCulture).PadLeft(tab) + "\n");
if (iter!=0 && Math.Abs(xn - xo)<EPS_CONST && Math.Abs(yn - yo) < EPS_CONST)
break;
xo = xn;
37
yo = yn;
iter++;
}
richTextBox1.AppendText($"Кол-во итераций = {iter + 1}");
}
void Iter()
{
richTextBox1.AppendText("Метод простых итераций:\n");
int iter = 0;
double xo, xn, yo, yn;
xo = xn = 0.8;
yo = yn = 2;
+ "x2(n-1)".PadLeft(tab + 3) + "\n");
while (true)
{
xn = F11(yo);
yn = F22(xo);
if (iter != 0 && Math.Abs(xn - xo) < EPS_CONST && Math.Abs(yn - yo) < EPS_CONST)
break;
xo = xn;
yo = yn;
iter++;
}
}
void Zeidel()
{
richTextBox1.AppendText("Метод Зейделя:\n");
int iter = 0;
double xo, xn, yo, yn;
xo = xn = 0.8;
yo = yn = 2;
+ "x2(n-1)".PadLeft(tab + 3) + "\n");
while (true)
{
xn = F11(yo);
yn = F22(xn);
if (iter != 0 && Math.Abs(xn - xo) < EPS_CONST && Math.Abs(yn - yo) < EPS_CONST)
break;
xo = xn;
yo = yn;
iter++;
}
}
}
}
38
Метод Ньютона
Метод Ньютона:
i x1(n) x1(n-1) x2(n) x2(n-1)
1 0.80000 0.82046 2.00000 2.26021
2 0.82046 0.26089 2.26021 2.12669
3 0.26089 0.52850 2.12669 2.19285
4 0.52850 0.37483 2.19285 2.14060
5 0.37483 0.48888 2.14060 2.17428
6 0.48888 0.41313 2.17428 2.15076
7 0.41313 0.46480 2.15076 2.16606
8 0.46480 0.43065 2.16606 2.15565
9 0.43065 0.45364 2.15565 2.16251
10 0.45364 0.43839 2.16251 2.15790
11 0.43839 0.44859 2.15790 2.16096
12 0.44859 0.44181 2.16096 2.15891
13 0.44181 0.44634 2.15891 2.16027
14 0.44634 0.44332 2.16027 2.15936
15 0.44332 0.44533 2.15936 2.15997
16 0.44533 0.44399 2.15997 2.15956
17 0.44399 0.44489 2.15956 2.15983
18 0.44489 0.44429 2.15983 2.15965
19 0.44429 0.44469 2.15965 2.15977
20 0.44469 0.44442 2.15977 2.15969
21 0.44442 0.44460 2.15969 2.15975
22 0.44460 0.44448 2.15975 2.15971
23 0.44448 0.44456 2.15971 2.15974
Кол-во итераций = 23
-------------------------------------------------------------------------------------------
Метод простых итераций:
i x1(n) x1(n-1) x2(n) x2(n-1)
1 0.80000 0.58385 2.00000 2.25527
2 0.58385 0.36773 2.25527 2.19971
3 0.36773 0.41173 2.19971 2.13600
4 0.41173 0.46441 2.13600 2.14975
5 0.46441 0.45285 2.14975 2.16566
6 0.45285 0.43960 2.16566 2.16222
7 0.43960 0.44246 2.16222 2.15824
8 0.44246 0.44576 2.15824 2.15910
9 0.44576 0.44505 2.15910 2.16010
10 0.44505 0.44422 2.16010 2.15988
11 0.44422 0.44440 2.15988 2.15963
12 0.44440 0.44461 2.15963 2.15969
13 0.44461 0.44456 2.15969 2.15975
39
-------------------------------------------------------------------------------------------
Метод Зейделя:
i x1(n) x1(n-1) x2(n) x2(n-1)
1 0.80000 0.58385 2.00000 2.19971
2 0.58385 0.41173 2.19971 2.14975
3 0.41173 0.45285 2.14975 2.16222
4 0.45285 0.44246 2.16222 2.15910
5 0.44246 0.44505 2.15910 2.15988
6 0.44505 0.44440 2.15988 2.15969
7 0.44440 0.44456 2.15969 2.15974
8 0.44456 0.44452 2.15974 2.15972
40
7. Полиномы Лагранжа и Ньютона:
Используя таблицу значений Yi функции y  f(x) , вычисленных в точках Xi , i  0 ,..., 3
построить интерполяционные полиномы Лагранжа и Ньютона, проходящие через точки Xi , Yi} .
Привести полиномы к каноническому виду и вычислить значение погрешности интерполяции в
точке X*. Построить графики.
41
Графики:
public class Main {

Double X = 0.8;
Double X1 = 0.2;
Double X2 = 0.6;
Double X3 = 1.0;
Double X4 = 1.4;
System.out.print("Таблица значений функции в точках:\n");

System.out.print("Xi: ");
System.out.print(X1);
System.out.printf("%23s", X2 + " ");
System.out.printf("%23s", X3+ " ");
System.out.printf("%20s", X4+ " ");
System.out.printf("%20s", X+ " ");
System.out.printf("%s", "\n");
System.out.printf("%s", "Yi: ");
System.out.printf("%s", function(X1) + " ");
System.out.printf("%9s", function(X2) + " ");
42
System.out.printf("%25s", function(X) + " ");
System.out.printf("%s", "\n\n");
double L1 = 0;
double L2 = 0;
//Полином Лагранжа
L1 += function(X1) * ((X - X2) * (X - X3) * (X - X4)) / ((X1 - X2) * (X1 -
X3) * (X1 - X4));
X3) * (X2 - X4));
X2) * (X3 - X4));
X2) * (X4 - X3));
System.out.print("Полином Лагранжа L1 = ");

System.out.print(L1);
System.out.print("Погрешность: ");
System.out.print(Math.abs(function(X) - L1));
//Полином Ньютона
L2 += function(X1) + function1(X1, X2, function(X1), function(X2)) * (X - X1)
+
function2(X1, X2, X3, function(X1), function(X2), function(X3)) * (X
- X1)*(X - X2) +
function3(X1, X2, X3, X4, function(X1), function(X2), function(X3),
function(X4)) * (X - X1)*(X - X2)*(X - X3);
System.out.print("\nПолином Ньютона L2 = ");
System.out.print(L2);
System.out.print("Погрешность: ");
System.out.print(Math.abs(function(X) - L2));
System.out.print("Полином: y = 1.07665 x^3 - 3.7748 x^2 + 5.20651 x - 2.50836

\n\n" );
static double function(double x) {

return log(x);
}
static double function1(double x1, double x2, double y1, double y2) {
return (y2 - y1) / (x2 - x1);
}
static double function2(double x1, double x2, double x3, double y1, double y2,
double y3) {
return ((function1(x2, x3, y2, y3) - function1(x1, x2, y1, y2)) / (x3 - x1));
}
static double function3(double x1, double x2, double x3, double x4, double y1,
double y2, double y3, double y4) {
return ((function2(x2, x3, x4, y2, y3, y4) - function2(x1, x2, x3, y1, y2,
y3)) / (x4 - x1));
}
43
44
8. Сплайн-интерполяция:
Построить кубический сплайн для функции, заданной в узлах интерполяции, предполагая, что
сплайн имеет нулевую кривизну при x  x0 и x  x4. Вычислить значение функции в точке x  X*.
Построить график.
45
Графики:
import static java.lang.Math.ceil;

import static java.lang.Math.pow;
public class Main {

int SIZE = 5;
int i, Cut = 0;
double X = 0.8; //Заданное значение
double[] x = { 0.1, 0.5, 0.9, 1.3, 1.7 }; //Таблица
double[] y = { -2.3026, -0.69315, -0.10536, 0.26236, 0.53063 }; //Таблица
double[] h = new double[SIZE]; //Шаг
double[] Y = new double[SIZE]; //Замена правой части
double[] m = new double[SIZE];
double[] Q = new double[SIZE]; //Прогоночные коэффициенты
double[] P = new double[SIZE]; //Прогоночные коэффициенты
//Вычисление шага h
for (i = 1; i < SIZE; i++)
{
h[i] = x[i] - x[i - 1]; //Вычисляем шаги
}
//Вычисляем Y, P, Q
46
for (i = 1; i < SIZE - 1; i++)
{
Y[i] = ((y[i + 1] - y[i]) / h[i + 1]) - ((y[i] - y[i - 1]) / h[i]);
P[i + 1] = (-1 * h[i + 1]) / (2 * (h[i] + h[i + 1]) + P[i] * h[i]);
Q[i + 1] = (6 * Y[i] - h[i] * Q[i]) / (2 * (h[i] + h[i + 1]) + P[i] *
h[i]);
}
//Вычисляем m
for (i = SIZE - 1; i > 1; i--)
m[i - 1] = P[i] * m[i] + Q[i];
//Вывод всех значений

System.out.print("i = ");
for (i = 0; i < SIZE; i++)
{
System.out.print(i + " ");
}
System.out.printf("%13s",
"\n______________________________________________________________\n\n");
System.out.printf("%13s", "h[i] = ");

Vivod(h);
System.out.printf("%13s", "Y[i] = ");
Vivod(Y);
System.out.printf("%13s", "P[i] = ");
Vivod(P);
System.out.printf("%13s", "Q[i] = ");
Vivod(Q);
System.out.printf("%13s", "m[i] = ");
Vivod(m);
System.out.printf("%13s", "Кубический сплайн: ");

System.out.printf("%13s", "\n");
//Ищем отрезок который содержит X*

for (i = 0; i < SIZE - 1; i++)
if (X > x[i] && X < x[i + 1])
Cut = i + 1;
System.out.print("Искомое значение лежит в ");

System.out.print(Cut);
System.out.print(" отрезке (i = ");
System.out.print(Cut);
System.out.print(") \n\n");
System.out.print("Кубический многочлен: S");

System.out.print(Cut + 1);
System.out.print("(X) = 4.326838727678571*x^3 -
11.359924386160714*x^2+10.839842661830357*x - 3.8139450753348214");
double S = (m[Cut] * pow((X - x[Cut - 1]), 3) / (6 * h[Cut])) +

(m[Cut - 1] * pow((x[Cut] - X), 3) / (6 * h[Cut])) +
((y[Cut] - (m[Cut] * pow(h[Cut], 2) / 6)) * ((X - x[Cut - 1]) /
h[Cut])) +
(((y[Cut - 1] - (m[Cut - 1] * pow(h[Cut], 2) / 6))) * ((x[Cut] - X) /
h[Cut]));
System.out.print("Значение функции в точке x = ");

System.out.print(X);
System.out.print(": S");
System.out.print(Cut + 1);
47
System.out.print("(");
System.out.print(") = ");
System.out.print(S);
static void Vivod(double[] a)

{
int SIZE = 5;

{
System.out.print(ceil(a[i]*1000)/100+ " ");
}
System.out.printf("%13s",
"\n______________________________________________________________\n\n");
48
9. Метод наименьших квадратов:
Для таблично заданной функции путем решения нормальной системы МНК найти
приближающие многочлены a) 1-ой и б) 2-ой степени. Для каждого из приближающих
многочленов вычислить сумму квадратов ошибок. Построить графики приближаемой функции и
приближающих многочленов.
49
Графики:
50
import static java.lang.Math.pow;
public class Main {

int z1 = 2;
int z2 = 3;
int n = 6; //Размер системы
//int i, j;
double Temp;
double error = 0;
char[] abc = { 'a', 'b', 'c' };
double[] x = { 0.1, 0.5, 0.9, 1.3, 1.7, 2.1 };

double[] y = { -2.3026, -0.69315, -0.10536, 0.26236, 0.53063, 0.74194};
double[][] system = new double[3][3];

double[] b = new double[3];
//Пункт 1(a)
System.out.print("1) Приближенный многочлен первой степени:\n\n");
//Считаем левую часть системы
for (int j = 0; j < z1; j++)
for (int i = 0; i < z1; i++)
{
int p = 3 - i - j - 1;
if (p == 0)
system[i][j] = n;
else
system[i][j] = Sum(x, p);
}
//Считаем правую часть системы
for (int i = 0; i < z1; i++)
{
b[z1 - i - 1] = Sum1(x, y, i);
51
}
System.out.print("Полученная система: \n");
//Вывод полученной системы
for (int i = 0; i < z1; i++)
{
for (int j = 0; j < z1; j++)
{
System.out.printf("%8s", system[i][j]);
}
System.out.print(" | ");
System.out.print(b[i]);
}
//Решаем систему методом Гауса

//Прямой ход методом Гаусса
for (int j = 0; j < z1; j++)
{
Temp = system[j][j];
//Делим a11 на 2
for (int m = 0; m < z1; m++)
{
system[j][m] /= Temp;
}
b[j] /= Temp;
//2 строчка
for (int i = j + 1; i < z1; i++)
{
Temp = -1 * system[i][j];
for (int k = 0; k < z1; k++)
{
system[i][k] += system[j][k] * Temp;
}
}
}
//Вывод a, b, c
for (int i = z1 - 2; i >= 0; i--)
{
for (int j = z1 - 1; j > i; j--)
{
system[i][j] *= b[j];
b[i] -= system[i][j];
}
}
for (int i = 0; i < z1; i++) {
System.out.print(abc[i]);
}
//Вывод полученного P(x)

System.out.print("\nP(x) = ");
System.out.print(b[0]);
System.out.print("*x + ");
52
//Вычислим сумму квадратов ошибок
for (int i = 0; i < n; i++)
{
error += Math.pow(y[i] - b[0] * x[i] - b[1], 2);
}
System.out.print("Сумма квадратов ошибок = ");
System.out.print(error);
//Пункт 2(б)
System.out.print("___________________________________________________________________
_______\n\n2) Приближенный многочлен второй степени:\n\n");
//Считаем левую часть системы
for (int j = 0; j < z2; j++)

for (int i = 0; i < z2; i++)
{
int p = 5 - i - j - 1;
if (p == 0)
system[i][j] = n;
else
system[i][j] = Sum(x, p);
}
//Считаем правую часть системы

for (int i = 0; i < z2; i++)
{
b[z2 - i - 1] = Sum1(x, y, i);
}
System.out.print("Полученная система: \n");

//Вывод полученной системы
for (int i = 0; i < z2; i++)
{
for (int j = 0; j < z2; j++)
{
System.out.printf("%8f", system[i][j]);
}
System.out.printf("%8s", " | ");
System.out.printf("%8s", b[i]);
}
System.out.printf("%8s", "\n\n");
//Решаем систему методом Гауса

//Прямой ход методом Гаусса
for (int j = 0; j < z2; j++)
{
Temp = system[j][j];
//Делим a11 на 2
for (int m = 0; m < z2; m++)
{
system[j][m] /= Temp;
}
b[j] /= Temp;
//2 строчка
for (int i = j + 1; i < z2; i++)
{
Temp = -1 * system[i][j];
53
for (int k = 0; k < z2; k++)
{
system[i][k] += system[j][k] * Temp;
}
}
}
//Вывод a, b, c
for (int i = z2 - 2; i >= 0; i--)
{
for (int j = z2 - 1; j > i; j--)
{
system[i][j] *= b[j];
b[i] -= system[i][j];
}
}
for (int i = 0; i < z2; i++)
{
System.out.print(abc[i]);
}
//Вывод полученного P(x)

System.out.print("\nP(x) = ");
System.out.print("*x^2 + ");
System.out.print("*x + ");
error = 0;
//Вычислим сумму квадратов ошибок
for (int i = 0; i < n; i++)
{
error += Math.pow(y[i] - b[0] * Math.pow(x[i], 2) - b[1] * x[i] - b[2],
2);
}
System.out.print("Сумма квадратов ошибок = ");
System.out.print(error);
static double Sum(double[] x, int q)

{
int n = 6;
double S = 0;
for (int i = 0; i < n; i++)
S += pow(x[i], q);
return S;
}
static double Sum1(double[] x, double[] y, int q)

{
int n = 6;
double S = 0;
for (int i = 0; i < n; i++)
54
S += pow(x[i], q) * y[i];
return S;
}
55
10. Численное дифференцирование:
Вычислить первую и вторую производную от таблично заданной функции yi  f(xi), i  0, 1, 2, 3, 4 в
точке x  X*.
56
public class Main {
int SIZE = 5;
int j = 0;
double X, h, fc, fl, fr, f2;
double[] x = { 0.0, 1.0, 2.0, 3.0, 4.0 };
double[] y = { 0.0, 1.0, 1.4142, 1.7321, 2.0 };
X = 2.0; // точка, в которой вычисляем производную
h = x[1] - x[0]; // шаг, с которым вычисляем производную

if (X == x[i])
j = i;
// приближенно вычисляем первую производную

fc = (y[j+1] - y[j - 1]) / (2 * h); //центральным способом
fl = (y[j] - y[j - 1]) / h; // левая
fr = (y[j + 1] - y[j]) / h; // правая
// приближенно вычисляем вторую производную

f2 = (y[j+1] - 2 * y[j] + y[j-1]) / (h * h);
// выводим результаты на экран

System.out.print("Заданная точка X* = ");
System.out.print("Первая производная f1 левосторонняя = ");
System.out.print(fl);
System.out.print("Первая производная f1 правосторонняя = ");
System.out.print(fr);
System.out.print("Первая производная f1 центральная = ");
System.out.print(fc);
System.out.print("Вторая производная f2 = ");
System.out.print(f2);
57
58
11. Численное интегрирование:
XK
Вычислить определенный интеграл F=∫ y dx, методами прямоугольников, трапеций и

X0
Симпсона с шагами h1, h2. Оценить погрешность вычислений, используя Метод Рунге-Ромберга:
59
public class Main {
double s1, s2, s3, s11 = 0, s21 = 0, s31 = 0;

double p = 0;
double x0 = -1;
double xk = 1;
double h = 0.5;
double h1 = h;
do
{
double[] x = new double[11];
double[] y = new double[11];
System.out.print("При h");
System.out.print(p + 1);
System.out.print(h);
System.out.print(":");
int n = (int) ((xk - x0) / h); //Кол-во отрезков
System.out.print("Кол-во отрезков = ");
//Считаем все X
x[0] = x0;
for (int i = 1; i <= n; i++)
{
if (x[i] <= xk)
x[i] = x[i - 1] + h;
}
//Считаем все Y(x)

for (int i = 0; i <= n; i++)
{
y[i] = function(x[i]);
}
//Выводим таблицу
System.out.print("\n Таблица:");
System.out.print(" Xi: ");
for (int i = 0; i <= n; i++)
{
System.out.printf("%10s", x[i]);
}
System.out.printf("%10s", "Yi: ");
60
for (int i = 0; i <= n; i++)
{
System.out.printf("%10s", ceil(y[i] * 10000)/10000);
}
//Метод интегрирования трапециями

s1 = 0;
double sum = 0;
for (int i = 1; i <= n - 1; i++)
{
sum += y[i];
}
s1 = h / 2 * (y[0] + 2 * sum + y[n]);
System.out.print(" Метод интегрирования трапециями: ");
System.out.print(s1);
if (p == 0)
s11 = s1;
//Метод Симпсона
s2 = 0;
sum = 0;
double sum1 = 0;
for (int i = 1; i <= n - 1; i += 2)
{
sum += y[i];
}
for (int k = 2; k <= n - 2; k += 2)
{
sum1 += y[k];
}
s2 = h / 3 * (y[0] + 4 * sum + 2 * sum1 + y[n]);
System.out.print(" Метод Симпсона: ");
if (p == 0)
s21 = s2;
//Метод интегрирования прямоугольниками
s3 = 0;
for (int i = 0; i < n; i++)
{
s3 += function(x0 + h * (i + 0.5));
}
s3 *= h;
System.out.print(" Метод интегрирования прямоугольниками: ");

System.out.print("\n\n\n\n");
if (p == 0)
s31 = s3;
h = 0.25; //h2
61
p++;
} while (p != 2);
//Считаем погрешность используя метод Рунге-Ромберга:

double R = h / h1; // R = h2/h1
double z1 = ((s11 - s1) / (pow(R, 2) - 1));

System.out.print("Погрешность метода трапециями = ");
System.out.print(z1);
double z2 = ((s21 - s2) / (Math.pow(R, 4) - 1));
System.out.print("Погрешность метода Симпсона = ");
double z3 = ((s31 - s3) / (Math.pow(R, 1) - 1));
System.out.print("Погрешность метода прямоугольниками = ");
static double function(double x) { return 1 / ((2 * x + 7) * (3 * x + 4)); }
62
12. Задача Коши(ДУ1п):
Решить задачу Коши для обыкновенного дифференциального уравнения первого порядка на
указанном отрезке с заданным шагом h методами Эйлера, Эйлера-Коши, Рунге-Кутты (четвёртого
63
порядка точности) и Адамса (четвёртого порядка точности). Полученное численное решение
сравнить с точным. Построить графики точного и численного решения. Определить погрешность
решения.
64
Графики:
public class Main {

int SIZE = 11;
int SIZE1 = 4;
int i;
double h = 0.1;
double x_0 = 0, x_i = 1;
double[] x = new double[SIZE];
double[] y = new double[SIZE];
double x0 = 0;
double y0 = -1;
//Метод Эйлера
System.out.print("Метод Эйлера:\n");
x[0] = x0;
y[0] = y0;
for (i = 1; i < SIZE; i++)

{
x[i] = x[i - 1] + h;
y[i] = y[i - 1] + h * df(x[i - 1], y[i - 1]);
}
System.out.printf("%12s", "X");
System.out.printf("%8s", "Y");
System.out.printf("%20s", "Точное решение");
65
for (i = 0; i < SIZE; i++)
{
System.out.printf("%s", "i = ");
System.out.printf("%2d", i);
System.out.printf("%7f", x[i]);
System.out.printf("%10f", y[i]);
System.out.printf("%14f", f(x[i]));
}
System.out.printf("%s", "____________________________________\n\n");
//Метод Эйлера - Коши

System.out.printf("%s", "Метод Эйлера - Коши:\n");
x[0] = x0;
y[0] = y0;
for (i = 1; i < SIZE; i++)

{
x[i] = x[i - 1] + h;
y[i] = y[i - 1] + h / 2 * (df(x[i - 1], y[i - 1]) + df(x[i - 1] + h, y[i
- 1] + h * df(x[i - 1], y[i - 1])));
}
for (i = 0; i < SIZE; i++)
{
}
//Метод Рунге-Кутты
System.out.printf("%s", "Метод Рунге-Кутты:\n");
double[] K = new double[SIZE1];

x[0] = x0;
y[0] = y0;
for (i = 1; i < SIZE; i++)

{
x[i] = x[i - 1] + h;
K[0] = df(x[i - 1], y[i - 1]);

K[1] = df(x[i - 1] + (h / 2), y[i - 1] + (h / 2) * K[0]);
K[2] = df(x[i - 1] + (h / 2), y[i - 1] + (h / 2) * K[1]);
K[3] = df(x[i - 1] + h, y[i - 1] + (h * K[2]));
y[i] = y[i - 1] + h / 6 * (K[0] + 2 * K[1] + 2 * K[2] + K[3]);

}
66
for (i = 0; i < SIZE; i++)
{
}
//Метод Адамса
System.out.printf("%s", "Метод Адамса:\n");
for (i = 4; i < SIZE; i++)

{
y[i] = y[i - 1] + (h / 24 * (55 * df(x[i - 1], y[i - 1]) - 59 * df(x[i -
2], y[i - 2]) + 37 * df(x[i - 3], y[i - 3]) - 9 * df(x[i - 4], y[i - 4])) );
}
for (i = 0; i < SIZE; i++)
{
}
System.out.printf("%s", "\nТочечное решение y(");

System.out.printf("%f", x_i);
System.out.printf("%s", ") = ");
System.out.printf("%f", f(x[SIZE - 1]));
System.out.printf("%s", "\n\n");
static double f(double x) { return (-1.4* pow(x, 4) + 2.0/3.0 * pow(x,3) + 12)/

((x-3)*(pow(x-2,2))); }
static double df(double x, double y) { return (-3 * x * y + 8 * y - pow(x,2))
/ (x * x - 5 * x + 6); }
67
68
13. Краевая задача:
Решить краевую задачу для обыкновенного дифференциального уравнения 2-го порядка,
используя конечно-разностный метод. Оценить погрешность численного решения путем
сравнения с точным решением. Построить графики точного и численного решения.
69
Графики:
public class Main {

int SIZE = 11; //кол-во отрезков n-1
int j;
double x_0 = 0, x_i = PI/4; //Границы из моего №7
double h;
//Условия
double R = 1, S = 0, T = 1; //Левая граница отрезка
double V = 0, W = 1, Z = 1; //Правая граница отрезка
//Делим отрезок на SIZE - 1

h = (x_i - x_0) / (SIZE - 1);
System.out.print("Разделим отрезок на ");
System.out.print(SIZE - 1);
System.out.print(" равных отрезка (h = ");
System.out.print(h);
System.out.print(")");
double[] x = new double[SIZE];

double[] y = new double[SIZE];
x[0] = x_0;
70
x[i] = x[i - 1] + h;
for (int i = 0; i < SIZE; i++){

System.out.print("X");
System.out.print(x[i]);
}
double[][] Systems = new double[SIZE][SIZE];

double[] d = new double[SIZE];
Systems[0][0] = (-1 * R / h) + S; //Первая строчка

Systems[0][1] = R / h;
Systems[SIZE - 1][SIZE - 2] = V / h; //Последняя строчка
Systems[SIZE - 1][SIZE - 1] = (-1 * V / h) - W;
d[0] = T;
d[SIZE - 1] = -1*Z;
double X;
//Заполняем левую часть системы
for (int i = 1; i < SIZE - 1; i++)
{
j = i - 1;
X = x[i];
Systems[i][j] = a(X, h);
Systems[i][j + 1] = b(X, h);
Systems[i][j + 2] = c(X, h);
}
//Заполняем правую часть системы

for (int i = 1; i < SIZE - 1; i++)
{
X = x[i];
d[i] = Fx(X);
}
System.out.print("Расширенная матрица: ");

{
for (j = 0; j < SIZE; j++) {
System.out.printf("%8s", round(Systems[i][j]));
}
System.out.printf("%8s", " | ");
System.out.printf("%8s", d[i]);
}
//Считаем систему методом прогонки

double[] a = new double[SIZE];
double[] b = new double[SIZE];
double[] c = new double[SIZE];
double[] P = new double[SIZE+1];
71
double[] Q = new double[SIZE+1];

{
if (i == 0)
{
a[i] = 0;
b[i] = Systems[i][i];
c[i] = Systems[i][i + 1];
}
if (i == SIZE - 1)
{
a[i] = Systems[i][i - 1];
c[i] = 0;
}
if (i != 0 && i != SIZE - 1)
{
a[i] = Systems[i][i - 1];
c[i] = Systems[i][i + 1];
}
}

{
System.out.print("a");
System.out.print(round(a[i]));
System.out.print("b");
System.out.print(round(b[i]));
System.out.print("c");
System.out.print(round(c[i]));
}
for (int i = 1; i < SIZE + 1; i++) {

P[i] = -1 * (c[i - 1]) / (b[i - 1] + a[i - 1] * P[i - 1]);
System.out.print("P");
System.out.print(i);
System.out.print(P[i]);
Q[i] = (a[i - 1] * Q[i - 1] - d[i - 1]) / (-1 * (b[i - 1]) - (a[i - 1] *
P[i - 1]));
System.out.print("Q");
System.out.print(i);
System.out.print(Q[i]);
}
72
y[SIZE - 1] = Q[SIZE];
for (int i = SIZE - 2; i >= 0; i--)
{
y[i] = Q[i + 1] + P[i + 1] * y[i + 1];
}
System.out.print(" Полученные Y");

System.out.print(" Точное решение Y");
{
}
static double f(double x) { return Math.tan(x); } //Точное решение
static double Kx(double x) { return 1; }

static double Lx(double x) { return 0; }
static double Mx(double x) { return -2 / pow(cos(x),2); } //Постоянное
static double Fx(double x) { return 0; } //Постоянное
static double a(double x, double h) { return (Kx(x) / (h * h)) - (Lx(x) / 2 / h);

}
static double b(double x, double h) { return (-2 * Kx(x)) / (h * h) + Mx(x); }
static double c(double x, double h) { return (Kx(x) / (h * h)) + (Lx(x) / 2 / h);
}
}
73
74

РГР Ананьев3

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

РГР Ананьев3

Загружено:

Авторское право:

Доступные форматы

МИНИСТЕРСТВО НАУКИ И ВЫСШЕГО ОБРАЗОВАНИЯ РФ

ФЕДЕРАЛЬНОЕ ГОСУДАРСТВЕННОЕ БЮДЖЕТНОЕ ОБРАЗОВАТЕЛЬНОЕ

Институт № 8 «Информационные технологии и прикладная математика»

Выполнил студент группы М3О-319Бк-18:

import static java.lang.Math.round;

public class Main {

public static void main(String[] args) {

double[][] a = {{3, -8, 1, -7},

double[] b = {96, -13, -54, 82};

//Вывод изменённой системы

System.out.println("Расширенная матрица: ");

for (int i = 0; i < systemSize; i++) {

for (int j = 0; j < systemSize; j++) {

//Вывод изменённой системы

System.out.println("Закончился прямой ход метода Гаусса: ");

for (int i = 0; i < systemSize; i++) {

for (int i = systemSize - 2; i >= 0; i--) {

for (int i = 0; i < systemSize; i++){

import static java.lang.Math.round;

public class Main {

public static void main(String[] args) {

double[][] sys = { {8, 4, 0, 0, 0},

{-5, 22, 8, 0, 0},

{0, -5, -11, 1, 0},

{0, 0, -9, -15, 1},

double[] d = { 48, 125, -43, 18, -23 };

Double[] x = new Double[5];

double[] P = new double[6];

//double P[5 + 1] = { 0 }, Q[5 + 1] = { 0 };

for (int i = 0; i < 5; i++) {

for (int i = 0; i < 5; i++) {

for (int i = 1; i < 5 + 1; i++) {

for (int i = 5 - 2; i >= 0; i--) {

for (int i = 0; i < 5; i++) {

Рис. 1 Метод простых итераций

import static java.lang.Math.*;

public class Main {

public static void main(String[] args) {

System.out.println("Метод простых итераций");

double[][] a = { {20, 5, 7, 1},

double[] b = { -117, -1, 49, -21 };

for (int i = 0; i < systemSize; i++) {

for (int i = 0; i < systemSize; i++) {

//Поиск максимума среди норм

double max_1 = Norma_1[0];

if (Norma_1[i] > max_1) {

if (Norma_2[i] > max_2) {

if (Norma_b[i] > max_b) {

Norm = min(max_1, max_2); //Минимальная из норм

for (int i = 0; i < systemSize; i++) {

System.out.println(" " + "ESP" + " " +

//За начальный вектор

System.out.print("Итерация №1: ");

ESP = pow(Norm, 1) / (1 - Norm) * max_b; //Вычисление погрешности

for (int i = 0; i < systemSize; i++) {

Iterations[n][i] += (Temp + B[i]);

System.out.print("\nКоличество требуемых итераций: ");

double[][] A = { {20, 5, 7, 1},

double[] C = { -117, -1, 49, -21 };

//Обнуляем все элементы из предыдущего метода

for (int i = 0; i < systemSize; i++) {

for (int j = 0; j < 50; j++) {

for (int i = 0; i < systemSize; i++) {

-0.20.089 <0 следовательно с = ( -1 f(-0.7) + 0.7 * f(-1) ) / ( f(-0.7) - f(-1) )