Программирование на языке высокого уровня

Екатеринбург 2012 г.

Федеральное агентство связи ФГОБУ ВПО «Сибирский государственный университет телекоммуникаций и информатики»

Уральский технический институт связи и информатики (филиал)

КУРСОВАЯ РАБОТА

по дисциплине

ЯЗЫКИ ПРОГРАММИРОВАНИЯ

210 406.65 «Сети связи и системы коммутации»

Выполнил: Романцев С.А.

Проверил: Кондратьев В.П.

СОДЕРЖАНИЕ Задание для курсовой работы

1. Проект в Delphi

1.1 Вид и работа программы

1.2 Код программы

2. Проект в Maple

2.1 Интегрирование дифференциального уравнения. Сравнение с расчетами, выполненными в Delphi

2.2 Спектральная анализ сигнала в Maple

Список используемой литературы

Задание для курсовой работы Написать программу на языке программирования Паскаль для решения следующей задачи (вариант задания индивидуальный). Результаты расчетов должны выводиться на экран и в файл. Оформление графиков и таблиц выполнять средствами математических пакетов (Maple, MathCad). Демонстрационный вариант программы подготовить в среде визуального программирования Delphi.

Проверить решение промежуточных задач средствами математических пакетов. Построить блок-схемы задачи и вспомогательных частей алгоритма. Оценить погрешность выполненных расчетов.

Напряжение U=U (t) на входе транзистора как функция времени описывается дифференциальным уравнением с начальными условиями (1), где n — последняя цифра номера зачетной книжки, k — коэффициент усиления (см. ниже), fs (t) — периодический сигнал (рис. 1), m — коэффициент обратной связи.

Указания и пояснения.

1. Дифференциальное уравнение с заданными начальными условиями (задача Коши) решается методом Рунге-Кутта второго порядка с коррекцией (3) на отрезке [0;5] с шагом h=0.01.(в узлах tj =jh, j=0,1,2…). Функция fs (t) в правой части представляет собой регулирующий периодический (период Т) сигнал единичной амплитуды (рис 1, номер варианта n — последняя цифра номера зачетной книжки,). Результаты расчетов—таблица (tj, Uj) и график функции U (t) (на экран и в файл).

2. Значение коэффициента усиления k в правой части дифференциального уравнения есть наименьший положительный корень полинома (2), который вычисляется одним из методов нахождения корней уравнения (метод касательных, метод Вегстейна).

3. Построить спектральные характеристики периодического сигнала fs (t), заданного в аналоговой форме и в виде дискретного сигнала. Длительность сигнала равна 1, период T=k.

4. Период функции U (t) определить с помощью функции автокорреляции.

Курсовая работа выполняется в ЧЕТЫРЕ этапа.

1. Средствами математического пакета Maple решается задача спектрального анализа аналогового и дискретного периодического сигнала fs (t). Сравниваются спектры амплитуд аналогового и дискретного представлений сигнала. (образец выполнения задания — файл вариант11. mws).

2. Создается проект в визуальной среде Delphi, решающий эту же задачу для дискретного сигнала, а результаты выполнения сравниваются визуально.

3. С помощью языка программирования системы Maple решается задача интегрирования дифференциального уравнения (задача Коши) методом (по варианту задания). Окончательные вычисления в программе зависят от результатов расчета программы в Delphi (следующий пункт). Образец выполнения задания — файл RUTTA.mws.

4. Создается проект в визуальной среде Delphi, решающий ту же задачу Коши, результаты расчета которой записываются в файл, который используется в предыдущем пункте. Выводятся графики результатов вычислений в Maple и Delphi и сравниваются между собой. Явные несовпадения свидетельствуют об ошибке в программе на Delphi.

Оформление:

v Формат А4.

v Титул

v Постановка задачи

v Алгоритмы решения вспомогательных задач

v Блок-схемы

v Результаты расчетов, графики

v Литература

Индивидуальное задание № 14

1. Начальные условия: U (0)=0.2

2. полином: x⁵−7x-10

3. коррекция: в средней точке

4. метод поиска корня Метод Вегстейна

Сигнал:

1. Проект в Delphi

1.1 Вид и работа программы

Рис. 1 — Форма программы

Рис. 2 — Работа программы (построение графика сигнала)

Рис. 3 — Работа программы (Спектр амплитуд)

1.2 Код программы

unit Romanzew;

interface

uses

Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,

Dialogs, ExtCtrls, StdCtrls, Buttons;

type

TForm1 = class (TForm)

BitBtn1: TBitBtn;

BitBtn2: TBitBtn;

BitBtn3: TBitBtn;

BitBtn4: TBitBtn;

BitBtn5: TBitBtn;

Label1: TLabel;

Label2: TLabel;

ListBox1: TListBox;

SaveDialog1: TSaveDialog;

BitBtn6: TBitBtn;

BitBtn7: TBitBtn;

Image1: TImage;

procedure BitBtn1Click (Sender: TObject);

procedure BitBtn2Click (Sender: TObject);

procedure BitBtn3Click (Sender: TObject);

procedure BitBtn4Click (Sender: TObject);

procedure BitBtn5Click (Sender: TObject);

procedure BitBtn6Click (Sender: TObject);

procedure BitBtn7Click (Sender: TObject);

private

{ Private declarations }

public

{ Public declarations }

end;

var

Form1: TForm1;

implementation

{$R *.dfm}

const

Npoint=50;

U0=0.2;

h=5/Npoint;

Nzach=8;

KOC=0.5;

N=40;

m=20;

{——————}

a=0;b=2; epsilon=0.1;

type

dann=array[0.Npoint]of real;

koef=array[0.m] of real;

var

U:dann;

root:real;

t:real;

kolit:integer;

fn:string;

ft:text;

Y:dann;

v, e: koef;

function f (t:real):real;

begin

f:=t*t*t*t*t-7*t-10;

{ f:=t*sqr (sqr (t))-8*t-1; }

end;

function phi (x:real):real;

begin

phi:=x+f (x);

end;

procedure Iter (a, b: real;var x2, y2:real; var flag: Boolean);

var

x0,x1,y0,y1:real;

begin

kolit:=kolit+1;

x0:=a;y0:=phi (x0);

x1:=b;y1:=phi (x1);

x2:=(x1*y0-y1*x0)/((x1-x0)-(y1-y0));

{writeln (a, b, x2);}

y2:=phi (x2);

flag:=(y0-x0)*(y2-x2)>0;

end;

procedure Vegstein (a, b, eps:real; var x: real);

var

xz, yz: real;

prizn:Boolean;

begin

repeat

Iter (a, b, xz, yz, prizn);

if prizn then a:=xz else b:=xz;

until abs (xz-yz)

{ writeln ('корень===', xz); }

x:=xz;

end;

{=======================================================}

function signal (t:real):real;

var

z:real;

begin

if t<0 then z:=0

else if t<1 then z:=1-sin (Pi*t)

else z:=0;

signal:=z;

end;

function Period (x, T: real):real;

var

z:real;

begin

z:=x-trunc (x/T)*T;

Period:=signal (z);

end;

{==================================================}

procedure graf;

var

x:real;

y:real;

j:integer;

k:integer;

begin

with Form1. ListBox1.Canvas do

begin

MoveTo (10,120);LineTo (600,120);

MoveTo (10,10);LineTo (10,220);

MoveTo (8,15);LineTo (10,10);

MoveTo (12,15);LineTo (10,10);

MoveTo (595,118);LineTo (600,120);

MoveTo (595,122);LineTo (600,120);

for j := 0 to 500 do

begin

x:=j/100; {интервал [0.5]}

y:=Period (x, T);

k:=trunc (y*100);

Pixels[j+10,120-k]: =RGB (255,0,0);

Pixels[j+10,120-k+1]:=RGB (255,0,0);

{ Pixels[j+10,120-k+1]: =clBlue;}

Sleep (5);

end;

end;

end;

{=======================================================}

function RHS (x, U: real):real;

begin

RHS:=Nzach*(cos ((4+Nzach/10)*x+U)+T*Period (x, T)-KOC*U);

{=1}

end;

{=======================================================}

procedure difur;

var j: integer; x, y: real;

yz:real;

begin

U[0]: =U0; x:=0;

for j:=1 to npoint do

begin

y:=RHS (x, U[j-1]);

{U[j]: =U[j-1]+h*y;} {коррекция}

yz:=U[j-1]+h/2*y;

U[j]: =U[j-1]+h*rhs (x+h/2,yz);

x:=j*h;

end;

end;

{=======================================================}

procedure zapis;

var

j:integer;

begin

assignfile (ft, fn);

rewrite (ft, fn);

for j:= 0 to Npoint do

writeln (ft, j*h:6:2,U[j]: 12:4);

closefile (ft);

end;

{=======================================================}

procedure Furkoef (m, N: integer;Y:dann;var v, e: koef);

var

j, k: integer;

p, q: real;

x:real;

h:real;

begin

h:=2*Pi/N;

for k:=0 to m do

begin

p:=0;q:=0;

for j:=1 to N do

begin

x:=j*h;

p:=p+Y[j]*cos (x*k);

q:=q+Y[j]*sin (x*k);

end;

v[k]: =p*2/N;

e[k]:=q*2/N;

end;

end;

function Tpol (m:integer;x:real):real;

var

z:real;

k:integer;

begin

z:=v[0]/2;

for k:=1 to m do

z:=z+(v[k]*cos (k*2*Pi/T*x)+e[k]*sin (k*2*Pi/T*x));

Tpol:=z;

end;

{===========================================================}

procedure spektr (numvar:integer);

var

L, R, W, H: integer;

X: dann;

Y: dann;

k:integer;

ymin, ymax: real;

Mx, My: real;

x0,y0: integer;

posx, posy: integer;

Nkf:string;

tx:real;

ypol:real;

procedure min_max (N:integer;Y:dann; var min, max: real);

var

k: integer;

begin

min:=Y[0]; max:=Y[0];

for k := 1 to N do

if Y[k]> max then

max:=Y[k]

else if Y[k]< min then

min:=Y[k];

{увеличиваем диапазон}

max:=max+0.1;

min:=min-0.1;

end;

begin

L:=10;

R:=form1.Image1.clientHeight-20;

W:=form1.Image1.Width-50;

H:=form1.Image1.clientheight-50;

case numvar of 1:

begin

for k:=0 to m do

Y[k]: =sqrt (sqr (v[k])+sqr (e[k]));

min_max (m, Y, ymin, ymax);

Mx:=W/m;

My:=H/(ymax-ymin);

x0:=L;

y0:=R-abs (Round (ymin*My));

with form1. Image1.Canvas do

begin

pen.Width:=1;

pen.Color:=clred;

Moveto (L, R);lineto (L, R-H);

moveto (x0,y0);lineto (x0+W, y0);

pen.Width:=4;

pen.Color:=clgreen;

for k:=0 to m do

begin

posx:=x0+round (k*Mx);

posy:=y0-round (Y[k]*My);

moveto (posx, y0);

lineto (posx, posy);

end;

end;

end;

end;

end;

procedure TForm1. BitBtn1Click (Sender: TObject);

begin

vegstein (a, b, epsilon, T);

{ writeln ('число шагов', kolit:6);}

Label1.Visible:=true;

Label1.Caption:='Вычисляем корень полинома';

Label2.Visible:=true;

Label2.Caption:='Корень='+floattostr (T);

BitBtn1.Visible:=false;

BitBtn2.Visible:=true;

BitBtn6.Visible:=false;

BitBtn7.Visible:=false;

BitBtn2.SetFocus;

end;

procedure TForm1. BitBtn2Click (Sender: TObject);

begin

label1.Caption:='Строим график сигнала';

graf;

BitBtn2.Visible:=false;

BitBtn3.Visible:=true;

BitBtn6.Visible:=false;

BitBtn7.Visible:=false;

BitBtn3.SetFocus;

end;

procedure TForm1. BitBtn3Click (Sender: TObject);

begin

Label1.Caption:='Решаем ДифУравнение';

ListBox1.Clear;

difur;

BitBtn3.Visible:=false;

BitBtn4.Visible:=true;

BitBtn6.Visible:=false;

BitBtn7.Visible:=false;

BitBtn4.SetFocus;

end;

procedure TForm1. BitBtn4Click (Sender: TObject);

begin

if SaveDialog1. Execute then

fn:=SaveDialog1.Filename;

Label1.Caption:='Запись в файл '+fn;

zapis;

BitBtn4.Visible:=false;

BitBtn5.Visible:=true;

BitBtn6.Visible:=true;

BitBtn7.Visible:=false;

BitBtn6.SetFocus;

end;

procedure TForm1. BitBtn5Click (Sender: TObject);

begin

Close;

end;

procedure TForm1. BitBtn6Click (Sender: TObject);

var

j:integer;

s1,s2,s3:string;

begin

for j:=0 to N do

Y[j]: =signal (j*Pi/N);

Y[N]:=(Y[0]+Y[N])/2;

Furkoef (m, N, Y, v, e);

for j:=0 to m do

begin

str (j:2,s1);

str (v[j]: 10:5,s2);

str (e[j]:10:5,s3);

listbox1.Items.Add (s1+s2+s3);

BitBtn3.Visible:=false;

BitBtn4.Visible:=false;

BitBtn6.Visible:=false;

BitBtn7.Visible:=true;

BitBtn7.SetFocus;

end;

end;

procedure TForm1. BitBtn7Click (Sender: TObject);

begin

Label1.Caption:='График спектра амплитуд';

spektr (1);

BitBtn3.Visible:=false;

BitBtn3.Visible:=false;

BitBtn6.Visible:=false;

BitBtn7.Visible:=false;

BitBtn5.SetFocus;

end;

end.

2. Проект в Maple

2.1 Интегрирование дифференциального уравнения. Сравнение с расчетами, выполненными в Delphi

> restart; with (plots):with (linalg):

> pol:=x⁵−7*x-10:

> T:=fsolve (pol, x=1.3):

> plot (pol, x=0.2.1,color=blue, thickness=2):

> signal:=proc (t) local z;

z:=piecewise (t<0,0,t<=1,1-sin (Pi*t), 0);

end:

> plot (signal (x), x=-1.3, color=blue, thickness=2,discont=true);

> Period:=proc (x) local z;global T;

z:=x-floor (x/T)*T; signal (z);end:

> plot (Period (x), x=0.5,color=brown, thickness=3,discont=true):

Error, (in plot) unable to determine the discontinuities

> #константы варианта

> Nzac:=8:Koc:=1:u0:=0.2:Koeff:=T:

> ur:=diff (U (t), t):

> F:=Nzac/10*(cos ((4+Nzac/10)*t+U (t))+Koeff*Period (t)-Koc*U (t)):

> RK:=dsolve ({ur=F, U (0)=u0}, U (t), type=numeric, output=listprocedure):

> fU:=subs (RK, U (t)):

> T0:=5:Nt:=50:h:=T0/Nt:

> h := 1/10:

> Tx:=array (0.Nt):U:=array (0.Nt):U_map:=array (0.Nt):

> for j from 0 to Nt do

> x:=j*h;z:=fU (x);Tx[j]: =x;U[j]:=z;U_map[j]:=z;

> #print (x, z);

> od:

> RisU:=zip ((a, b)->[a, b], Tx, U):

> RU:=plot (RisU):

> display (RU):

> #====================================

>

> fn:=`D:\Romanzew.txt`:

> L:=readdata (fn, 2):

> Graf:=plot (L, style=point, symbol=cross, color=blue, symbolsize=18):

> display (Graf, RU);

> L:=readdata (fn, 2):

Nstrok:=vectdim (L):

> U_n:=array (1.Nstrok):

T_n:=array (1.Nstrok):

>

> for j from 1 to Nstrok do

T_n[j]: =L[j, 1];

U_n[j]:=L[j, 2];

#print (j, T_n[j], U_n[j]);

od:

> u1:=zip ((a, b)->[a, b], T_n, U_n):

> RU1:=plot (u1,style=point, symbol=cross, color=black):

> display (RU, RU1);

Сравнение результатов на одинаковых сетках

>

> printf («%s» ,` № t U_map U_pas разн n`);

for k from 0 to Nt do t:=Tx[k]: del:=U_map[k]-U_n[k+1];

printf («% 3.0f % 6.2f % 8.4f % 8.4f % 8.4f n», k, t, U_map[k], U_n[k+1], del):

end:;

№ t U_map U_pas разн

0 0.00 0.2000 0.2000 0.0000

1 0.10 0.3709 0.3666 0.0043

2 0.20 0.4525 0.4460 0.0065

3 0.30 0.4532 0.4467 0.0065

4 0.40 0.3952 0.3901 0.0051

5 0.50 0.3053 0.3024 0.0029

6 0.60 0.2100 0.2096 0.0004

7 0.70 0.1348 0.1367 -0.0019

8 0.80 0.1033 0.1073 -0.0040

9 0.90 0.1371 0.1424 -0.0053

10 1.00 0.2514 0.1819 0.0695

11 1.10 0.2745 0.2052 0.0693

12 1.20 0.3214 0.2536 0.0678

13 1.30 0.3725 0.3082 0.0643

14 1.40 0.4070 0.3480 0.0590

15 1.50 0.4108 0.3582 0.0526

16 1.60 0.3801 0.3343 0.0458

17 1.70 0.3197 0.2802 0.0395

18 1.80 0.2388 0.2046 0.0342

19 1.90 0.1854 0.1879 -0.0025

20 2.00 0.2057 0.2100 -0.0043

21 2.10 0.1965 0.2027 -0.0062

22 2.20 0.1804 0.1885 -0.0081

23 2.30 0.1766 0.1860 -0.0094

24 2.40 0.1986 0.2086 -0.0100

25 2.50 0.2516 0.2610 -0.0094

26 2.60 0.3302 0.3381 -0.0079

27 2.70 0.4216 0.4275 -0.0059

28 2.80 0.5131 0.5172 -0.0041

29 2.90 0.5597 0.5218 0.0379

30 3.00 0.4771 0.4443 0.0328

31 3.10 0.3789 0.3507 0.0282

32 3.20 0.2759 0.2512 0.0247

33 3.30 0.1788 0.1569 0.0219

34 3.40 0.0985 0.0785 0.0200

35 3.50 0.0449 0.0260 0.0189

36 3.60 0.0261 0.0075 0.0186

37 3.70 0.0449 0.0261 0.0188

38 3.80 0.1662 0.1393 0.0269

39 3.90 0.3272 0.2998 0.0274

40 4.00 0.4275 0.4009 0.0266

41 4.10 0.4603 0.4360 0.0243

42 4.20 0.4356 0.4148 0.0208

43 4.30 0.3738 0.3568 0.0170

44 4.40 0.2983 0.2850 0.0133

45 4.50 0.2327 0.2225 0.0102

46 4.60 0.1994 0.1916 0.0078

47 4.70 0.2194 0.2132 0.0062

48 4.80 0.2276 0.2187 0.0089

49 4.90 0.2051 0.1964 0.0087

50 5.00 0.2197 0.2105 0.0092

2.2 Спектральная анализ сигнала в Maple

Ниже приведены команды системы математических вычислений MAPLE

с комментариями и минимальными пояснениями используемых алгоритмов. Эти команды, набранные красным цветом, необходимо последовательно выполнять, нажимая клавишу Enter. (Следуя рекомендациям и указаниям, приведенным ниже, нужно выполнить расчеты своего варианта задания с помощью команд настоящего файла, модифицировав нужным образом, в соответствии с заданием, команды системы Maple).

Команда restart нужна для очистки памяти системы при повторном запуске программы и при начале следующего сеанса. Две следующие команды подключают пакеты линейной алгебры и графический пакет, соответственно. С помощью команды pp:=(x, y)->[x, y] строится отображение пар координат (координаты точки плоскости) в список. Этот список будет выдаваться на графике в виде множества точек. Сообщения после выполнения команд подключения пакетов (текст синего цвета) не свидетельствуют об ошибке в програме, а предупреждают о переопределении некоторых названий команд. Например, команда trace в обычном режиме задает трассировку вычислений при отладке, а в пакете линейной алгебры она означает вычисление следа матрицы.

>

>

> restart;

> with (linalg):with (plots):

pp:=(x, y)->[x, y];

Задается модельный сигнал (вариант 1), который следует заменить на сигнал своего варианта.

Это финитная функция единичной амплитуды, заданная на единичном отрезке-носителе.

> f:= proc (t) local z ;z:=piecewise (t<0,0,t<=1,1-sin (Pi*t), 0); evalf (z);end;

> plot (f (t), t=-1.2,thickness=2,color=brown);

> T:=2*Pi;#период сигнала

> tau:=2;#длительность сигнала Для полученной периодической функции вычисляем коэффициенты тригонометрического ряда Фурье Коэффициенты Фурье вычисляются в аналитическом виде процедурой Fourier (T, F),

где параметрами процедуры являются величина периода T и имя процедуры, вычисляющей значения сигнала на отрезке периодичности. В нашем случае это процедура Period, для использования которой следует согласовать параметры обеих процедур.

Процедура Fourier вычисляет коэффициенты Фурье и передает их как глобальные для процедуры объекты.

Интегрируемая функция имеет один параметр — переменную интегрерования.

При этом функция должна быть определена на отрезке периодичности, поэтому следует задать процедуру, в которой не должно быть других параметров:

>

> signal:=proc (x)global tau, T;

f (x/tau);

end;

> plot (signal (x), x=0.T, thickness=2,color=blue);

Таким образом, фактическим параметром, соответствующим названию функции при вызове процедуры Fourier должна быть процедура F.

>

> Fourier:=proc (T, f) global a0, A, B;

a0:=2/T*evalf (Int (f (x), x=0.T)):;

A:=value (2/T*int (f (x)*cos (2*Pi*k*x/T), x=0.T));

B:=value (2/T*int (f (x)*sin (2*Pi*k*x/T), x=0.T));

end proc:

Вычислими выражения для коэффициентов и выведем их значения:

> Fourier (T, signal):

> a0;evalf (A, 4);evalf (B, 4);

Значения коэффициентов и можно вычислить подстановкой (процедура subs) натуральных чисел в полученные выражения Зафиксируем число коэффициентов (степень)тригонометрического полинома Фурье и построим совместные графики исходного сигнала и приближающих его полиномов для нескольких значений степеней. Глобальный параметр k, как и выражения для коэффициентов Фурье определяются процедурой Fourier

>

> Trig:=proc (t, n) local z;global k, T, a0,A, B;

z:=a0/2+sum (A*cos (k*2*Pi*t/T)+B*sin (k*2*Pi*t/T), k=1.n);

end:

Построим график триг. полинома пятой степени

> plot (Trig (x, 5), x=-T.2*T);

> grafik:=plot (signal (x), x=-0.2.T+0.2,thickness=3,color=blue, discont=true):

Построим совместные графики сигнала и полиномов нескольких степеней

> CL:=brown, red, gold;

> RisTrig:=seq (plot (Trig (t, 2*j), t=-0.1.2*T, color=CL[j]), j=1.3):

> display (RisTrig, grafik);;

>

> with (plottools):

Выполним спектральный анализ аналогового сигнала. Затем дискретизируем сигнал и также построим его спектр для сравнения и понимания различий в спектрах дискретного и аналогового сигналов. Присоединим процедуры, решающие эту задачу. Тексты процедур, их назначениВе и смысл параметров описаны в методическом пособии «Язык программирования системы Maple» глава 9.3 —- Кусочные функции. Процедура Fourier_T вычисляет в аналитической форме интегралы, через которые вычисляются коэффициенты ряда Фурье.

>

> Fourier_T:=proc (F, T0, TN, k: evaln) local T;

global A0, Ak, Bk;

T:=TN-T0;

A0:=2/T*Int (F (x), x=T0.TN);

Ak:=2/T*int (F (x)*cos (k*x*2*Pi/T), x=T0.TN):

Bk:=2/T*int (F (x)*sin (k*x*2*Pi/T), x=T0.TN):

end proc:

Процедура Trig_polynom подстановкой номеров k в формулы коэффициентов вычисляет эти коэффициенты и сохраняет во вновь созданных массивах a, b [0.N]. Заодно строится график тригонометрического полинома степени N (структура RisTrig, которая является глобальной и может быть выведена оператором display после вызова процедуры).

>

> Trig_polynom:=proc (N, T, a0,ak, bk, k: evaln) local n, Pol, A0, A, B;

global a, b, RisTrig;

a:=array (0.N);b:=array (0.N);

A0:=evalf (a0);a[0]: =A0;b[0]:=0;

A:=seq (evalf (subs (k=n, ak)), n=1.N);

B:=seq (evalf (subs (k=n, bk)), n=1.N);

for n from 1 to N do

a[n]: =A[n];b[n]:=B[n];

end do;

Pol:=A0/2+sum (A[k]*cos (2*Pi*k*x/T)+B[k]*sin (2*Pi*k*x/T), k=1.N):

RisTrig:=plot (Pol, x=-T/2.3*T/2,color=blue, thickness=2):

RETURN (Pol);

end proc:

Процедура ARR строит спектр амплитуд линейчатой гистограммой.

>

> ARR:=proc (n:integer, c) local L, H, ma, mi, k: integer,

Sim:array (0.n);

ma:=c[0]; mi:=c[0];

L:=line ([0,c[0]],[n, c[n]], thickness=2,color=red);

for k from 1 to n do

if c[k]>ma then ma:=c[k]; end if;

if c[k]

end do;

H:=ma-mi;

if H=0 then RETURN (L) end;

for k from 0 to n do

if abs (c[k])

Sim[k]: =ellipse ([k, c[k]], 0.2,0.01*H, color=blue);

else

Sim[k]:=plottools[arrow]([k, 0],[k, c[k]], 0.2,0.2,0,color=black);

end if;

end do;

convert (Sim, list);

end:

Процедура Spectr вычисляет модули и аргументы комплексной (синусной) формы тригонометрического полинома.

График спектра фаз —- структура Risphi.

> Spectr:=proc (n, a, b, c, Risphi) local k, R, phi;

for k from 0 to n do

c[k]: =evalf (abs (I*a[k]+b[k])):

phi:=evalf (argument (I*a[k]+b[k]));

R[k]:=[eval (k), eval (phi)];

end:;

Risphi:=plot (convert (R, list)):

end:

Определим прямоугольный импульс f (t) единичной длительности (здесь полезно повторить вычисления для своего варианта сигнала, заменив только определение импульса с помощью команды piecewise).

Построим сигнал (F_for_all) длительности и для него выполним вычисления спектральных характеристик.

Здесь и дальше команды не будут зависеть от варианта сигнала, поскольку название обрабатываемого сигнала теперь у всех одинаково (F_for_all)

Положим величину периода T=2 (для всех вариантов). Аналитические выражения коэффициентов вычисляются в процедуре Fourier_T.

>

> tau:=Pi;# длительность сигнала

> T:=2*Pi;# величина периода

> F_for_all:=proc (t) global tau;f (t/tau);end proc:;

Получим формулы для коэффициентов Фурье, зависящие от номера коэффициента k.

Ris1:=plot (F_for_all (t), t=0.T, color=brown, thickness=2):display (Ris1);

> Fourier_T (F_for_all, 0, T, k):

> a0:=evalf (A0);a_k=Ak;b_k=Bk;

Значения величин С[k] в аналитическом виде можно вычислить (для любого натурального k) по формуле:

> > C[k]: =simplify (sqrt (Ak²+Bk²)):

Для построения спектра амплитуд зафиксируем число коэффициентов и с помощью процедуры Trig_polynom

вычислим коэффициенты a[k], b[k] тригонометрического полинома степени N, а также построим его график на отрезке, большем длины периода. Массивы коэффициентов создаются при работе процедуры и являются глобальными, то есть доступными вне процедуры.

> N:=15;

> Trig_polynom (N, T, A0,Ak, Bk, k):

> display (RisTrig, Ris1) :

Амплитудный спектр (коэффициенты С[k]) вычисляется процедурой Spectr, которая как побочный эффект строит графическую структуру

Risphi1, являющуюся графиком спектра фаз. График спектра амплитуд строит процедура ARR.

> Spectr (N, a, b, c,'Risphi1'):;

> display (ARR (N, c));

> RisAMP:=display (ARR (N, c)):

> display (Risphi1);

Дискретизация задачи Пакет MAPLE выполняет вычисления в аналитической форме, если не указано дополнительно требование: получить результет в числовом виде, например команда fsolve. Для получения результатов, совпадающих с вычислениями, выполненными программным путем (среда Turbo Delphi), перейдем к дискретному варианту решения задачи, то есть к вычислениям на конечном множестве точек отрезка [0, T]. Определим массив Y для сеточных значений функции F_for_all (t), соответственно. Определим также массивы a, b для размещения значений коэффициентов тригонометрического полинома, аппроксимирующего функцию f (t) на отрезке длины периода T > .

Параметр Nt, задающий число дискретных отсчетов (0. Nt) следует поизменять и выбрать каких-нибудь 2−3 варианта. Этот параметр определяет качество аппроксимации сигнала на периоде. (Согласно теореме Котельникова, если сигнал имеет ограниченный спектр, то сигнал может быть точно восстановлен по дискретным отсчетам, но при малом количестве отсчетов будут потеряны высокочастотные составляющие сигнала).

Число коэффициентов тригонометрического полинома выбирается как максимально возможное и равное n = Nt/2

Массивы коэффициентов Фурье определяются по максимальному значению n, но в силу ортогональности системы тригонометрических функций, тригонометрические полиномы меньшей степени имеют те же самые коэффициенты (первые по порядку из массива коэффициентов).

Построение спектральных характеристик дискретного сигнала в Maple будем выполнять с помощью процедур ДПФ (дискретного преобразования Фурье, методическое пособие «Дискретное преобразование Фурье. pdf»).

Присоединим модифицированную процедуру DTF из пособия, а также процедуру Setka и Spectr_DTF, последняя из которых вычисляет модули и аргументы комплексных коэффициентов ДПФ.

>

> DTF:=proc (y, N, Y, n) local k, j, p, h;

h:=2*Pi/N;

2.1: for k from 0 to n do

p:=0;

for j from 0 to N-1 do

p:=p+evalf (y[j]*exp (-I*k*j*h));

end;

Y[k]: =evalf (p/N);

end:

end:;

> Setka:=proc (Nt, T, F, Y: array) local h, j, x, R;

global GrafF;

h:=T/Nt;

for j from 0 to Nt do

x:= evalf (j*h);

Y[j]: = F (x);

R[j]: =[j, eval (Y[j])];

end:

5.1: R[Nt]: =[j, eval (Y[0])];

GrafF:=plot (convert (R, list), 0. Nt, color=brown,

style=point, symbol=circle):

end:

> 6: Spectr_DTF:=proc (n, C, A, phi) local k, R;global Risphi;

6.1: for k from 0 to n do

A[k]: =evalf (abs (C[k])):

phi[k]:=evalf (argument (C[k]));

R[k]:=[eval (k), eval (phi[k])];

end:;

Risphi:=plot (convert (R, list), thickness=2,color=blue, style=point, symbol=box):

end:

Зададим число точек дискретизации N= Nt+1, число коэффициентов n в массивах ДПФ (N— параметр процедур ДПФ и он равен числу дискретных отсчетов сигнала, которые нумеруются инлексами 0. N-1).

Для демонстрации свойства симметрии коэффициентов n будем задавать большим Nt. В случае вещественного сигнала (не имеющего мнимой составляющей) в силу свойства симметрии спектральных характеристик (четная — для АЧХ, нечетная — для ФЧХ) полагают n=Nt/2, если требуется только построение их графиков, а не восстановление сигнала обратным дискретным преобразованием Фурье.

Параметры задачи

> Nt:=31;`число дискретных отсчетов -1`:

> n:=Nt;# в обычном случае

n:=60;# для демонстрации свойства симметрии

> C:=array (0.n):phi:=array (0.n):A:=array (0.n):;

Y:=array (0.Nt):

> Setka (Nt, T, F_for_all, Y);

> DTF (Y, Nt+1,C, n):

> Spectr_DTF (n, C, A, phi):;

> display (ARR (n, A));

> display (RisAMP);

maple delphi математический задача

1.Фаронов В. В. DELPHI. Программирование на языке высокого уровня. Учебник для вузов.—СПб.:Питер, 2005, 640с.

4.Кондратьев В. П. Языки программирования. Система Maple.ч. I. Основы работы в системе. Ч. III/. Язык программирования системы. Учебное пособие. Екатеринбург: УрТИСИ ГОУ ВПО «СибГУТИ», 2006.