close

Вход

Забыли?

вход по аккаунту

?

Отчет (10)

код для вставкиСкачать
Министерство образования и науки Российской Федерации Казанский национально исследовательский технический университет
им. А. Н. Туполева
Кафедра прикладной математики и информатики
Им Ю.А. Кожевникова
РАСЧЕТНО-ГРАФИЧЕСКАЯ РАБОТА
по дисциплине
"Вычислительная математика"
Тема: "Приближенное решение задачи Коши для обыкновенного дифференциального уравнения методами производных высших порядков"
Работу выполнил
студент гр. 4211 Азимов
Казань 2013
Оглавление
Задание на расчетно-графическую работу и постановка задачи2
Краткое теоретическое описание3
Основные результаты вычислений10
Заключение14
Приложение 1. Листинг программы15
Приложение 2. Результаты работы программы20
Список литературы22
Задание на расчетно-графическую работу и постановка задачи Изучить методы производных второго и третьего порядков для обыкновенных дифференциальных уравнений.
Составить программу, реализующую алгоритмы указанных методов, и проинтегрировать данное дифференциальное уравнение y^'=f(x,y) при заданном начальном условии y(x_0)=y_0 на некотором отрезке [a, b] с шагом h=(b-a)/n при n = 10, n = 20. Начальный отрезок определяется методом Рунге-Кутта 4-го порядка точности.
Найти точное решение задачи в виде функции y^* (x).
Вычислить значения функции y^* (x) в точках x_0, x_(1 ), ... , x_n и сравнить полученные результаты решения уравнения различными методами и при различных значениях n с точным решением.
Уравнение: x^2 y^2 y^'+xy^3=1, y(1)=2
Краткое теоретическое описание
Основные результаты вычислений
Точное решение задачи для отрезка [0, 1]:
y^*=∛(3x^2+13)/(∛2 x)
Значения функции y^* (x) в точках x_0, x_(1 ), ... , x_n (для n=20):
y_0=2
y_1=1.916887
y_2=1,841739
y_3=1.773501
y_4=1,711294
y_5=1.654381
y_6=1,602136
y_7=1.554028
y_8=1,509603
y_9=1.468466
y_10=1,430280
y_11=1.394748
y_12=1,361613
y_13=1.330646
y_14=1,301649
y_15=1.274446
y_16=1,248879
y_17=1.224808
y_18=1,202111
y_19=1.180674
y_20=1,160397
По первому методу для n=10 получены результаты:
y_0=2
y_1=1,841739
y_2=1,711295
y_3=1,601824
y_4=1,509150
y_5=1,429732
y_6=1,361022
y_7=1,301042
y_8=1,248274
y_9=1,201518
y_10=1,159824
По второму методу для n=10 получены результаты:
y_0=2
y_1=1,841739
y_2=1,711295
y_3=1,602138
y_4=1,509605
y_5=1,430282
y_6=1,361615
y_7=1,301652
y_8=1,248881
y_9=1,202113
y_10=1,160399
По первому методу для n=20 получены результаты:
y_0=2
y_1=1,916887
y_2=1,841739
y_3=1,773483
y_4=1,711264
y_5=1,654341
y_6=1,602090
y_7=1,553978
y_8=1,509549
y_9=1,468411
y_10=1,430224
y_11=1,394691
y_12=1,361556
y_13=1,330590
y_14=1,301594
y_15=1,274392
y_16=1,248825
y_17=1,224756
y_18=1,202060
y_19=1,180624
y_20=1,160349
По второму методу для n=20 получены результаты:
y_0=2
y_1=1.916887
y_2=1,841739
y_3=1.773501
y_4=1,711294
y_5=1.654381
y_6=1,602136
y_7=1.554029
y_8=1,509603
y_9=1.468467
y_10=1,430280
y_11=1.394748
y_12=1,361613
y_13=1.330646
y_14=1,301650
y_15=1.274446
y_16=1,248879
y_17=1.224809
y_18=1,202111
y_19=1.180674
y_20=1,160397
Заключение
Оба метода дают очень приближенные к реальным результаты решения уравнения, второй метод (метод, использующий производную третьего порядка) более точен. С уменьшением величины шага точность результатов увеличивается.
Приложение 1. Листинг программы
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 Caushy
{
public partial class Form1 : Form
{
public InitialConditions initialConditions { get; set; }
public decimal h { get;set; }
public int n { get; set; }
public decimal a { get; set; }
public decimal b { get; set; }
public Form1()
{
InitializeComponent();
}
private void Form1_Load(object sender, EventArgs e)
{
this.cb_n.Items.Add(10);
this.cb_n.Items.Add(20);
this.cb_n.SelectedItem = 10;
this.tb_b.Value = 1;
initialConditions = new InitialConditions() { x = 1, y = 2 };
}
private void btn_JustDoIt_Click(object sender, EventArgs e)
{
this.a = this.tb_a.Value;
this.b = this.tb_b.Value;
this.n = Int32.Parse(this.cb_n.SelectedItem.ToString());
this.h = (this.b - this.a) / this.n;
RungeKutt rk = new RungeKutt(this.h, this.n, this.initialConditions);
List<InitialConditions> result = rk.GetInitialConditions();
Integrate integrate = new Integrate(this.h, this.n, result);
result = this.rb_2.Checked == true ? integrate.GetIntegrateResult() : integrate.GetIntegrateResultSecondWay();
dgv_result.Rows.Clear();
int num = 0;
foreach (InitialConditions ic in result)
{
dgv_result.Rows.Add(num, Decimal.Round(ic.x, 6), Decimal.Round(ic.y, 6), Decimal.Round(ic.firstDif, 6), Decimal.Round(ic.secondDif, 6), Decimal.Round(ic.thirdDif, 6));
num++;
}
}
private void cb_n_SelectedValueChanged(object sender, EventArgs e)
{
if (!string.IsNullOrEmpty(this.tb_b.Value.ToString()) && !string.IsNullOrEmpty(this.tb_a.Value.ToString()) && this.tb_b.Value > this.tb_a.Value)
{
this.tb_h.Text = (this.tb_b.Value - this.tb_a.Value) / Int32.Parse(this.cb_n.SelectedItem.ToString()) + "";
}
else
{
this.tb_h.Text = "";
}
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Caushy
{
public class Integrate
{
public decimal h;
public int n;
public List<InitialConditions> firstCond;
public Integrate(decimal h, int n, List<InitialConditions> firstCond)
{
this.h = h;
this.n = n;
this.firstCond = firstCond;
}
public List<InitialConditions> GetIntegrateResult()
{
List<InitialConditions> result = new List<InitialConditions>(this.firstCond);
for (int i = 3; i <= this.n; i++)
{
InitialConditions current = GetNextDif(result[i - 3], result[i - 2], result[i - 1]);
result.Add(current);
}
return result;
}
public List<InitialConditions> GetIntegrateResultSecondWay()
{
List<InitialConditions> result = new List<InitialConditions>(this.firstCond);
for (int i = 3; i <= this.n; i++)
{
InitialConditions current = GetNextDifSecondWay(result[i - 3], result[i - 2], result[i - 1]);
result.Add(current);
}
return result;
}
public InitialConditions GetNextDif(InitialConditions minus2, InitialConditions minus1, InitialConditions current)
{
decimal nextX = current.x + this.h;
decimal nextFirstY = minus2.y + 3 * (current.y - minus1.y) + h * h * (current.secondDif - minus1.secondDif);
decimal nextFirstFirstDif = RungeKutt.GetFirstDifValue(nextX, nextFirstY);
decimal nextFirstSecondDif = RungeKutt.GetSecondDifValue(nextX, nextFirstY);
decimal nextFirstThirdDif = RungeKutt.GetThirdDifValue(nextX, nextFirstY);
decimal nextSecondY = current.y + (h / 2) * (current.firstDif + nextFirstFirstDif) + ((h * h) / 12) * (current.secondDif - nextFirstSecondDif);
decimal nextSecondFirstDif = RungeKutt.GetFirstDifValue(nextX, nextSecondY);
decimal nextSecondSecondDif = RungeKutt.GetSecondDifValue(nextX, nextSecondY);
decimal nextSecondThirdDif = RungeKutt.GetThirdDifValue(nextX, nextSecondY);
decimal nextThirdY = current.y + (h / 2) * (current.firstDif + nextSecondFirstDif) + ((h * h) / 12) * (current.secondDif - nextSecondSecondDif);
decimal nextThirdFirstDif = RungeKutt.GetFirstDifValue(nextX, nextThirdY);
decimal nextThirdSecondDif = RungeKutt.GetSecondDifValue(nextX, nextThirdY);
decimal nextThirdThirdDif = RungeKutt.GetThirdDifValue(nextX, nextThirdY);
return new InitialConditions() { x = nextX, y = nextThirdY, firstDif = nextThirdFirstDif, secondDif = nextThirdSecondDif, thirdDif = nextThirdThirdDif };
}
public InitialConditions GetNextDifSecondWay(InitialConditions minus2, InitialConditions minus1, InitialConditions current)
{
decimal nextX = current.x + this.h;
decimal nextFirstY = minus2.y + 3 * (current.y - minus1.y) + (Pow(h, 3) / 2) * (current.thirdDif + minus1.thirdDif);
decimal nextFirstFirstDif = RungeKutt.GetFirstDifValue(nextX, nextFirstY);
decimal nextFirstSecondDif = RungeKutt.GetSecondDifValue(nextX, nextFirstY);
decimal nextFirstThirdDif = RungeKutt.GetThirdDifValue(nextX, nextFirstY);
decimal nextSecondY = current.y + (h / 2) * (current.firstDif + nextFirstFirstDif) - (Pow(h, 2) / 10) * (nextFirstSecondDif - current.secondDif) + (Pow(h, 3) / 120) * (nextFirstThirdDif + current.thirdDif);
decimal nextSecondFirstDif = RungeKutt.GetFirstDifValue(nextX, nextSecondY);
decimal nextSecondSecondDif = RungeKutt.GetSecondDifValue(nextX, nextSecondY);
decimal nextSecondThirdDif = RungeKutt.GetThirdDifValue(nextX, nextSecondY);
//decimal nextThirdY = current.y + (h / 2) * (current.firstDif + nextSecondFirstDif) - (Pow(h, 2) / 10) * (nextSecondSecondDif - current.secondDif) + (Pow(h, 3) / 120) * (nextSecondThirdDif + current.thirdDif);
//decimal nextThirdFirstDif = RungeKutt.GetFirstDifValue(nextX, nextThirdY);
//decimal nextThirdSecondDif = RungeKutt.GetSecondDifValue(nextX, nextThirdY);
//decimal nextThirdThirdDif = RungeKutt.GetThirdDifValue(nextX, nextThirdY);
//return new InitialConditions() { x = nextX, y = nextThirdY, firstDif = nextThirdFirstDif, secondDif = nextThirdSecondDif, thirdDif = nextThirdThirdDif };
return new InitialConditions() { x = nextX, y = nextSecondY, firstDif = nextSecondFirstDif, secondDif = nextSecondSecondDif, thirdDif = nextSecondThirdDif };
}
public static decimal Pow(decimal value, decimal pow)
{
decimal result = 1;
for (int i = 1; i <= pow; i++)
{
result *= value;
}
return result;
}
}
} using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Caushy
{
public class RungeKutt
{
public decimal h;
public int n;
public InitialConditions firstCond;
public RungeKutt (decimal h, int n, InitialConditions firstCond)
{
this.h = h;
this.n = n;
this.firstCond = firstCond;
}
public List<InitialConditions> GetInitialConditions()
{
List<InitialConditions> result = new List<InitialConditions>();
InitialConditions currentCondition = new InitialConditions()
{
x = this.firstCond.x,
y = this.firstCond.y,
firstDif = GetFirstDifValue(this.firstCond.x, this.firstCond.y),
secondDif = GetSecondDifValue(this.firstCond.x, this.firstCond.y),
thirdDif = GetThirdDifValue(this.firstCond.x, this.firstCond.y)
};
result.Add(currentCondition);
for(int i = 1; i <= 2; i++)
{
currentCondition = GetNextCondition(currentCondition);
result.Add(currentCondition);
}
return result;
}
public InitialConditions GetNextCondition(InitialConditions ic)
{
decimal k1 = this.h * GetFirstDifValue(ic.x, ic.y);
decimal k2 = this.h * GetFirstDifValue(ic.x + h / 2, ic.y + k1 / 2);
decimal k3 = this.h * GetFirstDifValue(ic.x + h / 2, ic.y + k2 / 2);
decimal k4 = this.h * GetFirstDifValue(ic.x + h, ic.y + k3);
decimal deltaY = (k1 + 2 * k2 + 2 * k3 + k4) / 6;
decimal nextX = ic.x + this.h;
decimal nextY = ic.y + deltaY;
decimal nextFirstDif = GetFirstDifValue(nextX, nextY);
decimal nextSecondDif = GetSecondDifValue(nextX, nextY);
decimal nextThirdDif = GetThirdDifValue(nextX, nextY);
return new InitialConditions() { x = nextX, y = nextY, firstDif = nextFirstDif, secondDif = nextSecondDif, thirdDif = nextThirdDif };
}
public static decimal GetFirstDifValue(decimal x, decimal y)
{
return ((1 - x * y * y * y) / (x * x * y * y));
}
public static decimal GetSecondDifValue(decimal x, decimal y)
{
return ((x * Pow(y, 3) - 2) / (Pow(x, 3) * Pow(y, 2)) - ((x * Pow(y, 3) + 2) / (Pow(x, 2) * Pow(y, 3))) * GetFirstDifValue(x, y));
}
public static decimal GetThirdDifValue(decimal x, decimal y)
{
decimal z = (3 * x * Pow(y, 3) - 4 * Pow(x, 2) * Pow(y, 6) + 8) / (Pow(x, 5) * Pow(y, 5)) +
((2 * (Pow(x, 2) * Pow(y, 6) + x * Pow(y, 3) + 5)) / (Pow(x, 4) * Pow(y, 6))) * GetSecondDifValue(x, y);
return z;
}
public static decimal Pow(decimal value, decimal pow)
{
decimal result = 1;
for (int i = 1; i <= pow; i++)
{
result *= value;
}
return result;
}
}
public class InitialConditions
{
public decimal x { get; set; }
public decimal y { get; set; }
public decimal firstDif { get; set; }
public decimal secondDif { get; set; }
public decimal thirdDif { get; set; }
}
}
Приложение 2. Результаты работы программы
Список литературы
Демидович Б.П., Марон И.А. Основы вычислительной математики. М.: Наука, 1966. 664 с. 22
Документ
Категория
Разное
Просмотров
16
Размер файла
902 Кб
Теги
отчет
1/--страниц
Пожаловаться на содержимое документа