Проверка в Wolfram Alfa

Московский Авиационный Институт

(Национальный Исследовательский Университет)

 

Факультет радиоэлектроники летательных аппаратов

Кафедра 404

Работа по дисциплине

«ИНФОРМАТИКА»

 

“Численное интегрирование”

 

Выполнил:

Студент группы М4О-101Б-19

Прозоров Е. И.

 

Принял:

Доцент кафедры 403

Кошелькова Л.В.

Москва 2020

Задание

Вариант 15

Разработать схему алгоритма, составить программу на С++ Builder для вычисления численного интеграла

различными методами.

Вычисленному при заданных пределах интегрирования a = -0,025 и b = 1,88 с погрешностью ɛ = 10^-3 ÷ 10^-6

 

Анализ задания

 

Входные данные:

1. C – нижняя граница интегрирования, тип – вещественный;

2. D – верхняя граница интегрирования, тип – вещественный;

3. Eps – погрешность вычисления интеграла, тип – вещественный;

4. Km – предельное число повторений цикла, тип – целый.

 

Выходные данные:

1. Er,Er2,Er3 – признак ошибки при вычислении интеграла, тип – целый;

2. LT,LS,LP – Количество итераций, тип – целый;

3. In,ln2,ln3 – численное значение интеграла, тип – вещественный.

 

В алгоритме выполняются следующие функции:

· Ввод исходных данных;

· Вычисление значения определенного интеграла методом трапеций;

· Вычисление значения определенного интеграла методом Симпсона;

· Вычисление значения определенного интеграла методом Прямоугольников; · Вывод результатов вычислений.

 

 

Текст программы на языке программирования C++ Builder и результаты её выполнения

//---------------------------------------------------------------------------

 

#include <vcl.h>

#pragma hdrstop

 

#include "Unit1.h"

//---------------------------------------------------------------------------

#pragma package(smart_init)

#pragma resource "*.dfm"

TForm1 *Form1;

//---------------------------------------------------------------------------

double F(double);

double F(double X)

{

     double F=pow(M_E,X)*sin(16*X)*sin(5*X);

     return F;

}

//Текст функции вычисления интеграла с заданной погрешностью методом трапеции

void Trap(double, double, double, int &, int *, int, double &);

void Trap(double C, double D, double Eps, int &LT, int *Er, int Km, double &In)

{

      double Y1, Yn, H, Del, Int1, X;

      int I, J, N;

      Y1 = F(C);

      Yn = F(D);

      Int1 = 0;

      N = 2;

      LT=0;

      *Er = 1;

      J = 1;

      while (J <= Km)

      {

               H = (D - C) / N;

               X = C + H;

               In = 0;

 

               for (I = 1; I<N; I++)

               {

               In = In + F(X);

               X = X + H;

              }

      In = H * (Y1 / 2 + Yn / 2 + In);

      Del = fabs(Int1 - In);

      if (Del < Eps)

      {

      LT = J;

      J = Km;

      *Er = 0;

      }

      else

      {

      Int1 = In;

      N = N * 2;

      }

      J = J + 1;

      }

     }

 

void Sim(double C, double D, double Eps, int Km, int *Er2, int &LS, double &In2)

{

 double Int1, Y1, Yn, S4, S2, H, Del, X, Loc;

 int I, J, K2;

 Int1 = 0;

 Y1 = F(C);

 Yn = F(D);

 K2 = 2;

 LS=0;

 *Er2 = 1;

 J = 1;

 while (J <= Km)

 {

 H = (D - C) / K2;

 In2 = 0;

 S2 = 0;

 S4 = 0;

 I = 1;

 X = C + H;

 do {

 if ((I % 2)!= 0)

 S4 = S4 + F(X);

 else

 S2 = S2 + F(X);

 Loc = 4 * S4 + 2 * S2;

 I = I + 1;

 X = X + H;

 } while (I < K2);

 In2 = H * (Y1 + Yn + Loc) / 3;

 Del = fabs(Int1 - In2);

 if (Del < Eps)

 {

 *Er2 = 0;

 LS = J;

 J = Km;

 }

 else

 {

 Int1 = In2;

 K2 = K2 * 2;

 }

 J = J + 1;

 }

}

 

void Prm(double C, double D, double Eps, int &LP, int *Er3, int Km, double &In3)

{

 double Y1, Yn, H, Del, Int1, X;

 int I, J, N3;

 Y1 = F(C);

 Yn = F(D);

 Int1= 0;

 N3 = 2;

 LP=0;

 *Er3 = 1;

 J = 1;

 while (J <= Km)

 {

      H = (D - C) / N3;

      X = C;

      In3 = 0;

      for (I = 1; I<N3; I++)

      {

               In3 = In3 + F(X);

               X = X + H;

      }

      In3 = H * (Y1 + Yn + In3);

      Del = fabs(Int1 - In3);

 if (Del < Eps)

 {

      LP = J;

      J = Km;

      *Er3 = 0;

 }

 else

 {

 Int1 = In3;

 N3 = N3 * 2;

 }

 J = J + 1;

 }

}

 

__fastcall TForm1::TForm1(TComponent* Owner)

    : TForm(Owner)

{

 

}

//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)

{

     double C, D, Eps, In, In2, In3;

      int Er, Er2, Er3, Km, LT, LS, LP;

      C=StrToFloat(Edit1->Text);

      D=StrToFloat(Edit2->Text);

      Eps=StrToFloat(Edit3->Text);

      Km=StrToInt(Edit4->Text);

      Trap(C, D, Eps, LT, &Er, Km, In);

      if (Er == 1)

              ShowMessage("Интеграл не найден за Km итераций");

      Sim(C, D, Eps, Km, &Er2, LS, In2);

      if (Er2 == 1)

              ShowMessage("Интеграл не найден за Km итераций");

      Prm(C, D, Eps, LP, &Er3, Km, In3);

      if (Er3 == 1)

              ShowMessage("Интеграл не найден за Km итераций");

      Edit6->Text=FloatToStr(In);

      Edit5->Text=FloatToStr(In2);

      Edit7->Text=FloatToStr(In3);

      Edit9->Text=IntToStr(LT);

      Edit10->Text=IntToStr(LS);

      Edit8->Text=IntToStr(LP);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::Button2Click(TObject *Sender)

{

Close();

}

//---------------------------------------------------------------------------

 

Рис. 1 Проект формы

Рис. 2 Результат выполнения

 

Проверка в Wolfram Alfa

Рис. 3 Результат вычислений в Wolfram Alpha