© 1997 J.Sklenar ( jaroslav.sklenar@um.edu.mt )
Этот документ основан на IT - семинар под названием 30 лет объектно - ориентированного программирования (OOP) , которая состоялась в Университете Мальты на 5/12/1997. Первый объектно - ориентированный язык (OOL) Simula 67 был официально представлен Оле Йохан Даль и Кристен Nygaard на рабочей конференции IFIP TC 2 по моделированию языков в Lysebu вблизи Осло в мае 1967 г. 30 лет представляют собой один человеческий и несколько компьютерных поколений. Несмотря на то, находящийся в пользовании в течение столь длительного времени, все современные программирования работы , проводимой в настоящее время основывается на принципах ООП введена впервые в SIMULA определения. И что более важно, SIMULA содержит объекты , которые до сих пор не использовались в полной мере и даже не понимает не только общего программирования общественности , но и люди из объектно - ориентированного сообщества. Целью беседы было краткое введение основных Simula функций, в основном те , которые не присутствуют в других OOL. То же цель этого документа.
Заметки:
SIMULA - ОСНОВНЫЕ ФАКТЫ
ИСТОРИЯ SIMULA I
ИСТОРИЯ SIMULA 67
SIMULA ТИПЫ ДАННЫХ
SIMULA ОТЧЕТНОСТЬ
SIMULA ПРОЦЕДУРЫ
SIMULA КЛАССЫ
SIMULA ПАКЕТЫ = ВЛОЖЕННЫЕ КЛАССЫ
SIMULA СТАНДАРТНЫЕ ПАКЕТЫ
SIMULA КВАЗИПАРАЛЛЕЛЬНЫХ СИСТЕМЫ
МОДЕЛИРОВАНИЕ = МИР ПАРАЛЛЕЛЬНЫХ ПРОЦЕССОВ
SIMULA ВЛОЖЕННЫЕ КПС
SIMULA NESTED SIMULATION
ЧТО НЕ ТАК С SIMULA?
SIMULA - ОСНОВНЫЕ ФАКТЫ
SIMULA I = ориентированный процесс дискретного языка моделирования основе Algol 60. (1964 - 1965) Язык моделирования.
SIMULA 67 = Общий объектно-ориентированный язык с классами системы поддерживающей связанные списки (система класса Simset ) и дискретный процесс ориентированное моделирование (системный класс Simulation). (1967 - 1971) Простой универсальный язык.
SIMULA = SIMULA 67(Номер не используется больше, потому что SIMULA I не был использован течение очень долгого времени).
Рисунок 1: Основные части и интерфейсные линии в SIMULA среде.
ИСТОРИЯ SIMULA I
1952 Кристен Найгаард начинает работу в области исследования операций , включая модели написания моделирования. Проблема: как осмыслять сложный реальный мир. С самого начала SIMULA предназначен , чтобы быть как описание системы и языка программирования .
1960 Алгол 60 с его истинной рекурсивная блок механизма структуры , основанной на принципе стека. Все важные управляющие структуры введены. SIMULA задумана как пакет с препроцессором до Алголя 60.
1962 Оле-Йохан Даль и Кристен Найгаард встречаются в Норвежском вычислительном центре (НКЦ) в Осло. Первое предложение формальный язык , представленный на МФОИ 62 Всемирном конгрессе в Мюнхене.
1962 SIMULA проект , поддерживаемый UNIVAC, что привело к UNIVAC 1107 установки в НКК в 1963 году.
1963 Конфликт между строгим механизмом стека Алголь и SIMULA в сложных объектов моделирования ориентированных больше очереди принцип. Препроцессор идея отказаться, Simula независимым на основе Алгол языка .
1963 Оле-Йохан Даль работает по новой схеме размещения хранения на основе двумерного списка свободных областей.
1964 Оригинальная идея пассивных клиентов , переходящих через сеть активных компонентов ( деятельностный подход ) стал ограничивающим фактором . Другой путь круглый возможно - активные клиенты , проходящие через пассивной сети. Это привело к объединительной общая концепция процесса :
Система = совокупность взаимодействующих квазипараллельных процессов.
1964 Первый прототип SIMULA компилятора , работающего на UNIVAC НКЦ 1107 в декабре, SIMULA я по эксплуатации появился в мае 1965 г. В течение первого года SIMULA применяется к широкой области проблем исследования операций.
ИСТОРИЯ SIMULA 67
1965,66 SIMULA I использован в Швеции, Германии, США (Burroughs B5500), Советского Союза (URAL 16) и других стран. Усилия, чтобы познакомить и научить языку.
1965 концептуальный альбом класс Тони Хоара представлены в бюллетене Алголь. После тщательного изучения, Nygaard и Даль принять идеи, но некое обобщенное понятие по-прежнему отсутствует.
1966 Представления идею префиксов. Процессы (позже объекты) состоят из двух слоев: приставкой слоя, основного слоя. Идея подклассов . Nygaard и Даль начали работу над новым общего языка высокого уровня.
1967 (май). SIMULA 67 официально представлен на Dahl и Nygaard на рабочей конференции IFIP TC 2 по моделированию языков в Lysebu близ Осло.
1967 (июнь). Определение стандарта SIMULA 67 называется Common Base Standard .
1968 Первое заседание SIMULA группы по стандартизации (SSG). После принятия и обработки строк ввода / вывода сделано Bjorn Myhrhaug , SIMULA официально заморожен .
1973 Ассоциация Simula пользователей (ASU) основана. Симула используется в более чем 250 объектах в тот году.
Реализации:
1969 CDC 3300, 3600 (Норвегия - Университет Осло, THER)
1971 UNIVAC 1100 (НКК)
1972 IBM 360/370 (НКК)
1972 CII 10070, IRIS 80 (Франция)
1973/74 CDC 6000 (Франция, Нидерланды), CDC Cyber 70 (NDRE)
1975 10 декабря (Швеция) и т.д.
Периодические издания:
Материалы ежегодных конференций ASU (первый 1973 Осло)
ASU Информационный бюллетень
SIMULA ТИПЫ ДАННЫХ
SIMULA содержит все общие объекты высокого уровня языков третьего поколения. Вот почему следующие две главы очень краткие резюме, текст является единственным исключением.
Integer Short Integer
Real Long Real
Boolean Character
Object Reference Declaration: Ref( Object Identifier) (None is the trivial value)
Text Constants: "A", "Simula", Notext
Текст концептуально класс экземпляра, который имеет свои атрибуты и методы.
Методы :
Boolean Procedure Constant; (Правда , если константа)
Text Procedure Main; (Основная строка - текст является частью основной)
Integer Procedure Start; (Исходное положение в Main)
Integer Procedure Length; (Количество символов)
Integer Procedure Pos; (Текущая позиция)
Procedure SetPos(i); Integer i; (Изменение положения)
Boolean Procedure More; (Правда , если Pos <= Length)
Character Procedure GetChar; (Персонаж из Pos )
Procedure PutChar(c); Character c; (Сохранение символ Pos )
Text Procedure Sub(i, n); Integer i,n; (Substring при I длины п)
Text Procedure Strip; (Удаляет правильные пробелы)
Де-редактирования Методы :
Integer Procedure GetInt; (Читает целое число)
Long Real Procedure GetReal; (Читает реальное)
Integer Procedure GetFrac; (Как GetInt , игнорирует пробелы)
Методы редактирования:
Procedure PutInt(i); Integer i; (Записывает целое значение)
Procedure PutFix(i, n); Integer i,n; (Пишет десятичное значение)
Procedure PutReal(r, n); Long Real r; Integer n; (Записывает в научном формате)
Procedure PutFrac(i, n); Integer i,n; (Группы 3, пробелы)
Генерация текста :
Text Procedure Blanks(n); Integer n; (Возврат п заготовки)
Text Procedure Copy(T); Text T; (Возвращает копию Т)
Массивы
Примеры массивов , объявленных в блоках (n, m, a, b глобальные переменные):
Integer Array MyList (1:100);
Array Matrix (1:n, 1:m); (Неявный тип реально)
Character Array Buffer(1: If a>b then a else b);
SIMULA ОТЧЕТНОСТЬ
Простые высказывания
Назначение := Examples: X := If a>b Then a Else b ; X:=Y:=0; ( ** available )
Ссылка Назначение :- Examples: Queue :- New Head; T :- Blanks(80);
Процедура
Перейти к Goto
Структурированные заявления
Begin ... End;
If ... Then ... ; If ... Then ... Else ... ;
Switch Пример :
Switch Target := L1, L2, L3, ... ;
Goto Target( Index_expression );
L1: ...
L2: ...
While ... do ... ;
For Пример:
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;
Выход: 1 13 20 30 40 70 71 72 73 74 75 100 150 200 250 1000 1500
SIMULA ПРОЦЕДУРЫ
Режимы передачи параметров:
Рисунок 2: передачи параметров режимов, примененные к текстовым параметром.
Процедуры
Пример процедуры с двумя входными и одним выходным параметрам: (Отображает право отступом текст)
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;
Вывод:
Short
And the long one
Функции = Тип Процедуры
Пример функции целым числом с двумя входными параметрами: (Вычисляет наибольший общий делитель)
Begin
Integer Procedure GCD(M, N); Integer M, N;
Begin
While M<>N do
If M
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;
Примечание: Функция может быть вызвана , как если бы это была Бестиповое процедура.
SIMULA КЛАССЫ
Рисунок 3: Simula классы состоят из четырех частей.
Декларация:
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;
Объекта Генерации:
Ref(Rectangle) R; (Ссылочная переменная класса)
...
R :- New Rectangle(50, 40); Деятельность участвующие в этом поколении объекта:
Распределение памяти, ссылка хранится в R.
Значения параметров Копирование в (значение проходом).
Начиная тело объекта (правила жизни).
Декларация подклассы:
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;
Объекта Генерации:
Ref(Rectangle) R; (Ссылки переменные класса)
Ref(LocRectangle) LR;
...
R: - New Rectangle (50, 40);
LR :- New LocRectangle(20, 30, 100, 200); (Обратите внимание что также параметры для родительского класса приведены)
Мероприятия, включенные в выше поколения объекта:
Распределение памяти, ссылка хранится в LR.
Копирование значений всех параметров (родительский класс первого).
Начиная тело родительского класса, то подкласс.
Это может быть обобщено на префикс последовательности любой длины :
Class A; Begin ... LifeA End;
A Class B; Begin ... LifeB End;
B Class C; Begin ... LifeC End;
Ref(C) X;
...
X :- New C;
Если не изменен Inner - смотрите следующий абзац, последовательность действий , участвующих в вышеупомянутом поколении объекта является:
LifeA LifeB LifeC
Нарушение правил жизни в заявлении Inner:
Пример заявления:
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 (Inner в жизни C игнорировали) LifeC2 LifeB2 LifeA2
Примечания :
1) Отсутствует внутренний такой же , как Inner только до конца класса.
2) В основном одно внутреннее допускается в теле класса.
Приставка блоки:
Давайте предположим, что программа со следующей структурой:
Begin
Class A(P); Integer P;
Begin LifeA1 Inner; LifeA2 End;
Part1
A(3) Begin
Block body
End;
Part2
End;
Виды деятельности, участвующие в выполнении указанной выше приставкой блока:
Создание класса экземпляра A.
Копирование значений ее параметра (ов).
Начиная тело класса, который включает в себя выполнение кода блока.
Таким образом, в указанной выше программе последовательность операций заключается в следующем:
Part1 LifeA1 Block body LifeA2 Part2
Префиксальный блок концептуально экземпляр класса без имени , который имеет:
- Параметры класса префикса
- Больше атрибутов (класс атрибуты + Локальные переменные блока)
- Больше методов (методы класса + местные процедуры блок)
- Больше правил сложной жизни (класс корпус + блок тела).
Заметки:
2) В Simula программ нет явной деаллокация памяти , потому что сборщик мусора автоматически восстанавливается память , занятую не ссылочных экземпляров класса.
Навигация в последовательности префикса
Следующий текст основан на следующих заявлений:
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 заявление
a) Простой
Inspect XA do Show; делает в основном такой же , как XA.Show ;
Разница заключается в том, что с Inspect , если ХА = None , заявление после того, как do игнорируется. Если XA нет = None, XA.Show приводит к ошибке времени выполнения.
b) None Тестирование Отсутствует в пункте В Otherwise
Inspect XA do Begin
Show; ...
End
Otherwise Begin
OutText("Sorry, XA not created"); OutImage
End;
c) тип тестирования по статье When
Отображение связанного списка, выполненный из различных элементов типов А, В и С, чья голова указатель находится в первой:
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;
Примечание : Нормальные свойства переменной - ссылки на квалификацию B объявлен как Ref(B) XB :
Эти нормальные свойства могут быть преодолены с помощью Inspect или Qua . Обратите внимание , из третьего правила , что обычный позднего связывания механизм (как, например , в Object Pascal) не работает автоматически в SIMULA . Решение этой проблемы заключается в Inspect с When положения - см в приведенном выше примере. SIMULA в подход может быть менее дружественна к пользователю, но он является более общим и программист имеет все под контролем.
3. Реферирование себя на This
Следующий код представляет собой метод А, который добавляет объект в список первой:
Procedure Add_to_List(First); Name First; Ref(A) First;
Begin
Link :- First; First :- This A
End;
4. Тестирование Аттестация Is и In
Следующие self explaining сегменты кода на основе деклараций Ref (B) XB и Ref (A) XA показывают использование дружественных очень пользовательских операторов Is и In . Обратите внимание , что, например , Object Pascal не имеет собственной эквивалент In . Единственное решение этой проблемы в 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. Защита атрибутов
Hidden атрибуты могут быть использованы только в теле класса где они были объявлены.
Protected атрибуты могут быть использованы только в органах класса котором они были объявлены и все подклассы.
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 СТАНДАРТНЫЕ ПАКЕТЫ
Окружающая среда - система объектов
Атрибуты доступны для:
Методы доступны для:
BasicIO - мир за пределами
Все операции ввода и вывода представлены методы файловых объектов. Общего предка называется Файл - смотрите Рисунок 5 - реализует объекты , общие для всех файлов. Его подклассы являются ByteFile и ImageFile (текстовый файл - "образ" является его текстовый буфер). Оба дополнительно специализированы в соответствии с методом доступа (вход, выход прямого доступа). OutFile имеет еще один потомка PrintFile , который реализует страницы ориентированный текстовый вывод. Обратите внимание, что SIMULA не напечатали файлы, сделанные, например , из записей. Этот тип файлов может быть реализован с помощью байтовых файлов. Рисунок 5 содержит некоторые более важные методы с self explaining именами.
Рисунок 5: Иерархия Simula классов файлов.
кадр программы
Все системные объекты в SIMULA концептуально реализованы в виде классов с определенными атрибутами, методов и локальных классов. Пользовательские программы написаны так , как если бы они были вставлены в следующем кадре. Обратите внимание , что правила жизни класса BasicIO создавать и открывать системные файлы перед запуском кода пользователя. После его окончания системные файлы закрыты. Пользовательский код вставляется в двойную Inspect заявление. Это означает, что методы системных файлов (как, например , 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. Связь является знание о двух способов связывания как таковой. Это является еще одним специализированным в качестве заголовка и через элементы членов .
Рисунок 7: Классы , объявленные в системе класса Simset .
Методы списка классов, связанных с:
Linkage
Head
Link
Методы могут быть объединены для представления сложных видов деятельности. Например оператора процедуры:
Queue1.Last.Precede ( Queue2.First);
удаляет последний элемент из queue1 и вставляет его в начале Queue2.
stopped
SIMULA КВАЗИПАРАЛЛЕЛЬНЫХ СИСТЕМЫ
Правила жизни из Simula объектов являются сопрограммы , которые могут быть временно приостановлена , а затем возобновлена. Есть два уровня (квази) параллельности в SIMULA . Первый уровень не работает со временем, программист "мыслит в квазипараллельных ". Второй уровень вводит понятие времени, программист работает с параллельно (с точки зрения пользователя) процессов. Первый уровень может быть применен ко всем классам, второй уровень реализуется классом Process классовой системы Simulation. На рисунке 8 показаны возможные состояния в сопрограммы (тела) объекта X . Обратите внимание , что сопрограммная , который не использует какой - либо из следующих объектов находится на первом attached, а затем terminated (объекты других нструменты всегда прекращается). Уволенному объект все еще может быть использован (можно назвать его методы и / или получить доступ к его атрибуты). Эти Simula средства (методы , доступные во всех классах) , которые поддерживают работу с квазипараллельных системами (КПС):
Detach останавливает выполнение текущего объекта (тот , который выполняет Detach). Текущий объект становится detached. Управление передается в точку , где текущий объект был либо создан или возобновлен.
Resume (Y) активирует отдельно стоящий объект Y , который становится resumed. Текущий объект отделяется.
Call (Y) похожа на резюме , но объект Y прикрепляется к текущему объекту. Текущий объект отделяется. Текущий объект будет возобновлено после того, как отсоединение Y.
Рисунок 8: диаграмма состояния Simula сопрограммам .
QPS Пример 1 : шахматы управления игрой с помощью двух мастеров подход.
В следующей программе есть три сопрограммы : два игрока и основной блок. Отметим , что первые два хода являются специальными. Игрок может выиграть с некоторой вероятностью из третьего хода и далее: Draw ( 0.3, Seed) является булево функция , которая возвращает истину , с вероятностью 0,3. Обратите внимание , как основной блок создает два игрока, связывает их атрибутами Противник и передает управление White. Затем игроки неоднократно делают ходы и возобновить противника , пока один из них не выиграет. Это завершает свое тело и управление передается на основной блок.
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;
Это отступом выход выше программы. Отступ показывает объект, который генерирует вывод - слева направо : Main block, White, Black.
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 : шахматы управления игрой с помощью мастера и два Рабы подхода.
В следующей программе есть также три сопрограммы : два игрока и основной блок. Разница между этим и предыдущим программы является активная роль основного блока. Игроки не возобновить друг друга. Они просто сделать шаг и снять. Основной блок активирует их несколько раз , пока один из них не выиграет. Обратите внимание на использование Call - игроки повторно прикреплены к основному блоку.
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;
Это отступом выход выше программы. Отступ показывает объект, который генерирует вывод - слева направо : Главный блок, белый, черный .
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 Пример 3 : шахматы управления игрой с помощью Мастера и два Рабы подход , осуществленный в виде пакета (main class).
В следующей программе основной класс Chess объявляет две местные классы: Player и Referee. Правила жизни основного класса подготовить игру путем создания и компоновки двух игроков и рефери. Все три объекта отсоединиться и тело главного класса заканчивается. Игра должна быть запущена программой (блокированный с приставкой шахматах). Приставка импортирует все декларации и готовит игру. Обратите внимание, что приставкой блок просто активирует рефери и оценивает игру.
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;
Следующая программа использует основной класс шахматы:
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;
Это отступом выход выше программы. Отступ показывает объект, который генерирует выход - слева: Тело шахмат, Префиксальный блок, белый, черный .
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
МОДЕЛИРОВАНИЕ = МИР ПАРАЛЛЕЛЬНЫХ ПРОЦЕССОВ
Основное понятие классовой системы Simulation является Process - последовательность мгновенных событий (представленных сегментами кода) , разделенных пассивных периодов. На рисунке 9 показаны классы , объявленные в имитации и их методов. Event Notice (подкласс Link) представляет собой запланированное событие , которое произойдет в определенное время - EvTime- в будущем. Proc это процесс , чей сегмент кода будет активирован. SQS (подкласс Head) представляет собой список событий , упорядоченных по времени. Это обычный календарь дискретных языков моделирования. Концептуально это упорядоченный связанный список, внутренняя реализация , как правило , основаны на более эффективной структуре дерева. Очевидно , что этот список не может получить доступ непосредственно из пользовательской программы. Есть диспетчеризацию объектов - увидим позже, что поддержка работы со временем и взаимной синхронизации процессов. Процессы пользовательской программы являются подклассами общего предка Process. Первые два метода проверки его состояния, два других возвращение следующего запланированного события и его время активации.
Рисунок 9: Классы классовой системы моделирования.
Средства системного класса Simulation реализованы с помощью "низкого уровня" квазипараллельных методы: снять, резюме, звоните, но они более дружественным к пользователю. Пользователь моделирования "думает , что параллельно". Динамика имитационной модели выражается в терминах взаимно взаимодействующих параллельных процессов. Таким образом , очень естественно - это именно то, насколько реально работает мир.
Состояния объекта процесса:
Сроки, секвенирование и синхронизация Услуги:
Моделирование Пример 1 : Многоканальная система массового обслуживания - Активный подход клиента.
На рисунке 10 показана система моделируется. Это абстракция, например , банк , где клиенты ждут в одной очереди для любого из кассиров. Интервал между заездах случайна, равномерно распределены между 1 до 3 минут. Все серверы имеют один и тот же случайный службы времени, который обычно распределяется со средним значением 8 минут и стандартное отклонение 2 минуты. Моделирование должно найти среднее время клиент тратит в системе. ( Заметим, что аналитическая модель указанной системы не доступна). Моделирование подобных систем в SIMULA (именно в классе системы моделирования из SIMULA ) всегда начинается с идентификации процессов. Один процесс, очевидно , генератор клиентов - он будет повторно генерировать клиента, записывать свое время прибытия, и ждать случайную задержку. Для того, чтобы выразить динамику системы, существуют два логических подхода. Во- первых (используемый в данном примере) , основан на активных клиентов и пассивных серверов. Противоположный подход - активные серверы, пассивные клиенты показано в следующем примере. Активный клиент имеет правила жизни , представленные следующими шагами:
Рисунок 10: Очереди система, состоящая из одной очереди и более серверов.
Следующая программа является имитационная модель указанной системы. Обратите внимание, что основной целью было показать логику модели в программе как можно более простым. Реальные имитационные модели конечно приглашение для всех переменных параметров и предоставить больше результатов (как, например , средняя и максимальная длина очереди, и т.д. ). В следующей программе существуют два процесса , которые существуют в течение всего эксперимента: генератор и основной программы (блок с приставкой Simulation), который только ждет , пока эксперимент не закончится , а затем отображает результат. Тогда это переменное число процессов клиентов, которые существуют временно. После обновления статистики клиенты прекращается. Обратите внимание на использование стандартных функций для генерации случайных задержек. Существуют стандартные функции в 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 : Многоканальная система массового обслуживания - Активный подход сервера.
Система моделируется такая же, как и в предыдущем примере - см Рисунок 10. Разница в том , активный сервер, который многократно обслуживает клиентов из очереди , пока очередь не опустеет. Затем сервер пассивирует. Клиенты сначала активировать все простаивающие серверы (если таковые имеются) , а затем перейти в очередь. Это, конечно , не очень эффективен, но просто. Клиенты активируются серверами после завершения службы. В остальной части их жизни клиенты просто обновить статистику. Основная программа создает и активизирует все серверы, но они тут же пассивируя, потому что очередь пуста. Затем основная программа активирует генератор и ждет , пока эксперимент не закончится.
! 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 ВЛОЖЕННЫЕ КПС
Квазипараллельного система (КПС) в SIMULA в основном блок ( как правило , но не обязательно приставкой один), чье тело создает некоторые объекты , которые вместе с основной блок из системы квазипараллельных сопрограммам . Поскольку SIMULA ( в отличие, например , Pascal) является истинным блок - ориентированный язык, блок (что обычно означает КПС) может произойти в любом месте в коде как утверждение. Это означает, что КПС может содержать локальные (вложенными) КПС - ые годы, которые также могут содержать локальные КПС - ые годы, и т.д. Это простое правило дает способ создать невероятно сложные структуры с последствиями, которые до сих пор не использовались в полной мере и даже не понял. Следующая программа описывает возможное использование вложенного КПС в контроле шахмат. Следующая глава показывает программу моделирования с вложенной моделирования.
Уплотненный QPS Пример : Контрольная шахматы , используя имитацию игру в качестве части решения.
Давайте предположим , что шахматист , как часть его / ее решение имитирует текущую игру , чтобы проверить возможный исход следующего хода. Следующая программа (на основе подхода двух мастеров) приведено краткое описание одного из возможных решений. Обратите внимание , что класс игрока имеет метод TestStrategy называемый как часть каждого решения. Этот метод реализует КПТ похож на внешней. Он содержит локальный класс 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 в SIMULA , как можно реализовать вложенные системы. В предыдущей главе рассматриваются низкий уровень вложенных QPS - х. Класс Система имитации вводит понятие времени. Это означает , что если вложены, будут и другие местные (вложенные) раз. Основная идея заключается в рисунке 11. Заявления Трюмные с задержками х и г относится к главному (внешней) времени. Оператор Удержание с задержкой у находится в другом альтернативном мире. Таким образом , в SIMULA можно моделировать системы , найденные до сих пор только в научной фантастике. Есть практические применения. В принципе можно моделировать системы, содержащие моделирование как часть процесса принятия решений. Рассмотрим такую ситуацию: есть некая сложная система и группа экспертов , которые предлагают разные решения, результаты которых не могут быть проверены в тривиальной или аналитическим способом. (Не это обычное дело на практике?) Для того, чтобы проверить и оценить свои предложения решения, эксперты проводят эксперименты моделирования, сравнить результаты и выбрать наиболее перспективное решение. Теперь предположим, что все это будет имитацией.
Рисунок 11: Основные идеи вложенную моделирования.
Уплотненный Моделирование Пример : массового обслуживания сети , чья часть оптимизирована путем повторного вложенного моделирования.
На рисунке 12 показана система моделируется. Это абстракция, например , банк , где клиенты сначала ждать в одной очереди для кассира. После того , как обслуживается кассиром, клиент обслуживается кассиром. Существует еще одна очередь, где клиенты ждут кассиров. Случайный интервал между прибытием и в случайные моменты времени обслуживания кассиров и кассиры известны. Давайте предположим, что есть определенное количество клерков, которые могут работать как в качестве кассиров и кассиров. Руководство банка хочет проверить, как клерки выделяются , как кассиры и кассиры , как во время обычного сдвига состоит из трех периодов: занят, неактивен, и очень занят один с различными интервалами между поступлениями клиентов. Чтобы найти лучший политики распределения, вложенный моделирование может быть использовано следующим образом: в начале каждого периода, внутреннее повторяется моделирование будет тестировать поведение первого этапа для различного числа кассиров (очевидно , диапазон от 1 до общее известное число клерков). Используя результаты этих внутренних имитационных экспериментов, руководство будет выбирать количество клерков , которые будут работать в качестве кассиров, остальные будут работать в качестве кассиров. Для того чтобы программа проста, решение делается пользователем, который дается результаты внутреннего моделирования , а затем будет предложено ввести количество кассиров и количество кассиров. Критерий решение среднее время , проведенное на первом этапе. Политика как таковой также оценивается среднее время , проведенное во всей системе.
Рисунок 12: Очереди сеть состоит из двух многоканальных серверов.
Следующий "Программа" представляет собой план программы моделирования (что следует). Обратите внимание, что внутренний блок с приставкой моделирования выполняется многократно три раза для всех возможных чисел кассиров. Он содержит декларацию классов , подобных внешних. Различие является более простым поведение клиента, так как существует только один этап сервис. Там также не далее вложенности. В основном внутреннее моделирование аналогично примеру , приведенному в главе о классе системы моделирования (активный подход к клиенту).
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;
The next program is the nested simulation model with the above structure.
! NESTED Моделирование с помощью SIMULA в классе МОДЕЛИРОВАНИЯ ;
! ;
! Примером может служить модель банка. Клиенты в первую очередь ;
! служил на кассиров, а затем кассирами. ;
! Изменения скорости ввода в три периода: есть занят;
! период , тогда период простоя и снова напряженным. ;
! Для каждого периода повторное внутреннее моделирование эксперимента;
! имитирует первую очередь для конкретной скорости ввода ;
! и для различного количества серверов. Затем он показывает ;
! Результаты (среднее время , проведенное на первом сервере) и ;
! запрашивает у пользователя числа кассиров и числа;
! из кассиров. Tellers всегда закончить службу , которая имеет ;
! уже началась. Моделирование должно найти ;
! время клиенты тратят в банке (средней и максимальной) ;
! для различного числа клерков в трех периодах. ;
! ;
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;
Это выход имитационной модели вместе с номерами введенных. Общее количество клерки составляет 6, числа , выделенные в качестве кассиров и кассиры, вводятся пользователем. Обратите внимание , максимальное время , проведенное в системе. Это не сохраняется разумным до третьего периода, где он повышен до 63,93 минут (обратите внимание , что общее среднее время обслуживания составляет 6 + 8 = 14 минут). Так что ясно, что в третьем очень напряженный период еще один клерк бы значительно улучшить системы поведения . Эта гипотеза была проверена другим симуляции с теми же данными , за исключением еще одного кассира в третьем периоде (4 кассиров, 3 кассиры). Это дало следующие результаты: среднее время , проведенное в системе 19,67 ( 21,84 для 2 -х кассиров), максимальное время , проведенное в системе 36.58 , что является ожидаемым улучшением. Таким образом, результат моделирования является предложение руководству выделить еще одну кассиршу в третьем очень напряженный период, в противном случае система ведет себя хорошо с 6 клерков.
*** 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
Нажмите Enter, чтобы продолжить.
ЧТО НЕ ТАК С SIMULA?
SIMULA никогда не стал широко распространен широко используемый язык. Существуют различные причины , чтобы объяснить этот факт. Даже несмотря на то причины , все зависят друг от друга, следующая попытка сгруппировать их из различных Ponts зрения.
В общем:
Языковые особенности:
Особенности ООП:
Моделирование:
Источник: http://staff.um.edu.mt/jskl1/talk.html