Science for all





Original article: http://staff.um.edu.mt/jskl1/talk.html

შესავალი OOP IN SIMULA
© 1997 ჯ Sklenar ([email protected])


 

ეს დოკუმენტი ეფუძნება ეს სემინარი . წ. 30 წლის ობიექტზე ორიენტირებული დაპროგრამება (OOP) გაიმართა უნივერსიტეტის მალტის 5/12/1997. საქართველოს პირველი ობიექტზე ორიენტირებული ენის (OOL) Simula 67 ოფიციალურად გააცნო ოლე Johan Dahl და Kristen Nygaard იმ IFIP TC 2 სამუშაო კონფერენცია სიმულაციური ენებზე Lysebu ახლოს ოსლოში მაისში 1967. 30 წლის წარმოადგენს ერთი ადამიანის და რამდენიმე კომპიუტერის თაობები. მიუხედავად იმისა, რომ გამოიყენება ისეთი დიდი ხნის განმავლობაში, ყველა თანამედროვე პროგრამირების მუშაობა ხორციელდება დღეს ეფუძნება პრინციპების OOP გააცნო პირველად Simula განმარტება. და რა არის უფრო მნიშვნელოვანი, Simula შეიცავს ობიექტების, რომ დღემდე სრულად არ არის გამოყენებული და არც კი ესმოდა, არა მხოლოდ ზოგადი პროგრამირების საჯარო მაგრამ ასევე ადამიანი OOP საზოგადოებას. იმ მიზნით, რომ საუბარი იყო მოკლე შესავალი ძირითადი Simula თვისებები, ძირითადად, ის არ იმყოფება სხვა OOLs. იგივე მიზანს ემსახურება ეს დოკუმენტი.

შენიშვნები:
  • შემდეგი ტექსტი ტერმინი ობიექტის იმას ნიშნავს, a კლასის მაგალითად (შენიშვნა, რომ “ობიექტი” – ობიექტი, პასკალ და ზოგიერთი სხვა OOLs, ფაქტობრივად კლასები).
  • თქვენ შეგიძლიათ ჩამოტვირთოთ ყველა პროგრამები (simprogs.zip) იმის გათვალისწინებით, ამ დოკუმენტს და ზოგიერთი სხვა. არსებობს ასევე Turbo Pascal აპარატი SIMSET.პა ძალიან გავს Simset ” Simula. გამოვიყენოთ თუ გვინდა, მუშაობა მონაცემთა სტრუქტურები სხვადასხვა რაოდენობის საკითხი. გაფართოების zip ფაილი ზოგიერთ დირექტორია, სადაც თქვენ ნახავთ სიას პროგრამების ერთად მოკლე აღწერა ფაილის Readme.
  • თუ თქვენ ხართ ახალი სიმულაციური, განიხილოს ათვალიერებს გვერდი სიმულაციური , რომელიც განმარტავს, ძირითადი იდეები კომპიუტერული მოდელირება.

შინაარსი:

SIMULA – ძირითადი ფაქტები

SIMULA მე ისტორია

SIMULA 67 ისტორია

SIMULA მონაცემთა ტიპები

SIMULA განცხადებები

SIMULA პროცედურები

SIMULA კლასი

SIMULA პაკეტები = წყობილი კლასი

SIMULA სტანდარტული პაკეტების

SIMULA QUASIPARALLEL სისტემები

სიმულაციური = სამყაროში პარალელური პროცესები

SIMULA წყობილი QPS

SIMULA წყობილი სიმულაციური

რა არის ცუდი SIMULA ?

ლიტერატურა

დავუბრუნდეთ ავტორის მთავარი გვერდი

 


SIMULA – ძირითადი ფაქტები


Simula I = პროცესი ორიენტირებული დისკრეტული სიმულაციური ენის საფუძველზე Algol 60. (1964 – 1965) ერთდlation language.

Simula 67 = გენერალური ობიექტზე ორიენტირებული ენის სისტემა კლასების მხარდამჭერი დაკავშირებული სიები (სისტემა კლასის Simset) და დისკრეტული პროცესი ორიენტირებული მოდელირება (სისტემა კლასში სიმულაციური). (1967 – 1971) სიმ –ple universal language.

Simula = Simula 67 (ნომერი არ გამოიყენება რაიმე სხვა, რადგან Simula მე მას არ იყენებდნენ დიდი ხნის განმავლობაში).

ფიგურა 1: ძირითადი ნაწილები და ინტერფეისი ხაზები Simula გარემოს.
უკან შინაარსი


SIMULA მე ისტორია


(წყარო: Jan Rune Holmevik: შედგენის Simula – ვნახოთ ცნობას)

1952 Kristen Nygaard იწყებს მუშაობას ოპერაციების კვლევა, მათ შორის, წერა სიმულაციური მოდელები. პრობლემა: როგორ conceptualize კომპლექსი რეალურ სამყაროში. მას შემდეგ, რაც თავიდანვე Simula განკუთვნილი უნდა იყოს ორივე სისტემის აღწერა და პროგრამირების ენა.

1960 Algol 60 თავისი ნამდვილი რეკურსიული ბლოკი მექანიზმის სტრუქტურა ეფუძნება დასტის პრინციპი. ყველა მნიშვნელოვანი კონტროლი სტრუქტურების გააცნო. Simula განკუთვნილი პაკეტი preprocessor , რომ Algol 60.

1962 Ole-იოჰან Dahl და კრისტენ Nygaard შეხვდება ნორვეგიის გამოთვლითი ცენტრი (NCC) ოსლოში. პირველი ოფიციალური ენის წინადადება წარმოდგენილი IFIP 62 მსოფლიო კონგრესის მიუნხენში.

1962 Simula მიერ მხარდაჭერილი პროექტის UNIVAC, რის შედეგადაც UNIVAC 1107 მონტაჟი NCC 1963 წელს.

1963 კონფლიქტი მკაცრი Algol დასტის მექანიზმი და Simula ის დახვეწილი სიმულატორი ობიექტებზე ორიენტირებული უფრო მდგომ პრინციპი. Preprocessor იდეა მიტოვებული, Simula უნდა იყოს დამოუკიდებელი Algol დაფუძნებული ენაზე.

1963 Ole-იოჰან Dahl მუშაობს ახალ შენახვის განაწილების სქემა ეფუძნება ორ განზომილებიანი სია უფასო სფეროში.

1964 ორიგინალური იდეა პასიური მომხმარებელს მოძრავი მეშვეობით ქსელის აქტიური კომპონენტები (აქტივობა მიდგომა) გახდა შეზღუდვის ფაქტორი. სხვა გზა რაუნდი შესაძლებელია – აქტიურ მომხმარებელს, მოძრავი მეშვეობით პასიური ქსელი. ამან გამოიწვია გამაერთიანებელი ზოგადი პროცესი კონცეფცია:

სისტემის = კომპლექტი ძალებთან quasiparallel პროცესები.
1964 წელს პირველი პროტოტიპი Simula შემდგენელი გაშვებული NCC-ის UNIVAC 1107 დეკემბერში, Simula მე მექანიკური გამოჩნდა, შესაძლოა, 1965. პირველი წლის განმავლობაში Simula მიმართა ფართო ფართი ოპერაციების კვლევის პრობლემები.

უკან შინაარსი


SIMULA 67 ისტორია


(წყარო: Jan Rune Holmevik: შედგენის Simula – ვნახოთ ცნობას)

1965,66 Simula მე შვედეთში, გერმანიაში, აშშ (Burroughs B5500), საბჭოთა კავშირის (ურალის 16) და სხვა ქვეყნებში. იმისთვის, რათა გააცნოს და შეასწავლოს ენა.

1965 ტონი Hoare რეკორდი კლასის კონცეფცია წარმოდგენილი Algol ბიულეტენი. შემდეგ ფრთხილად გამოკვლევა, Nygaard და Dahl მიიღოს იდეები, მაგრამ ერთგვარი განზოგადებული კონცეფცია, მაინც დაკარგული.

1966 შემოღების იდეა prefixing. პროცესების (მოგვიანებით ობიექტები) დამზადებული ორი ფენა: პრეფიქსი ფენა, ძირითადი ფენა. იდეა ქვეკლასით. Nygaard და Dahl დაიწყოს მუშაობა ახალი გენერალური მაღალი დონის ენა.

1967 (მაისი). Simula 67 ოფიციალურად გააცნო მიერ Dahl და Nygaard დროს IFIP TC 2 სამუშაო კონფერენცია სიმულაციური ენებზე Lysebu ახლოს ოსლოში.

1967 წლის (ივნისი). განმარტება Simula 67 სტანდარტული მოუწოდა საერთო ბაზა სტანდარტული.

1968 პირველი შეხვედრა Simula სტანდარტების ჯგუფი (SSG). მიღების შემდეგ string გატარება და I/O კეთდება ბიორნ Myhrhaug, Simula ფორმალურად გაყინული.

1973 ასოციაცია Simula მომხმარებელი (ASU) დაარსდა. Simula მეორადი 250-ზე მეტი საიტები, რომ წლის.

შესრულება:

1969 CDC 3300, 3600 (ნორვეგია – ოსლოს უნივერსიტეტი, NDRE)

1971 UNIVAC 1100 (NCC)

1972 წელს IBM 360/370 (NCC)

1972 CII 10070, IRIS 80 (საფრანგეთი)

1973/74 CDC 6000 (საფრანგეთი, ნიდერლანდები), CDC კიბერ 70 (NDRE)

1975 DEC 10 (შვედეთი) და ა.შ.

პერიოდული:

წარმოების წლიური ASU კონფერენციები (პირველი 1973 წელს ოსლო)

ASU ბიულეტენი

უკან შინაარსი


SIMULA მონაცემთა ტიპები


 

Simula შეიცავს ყველა საერთო ობიექტების მაღალი დონის მესამე თაობის ენებზე. სწორედ ამიტომ, მომდევნო ორი თავი ძალიან მოკლე რეფერატების, ტექსტი, რომ ერთადერთი გამონაკლისი.

Value Types

Integer Short Integer
Real Long Real
Boolean Character

Reference Types

Object Reference Declaration: Ref( Object Identifier) (None is the trivial value)
Text Constants: “A”, “Simula”, Notext

ტექსტი არის კონცეპტუალურად კლასის მაგალითად, რომ აქვს თავისი ატრიბუტები და მეთოდები.

Methods:
Boolean Procedure Constant; (True if constant)
Text Procedure Main; (Main string – the text is a part of Main)
Integer Procedure Start; (Starting position in Main)
Integer Procedure Length; (Number of characters)
Integer Procedure Pos; (Current position)
Procedure SetPos(i); Integer i; (Changing position)
Boolean Procedure More; (True if Pos <= Length)
Character Procedure GetChar; (Character from Pos)
Procedure PutChar(c); Character c; (Storing character to Pos)
Text Procedure Sub(i, n); Integer i,n; (Substring at i of length n)
Text Procedure Strip; (Removes right spaces)

De-editing Methods:
Integer Procedure GetInt; (Reads integer)
Long Real Procedure GetReal; (Reads real)
Integer Procedure GetFrac; (Like GetInt, ignores spaces)

Editing methods:
Procedure PutInt(i); Integer i; (Writes integer value)
Procedure PutFix(i, n); Integer i,n; (Writes decimal value)
Procedure PutReal(r, n); Long Real r; Integer n; (Writes in scientific format)
Procedure PutFrac(i, n); Integer i,n; (Groups of 3, spaces)

Text generation:
Text Procedure Blanks(n); Integer n; (Returns n blanks)
Text Procedure Copy(T); Text T; (Returns a copy of T)

Arrays

Examples of arrays declared in blocks (n, m, a, b are global variables):
Integer Array MyList (1:100);
Array Matrix (1:n, 1:m); (Implicit type is real)
Character Array Buffer(1: If a>b then a else b);

უკან შინაარსი


SIMULA განცხადებები


 

Simple statements

Assignment := Examples: X := If a>b Then a Else b ; X:=Y:=0; ( ** available )

Reference Assignment :- Examples: Queue :- New Head; T :- Blanks(80);

Procedure

Go to Goto

Structured statements

Begin … End;

If … Then ; If … Then … Else … ;

Switch Example:

 
Switch Target := L1, L2, L3, ... ;

Goto Target( Index_expression );
 
  L1: ...

  L2: ...

While … do … ;

For (very general) Example:

 
Begin
   Integer i;
   For i:= 1, 13, 20 step 10 until 40, 70, i+1 while i lt 76,
          100 step 50 until 250, 1000, 1500 do  OutInt(i,5);
End;

Output: 1 13 20 30 40 70 71 72 73 74 75 100 150 200 250 1000 1500

უკან შინაარსი


SIMULA პროცედურები


პარამეტრი გავლის რეჟიმი:

ფიგურა 2: პარამეტრი გავლის რეჟიმი მიმართა ტექსტი პარამეტრი.

პროცედურები

მაგალითად პროცედურა ორი შემავალი და ერთი გამომავალი პარამეტრები: (აჩვენებს უფლება indented ტექსტი)

Begin
   Procedure RightText(T, N, FitsIn); Text T; Integer N;
               Name FitsIn; Boolean FitsIn;
   Begin
      Integer I;
      FitsIn := N >= T.Length;   
      For i:=1 step 1 until N-T.Length do OutText(" ");
      OutText(T)
   End of RightText;

   RightText("Short", 30); OutImage;
   RightText("And the long one", 30);
End of Program;

Output:

                         Short
              And the long one

 

 

Functions = Type Procedures

მაგალითად, რიცხვი, ფუნქცია, ორი შეყვანის პარამეტრებს: (Computes უდიდესი საერთო divisor)

Begin
  Integer Procedure GCD(M, N); Integer M, N;
  Begin
     While M<>N do
        If M<N then N := N - M else M := M - N;
     GCD := M
  End of GCD;

  Integer A, B;
  OutText("Enter an integer number: "); OutImage; A := InInt;
  OutText("Enter an integer number: "); OutImage; B := InInt; 
  OutText("Greatest Common Divisor of your numbers is ");
  OutInt(GCD(A,B), 4); OutImage;
End of Program;

შენიშვნა: ფუნქცია შეიძლება ეწოდოს, როგორც თუ ეს იყო typeless პროცედურა.

უკან შინაარსი


SIMULA კლასი


ფიგურა 3: Simula მეცადინეობა შედგება ოთხი ნაწილისაგან.

Declaration:

 
Class Rectangle (Width, Height); Real Width, Height;
                           ! Class with two parameters;
 Begin
    Real Area, Perimeter;  ! Attributes;

    Procedure Update;      ! Methods (Can be Virtual);
    Begin
      Area := Width * Height;
      Perimeter := 2*(Width + Height)
    End of Update;

    Boolean Procedure IsSquare;
      IsSquare := Width=Height;

    Update;                ! Life of rectangle started at creation;
    OutText("Rectangle created: "); OutFix(Width,2,6);
    OutFix(Height,2,6); OutImage
 End of Rectangle;

 

Object Generation:

Ref(Rectangle) R; (Class reference variable)

R :- New Rectangle(50, 40); Activities involved in this object generation:

      Memory allocation, reference stored to R.
      Copying values to parameters (value passing only).
      Starting the object's body (life rules).

Declaration of Subclasses:

Rectangle Class LocRectangle (X, Y); Integer X, Y;
Begin                                        ! More parameters;
   Boolean Tall;                             ! More attributes;
   Procedure Move (Dx, Dy); Integer Dx, Dy;  ! More methods;
   Begin
      X := X + Dx; Y := Y + Dy
   End of Move;
                                             ! Additional life rules;
   Tall := Height > Width;
   OutText("Located at: "); OutFix(X,2,6); OutFix(Y,2,6); OutImage
End of LocRectangle;

Object Generation:

Ref(Rectangle) R; (Class reference variables)
Ref(LocRectangle) LR;

R :- New Rectangle(50, 40);
LR :- New LocRectangle(20, 30, 100, 200); (Note that also parameters for the parent class are given)

Activities involved in the above object generation:

      Memory allocation, reference stored to LR.
      Copying values to all parameters (parent class first).
      Starting the body of the parent class, then the subclass.

ეს შეიძლება იყოს განზოგადებული , რომ პრეფიქსი თანმიმდევრობით ნებისმიერი სიგრძე:

Class A; Begin … LifeA End;
A Class B; Begin … LifeB End;
B Class C; Begin … LifeC End;
Ref(C) X;

X :- New C;

თუ არ შეცვალა by Inner – იხილეთ შემდეგი პუნქტის, თანმიმდევრობა საქმიანობაში ჩართული აღნიშნული ობიექტის თაობა:

LifeA LifeB LifeC

Breaking ცხოვრების წესების განცხადება შიდა:

მაგალითად დეკლარაციების:

Class A; Begin LifeA1 Inner; LifeA2 End;
A Class B; Begin LifeB1 Inner; LifeB2 End;
B Class C; Begin LifeC1 Inner; LifeC2 End;
Ref(C) X;

X :- New C;

თანმიმდევრობა საქმიანობაში ჩართული აღნიშნული ობიექტის თაობა:

LifeA1 LifeB1 LifeC1 (შიდა ცხოვრებაში C იგნორირებული) LifeC2 LifeB2 LifeA2

შენიშვნები:
1) დაკარგული შინაგანი არის იგივე როგორც შიდა, უბრალოდ ადრე კლასის ბოლოს.
2) ძირითადად ერთი შიდა დასაშვებია კლასის ორგანოს.

 

Prefixing ბლოკები:

მოდით ვივარაუდოთ, პროგრამის შემდეგი სტრუქტურა:

Begin
   Class A(P); Integer P;
   Begin  LifeA1  Inner;  LifeA2  End;
   Part1
   A(3) Begin
     Block body
   End;
   Part2
End;

საქმიანობაში ჩართული აღსრულების ზემოთ prefixed ბლოკი:

      Creating a class instance of A.
       Copying values to its parameter(s).
       Starting the body of the class, that includes execution of the block code.

ასე რომ, ზემოთ აღნიშნული პროგრამის თანმიმდევრობა ოპერაციებში არის ეს:

 Part1   LifeA1   Block body   LifeA2   Part2

 

Prefixed ბლოკი არის, კონცეპტუალურად a კლასის ინსტანციის გარეშე სახელი რომ აქვს:

– პარამეტრების პრეფიქსი კლასი

– უფრო ატრიბუტები (კლასი ატრიბუტები + ადგილობრივი ბლოკი ცვლადები)

– უფრო მეთოდები (კლასის მეთოდები + ადგილობრივი ბლოკი პროცედურები)

– უფრო რთული ცხოვრების წესები (კლასი სხეულის + ბლოკის ორგანო).

შენიშვნები:
1) ბლოკი prefixing მექანიზმი არ არის ძალიან სასარგებლო შემთხვევაში მარტივი კლასები. შესაძლო გამოყენება, იმპორტი კლასის დეკლარაციების (პარამეტრების, ატრიბუტები და მეთოდები) შევიდა ბლოკი. ეს უნდა იყოს გამოყენებული, ძირითადად ძირითადი კლასების (იხილეთ მომდევნო თავში), რომელიც წარმოადგენს მოდულები მიერ შექმნილი OOP პრინციპები. Prefixing ბლოკის მიერ ძირითადი კლასი (როგორიცაა, მაგალითად, სიმულაციური) შეიძლება იმპორტი მთელი პროგრამირების გარემოში ან სპეციალური დანიშნულების Simula დაფუძნებული ენებზე.
2) Simula პროგრამები არ არსებობს აშკარა მეხსიერება deallocation რადგან ნაგვის კოლექციონერი აღდგება ავტომატურად მეხსიერება მიერ ოკუპირებული არ არის დამოწმებული კლასის შემთხვევები.

 

ნავიგაცია in პრეფიქსი თანმიმდევრობა

შემდეგი ტექსტი ეფუძნება ეს დეკლარაციების:

Class A; Begin Ref(A) Link; Procedure Show; … End;
A Class B; Begin Procedure Show; … End;
B Class C; Begin Procedure Show; … End;

Ref(A) XA, First, Current; Ref(B) XB; Ref(C) XC;

1. საკვალიფიკაციო მიერ შეამოწმოს განცხადება

ა) მარტივი

Inspect XA do Show; does basically the same as XA.Show;

განსხვავება ის არის, რომ შეამოწმოს , თუ XA = None, განცხადება, შემდეგ არ არის იგნორირებული. თუ XA = None, XA.შედეგების ჩვენება, რომელიც აწარმოებს დროს შეცდომა.

ბ) ტესტირების არც მიერ პუნქტი, წინააღმდეგ შემთხვევაში

Inspect XA do Begin
Show; …
End
Otherwise Begin
OutText(“Sorry, XA not created”); OutImage
End;

გ) ტესტირების ტიპი მიერ პუნქტი , როდესაც

ნაჩვენებია დაკავშირებულია სია დამზადებული სხვადასხვა ნივთები სახეები A, B, და C, რომლის ხელმძღვანელი მაჩვენებელი არის პირველი:

Current :- First;
While Current ne None do begin
  Inspect Current
    When A do Show    ! Show of A;
    When B do Show    ! Show of B;
    When C do Show    ! Show of C;
    Otherwise OutText("Not a (sub)class of A");
  OutImage;
  Current :- Current.Link
End While;

2. გამდინარე საკვალიფიკაციო მიერ Qua პუნქტი

ვივარაუდოთ, რომ ამ განცხადების საფუძველზე, აღნიშნული დეკლარაციები:

XA :- New B;  XB :- New B;
XA.Show;        ! Show of A;
XA Qua B.Show;  ! Show of B - it is possible to go down;
XB Qua A.Show;  ! Show of A - it is possible to go up;
XA :- New A;
XA Qua B.Show;  ! This is illegal - attributes of B do not exist;

შენიშვნა: ნორმალური თვისებები მინიშნება ცვლადი კვალიფიციური ბ გამოცხადდა Ref(B) XB :

  • ვერ მითითება ობიექტები კლასის A.
  • შეიძლება reference ობიექტი class B, რომელიც საშუალებას აძლევს ხელმისაწვდომობის ატრიბუტები B და იმ არ re-განაცხადა B.
  • შეიძლება reference ობიექტები კლასის C, მაგრამ მხოლოდ ატრიბუტები B და არ re-განაცხადა ატრიბუტები შეიძლება გამოიყენოთ.
ეს ნორმალური თვისებები შეიძლება დაძლეულ შეამოწმოს ან Qua. შენიშვნა მესამე წესი, რომ ჩვეულებრივი გვიან სავალდებულო მექანიზმი (როგორც, მაგალითად, Object Pascal) არ მუშაობს ავტომატურად Simula. ამ პრობლემის არის შეამოწმოს ერთად , როდესაც დებულებები – ვხედავთ, აღნიშნული მაგალითი. Simula ის მიდგომა, შესაძლოა, ნაკლებად მოსახერხებელი, მაგრამ ეს უფრო ზოგადი და პროგრამისტი აქვს ყველაფერი კონტროლის ქვეშ.
3. მითითება თავად ამ

შემდეგი კოდი არის მეთოდი, რომელიც დასძენს ობიექტის სიაში პირველი:

Procedure Add_to_List(First); Name First; Ref(A) First;
Begin
   Link :- First; First :- This A
End;


4. ტესტირება საკვალიფიკაციო მიერ არის და ამ

შემდეგი selfexplaining კოდი სეგმენტების საფუძველზე დეკლარაციების Ref(B) XB და Ref(A) XA ნახოთ გამოყენება ძალიან მოსახერხებელი ოპერატორები არის და წელს. გაითვალისწინეთ, რომ, მაგალითად, Object Pascal არ აქვს en ექვივალენტი წელს. ერთადერთი გამოსავალი, რომ ეს პრობლემა Object Pascal არის განხორციელების მეთოდები, რომ დაბრუნების იდენტიფიკაციის წინაპრები.
If XB is B then
  OutText("XB is B")
Else
  OutText("XB is either subclass of B or None");
 
If XA in B then
  OutText("XA is either B or its subclass")
Else
  OutText("XA is either A or None");

5. დაცვის ატრიბუტები

ფარული ატრიბუტები შეიძლება იყოს გამოყენებული მხოლოდ სხეულის კლასი, სადაც ისინი განაცხადა.

დაცული ატრიბუტები შეიძლება იყოს გამოყენებული მხოლოდ ორგანოებში კლასი, სადაც ისინი გამოაცხადა და ყველა ქვეკლასით.
უკან შინაარსი

SIMULA პაკეტები = წყობილი კლასი


ფიგურა 4: Simula კლასები შეიძლება იყოს წყობილი, რომ ნებისმიერი სიღრმე.

კლასი, რომელიც შეიცავს დეკლარაცია ადგილობრივი კლასი ეწოდება, ძირითადი კლასები. შემდეგი მაგალითი კოდი განსაზღვრავს ძირითადი კლასი. წ. გეომეტრია.

! The program defines the main class "Geometry". ;
! It represents a theory with terms "point, rectangle, circle, and line".;

Class Geometry;
Begin

  Class Point(X,Y); Real X,Y;
  Begin
    Procedure Print; Begin  ...  End;
    Procedure Shift(Dx, Dy); Real Dx, Dy; Begin  ...  End;
    Print;                  ! Life of point;
  End of Point;

  Class Rectangle(RecName, Width, Height);
       Text RecName; Real Width, Height;
  Begin
    Real Area, Perimeter;
    Procedure Update; Begin  ...  End;
    Procedure Show; Begin  ...  End;
    Update; Show;           ! Life of rectangle;
  End of Rectangle;

  Class Circle(Radius, Center); Real Radius; Ref(Point) Center;
  Begin
    Procedure Shift(Dx, Dy); Real Dx, Dy; Begin  ...  End;
    OutText("Circle created at "); ! Life of circle;
    Center.Print;
  End of Circle;

  Class Line(M,N); Ref(Point) M,N; ! Line defined by two points;
  Begin
    Real Slope;
    Slope :=  ...  ;       ! Life of line;
  End of Line;

  !Variables declared in geometry: ;
  Ref(Point) Origin, A, B;
  Ref(Line) X,Y;

  !Life of geometry: ;
  Origin :- New Point(0,0); ! Creating the origin;
  A :- New Point(1,0); B :- New Point(0,1);
  X :- New Line(Origin, A); ! Creating the axes;
  Y :- New Line(Origin, B);
  OutText("*** Geometry initialized ***"); OutImage;
End of Geometry;
შემდეგი პროგრამის გამოყენებით, ძირითადი კლასი გეომეტრია. ყურადღება მიაქციეთ, როგორ კლასები გამოცხადებულია გეომეტრია გამოიყენება განაცხადოს ქვეკლასით სპეციალიზებული პრობლემა გვარდება. შემდეგ არ არის გამორიცხული, რომ განაცხადოს, და გამოიყენოთ მინიშნება ცვლადები კვალიფიციური შევიდა როგორც იმპორტული და ადგილობრივად განაცხადა კლასები. ეს არის ფუნდამენტური იდეა Simula დაფუძნებული პაკეტების ან მომხმარებლის განსაზღვრული ენაზე (რა განსხვავებაა?)

 

External Class Geometry;
Geometry Begin
  ! Subclasses declared in the prefixed block: ;
  Point Class Color_Point(C); Character C; Begin  ...  End;
  Rectangle Class Square; Begin  ...  End;

  ! Variables declared in the prefixed block: ;
  Ref(Color_Point) A1;
  Ref(Point) C, D;
  Ref(Circle) K;
  Ref(Line) E, F;
  Ref(Rectangle) R1;
  Ref(Square) S1;

  ! Block body: ;
  C :- New Point(5,6);
  D :- New Point(20,30);
  A1 :- New Color_Point(3, 4, 'G');
  K :- New Circle(10, C);
  E :- New Line(C, D);
  F :- X;
  K.Shift (1,1);
  R1 :- New Rectangle("Rec_R1", 5, 4);
  S1 :- New Square("Square_S1", 4, 6);
  S1.Show;
End of prefixed block;
უკან შინაარსი

 


SIMULA სტანდარტული პაკეტების


 

გარემო – სისტემის ობიექტების
ატრიბუტები ხელმისაწვდომია:
  • გარემოს მუდმივები (MaxInt, MaxReal, … )
მეთოდები ხელმისაწვდომია:
  • ძირითადი არითმეტიკული ოპერაციების (Mod, Abs, trc, esp, … )
  • ძირითადი ტექსტი და ხასიათი გატარება (ასლი, ბლანკები, UpCase, … )
  • მათემატიკური ფუნქციების (Sin, Exp, … )
  • ექსტრემალური ფუნქციები (Max, Min)
  • შემთხვევითი რიცხვები (ფრე, ფორმა, ნორმალური, ისტორია, … )
  • შემდგენელი ინფორმაცია (SourceLine, SIMULAId)
  • სხვები (შეცდომა, ზედა/LowerBound კოლექტორები, თარიღი, დრო … )

BasicIO – მსოფლიოში გარეთ
ყველა input და output operations წარმოდგენილია მეთოდები ფაილი ობიექტები. საერთო წინაპრის მოუწოდა ფაილი – გრაფიკი 5 – ინვენტარი ობიექტების საერთო ყველა ფაილი. მისი ქვეკლასით არიანByteFile და ImageFile (ტექსტური ფაილი, – “image” არის მისი ტექსტი ბუფერული). ორივე შემდგომი სპეციალიზებული მიხედვით წვდომის მეთოდი (input output, პირდაპირი დაშვება). OutFile აქვს ერთი descendent PrintFile რომ ინვენტარი გვერდი ორიენტირებული ტექსტი გამომუშავება. გაითვალისწინეთ, რომ Simula არ აქვს აკრეფილი ფაილი გააკეთა, მაგალითად, ჩანაწერები. ამ ტიპის ფაილი შეიძლება განხორციელდეს by byte ფაილი. ფიგურა 5 შეიცავს რაღაც უფრო მნიშვნელოვანი მეთოდები selfexplaining სახელები.

ფიგურა 5: იერარქიაში Simula ფაილი კლასები.

პროგრამის ფარგლებში
ყველა სისტემის ობიექტების Simula არიან კონცეპტუალურად განხორციელდა, რაც კლასები გარკვეული ატრიბუტები, მეთოდები და ადგილობრივი კლასები. მომხმარებლის პროგრამები იწერება, თითქოს ისინი ჩასმული შევიდა შემდეგი კარკასი. გაითვალისწინეთ, რომ ცხოვრების წესების კლასის BasicIO შექმნა და ღია სისტემა ფაილი დაწყებამდე მომხმარებლის კოდი. მას შემდეგ, რაც მისი შეწყვეტის სისტემა ფაილი დახურულია. მომხმარებლის კოდი არის ჩასმული შევიდა ორმაგი შეამოწმოს განცხადებაში. ეს იმას ნიშნავს, რომ მეთოდები სისტემა ფაილი (როგორიცაა, მაგალითად, GetInt, OutImage და ა. შ.) არ უნდა იყოს წინ უძღოდა ფაილის სახელი.

 

Begin
  Class Environment; ...
  Environment Class BasicIO ... ;
  Begin
    Ref(InFile) SysIn; Ref(OutFile) SysOut; ...
    Class Simset ... ;
    Simset Class Simulation ... ;
    Procedure Terminate_Program;
    Begin ... ; GoTo STOP End;
     ...
    SysIn :- New InFile ( ... );
    SysOut :- New PrintFile ( ... );
    SysIn.Open ( ... );
    SysOut.Open ( ... );
    Inner;                 ! This starts the user program;
   STOP: SysIn.Close ( ... );
    SysOut.Close ( ... )
  End BasicIO;

BasicIO Begin
    Inspect SysIn do
      Inspect SysOut do

Begin                ! User program starts by this begin;
       User statements
      End;                 ! Last line of user program;

End;
End;

 

 

 

Simset – მსოფლიოს დაკავშირებული სიები

 

სისტემა კლასის Simset ინვენტარი წრიული ორი გზა უკავშირდება სიები ხელმძღვანელი ნივთი ჩართული აკავშირებს, რომ თავდაპირველად სახელწოდებით “კომპლექტი” – იხილეთ ნახაზი 6.

გრაფიკი 6: Simula დაკავშირებული სიები განხორციელდა სისტემის კლასის Simset.
 

ზემოთ ჩამოთვლილია წარმოდგენილია სამი კლასი – გრაფიკი 7. განმცხადებელი არის ცოდნა ორი გზა აკავშირებს, როგორც ასეთი. ეს არის კიდევ უფრო სპეციალიზებული, როგორც უფროსი და წევრი ელემენტები.

Figure 7: Classes declared in the system class Simset.

Methods of list related classes:

Linkage
  • Suc is the successor qualified to Link (None for the last item of the list).
  • Pred is the predecessor qualified to Link (None for the first item of the list).
  • Prev is the previous item qualified to Linkage.

Head
  • First is the first item of the list (None if the list is empty).
  • Last is the last item of the list (None if the list is empty).
  • Empty returns true if the list is empty.
  • Cardinal is the number of items in the list.
  • Clear removes all items from the list, memory will be recovered by the garbage collector.

Link
  • Into(S) inserts the item at the end of the list (Head) S.
  • Out removes the item from the list.
  • Follow(L) inserts the item that performs this method after the Linkage L.
  • Precede(L) inserts the item that performs this method before the Linkage L.
Methods can be combined to represent complex activities. For example the procedure statement:

Queue1.Last.Precede(Queue2.First);
removes the last item from Queue1 and inserts it at the beginning of Queue2.

უკან შინაარსი


SIMULA QUASIPARALLEL სისტემები


 

 

ცხოვრება წესები Simula ობიექტები არიან coroutines, რომ შეიძლება დროებით შეწყდეს და შემდეგ განაახლა. არსებობს ორი დონის (კვაზი)პარალელიზმის in Simula. პირველ დონეზე არ მუშაობს, პროგრამისტი “ფიქრობს, რომ quasiparallel”. მეორე დონეზე შემოაქვს ცნება, პროგრამისტი მუშაობს პარალელურად (მომხმარებლის თვალსაზრისით) პროცესებში. პირველ დონეზე შეიძლება იქნას გამოყენებული ყველა კლასები, მეორე დონეზე ხორციელდება კლასის პროცესი, სისტემის კლასში სიმულაციური. გრაფიკი 8 აჩვენებს შესაძლებელი ქვეყნების coroutine (body) ობიექტის X. გაითვალისწინეთ, რომ coroutine, რომ არ გამოიყენოთ ნებისმიერი შემდეგი ობიექტების პირველ რიგში ერთვის, მაშინ წყდება (ობიექტები სხვა OOLs ყოველთვის წყდება). წყდება ობიექტი შეიძლება კიდევ იყოს გამოყენებული (შესაძლებელია დარეკეთ მისი მეთოდები და/ან წვდომის მისი ატრიბუტები). ეს არის Simula ობიექტების (მეთოდები ხელმისაწვდომია ყველა კლასები), რომ მხარდაჭერა, მუშაობა quasiparallel სისტემები (QPS):

 

Detach აჩერებს აღსრულებას მიმდინარე ობიექტის (ერთი, რომ ასრულებს გაშლა). მიმდინარე ობიექტი ხდება მოშორება. კონტროლის გავიდა იმ წერტილში, სადაც მიმდინარე ობიექტი იყო, ან შეიქმნა, ან განაახლეს.

 

Resume(Y) ააქტიურებს მდგომი ობიექტის Y, რომ ხდება განაახლა. მიმდინარე ობიექტი ხდება მოშორება.

 

Call(Y) მსგავსი რეზიუმე, მაგრამ ობიექტი Y ხდება ერთვის მიმდინარე ობიექტი. მიმდინარე ობიექტი ხდება მოშორება. მიმდინარე ობიექტი იქნება განაახლა მას შემდეგ, რაც detaching Y.

 

გრაფიკი 8: ქალაქი დიაგრამა Simula coroutines.


 

 

QPS მაგალითი 1: ჭადრაკი თამაში კონტროლის გამოყენებით ორი ბატონის მიდგომა.

 

შემდეგ პროგრამა არსებობს სამი coroutines: ორი მოთამაშე და მთავარი ბლოკი. გაითვალისწინეთ, რომ პირველი ორი ნაბიჯები განსაკუთრებული. მოთამაშეს შეუძლია მოიგოს გარკვეული ალბათობა მესამე გადაადგილება წლიდან მოყოლებული: ფრე(0.3,სათესლე) არის ლოგიკური ფუნქცია, რომელიც აბრუნებს true ალბათობა, 0.3. ყურადღება მიაქციეთ, როგორ ძირითადი ბლოკი ქმნის ორი მოთამაშე, ბმულები მათ მიერ ატრიბუტები მოწინააღმდეგე და პასს კონტროლის თეთრი. შემდეგ ფეხბურთელები არაერთხელ, რომ მათი ნაბიჯები და რეზიუმე მოწინააღმდეგე, სანამ ერთ-ერთი მათგანი მოიგებს. ამ წყვეტს მათი ორგანოები და კონტროლის გავიდა მთავარი ბლოკი.

Begin
   Boolean Mate;
   Ref(Player) White, Black, Winner;
   Integer Seed;

   Class Player(PName); Text PName;
   Begin
     Ref(Player) Opponent;
     Integer Move;
          ! The life follows;
      Detach;
      OutText(PName); OutText("'s First Move"); OutImage;
      Resume(Opponent);
      OutText(PName); OutText("'s Second Move"); OutImage;
      Resume(Opponent);
      Move := 2;
      While not Mate do begin
         Move := Move+1;
         OutText(PName); OutText("'s Move # ");
         OutInt(Move,3); OutImage;
         If Draw(0.3,Seed) then begin
            Mate := true; Winner :- This Player;
         End If;
         Resume(Opponent);
      End While;
   End of Player;

   Begin   ! QPS head;
      OutText("Creating Players, Starting the white one"); OutImage;
      White :- New Player("White");
      Black :- New Player("Black");
      White.Opponent :- Black;
      Black.Opponent :- White;
      Seed := 17;
      Resume(White);
      OutText("Finish: "); OutText(Winner.PName);
      OutText(" won in move"); OutInt(Winner.Move,3); OutImage;
   End of QPS
End of program;


 


 

ეს არის indented გამომავალი ზემოთ პროგრამა. წანაცვლება გვიჩვენებს ობიექტი, რომელიც ქმნის გამომავალი – მარცხენა: მთავარი ბლოკი, თეთრი, შავი.

 

Creating Players, Starting the white one
  White's First Move
    Black's First Move
  White's Second Move
    Black's Second Move
  White's Move #   3
    Black's Move #   3
  White's Move #   4
    Black's Move #   4
Finish: Black won in move  4

 


 

QPS მაგალითი 2: ჭადრაკი თამაში კონტროლის გამოყენებით ოსტატი და ორი მონები მიდგომა.
შემდეგ პროგრამა ასევე არსებობს სამი coroutines: ორი მოთამაშე და მთავარი ბლოკი. განსხვავება ამ და წინა პროგრამა არის აქტიური როლი მთავარი ბლოკი. მოთამაშეებს არ რეზიუმე ერთმანეთს. ისინი უბრალოდ გააკეთეთ სვლა და გაშლა. მთავარი ბლოკი ააქტიურებს მათ არაერთხელ, სანამ ერთ-ერთი მათგანი მოიგებს. შენიშვნა გამოყენების დარეკეთ – ფეხბურთელები, რომლებიც არაერთხელ ერთვის ძირითადი ბლოკი.

 


 

Begin
   Boolean Mate;
   Ref(Player) White,Black,Winner;
   Integer Seed;

   Class Player(PName); Text PName;
   Begin
     Ref(Player) Opponent;
     Integer Move;

     ! The life follows;
      Detach;
      OutText(PName); OutText("'s First Move"); OutImage;
      Detach;
      OutText(PName); OutText("'s Second Move"); OutImage;
      Detach;
      Move := 2;
      While true do begin
         Move := Move+1;
         OutText(PName); OutText("'s Move # ");
         OutInt(Move,3); OutImage;
         If Draw(0.05,Seed) then begin
            Mate := true; Winner :- This Player;
         end;
         Detach;
      End While;
   End Player;

   Begin
      OutText("Creating Players, Starting the game"); OutImage;
      White :- New Player("White");
      Black :- New Player("Black");
      White.Opponent :- Black;
      Black.Opponent :- White;
      Seed := 11;
      While not Mate do begin
         Call(White);
         If not Mate then Call(Black)
      End While;
      OutText("Finish: "); OutText(Winner.PName);
      OutText(" won in move"); OutInt(Winner.Move,3); OutImage;
   End
End;


This is the indented output of the above program. Indentation shows the object, that generates the output – from left: Main block, White, Black.

Creating Players, Starting the game
  White's First Move
    Black's First Move
  White's Second Move
    Black's Second Move
  White's Move #   3
    Black's Move #   3
  White's Move #   4
    Black's Move #   4
  White's Move #   5
    Black's Move #   5
  White's Move #   6
Finish: White won in move  6


QPS Example 3: Chess game control using Master and Two Slaves approach implemented as a package (main class).
In the following program the main class Chess declares two local classes: Player and Referee. The life rules of the main class prepare the game by creating and linking the two players and the referee. All three objects detach and the body of the main class terminates. The game must be started by the program (a block prefixed by Chess). Prefixing imports all declarations and prepares the game. Note, that the prefixed block just activates the referee and evaluates the game.


Class Chess;     ! Main class with local: Player, Referee;
   Begin
   Boolean Mate;
   Ref(Player) White,Black,Winner;
   Ref(Referee) Master;
   Integer Seed;

   Class Player(PName); Text PName;
   Begin
     Ref(Player) Opponent;
     Integer Move;
                ! The life of Player;
      Detach;
      OutText(PName); OutText("'s First Move"); OutImage;
      Detach;
      OutText(PName); OutText("'s Second Move"); OutImage;
      Detach;
      Move := 2;
      While true do begin
         Move := Move+1;
         OutText(PName); OutText("'s Move # ");
         OutInt(Move,3); OutImage;
         If Draw(0.05,Seed) then begin
            Mate := true; Winner :- This Player;
         end;
         Detach;
      End While;
   End Player;

   Class Referee;
   Begin
      Detach;
      While not Mate do begin
         Call(White);
         If not Mate then Call(Black)
      End While
   End of Referee;

   Begin     ! Life of Chess;
      Seed := 11;
      OutText("Creating the Players and the Master"); OutImage;
      White :- New Player("White");
      Black :- New Player("Black");
      White.Opponent :- Black;
      Black.Opponent :- White;
      Master :- New Referee;
   End
End of Chess;
The next program uses the main class Chess:
 
External Class Chess;

Chess Begin
    OutText("Resuming the Master"); OutImage;
    Resume(Master);
    OutText("Finish: "); OutText(Winner.PName);
    OutText(" won in move"); OutInt(Winner.Move,3); OutImage;
End of Program;


This is the indented output of the above program. Indentation shows the object, that generates the output – from left: Body of Chess, Prefixed block, White, Black.

Creating the Players and the Master
  Resuming the Master
    White's First Move
      Black's First Move
    White's Second Move
      Black's Second Move
    White's Move #   3
      Black's Move #   3
    White's Move #   4
      Black's Move #   4
    White's Move #   5
      Black's Move #   5
    White's Move #   6
  Finish: White won in move  6
უკან შინაარსი

სიმულაციური = სამყაროში პარალელური პროცესები


 

” ძირითადი ცნება სისტემა კლასში სიმულაციური არის პროცესი – თანმიმდევრობა გამდინარე ღონისძიებები (წარმოდგენილი კოდი სეგმენტების) გამოყოფილი პასიური პერიოდები. ფიგურა 9 გვიჩვენებს კლასები გამოცხადებულია სიმულაციური და მათი მეთოდები. Event Notice (ქვეკლასით ბმული) წარმოადგენს დაგეგმილი ღონისძიება რომ მოხდება გარკვეული დრო – EvTime – მომავალი. Proc არის პროცესი, რომლის კოდი სეგმენტი იქნება გააქტიურებული. SQS (ქვეკლასით ხელმძღვანელი) არის სია, მოვლენების დაკვეთით. ეს არის ჩვეულებრივი კალენდარი დისკრეტული სიმულაციური ენებზე. კონცეპტუალურად ეს წესრიგიანი უკავშირდება სია, შიდა განხორციელება, როგორც წესი, ეფუძნება უფრო ეფექტური ხის სტრუქტურა. ცხადია, ეს სია ვერ იქნება ხელმისაწვდომი პირდაპირ მომხმარებელს პროგრამა. არსებობს დანიშვნა საშუალებები – ვნახოთ მოგვიანებით, რომ მხარდაჭერა, მუშაობა დრო და ურთიერთდახმარების სინქრონიზაციის პროცესები. პროცესების შესახებ, პროგრამა ქვეკლასით საერთო წინაპარი პროცესი. პირველი ორი მეთოდი, ტესტის თავისი სტატუსი, დანარჩენი ორი დაბრუნების შემდეგ დაგეგმილია ღონისძიება და მისი გააქტიურება.

ფიგურა 9: კლასების სისტემა კლასში სიმულაციური.

ობიექტების სისტემა კლასში სიმულაციური ახორციელებენ “დაბალი დონის” quasiparallel მეთოდები: გაშლა, რეზიუმე, ზარი, მაგრამ ისინი უფრო მოსახერხებელი. მომხმარებლის სიმულაციური “მიიჩნევს, პარალელურად”. დინამიკა სიმულაციური მოდელი გამოიხატება პირობების ორმხრივად ძალებთან პარალელური პროცესები. ეს გზა არის ძალიან ბუნებრივი – ეს არის ზუსტად ის, თუ როგორ რეალურ სამყაროში მუშაობს.
States of a process object:
  • Active a segment of the process is being executed.
  • Suspended process has its event notice in SQS. Unless canceled it will be activated in future.
  • Passive process has no scheduled event. It must be activated by another process.
  • Terminated process has finished. It can not be activated again.
Timing, Sequencing and Synchronizing Facilities:
  • Activate X activates a passive process X.
  • Reactivate X. either activates a passive process or changes the next activation time if the process is suspended or active.
  • Hold(T) generates the delay T in the process life.
  • Passivate makes the current process passive.
  • Cancel(X) cancels the next activation of X.
  • Wait(Q) passivates the process and puts it at the end of the list (queue) Q.

 


 

Simulation Example 1: მრავალარხიანი queuing სისტემა – აქტიური მომხმარებლის მიდგომა.
გრაფიკი 10 გვიჩვენებს სისტემა, რომელიც იმიტირებული. ეს არის აბსტრაქცია, მაგალითად, საბანკო, სადაც მომხმარებელს დაველოდოთ ერთი მდგომ ნებისმიერი tellers. შორის შუალედი ლიტერატურა არის შემთხვევითი, ერთნაირად გადანაწილდება 1-დან 3 წუთის განმავლობაში. ყველა სერვერები აქვს იგივე შემთხვევითი მომსახურების დრო, რომ ჩვეულებრივ ნაწილდება ერთად ნიშნავს ღირებულება 8 წუთი და სტანდარტული გადახრა, 2 წუთი. სიმულაციური უნდა იპოვოს საშუალო დრო მომხმარებელს ხარჯავს სისტემა. (გაითვალისწინეთ, რომ ანალიტიკური მოდელი, აღნიშნული სისტემა არ არის ხელმისაწვდომი). სიმულაციური მსგავსი სისტემების Simula (ზუსტად სისტემა კლასი სიმულაციური საქართველოს Simula) ყოველთვის იწყება მიერ იდენტიფიკაციის პროცესში. ერთი პროცესი, ცხადია, გენერატორი მომხმარებელს – ის არაერთხელ გენერირება მომხმარებელს, ჩანაწერი მისი ჩამოსვლის დროს, და დაველოდოთ შემთხვევითი გადადება. გამოხატოთ დინამიკა სისტემა, არსებობს ორი ლოგიკური უახლოვდება. პირველი (გამოიყენება ამ მაგალითში) დაფუძნებულია აქტიურ მომხმარებელს და პასიური სერვერები. საპირისპირო მიდგომა – აქტიური სერვერები, პასიური მომხმარებელს ნაჩვენებია შემდეგი მაგალითი. არის აქტიური მომხმარებელს აქვს ცხოვრების წესები წარმოდგენილია შემდეგი ნაბიჯები:
  • თუ არსებობს უფასო სერვერზე, გააგრძელოთ. დაველოდოთ მდგომ სხვაგვარად.
  • ჩაიგდოს სერვერზე, შემთხვევითი წარმოქმნის შეფერხება, რომელიც წარმოადგენს მომსახურების დროს.
  • გამოშვების სერვერზე.
  • თუ არსებობს ელოდება მომხმარებელს (თუ მდგომ არ არის ცარიელი), ამოიღონ იგი მდგომ და გაააქტიუროთ იგი. (გააქტიურებული მომხმარებელს დაიწყება მისი ნაბიჯი 2.)
  • განახლება სტატისტიკა.

გრაფიკი 10: Queuing სისტემა გააკეთა ერთი მდგომ და უფრო სერვერები.

შემდეგ პროგრამა არის სიმულაციური მოდელი ზემოთ სისტემა. გაითვალისწინეთ, რომ პირველადი მიზანი იყო იმის ჩვენება, ლოგიკა მოდელი პროგრამა მარტივი, როგორც ეს შესაძლებელია. უძრავი სიმულაციური მოდელების, რა თქმა უნდა, დროული ყველა ცვლადი პარამეტრების და უზრუნველყოფს უფრო შედეგები (როგორიცაა, მაგალითად, საშუალო და მაქსიმალური მდგომ სიგრძე, და ა. შ.). შემდეგ პროგრამა არსებობს ორი პროცესები, რომ არსებობს მთელი ექსპერიმენტი: გენერატორი და ძირითადი პროგრამა (ბლოკი prefixed მიერ სიმულაციური), რომ უბრალოდ ელოდება, სანამ ექსპერიმენტი დასრულდა და შემდეგ აჩვენებს შედეგი. მაშინ არსებობს სხვადასხვა რაოდენობის მომხმარებელს პროცესები, რომ არსებობდეს დროებით. მას შემდეგ, რაც განახლებაზე სტატისტიკა მომხმარებელს შეწყვიტოს. შენიშვნა გამოყენების სტანდარტული ფუნქციები გენერირება შემთხვევითი დაგვიანებით. არსებობს სტანდარტული ფუნქციების Simula ყველაზე ხშირად გამოყენებული დისტრიბუციის. ყველა მოცემულია რიცხვი ცვლადი როგორც სათესლე გამოყენებული იქნას შემთხვევითი გენერატორი. ასე რომ, ყველა შემთხვევითი ღირებულებები შეიძლება გამოიყენოთ ცალკე ნაკადს შემთხვევითი რიცხვები ან საერთო ერთი.
! Active customer approach;
Simulation Begin
  Real  TrialDuration;    ! Experiment length [min];
  Ref(Head)  Queue;       ! The queue;
  Integer  Servers;       ! Total number of servers;
  Integer  BusyServers;   ! Numbers of working servers;
  Integer  TrialSeedG, TrialSeedS;    ! Seeds of random generators;
  Long Real  TotalTime, TimeSpent;    ! Variables for statistics;
  Integer  CustomersOut;  ! Number of served customers;
  Real  MinInt, MaxInt;   ! Uniform interval between arrivals;
  Real  SMean, SStd;      ! Normal service duration;

  Process Class Generator;
  Begin
    While true do begin
      Activate New Customer(Time);  ! Time is the current (arrival) time;
      ! Interval between arrivals: ;
      Hold(Uniform(MinInt, MaxInt, TrialSeedG));
    End While;
  End of Generator;

  Process Class Customer(Arrival);  Real Arrival;
  Begin
    Ref(Customer)  Next;

    If not Queue.Empty or (BusyServers >= Servers) then
    Wait(Queue);          ! Customer has to wait in the Queue;
      ! Service can start: ;
    BusyServers := BusyServers + 1;  ! Seize a server;
      ! This is the teller service: ;
    Hold(Normal(SMean, SStd, TrialSeedS));
    BusyServers := BusyServers - 1;  ! Release the server;
    If not Queue.Empty then begin
      Next :- Queue.First;
      Next.Out;           ! First from Queue served;
      Activate Next after Current;
    End If;
    CustomersOut := CustomersOut + 1;    ! Statistics;
    TotalTime := TotalTime + (Time - Arrival);
  End of Customer;

 ! MAIN program body: ;
  TrialSeedG := 7;  TrialSeedS := 23;  ! Seeds for random variables;
  MinInt := 1; MaxInt := 3;            ! Min and Max intervals;
  SMean := 8; SStd  := 2;              ! Random normal servers;
  OutText("Enter the number of Servers : "); OutImage;
  Servers := InInt;                    ! Initial numbers;
  TrialDuration := 600;                ! Other variables initialized to 0;
  Queue :- New Head;                   ! Create an empty queue;
  Activate New Generator;              ! This starts the experiment;
  Hold(TrialDuration);                 ! Experiment duration;
  TimeSpent := TotalTime/CustomersOut;
  OutText("Average time spent in the system: ");
  OutFix(TimeSpent, 3, 10); OutImage;
  InImage
End of program;

 


 

სიმულაციური მაგალითი 2: მრავალარხიანი queuing სისტემის – Active Server მიდგომა.
სისტემა, რომ იმიტირებული არის იგივე, რაც წინა, მაგალითად – გრაფიკი 10. სხვაობა არის აქტიური სერვერზე, რომ არაერთხელ ემსახურება მომხმარებელს რიგში, სანამ მდგომ არის ცარიელი. შემდეგ სერვერზე passivates. მომხმარებელს, პირველ რიგში გააქტიურება ყველა მოჩვენებითი სერვერები (ასეთის არსებობის შემთხვევაში) და მერე შევიდა რიგი. ეს, რა თქმა უნდა არ არის ძალიან ეფექტური, მაგრამ მარტივი. მომხმარებლებს, რომლებიც გააქტიურებული სერვერები დასრულების შემდეგ, მომსახურების. დანარჩენი მათი ცხოვრების მომხმარებელს პირველი განახლება სტატისტიკა. ძირითადი პროგრამა ქმნის და ააქტიურებს ყველა სერვერები, მაგრამ ისინი მაშინვე passivate, რადგან მდგომ არის ცარიელი. მაშინ მთავარი პროგრამა ააქტიურებს გენერატორი და ელოდება, სანამ ექსპერიმენტი დასრულდა.
! Active server approach;
Simulation Begin
  Real  TrialDuration;       ! Experiment length [min];
  Ref(Head)  Queue;          ! The queue;
  Integer  Servers;          ! Total number of servers;
  Integer  TrialSeedG, TrialSeedS;    ! Seeds of random generators;
  Long Real  TotalTime, TimeSpent;    ! Variables for statistics;
  Integer  CustomersOut;     ! Number of served customers;
  Real  MinInt, MaxInt;      ! Uniform interval between arrivals;
  Real  SMean, SStd;         ! Normal service duration;
  Ref(Server) Array ServBank(1:10);   ! Max. number of servers is 10;
  Integer i;

  Process Class Generator;
  Begin
    While true do begin
      Activate New Customer(Time);
       ! Interval between arrivals: ;
      Hold(Uniform(MinInt, MaxInt, TrialSeedG));
    End While;
  End of Generator;

  Process Class Server;
  Begin
    Ref(Customer) ServedOne;

    While true do
      If not Queue.Empty then begin
        ServedOne :- Queue.First;
        ServedOne.Out;      ! First from Queue served;
        Hold(Normal(SMean, SStd, TrialSeedS));
        Activate ServedOne after Current
       end
      Else
        Passivate;
  End of Server;

  Process Class Customer(Arrival);  Real Arrival;
  Begin
    For i:=1 step 1 until Servers do
      If ServBank(i).Idle then
        Activate ServBank(i) after Current;
    Wait(Queue);

     ! Service finished: ;
    CustomersOut := CustomersOut + 1;  ! Statistics;
    TotalTime := TotalTime + Time - Arrival;
  End of Customer;

 ! MAIN program body: ;
  TrialSeedG := 7;  TrialSeedS := 23;  ! Seeds for random variables;
  MinInt := 1; MaxInt := 3;            ! Min and Max intervals;
  SMean := 8; SStd  := 2;              ! Random normal servers;
  OutText("Enter the number of Servers : "); OutImage;
  Servers := InInt;                    ! Initial numbers;
  TrialDuration := 600;
  Queue :- New Head;
  For i:=1 step 1 until Servers do begin
    ServBank(i) :- New Server;
    Activate ServBank(i)               ! Create and activate all servers;
  End For;
  Activate New Generator;              ! This starts the experiment;
  Hold(TrialDuration);                 ! Experiment duration;
  TimeSpent := TotalTime / CustomersOut;
  OutText("Average time spent in the system: ");
  OutFix(TimeSpent, 3, 10); OutImage;
  InImage
End of program;
უკან შინაარსი

 


SIMULA წყობილი QPS


 

A quasiparallel სისტემა (QPS) Simula ძირითადად ბლოკი (როგორც წესი, მაგრამ არ არის აუცილებელი prefixed ერთი), რომლის სხეულის ქმნის ზოგიერთი ობიექტი, რომელიც ერთად მთავარი ბლოკი შედგება სისტემა quasiparallel coroutines. იმიტომ, რომ Simula (განსხვავებით, მაგალითად, Pascal) არის ნამდვილი ბლოკი ორიენტირებული ენა, დაბლოკოს (რაც ზოგადად იმას ნიშნავს, QPS) შეიძლება მოხდეს ნებისმიერ ადგილას, კოდი, როგორც განცხადებაში. ეს იმას ნიშნავს, რომ QPS შეიძლება შეიცავდეს ადგილობრივი (წყობილი) QPS ის, რომ შეიძლება შეიცავდეს ადგილობრივი QPS-ს და ა. შ. ეს მარტივი წესი იძლევა გზა შექმნა წარმოუდგენლად რთული სტრუქტურების შედეგები, რომ ჯერჯერობით არ ყოფილა სრულად გამოყენებული და არც კი ესმოდა. მომდევნო პროგრამა ასახავს შესაძლო გამოყენების წყობილი QPS ჭადრაკის კონტროლი. შემდეგი თავი გვიჩვენებს სიმულაციური პროგრამა წყობილი სიმულაციური.

 


 

Nested QPS Example: ჭადრაკი კონტროლი გამოყენებით მოდელირებული თამაში, როგორც ნაწილი გადაწყვეტილება.
მოდით ვივარაუდოთ, რომ მოჭადრაკე, როგორც ნაწილი მისი გადაწყვეტილება სიმულაციას მიმდინარე თამაში რათა შეამოწმოთ შესაძლო შედეგს მომდევნო ნაბიჯი. შემდეგ პროგრამა (დაფუძნებული ორი ბატონის მიდგომა) არის მონახაზი ერთი შესაძლო გამოსავალი. გაითვალისწინეთ, რომ კლასის ფეხბურთელი ჰყავს მეთოდი TestStrategy მოუწოდა, როგორც ნაწილი თითოეული გადაწყვეტილება. ეს მეთოდი ახორციელებს QPS მსგავსი გარე ერთ. იგი შეიცავს ადგილობრივი კლასის TestPlayer, რომ შეიძლება იყოს ძალიან გავს გარე მოთამაშე, გარდა TestStrategy (ეს შეიძლება აქვს რაღაც მსგავსი, მაგრამ მობუდარი აქვს შეჩერება გარკვეულ დონეზე). სხეულის TestStrategy არის შიდა QPS, რომლის შედეგები გამოიყენება მოთამაშე ზედა დონეზე.
Begin
  Boolean  Mate;
  Ref(Player)  White, Black, Winner;
  Integer  Seed;

  Class Player(PName);  Text PName;
  Begin
    Ref(Player) Opponent;
    Integer Move; 

    Procedure TestStrategy;
    Begin
      Class TestPlayer ... ;

      Begin
        ! Internal experiment, similar to the outer QPS;
         ...
      End of internal QPS;
    End of TestStrategy;

   ! The life of Player;
    Detach;
    TestStrategy;
    OutText(PName);  OutText("'s First Move");  OutImage;
    Resume(Opponent);
    TestStrategy;
    OutText(PName);  OutText("'s Second Move");  OutImage;
    Resume(Opponent);
    Move := 2;
    While not Mate do begin
      Move := Move+1;
      TestStrategy;
      OutText(PName);  OutText("'s Move # ");
      OutInt(Move,3);  OutImage;
      If  Draw(0.3,Seed)  then  begin
        Mate := true;
        Winner :- This Player;
      End If;
      Resume(Opponent);
    End While;
  End of Player;

  Begin   ! This block is the outer QPS head;
    OutText("Creating Players,  Starting the white one");  OutImage;
    White :- New Player("White");
    Black :- New Player("Black");
    White.Opponent :- Black;
    Black.Opponent :- White;
    Seed := 17;
    Resume(White);
    OutText("Finish: ");  OutText(Winner.PName);
    OutText(" won in move");  OutInt(Winner.Move,3);  OutImage;
  End of outer QPS;
End of program;
უკან შინაარსი

 


SIMULA წყობილი სიმულაციური


 

იქ არსებობს ორი დონის quasiparallelism in Simula, ორივე შეიძლება განახორციელოს წყობილი სისტემები. წინა თავი ეხება დაბალი დონე წყობილი QPS-ს. სისტემა კლასში სიმულაციური შემოაქვს ცნება დროს. ეს იმას ნიშნავს, რომ თუ წყობილი, იქნება სხვა ადგილობრივი (წყობილი) – ჯერ. ძირითადი იდეა არის ის ფიგურა 11. გამართავს ანგარიშგების დაგვიანებით x და z ვრცელდება ძირითადი (გარე) დროს. გამართავს განცხადება დაგვიანებით y არის კიდევ ერთი ალტერნატიული სამყარო. ასე რომ, Simula არ არის გამორიცხული, რომ სიმულაცია სისტემები ი ჯერჯერობით მხოლოდ სამეცნიერო ფანტასტიკა. არსებობს პრაქტიკული პროგრამა. ძირითადად, არ არის გამორიცხული, რომ სიმულაცია სისტემები, რომელიც შეიცავს სიმულაციური, როგორც ნაწილი გადაწყვეტილების მიღების პროცესში. განვიხილოთ ეს სიტუაცია: არის გარკვეული კომპლექსური სისტემა და ექსპერტთა ჯგუფი, რომელიც გთავაზობთ სხვადასხვა გადაწყვეტილებები, რომლის შედეგები არ შეიძლება იყოს ტესტირება ტრივიალური ან ანალიტიკური გზა. (არ არის ეს ჩვეულებრივი შემთხვევაში პრაქტიკაში?) გამოცდა და შეაფასოს მათი გადაწყვეტილება წინადადებები, ექსპერტები შეასრულოს სიმულაციური ექსპერიმენტი, შეადარეთ შედეგები და აირჩიეთ ყველაზე პერსპექტიული გადაწყვეტილება. ახლა დავუშვათ, რომ ეს ყველაფერი იქნება იმიტირებული.

ნახატი 11: ძირითადი იდეები წყობილი სიმულაციური.


 

წყობილი სიმულაციური მაგალითად: Queuing ქსელი, რომლის ნაწილი არის ოპტიმიზირებული მიერ განმეორებითი წყობილი სიმულაციური.
ნახატი 12 გვიჩვენებს სისტემა, რომელიც იმიტირებული. ეს არის აბსტრაქცია, მაგალითად, საბანკო, სადაც მომხმარებელს, პირველ რიგში, დაველოდოთ ერთი მდგომ მთხრობელი. მას შემდეგ, რაც ემსახურება მთხრობელი, მომხმარებელს ემსახურება მოლარე. არსებობს კიდევ ერთი მდგომ, სადაც მომხმარებელს დაველოდოთ მოლარეების. შემთხვევითი შორის შუალედი ლიტერატურა და შემთხვევითი მომსახურების ჯერ tellers და მოლარეების არის ცნობილი. მოდით ვივარაუდოთ, რომ არსებობს გარკვეული რაოდენობის clerks, რომ შეუძლია იმუშაოს როგორც მოლარეები, როგორც მოლარეების. მართვის ბანკის სურს შეამოწმოს გზა clerks გამოყოფილი მოლარეები, როგორც მოლარეების დროს ტიპიური ცვლა გააკეთა სამ პერიოდს: დაკავებული, მოჩვენებითი, და ძალიან დაკავებული ერთ სხვადასხვა ინტერვალით შორის ლიტერატურა მომხმარებელს. საუკეთესო განაწილების პოლიტიკის წყობილი სიმულაციური შეიძლება იყოს გამოყენებული, ამ გზით: დასაწყისში თითოეულ პერიოდში, შიდა განმეორებითი სიმულაციური იქნება ტესტი, ქცევის პირველ ეტაპზე სხვადასხვა ნომრები tellers (ცხადია, დიაპაზონი 1-დან სულ ცნობილია რაოდენობის clerks). გამოყენებით შედეგები ამ შიდა სიმულაციური ექსპერიმენტი, მენეჯმენტი შეარჩევს რაოდენობის clerks, რომელიც იმუშავებს როგორც tellers, სხვები იმუშავებს როგორც მოლარეების. რათა პროგრამა მარტივია, გადაწყვეტილება კეთდება მომხმარებლის მიერ, რომელიც მოცემული შედეგების შიდა სიმულაციური და შემდეგ აიძულა შესვლის რაოდენობის tellers და რაოდენობის მოლარეების. გადაწყვეტილება კრიტერიუმი არის საშუალო დრო გაატარა პირველ ეტაპზე. პოლიტიკა, როგორც ასეთი, არის, ასევე, შეაფასა საშუალო დრო გაატარა მთელი სისტემა.

ნახატი 12: Queuing ქსელი გააკეთა ორი მრავალარხიანი სერვერები.

შემდეგი “პროგრამა” მონახაზი სიმულაციური პროგრამით (რომელიც შემდეგნაირად). გაითვალისწინეთ, რომ შიდა ბლოკი prefixed მიერ სიმულაციური ხორციელდება განმეორებით სამჯერ ყველა შესაძლო ნომრები tellers. იგი შეიცავს დეკლარაცია კლასები მსგავსი გარე პირობა. სხვაობა არის მარტივი ქცევის მომხმარებელს, რადგან არსებობს მხოლოდ ერთი სამსახურის ეტაპზე. არსებობს ასევე შემდგომი მობუდარი. ძირითადად შიდა სიმულაციური არის მსგავსი მაგალითი მოცემულია თავი სისტემა კლასში სიმულაციური (აქტიური მომხმარებლის მიდგომა).
Simulation Begin
  Declaration of global variables
  Process Class Generator;  Begin ... End;
  Process Class Customer;  Begin ... End;

  Initialize the global experiment

  For Period:=1 step 1 until 3 do begin
    For Trial:=1 step 1 until MaxClerks do
      Simulation Begin

        Declaration of internal global variables
        Process Class Igenerator;  Begin ... end;
        Process Class Icustomer;  Begin ... End;

        Perform and evaluate one inner experiment

      End of internal simulation;

    Show results of internal experiments;
    Select the best numbers of tellers and cashiers;

    Perform a part of outer experiment for this period

  End For;
  Evaluate the global experiment
End of program;

მომდევნო პროგრამა არის წყობილი სიმულაციური მოდელი ზემოთ სტრუქტურა.

!  NESTED Simulation using the Simula's class SIMULATION    ;
!                                                           ;
!  The example is a model of a bank. Customers are first    ;
!  served by tellers, then by cashiers.                     ;
!  The input rate changes in three periods: there is a busy ;
!  period, then an idle period and again a busy one.        ;
!  For each period the repeated inner simulation experiment ;
!  simulates the first queue for the particular input rate  ;
!  and for various numbers of servers. Then it shows the    ;
!  results (average time spent at the first server) and     ;
!  prompts the user for the number of tellers and the number;
!  of cashiers. Tellers always finish a service that has    ;
!  already started. The simulation should find the          ;
!  time customers spend in the bank (average and maximum)   ;
!  for various numbers of clerks in the three periods.      ;
!                                                           ;

Simulation Begin
                                       ! Global variables: ;
   Integer Period,Trial;               ! Period, Trial number;
   Real Array MinInt,MaxInt(1:3);      ! Min and Max intervals;
   Real Array Duration(1:3);           ! Duration of periods [min];
   Ref(Head) Queue1,Queue2;            ! The two queues;
   Integer MaxClerks, Tellers, Cashiers;  ! Total numbers;
   Integer BusyTellers, BusyCashiers;  ! Numbers of working clerks;
   Real S1Mean, S1Std, S2Mean, S2Std;  ! Random normal servers;
   Integer SeedG, SeedS1, SeedS2;      ! Seeds of the random generators;
   Long Real TotalTime, MaxTime;       ! Variables for statistics;
   Integer CustomersOut;               ! Number of served customers;

   Process Class Generator;
   Begin
      While true do begin
             ! Interval between arrivals: ;
         Hold(Uniform(MinInt(Period),MaxInt(Period),SeedG));
         Activate New Customer(Time);
      End While;
   End of Generator;

   Process Class Customer(Arrival); Real Arrival;
   Begin
      Ref(Customer) Next;
      Real Spent;

      If (not Queue1.Empty) or (BusyTellers >= Tellers) then
         Wait(Queue1);   ! Has to wait in Queue1;
                         ! Service can start;
      BusyTellers := BusyTellers + 1;
      Hold(Normal(S1Mean, S1Std, SeedS1));  ! This is the teller service;
      BusyTellers := BusyTellers - 1;

      If (not Queue1.Empty) and (BusyTellers < Tellers) then begin
         Next :- Queue1.First;
         Next.Out;                          ! First from Queue1 served;
         Activate Next after Current;
      End If;

      If (not Queue2.Empty) or (BusyCashiers >= Cashiers) then
         Wait(Queue2);   ! Has to wait in Queue2;
                         ! Service can start;
      BusyCashiers := BusyCashiers + 1;
      Hold(Normal(S2Mean, S2Std, SeedS2));  ! This is the cashier service;
      BusyCashiers := BusyCashiers - 1;

      If (not Queue2.Empty) and (BusyCashiers < Cashiers) then begin
         Next :- Queue2.First;
         Next.Out;                          ! First from Queue2 served;
         Activate Next after Current;
      End If;

      CustomersOut := CustomersOut + 1;
      Spent := Time - Arrival;
      TotalTime := TotalTime + Spent;
      If Spent > MaxTime then MaxTime := Spent;
   End of Customer;

   Procedure Report;          ! Experiment evaluation;
   Begin
      OutText("  *** Report on external simulation ***"); OutImage;
      OutInt(CustomersOut,6); OutText(" customers ready at time ");
      OutFix(Time,2,10); OutImage;
      OutText("Average time in system: ");
      OutFix(TotalTime/CustomersOut,2,10); OutImage;
      OutText("Maximum time in system: ");
      OutFix(MaxTime,2,10); OutImage;
   End of Report;

! MAIN program body;

    SeedG  := 11;                    ! Seeds of random variables;
    SeedS1 := 13;
    SeedS2 := 17;
    MinInt(1) := 1; MaxInt(1) := 4;  ! Min and Max intervals;
    MinInt(2) := 2; MaxInt(2) := 9;
    MinInt(3) := 1; MaxInt(3) := 3;
    Duration(1) := 120;              ! Duration of periods;
    Duration(2) := 240;
    Duration(3) := 120;
    MaxClerks  := 6;
    S1Mean := 6;                     ! Random normal servers;
    S1Std  := 1;
    S2Mean := 8;
    S2Std  := 2;
    Queue1 :- New Head;
    Queue2 :- New Head;
    Period := 1;
    Activate New Generator;

For Period:=1 step 1 until 3 do begin

 Real Array TimeSpent(1:MaxClerks);
 OutText("  *** Results of internal simulation *** Period ");
 OutInt(Period,1); OutImage;
 OutText("      Tellers     Average time spent"); OutImage;

 For Trial:=1 step 1 until MaxClerks do
 ! ********************************************************** ;
  Simulation Begin
                                       ! Internal Global variables: ;
   Real TrialDuration;                 ! Internal experiment [min];
   Ref(Head) Queue;                    ! The queue;
   Integer Servers;                    ! Total number;
   Integer BusyServers;                ! Numbers of working clerks;
   Integer TrialSeedG,TrialSeedS;      ! Seeds of the random generators;
   Long Real TotTime;                  ! Variables for statistics;
   Integer CustOut;                    ! Number of served customers;

   Process Class IGenerator;
   Begin
      While true do begin
         Hold(Uniform(MinInt(Period),MaxInt(Period),TrialSeedG));
         Activate New ICustomer(Time);   ! Interval between arrivals: ;
      End While;
   End of IGenerator;

   Process Class ICustomer(Arrival); Real Arrival;
   Begin
      Ref(ICustomer) Next;

      If not Queue.Empty or (BusyServers >= Servers) then
         Wait(Queue);    ! Has to wait in Queue;
                         ! Service can start;
      BusyServers := BusyServers + 1;
      Hold(Normal(S1Mean, S1Std, TrialSeedS));  ! Teller's service;
      BusyServers := BusyServers - 1;

      If not Queue.Empty then begin
         Next :- Queue.First;
         Next.Out;                       ! First from Queue served;
         Activate Next after Current;
      End If;

      CustOut := CustOut + 1;
      TotTime := TotTime + Time - Arrival;
   End of ICustomer;

  ! Internal MAIN program body;

    TrialSeedG := 7;                  ! Seeds for random variables;
    TrialSeedS := 23;
    Servers := Trial;
    TrialDuration := 600;
    Queue :- New Head;
    Activate New IGenerator;
    Hold(TrialDuration);             ! Internal experiment duration;
    TimeSpent(Trial) := TotTime/CustOut;
    OutInt(Trial,13);
    OutFix(TimeSpent(Trial),3,23); OutImage;

   End of internal simulation;
 ! ********************************************************** ;

  OutText("Enter the number of tellers : "); OutImage;
  Tellers := InInt;
  OutText("Enter the number of cashiers : "); OutImage;
  Cashiers := InInt;
  Hold(Duration(Period));
  Report;
  OutText("Press Enter to Continue."); OutImage; InImage;
 End For;
End of program;
ეს არის გამომავალი სიმულაციური მოდელი ერთად ნომრები შევიდა. საერთო რაოდენობის clerks 6, ნომრები გამოყოფილი მოლარეები, მოლარეების არიან inputted შესახებ. შენიშვნა მაქსიმალური დრო გაატარა სისტემა. ეს არის დაცული გონივრული სანამ მესამე პერიოდი, სადაც იგი გაიზარდა 63.93 წუთი (გაითვალისწინეთ, რომ საერთო საშუალო მომსახურების დრო არის 6+8=14 წუთი). ასე რომ, ნათელია, რომ მესამე პერიოდში ძალიან დაკავებული კიდევ ერთი კლერკი, რომ მნიშვნელოვნად გააუმჯობესებს სისტემის ქცევა. ეს ჰიპოთეზა იყო ტესტირება კიდევ ერთი სიმულაციური აწარმოებს იგივე მონაცემები, გარდა იმ შემთხვევისა, ერთი უფრო მოლარე მესამე პერიოდში (4 tellers, 3 მოლარეების). მისცა ამ შედეგები: საშუალო დრო გაატარა სისტემა 19.67 (21.84 2 მოლარეების), მაქსიმალური დრო გაატარა სისტემა 36.58,, რომ არის მოსალოდნელი გაუმჯობესება. ასე რომ შედეგს სიმულაციური არის წინადადება, რომ მართვის გამოყოს ერთი მოლარე მესამე ძალიან დატვირთული პერიოდი, წინააღმდეგ შემთხვევაში, სისტემის იქცევა კარგად, 6 clerks.
  *** Results of internal simulation *** Period 1
      Tellers     Average time spent
            1                181.404
            2                 52.691
            3                  6.132
            4                  5.979
            5                  5.972
            6                  5.972
Enter the number of tellers :
3
Enter the number of cashiers :
3
  *** Report on external simulation ***
    42 customers ready at time     120.00
Average time in system:      18.52
Maximum time in system:      25.95
Press Enter to Continue.
  *** Results of internal simulation *** Period 2
      Tellers     Average time spent
            1                 36.620
            2                  6.090
            3                  6.045
            4                  6.038
            5                  6.038
            6                  6.038
Enter the number of tellers :
2
Enter the number of cashiers :
4
  *** Report on external simulation ***
    91 customers ready at time     360.00
Average time in system:      17.29
Maximum time in system:      27.16
Press Enter to Continue.
  *** Results of internal simulation *** Period 3
      Tellers     Average time spent
            1                205.290
            2                103.226
            3                  7.937
            4                  5.993
            5                  5.974
            6                  5.972
Enter the number of tellers :
4
Enter the number of cashiers :
2
  *** Report on external simulation ***
   119 customers ready at time     480.00
Average time in system:      21.84
Maximum time in system:      63.93
Press Enter to Continue.
უკან შინაარსი

 


რა არის ცუდი SIMULA ?


 

Simula არასდროს გახდა ფართოდ გავრცელდა ხშირად გამოიყენება ენაზე. არსებობს სხვადასხვა მიზეზების ახსნის ამ ფაქტს. მიუხედავად იმისა, რომ მიზეზი, ყველა ერთმანეთზეა დამოკიდებული, შემდეგ არის მცდელობა, რომ მათ სხვადასხვა ponts ხედი.
Generally:
  • Born in a small European country
  • Frozen in 1968
  • Expensive
  • Does not have a modern IDE
  • Too complicated
  • Not enough publications
Language features:
  • Limited file access facilities (typed files)
  • Missing data types (records, sets)
  • No advanced parallelism and real time support
  • No GUI support
  • Long executable files for short programs
OOP features:
  • No multiple inheritance
  • No interfaces
Simulation:
  • No automatic collection of statistics
  • No report generator
  • No useful specialized facilities (resources)
უკან შინაარსი

ლიტერატურა


 

წიგნები/ნაშრომების

Birtwistle, გ. მ., ო-ჯ Dahl, ბ Myhrhaug და კ. Nygaard: SIMULA დაიწყოს, AUERBACH გამომცემლები Inc, 1973.

Pooley, რ. ჯ.: შესავალი პროგრამირების SIMULA, Oxford, Blackwell სამეცნიერო ფონდი, 1987.

Kirkerud, ბ.: ობიექტზე ორიენტირებული პროგრამირების SIMULA, Addison-Wesley, 1989.

Holmevik, J. R.(1994). ” შედგენის SIMULA: ისტორიული კვლევის ტექნოლოგიური დაბადება.” IEEE ანალები ისტორიაში Computing, 16 (4), გვ. 25-37, 1994. სტატია იყო წარმოდგენილი მე-18 ASU კონფერენცია, 1992 წელს და გამოქვეყნდა SIMULA გამოწერა Vol.20(1), ოქტომბერი, 1992.
დიდი მადლობა ბატონო Holmevik სახის ნებართვის თქვენ შეგიძლიათ გადმოწეროთ ადგილობრივი ასლი მისი ქაღალდის შედგენის SIMULA.


პერიოდული
წარმოების წლიური ASU კონფერენციები. (პირველი 1973 წელს ოსლოში).
ASU ბიულეტენი

 


 

ვებ მისამართი
DIRO Simula მთავარი არის Simula ორიენტირებული გვერდი გაიმართა Département d’informatique et recherche opérationnelle (Université de Montréal). იგი შეიცავს ბევრ ძალიან საინტერესო იდეები და დამატებითი ლიტერატურა.
ASU (ასოციაცია Simula მომხმარებელი) არის განთავსებული ISIMA, Université Blaise Pascal, საფრანგეთი. იგი შეიცავს (მათ შორის) ინფორმაცია ASU კონფერენციები და ყოვლისმომცველი ბიბლიოგრაფია.