16215

СЕКЦИИ ДОСТУПА, СВОЙСТВА, РАБОТА С НЕСКОЛЬКИМИ ОБЪЕКТАМИ КЛАССА

Лабораторная работа

Информатика, кибернетика и программирование

Лабораторная работа №3 Секции доступа свойства работа с несколькими объектами класса Цель лабораторной работы: изучить принципы реализации инкапсуляции. Постановка задачи: На примере класса вычисления определенного интеграла разработать свойства доступа к за

Русский

2013-06-20

107 KB

6 чел.

Лабораторная работа №3

Секции доступа, свойства, работа с несколькими объектами класса

Цель лабораторной работы: изучить принципы реализации инкапсуляции.

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

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

Краткие теоретические сведения:

Классами в Object Pascal называются специальные типы, которые содержат поля, методы и свойства. Как и любой другой тип, класс служит лишь образцом для создания конкретных экземпляров реализации, которые называются объектами.

В основе классов лежат три фундаментальных принципа, которые называются инкапсуляция, наследование и полиморфизм.

Под инкапсуляцией понимается скрытие полей объекта с целью обеспечения доступа к ним только посредством методов и свойств класса.

Механизм создания новых классов на основе существующих по средствам добавления полей, свойств и методов к уже существующим классам называется наследованием.

Полиморфизм - это свойство классов решать схожие по смыслу проблемы разными способами (возможность использовать одинаковые имена для методов, входящих в различные классы).

Свойство отражает ту или иную черту (аспект класса. Часто это просто значение поля с почти идентичным именем. Если бы мы сделали поле доступным для всех остальных объектов, тогда они могли бы читать это поле и записывать в него. Введя в класс свойство, мы защищаем поле, контролируя доступ к нему извне. Такая методика носит название инкапсуляции.

Текст программы:

// основная программа

unit UDisplayForm;

unit UDisplayForm;

interface

uses

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

 Dialogs, Series, ExtCtrls, StdCtrls, TeEngine, TeeProcs, Chart, Buttons, UCalc, UTwoIntegrals;

type

 TForm1 = class(TForm)

   Edit2: TEdit;

   Edit1: TEdit;

   MethodSelector: TRadioGroup;

   DisplayChart: TChart;

   SeriesFunction1: TLineSeries;

   Label1: TLabel;

   Label2: TLabel;

   Label4: TLabel;

   SeriesPatterned1: TAreaSeries;

   Label3: TLabel;

   Edit3: TEdit;

   SpeedButton1: TSpeedButton;

   Edit4: TEdit;

   Panel1: TPanel;

   Label5: TLabel;

   Panel2: TPanel;

   CheckBox1: TCheckBox;

   SeriesPatterned2: TAreaSeries;

   SeriesFunction2: TLineSeries;

   SeriesCommon: TAreaSeries;

   Label6: TLabel;

   Edit5: TEdit;

   Label7: TLabel;

   Edit6: TEdit;

   Label8: TLabel;

   Edit7: TEdit;

   Panel3: TPanel;

   Label9: TLabel;

   Edit8: TEdit;

   Panel4: TPanel;

   Label10: TLabel;

   Edit9: TEdit;

   Panel5: TPanel;

   Label11: TLabel;

   Edit10: TEdit;

   Bevel1: TBevel;

   Panel6: TPanel;

   Label12: TLabel;

   Edit11: TEdit;

   procedure FormCreate(Sender: TObject);

   procedure SomeEditKeyPress(Sender: TObject; var Key: Char);

   procedure SpeedButton1Click(Sender: TObject);

   procedure SomeEditChange1(Sender: TObject);

   procedure SomeEditChange2(Sender: TObject);

   procedure MethodSelectorClick(Sender: TObject);

   procedure CheckBox1Click(Sender: TObject);

   procedure FormShow(Sender: TObject);

   procedure FormClick(Sender: TObject);

   procedure SmthChanged;

   function f2(x: Extended): Extended;

 private

   { Private declarations }

 public

   { Public declarations }

 end;

var

 Form1: TForm1;

 e1, e2, e3, e5, e6, e7: string;

 p1, p2, p3, p5, p6, p7: integer;

 integ: TIntegral;

 twoIntegrals: TTwoIntegrals;

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);

begin

 integ:=TIntegral.Create(0);

 twoIntegrals:=TTwoIntegrals.Create();

 twoIntegrals.Chart:=DisplayChart;

 twoIntegrals.OnSomethingChanged:=SmthChanged;

 //integ.Chart:=DisplayChart;

end;

//Edited

procedure TForm1.SomeEditKeyPress(Sender: TObject; var Key: Char);

begin

 if Sender=Edit3 then

   p3:=Edit3.SelStart;

 

 if (Sender=Edit2) then

   p2:=Edit2.SelStart;

 if (Sender=Edit1) then

   p1:=Edit1.SelStart;

 if Sender=Edit7 then

   p7:=Edit7.SelStart;

 if (Sender=Edit6) then

   p6:=Edit6.SelStart;

 if (Sender=Edit5) then

   p5:=Edit5.SelStart;

end;

procedure TForm1.SpeedButton1Click(Sender: TObject);

begin

 Application.Terminate;

end;

procedure TForm1.SomeEditChange1(Sender: TObject);

var r: real;

begin

 if Sender=Edit3 then

 begin

   try

    twoIntegrals.Integral1.N:=StrToInt((Sender as TEdit).Text);

     e3:=Edit3.Text;

   except

     on EConvertError do begin

                               Edit3.Text:=e3;

                               Edit3.SelStart:=p3;

                             end;

   end;

 end

 else if ((Sender=Edit1) or (Sender=Edit2)) then

 begin

   if true then

   begin

       try

         r:=StrToFloat((Sender as TEdit).Text);

         e1:=Edit1.Text;

         e2:=Edit2.Text;

       except

         on EConvertError do begin

                               if Sender=Edit1 then

                               begin

                                 (Sender as TEdit).Text:=e1;

                                 (Sender as TEdit).SelStart:=p1;

                               end

                               else if Sender=Edit2 then

                               begin

                                 (Sender as TEdit).Text:=e2;

                                 (Sender as TEdit).SelStart:=p2;

                               end;

                               exit;

                             end;

       end;

       if Sender=Edit2 then

       begin

         twoIntegrals.Integral1.B:=r;

       end

       else

       begin

         twoIntegrals.Integral1.A:=r;

       end;

   end;

 end;

end;

procedure TForm1.SomeEditChange2(Sender: TObject);

var r: real;

begin

 if Sender=Edit7 then

 begin

   try

    twoIntegrals.Integral2.N:=StrToInt((Sender as TEdit).Text);

     e7:=Edit7.Text;

   except

     on EConvertError do begin

                               Edit7.Text:=e7;

                               Edit7.SelStart:=p7;

                             end;

   end;

 end

 else if ((Sender=Edit5) or (Sender=Edit6)) then

 begin

   if true then

   begin

       try

         r:=StrToFloat((Sender as TEdit).Text);

         e5:=Edit5.Text;

         e6:=Edit6.Text;

       except

         on EConvertError do begin

                               if Sender=Edit5 then

                               begin

                                 (Sender as TEdit).Text:=e5;

                                 (Sender as TEdit).SelStart:=p5;

                               end

                               else if Sender=Edit6 then

                               begin

                                 (Sender as TEdit).Text:=e6;

                                 (Sender as TEdit).SelStart:=p6;

                               end;

                               exit;

                             end;

       end;

       if Sender=Edit6 then

       begin

         twoIntegrals.Integral2.B:=r;

       end

       else

       begin

         twoIntegrals.Integral2.A:=r;

       end;

   end;

 end;

end;

procedure TForm1.MethodSelectorClick(Sender: TObject);

begin

 twoIntegrals.CalcMethod:=MethodSelector.ItemIndex;

end;

procedure TForm1.CheckBox1Click(Sender: TObject);

begin

 SeriesPatterned1.AreaLinesPen.Visible:=(Sender as TCheckBox).Checked;

 SeriesPatterned2.AreaLinesPen.Visible:=(Sender as TCheckBox).Checked;

end;

procedure TForm1.FormShow(Sender: TObject);

begin

 SomeEditChange1(Edit1);

 SomeEditChange1(Edit2);

 SomeEditChange2(Edit5);

 SomeEditChange2(Edit6);

end;

procedure TForm1.FormClick(Sender: TObject);

begin

 integ.f:=f2;

end;

procedure TForm1.SmthChanged;

begin

 if not twoIntegrals.Integral1.IsError then

   Edit4.Text:=FloatToStr(twoIntegrals.Integral1.Res)

 else

   Edit4.Text:='Ошибка в данных!';

 if not twoIntegrals.Integral2.IsError then

   Edit9.Text:=FloatToStr(twoIntegrals.Integral2.Res)

 else

   Edit9.Text:='Ошибка в данных!';

 if not twoIntegrals.IsError then

 begin

   Edit8.Text:=FloatToStr(twoIntegrals.Sum);

   Edit10.Text:=FloatToStr(twoIntegrals.Difference12);

   Edit11.Text:=FloatToStr(twoIntegrals.Difference21);

 end

 else

 begin

   Edit8.Text:='Ошибка в данных!';

   Edit10.Text:='Ошибка в данных!';

   Edit11.Text:='Ошибка в данных!';

 end;

end;

function TForm1.f2(x: Extended): Extended;

begin

 Result:=x*x*3;

end;

end.

// модуль, содержащий класс

unit UCalc;

unit UCalc;

interface

uses Chart;

const funcCount=4;

type

   TValueChangedFunc=procedure (newValue: Extended) of object;

    TF=function (x: Extended): Extended of object;

    TIntegral=class

     private

       FValueMin: Extended;//Нижняя граница

       FValueMax: Extended;//Верхняя граница

       FValueH: Extended; //Ширина шага

       FRes: Extended;    //Результат

       FValueN: Integer;  //Количество шагов

       FCalcMethod: Byte; //Номер выбранного способа подсчёта (0-трап.; 1-лев.прямоуг.; 2-прав.прямоуг.; 3-средн.прямоуг)

       FAutoRedraw: Boolean; //Перерисовывать при изменении хотя бы одного параметра

       FChart: TChart;

       FMaxY: extended;

       FOnMinChanged: TValueChangedFunc;

       FOnMaxChanged: TValueChangedFunc;

       FOnNChanged: TValueChangedFunc;

       FOnHChanged: TValueChangedFunc;

       FOnRecalc: TValueChangedFunc;

       FIsError: boolean;

       FSeries: byte;

       FF: TF;          //Функция подынтегральная

     protected

       procedure SetN(newN: integer); virtual;

       procedure SetH(newH: Extended); virtual;

       procedure SetMin(newMin: Extended); virtual;

       procedure SetMax(newMax: Extended); virtual;

       procedure SetCalcMethod(newMethod: byte); virtual;

       procedure SetChart(newChart: TChart); virtual;

       procedure SetF(newF: TF);

     public

       constructor Create(newSeries: byte=0);

       destructor Destroy; override;

       property A: Extended read FValueMin write SetMin;//Нижняя граница

       property B: Extended read FValueMax write SetMax;//Верхняя граница

       property N: integer read FValueN write SetN default 10;//Количество шагов

       property H: Extended read FValueH write SetH;//Ширина одного шага

       property CalcMethod: byte read FCalcMethod write SetCalcMethod default 0;   //Номер выбранного способа подсчёта (0-трап.; 1-лев.прямоуг.; 2-прав.прямоуг.; 3-средн.прямоуг)

       property Chart: TChart read FChart write SetChart;

       property AutoRedraw: boolean read FAutoRedraw write FAutoRedraw default true;//Перерисовывать при изменении хотя бы одного параметра

       property Res: Extended read FRes;

       property IsError: boolean read FIsError;

       property MaxY: Extended read FMaxY;

       //События (на изменение каждого из параметров)

       property OnMinChanged: TValueChangedFunc read FOnMinChanged write FOnMinChanged default nil;

       property OnMaxChanged: TValueChangedFunc read FOnMaxChanged write FOnMaxChanged default nil;

       property OnNChanged: TValueChangedFunc read FOnNChanged write FOnNChanged default nil;

       property OnHChanged: TValueChangedFunc read FOnHChanged write FOnHChanged default nil;

       property OnRecalc: TValueChangedFunc read FOnRecalc write FOnRecalc default nil;

       //Подынтегральная функция

       function fDefault(x: Extended): Extended; virtual;

       //

       property f: TF read FF write SetF;

       //Функции подсчёта результата

       procedure ReCalc(); virtual;

       function calc_trapezium: Extended; virtual;

       function calc_rectangle_left: Extended; virtual;

       function calc_rectangle_right: Extended; virtual;

       function calc_rectangle_media: Extended; virtual;

       //Функции вывода информации в компонент TChart

       procedure Redraw(); virtual;

       procedure draw_f; virtual;

       procedure draw_trapezium; virtual;

       procedure draw_rectangle_left; virtual;

       procedure draw_rectangle_right; virtual;

       procedure draw_rectangle_media; virtual;

    end;

implementation

constructor TIntegral.Create(newSeries: byte = 0);

begin

 inherited Create();

 FValueMax:=1;

 FValueMin:=0;

 FValueH:=0.1;

 FAutoRedraw:=true;

 FF:=fDefault;

 FSeries:=newSeries;

 FIsError:=true;

 N:=10;

end;

destructor TIntegral.Destroy;

begin

 inherited Destroy;

end;

procedure TIntegral.SetN(newN: integer);

begin

 FValueN:=newN;

 if FValueN<1 then

   FValueN:=1;

 FValueH:=(FValueMax-FValueMin)/FValueN;

 

 if (AutoRedraw) then

   Redraw();

 ReCalc();

 if Assigned(FOnNChanged) then

   FOnNChanged(FValueN);

 if Assigned(FOnHChanged) then

   FOnHChanged(FValueH);

end;

procedure TIntegral.SetH(newH: Extended);

begin

 FValueN:=round((FValueMax-FValueMin)/newH)+1;

 FValueH:=(FValueMax-FValueMin)/FValueN;

 

 if (AutoRedraw) then

   Redraw();

 ReCalc();

 if Assigned(FOnNChanged) then

   FOnNChanged(FValueN);

 if Assigned(FOnHChanged) then

   FOnHChanged(FValueH);

end;

procedure TIntegral.SetMin(newMin: Extended);

begin

 FValueMin:=newMin;

 FValueH:=(FValueMax-FValueMin)/FValueN;

 

 if (AutoRedraw) then

   Redraw();

 ReCalc();

 if Assigned(FOnMinChanged) then

   FOnMinChanged(newMin);

end;

procedure TIntegral.SetMax(newMax: Extended);

begin

 FValueMax:=newMax;

 FValueH:=(FValueMax-FValueMin)/FValueN;

 

 if (AutoRedraw) then

   Redraw();

 ReCalc();

 if Assigned(FOnMaxChanged) then

   FOnMaxChanged(newMax);

end;

procedure TIntegral.SetChart(newChart: TChart);

begin

 FChart:=newChart;

 if (AutoRedraw) then

   Redraw();

end;

procedure TIntegral.SetCalcMethod(newMethod: byte);

begin

 if (newMethod in [0..3]) then

 begin

   FCalcMethod:=newMethod;

   if (AutoRedraw) then

     Redraw();

   ReCalc();

 end;

end;

procedure TIntegral.SetF(newF: TF);

begin

 if (@newF<>nil) then

 begin

   FF:=newF;

   ReCalc;

   Redraw;

 end;

end;

procedure TIntegral.ReCalc;

begin

   FRes:=0;

   FIsError:=true;

   if FValueMin<FValueMax then

   begin

     case FCalcMethod of

     0: FRes:=calc_trapezium();

     1: FRes:=calc_rectangle_left();

     2: FRes:=calc_rectangle_right();

     3: FRes:=calc_rectangle_media();

     end;

     FIsError:=false;

   end;

   if Assigned(FOnRecalc) then

     FOnRecalc(FRes);

end;

function TIntegral.calc_trapezium: Extended;

var x: extended;

   i: integer;

begin

 Result:=0;

 x:=FValueMin;

 for i:=1 to FValueN do

 begin

   Result:=Result+(f(x)+f(x+FValueH))/2*FValueH;

   x:=x+FValueH;

 end;

end;

function TIntegral.calc_rectangle_left:Extended;

var i:integer;

   x:extended;

begin

 Result:=0;

 x:=FValueMin;

 for i:=1 to n do

   begin

     Result:=Result+FValueH*f(x);

     x:=x+FValueH;

   end;

end;

function TIntegral.calc_rectangle_right:Extended;

var i:integer;

   x:extended;

begin

 Result:=0;

 x:=FValueMin;

 for i:=1 to n do

   begin

     Result:=Result+FValueH*f(x+FValueH);

     x:=x+FValueH;

   end;

end;

function TIntegral.calc_rectangle_media:Extended;

var i:integer;

   x:extended;

begin

 Result:=0;

 x:=FValueMin;

 for i:=1 to n do

   begin

     Result:=Result+FValueH*f(x+FValueH/2);

     x:=x+FValueH;

   end;

end;

procedure TIntegral.Redraw;

begin

 if (Assigned(FChart) and (FValueMin<FValueMax)) then

 begin

   draw_f;

   case FCalcMethod of

   0: draw_trapezium();

   1: draw_rectangle_left();

   2: draw_rectangle_right();

   3: draw_rectangle_media();

   end;

 end

 else if Assigned(FChart) then

 begin

   Chart.Series[FSeries].Clear;

   Chart.Series[FSeries+3].Clear;

   FMaxY:=0;

 end;

end;

procedure TIntegral.draw_f;

var rightRange, x, h1: extended;

begin

 if Assigned(FChart) then

 begin

   FChart.Series[FSeries+3].Clear;

   rightRange:=FValueMax+(FValueMax-FValueMin)*0.1;

   x:=FValueMin-(FValueMax-FValueMin)*0.1;

   h1:=(rightRange-x)/50;

   rightRange:=rightRange+h1;

   while x<=rightRange do

   begin

     FChart.Series[FSeries+3].AddXY(x, f(x));

     x:=x+h1;

   end;

   FMaxY:=f(x)*1.05;

 end;

end;

procedure TIntegral.draw_trapezium;

var x: extended;

   i: integer;

begin

 if Assigned(FChart) then

 begin

   draw_f;

   FChart.Series[FSeries].Clear;

   x:=FValueMin;

   for i:=0 to FValueN do

   begin

     FChart.Series[FSeries].AddXY(x, f(x));

     x:=x+FValueH;

   end;

 end;

end;

procedure TIntegral.draw_rectangle_left;

var x: extended;

   i: integer;

begin

 if Assigned(FChart) then

 begin

   draw_f;

   FChart.Series[FSeries].Clear;

   x:=FValueMin;

   for i:=1 to FValueN do

   begin

     FChart.Series[FSeries].AddXY(x, f(x));

     FChart.Series[FSeries].AddXY(x+FValueH, f(x));

     x:=x+FValueH;

   end;

 end;

end;

procedure TIntegral.draw_rectangle_right;

var x: extended;

   i: integer;

begin

 if Assigned(FChart) then

 begin

   draw_f;

   FChart.Series[FSeries].Clear;

   x:=FValueMin;

   for i:=1 to FValueN do

   begin

     FChart.Series[FSeries].AddXY(x, f(x+FValueH));

     FChart.Series[FSeries].AddXY(x+FValueH, f(x+FValueH));

     x:=x+FValueH;

   end;

 end;

end;

procedure TIntegral.draw_rectangle_media;

var x: extended;

   i: integer;

begin

 if Assigned(Chart) then

 begin

   draw_f;

   FChart.Series[FSeries].Clear;

   x:=FValueMin;

   for i:=1 to FValueN do

   begin

     Chart.Series[FSeries].AddXY(x, f(x+FValueH/2));

     Chart.Series[FSeries].AddXY(x+FValueH, f(x+FValueH/2));

     x:=x+FValueH;

   end;

 end;

end;

function TIntegral.fDefault(x: extended): extended;

begin

 Result:=Exp(sqr(x));

end;

end.

// модуль, содержащий второй класс

unit UTwoIntegrals;

interface

uses UCalc, Chart, Windows;

type TProcedure=procedure () of object;

type TTwoIntegrals=class

 private

   FIsError: boolean;

   FSum: Extended;

   FDifference12: Extended;

   FDifference21: Extended;

   FACommon: Extended;

   FBCommon: Extended;

   FChart: TChart;

   FIntegral1: TIntegral;

   FIntegral2: TIntegral;

   FCalcMethod: byte;

   FOnSomethingChanged: TProcedure;

 protected

   function f1(x: Extended): Extended; virtual;

   function f2(x: Extended): Extended; virtual;

   procedure SetChart(newChart: TChart); virtual;

   procedure SetCalcMethod(newMethod: byte); virtual;

   procedure ParametersChanged(AA: Extended); virtual;

   procedure Recalculate; virtual;

   procedure Redraw; virtual;

 public

   constructor Create();

   destructor Destroy(); override;

   property Sum: Extended read FSum;

   property Difference12: Extended read FDifference12;

   property Difference21: Extended read FDifference21;

   property IsError: boolean read FIsError;

   property Chart: TChart read FChart write SetChart;

   property CalcMethod: byte read FCalcMethod write SetCalcMethod;

   property Integral1: TIntegral read FIntegral1;

   property Integral2: TIntegral read FIntegral2;

   property OnSomethingChanged: TProcedure read FOnSomethingChanged write FOnSomethingChanged;

 end;

implementation

constructor TTwoIntegrals.Create();

begin

 inherited Create();

 FIntegral1:=TIntegral.Create(0);

 FIntegral2:=TIntegral.Create(1);

 FIntegral1.f:=f1;

 FIntegral2.f:=f2;

 

 FIntegral1.OnRecalc:=ParametersChanged;

 {FIntegral1.OnMaxChanged:=ParametersChanged;

 FIntegral1.OnMinChanged:=ParametersChanged;

 FIntegral1.OnNChanged:=ParametersChanged;

 }

 FIntegral2.OnRecalc:=ParametersChanged;

 {FIntegral2.OnMaxChanged:=ParametersChanged;

 FIntegral2.OnMinChanged:=ParametersChanged;

 FIntegral2.OnNChanged:=ParametersChanged;

 }

 FIntegral2.A:=0.2;

 FIntegral2.B:=1.2;

end;

function TTwoIntegrals.f1(x: Extended): Extended;

begin

 Result:=Exp(x);

end;

function TTwoIntegrals.f2(x: Extended): Extended;

begin

 Result:=3.5*x;

end;

procedure TTwoIntegrals.SetChart(newChart: TChart);

begin

 FChart:=newChart;

 FIntegral1.Chart:=FChart;

 FIntegral2.Chart:=FChart;

 Self.Redraw();

end;

procedure TTwoIntegrals.SetCalcMethod(newMethod: byte);

begin

 if newMethod<4 then

 begin

   FCalcMethod:=newMethod;

   FIntegral1.CalcMethod:=FCalcMethod;

   FIntegral2.CalcMethod:=FCalcMethod;

   ParametersChanged(0);

 end;

end;

procedure TTwoIntegrals.ParametersChanged(AA: Extended);

begin

 Self.FACommon:=FIntegral1.A;

 if (FIntegral2.A>Self.FACommon) then

   Self.FACommon:=FIntegral2.A;

 Self.FBCommon:=FIntegral1.B;

 if (FIntegral2.B<Self.FBCommon) then

   Self.FBCommon:=FIntegral2.B;

 Self.FIsError:=(FIntegral1.IsError or FIntegral2.IsError);

 //MessageBox(0, '', '', 0);

 self.Redraw();

 self.Recalculate();

 if Assigned(FOnSomethingChanged) then

   FOnSomethingChanged();

end;

procedure TTwoIntegrals.Recalculate;

begin

 if not (Self.FIsError) then

 begin

   FSum:=FIntegral1.Res+FIntegral2.Res;

   FDifference12:=FIntegral1.Res-FIntegral2.Res;

   FDifference21:=FIntegral2.Res-FIntegral1.Res;

 end;

end;

procedure TTwoIntegrals.Redraw;

var e, h, r1, r2: extended;

   i: integer;

begin

 {if not IsError then

 begin

   FChart.LeftAxis.Maximum:=FIntegral1.MaxY;

   if (FIntegral2.MaxY>FIntegral1.MaxY) then

     FChart.LeftAxis.Maximum:=FIntegral2.MaxY;

 end; }

 if (Assigned(FChart) and not (FIsError or (Self.FBCommon<=Self.FACommon))) then

 begin

   e:=FACommon;

   h:=(FBCommon-FACommon)/50;

   FChart.Series[2].Clear;

   for i:=0 to 50 do

   begin

     r1:=f1(e);

     r2:=f2(e);

     if r1>r2 then

       r1:=r2;

     FChart.Series[2].AddXY(e, r1);

     e:=e+h;

   end;

 end

 else if Assigned(FChart) then

 begin

   FChart.Series[2].Clear;

 end;

end;

destructor TTwoIntegrals.Destroy;

begin

 FIntegral1.Free;

 FIntegral2.Free;

 inherited Free;

end;

end.


Результаты работы программы:

Вывод: В результате выполнения данной лабораторной работы был  разработан новый класс TTwoIntegrals для вычисления суммы и разности определенного интеграла. Он содержит в себе два объекта класса TIntegral, в каждом из которых вычисляется значение интеграла нужным способом и строится его графическое отображение. В новом классе TTwoIntegral предусмотрены методы графического отображения общей площади подынтегральных функций. В процессе выполнения работы были рассмотрены возможности объектно-ориентированного программирования, изучены способы создания полей, методов и свойств классы и способы обращения к ним.


 

А также другие работы, которые могут Вас заинтересовать

44573. Топология типа «шина» 82.5 KB
  В ней используется один сетевой кабель именуемый магистралью или сегментом вдоль которого подключены все РС сети. Пакет в виде электрических сигналов передается по шине в обоих направлениях всем компьютерам сети. Так как в каждый момент времени в сети может вести передачу только одна РС то производительности ЛВС зависит от количества РС подключенных к шине. Чем их больше тем больше ожидающих передачи данных тем ниже производительности сети.
44574. Топология типа «звезда» 65.5 KB
  Основное достоинство этой топологии в том что если повреждена какая-либо РС или отдельное соединение между РС и концентратором вся сеть остается работоспособной. Как недостатки организации такой топологии следует отметить следующее: Так как все РС подключены к центральной точке то для больших ЛВС значительно увеличивается расход кабеля. Концентраторы являются центральным узлом в топологии звезда.
44575. Топология типа «кольцо» 41 KB
  Кроме того изменение конфигурации сети или подключение новой РС требует остановки всей сети.
44576. Комбинированные топологии 66 KB
  Звезда –шина strbus - это комбинация топологий шина и звезда Чаще всего это выглядит так: несколько сетей с топологией звезда объединяются при помощи магистральной шины. Топология €œзвезда-кольцо Звезда-кольцо strring – кажется похожей на звезду-шину И в том и в другом случае компьютеры подключены к концентратору который фактически формирует кольцо или шину.
44577. Сравнительные характеристики топологий 31.5 KB
  При значительных объемах трафика уменьшается пропускная способность; трудная локализация проблем; выход из строя кабеля остановит работу пользователей. выход из строя одной РС выводит из строя всю сеть; трудно локализовать проблемы; изменение конфигурации сети требует остановки всей сети. Звезда легко модифицировать сеть добавляя новые РС; централизованный контроль и управление; выход из строя РС не влияет на работу сети. Выход из стоя центрального концентратора выводит из стоя всю сеть.
44578. Методы доступа, Коллизия в сети 87 KB
  Коллизия в сети Наибольшее распространение при проектировании и построении ЛВС получили два метода доступа зто: Множественный доступ с контролем несущей и обнаружением коллизии CSM CD CrrierSense Multiple ccess nd Collision Defection. Алгоритм работы рабочей станции а точнее ее сетевого адаптера при использовании первого метода доступа заключается в следующем: 1. Вдумайтесь в название этого доступа.
44579. Типы и компоненты беспроводных сетей 30 KB
  В зависимости от технологии беспроводные сети подразделяют на: локальные вычислительные сети; мобильные вычислительные сети. Их можно устанавливать как на автономно работающих компьютерах так и на компьютерах подключенных к сети. Трансивер - это устройство для подключения компьютера к сети т.
44580. Инфракрасные и лазерные беспроводные ЛВС 41.5 KB
  Инфракрасные сети нормально функционируют на скорости 10 Мбит с. Различают 4 типа инфракрасных сетей: Сети прямой видимости между приемником и передатчиком. Сети на рассеянном излучении.
44581. Беспроводные ЛВС с радиопередачей данных 42 KB
  Переключение всех компьютеров в сети происходит синхронно. Есть сети построенные по данной технологии работающие со скоростью до 2 Мбит с на расстояние до 32 км на открытом пространстве и до 120 м – внутри здания. Если компьютеры оснастить сетевыми адаптерами Xircom CreditCrd Netwre и ОС Windows 95 98 или Windows NT то они могут без кабеля функционировать как одноранговые сети. Беспроводные ЛВС с радиопередачей данных Если уже работает сеть на основе Windows NT Server то к ней можно подключить сегмент беспроводной сети если к одному...