Загальні відомості про мову програмування С++

      Для наведених вище рядів рекурентні  співвідношення можуть бути легко виведені безпосередньо. Простіше всього взяти відношення двох сусідніх членів. Розглянемо, наприклад, ступеневий ряд для функції , загальний член якого має вигляд . За допомогою відношення подальшого члена до попереднього одержимо:

                                                  .                            (2.3)              

      Таким чином, для двох сусідніх членів ряду одержимо рекурентне співвідношення, яке зручне для послідовного обчислення членів ряду:

                                                                                            (2.4)                      

      При обчисленні з рядами замінимо суму ряду його частковою сумою, тобто  обмежившись кінцевим числом членів. Виникає практичне питання: скільки членів ряду потрібно зберегти, щоб погрішність, що виходить, не перевищувала заданої?

      Якщо  члени ряду убувають достатньо швидко і при тому із самого початку, то вигідно використати знакозмінний ряд, погрішність якого легко оцінюється. Сума знакозмінного ряду менше його першого члена (по абсолютній величині). Тому при заміні суми такого ряду його частковою сумою припускається похибки, що не перевищує модулю першого з відкинутих членів. Якщо ж члени ряду убувають поволі або убувають хоча і дуже швидко, але не спочатку, а перші члени ряду достатньо великі, фактична погрішність буде помітно більшою через погрішності віднімання перших великих членів. Наприклад, члени рядів для обчислення cosx і sinx убувають достатньо швидко і ряди сходяться при будь-якому х. Проте при великих х (х ≥ 10), перші члени цих рядів досить швидко зростають, і обчислення cosx і sinx за допомогою цих рядів скрутне. Виникає така втрата точності при відніманні великих перших членів, яку не можна відшкодувати обчисленням великого числа доданків.

       Для рядів  з позитивними членами, оцінка погрішності складніша  ніяких загальних методів оцінки, придатних для всіх рядів, запропонувати не можна.

      Розглянуті  ступені ряди − зручний засіб для програмування елементарних функцій. Кожен з лав легко програмується як звичний цикл, який можна писати і як арифметичний, і як ітераційний. 

      2.2. Виконання програмного забезпечення

      Складаємо програму на мові С++ Builder, обчислення величини регулюючої дії управління, що виробляється комп'ютерною системою, для якогось об'єкту, при заданій величині вхідної дії згідно рівняння:

                                                                 (2.5)

      при:                                                                                     (2.6)

      Для цього використовуємо оператор циклу do…while. Ми вводимо вхідні дані із клавіатури, вихідні дані (результати обчислень), відображали на екрані монітора й записували у файл, що містить програму. Процедуру обчислення робимо з наперед заданою оператором точністю, але не більше 30 ітерацій. Додатково забезпечимо можливість відображення номера останньої ітерації, величину останнього члена ряду, і отримаємо точність обчислень.

      Складемо  програму обчислення ряду:

                                                                                                  (2.7)                                             

        Обчислюємо  :

                  (2.8)            

       Обчислюємо  похідну:

                                                                                                                           (2.9)

       Розраховуємо  факторіали:

1!=1 

 

                                                                                                                      (2.10) 

       Виконуємо наступні дії для функції , при х = 1:

1:  

2:  

3:                                                    (2.11)       
 

4:  

       Знаходимо функцію для :

                                                                                                    (2.12)

       Виконуємо наступні розрахунки для функції , при х = 1:

1:

2:                                                     (2.13)       

3:  

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

      Відповідне  програмне забезпечення має наступний вигляд:

#include <vcl.h>

#include<vcl.h>

#include<stdio.h>

#include<stdlib.h>

#include<fcntl.h>

#include<sys\stat.h>

#include<io.h>

#include<string.h>

#pragma hdrstop

#include "Unit1.h"

#include "math.h"

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

#pragma package(smart_init)

#pragma resource "*.dfm"

TForm1 *Form1;

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

float x; // Вводимо змінну х  (результат  обчислень)

float y; // Вводимо змінну у (показник ступеня)

float d; // Вводимо змінну d (кінцева точність  розрахунку)

float y0; // Вводимо змінну у0 

__fastcall TForm1::TForm1(TComponent* Owner)

        : TForm(Owner)

{

Button2->Enabled=false;//Робимо невидимою Button2

}

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

// Прописуємо події, які виникають при натисканні кнопки Button1 

void __fastcall TForm1::Button1Click(TObject *Sender)

{

//Якщо кнопка натиснута то:

switch (Button1->Tag)

        {

case 0:

Button2->Enabled=true;        // стає видимою кнопка Button2

Button2->Caption="Зберегти"; // на Button2 з'являється напис " Зберегти "

Button2->Tag=0; // Значенню Tag привласнюється значення 0

break;

}

// При  натисканні кнопки:

// Вводимо  змінні усередині процедури Button1Click

float r;

float rc;

float b;

float bc;

float da;

float dc;

float t;

float tc;

float e;

float ec;

float dd;

float yc;

float xc;

float w;

// Задаємо початкові значення змінних:

r = 1;

rc = 1;

b = 30; // задаємо  максимальне число ітерацій

bc = 30;

da = 0;

dc = 0;

x = 1;

xc = 1;

// Введення  кінцевої точності ітерацій з  об'єкта Edit1,

// наприклад  1Е-5 (відповідає 0.00001)

d = StrToFloat(Edit1->Text);

dc = StrToFloat(Edit1->Text);

// Введення  показника ступеня з об'єкта Edit2

// наприклад  2Е-1 (відповідає 0.2)

y = StrToFloat(Edit2->Text);

yc = StrToFloat(Edit2->Text);

da = 1;// задаємо  крок ітерацій

dc = 1;

t = 1;

tc = 1;

y0 = y;

e = 0;

ec = 0;

// Організовуємо  цикл розрахунку кількості ітерацій, підрахунку в у ступені

//а2, розрахунку  факторіала для першого члена:

do {

// присвоювання  в наступному циклі значенню da більше на 1 

          da = da + 1;

// кількість  ітерацій (в циклі do...while перевірка  дотримання)

          r = da -1;

// умовний   проводиться в кінці циклу  вже після розрахунків нових значень)

// розрахунок  значень у в степені а2

          y =2*(y*y0);

// розрахунок  факторіала

          t *= r;  

// розрахунок  суми членів ряду без першого,  що дорівнює 1

          e += y/(y0*t);

// обчислювання  значення е в заданої степені

          x = (e + 1);

// обчислювання  значення останнього  члена ряду

          dd = y/(y0*t);

// вивід  результатів розрахунку на форму

Label6->Caption = "Результат :" + FloatToStrF(x,ffGeneral,7,2);

// Завершення  циклу, перевірка виконання умови:  допустимого числа ітерацій

// та  точності розрахунку

      } while (da <= b ^ dd <= d); 

do {

// присвоювання  в наступному циклі значенню da більше на 1 

          dc = dc + 1;

// кількість  ітерацій (в циклі do...while перевірка  дотримання)

          rc = dc -1;

// умовний  проводиться в кінці циклу вже після розрахунків нових значень)