texts
stringlengths 0
715k
| names
stringlengths 8
91
|
|---|---|
Empty.odc |
|
Проект ИНФОРМАТИКА-21
Внедрение современных технологий и методов программирования
в общие базовые курсы программирования
(5-11 классы средних школ и 1-3 курсы университетов,
независимо от профиля и специализации)
с целью создания единого пространства
для преподавания основ ИТ
как естественного продолжения
единой общей системы преподавания основ математики
Подробная информация о проекте: http://www.inr.ac.ru/~info21/
Для вопросов и замечаний: [email protected]
Благодарности. Российские версии среды обучения и разработки программ, носящие название Блэкбокс, основаны на системе программирования BlackBox Component Builder, созданной в Oberon microsystems, Inc., в развитие идей, впервые реализованных в Системе Оберон Никлауса Вирта и Юрга Гуткнехта (Niklaus Wirth, Jurg Gutknecht, ETH, Zurich, Switzerland). Со-архитектор Блэкбокса Клеменс Шиперски (Clemens Szyperski) работает в исследовательском подразделении корпорации Майкрософт (Microsoft Research).
Вклад в создание данного пакета внесли множество людей, в том числе: Wolfgang Weck, И.Н.Горячев, И.А.Дехтяренко, И.Е.Ермаков, А.С.Ильин, ketmar, Ю.Л.Костюк, Л.Г.Куркина, Т.В.Овсянникова, А.И.Попков, Б.В.Рюмшин, Е.Э.Темиргалеев, Ф.В.Ткачев, И.А.Цвелая.
Особая благодарность компании Метасистемы (г.Орел), а также всем тем, кто принял участие в переводах документации на русский язык.
г Все тексты программ и др. материалы проекта, если не указано иное: проект Информатика-21 ( http://www.inr.ac.ru/~info21/), 2002-2012 гг. Никакое коммерческое использование материалов, в том числе в рамках PR-деятельности коммерческих фирм и т.п., без письменного разрешения авторов не допускается. | i21Greeting.odc |
Сборка Блэкбокса для школьных уроков информатики
«Блэкбокс практически идеальная среда для обучения программированию.»
Т.Евсикова, научный сотрудник,
Институт математики и информатики, Вильнюс, Литва
«... школьная сборка это блестящая работа, лучше я еще не видел.
Для меня главное, что показан путь, каким надо двигаться в рамках моих учебных дел.
Это очень ценно и для развивающихся учителей: они сами будут достраивать <сборку>
в нужном направлении. Никаких специальных институтов не нужно.»
В.В.Лаптев, профессор,
Астраханский гос. тех. университет
«... скачал вашу сборку и как в сказку попал ...
Ввод через любое выделение в документе, дружелюбная гипернавигация,
<ключевые> слова <можно писать> на русском, мастер нового приложения с подсказками ...»
Александр Шостак, студент,
специальность "экономическая информатика"
Основа школьной сборки уникальная современная бесплатная и открытая среда программирования Блэкбокс (BlackBox Component Builder), воплотившая полувековой (считая с Алгола-60) опыт разработки технологий и методов программирования (школа Никлауса Вирта в цюрихском университете ETH, исследовательская лаборатория Xerox Palo Alto Research Center и др.).
Система Блэкбокс реализует в широко доступном виде идеи проекта Оберон легендарного Никлауса Вирта и его соратника Юрга Гуткнехта (см. книгу «Проект Оберон», ДМК Пресс, 2012), а также предшественников (системы Lilith/ETHZ и Mesa/Xerox PARC).
Язык программирования, используемый в Блэкбоксе, Оберон/Компонентный Паскаль прямой потомок старого паскаля (в отличие от множества "бастардов", которые, чтобы уцепиться за легендарный бренд, вынуждены декларировать "совместимость" с давно устаревшим языком, что на поверку оборачивается сохранением всех его дефектов, в том числе довольно существенных).
Со-архитектор Блэкбокса Клеменс Шиперски ведущий мировой специалист по вопросам архитектуры ПО. Он описал принципы, на которых систематически построен Блэкбокс, в мировом бестселлере (C.Szyperski "Component Software. Beyond Object-Oriented Programming", Addison Wesley Longman, 1998, 2002) и с 1999 работает в Microsoft Research, помогая внедрять эти идеи в промышленную практику.
Однако, увы, на широко распространенных промышленных инструментах тяжким грузом лежит наследие ошибок и заблуждений начального этапа становления сферы ИТ, оформившихся по законам антропологии в своеобразную мифологию, которая поддерживает сама себя в том числе и через зачастую иррациональные требования "совместимости".
Тем не менее идеология Оберона (точный минимализм и безусловный приоритет надёжности и расширяемости) продолжает медленно, но верно влиять на IT-индустрию (Java, C#, Go ...).
В этом смысле Оберон, являющийся квинтэссенцией лучшего мирового опыта программирования, оказывается уникальным образовательным инструментом, своего рода вдохновляющим «воспоминанием о будущем».
Школьная сборка опирается на опыт участников проекта «Информатика-21» и в полной мере эксплуатирует мощные обероновские механизмы безопасной компонентной расширяемости, доступные любым квалифицированным учителям (например, настройки меню системы способны выполнять даже некоторые 5-классники после краткого инструктажа).
Школьная сборка является компонентной надстройкой над т.наз. «базовой» сборкой Блэкбокса 1.5 от проекта «Информатика-21». Обе сборки свободно доступны в Сети по адресу http://www.inr.ac.ru/~info21/software.htm
В школьной сборке по сравнению с «базовой»:
имеется довольно полный комплект обучающих инструкций для учителя (файл "i21edu/Справка для учителя.odc", куда включены обновленные инструкции с сайта проекта, так что теперь всё доступно в одном месте);
реализована возможность компиляции и выполнения «одной кнопкой» в стиле Турбо Паскаля;
добавлена опция «жёсткой» проверки компилятором отступов в программах;
русифицированы меню, сообщения компилятора и проч.;
возможность прозрачно работать с программами, использующими ключевые слова с кириллицей (наряду с английскими), при русифицированной поддержке отладочных средств; при этом механизм локализации может быть легко настроен на работу и c языками, имеющими кодировки в расширенном диапазоне ASCII, поддерживаемые операционной системой;
имеются дополнительные учебные материалы.
Как и в «базовой» сборке, имеется полный перевод документации на русский язык с соответствующей инструментальной поддержкой (поиск, меню и т.п.).
Форум для вопросов по данной сборке Блэкбокса:
http://forum.oberoncore.ru/viewtopic.php?f=7&t=2059
____________________
Проект «Информатика-21»
2012-11-09
| i21Привет.odc |
Это вход для профи, много лет проведших с традиционными средствами разработки, чтобы облегчить им традиционную ломку.
Профи
Выше жирно напечатано имя простого модуля, в котором содержится програмка типа Hello World и объяснения.
Чтобы открыть и поиграть с исходником, дважды кликнуть по Профи (хоть по этому, хоть по тому) и нажать Ctrl+0 (тут нуль цифра).
Исходник хранится в документе Mod/Профи.odc и это не чистый текст не надо пытаться открывать его в Блокноте при работе в Блэкбоксе необходим только Блэкбокс со своим интегрированным редактором.
Так нужно, потому что в Оберонах вообще и в Блэкбоксе в частности реализована идея «текст как интерфейс», т.е. вместо традиционной командной строки, где редактируется только последняя строчка, здесь весь (любой) текстовый документ может служить этакой двумерной «командной строкой» для ввода команд и данных.
Понадобится время, чтобы уяснить себе всё удобство и всю мощь этого обобщения.
Можно точно так же быстро (двойной клик, Ctrl+0) открыть исходники других модулей, например, i21sysEdit (файл i21sys/Mod/Edit.odc; о правилах хранения модулей см. инструкции на сайте Информатика-21 и Полезные сведения
программеры удивлялись, что достаточно инструкций на сайте и в документации, чтобы довольно быстро начать продуктивно работать: толстых учебников не нужно).
В модуле i21sysEdit зашито, как именно кнопка F5 раскрывает синтаксические конструкции по первому слову, причем с правильными отступами (табы). См. ссылки в объяснениях к исходнику.
Успехов!
info21
2009-03-28; последне испр. 2010-04-01
PS Большая благодарность В.В.Лаптеву за совет.
| readme, профи!.odc |
BlackBox
Windows
Guided Tour
July 2000
Guided demonstration of the BlackBox Component Builder.
About this tour
This text is a quick introduction to the BlackBox Component Builder. Read it and follow the small handsђon examples to get a feeling for the way how BlackBox works.
Overview over the BlackBox Component Builder
The BlackBox Component Builder is an integrated development environment optimized for component-based software development. It consists of development tools, a library of reusable components, a framework that simplifies the development of robust custom components and applications, and a run-time environment for components.
In BlackBox, the development of applications and their components is done in Component Pascal. This language is a descendant of Pascal, Modula-2, and Oberon. It provides modern features such as objects, full type safety, components (in the form of modules), dynamic linking of components, and garbage collection. The entire BlackBox Component Builder is written in Component Pascal: all library components, all development tools including the Component Pascal compiler, and even the low-level run-time system with its garbage collector. In spite of its power, Component Pascal is a small language that is easy to learn and easy to teach.
The component library that comes with BlackBox contains components for user interface elements such as command buttons or check boxes; various components that provide word processing functionality (Text subsystem); various components that provide layout management functionality for graphical user interfaces (Form subsystem); database access components (Sql subsystem); communication components (Comm subsystem); and a number of development tool components such as compiler, interface browser, debugger, and so on (Dev subsystem).
Component interactions are governed by the BlackBox Component Builder's Frameworks. These consist of a number of complementary programming interfaces. These interfaces are much simpler and safer, and platform-independent moreover, than basic APIs, such as the Windows APIs. For interactive applications, they define a quite unique compound document architecture. This architecture enables rapid application development (RAD), including the rapid development of new user interface components. The framework design strongly emphasizes robust component interaction. This is important for large-scale software projects that involve components from different sources and evolution of the software over long periods of time. To combine the productivity of a RAD environment with a high degree of architectural robustness was a major design goal for the BlackBox Component Builder. It was attempted to create an environment that is light-weight and flexible, yet doesn't sacrifice robustness and long-term maintainability of software produced with it. This was made possible by an architecture that decomposes the system into components with well-defined interfaces. Software is evolved incrementally, by adding, updating, or removing entire components.
The BlackBox run-time environment supports dynamic linking and loading (and unloading) of components. In this way, a system can be extended at run-time, without recompiling, relinking, or restarting existing code. Component objects (i.e., instances of classes contained in components) are automatically removed when they are not referenced anymore. This garbage collection service is a crucial safety feature of the run-time system, since it allows to prevent errors like memory leaks and danging pointers, which are almost impossible to avoid in a heavily component-oriented system like BlackBox.
Views
Now let's have a look at some standard BlackBox components. Views are the most interesting objects implemented by BlackBox components; they can be embedded into documents or other views. Views can be edited and resized in place. This tour text contains several embedded views. Here is a first one: a picture view without editing capabilities; it can be resized by first clicking into the picture and then dragging the displayed resize handles.
A picture view as an example of a component object embedded in a compound document.
Other examples of views are controls such as command buttons, check boxes, alarm indicators, oil level meters, and so on. More complex views can implement full-fledged editors such as spreadsheets or graphics editors. The most complex views in BlackBox are container views, i.e., views that may contain other views. Text views are an important example of BlackBox container views. You are now looking at such a text view. Further below, there is an embedded text view containing a small program. The following sections demonstrate how simple programs can be written and tested, and how a graphical user interface can be constructed.
Software development
The source code below is a fully editable text, showing the complete implementation of a small Component Pascal module. To compile the module, focus the embedded view by clicking into it (e.g., click on the keyword PROCEDURE), and then execute Compile from menu Dev. As a result, the module is compiled into fast native machine which is written to disk (the file Obx/Code/Hello0).
MODULE ObxHello0;
IMPORT StdLog;
PROCEDURE Do*;
BEGIN
StdLog.String("Hello World"); StdLog.Ln
END Do;
END ObxHello0.
ObxHello0 is a minimal "hello world" program in Component Pascal. It writes a single line to the system log text. Execute Open Log from menu Info to display the system log, if it is not open already.
Exported items in Component Pascal modules are marked by a trailing asterisk; there are no separate header files, definition modules, or the like. Consistency of interfaces and implementations is fully checked by the compiler; version integrity is checked by the dynamic linker.
Module ObxHello0 exports a single command Do. Commands are exported Component Pascal procedures that can be called by the user; i.e., they can be executed directly from the user interface. There is no need for a central "main" procedure or top-level module. A command can be added to a menu, attached to a button, or executed directly from within a text. Select the string "ObxHello0.Do" below, and then execute command Execute in menu Dev:
ObxHello0.Do
When the compiler finds syntax errors, it flags them directly in the text. For example, the following module version erroneously imports the (nonђexisting) module StdLok, instead of StdLog. Try to compile the module - the compiler inserts special embedded objects (error markers) flagging the errors that it found. The compiler also writes a report to the system log.
MODULE ObxHello0;
IMPORT StdLok;
PROCEDURE Do*;
BEGIN
StdLog.String("Hello World"); StdLog.Ln
END Do;
END ObxHello0.
By clicking on an error marker, a short error message is displayed in the status bar. Correct the mistake (replace the "k" in IMPORT StdLok by a "g"), and compile again. The marker disappears, and the module is compiled successfully.
The set of currently loaded modules can be inspected by clicking on the Loaded Modules command in the Info menu. The interfaces of modules (loaded or not) can be displayed using the interface browser: select a module name and then execute Client Interface from menu Info. For example, you may find out the interface of the following module:
Math
A module remains loaded until it is explicitly unloaded, or until the BlackBox Component Builder is restarted. To explicitly unload a module, select the module name and execute Unload Module List from menu Dev. For example, unload ObxHello0, modify the string "Hello world", recompile ObxHello0, and execute ObxHello0.Do again. Note that your changes do not affect the running system until after you have unloaded the old module. Such an explicit unloading is a very useful mechanism to allow major changes in multiple modules, while still using and working with the previous version. For simple top-level modules, (modules that are not imported by other modules), the command Compile And Unload provides a convenient shortcut.
Linking programs to form documents
Besides the text and development subsystems, the BlackBox Component Builder also comes with a form subsystem, which includes a visual user interface designer. Forms can be data entry masks or dialog boxes.
The following module defines a simple record variable to be used for a data entry form.
MODULE ObxAddress1;
IMPORT Views, TextModels, TextMappers, TextViews;
VAR
adr*: RECORD
name*: ARRAY 64 OF CHAR;
city*: ARRAY 24 OF CHAR;
country*: ARRAY 16 OF CHAR;
customer*: INTEGER;
update*: BOOLEAN
END;
PROCEDURE OpenText*;
VAR t: TextModels.Model; f: TextMappers.Formatter; v: Views.View;
BEGIN
t := TextModels.dir.New(); (* create a new text editor object *)
f.ConnectTo(t); (* connect a formatter to this object *)
f.WriteString(adr.name); f.WriteTab;
f.WriteString(adr.city); f.WriteTab;
f.WriteString(adr.country); f.WriteTab;
f.WriteInt(adr.customer); f.WriteTab;
f.WriteBool(adr.update); f.WriteLn;
v := TextViews.dir.New(t); (* create a visual component for the text object *)
Views.OpenView(v) (* open the visual component in its own window *)
END OpenText;
END ObxAddress1.
After compiling the module, a dialog box can be created for the items exported by ObxAddress1 using command New Form... from menu Controls. Just enter the name ObxAddress1 into the Link field, and then click on the Create button. The type information extracted by the compiler is available to the BlackBox Component Builder at run-time, and is used to automatically create a data-entry form for the record declaration above. The form has a simple default layout. This default layout may be edited, and then opened as a dialog using the Open as Aux Dialog command in menu Controls.
The text entry fields and the checkbox of the form are directly linked to the fields name, city, country, customer and update of the record ObxAddress1.adr. The button is linked to the command OpenText, i.e., to the procedure exported by module ObxAddress1. Clicking the button causes procedure OpenText to be called. As a result, a new text is created; a textual report based on the variable adr is written to this text; a new text view is created; and the view is opened in a window, displaying the report.
Text entry fields, checkboxes, and other so-called controls may have properties that could be inspected and modified by a suitable control property inspector. Instead of first writing a module and then creating an initial layout, as we have done above, the form can be constructed first, and the corresponding module written later. A BlackBox Component Builder dialog does not necessarily correspond to exactly one record variable. The individual controls of a dialog box may be linked to records in different modules, and a dialog box may also contain other views which are not controls, such as pictures.
A form can be saved from within the visual editor; thereafter it can be attached to a menu entry, or another dialog's button. Dialog boxes are saved in the standard document format, in a platformђindependent way. This approach eliminates the need for an intermediate source code generator and allows to later modify the dialog boxes without having to recompile anything.
And more ...
After this first impression, you may want to consult your documentation for an in-depth coverage of the BlackBox Component Builder. Select the Contents item in the Help menu for an overview over the documentation. From there, the complete on-line documentation can be reached via hyperlinks.
How should you start to get acquainted with BlackBox? We suggest that you start with the introduction texts A Brief History of Pascal and Roadmap.
The documentation consists of four major parts:
A user manual that describes the user interface and most important commands of the BlackBox Component Builder
A tutorial that first introduces the general BlackBox design patterns (chapters 1 to 3). Graphical user interfaces, forms, and controls are discussed in chapter 4. The text subsystem is explained in chapter 5. The remaining chapter 6 deals with view programming.
Overview by Example is a rich source of examples, ordered by category and difficulty.
The programmer's reference consists of one documentation file per module. Each subsystem has a Sys-Map text which contains links to the individual texts.
| Tour.odc |
Блэкбокс
Краткий обзор
ENGLISH
Июль 2000
(C) Oberon microsystems, Inc.
(C) Перевод на русский язык: В. В. Лось, 2002.
(C) Редакция перевода: Ф. В. Ткачев, 2010.
О переводе терминологии.
Краткий обзор основных возможностей системы Блэкбокс (BlackBox Component Builder).
Об этом обзоре
Данный текст представляет собой краткое введение в BlackBox Component Builder (в дальнейшем Блэкбокс). Чтобы представить себе, как работает Блэкбокс, читайте и следите за практическими примерами в тексте.
Обзор системы Блэкбокс
Блэкбокс это интегрированная среда разработки, оптимизированная для разработки ПО с компонентной структурой. В неё входят: инструменты разработки; библиотека повторно используемых компонентов; каркас приложений, упрощающий создание надёжных пользовательских компонентов и приложений; среда поддержки функционирования компонентов во время исполнения.
В системе Блэкбокс приложения и их компоненты пишутся на Компонентном Паскале (в дальнейшем КП; см. русскийЏпереводЏописания) наследнике Паскаля, Модулы-2 и Оберона. Этот язык программирования предоставляет такие современные возможности, как полная защищенность типов (type safety), компоненты (в виде модулей), динамическое связывание компонентов, а также сборка мусора. Сам Блэкбокс целиком написан на КП, включая все компоненты в библиотеке, весь инструментарий разработчика, компилятор КП, и даже низкоуровневую систему поддержки времени исполнения со сборщиком мусора. Несмотря на всю свою мощь, Компонентный Паскаль маленький язык, легкий для изучения.
Библиотека компонентов, поставляемая с Блэкбоксом, содержит:
компоненты для элементов пользовательского интерфейса (командные кнопки, кнопки-флажки и т.п.); средства обработки текстов (подсистема Text);
различные компоненты для управления расположением элементов графического интерфейса пользователя (подсистема Form);
компоненты доступа к базам данных (подсистема Sql); коммуникационные компоненты (подсистема Comm);
инструменты программирования: компилятор, просмотрщик интерфейсов, отладчик и т. д. (подсистема Dev).
Взаимодействие между компонентами осуществляется посредством каркасов (Frameworks) системы Блэкбокс. Они состоят из небольшого числа дополняющих друг друга программных интерфейсов. Эти интерфейсы значительно проще и безопаснее базовых API, таких как Windows API, и, кроме того, платформо-независимы. Для интерактивных приложений эти интерфейсы определяют довольно уникальную архитектуру составных документов. Эта архитектура делает возможной быструю разработку приложений (RAD), в том числе быструю разработку новых компонентов интерфейса пользователя. В конструкции каркаса особое внимание уделено безопасному взаимодействию между компонентами. Это условие становится чрезвычайно важным для крупномасштабных программных проектов, характеризующиеся большим временем жизни и содержащие компоненты от различных поставщиков. Сочетание производительности RAD с высоким уровнем надёжности архитектуры было одной из главных целей разработки системы Блэкбокс. Была сделана попытка создать гибкую и нетребовательную к ресурсам среду, не жертвуя ни надёжностью, ни удобством долгосрочного сопровождения проектов, созданных в этой среде. Это было достигнуто благодаря архитектуре, в которой система разделяется на компоненты с четко и строго определёнными интерфейсами. Программное обеспечение развивается эволюционно через добавление, обновление или удаление отдельных компонентов.
Среда времени выполнения системы Блэкбокс поддерживает динамическое связывание, загрузку и выгрузку компонентов. За счёт этого система может быть расширена прямо во время выполнения без повторной компиляции, сборки или перезапуска полученного кода. Объекты компонентов (т. е. экземпляры классов, содержащихся в компонентах) автоматически удаляются, когда на них больше нет ссылок. Сборка мусора ключевой аспект безопасности системы времени выполнения, так как она позволяет предотвратить такие ошибки, как утечки памяти и «висячие» указатели, которых иначе практически невозможно избежать в среде, столь сильно ориентированной на использование компонентов, как Блэкбокс.
Объекты изображения («вьюшки»)
А теперь посмотрим на некоторые стандартные компоненты Блэкбокса. Наиболее интересными объектами, реализуемыми компонентами Блэкбокса, являются объекты изображения или «вьюшки» (views; см. О переводе терминологии); они могут быть вставлены в документы и в другие вьюшки. Вьюшки могут быть отредактированы, их размеры можно изменять прямо в месте их расположения. Текст данной экскурсии содержит несколько встроенных вьюшек. Вот первая из них: вьюшка с картинкой без возможности редактирования; ее размеры можно изменять, щёлкнув по картинке и затем перетаскивая появившиеся метки-манипуляторы размера.
Объект изображения (вьюшка) с картинкой как пример объекта-компонента, помещенного в составной документ.
Другими примерами вьюшек являются элементы управления, такие как командные кнопки, флажки, индикаторы ошибок, индикаторы уровня масла и т. д. Более сложные вьюшки могут реализовывать полнофункциональные редакторы, такие как электронная таблица или графический редактор. Наиболее сложными вьюшками в Блэкбоксе являются вьюшки-контейнеры, то есть объекты-вьюшки, которые могут содержать другие вьюшки. Текстовые вьюшки важный пример вьюшек-контейнеров Блэкбокса. Сейчас вы смотрите именно на такую текстовую вьюшку. Далее внизу вставлена текстовая вьюшка, содержащая маленькую программу.
Дальнейшие разделы показывают, как могут быть написаны и протестированы простые программы и как можно создавать элементы графического интерфейса пользователя.
Разработка программ
Приведенный ниже код редактируемый текст, показывающий законченную реализацию маленького модуля, написанного на КП. Чтобы скомпилировать его, установите фокус на эту вьюшку, щёлкнув по ней (например, щёлкните по слову PROCEDURE), и затем вызовите в меню Dev команду Compile. В результе модуль скомпилируется в быстрый исполняемый машинный код и будет сохранён на диске (в файле Obx/Code/Hello0).
MODULE ObxHello0;
IMPORT StdLog;
PROCEDURE Do*;
BEGIN
StdLog.String("Hello World"); StdLog.Ln
END Do;
END ObxHello0.
ObxHello0 традиционная минимальная программа "hello world" на КП. (На самом деле возможен ещё более краткий вариант, см. О процедурах и модулях. прим. ФТ.) Эта программа записывает единственную строку в рабочий журнал (system log). Чтобы открыть рабочий журнал (если он по какой-то причине не виден) выполните команду меню Info->Open Log.
Чтобы указать, что какой-то элемент экспортируется из данного модуля, после имени элемента в его объявлении ставится звёздочка; никаких отдельных заголовочных файлов, модулей определений и т.п. создавать не требуется. Компилятор полностью проверяет согласованность интерфейсов и реализаций, а динамический загрузчик согласованность версий.
Модуль ObxHello0 экспортирует единственную команду Do. Команды экспортированные процедуры КП, которые могут выполняться пользователем напрямую, средствами пользовательского интерфейса. Нет необходимости в особой «главной» процедуре или модуле верхнего уровня. Команды могут быть добавлены в меню, связаны с командной кнопкой или выполнены прямо из текста. Выделите стоящую ниже строку «ObxHello0.Do» и выполните пункт меню Dev>Execute.
ObxHello0.Do
Когда компилятор находит синтаксические ошибки, он отмечает их прямо в тексте. Например, следующая версия модуля импортирует несуществующий модуль StdLok вместо StdLog. Попробуйте скомпилировать этот модуль компилятор вставит специальные маркеры, отмечающие ошибки, которые он обнаружил. Компилятор также выводит отчёт в системный журнал.
MODULE ObxHello0;
IMPORT StdLok;
PROCEDURE Do*;
BEGIN
StdLog.String("Hello World"); StdLog.Ln
END Do;
END ObxHello0.
Двойной щелчок по отметке об ошибке высвечивает короткое сообщение об ошибке в строке состояния. Исправьте ошибку (замените «k» в IMPORT StdLok на «g») и скомпилируйте ещё раз. Модуль успешно скомпилируется и отметки исчезнут.
Посмотреть весь набор модулей, загруженных в память, можно с помощью команды меню Info>Loaded Modules. Интерфейсы модулей (загруженных или нет) можно посмотреть просмотрщиком интерфейсов: выделите имя модуля и затем выполните команду меню Info>Client Interface. Например, попробуйте узнать интерфейс следующего модуля:
Math
Всякий модуль остаётся загруженным до тех пор, пока его явно не выгрузят (unload) или не перезапустят BlackBox Component Builder. Для явной выгрузки модуля выделите имя модуля и выполните Dev>Unload Module List. Например, для выгрузите ObxHello0, измените строку "Hello world", перекомпилируйте ObxHello0 и снова запустите ObxHello0.Do. Обратите внимание, что новые изменения никак не затронули программы, уже находящиеся в памяти, пока вы не выгрузили старый модуль. Этот механизм явной выгрузки очень полезен, когда нужно сделать значительные изменения в нескольких модулях, в то время как предыдущие версии всё еще используются в работе. Для простых модулей высшего уровня (не импортированных другими модулями), существует пункт Скомпилировать и Выгрузить (Dev->Compile And Unload).
Связывание программ с документами форм
Кроме подсистем Text и Dev, с Блэкбоксом поставляется также подсистема форм (Form), которая включает в себя визуальный дизайнер пользовательских интерфейсов. Формы могут использоваться для ввода данных или быть диалоговыми окнами.
Следующий модуль определяет запись для использования в форме ввода данных.
MODULE ObxAddress1;
IMPORT Views, TextModels, TextMappers, TextViews;
VAR
adr*: RECORD
name*: ARRAY 64 OF CHAR;
city*: ARRAY 24 OF CHAR;
country*: ARRAY 16 OF CHAR;
customer*: INTEGER;
update*: BOOLEAN
END;
PROCEDURE OpenText*;
VAR t: TextModels.Model; f: TextMappers.Formatter; v: Views.View;
BEGIN
t := TextModels.dir.New(); (* создать новый объект-текст *)
f.ConnectTo(t); (* подключить форматер к этому объекту *)
f.WriteString(adr.name); f.WriteTab;
f.WriteString(adr.city); f.WriteTab;
f.WriteString(adr.country); f.WriteTab;
f.WriteInt(adr.customer); f.WriteTab;
f.WriteBool(adr.update); f.WriteLn;
v := TextViews.dir.New(t); (* создать объект-вьюшку для текстового объекта *)
Views.OpenView(v) (* открыть эту вьюшку в ее собственном окне*)
END OpenText;
END ObxAddress1.
После компиляции этого модуля можно использовать команду меню Новая Форма... (Controls>New Form...), чтобы создать диалоговое окно для экспортирующихся элементов ObxAddress1. Просто введите имя ObxAddress1 в поле Связан с (Link) и затем нажмите кнопку OK. Информация о типах, полученная компилятором, доступна Блэкбоксу и используется для автоматического создания формы ввода данных для записи, объявленной выше. При создании формы элементы размещаются в них по некоторым простым предопределённым правилам. Форму можно отредактировать, а затем открыть командой Controls->Open as Aux Dialog.
Поля ввода текста и флажки в форме напрямую связываются с полями name, city, country, customer и update записи ObxAddress1.adr. Кнопка связывается с командой OpenText, то есть с процедурой, экспортированной модулем ObxAddress1. Нажатие на эту кнопку вызывает исполнение процедуры. В результате создаётся новый текст; туда пишется текстовый отчёт, основанный на данных из переменной adr; создаётся новое текстовое изображение; это изображение открывается в окне, показывая отчёт.
У полей ввода текста, флажков и других элементов управления имеются свойства, которые можно посмотреть и отредактировать в т. наз. инспекторе. Вместо той последовательности действий, которую мы только что продемонстрировали (сначала был написан модуль, потом создавалась форма), мы можем сначала построить форму, и только потом написать соответствующий модуль. Диалог в Блэкбоксе не обязан соответствовать единственной переменной-записи. Разные элементы управления в диалоге могут подключаться к записям в различных модулях. Кроме того, диалоги могут содержать другие вьюшки наряду с элементами управления, например, картинки или текст.
Форма может быть сохранена прямо из визуального редактора; затем ее можно связать с пунктом меню или с кнопкой какого-нибудь другого диалога. Диалоговые окна сохраняются в стандартном формате документов, независящим от платформы. Такой подход устраняет необходимость иметь генератор промежуточного кода и позволяет в дальнейшем изменять диалоговые окна без какого-либо перекомпилирования.
Что дальше ...
Получив первые впечатления, вы можете воспользоваться документацией для более глубокого изучения Блэкбокса. Выберите пункт меню Help->Contents для обзора документации. Отсюда через гиперссылки вы сможете получить доступ к полной документации.
Как лучше знакомиться с Блэкбоксом? Мы советуем начать с вводных текстов Краткая история Паскаля и Путеводитель (см. также Полезные сведения прим. ред.)
Документация делится на четыре большие части:
Руководство пользователя описывает интерфейс пользователя и наиболее важные команды Блэкбокса.
Учебник объясняет основные шаблоны проектирования Блэкбокс (главы с 1-й по 3-ю). В главе 4 обсуждается графический интерфейс пользователя, формы и управляющие элементы. Текстовая подсистема описывается в главе 5. Последняя глава 6 знакомит с программированием объектов изображения (вьюшек, views).
Примеры богатый набор примеров с исходными текстами, упорядоченных по категориям и сложности.
Руководство программиста содержит по одному файлу документации на каждый программный модуль. В каждой подсистеме имеется документ с названием Sys-Map, содержащий ссылки на тексты для отдельных модулей. | TourRu.odc |
О примерах программ из книги:
Н.Вирт «Алгоритмы и структуры данных.
Новая версия для Оберона»
ДМК Пресс, Москва, 2010
Ф.В.Ткачев, 2009-10-18; последние исправления 2012-11-09
Книга на Озоне:
Н.Вирт. «Алгоритмы и структуры данных. Новая версия для Оберона.» ДМК Пресс, 2010
Как приступить к Блэкбоксу
Номенклатура названий модулей
Оформление примеров программ из книги
Вспомогательные модули
Ввод-вывод
Список модулей с примерами
Как приступить к Блэкбоксу
Получить самые первые сведения по работе в Блэкбоксе можно, изучив первый пример: ADruS13 (это гиперссылка, типа как в браузере, клик по ней открывает модуль; ниже дан список гиперссылок на остальные модули).
Научиться работать в Блэкбоксе гораздо проще, чем обычно кажется профессионалам можно обойтись без чтения толстых мануалов, так как никаких make'ов и прочих прагм тут нет как класса.
Для для тех, кто привык к традиционным средам, есть быстрое введение Привет, профи!
Начинающим рекомендуется посмотреть следующие документы: Краткий обзор, Полезные сведения.
Инструкции можно найти на сайте проекта Информатика-21, частично инструкции собраны в отдельном документе на диске, прилагаемом к книге.
Номенклатура названий модулей
Примеры программ из книги оформлены в виде модулей, список которых приведен ниже.
В каждом примере в книге в первой строке справа дан комментарий с именем модуля, в котором реализован данный фрагмент (иногда с указанием имени конкретной процедуры через точку).
Например, имя модуля вида ADruS192_БМ разбивается следующим образом:
ADruS192_БМ >> ADru + S192_БМ >> ADru + S + 192 + _БМ
ADru общее для всех модулей имя подсистемы в Блэкбоксе, в которой собраны примеры (в Блэкбоксе все программы организованы в подсистемы, и каждой подсистеме соответствует папка в главной папке Блэкбокса, в данном случае папка ADru).
S192_БМ имя файла в папке ADru/Mod/ (в подпапке Mod хранятся исходники модулей подсистемы), расширение у имени файла .odc, так что полное имя файла относительно главной папки Блэкбокса будет ADru\Mod\S192_БМ.odc.
Это не обычные текстовые файлы, читать их нужно в Блэкбоксе. Потому что в Оберонах реализована мощная парадигма организации пользовательских интерфейсов, называемая «текст как интерфейс».
S section = раздел.
192 соответствует номеру раздела: 1.9.2.
_БМ напоминание, что речь идет об алгоритме Бойера и Мура.
Список модулей дан ниже. В таблице для каждого модуля указана соответствующая страница книги (первого издания 2010 г.). Эта страница указана и в комментарии внутри модуля.
Оформление примеров программ из книги
В модулях добавлена вся необходимая «сантехника» для реального выполнения примеров.
Некоторые примеры оформлены в отдельных модулях, другие (например, сортировки) собраны группами в одном, т.к. используют общую «сантехнику» (одинаковые процедуры инициализации начальных данных и т.п.).
На уровне примеров в книге отличий между классическим Обероном, использованным в книге, и Компонентным Паскалем практически нет. (Может быть, только в паре мест VAR заменено на OUT для более точного описания смысла процедур.)
Фрагменты кода из книги оформлены комментариями с указанием соответствующих страниц книги (см. также таблицу далее в этом документе).
Большие фрагменты выделены комментариями такого вида:
(* фрагмент из книги, с.24: *************************************)
y := 1.0; i := n;
WHILE i > 0 DO (* x0n = xi * y *)
IF ODD(i) THEN y := y*x END;
x := x*x; i := i DIV 2
END;
(* конец фрагмента ******************************************)
Обычно фрагментам из книги что-то предшествует (заголовок модуля, глобальные объявления и т.п.).
А после фрагментов идут процедуры-драйверы, которые, собственно, и вызываются.
Команды исполнения процедур-драйверов вместе с вводимыми данными и комментариями собраны после текста модуля.
Обычно это т.наз. коммандеры (commanders) объекты вида , по которым кликают мышкой, чтобы выполнить процедуру.
Чтобы посмотреть, как это сделано, и почитать дальнейшие инструкции, кликнуть сюда:
ADruS13.
Вспомогательные модули
В книжке используется несколько вспомогательных модулей (Files, Texts, Runs, Draw).
Их реализации в данном пакете названы по описанной выше схеме, но в инструкциях импорта им присваиваются такие же имена, как и в книге, так что сами фрагменты программ из книги менять не надо:
Files := ADruS171_Files
Texts := ADruS174_Texts
Runs := ADruS242_Runs
Draw := ADruS33_Draw
Ввод-вывод
В примерах в книге обычно для вывода результатов используется глобальный объект записи (Writer).
В реализациях примеров этот глобальный объект направляет вывод в стандартный для Оберона/Блэкбокса т.наз. Рабочий журнал (Log).
Во вспомогательных процедурах также используются штатное средство Блэкбокса для вывода в Рабочий журнал модуль StdLog (обычно в сокращении Log := StdLog).
Для ввода данных в реализации примеров используется модуль i21sysIn под псевдонимом In. Модуль i21sysIn это исправленная и чуть развитая версия модуля In, поставляемого в дистрибутиве Блэкбокса. Модуль In в Блэкбоксе взят один-в-один из книги Вирта и Райзера по программированию на Обероне, и поэтому намеренно воспроизводит одну ошибку. Подробнее: выделить двойным кликом прямо здесь имя i21sysIn и вызвать команду меню Info, Документация (ее можно вызвать и через контекстное меню, открывающееся кликом правой кнопкой).
Список модулей с примерами
Чтобы открыть исходник модуля, кликнуть по его имени.
Имя модуля Страницы в книге Примечание
Глава 1.
ADruS13 инструкции! 24 возведение в степень;
ADruS14 28-29
ADruS171_Files 39-40 вспомогательный модуль Files
ADruS174 47 преобразование числа <> литеры
ADruS174_Texts 48-49 вспомогательный модуль Texts
ADruS18_Поиск 50-52
ADruS183 54 поиск в таблице
ADruS191_Простой 56-57 простой поиск слова в тексте
ADruS192_KMP 56, 60, 62 Кнут, Моррис, Пратт
ADruS193_БМ 63-64 Бойер, Мур
Глава 2. Сортировка
ADruS2_Sorts 74, 76, 78-79, 82, 87, 90, 94 сортировки массивов
ADruS242_Runs 105 вспомогательный модуль Runs
ADruS24_MergeSorts 101, 108, 112, 121, 126 сортировки последовательностей
Глава 3. Рекурсивные алгоритмы
ADruS33_Draw 138 вспомогательный модуль Draw
ADruS33_Hilbert 138 гильбертовы кривые
ADruS33_Sierpinski 141 кривые Серпиньского
ADruS34_KnightsTour 146 путешествие коня
ADruS35_Queens 151, 153 8 ферзей
ADruS36_Marriages 158 стабильные браки
ADruS37_OptSelection 163 задача об оптимальном выборе
Глава 4. Динамические структуры данных
ADruS432_List 180 списки
ADruS432_List2 180
ADruS432_List3 182
ADruS432_List4 183
ADruS433_TopSort 187, 189 топологическая сортировка
ADruS441_BalancedTree 196 сбалансированные деревья
ADruS443_Tree 201-202 двоичные деревья
ADruS443_CrossRef 204
ADruS444_Deletion 206
ADruS45_AVLtrees 214, 217 АВЛ-деревья
ADruS46_OptTree 224
ADruS471_Btrees 235
ADruS472_BBtrees 245
ADruS48_PrioritySearchTrees 249, 250
Глава 5. Хэширование
ADruS53_CrossRef 259
Для компиляции всех модулей с примерами кликнуть по вот этому черному «коммандеру»:
DevCompiler.CompileThis
ADruS174_Texts
ADruS171_Files
ADruS242_Runs
ADruS33_Draw
ADruS13
ADruS14
ADruS174
ADruS18_Поиск
ADruS183
ADruS191_Простой
ADruS192_KMP
ADruS193_БМ
ADruS2_Sorts
ADruS24_MergeSorts
ADruS33_Hilbert
ADruS33_Sierpinski
ADruS34_KnightsTour
ADruS35_Queens
ADruS36_Marriages
ADruS37_OptSelection
ADruS432_List
ADruS432_List2
ADruS432_List3
ADruS432_List4
ADruS433_TopSort
ADruS441_BalancedTree
ADruS443_Tree
ADruS443_CrossRef
ADruS444_Deletion
ADruS45_AVLtrees
ADruS46_OptTree
ADruS471_Btrees
ADruS472_BBtrees
ADruS48_PrioritySearchTrees
ADruS53_CrossRef
| ADru/Справка.odc |
ADru/Справка.odc | ADru/Docu/Sys-Map.odc |
ADruS171_Files
DEFINITION ADruS171_Files;
TYPE
File = POINTER TO RECORD END;
Rider = EXTENSIBLE RECORD
eof-: BOOLEAN
END;
PROCEDURE Close (VAR f: File);
PROCEDURE New (name: ARRAY OF CHAR): File;
PROCEDURE Old (name: ARRAY OF CHAR): File;
PROCEDURE Read (VAR r: Rider; OUT ch: CHAR);
PROCEDURE ReadInt (VAR r: Rider; OUT x: INTEGER);
PROCEDURE Set (VAR r: Rider; f: File; pos: INTEGER);
PROCEDURE Write (VAR r: Rider; ch: CHAR);
PROCEDURE WriteInt (VAR r: Rider; x: INTEGER);
END ADruS171_Files.
Эмуляция модуля Files из книжки Н.Вирта "Алгоритмы и структуры данных. Новая версия для Оберона", ДМК Пресс, 2010, переводчик Ф.В.Ткачев
| ADru/Docu/ru/S171_Files.odc |
ADruS174_Texts
DEFINITION ADruS174_Texts;
CONST
Char = 4;
Int = 1;
Name = 3;
Real = 2;
TYPE
Reader = RECORD
eot-: BOOLEAN
END;
Scanner = RECORD
class-, i-: INTEGER;
x-: REAL;
s-: ARRAY 32 OF CHAR;
ch-, nextCh-: CHAR
END;
Text = RECORD END;
Writer = RECORD END;
VAR
log: Text;
PROCEDURE Close (VAR w: Writer);
PROCEDURE Length (t: Text): INTEGER;
PROCEDURE OpenReader (VAR r: Reader; t: Text; pos: INTEGER);
PROCEDURE OpenScanner (VAR s: Scanner; t: Text; pos: INTEGER);
PROCEDURE OpenWriter (VAR w: Writer; t: Text; pos: INTEGER);
PROCEDURE Read (VAR r: Reader; VAR ch: CHAR);
PROCEDURE Scan (VAR s: Scanner);
PROCEDURE Write (VAR w: Writer; ch: CHAR);
PROCEDURE WriteInt (VAR w: Writer; x, n: INTEGER);
PROCEDURE WriteLn (VAR w: Writer);
PROCEDURE WriteReal (VAR w: Writer; x: REAL);
PROCEDURE WriteString (VAR w: Writer; s: ARRAY OF CHAR);
END ADruS174_Texts.
Эмуляция модуля Files из книжки Н.Вирта "Алгоритмы и структуры данных. Новая версия для Оберона", ДМК Пресс, 2010, переводчик Ф.В.Ткачев
Для удобства использования в Блэкбоксе добавлены:
VAR log: Text;
запись в этот текст приводит к записи в Рабочий журнал (Log).
PROCEDURE Length( t: Text ): INTEGER;
Смысл функции очевиден.
С ее помощью можно писать в конец Рабочего журнала, например:
ADruTexts.OpenWriter( w, ADruTexts.log, ADruTexts.Length( ADruTexts.log ) ); | ADru/Docu/ru/S174_Texts.odc |
ADruS242_Runs
DEFINITION ADruS242_Runs;
IMPORT ADruS174_Texts, ADruS171_Files;
TYPE
Rider = RECORD (ADruS171_Files.Rider)
(* ADruS171_Files.Rider *) eof-: BOOLEAN;
first-: INTEGER;
eor-: BOOLEAN
END;
PROCEDURE ListSeq (VAR W: ADruS174_Texts.Writer; f: ADruS171_Files.File);
PROCEDURE LogSeq (f: ADruS171_Files.File);
PROCEDURE OpenRandomSeq (f: ADruS171_Files.File; length, seed: INTEGER);
PROCEDURE Set (VAR r: Rider; f: ADruS171_Files.File);
PROCEDURE copy (VAR src, dest: Rider);
END ADruS242_Runs.
Эмуляция модуля Runs из книжки Н.Вирта "Алгоритмы и структуры данных. Новая версия для Оберона", ДМК Пресс, 2010, переводчик Ф.В.Ткачев
| ADru/Docu/ru/S242_Runs.odc |
ADruS33_Draw
DEFINITION ADruS33_Draw;
CONST
height = 512;
width = 512;
PROCEDURE Clear;
PROCEDURE NextThick;
PROCEDURE SetPen (x, y: INTEGER);
PROCEDURE Test;
PROCEDURE line (dir, len: INTEGER);
END ADruS33_Draw.
Эмуляция модуля Draw из книжки Н.Вирта "Алгоритмы и структуры данных. Новая версия для Оберона", ДМК Пресс, 2010, переводчик Ф.В.Ткачев
| ADru/Docu/ru/S33_Draw.odc |
ADru/Справка.odc | ADru/Docu/ru/Sys-Map.odc |
(* Общие сведения о примерах: Справка *)
(* Исправления и подготовка примеров: (С) Ф.В.Ткачев, 2009, info21 AT inr.ac.ru *)
(* В таких скобках со звездочками -- комментарии, они могут быть (*вложены,*) компилятор их игнорирует. Цвет компилятору не важен. Этим цветом оформляем комментарии и инструкции ASSERT, которые похожи на комментарии, ибо сообщают о предусловиях, инвариантах и т.п.
Первая инструкция исходника модуля его заголовок начинается ниже с ключевого слова MODULE, после которого стоит имя модуля.
Завершается модуль строкой со словом END, после которого повторяется это имя.
О вызове программ -- см. после текста модуля. *)
MODULE ADruS13; (* Примеры из раздела 1.3. *)
(* Соответствующий программный фрагмент в книге отмечен комментарием с именем модуля в первой строке примера справа, в данном случае такой комментарий имеет вид (* ADruS13 *).
В книге для краткости опущена «сантехника», необходимая для полноценной работы примеров.
В частности, нужна инструкция импорта, позволяющая использовать средства, экспортированные из других, в данном случае вывод в рабочий журал (Log) и ввод из текста: *)
IMPORT Log := StdLog, In := i21sysIn; (* можно вводить сокращения имен *)
PROCEDURE Power*; (* возведение в степень из раздела 1.3.2 *)
VAR x0, x, y: REAL; i, n: INTEGER;
BEGIN
(* ввод данных из входного потока (стоят после коммандера, см. в конце документа) *)
In.Open; ASSERT( In.done );
In.Real( x0 ); ASSERT( In.done );
In.Int( n ); ASSERT( In.done & ( n >= 0 ) );
x := x0;
(* фрагмент из книги, с.24: *************************************)
y := 1.0; i := n;
WHILE i > 0 DO (* x0n = xi * y *)
IF ODD(i) THEN y := y*x END;
x := x*x; i := i DIV 2
END;
(* конец фрагмента *******************************************)
(* вывод данных в рабочий журнал *)
Log.Real( x0 ); Log.Int( n ); Log.Real( y ); Log.Ln;
END Power;
END ADruS13. << Эта точка завершает текст модуля.
Все, что стоит дальше, компилятор игнорирует, здесь «чулан».
Поэтому не нужно ничего оформлять комментариями.
И это всё могло бы храниться в другом документе.
Для выполнения процедуры Power кликнуть по черному «коммандеру» (Commander), результат будет виден в «рабочем журнале» (окошко Log; чтобы открыть, выполнить команду меню Info, Open Log) :
ADruS13.Power -3.12914 5
Числа после имени процедуры «поток ввода», его читают инструкции, начинающиеся с In. In.Open и т.д.
Второе число должно быть целым, без точки, т.к. процедура In.Int умеет читать только целые числа. (Однако есть и средства сканировать ввод и определять, что там стоит.)
Поток ввода служит функциональной заменой ввода данных с командной строки но у нас здесь всё гораздо удобней (см. о мощной парадигме «текст как интерфейс»).
Черный треугольничек после чисел ограничивает поток ввода, если поток не выделен мышкой.
Коммандер вставляется с помощью Ctrl+Q, треугольничек с помощью Ctrl+Shift+Q.
Для изменения входных данных нужно обычным образом поменять числа при новом клике по коммандеру прочтутся новые данные.
Можно указать вводимые данные, выделяя их мышкой: например, можно выделить мышкой любую пару ниже (или написать свои) и кликать по тому же коммандеру:
2 8
3.1415 7
Коммандеров можно иметь в тексте сколько угодно, хоть целое меню кликать можно по любому, будет вызвана соответствующая команда-процедура.
Входных данных тоже можно иметь в тексте сколько угодно, самых разных.
А еще можно печатать в Log и брать данные оттуда (обычным копированием) и снова использовать их в качестве ввода для других команд. Очень удобно и производительно.
| ADru/Mod/S13.odc |
(* Общие сведения о примерах: Справка *)
(* Исправления и подготовка примеров: (С) Ф.В.Ткачев, 2009, info21 AT inr.ac.ru *)
MODULE ADruS14; (* Примеры из раздела 1.4. *)
IMPORT Log := StdLog, In := i21sysIn, Texts := ADruS174_Texts;
PROCEDURE For*;
CONST N = 100;
VAR a: ARRAY N OF INTEGER;
sum, max, i, k: INTEGER;
BEGIN
FOR i := 0 TO N - 1 DO
a[ i ] := 10*i - i*i
END;
(* фрагмент из книги, с.28: ************************************)
sum := 0;
FOR i := 0 TO N-1 DO sum := a[i] + sum END;
k := 0; max := a[0];
FOR i := 1 TO N-1 DO
IF max < a[i] THEN k := i; max := a[k] END;
END;
(* конец фрагмента ******************************************)
(* вывод в рабочий журнал: *)
Log.Int( sum ); Log.Ln;
Log.Int( k ); Log.Int( max ); Log.Ln;
END For;
(* коммандер для выполнения команды можно вставить прямо в тексте программы, заключив его в комментарий: ADruS14.For *)
(* фрагмент из книги, с.29: *************************************)
PROCEDURE Power ( VAR W: Texts.Writer; N: INTEGER );
(* вычислить десятичное представление отрицательных степеней числа 2 *)
VAR i, k, r: INTEGER;
d: POINTER TO ARRAY OF INTEGER;
BEGIN
NEW( d, N );
FOR k := 0 TO N-1 DO
Texts.Write(W, "."); r := 0;
FOR i := 0 TO k-1 DO
r := 10*r + d[i]; d[i] := r DIV 2; r := r MOD 2;
Texts.Write(W, CHR(d[i] + ORD("0")))
END;
d[k] := 5; Texts.Write(W, "5"); Texts.WriteLn(W)
END
END Power;
(* конец фрагмента *******************************************)
PROCEDURE DoPower*; (* управляющая процедура для Power *)
VAR w: Texts.Writer; N: INTEGER;
BEGIN
(* ввод N: *)
In.Open; In.Int( N ); ASSERT( In.done & ( N > 0 ) );
(* подготовка w к печати в рабочий журнал (Log): *)
Texts.OpenWriter( w, Texts.log, Texts.Length( Texts.log ) );
Power( w, N );
END DoPower;
END ADruS14.
ADruS14.For
ADruS14.DoPower 10 | ADru/Mod/S14.odc |
(* Общие сведения о примерах: Справка *)
(* Исправления и подготовка примеров: (С) Ф.В.Ткачев, 2009, info21 AT inr.ac.ru *)
MODULE ADruS171_Files; (* Реализация модуля Files, сс. 39, 40. *)
IMPORT SYSTEM, Log := StdLog;
CONST MaxLength = 4096;
TYPE
File* = POINTER TO RECORD
len: INTEGER;
a: ARRAY MaxLength OF CHAR
END;
Rider* = EXTENSIBLE RECORD (* 0 <= pos <= f.len <= MaxLength *)
f: File;
pos: INTEGER;
eof-: BOOLEAN
END;
PROCEDURE New* ( name: ARRAY OF CHAR ): File;
VAR f: File;
BEGIN NEW(f); f.len := 0; RETURN f
END New;
PROCEDURE Old* ( name: ARRAY OF CHAR ): File;
VAR f: File;
BEGIN HALT( 126 ); RETURN f
END Old;
PROCEDURE Close* ( VAR f: File );
BEGIN
END Close;
PROCEDURE Set* ( VAR r: Rider; f: File; pos: INTEGER );
BEGIN
ASSERT( f # NIL );
r.f := f; r.eof := FALSE;
IF r.pos < 0 THEN
r.pos := 0
ELSIF pos > f.len THEN
r.pos := f.len
ELSE
r.pos := pos
END
END Set;
PROCEDURE Write* ( VAR r: Rider; ch: CHAR );
BEGIN
ASSERT( r.pos <= r.f.len );
IF r.pos < MaxLength THEN
r.f.a[ r.pos ] := ch; INC( r.pos );
IF r.pos > r.f.len THEN INC( r.f.len ) END
ELSE
r.eof := TRUE
END
END Write;
PROCEDURE Read* ( VAR r: Rider; OUT ch: CHAR );
BEGIN
IF r.pos < r.f.len THEN ch := r.f.a[ r.pos ]; INC( r.pos ) ELSE r.eof := TRUE END
END Read;
(* следующие две процедуры отсутствуют в английском "исходнике" книги;
они используются в сортировках слиянием: *)
PROCEDURE WriteInt* ( VAR r: Rider; x: INTEGER );
VAR u: RECORD [union]
x: INTEGER;
a: ARRAY 2 OF CHAR;
END;
BEGIN
u.x := x;
Write( r, u.a[ 0 ] );
Write( r, u.a[ 1 ] );
END WriteInt;
PROCEDURE ReadInt* ( VAR r: Rider; OUT x: INTEGER );
VAR u: RECORD [union]
x: INTEGER;
a: ARRAY 2 OF CHAR;
END;
BEGIN
Read( r, u.a[ 0 ] );
Read( r, u.a[ 1 ] );
x := u.x;
END ReadInt;
PROCEDURE Base* ( VAR r: Rider ): File;
BEGIN
RETURN r.f
END Base;
END ADruS171_Files.
ADruS171_FilesTest.Do
| ADru/Mod/S171_Files.odc |
(* Общие сведения о примерах: Справка *)
(* Исправления и подготовка примеров: (С) Ф.В.Ткачев, 2009, info21 AT inr.ac.ru *)
MODULE ADruS174; (* Примеры из раздела 1.7.4. *)
IMPORT Log := StdLog, In := i21sysIn, Texts := ADruS174_Texts;
PROCEDURE Read ( OUT ch: CHAR );
BEGIN
In.Char( ch ); ASSERT( In.done );
END Read;
PROCEDURE Write ( ch: CHAR );
BEGIN Log.Char( ch );
END Write;
(* преобразование литер в число из разд. 1.7.4: *)
PROCEDURE ЛитерыВЧисло*;
VAR x: INTEGER; ch: CHAR;
BEGIN
(* приготовление ввода: *)
In.Open; ASSERT( In.done ); Read( ch ); ASSERT( In.done );
(* фрагмент из книги, с. 47: ************************************)
x := 0; Read( ch );
WHILE ("0" <= ch) & (ch <= "9") DO
x := 10*x + (ORD(ch) - ORD("0")); Read(ch)
END;
(* конец фрагмента ******************************************)
(* проверяем печатью в рабочий журнал: *)
Log.Int( x ); Log.Ln;
END ЛитерыВЧисло;
(* преобразование числа в литеры из разд. 1.7.4: *)
PROCEDURE ЧислоВЛитеры*;
VAR x, i: INTEGER; d: ARRAY 11 OF INTEGER;
BEGIN
(* ввод числа: *)
In.Open; ASSERT( In.done ); In.Int( x ); ASSERT( In.done & ( x >= 0 ));
(* фрагмент из книги, с. 47: ************************************)
i := 0;
REPEAT d[i] := x MOD 10; x := x DIV 10; INC( i )
UNTIL x = 0;
REPEAT DEC( i ); Write( CHR( d[ i ] + ORD("0") ) )
UNTIL i = 0;
(* конец фрагмента ******************************************)
Log.Ln;
END ЧислоВЛитеры;
END ADruS174.
ADruS174.ЛитерыВЧисло 12345
ADruS174.ЧислоВЛитеры 2345
Для изменения входных данных поменять числа после команд (или выделить число мышкой) -- при клике прочтутся новые данные.
Число здесь должно быть целым, без точки.
| ADru/Mod/S174.odc |
(* Общие сведения о примерах: Справка *)
(* Исправления и подготовка примеров: (С) Ф.В.Ткачев, 2009, info21 AT inr.ac.ru *)
MODULE ADruS174_Texts; (* Эмуляция модуля Texts.
Копия интерфейса, данного в книге, сc. 48-49:
DEFINITION Texts;
CONST Int = 1; Real = 2; Name = 3; Char = 4;
TYPE Text, Writer;
Reader = RECORD eot: BOOLEAN END;
Scanner = RECORD class: INTEGER;
i: INTEGER;
x: REAL;
s: ARRAY 32 OF CHAR;
ch: CHAR;
nextCh: CHAR
END;
PROCEDURE OpenReader(VAR r: Reader; t: Text; pos: INTEGER);
PROCEDURE OpenWriter(VAR w: Writer; t: Text; pos: INTEGER);
PROCEDURE OpenScanner(VAR s: Scanner; t: Text; pos: INTEGER);
PROCEDURE Read(VAR r: Reader; VAR ch: CHAR);
PROCEDURE Scan(VAR s: Scanner);
PROCEDURE Write(VAR w: Writer; ch: CHAR);
PROCEDURE WriteLn(VAR w: Writer); (*завершить строку*)
PROCEDURE WriteString(VAR w: Writer; s: ARRAY OF CHAR);
PROCEDURE WriteInt(VAR w: Writer; x, n: INTEGER);
(*вывести целое x с (по крайней мере) n литерами.
Если n больше, чем необходимое число цифр,
перед числом добавляются пробелы*)
PROCEDURE WriteReal(VAR w: Writer; x: REAL);
PROCEDURE Close(VAR w: Writer);
END Texts.
*)
IMPORT Log := StdLog, In := i21sysIn,
TextModels, TextViews, TextMappers, TextControllers, C := DevCommanders;
CONST Int* = 1; Real* = 2; Name* = 3; Char* = 4; Eot* = 5;
TYPE
Text* = RECORD
t: TextModels.Model
END;
Writer* = RECORD
fm: TextMappers.Formatter
END;
Reader* = RECORD
eot-: BOOLEAN;
rd: TextModels.Reader;
END;
Scanner* = RECORD
class-: INTEGER;
i-: INTEGER;
x-: REAL;
s-: ARRAY 32 OF CHAR;
ch-: CHAR;
nextCh-: CHAR;
sc: TextMappers.Scanner;
END;
VAR log*, input*: Text;
PROCEDURE OpenText ( VAR text: Text; t: TextModels.Model ); (* добавлено для удобства *)
BEGIN
text.t := t
END OpenText;
PROCEDURE OpenInput*; (* POST: input = поток ввода по правилам модуля i21sysIn *)
VAR c: TextControllers.Controller; beg, end: INTEGER; t: TextModels.Model;
BEGIN
t := TextModels.dir.New();
c := TextControllers.Focus();
IF ( c # NIL ) & c.HasSelection() THEN
c.GetSelection( beg, end );
t.InsertCopy( 0, c.text, beg, end )
ELSIF C.par # NIL THEN
t.InsertCopy( 0, C.par.text, C.par.beg, C.par.end )
ELSIF c # NIL THEN
t := c.text
ELSE
t := NIL
END;
ASSERT( t # NIL );
OpenText( input, t )
END OpenInput;
PROCEDURE Length* ( t: Text ): INTEGER; (* добавлено для удобства записи в конец Log'а *)
BEGIN RETURN t.t.Length()
END Length;
PROCEDURE ShowEnd* ( t: Text ); (* добавлено для удобства показа конца текста --info21 *)
BEGIN
TextViews.ShowRange( t.t, t.t.Length(), t.t.Length(), TextViews.any );
END ShowEnd;
PROCEDURE OpenReader* ( VAR r: Reader; t: Text; pos: INTEGER);
VAR
BEGIN
r.rd := t.t.NewReader( NIL );
r.rd.SetPos( pos );
r.eot := r.rd.eot;
END OpenReader;
PROCEDURE Read* ( VAR r: Reader; OUT ch: CHAR );
VAR
BEGIN
r.rd.ReadChar( ch );
r.eot := r.rd.eot;
END Read;
PROCEDURE OpenScanner* ( VAR s: Scanner; t: Text; pos: INTEGER );
VAR
BEGIN
ASSERT( t.t # NIL );
s.sc.ConnectTo( t.t );
s.sc.SetPos( pos );
s.sc.SetOpts( {} );
END OpenScanner;
PROCEDURE Scan* ( VAR s: Scanner );
VAR pos: INTEGER; c: CHAR;
BEGIN
s.sc.Scan;
IF s.sc.type = TextMappers.int THEN
s.class := Int;
s.i := s.sc.int;
ELSIF s.sc.type = TextMappers.real THEN
s.class := Real;
s.x := s.sc.real;
ELSIF s.sc.type = TextMappers.string THEN
s.class := Name;
ASSERT( LEN( s.sc.string$ ) < 32 );
s.s := s.sc.string$;
ELSIF s.sc.type = TextMappers.char THEN
s.class := Char;
s.ch := s.sc.char;
ELSIF s.sc.type = TextMappers.eot THEN
s.class := Eot;
s.ch := s.sc.char;
ELSE
HALT( 126 );
END;
pos := s.sc.rider.Pos();
s.sc.rider.ReadChar( c );
s.nextCh := c;
s.sc.SetPos( pos );
END Scan;
PROCEDURE ReadInt* ( VAR r: Reader; OUT n: INTEGER ); (* часто используется *)
VAR t: Text; s: Scanner;
BEGIN
OpenText( t, r.rd.Base() );
OpenScanner( s, t, r.rd.Pos() );
Scan( s );
ASSERT( s.class = Int );
n := s.i;
r.eot := r.rd.eot;
r.rd.SetPos( s.sc.rider.Pos() );
END ReadInt;
PROCEDURE OpenWriter* ( VAR w: Writer; t: Text; pos: INTEGER );
VAR
BEGIN
w.fm.ConnectTo( t.t );
w.fm.SetPos( pos );
END OpenWriter;
PROCEDURE Write* ( VAR w: Writer; ch: CHAR );
VAR
BEGIN
w.fm.WriteChar( ch );
END Write;
PROCEDURE WriteLn* ( VAR w: Writer ); (*завершить строку*)
VAR
BEGIN
w.fm.WriteLn;
END WriteLn;
PROCEDURE WriteTab* ( VAR w: Writer );
VAR
BEGIN
w.fm.WriteTab;
END WriteTab;
PROCEDURE WriteString* ( VAR w: Writer; s: ARRAY OF CHAR );
VAR
BEGIN
w.fm.WriteString( s );
END WriteString;
PROCEDURE WriteInt* ( VAR w: Writer; x, n: INTEGER );
(*вывести целое x с (по крайней мере) n литерами.
Если n больше, чем необходимое число цифр,
перед числом добавляются пробелы*)
VAR
BEGIN
w.fm.WriteIntForm( x, 10, n, ' ', FALSE );
END WriteInt;
PROCEDURE WriteReal* ( VAR w: Writer; x: REAL );
VAR
BEGIN
w.fm.WriteReal( x );
END WriteReal;
PROCEDURE Close* ( VAR w: Writer );
VAR
BEGIN
w.fm.ConnectTo( NIL );
END Close;
BEGIN
log.t := Log.text;
END ADruS174_Texts.
| ADru/Mod/S174_Texts.odc |
(* Общие сведения о примерах: Справка *)
(* Исправления и подготовка примеров: (С) Ф.В.Ткачев, 2009, info21 AT inr.ac.ru *)
MODULE ADruS183;
(* К разделу 1.8.3 о поиске в таблице. *)
IMPORT Log := StdLog, In := i21sysIn, Math;
PROCEDURE Делать*;
CONST M = 100; N = 10;
TYPE String = ARRAY M OF CHAR;
VAR
T: ARRAY N OF String;
x: String;
VAR i, L, R, m: INTEGER;
BEGIN
(*ввод аргумента поиска и таблицы: *)
In.Open; ASSERT( In.done );
In.String( x ); ASSERT( In.done );
FOR i := 0 TO N-1 DO In.String( T[i] ); ASSERT( In.done ) END;
(* фрагмент из книги, с. 54: ************************************)
L := 0; R := N;
WHILE L < R DO
m := (L+R) DIV 2;
i := 0;
WHILE ( x[i] # 0X ) & ( T[m, i] = x[i] ) DO i := i+1 END;
IF T[m, i] < x[i] THEN L := m+1 ELSE R := m END
END;
IF R < N THEN
i := 0;
WHILE ( x[i] # 0X ) & ( T[R, i] = x[i] ) DO i := i+1 END
END;
(* ( R < N ) & ( T[R,i] = x[i] ) устанавливает совпадение *)
(* конец фрагмента ******************************************)
Log.Int( R ); Log.Tab; Log.String( T[R] ); Log.Ln;
END Делать;
END ADruS183.
можно менять аргумент поиска (искомое значени; это первая вводимая цепочка литер, стоящая в строке командира) и снова кликать:
ADruS183.Делать "Единая"
"Оберон"
""
"замечательный язык"
"программирования"
"."
" "
"Единая"
"система"
"вводных"
"курсов"
"информатики"
"на основе"
"Оберонов."
| ADru/Mod/S183.odc |
(* Общие сведения о примерах: Справка *)
(* Исправления и подготовка примеров: (С) Ф.В.Ткачев, 2009, info21 AT inr.ac.ru *)
MODULE ADruS18_Поиск; (* Иллюстрация алгоритмов поиска, раздел 1.8. *)
IMPORT Log := StdLog, In := i21sysIn, R := ObxRandom;
PROCEDURE InitRandom ( OUT a: ARRAY OF INTEGER ); (* инициализация массива случайными числами *)
VAR i: INTEGER;
BEGIN
R.InitSeed( 12345 );
FOR i := 0 TO LEN( a ) - 1 DO
a[ i ] := 1 + SHORT( ENTIER( ( LEN( a ) )* R.Uniform() ) );
ASSERT( a[ i ] > 0 ); (* гарантируем инициализацию только положительными числами *)
END;
END InitRandom;
PROCEDURE InitSorted ( OUT a: ARRAY OF INTEGER ); (* инициализация массива упорядоченными числами *)
VAR i: INTEGER;
BEGIN
FOR i := 0 TO LEN( a ) - 1 DO
a[ i ] := 1 + i ;
ASSERT( a[ i ] > 0 ); (* гарантируем инициализацию только положительными числами *)
END;
END InitSorted;
PROCEDURE Линейный*; (* несколько программных фрагментов из раздела 1.8.1 *)
VAR
a: POINTER TO ARRAY OF INTEGER; (* указатель на массив, в котором поиск *)
N: INTEGER; (* кол-во элементов, среди которых ищем *)
x: INTEGER; (* искомое значение или "аргумент поиска" *)
i: INTEGER;
a1, a2, a3, a4: POINTER TO ARRAY OF INTEGER;
BEGIN
Log.Ln;
Log.String('Проверяем примеры линейного поиска:'); Log.Ln;
N := 10;
x := 0; (* в примерах будем всегда искать значение нуль *)
(* в каждом примере размещаем новый массив а, но запоминаем указатель на него, чтобы иметь возможность заглянуть в содержимое массивов в конце*)
(* Простейший линейный поиск *)
(* Пример 1. Искомое значение присутствует в массиве *)
NEW( a, N );
a1 := a; (* запомнили указатель, чтобы в конце посмотреть на массив *)
InitRandom( a );
a[ 5 ] := 0;
a[ 8 ] := 0; (* помещаем дважды, найдется первое вхождение *)
(* собственно поиск, фрагмент из книги, с. 50: ****************)
i := 0;
WHILE ( i < N ) & ( a[ i ] # x ) DO INC( i ) END;
(* конец фрагмента. ************************************)
ASSERT( i = 5 ); (* нашли наименьшую позицию *)
Log.String('Выполнен пример 1.'); Log.Ln;
(* Пример 2. Искомого значения в массиве нет *)
NEW( a, N );
a2 := a; (* запомнили указатель, чтобы в конце посмотреть на массив *)
InitRandom( a );
i := 0;
WHILE ( i < N ) & ( a[ i ] # x ) DO INC( i ) END;
ASSERT( i = N ); (* не нашли *)
Log.String('Выполнен пример 2.'); Log.Ln;
(* Линейный поиск с барьером *)
(* Пример 3. Искомое значение присутствует в массиве *)
NEW( a, N + 1 ); (* нужен один лишний элемент для барьера *)
a3 := a; (* запомнили указатель, чтобы в конце посмотреть на массив *)
InitRandom( a );
a[ 5 ] := 0;
a[ N ] := 0; (* выставили барьер *)
i := 0;
WHILE a[ i ] # x DO INC( i ) END;
ASSERT( i = 5 ); (* нашли наименьшую позицию *)
Log.String('Выполнен пример 3.'); Log.Ln;
(* Пример 4. Искомого значения в массиве нет *)
NEW( a, N + 1 ); (* нужен один лишний элемент для барьера *)
a4 := a; (* запомнили указатель, чтобы в конце посмотреть на массив *)
InitRandom( a ); (* в массиве только положит. числа *)
(* фрагмент из книги, с. 51, вверху: *******************************)
a[ N ] := x; i := 0;
WHILE a[ i ] # x DO INC( i ) END;
(* конец фрагмента *******************************************)
ASSERT( i = N ); (* нашли только сам барьер *)
Log.String('Выполнен пример 4.'); Log.Ln;
a := NIL;
HALT( 0 ); (* чтобы заглянуть в содержимое всех 4х массивов, кликать по синим ромбам и черным стрелочкам в окошке Трапа *)
END Линейный;
PROCEDURE ДелениемПополам*; (* к разделу 1.8.2 *)
VAR
a: POINTER TO ARRAY OF INTEGER; (* указатель на массив, в которых поиск *)
N: INTEGER; (* кол-во элементов, среди которых ищем *)
n: INTEGER; (* позиция искомого значения *)
x: INTEGER; (* искомое значение или "аргумент поиска" *)
L, R, m: INTEGER;
found: BOOLEAN;
BEGIN
Log.Ln;
Log.String('Проверяем поиск делением пополам:'); Log.Ln;
N := 100000;
n := ( 3 * N ) DIV 4;
(* Пример 1. В массиве нет искомого значения *)
NEW( a, N );
InitSorted( a ); (* возрастающие положительные *)
x := 0;
(* фрагмент из книги, с. 51 внизу: ******************************)
L := 0; R := N - 1; found := FALSE;
WHILE ( L <= R ) & ~found DO
m := ( L + R ) DIV 2; (* любое значение между L и R *)
IF a[ m ] = x THEN
found := TRUE
ELSIF a[ m ] < x THEN
L := m + 1
ELSE
R := m - 1
END
END;
(* конец фрагмента ******************************************)
ASSERT( ~found ); (* не нашли *)
Log.String('Выполнен пример 1.'); Log.Ln;
(* Пример 2. В массиве ровно одно искомое значение *)
NEW( a, N );
InitSorted( a ); (* возрастающие положительные *)
x := a[ n ]; (* искомое значение в массиве *)
L := 0; R := N - 1; found := FALSE;
WHILE ( L <= R ) & ~found DO
m := ( L + R ) DIV 2; (* любое значение между L и R *)
IF a[ m ] = x THEN
found := TRUE
ELSIF a[ m ] < x THEN
L := m + 1
ELSE
R := m - 1
END
END;
ASSERT( m = n ); (* т.е. успешно нашли позицию значения x *)
Log.String('Выполнен пример 2.'); Log.Ln;
(* Пример 3. В массиве искомое значение в нескольких экземплярах *)
NEW( a, N );
InitSorted( a ); (* возрастающие положительные *)
x := a[ n ]; (* искомое значение в массиве *)
a[ n+1 ] := x; (* чтобы усложнить жизнь *)
a[ n-1 ] := x; (* чтобы усложнить жизнь *)
L := 0; R := N - 1; found := FALSE;
WHILE ( L <= R ) & ~found DO
m := ( L + R ) DIV 2; (* любое значение между L и R *)
IF a[ m ] = x THEN
found := TRUE
ELSIF a[ m ] < x THEN
L := m + 1
ELSE
R := m - 1
END
END;
ASSERT( ( m = n ) OR ( m = n-1 ) OR ( m = n+1) ); (* т.е. успешно нашли позицию значения x *)
Log.Int( n ); Log.Int( m ); Log.Ln;
Log.String('Выполнен пример 3.'); Log.Ln;
(* Пример 4. Немного ускоренный вариант, с. 52 *)
NEW( a, N );
InitSorted( a ); (* возрастающие положительные *)
x := a[ n ]; (* искомое значение в массиве *)
(* фрагмент из книги, с. 52 внизу: *********************************)
L := 0; R := N;
WHILE L < R DO
m := (L+R) DIV 2;
IF a[m] < x THEN L := m+1 ELSE R := m END
END;
(* конец фрагмента ********************************************)
ASSERT( ( L = n ) OR ( L = n+1) );
Log.Int( n ); Log.Int( L ); Log.Ln;
Log.String('Выполнен пример 4.'); Log.Ln;
END ДелениемПополам;
END ADruS18_Поиск.
ADruS18_Поиск.Линейный При выполнении выскочит окошко Trap из-за вставленной в конце процедуры команды HALT(0). Это чтобы можно было заглянуть в содержимое всех 4х массивов, для чего кликать по синим ромбам и черным стрелочкам в окошке Трапа.
Закрывается окошко Трапа обычным способом, и можно продолжать:
ADruS18_Поиск.ДелениемПополам
| ADru/Mod/S18_Поиск.odc |
(* Общие сведения о примерах: Справка *)
(* Исправления и подготовка примеров: (С) Ф.В.Ткачев, 2009, info21 AT inr.ac.ru *)
MODULE ADruS191_Простой;
(* Поиск в тексте. Простой алгоритм, раздел 1.9.1. *)
IMPORT Log := StdLog, In := i21sysIn;
CONST Mmax = 1000;
(* для упрощения примеров данные реализованы в глобальных переменных: *)
VAR p, s: ARRAY Mmax OF CHAR; M, N: INTEGER;
(* реализация предикатов, определенных в тексте: *)
PROCEDURE R ( i: INTEGER ): BOOLEAN; (*** с. 56 ***)
VAR j: INTEGER;
BEGIN
(* 0 <= i < N *)
j := 0;
WHILE (j < M) & (p[j] = s[i+j]) DO INC(j) END;
RETURN ~(j < M)
END R;
PROCEDURE Q ( i: INTEGER ): BOOLEAN;
VAR k: INTEGER;
BEGIN
k := 0;
WHILE ( k < i ) & ~R( k ) DO INC( k ) END;
RETURN ~( k < i )
END Q;
PROCEDURE P ( i, j: INTEGER ): BOOLEAN;
VAR k: INTEGER;
BEGIN
k := 0;
WHILE ( k < j ) & ( s[ i+k ] = p[ k ] ) DO INC( k ) END;
RETURN ~( k < j )
END P;
(* Ниже в двух процедурах реализованы оба варианта простого поиска из раздела 1.9.1:
1) простейший -- в виде линейного поиска с использованием предиката R;
2) через цикл Дейкстры (см. в книге Приложение С).
Переменные p, s, M, N определены как глобальные, чтобы предикаты выглядели попроще, как в книге *)
PROCEDURE Простейший* ( OUT r: INTEGER );
(* Поиск образца p длины M в тексте s длины N; M <= Mmax.
Если p найден, то r указывает его позицию в s, иначе r = -1.
Все данные определены как глобальные переменные в начале модуля. *)
VAR i: INTEGER;
BEGIN
(* фрагмент из книги, с. 56: ***********************************)
i := 0;
WHILE (i <= N-M) & ~R(i) DO INC(i) END;
(* конец фрагмента *****************************************)
IF i <= N-M THEN
r := i
ELSE
r := -1
END;
END Простейший;
PROCEDURE ПоДейкстре* ( OUT r: INTEGER );
(* То же, что Простейший, но реализация с помощью цикла Дейкстры;
см. в книге Приложение С.
*)
VAR i, j: INTEGER;
BEGIN
(* фрагмент из книги, с. 57; в целях иллюстрации красным вставлены проверки инварианта цикла в начале и конце каждой ветви: ***************)
i := 0; j := 0;
ASSERT( P(i,j) );
LOOP IF (i <= N-M) & (j < M) & (s[i+j] = p[j]) THEN (* о цикле Дейкстры см. Приложение С *)
ASSERT( P(i,j) );
INC( j );
ASSERT( P(i,j) );
ELSIF (i <= N-M) & (j < M) THEN
ASSERT( P(i,j) );
INC( i ); j := 0;
ASSERT( P(i,j) );
ELSE EXIT END END;
ASSERT( P(i,j) );
(* конец фрагмента ********************************************)
(* обработка окончания цикла *)
IF i <= N-M THEN
r := i
ELSE
r := -1
END;
END ПоДейкстре;
PROCEDURE Проверить*;
VAR r0, r1: INTEGER;
BEGIN
In.Open; ASSERT( In.done );
In.String( s ); ASSERT( In.done );
N := LEN( s$ );
In.String( p ); ASSERT( In.done );
M := LEN( p$ );
Простейший ( r0 );
ПоДейкстре ( r1 );
ASSERT( r0 = r1 );
Log.Int( r0 ); Log.Ln;
END Проверить;
END ADruS191_Простой.
ADruS191_Простой.Проверить "Hoola-Hoola girls like Hooligans." "Hooligan"
"Hoola-Hoola girls like Hooligans." "Hooligan"
или можно выделить любую строчку и кликнуть по командиру:
"Hoola-Hoola girls like Hooligans." "H"
"Hoola-Hoola girls like Hooligans." "o"
"Hoola-Hoola girls like Hooligans." "gi"
"Hoola-Hoola girls like Hooligans." "ns."
"Hoola-Hoola girls like Hooligans." "ooo"
"baaab" "abab"
aahaahaa ahaah
| ADru/Mod/S191_Простой.odc |
(* Общие сведения о примерах: Справка *)
(* Исправления и подготовка примеров: (С) Ф.В.Ткачев, 2009, info21 AT inr.ac.ru *)
MODULE ADruS192_KMP;
(* Поиск в тексте. Алгоритм Кнута, Морриса и Пратта, раздел 1.9.2. *)
IMPORT Log := StdLog, In := i21sysIn, Math;
CONST Mmax = 10; Nmax = 1000;
VAR
s: ARRAY Nmax OF CHAR; N: INTEGER;
p: ARRAY Mmax OF CHAR; M: INTEGER;
(* реализация предикатов, определенных в тексте: *)
PROCEDURE R ( i: INTEGER ): BOOLEAN; (*** с. 56 ***)
VAR j: INTEGER;
BEGIN
(* 0 <= i < N *)
j := 0;
WHILE (j < M) & (p[j] = s[i+j]) DO INC(j) END;
RETURN ~(j < M)
END R;
PROCEDURE Q ( i: INTEGER ): BOOLEAN;
VAR k: INTEGER;
BEGIN
k := 0;
WHILE ( k < i ) & ~R( k ) DO INC( k ) END;
RETURN ~( k < i )
END Q;
PROCEDURE P ( i, j: INTEGER ): BOOLEAN;
VAR k: INTEGER;
BEGIN
k := 0;
WHILE ( k < j ) & ( s[ i+k ] = p[ k ] ) DO INC( k ) END;
RETURN ~( k < j )
END P;
PROCEDURE УрВыполняется ( j, D: INTEGER ): BOOLEAN;
(* проверка выполнения уравнения сc. 60, 62 *)
VAR k: INTEGER;
BEGIN
ASSERT( ( j >= 0 ) & ( D >= 0 ), 20 );
k := 0;
WHILE ( k < D ) & ( p[k] = p[j-D+k] ) DO
INC( k )
END;
RETURN ( D = 0 ) OR ( k = D )
END УрВыполняется;
PROCEDURE D ( j: INTEGER ): INTEGER;
(* прямое вычисление величины D, используемой в тексте,
-- прямым поиском решения уравнения (см. с. 62) *)
VAR d: INTEGER;
BEGIN
d := j - 1;
WHILE ( d >= 0 ) & ~( УрВыполняется( j, d ) & ( p[d] # p[j] ) ) DO
DEC( d )
END;
RETURN d
END D;
(* фрагмент из книги, с.62: *************************************)
PROCEDURE Search ( IN p, s: ARRAY OF CHAR; M, N: INTEGER; OUT r: INTEGER );
(* поиск образца p длины M в тексте s длины N; M <= Mmax *)
(* если p найден, то r указывает его позицию в s, иначе r = -1 *)
(* *)
VAR i, j, k: INTEGER;
d: ARRAY Mmax OF INTEGER;
BEGIN
(* вычислить d из p *)
d[0] := -1;
IF p[0] # p[1] THEN d[1] := 0 ELSE d[1] := -1 END; ASSERT( d[1] = D(1) );
j := 1; k := 0;
LOOP IF (j < M-1) & (k >= 0) & (p[j] # p[k]) THEN
k := d[k]
ELSIF j < M-1 THEN (* (k < 0) OR (p[j] = p[k]) *)
INC( j ); INC( k );
IF p[j] # p[k] THEN d[j] := k ELSE d[j] := d[k] END; ASSERT( d[j] = D(j) );
ELSE EXIT END END;
(* собственно поиск; проверки инварианта цикла P(i-j,j) показаны красным всюду, где инвариант должен выполняться *)
i := 0; j := 0;
ASSERT( P(i-j, j) );
LOOP IF (j < M) & (i < N) & (j >= 0) & (s[i] # p[j]) THEN
ASSERT( P(i-j, j) );
j := d[j];
ASSERT( P(i-j, j) );
ELSIF (j < M) & (i < N) THEN
ASSERT( P(i-j, j) );
INC(i); INC(j);
ASSERT( P(i-j, j) );
ELSE EXIT END; END;
ASSERT( P(i-j, j) );
IF j = M THEN
r := i-M
ELSE
r := -1;
END
END Search;
(* конец фрагмента ********************************************)
PROCEDURE Проверить*;
VAR r: INTEGER;
BEGIN
Log.Ln;
Log.String('Проверяем Кнута-Морриса-Пратта:'); Log.Ln;
In.Open; ASSERT( In.done );
In.String( s ); ASSERT( In.done ); N := LEN( s$ );
In.String( p ); ASSERT( In.done ); M := LEN( p$ );
Search( p, s, M, N, r );
Log.Int( r ); Log.Ln;
END Проверить;
END ADruS192_KMP.
ADruS192_KMP.Проверить
"Hoola-Hoola girls like Hooligans." "Hooligan"
или можно выделить любую строчку и кликнуть по командиру:
"Hoola-Hoola girls like Hooligans." "H"
"Hoola-Hoola girls like Hooligans." "o"
"Hoola-Hoola girls like Hooligans." "gi"
"Hoola-Hoola girls like Hooligans." "ns."
"Hoola-Hoola girls like Hooligans." "ooo"
"baaab" "abab"
aahaahaa ahaah
| ADru/Mod/S192_KMP.odc |
(* Общие сведения о примерах: Справка *)
(* Исправления и подготовка примеров: (С) Ф.В.Ткачев, 2009, info21 AT inr.ac.ru *)
MODULE ADruS193_БМ;
(* Поиск в тексте. Алгоритм Бойера и Мура, раздел 1.9.3. *)
IMPORT Log := StdLog, In := i21sysIn;
CONST Mmax = 10; Nmax = 1000;
VAR
s: ARRAY Nmax OF CHAR; N: INTEGER;
p: ARRAY Mmax OF CHAR; M: INTEGER;
(* реализация предикатов, определенных в тексте на с. 63: *)
PROCEDURE P ( i, j: INTEGER ): BOOLEAN;
VAR k: INTEGER;
BEGIN
k := j;
WHILE ( k < M ) & ( s[ i-M+k ] = p[ k ] ) DO INC( k ) END;
RETURN k = M
END P;
PROCEDURE R ( i: INTEGER ): BOOLEAN;
VAR j: INTEGER;
BEGIN
RETURN P( i, 0 )
END R;
PROCEDURE Q ( i: INTEGER ): BOOLEAN;
VAR k: INTEGER;
BEGIN
k := M;
WHILE ( k < i ) & ~R( k ) DO INC( k ) END;
RETURN ~( k < i )
END Q;
(* фрагмент из книги, с.64: **************************************)
PROCEDURE Search ( IN p, s: ARRAY OF CHAR; M, N: INTEGER; OUT r: INTEGER );
(* поиск образца p длины M в тексте s длины N; M <= Mmax *)
(* если p найден, то r указывает его позицию в s, иначе r = -1 *)
VAR i, j, k: INTEGER;
d: ARRAY 128 OF INTEGER;
BEGIN
FOR i := 0 TO 127 DO d[i] := M END;
FOR j := 0 TO M-2 DO d[ ORD( p[j] ) ] := M-j-1 END;
(* проверки инварианта цикла (показаны красным) вставлены всюду, где инвариант должен выполняться; в целях наглядности этих проверок вставлено больше, чем нужно: было бы достаточно оставить в обоих ветках по одной проверке в начале или в конце шага *)
i := M; j := M; k := i;
ASSERT( Q(i) & P(i, j) & (k = i-M+j) );
LOOP IF (j > 0) & (i <= N) & (s[k-1] = p[j-1]) THEN
ASSERT( Q(i) & P(i, j) & (k = i-M+j) );
DEC(k); DEC(j);
ASSERT( Q(i) & P(i, j) & (k = i-M+j) );
ELSIF (j > 0) & (i <= N) THEN
ASSERT( Q(i) & P(i, j) & (k = i-M+j) );
i := i + d[ ORD( s[i-1] ) ]; j := M; k := i;
ASSERT( Q(i) & P(i, j) & (k = i-M+j) );
ELSE EXIT END END;
ASSERT( Q(i) & P(i, j) & (k = i-M+j) );
IF j = 0 THEN r := k ELSE r := -1 END;
END Search;
(* конец фрагмента *******************************************)
PROCEDURE Проверить*;
VAR r: INTEGER;
BEGIN
Log.Ln;
Log.String('Проверяем Бойера-Мура:'); Log.Ln;
In.Open; ASSERT( In.done );
In.String( s ); ASSERT( In.done ); N := LEN( s$ );
In.String( p ); ASSERT( In.done ); M := LEN( p$ );
Search( p, s, M, N, r );
Log.Int( r ); Log.Ln;
END Проверить;
END ADruS193_БМ.
ADruS193_БМ.Проверить
"Hoola-Hoola girls like Hooligans." "Hooligan"
или можно выделить любую строчку и кликнуть по командиру:
"Hoola-Hoola girls like Hooligans." "H"
"Hoola-Hoola girls like Hooligans." "o"
"Hoola-Hoola girls like Hooligans." "gi"
"Hoola-Hoola girls like Hooligans." "ns."
"Hoola-Hoola girls like Hooligans." "gi"
"Hoola-Hoola girls like Hooligans." "ooo"
"baaab" "abab"
aahaahaa ahaah
| ADru/Mod/S193_БМ.odc |
(* Общие сведения о примерах: Справка *)
(* Исправления и подготовка примеров: (С) Ф.В.Ткачев, 2009, info21 AT inr.ac.ru *)
MODULE ADruS242_Runs;
(* Реализация вспомогательного модуля Runs из раздела 2.4.2, с. 105. ********
Средства модуля используются в различных алгоритмах сортировки слияниями. *)
IMPORT Files := ADruS171_Files, Texts := ADruS174_Texts;
TYPE
Rider* = RECORD ( Files.Rider )
first-: INTEGER;
eor-: BOOLEAN
END;
PROCEDURE OpenRandomSeq*( f: Files.File; length, seed: INTEGER );
VAR i: INTEGER; w: Files.Rider;
BEGIN
Files.Set( w, f, 0 );
FOR i := 0 TO length-1 DO
Files.WriteInt( w, seed ); seed := (31*seed) MOD 997 + 5
END;
Files.Close( f )
END OpenRandomSeq;
PROCEDURE Set*( VAR r: Rider; f: Files.File );
BEGIN
Files.Set( r, f, 0 );
Files.ReadInt( r, r.first );
r.eor := r.eof
END Set;
PROCEDURE copy*( VAR src, dest: Rider );
BEGIN
dest.first := src.first;
Files.WriteInt( dest, dest.first );
Files.ReadInt( src, src.first );
src.eor := src.eof OR ( src.first < dest.first )
END copy;
PROCEDURE ListSeq*( VAR W: Texts.Writer; f: Files.File );
VAR x, y, k, n: INTEGER; r: Files.Rider;
BEGIN
k := 0; n := 0;
(* Версия из книги. Проверка флажка r.eof должна выполняться немедленно за попыткой чтения ReadInt. Ошибка происходит из попытки оптимизации (сэкономить на повторении группы команд).
Корректная версия приводится ниже.
Files.Set( r, f, 0 ); Files.ReadInt( r, x );
WHILE ~r.eof DO
Texts.WriteInt( W, x, 6 ); INC( k ); Files.ReadInt( r, y );
IF y < x THEN (*конец серии*) Texts.Write( W, "|" ); INC( n ) END;
x := y
END;
*)
(* корректная версия *)
Files.Set( r, f, 0 ); Files.ReadInt( r, x );
IF ~r.eof THEN
Texts.WriteInt( W, x, 6 ); INC( k ); Files.ReadInt( r, y );
WHILE ~r.eof DO
IF y < x THEN (*конец серии*) Texts.Write( W, "|" ); INC( n ) END;
x := y;
Texts.WriteInt( W, x, 6 ); INC( k ); Files.ReadInt( r, y );
END;
END;
Texts.Write( W, "$" ); Texts.WriteInt( W, k, 5 ); Texts.WriteInt( W, n, 5 );
Texts.WriteLn( W )
END ListSeq;
PROCEDURE LogSeq*( f: Files.File ); (* то же, что ListSeq, но пишет в Log (рабочий журнал), причем всегда в конце *)
VAR x, y, k, n: INTEGER; r: Files.Rider; log: Texts.Writer;
BEGIN
Texts.OpenWriter( log, Texts.log, Texts.Length( Texts.log ) );
k := 0; n := 0; Files.Set( r, f, 0 );
Files.ReadInt( r, x );
IF ~r.eof THEN
Texts.WriteInt( log, x, 6 ); INC( k );
Files.ReadInt( r, y );
WHILE ~r.eof DO
IF y < x THEN (*конец серии*) Texts.WriteLn( log ); Texts.Write( log, "|" ); INC( n ) END;
Texts.WriteInt( log, y, 6 ); INC( k );
x := y;
Files.ReadInt( r, y );
END;
ELSE
END;
Texts.Write( log, "$" ); Texts.WriteInt( log, k, 5 ); Texts.WriteInt( log, n, 5 );
Texts.WriteLn( log );
Texts.ShowEnd( Texts.log );
END LogSeq;
END ADruS242_Runs.
| ADru/Mod/S242_Runs.odc |
(* Общие сведения о примерах: Справка *)
(* Исправления и подготовка примеров: (С) Ф.В.Ткачев, 2009, info21 AT inr.ac.ru *)
MODULE ADruS24_MergeSorts; (* Сортировки слияниями, раздел 2.4. *)
IMPORT Log := StdLog, In := i21sysIn, Dialog,
Files := ADruS171_Files, Texts := ADruS174_Texts, Runs := ADruS242_Runs;
TYPE Proc = PROCEDURE ( src: Files.File ): Files.File; (*для тестов*)
TYPE элемент = INTEGER;
VAR
N: INTEGER;
a: POINTER TO ARRAY (* 2*N *) OF элемент;
PROCEDURE InArray*;
VAR i, x: INTEGER;
BEGIN
In.Open; ASSERT( In.done );
i := 0;
In.Int( x );
WHILE In.done DO INC( i ); In.Int( x ) END;
ASSERT( i > 0 );
N := i;
NEW( a, 2*N );
In.Open; ASSERT( In.done );
i := 0;
In.Int( x );
WHILE In.done DO a[ i ] := x; INC( i ); In.Int( x ) END;
END InArray;
PROCEDURE LogArray*;
VAR i: INTEGER;
BEGIN
Log.Ln;
FOR i := 0 TO N-1 DO
Log.Int( a[ i ] )
END;
Log.Ln;
END LogArray;
(* простые слияния, с. 101 *************************************)
PROCEDURE StraightMerge*;
VAR i, j, k, L, t: INTEGER; (*диапазон индексов массива a is 0 .. 2*n-1 *)
h, m, p, q, r: INTEGER; up: BOOLEAN;
BEGIN
up := TRUE; p := 1;
REPEAT
h := 1; m := N;
IF up THEN
i := 0; j := N-1; k := N; L := 2*N-1
ELSE
k := 0; L := N-1; i := N; j := 2*N-1
END;
REPEAT (*слить по одной подпоследовательности из i- и j-источников в k-приемник *)
q := MIN( p, m ); (* IF m >= p THEN q := p ELSE q := m END; *)
m := m - q;
r := MIN( p, m ); (* IF m >= p THEN r := p ELSE r := m END; *)
m := m - r;
WHILE ( q > 0 ) & ( r > 0 ) DO
IF a[ i ] < a[ j ] THEN
a[ k ] := a[ i ]; k := k+h; i := i+1; q := q-1
ELSE
a[ k ] := a[ j ]; k := k+h; j := j-1; r := r-1
END
END;
WHILE r > 0 DO
a[ k ] := a[ j ]; k := k+h; j := j-1; r := r-1
END;
WHILE q > 0 DO
a[ k ] := a[ i ]; k := k+h; i := i+1; q := q-1
END;
h := -h; t := k; k := L; L := t
UNTIL m = 0;
up := ~up; p := 2*p
UNTIL p >= N;
IF ~up THEN
FOR i := 0 TO N-1 DO a[ i ] := a[ i+N ] END
END
END StraightMerge;
(* конец фрагмента *******************************************)
PROCEDURE RandomArray* ( n, seed: INTEGER );
VAR i: INTEGER;
BEGIN
N := n;
NEW( a, 2*N );
FOR i := 0 TO N-1 DO
a[ i ] := seed;
seed := (31*seed) MOD 997 + 5
END;
END RandomArray;
(** Естественные слияния, с. 108 ********************************)
PROCEDURE copyrun ( VAR x, y: Runs.Rider );
BEGIN (*from x to y*)
REPEAT Runs.copy( x, y ) UNTIL x.eor
END copyrun;
PROCEDURE NaturalMerge ( src: Files.File ): Files.File;
VAR L: INTEGER; (*число серий после слияния*)
f0, f1, f2: Files.File;
r0, r1, r2: Runs.Rider;
BEGIN
Runs.Set( r2, src );
REPEAT
f0 := Files.New("test0"); Files.Set(r0, f0, 0);
f1 := Files.New("test1"); Files.Set (r1, f1, 0);
(*распределить из r2 в r0 и r1*)
REPEAT copyrun( r2, r0 );
IF ~r2.eof THEN copyrun( r2, r1 ) END
UNTIL r2.eof;
Runs.Set( r0, f0 ); Runs.Set( r1, f1 );
f2 := Files.New(""); Files.Set( r2, f2, 0 ); L := 0;
(*слить из r0 и r1 в r2*)
REPEAT
REPEAT
IF r0.first < r1.first THEN
Runs.copy( r0, r2 );
IF r0.eor THEN copyrun( r1, r2 ) END
ELSE
Runs.copy( r1, r2 );
IF r1.eor THEN copyrun( r0, r2 ) END;
END
UNTIL r0.eor & r1.eor;
INC( L )
UNTIL r0.eof OR r1.eof;
WHILE ~r0.eof DO copyrun( r0, r2 ); INC( L ) END;
WHILE ~r1.eof DO copyrun( r1, r2 ); INC( L ) END;
Runs.Set( r2, f2 )
UNTIL L = 1;
RETURN f2
END NaturalMerge;
(* конец фрагмента *******************************************)
(** Сбалансированные слияния, с. 112 ****************************)
PROCEDURE BalancedMerge ( src: Files.File ): Files.File;
CONST N = 3;
VAR i, j, m, tx: INTEGER;
L, k1, k2, K1: INTEGER;
min, x: INTEGER;
t: ARRAY N OF INTEGER; (*index map*)
R: Runs.Rider; (*source*)
f, g: ARRAY N OF Files.File;
r, w: ARRAY N OF Runs.Rider;
BEGIN
Runs.Set( R, src );
FOR i := 0 TO N-1 DO
g[ i ] := Files.New("");
Files.Set( w[ i ], g[ i ], 0 )
END;
(*распределить начальные серии из src по g[0] ... g[N-1]*)
j := 0; L := 0;
REPEAT
REPEAT Runs.copy( R, w[ j ] ) UNTIL R.eor;
INC( L ); INC( j );
IF j = N THEN j := 0 END
UNTIL R.eof;
REPEAT
IF L < N THEN k1 := L ELSE k1 := N END;
K1 := k1; (*число активных w[*]; k1 считает активные r[*]*)
FOR i := 0 TO k1-1 DO (*установить бегунки-источники*)
Runs.Set( r[ i ], g[ i ] )
END;
FOR i := 0 TO k1-1 DO (*установить бегунки-приемник*)
g[ i ] := Files.New("");
Files.Set( w[ i ], g[ i ], 0 )
END;
(*merge from r[0] ... r[k1-1] to w[0] ... w[K1-1]*)
FOR i := 0 TO k1-1 DO t[ i ] := i END;
L := 0; (*число серий, созданных слияниями*)
j := 0;
REPEAT (*слить по одной серии из источников в w[j]*)
INC( L ); k2 := k1;
REPEAT
(*выбрать наименьший ключ*)
m := 0; min := r[ t[ 0 ] ].first; i := 1;
WHILE i < k2 DO
x := r[ t[ i ] ].first;
IF x < min THEN min := x; m := i END;
INC( i )
END;
Runs.copy( r[ t[ m ] ], w[ j ] );
IF r[ t[ m ] ].eof THEN (*удалить последовательность*)
DEC( k1 ); DEC( k2 ); t[ m ] := t[ k2 ]; t[ k2 ] := t[ k1 ]
ELSIF r[ t[ m ] ].eor THEN (*закрыть серию*)
DEC( k2 ); tx := t[ m ]; t[ m ] := t[ k2 ]; t[ k2 ] := tx
END
UNTIL k2 = 0;
INC( j );
IF j = K1 THEN j := 0 END;
UNTIL k1 = 0
UNTIL L = 1;
RETURN g[ 0 ]
END BalancedMerge;
(* конец фрагмента *****************************************)
(** Многофазная сортировка, с. 121 ****************************)
PROCEDURE Polyphase ( src: Files.File ): Files.File; (*многофазная сортировка*)
CONST N = 6;
VAR i, j, mx, tn: INTEGER;
k, dn, z, level: INTEGER;
x, min: INTEGER;
a, d: ARRAY N OF INTEGER;
t, ta: ARRAY N OF INTEGER; (*отображения индексов*)
R: Runs.Rider; (*входные данные*)
f: ARRAY N OF Files.File;
r: ARRAY N OF Runs.Rider;
(*использована версия copyrun из NaturalMerge*)
PROCEDURE select; (*выбор*)
VAR i, z: INTEGER;
BEGIN
IF d[ j ] < d[ j+1 ] THEN
INC( j )
ELSE
IF d[ j ] = 0 THEN
INC( level ); z := a[ 0 ];
FOR i := 0 TO N-2 DO
d[ i ] := z + a[ i+1 ] - a[ i ];
a[ i ] := z + a[ i+1 ]
END
END;
j := 0
END;
DEC( d[ j ] )
END select;
BEGIN
Runs.Set( R, src );
FOR i := 0 TO N-2 DO
a[ i ] := 1; d[ i ] := 1;
f[ i ] := Files.New(""); Files.Set( r[ i ], f[ i ], 0 )
END;
(*распределить начальные серии*)
level := 1; j := 0; a[ N-1 ] := 0; d[ N-1 ] := 0;
REPEAT
select;
copyrun( R, r[ j ] )
UNTIL R.eof OR ( j = N-2 );
WHILE ~R.eof DO
select; (* r[ j ].first = последний элемент, записанный в f[ j ] *)
IF r[ j ].first <= R.first THEN
copyrun( R, r[ j ] );
IF R.eof THEN INC( d[ j ] )
ELSE copyrun( R, r[ j ] ) END
ELSE
copyrun( R, r[ j ] )
END
END;
FOR i := 0 TO N-2 DO
t[ i ] := i; Runs.Set( r[ i ], f[ i ] )
END;
t[ N-1 ] := N-1;
REPEAT (*слить из t[0] ... t[N-2] в t[N-1]*)
z := a[ N-2 ]; d[ N-1 ] := 0;
f[ t[ N-1 ] ] := Files.New(""); Files.Set( r[ t[ N-1 ] ], f[ t[ N-1 ] ], 0 );
REPEAT
k := 0; (*создать слиянием одну серию*)
FOR i := 0 TO N-2 DO
IF d[i] = 0 THEN
ta[ k ] := t[ i ]; INC( k )
ELSE
DEC( d[ i ] )
END
END;
IF k = 0 THEN
INC( d[ N-1 ] )
ELSE (*создать одну реальную серию слиянием из t[0] ... t[k-1] в t[N-1]*)
REPEAT mx := 0; min := r[ ta[ 0 ] ].first; i := 1;
WHILE i < k DO
x := r[ ta[ i ] ].first;
IF x < min THEN min := x; mx := i END;
INC( i )
END;
Runs.copy( r[ ta[ mx ] ], r[ t[ N-1 ] ] );
IF r[ ta[ mx ] ].eor THEN
ta[ mx ] := ta[ k-1 ]; DEC( k )
END
UNTIL k = 0
END;
DEC( z )
UNTIL z = 0;
Runs.Set( r[ t[ N-1] ], f[ t[ N-1 ] ] ); (*ротация последовательностей*)
tn := t[N-1]; dn := d[N-1]; z := a[N-2];
FOR i := N-1 TO 1 BY -1 DO
t[ i ] := t[ i-1 ]; d[ i ] := d[ i-1 ]; a[ i ] := a[ i-1 ] - z
END;
t[ 0 ] := tn; d[ 0 ] := dn; a[ 0 ] := z; DEC( level )
UNTIL level = 0 ;
RETURN f[ t[ 0 ] ]
END Polyphase;
(* конец фрагмента ******************************************)
PROCEDURE Distribute ( src: Files.File ): Files.File; (* c. 126 ****************)
CONST M = 16; mh = M DIV 2; (* размер пирамиды *)
VAR L, R: INTEGER;
x: INTEGER;
dest: Files.File;
r, w: Files.Rider;
H: ARRAY M OF INTEGER; (* пирамида *)
PROCEDURE sift ( L, R: INTEGER );
VAR i, j, x: INTEGER;
BEGIN
i := L; j := 2*L+1; x := H[ i ];
IF ( j < R ) & ( H[ j ] > H[ j+1 ] ) THEN INC( j ) END;
WHILE ( j <= R ) & ( x > H[ j ] ) DO
H[ i ] := H[ j ]; i := j; j := 2*j+1;
IF ( j < R ) & ( H[ j ] > H[ j+1 ] ) THEN INC( j ) END
END;
H[ i ] := x
END sift;
BEGIN
Files.Set( r, src, 0 ); dest := Files.New(""); Files.Set( w, dest, 0 );
(* шаг 1: заполнить верхнюю половину пирамиды *)
L := M;
REPEAT DEC( L ); Files.ReadInt( r, H[ L ] ) UNTIL L = mh;
(* шаг 2: заполнить нижнюю половину пирамиды *)
REPEAT DEC( L ); Files.ReadInt( r, H[ L ] ); sift( L, M-1 ) UNTIL L = 0;
IF r.eof THEN
Dialog.ShowMsg( 'слишком короткая последовательность на входе' ); HALT(128)
END;
(* шаг 3: пропустить элементы сквозь пирамиду *)
L := M; Files.ReadInt( r, x );
WHILE ~r.eof DO
Files.WriteInt( w, H[0] );
IF H[ 0 ] <= x THEN
(* x принадлежит той же серии *) H[ 0 ] := x; sift( 0, L-1 )
ELSE
(* начать новую серию *)
DEC( L ); H[ 0 ] := H[ L ]; sift( 0, L-1 ); H[ L ] := x;
IF L < mh THEN sift( L, M-1 ) END;
IF L = 0 THEN (* пирамида полна; начать новую серию *) L := M END
END;
Files.ReadInt( r, x )
END;
(* шаг 4: сброс нижней половины пирамиды *)
R := M;
REPEAT DEC( L ); Files.WriteInt( w, H[ 0 ] );
H[ 0 ] := H[ L ]; sift( 0, L-1 ); DEC( R ); H[ L ] := H[ R ];
IF L < mh THEN sift( L, R-1 ) END
UNTIL L = 0;
(* шаг 5: сброс верхней половины пирамиды, начать новую серию *)
WHILE R > 0 DO
Files.WriteInt(w, H[0]); H[0] := H[R]; DEC(R); sift(0, R)
END;
RETURN dest
END Distribute;
(* конец фрагмента ******************************************)
(* команды тестирования *)
PROCEDURE TestStraightlMerge*;
VAR n, seed: INTEGER;
BEGIN
Log.Ln;
Log.String('Тестируем сортировку простыми слияниями (StraightMerge): ');
Log.Ln;
In.Open; ASSERT( In.done );
In.Int( n ); ASSERT( In.done );
In.Int( seed ); ASSERT( In.done );
RandomArray( n, seed );
Log.String('исходная последовательность: '); Log.Ln;
LogArray;
StraightMerge;
Log.Ln; Log.String('последовательность после сортировки: '); Log.Ln;
LogArray;
END TestStraightlMerge;
PROCEDURE Do ( p: Proc; s: ARRAY OF CHAR );
VAR n, seed: INTEGER; old, new: Files.File; wr: Texts.Writer;
BEGIN
Log.Ln; Log.String(s); Log.Ln;
In.Open; ASSERT( In.done );
In.Int( n ); ASSERT( In.done );
In.Int( seed ); ASSERT( In.done );
old := Files.New('old');
Runs.OpenRandomSeq( old, n, seed );
Log.String('исходная последовательность, по сериям: '); Log.Ln;
Runs.LogSeq( old ); (* как выглядели серии в исходной последовательности *)
new := p( old );
Log.Ln; Log.String('последовательность после обработки (после знака $ печатается длина последовательности и количество серий минус 1): '); Log.Ln;
Runs.LogSeq( new );
END Do;
PROCEDURE TestNaturalMerge*;
BEGIN
Do( NaturalMerge, 'Тестируем сортировку естественными слияниями (NaturalMerge): ');
END TestNaturalMerge;
PROCEDURE TestBalancedMerge*;
BEGIN
Do( BalancedMerge, 'Тестируем сортировку сбалансированными слияниями (BalancedMerge): ');
END TestBalancedMerge;
PROCEDURE TestPolyphase*;
BEGIN
Do( Polyphase, 'Тестируем многофазную сортировку слияниями (Polyphase): ');
END TestPolyphase;
PROCEDURE TestDistribute*;
BEGIN
Do( Distribute, 'Тестируем процедуру распределения начальных серий посредством фильтрации сквозь пирамиду: ');
END TestDistribute;
END ADruS24_MergeSorts.
Все тесты производятся по одной общей схеме:
-- генерится последовательность случайных чисел заданной длины (первое число из пары),
-- сгенеренная последовательность печатается в рабочий журнал (Log),
-- к ней применяется соответствующая процедура;
-- получившаяся последовательность распечатывается.
Для прогона теста кликнуть по соответствующему черному командиру :
Простые слияния, раздел 2.4.1:
ADruS24_MergeSorts.TestStraightlMerge 12 1
Естественные слияния, раздел 2.4.2:
ADruS24_MergeSorts.TestNaturalMerge 12 1
Сбалансированные слияния, раздел 2.4.3:
ADruS24_MergeSorts.TestBalancedMerge 12 1
Многофазная сортировка, раздел 2.4.4:
ADruS24_MergeSorts.TestPolyphase 12 1
Распределение начальных серий, раздел 2.4.5; в конце последовательность распечатывается, чтобы показать получившиеся серии:
ADruS24_MergeSorts.TestDistribute 50 1
После команд указана пара чисел. Их можно менять:
Первое число -- определяет длину сортируемой последовательности.
Второе число -- затравка (seed) для генератора случайных чисел (разные затравки дают разные последовательности).
Эту пару чисел можно брать из другого места -- для этого достаточно перед кликом выделить нужную пару, например, вот в этой строчке:
12 314 ~ 91 314 ~ 1112 314
Еще способ проверки сортировки простыми слияниями.
Сортируемый массив задается непосредственно в потоке ввода, результат печатается в рабочий журнал (Log):
"ADruS24_MergeSorts.InArray;
ADruS24_MergeSorts.StraightMerge;
ADruS24_MergeSorts.LogArray" 44 55 12 42 94 18 06 67
| ADru/Mod/S24_MergeSorts.odc |
(* Общие сведения о примерах: Справка *)
(* Исправления и подготовка примеров: (С) Ф.В.Ткачев, 2009, info21 AT inr.ac.ru *)
MODULE ADruS2_Sorts;
(* Алгоритмы сортировки массивов, разделы 2.2-2.3. *)
IMPORT Log := StdLog, In := i21sysIn, Math, ObxRandom;
TYPE Item = INTEGER;
(* сортируемый массив: *)
VAR
n: INTEGER;
a: POINTER TO ARRAY (* n *) OF Item;
PROCEDURE Печатать*; (* печать массива в рабочий журнал *)
VAR i: INTEGER;
BEGIN
Log.String('n ='); Log.Int( n ); Log.Ln;
FOR i := 0 TO n-1 DO Log.Tab; Log.Int( a[i] ) END;
Log.Ln;
END Печатать;
PROCEDURE Проверить*; (* проверка упорядоченности массива *)
VAR i: INTEGER;
BEGIN
i := 1;
WHILE ( i < n ) & ( a[i-1] <= a[i] ) DO INC( i ) END;
Log.String('n ='); Log.Int( n ); Log.Ln;
IF i < n THEN
Log.String('массив не упорядочен: ');
Log.Int( i-1 ); Log.Int( i ); Log.Int( a[i-1] ); Log.Int( a[i] );
Log.Ln;
HALT( 128 ); (*останов без трапа*)
ELSE
Log.String('массив упорядочен по возрастанию.'); Log.Ln;
END;
END Проверить;
PROCEDURE Станд8*; (* инициализация сортируемого массива стандартной последовательностью, используемой Виртом *)
BEGIN
n := 8; NEW( a, n );
a[0] := 44;
a[1] := 55;
a[2] := 12;
a[3] := 42;
a[4] := 94;
a[5] := 18;
a[6] := 06;
a[7] := 67;
Log.String('Задан стандартный тестовый массив из 8 элементов.'); Log.Ln;
Печатать
END Станд8;
PROCEDURE Упорядоченный*;
VAR i: INTEGER;
BEGIN
In.Open; ASSERT( In.done );
In.Int( n ); ASSERT( In.done ); ASSERT( n > 0 );
NEW( a, n );
FOR i := 0 TO n-1 DO a[i] := i END;
Log.String('Задан упорядоченный массив, n ='); Log.Int( n ); Log.Ln;
END Упорядоченный;
PROCEDURE Обратный*;
VAR i: INTEGER;
BEGIN
In.Open; ASSERT( In.done );
In.Int( n ); ASSERT( In.done ); ASSERT( n > 0 );
NEW( a, n );
FOR i := 0 TO n-1 DO a[i] := n-i END;
Log.String('Задан массив, упорядоченный в обратном порядке, n ='); Log.Int( n ); Log.Ln;
END Обратный;
PROCEDURE Случайный*;
VAR i: INTEGER;
BEGIN
In.Open; ASSERT( In.done );
In.Int( n ); ASSERT( In.done ); ASSERT( n > 0 );
NEW( a, n );
FOR i := 0 TO n-1 DO
a[i] := SHORT( ENTIER( n * ObxRandom.Uniform() ) )
END;
Log.String('Задан случайный массив, n ='); Log.Int( n ); Log.Ln;
END Случайный;
PROCEDURE ВвестиМассив*;
VAR x, i: INTEGER;
BEGIN
In.Open; ASSERT( In.done );
In.Int( x ); i := 0;
WHILE In.done DO
INC( i ); In.Int( x );
END;
n := i; NEW( a, n );
In.Open; ASSERT( In.done );
In.Int( x ); i := 0;
WHILE In.done DO
a[ i ] := x;
INC( i ); In.Int( x );
END;
Log.String('Массив введен из потока ввода:'); Log.Ln;
Печатать
END ВвестиМассив;
PROCEDURE StraightInsertion*; (* простые вставки, с. 74 **************)
VAR i, j: INTEGER; x: Item;
BEGIN
FOR i := 1 TO n-1 DO
x := a[i]; j := i;
WHILE (j > 0) & (x < a[j-1]) DO
a[j] := a[j-1];
DEC(j)
END;
a[j] := x
END
END StraightInsertion;
PROCEDURE BinaryInsertion*; (* двоичные вставки, с. 74 **************)
VAR i, j, m, L, R: INTEGER; x: Item;
BEGIN
Печатать;
FOR i := 1 TO n-1 DO
x := a[i]; L := 0; R := i;
WHILE L < R DO
m := (L+R) DIV 2;
IF a[m] <= x THEN
L := m+1
ELSE
R := m
END
END;
FOR j := i TO R+1 BY -1 DO a[j] := a[j-1] END;
a[R] := x;
Печатать;
END
END BinaryInsertion;
PROCEDURE StraightSelection*; (* простой выбор, с. 76 ***************)
VAR i, j, k: INTEGER; x: Item;
BEGIN
FOR i := 0 TO n-2 DO
k := i; x := a[i];
FOR j := i+1 TO n-1 DO
IF a[j] < x THEN
k := j; x := a[k]
END
END;
a[k] := a[i]; a[i] := x
END
END StraightSelection;
PROCEDURE BubbleSort*; (* пузырек, с. 78 ************************)
VAR i, j: INTEGER; x: Item;
BEGIN
FOR i := 1 TO n-1 DO
FOR j := n-1 TO i BY -1 DO
IF a[j-1] > a[j] THEN
x := a[j-1]; a[j-1] := a[j]; a[j] := x
END
END
END
END BubbleSort;
PROCEDURE ShakerSort*; (* шейкер-сортировка, с. 79 ***************)
VAR j, k, L, R: INTEGER; x: Item;
BEGIN
L := 1; R := n-1; k := R;
REPEAT
FOR j := R TO L BY -1 DO
IF a[j-1] > a[j] THEN
x := a[j-1]; a[j-1] := a[j]; a[j] := x;
k := j
END
END;
L := k+1;
FOR j := L TO R BY +1 DO
IF a[j-1] > a[j] THEN
x := a[j-1]; a[j-1] := a[j]; a[j] := x;
k := j
END
END;
R := k-1
UNTIL L > R
END ShakerSort;
PROCEDURE ShellSort*; (* сортировка Шелла, с. 82 *****************)
CONST T = 4;
VAR i, j, k, m, s: INTEGER;
x: Item;
h: ARRAY T OF INTEGER;
BEGIN
(* изменен порядок элементов h, чтоб легче увеличить T *)
h[0] := 1; h[1] := 3; h[2] := 5; h[3] := 9;
FOR m := T-1 TO 0 BY -1 DO
k := h[m];
FOR i := k TO n-1 DO
x := a[i];
j := i-k;
WHILE (j >= 0) & (x < a[j]) DO
a[j+k] := a[j];
j := j-k
END;
a[j+k] := x
END
END;
END ShellSort;
PROCEDURE sift(L, R: INTEGER);
VAR i, j: INTEGER; x: Item;
BEGIN i := L; j := 2*i+1; x := a[i];
IF (j < R) & (a[j] < a[j+1]) THEN j := j+1 END;
WHILE (j <= R) & (x < a[j]) DO
a[i] := a[j]; i := j; j := 2*j+1;
IF (j < R) & (a[j] < a[j+1]) THEN j := j+1 END
END;
a[i] := x
END sift;
PROCEDURE HeapSort*; (* турнирная сортировка, с.87 **************)
VAR L, R: INTEGER; x: Item;
BEGIN L := n DIV 2; R := n-1;
WHILE L > 0 DO DEC(L); sift(L, R) END;
WHILE R > 0 DO
x := a[0]; a[0] := a[R]; a[R] := x;
DEC(R); sift(L, R)
END
END HeapSort;
PROCEDURE sort ( L, R: INTEGER );
VAR i, j: INTEGER; w, x: Item;
BEGIN
i := L; j := R;
x := a[(L+R) DIV 2];
REPEAT
WHILE a[i] < x DO i := i+1 END;
WHILE x < a[j] DO j := j-1 END;
IF i <= j THEN
w := a[i]; a[i] := a[j]; a[j] := w;
i := i+1; j := j-1
END
UNTIL i > j;
IF L < j THEN sort(L, j) END;
IF i < R THEN sort(i, R) END
END sort;
PROCEDURE QuickSort*; (* быстрая сортировка, с.90 *******************)
BEGIN sort(0, n-1)
END QuickSort;
PROCEDURE NonRecursiveQuickSort*; (* нерекурсивный вариант, с.90 ******)
CONST M = 12;
VAR i, j, L, R, s: INTEGER; x, w: Item;
low, high: ARRAY M OF INTEGER; (*стек индексов*)
BEGIN
s := 0; low[0] := 0; high[0] := n-1;
REPEAT (*взять верхний запрос со стека*)
L := low[s]; R := high[s]; DEC(s);
REPEAT (*разделить сегмент a[L] ... a[R]*)
i := L; j := R; x := a[(L+R) DIV 2];
REPEAT
WHILE a[i] < x DO INC(i) END;
WHILE x < a[j] DO DEC(j) END;
IF i <= j THEN
w := a[i]; a[i] := a[j]; a[j] := w;
i := i+1; j := j-1
END
UNTIL i > j;
IF i < R THEN (*сохранить в стеке запрос на сортировку правой части*)
INC(s); low[s] := i; high[s] := R
END;
R := j (*теперь L и R ограничивают левую часть*)
(* часть, показанную синим, можно оптимизировать в соответствии с рассуждениями в тексте книги, см. ниже *)
UNTIL L >= R
UNTIL s < 0
END NonRecursiveQuickSort;
PROCEDURE NonRecursiveQuickSort2*;
CONST M = 12;
VAR i, j, L, R, s: INTEGER; x, w: Item;
low, high: ARRAY M OF INTEGER; (*стек индексов*)
BEGIN
s := 0; low[0] := 0; high[0] := n-1;
REPEAT (*взять верхний запрос со стека*)
L := low[s]; R := high[s]; DEC(s);
REPEAT (*разделить сегмент a[L] ... a[R]*)
i := L; j := R; x := a[(L+R) DIV 2];
REPEAT
WHILE a[i] < x DO INC(i) END;
WHILE x < a[j] DO DEC(j) END;
IF i <= j THEN
w := a[i]; a[i] := a[j]; a[j] := w;
i := i+1; j := j-1
END
UNTIL i > j;
(* чтобы уменьшить глубину стека, сохраняем туда больший сегмент,
а сортируем меньший: *)
IF j - L < R - i THEN
IF i < R THEN (*записать в стек запрос на сортировку правой части*)
INC(s); low[s] := i; high[s] := R
END;
R := j (*продолжать сортировкой левой части*)
ELSE
IF L < j THEN (*записать в стек запрос на сортировку левой части*)
INC(s); low[s] := L; high[s] := j
END;
L := i (*продолжать сортировкой правой части*)
END
UNTIL L >= R
UNTIL s < 0
END NonRecursiveQuickSort2;
PROCEDURE Find ( k: INTEGER ); (* поиск k-го элемента из раздела 2.3.4, с. 94 *)
(*переставить a так, чтобы a[k] стал k-м по возрастанию*)
VAR L, R, i, j: INTEGER; w, x: Item;
BEGIN
L := 0; R := n-1;
WHILE L < R-1 DO
x := a[k]; i := L; j := R;
REPEAT
WHILE a[i] < x DO i := i+1 END;
WHILE x < a[j] DO j := j-1 END;
IF i <= j THEN
w := a[i]; a[i] := a[j]; a[j] := w;
i := i+1; j := j-1
END
UNTIL i > j;
IF j < k THEN L := i END;
IF k < i THEN R := j END
END
END Find;
PROCEDURE Median*;
VAR k: INTEGER;
BEGIN
(* предполагаем, что массив a инициализирован *)
In.Open; ASSERT( In.done );
In.Int( k ); ASSERT( In.done & ( k >= 0 ) );
Find( k );
Log.Int( a[k] ); Log.Ln;
END Median;
END ADruS2_Sorts.
Ниже приводятся команды для игр с сортировками массивов из разделов 2.2-2.3.
Обрабатываемый массив сохраняется в модуле, сортировки (и поиск медианы) работают прямо с этим массивом (in situ).
Первая группа команд -- различные способы задания исходного массива.
Вторая группа -- различные команды сортировки.
Третья группа -- вспомогательные команды (печать и проверка упорядоченности).
В командах имя модуля «покрашено» серым цветом (см. меню Атрибуты). Такая раскраска не влияет на работу команд, а только помогает лучше видеть имена вызываемых процедур.
В частности, чтобы посмотреть соотв. процедуры: двойной клик по имени процедуры, F4.)
1. Задание сортируемого массива
Каждый командир задает соответствующий массив.
Заданный массив распечатывается в рабочем журнале (окно Log).
После клика по любому командиру и переходить к командам сортировки.
ADruS2_Sorts.Станд8 --стандартный 8-элементный массив из книги (таблица 2.1 и далее).
ADruS2_Sorts.Упорядоченный 256 --упорядоченный массив из 256 элементов. Можно поменять число и снова кликнуть.
ADruS2_Sorts.Обратный 256 --массив из 256 элементов в обратном порядке
ADruS2_Sorts.Случайный 25 --случайный набор из 25 чисел
ADruS2_Sorts.ВвестиМассив 13 23 75 234 34 1 22 93 99 2 6
--массив составляется из указанных чисел; можно менять числа, удалять, добавлять новые, потом просто кликнуть по круглому командеру.
2. Сортировки
Длинные вычисления можно останавливать нажатием Ctrl+Break. Если при этом Рабочий журнал (Log) станет серым, то его можно закрыть и снова открыть -- Info, Open Log,
Клик по каждому командеру вызывает сортировку соответствующим методом:
ADruS2_Sorts.StraightInsertion --простые вставки, раздел 2.2.1.
ADruS2_Sorts.BinaryInsertion --двоичные вставки, там же.
ADruS2_Sorts.StraightSelection --простой выбор, раздел 2.2.2.
ADruS2_Sorts.BubbleSort --пузырьковая, раздел 2.2.3.
ADruS2_Sorts.ShakerSort --шейкер-сортировка, раздел 2.2.3.
ADruS2_Sorts.ShellSort --сортировка Шелла, раздел 2.3.1.
ADruS2_Sorts.HeapSort --турнирная сортировка, раздел 2.3.2.
ADruS2_Sorts.QuickSort --быстрая сортировка Хоора, раздел 2.3.3.
ADruS2_Sorts.NonRecursiveQuickSort --нерекурсивный вариант быстрой сортировки.
ADruS2_Sorts.NonRecursiveQuickSort2 --вариант с оптимизацией глубины стека.
ADruS2_Sorts.Median 4 --поиск k-го элемента по возрастанию, раздел 2.3.4; после вызова удобно отсортировать массив любым способом (кликнуть по любой сортировке) и распечатать командой ниже.
3. Проверки результата
Эти команды можно вызывать до и после сортировок, они не меняют массива:
ADruS2_Sorts.Проверить --проверка, что получился упорядоченный массив.
ADruS2_Sorts.Печатать --печать получившегося массива в рабочий журнал (Log).
Вызов нескольких команд одним кликом:
Последовательность команд оформляется как показано в примере.
Команды пишутся подряд через ; в порядке выполнения.
Все вместе заключаются в двойные кавычки.
Поток ввода -- всё, что стоит после закрывающей двойной кавычки до значка
"ADruS2_Sorts.Случайный;
ADruS2_Sorts.QuickSort;
ADruS2_Sorts.Проверить;ADruS2_Sorts.Печатать" 55
| ADru/Mod/S2_Sorts.odc |
(* Общие сведения о примерах: Справка *)
(* Исправления и подготовка примеров: (С) Ф.В.Ткачев, 2009, info21 AT inr.ac.ru *)
MODULE ADruS33_Draw; (* Эмуляция модуля Draw, описанного в разделе 3.3, с. 138 книги Н.Вирта «Алгоритмы и структуры данных. Новая версия для Оберона», 2009. *)
IMPORT Views, Ports, Properties, Windows;
TYPE
View = POINTER TO RECORD ( Views.View ) END;
Pos = RECORD
x, y: INTEGER
END;
Element = POINTER TO ABSTRACT RECORD
next: Element
END;
ElLine = POINTER TO RECORD ( Element )
start, finish: Pos;
thick: BOOLEAN;
END;
UpdateMsg = RECORD ( Views.Message ) END;
CONST width* = 512; height* = 512;
VAR v: View;
pen: Pos;
first, last: Element;
msg: UpdateMsg;
thick: BOOLEAN;
PROCEDURE PixelSize ( f: Ports.Frame ): INTEGER;
VAR res: INTEGER;
BEGIN
res := MAX( f.unit, 9525 ); (* на экране в пикселях, при печати в неких условных единицах, чтобы не было слишком мелко *)
RETURN res
END PixelSize;
PROCEDURE ( el: Element ) Draw ( f: Ports.Frame ), NEW, ABSTRACT;
PROCEDURE ( el: ElLine ) Draw ( f: Ports.Frame );
VAR ps: INTEGER; s: INTEGER;
BEGIN
ps := PixelSize( f );
IF el.thick THEN
s := 2*ps
ELSE
s := 0
END;
f.DrawLine(
ps * el.start.x, ps * (height - el.start.y),
ps * el.finish.x, ps * (height - el.finish.y),
s, Ports.black
)
END Draw;
PROCEDURE ( v: View ) Restore ( f: Views.Frame; l, t, r, b: INTEGER );
VAR el: Element; ps: INTEGER;
BEGIN
ps := PixelSize( f );
el := first;
WHILE el # NIL DO
el.Draw( f );
el := el.next
END
END Restore;
PROCEDURE ( v: View ) HandlePropMsg- ( VAR p: Properties.Message );
BEGIN
WITH p: Properties.ResizePref DO
p.horFitToWin := TRUE;
p.verFitToWin := TRUE
ELSE
END;
END HandlePropMsg;
PROCEDURE ( v: View ) HandleViewMsg- ( f: Views.Frame; VAR p: Views.Message );
BEGIN
WITH p: UpdateMsg DO
v.Restore( f, 0, 0, MAX(INTEGER), MAX(INTEGER) )
ELSE
END;
END HandleViewMsg;
PROCEDURE Include ( el: Element );
BEGIN
ASSERT( el.next = NIL, 20 );
IF first = NIL THEN
first := el
ELSE
last.next := el
END;
last := el;
Views.Update( v, Views.keepFrames );
END Include;
PROCEDURE SetPen* ( x, y: INTEGER );
VAR
BEGIN
ASSERT( x >= 0, 20 );
ASSERT( y >= 0, 21 );
pen.x := x;
pen.y := y;
END SetPen;
PROCEDURE NextThick*;
VAR
BEGIN
thick := TRUE
END NextThick;
PROCEDURE LineTo ( pos: Pos );
VAR l: ElLine;
BEGIN
NEW( l );
l.start := pen;
l.finish := pos;
l.thick := thick;
Include( l );
thick := FALSE;
SetPen( pos.x, pos.y )
END LineTo;
PROCEDURE line* ( dir, len: INTEGER );
(* нарисовать линию длины len в направлении dir*45 градусов; передвинуть перо соответственно *)
VAR new: Pos;
BEGIN
ASSERT( ( dir >= 0 ) & ( dir < 8 ), 20 );
new := pen;
IF ( dir = 0 ) OR ( dir = 1 ) OR ( dir = 7 ) THEN INC( new.x, len )
ELSIF ( dir = 3 ) OR ( dir = 4 ) OR ( dir = 5 ) THEN DEC( new.x, len )
END;
IF ( dir = 1 ) OR ( dir = 2 ) OR ( dir = 3 ) THEN INC( new.y, len )
ELSIF ( dir = 5 ) OR ( dir = 6 ) OR ( dir = 7 ) THEN DEC( new.y, len )
END;
(* draw from pen to new *)
LineTo( new )
END line;
PROCEDURE Init;
BEGIN
first := NIL; last := NIL; thick := FALSE;
END Init;
PROCEDURE Open;
BEGIN Views.OpenView( v ); Views.Update( v, Views.keepFrames )
END Open;
PROCEDURE Clear*; (* clear drawing plane *)
BEGIN Init; Views.Omnicast( msg )
END Clear;
PROCEDURE Close;
VAR w: Windows.Window;
BEGIN
w := Windows.dir.First();
WHILE ( w # NIL ) & ( w.doc.ThisView() # v ) DO
w := Windows.dir.Next( w )
END;
IF w # NIL THEN
Windows.dir.Close( w )
END;
END Close;
PROCEDURE Test*;
VAR
BEGIN
SetPen( 0, 0 ); line( 1, 20 );
SetPen( 40, 40 ); line( 1, 20 );
SetPen( 80, 80 ); line( 1, 40 )
END Test; (* ADruS33_Draw.Test *)
BEGIN
Init; NEW( v ); Open;
CLOSE
Close
END ADruS33_Draw.
| ADru/Mod/S33_Draw.odc |
(* Общие сведения о примерах: Справка *)
(* Исправления и подготовка примеров: (С) Ф.В.Ткачев, 2009, info21 AT inr.ac.ru *)
MODULE ADruS33_Hilbert;
(* Рисование гильбертовых кривых из раздела 3.3. *)
IMPORT Draw := ADruS33_Draw;
CONST right = 0; up = 2; left = 4; down = 6;
(* фрагмент из книги, с. 138 *************************************)
VAR u: INTEGER;
(* необходимые упреждающие определения, отсутствующие в книге: *)
PROCEDURE^ B ( i: INTEGER );
PROCEDURE^ C ( i: INTEGER );
PROCEDURE^ D ( i: INTEGER );
PROCEDURE A ( i: INTEGER );
BEGIN
IF i > 0 THEN
D( i - 1 ); Draw.line( left, u );
A( i - 1 ); Draw.line( down, u );
A( i - 1 ); Draw.line( right, u );
B( i - 1 )
END
END A;
PROCEDURE B ( i: INTEGER );
BEGIN
IF i > 0 THEN
C( i - 1 ); Draw.line( up, u );
B( i - 1 ); Draw.line( right, u );
B( i - 1 ); Draw.line( down, u );
A( i - 1 )
END
END B;
PROCEDURE C ( i: INTEGER );
BEGIN
IF i > 0 THEN
B( i - 1 ); Draw.line( right, u );
C( i - 1 ); Draw.line( up, u );
C( i - 1 ); Draw.line( left, u );
D( i - 1 )
END
END C;
PROCEDURE D ( i: INTEGER );
BEGIN
IF i > 0 THEN
A( i - 1 ); Draw.line( down, u );
D( i - 1 ); Draw.line( left, u );
D( i - 1 ); Draw.line( up, u );
C( i - 1 )
END
END D;
PROCEDURE Hilbert* ( n: INTEGER );
CONST SquareSize = 512;
VAR i, x0, y0: INTEGER;
BEGIN
Draw.Clear;
x0 := Draw.width DIV 2; y0 := Draw.height DIV 2;
u := SquareSize;
i := 0;
REPEAT
INC( i );
u := u DIV 2;
x0 := x0 + (u DIV 2); y0 := y0 + (u DIV 2); Draw.SetPen( x0, y0 );
A( i )
UNTIL i = n
END Hilbert;
(* конец фрагмента *******************************************)
END ADruS33_Hilbert.
При клике по одному из нижеприведенных командиров в отдельном окошке рисуется гильбетрова кривая соответствующего порядка.
При повторных кликах рисунок перерисовывается в том же окошке:
"ADruS33_Hilbert.Hilbert(1)"
"ADruS33_Hilbert.Hilbert(2)"
"ADruS33_Hilbert.Hilbert(3)"
"ADruS33_Hilbert.Hilbert(4)"
"ADruS33_Hilbert.Hilbert(5)"
"ADruS33_Hilbert.Hilbert(6)"
"ADruS33_Hilbert.Hilbert(7)"
Если окошко с рисунком случайно закрылось, кликнуть сюда:
DevDebug.UnloadThis ADruS33_Hilbert ADruS33_Sierpinski ADruS33_Draw
Для копирования получившихся картинок в текст (см. такую копию ниже):
отрегулировать размер окна, Ctrl+Space, Ctrl+C,
в тексте, куда надо вставить картинку:
Edit, Paste Special..., выбрать Picture (Metafile).
| ADru/Mod/S33_Hilbert.odc |
(* Общие сведения о примерах: Справка *)
(* Исправления и подготовка примеров: (С) Ф.В.Ткачев, 2009, info21 AT inr.ac.ru *)
MODULE ADruS33_Sierpinski; (* Рисование кривых Серпиньского, раздел 3.3. *)
IMPORT Log := StdLog, Math, Draw := ADruS33_Draw;
CONST в = 0; с = 2; з = 4; ю = 6; (*в = восток и т.д.*)
св = 1; сз = 3; юз = 5; юв = 7; (*св = северо-восток и т.д.*)
(* фрагмент из книги, с. 141 ************************************)
VAR h: INTEGER;
(* необходимые упреждающие определения, отсутствующие в книге: *)
PROCEDURE^ B ( k: INTEGER );
PROCEDURE^ C ( k: INTEGER );
PROCEDURE^ D ( k: INTEGER );
PROCEDURE A ( k: INTEGER );
BEGIN
IF k > 0 THEN
A( k - 1 ); Draw.line( юв, h );
B( k - 1 ); Draw.line( в, 2*h );
D( k - 1 ); Draw.line( св, h );
A( k - 1 )
END
END A;
PROCEDURE B ( k: INTEGER );
BEGIN
IF k > 0 THEN
B( k - 1 ); Draw.line( юз, h );
C( k - 1 ); Draw.line( ю, 2*h );
A( k - 1 ); Draw.line( юв, h );
B( k - 1 )
END
END B;
PROCEDURE C ( k: INTEGER );
BEGIN
IF k > 0 THEN
C( k - 1 ); Draw.line( сз, h );
D( k - 1 ); Draw.line( з, 2*h );
B( k - 1 ); Draw.line( юз, h );
C( k - 1)
END
END C;
PROCEDURE D ( k: INTEGER );
BEGIN
IF k > 0 THEN
D( k - 1 ); Draw.line( св, h );
A( k - 1 ); Draw.line( с, 2*h );
C( k - 1 ); Draw.line( сз, h );
D( k - 1 )
END
END D;
PROCEDURE Sn* ( n: INTEGER );
CONST SquareSize = 256;
VAR i, x0, y0: INTEGER;
BEGIN
Draw.Clear;
h := SquareSize DIV ASH( 2, n );
x0 := 2 * h DIV 3; y0 := Draw.width - x0;
h := h DIV 2; y0 := y0 + h; Draw.SetPen( x0, y0 );
A( n ); Draw.NextThick; Draw.line( юв, h );
B( n ); Draw.NextThick; Draw.line( юз, h );
C( n ); Draw.NextThick; Draw.line( сз, h );
D( n ); Draw.NextThick; Draw.line( св, h );
END Sn;
PROCEDURE Sierpinski* ( n: INTEGER );
CONST SquareSize = 256;
VAR i, x0, y0: INTEGER;
BEGIN
Draw.Clear;
h := SquareSize DIV 2;
x0 := 2*h; y0 := Draw.width - h;
i := 0;
REPEAT
INC( i ); x0 := x0 - h;
h := h DIV 2; y0 := y0 + h; Draw.SetPen( x0, y0 );
A( i ); Draw.line( юв, h );
B( i ); Draw.line( юз, h );
C( i ); Draw.line( сз, h );
D( i ); Draw.line( св, h )
UNTIL i = n
END Sierpinski;
(* конец фрагмента *****************************************)
END ADruS33_Sierpinski.
При клике по одному из нижеприведенных командиров в отдельном окошке рисуется кривая Серпиньского соответствующего порядка.
При повторных кликах рисунок перерисовывается в том же окошке:
Если окошко с рисунком случайно закрылось, прежде чем пытаться нарисовать его снова, кликнуть сюда:
DevDebug.UnloadThis ADruS33_Hilbert ADruS33_Sierpinski ADruS33_Draw
"ADruS33_Sierpinski.Sierpinski(1)"
"ADruS33_Sierpinski.Sierpinski(2)"
"ADruS33_Sierpinski.Sierpinski(3)"
"ADruS33_Sierpinski.Sierpinski(4)"
"ADruS33_Sierpinski.Sierpinski(5)"
"ADruS33_Sierpinski.Sierpinski(6)"
Отдельные кривые:
"ADruS33_Sierpinski.Sn(1)"
"ADruS33_Sierpinski.Sn(2)"
"ADruS33_Sierpinski.Sn(3)"
"ADruS33_Sierpinski.Sn(4)"
"ADruS33_Sierpinski.Sn(5)"
"ADruS33_Sierpinski.Sn(6)"
Для копирования получившихся картинок в текст (см. такую копию ниже):
отрегулировать размер окна, Ctrl+Space, Ctrl+C,
в тексте, куда надо вставить картинку:
Edit, Paste Special..., выбрать Picture (Metafile).
| ADru/Mod/S33_Sierpinski.odc |
(* Общие сведения о примерах: Справка *)
(* Исправления и подготовка примеров: (С) Ф.В.Ткачев, 2009, info21 AT inr.ac.ru *)
MODULE ADruS34_KnightsTour; (* Задача о путешествии коня, раздел 3.4. *)
IMPORT Log := StdLog, In := i21sysIn, Math;
VAR
n, nsqr: INTEGER;
(* фрагмент из книги, с. 146: **********************************)
VAR
h: POINTER TO ARRAY OF ARRAY (* n, n *) OF INTEGER;
dx, dy: ARRAY 8 OF INTEGER;
PROCEDURE^ TryNextMove( x, y, i: INTEGER; OUT done: BOOLEAN );
PROCEDURE CanBeDone ( u, v, i: INTEGER ): BOOLEAN;
VAR done: BOOLEAN;
BEGIN
h[u, v] := i;
TryNextMove( u, v, i, done );
IF ~done THEN h[u, v] := 0 END;
RETURN done
END CanBeDone;
PROCEDURE TryNextMove ( x, y, i: INTEGER; OUT done: BOOLEAN );
VAR eos: BOOLEAN; u, v: INTEGER; k: INTEGER;
PROCEDURE Next ( OUT eos: BOOLEAN; OUT u, v: INTEGER );
BEGIN
REPEAT
INC(k);
IF k < 8 THEN u := x + dx[k]; v := y + dy[k] END;
UNTIL (k = 8) OR ((0 <= u) & (u < n) & (0 <= v) & (v < n) & (h[u, v] = 0));
eos := (k = 8)
END Next;
PROCEDURE First ( OUT eos: BOOLEAN; OUT u, v: INTEGER );
BEGIN
eos := FALSE; k := -1; Next( eos, u, v )
END First;
BEGIN
IF i < nsqr THEN
First( eos, u, v );
WHILE ~eos & ~CanBeDone( u, v, i+1 ) DO
Next( eos, u, v )
END;
done := ~eos
ELSE
done := TRUE
END;
END TryNextMove;
PROCEDURE Clear;
VAR i, j: INTEGER;
BEGIN
FOR i := 0 TO n-1 DO
FOR j := 0 TO n-1 DO h[i,j] := 0 END
END
END Clear;
PROCEDURE KnightsTour ( x0, y0: INTEGER; OUT done: BOOLEAN );
BEGIN Clear; h[x0,y0] := 1; TryNextMove( x0, y0, 1, done );
END KnightsTour;
(* конец фрагмента *******************************************)
PROCEDURE Выполнить*; (* тестирующая команда (процедура-драйвер) *)
VAR x0, y0: INTEGER; done: BOOLEAN; i, j: INTEGER;
BEGIN
In.Open; ASSERT( In.done );
In.Int( n ); ASSERT( In.done & ( n >= 1 ) );
nsqr := n*n;
In.Int( x0 ); ASSERT( In.done & ( 0 <= x0 ) & ( x0 < n ) );
In.Int( y0 ); ASSERT( In.done & ( 0 <= y0 ) & ( y0 < n ) );
NEW( h, n, n );
Clear;
KnightsTour( x0, y0, done );
Log.Bool( done ); Log.Ln;
IF done THEN
FOR i := 0 TO n-1 DO
FOR j := 0 TO n-1 DO
Log.Tab; Log.Int( h[i,j] );
END;
Log.Ln;
END;
END;
END Выполнить;
BEGIN
(* dx := (2, 1, -1, -2, -2, -1, 1, 2) *)
(* dy := (1, 2, 2, 1, -1, -2, -2, -1) *)
dx[0] := 2; dx[1] := 1; dx[2] := -1; dx[3] := -2;
dy[0] := 1; dy[1] := 2; dy[2] := 2; dy[3] := 1;
dx[4] := -2; dx[5] := -1; dx[6] := 1; dx[7] := 2;
dy[4] := -1; dy[5] := -2; dy[6] := -2; dy[7] := -1;
END ADruS34_KnightsTour.
Выделить мышкой нужную тройку чисел (размер доски, координаты стартовой позиции коня) и кликнуть по черному командиру:
ADruS34_KnightsTour.Выполнить
5 2 2 ~
5 1 3 ~
6 0 0 ~
Для форматирования таблички в рабочем журнале перед выдачей вставить «линейку» (Ctrl+J) и наставить в ней позиций табуляции, кликая мышкой в нужных местах.
Чтобы спрятать/показать линейку (вместе с серыми прямоугольниками -- это символы табуляции), нажимать Ctrl+H.
Стереть/копировать ее можно как букву.
См. модуль TextRulers, «линейки». | ADru/Mod/S34_KnightsTour.odc |
(* Общие сведения о примерах: Справка *)
(* Исправления и подготовка примеров: (С) Ф.В.Ткачев, 2009, info21 AT inr.ac.ru *)
MODULE ADruS35_Queens; (* Задача о восьми ферзях, раздел 3.5. *)
IMPORT Texts := ADruS174_Texts, Log := StdLog;
VAR x: ARRAY 8 OF INTEGER;
a: ARRAY 8 OF BOOLEAN;
b, c: ARRAY 15 OF BOOLEAN;
m: INTEGER;
VAR W: Texts.Writer;
PROCEDURE ДопПечать; (* дополнительная выдача; для выравнивания вставить руками в рабочем журнале линейку с соотв. табуляцией: *)
VAR i, j: INTEGER;
BEGIN
Log.Ln;
FOR j := 0 TO 7 DO (* строки *)
Log.Int( j );
FOR i := 0 TO 7 DO
Log.Tab;
IF x[ i ] = j THEN Log.Char('Q') ELSE Log.Char('-') END;
END;
Log.Ln
END;
FOR i := 0 TO 7 DO
Log.Tab; Log.Char( CHR( i+ORD('0') ) );
END;
Log.Ln; Log.Ln;
Texts.OpenWriter( W, Texts.log, Texts.Length( Texts.log ) );
END ДопПечать;
PROCEDURE^ CanBeDone ( i, j: INTEGER ): BOOLEAN;
(* начало фрагмента из книги, с. 151: *****************************)
PROCEDURE Try ( i: INTEGER; OUT done: BOOLEAN );
VAR eos: BOOLEAN; j: INTEGER;
PROCEDURE Next;
BEGIN
REPEAT
INC( j );
UNTIL (j = 8) OR (a[j] & b[i+j] & c[i-j+7]);
eos := (j = 8)
END Next;
PROCEDURE First;
BEGIN
eos := FALSE; j := -1; Next
END First;
BEGIN
IF i < 8 THEN
First;
WHILE ~eos & ~CanBeDone( i, j ) DO
Next
END;
done := ~eos
ELSE
done := TRUE
END
END Try;
PROCEDURE CanBeDone ( i, j: INTEGER ): BOOLEAN;
(*решение можно достроить, поставив i-го ферзя в j-ю строку*)
VAR done: BOOLEAN;
BEGIN
x[i] := j; a[j] := FALSE; b[i+j] := FALSE; c[i-j+7] := FALSE;
Try( i+1, done );
IF ~done THEN
x[i] := -1; a[j] := TRUE; b[i+j] := TRUE; c[i-j+7] := TRUE
END;
RETURN done
END CanBeDone;
PROCEDURE Queens*;
VAR done: BOOLEAN; i, j: INTEGER; (*печать в глобальный W*)
BEGIN
FOR i := 0 TO 7 DO a[ i ] := TRUE; x[ i ] := -1 END;
FOR i := 0 TO 14 DO b[ i ] := TRUE; c[ i ] := TRUE END;
Try( 0, done ); ASSERT( done );
IF done THEN
FOR i := 0 TO 7 DO Texts.WriteInt( W, x[ i ], 4 ) END;
Texts.WriteLn( W );
ДопПечать;
END;
END Queens;
(* конец фрагмента *****************************************)
(* модификация для нахождения всех решений, с. 153: **************)
PROCEDURE write;
VAR k: INTEGER;
BEGIN
FOR k := 0 TO 7 DO Texts.WriteInt( W, x[k], 4 ) END;
Texts.WriteLn( W );
ДопПечать;
END write;
PROCEDURE TryAll ( i: INTEGER );
VAR j: INTEGER;
BEGIN
IF i < 8 THEN
FOR j := 0 TO 7 DO
IF a[j] & b[i+j] & c[i-j+7] THEN
x[i] := j; a[j] := FALSE; b[i+j] := FALSE; c[i-j+7] := FALSE;
TryAll( i + 1 );
x[i] := -1; a[j] := TRUE; b[i+j] := TRUE; c[i-j+7] := TRUE
END
END
ELSE
write;
m := m+1 (*подсчет решений*)
END
END TryAll;
PROCEDURE AllQueens*;
VAR i, j: INTEGER;
BEGIN
FOR i := 0 TO 7 DO a[ i ] := TRUE; x[ i ] := -1 END;
FOR i := 0 TO 14 DO b[ i ] := TRUE; c[ i ] := TRUE END;
m := 0;
TryAll( 0 );
Log.String('всего решений: '); Log.Int( m ); Log.Ln
END AllQueens;
(* конец фрагмента ******************************************)
BEGIN
(* пусть W пишет в рабочий журнал, в конец: *)
Texts.OpenWriter( W, Texts.log, Texts.Length( Texts.log ) )
END ADruS35_Queens.
Кликнуть по соответствующему черному коммандеру для выполнения соответствующей процедуры (вся выдача идет в рабочий журнал -- Log):
ADruS35_Queens.Queens --поиск одного решения
ADruS35_Queens.AllQueens --поиск всех решений
| ADru/Mod/S35_Queens.odc |
(* Общие сведения о примерах: Справка *)
(* Исправления и подготовка примеров: (С) Ф.В.Ткачев, 2009, info21 AT inr.ac.ru *)
MODULE ADruS36_Marriages; (* Задача о стабильных браках, раздел 3.6. *)
IMPORT Texts := ADruS174_Texts, Log := StdLog, In := i21sysIn;
TYPE man = INTEGER; woman = INTEGER; rank = INTEGER;
CONST n = 8;
VAR
x: ARRAY n OF woman;
y: ARRAY n OF man;
single: ARRAY n OF BOOLEAN;
rmw, rwm: ARRAY n, n OF rank;
wmr: ARRAY n, n OF woman;
mwr: ARRAY n, n OF man;
c: INTEGER;
VAR W: Texts.Writer;
(* фрагмент из книги, с. 158: ***********************************)
PROCEDURE write; (* выдача в глобальный объект печати W *)
VAR m: man; rm, rw: INTEGER;
BEGIN
Log.String('output:'); Log.Ln;
Texts.OpenWriter( W, Texts.log, Texts.Length( Texts.log ) ); (*открыть это в MAIN *)
rm := 0; rw := 0;
FOR m := 0 TO n-1 DO
Texts.WriteInt( W, x[ m ], 4 );
rm := rmw[ m, x[ m ] ] + rm;
rw := rwm[ x[ m ], m ] + rw
END;
Texts.WriteInt( W, rm, 8 ); Texts.WriteInt( W, rw, 4 ); Texts.WriteInt( W, c, 5 ); Texts.WriteLn( W );
c := 0;
END write;
PROCEDURE stable ( m, w, r: INTEGER ): BOOLEAN;
VAR pm, pw, rank, i, lim: INTEGER; S: BOOLEAN;
BEGIN
INC( c );
i := -1; S := TRUE;
REPEAT INC(i);
IF i < r THEN
pw := wmr[m,i];
IF ~single[pw] THEN S := rwm[pw,m] > rwm[pw, y[pw]] END
END
UNTIL (i = r) OR ~S;
IF S THEN
i := -1; lim := rwm[w,m];
REPEAT INC(i);
IF i < lim THEN
pm := mwr[w,i];
IF pm < m THEN S := rmw[pm,w] > rmw[pm, x[pm]] END
END
UNTIL (i > lim) OR ~S;
END;
RETURN S
END stable;
PROCEDURE Try ( m: INTEGER );
VAR w, r: INTEGER;
BEGIN
IF m < n THEN
FOR r := 0 TO n-1 DO
w := wmr[ m, r ];
IF single[ w ] & stable( m, w, r ) THEN
x[ m ] := w;
y[ w ] := m;
single[ w ] := FALSE;
Try( m+1 );
single[ w ] := TRUE
END
END
ELSE
write
END;
END Try;
PROCEDURE FindStableMarriages*;
(* В тексте книги ввод производится из явно заданного сканера.
В данном варианте ввод производится из стандартного потока ввода в Блэкбоксе с помощью модуля In. *)
VAR m, w, r: INTEGER; k: INTEGER;
BEGIN
In.Open; ASSERT( In.done );
FOR m := 0 TO n-1 DO
FOR r := 0 TO n-1 DO In.Int( k ); ASSERT( In.done );
wmr[ m, r ] := k; rmw[ m, wmr[ m, r ] ] := r
END
END;
FOR w := 0 TO n-1 DO
single[ w ] := TRUE;
FOR r := 0 TO n-1 DO In.Int( k ); ASSERT( In.done );
mwr[ w, r ] := k; rwm[ w, mwr[ w, r ] ] := r
END
END;
Log.String('starting...'); Log.Ln; (* печать в Log для удобства контроля *)
Try( 0 );
Log.String('done.'); Log.Ln; (* печать в Log для удобства контроля *)
END FindStableMarriages;
(* конец фрагмента ******************************************)
END ADruS36_Marriages.
Кликнуть по командиру для выполнения:
ADruS36_Marriages.FindStableMarriages
6 1 5 4 0 2 7 3
3 2 1 5 7 0 6 4
2 1 3 0 7 4 6 5
2 7 3 1 4 5 6 0
7 2 3 4 5 0 6 1
7 6 4 1 3 2 0 5
1 3 5 2 0 6 4 7
5 0 3 1 6 4 2 7
3 5 1 4 7 0 2 6
7 4 2 0 5 6 3 1
5 7 0 1 2 3 6 4
2 1 3 6 5 7 4 0
5 2 0 3 4 6 1 7
1 0 2 7 6 3 5 4
2 4 6 1 3 0 7 5
6 1 7 3 4 5 2 0
| ADru/Mod/S36_Marriages.odc |
(* Общие сведения о примерах: Справка *)
(* Исправления и подготовка примеров: (С) Ф.В.Ткачев, 2009, info21 AT inr.ac.ru *)
MODULE ADruS37_OptSelection; (* Задача об оптимальном выборе, раздел 3.7. *)
IMPORT Log := StdLog, In := i21sysIn, Math;
CONST n = 10;
(* фрагмент из текста, с. 163: ***********************************)
TYPE Object = RECORD value, weight: INTEGER END;
VAR a: ARRAY n OF Object;
limw, totv, maxv: INTEGER;
s, opts: SET;
PROCEDURE LogResult; (* процедура добавлена для печати результатов *)
VAR i: INTEGER;
BEGIN
FOR i := 0 TO n - 1 DO
Log.Tab;
IF i IN opts THEN Log.Char('*') END;
END;
Log.Tab; Log.Int( maxv ); Log.Ln
END LogResult;
PROCEDURE Try ( i, tw, av: INTEGER ); (* более чистая обработка окончания по сравнению с вариантом в книге *)
VAR tw1, av1: INTEGER;
BEGIN
IF i = n THEN
ASSERT( tw <= limw );
(* av = ценность s *)
IF av > maxv THEN
maxv := av; opts := s
END
ELSE
(*проверка включения*)
tw1 := tw + a[ i ].weight;
IF tw1 <= limw THEN
s := s + { i };
Try( i+1, tw1, av );
s := s - { i }
END;
(*проверка исключения*)
av1 := av - a[ i ].value;
IF av1 > maxv THEN
Try( i+1, tw, av1 )
END
END;
END Try;
PROCEDURE Selection ( weightInc, weightLimit: INTEGER );
VAR i: INTEGER;
BEGIN
limw := 0;
REPEAT
limw := limw + weightInc;
s := {}; opts := {}; maxv := 0;
Try( 0, 0, totv );
LogResult;
UNTIL limw >= weightLimit
END Selection;
(* конец фрагмента *******************************************)
PROCEDURE Do*; (* команда для вызова *)
VAR i, x: INTEGER;
BEGIN
In.Open; ASSERT( In.done );
FOR i := 0 TO n - 1 DO
In.Int( x ); ASSERT( In.done );
a[ i ].weight := x;
END;
totv := 0;
FOR i := 0 TO n - 1 DO
In.Int( x ); ASSERT( In.done );
a[ i ].value := x;
totv := totv + x
END;
Selection( 10, 120 )
END Do;
END ADruS37_OptSelection.
Для вызова кликнуть по черному командиру:
ADruS37_OptSelection.Do
10 11 12 13 14 15 16 17 18 19
18 20 17 19 25 21 27 23 25 24
Для форматирования таблички в рабочем журнале перед выдачей вставить линейку (Ctrl+J) и наставить в ней позиций табуляции, кликая мышкой в нужных местах.
Чтобы спрятать/показать линейку (вместе с серыми прямоугольниками -- это символы табуляции), нажимать Ctrl+H.
Стереть/копировать ее можно как букву.
См. модуль TextRulers, «линейки», .
| ADru/Mod/S37_OptSelection.odc |
(* Общие сведения о примерах: Справка *)
(* Исправления и подготовка примеров: (С) Ф.В.Ткачев, 2009, info21 AT inr.ac.ru *)
MODULE ADruS432_List; (* Простейшая процедура поиска с включением в линейный список (алфавитный частотный словарь), раздел 4.3.2. *)
IMPORT Log := StdLog, In := i21sysIn, Math, Texts := ADruS174_Texts;
(* фрагмент из текста, с. 180: **********************)
TYPE
Word = POINTER TO RECORD
key, count: INTEGER; next: Word
END;
VAR W: Texts.Writer; root: Word;
PROCEDURE search ( x: INTEGER; VAR root: Word );
VAR w: Word;
BEGIN
w := root;
WHILE (w # NIL) & (w.key # x) DO w := w.next END;
(* (w = NIL) OR (w.key = x) *)
IF w = NIL THEN (* новый элемент *)
w := root;
NEW( root ); root.key := x; root.count := 1; root.next := w
ELSE
INC( w.count )
END
END search;
PROCEDURE PrintList ( w: Word );
BEGIN
(* используется глобальный объект записи W *)
(* простой проход по списку: *)
WHILE w # NIL DO
Texts.WriteInt( W, w.key, 8 ); Texts.WriteInt( W, w.count, 8 );
Texts.WriteLn( W );
w := w.next
END
END PrintList;
(* конец фрагмента ********************************)
PROCEDURE Do*;
VAR n: INTEGER;
BEGIN
Texts.OpenWriter( W, Texts.log, Texts.Length( Texts.log ) );
(* читаем и обрабатываем поток чисел: *)
In.Open; ASSERT( In.done );
In.Int( n );
WHILE In.done DO
search( n, root );
In.Int( n )
END;
PrintList( root );
END Do;
END ADruS432_List.
ADruS432_List.Do 4 6 6 9 2 4 1 1 1 0 1 0 1
| ADru/Mod/S432_List.odc |
(* Общие сведения о примерах: Справка *)
(* Исправления и подготовка примеров: (С) Ф.В.Ткачев, 2009, info21 AT inr.ac.ru *)
MODULE ADruS432_List2; (* Процедура поиска с включением в линейный список, вариант с использованием барьера, раздел 4.3.2.
Модификации по сравнению с простейшим вариантом показаны красным. *)
IMPORT Log := StdLog, In := i21sysIn, Math, Texts := ADruS174_Texts;
TYPE
Word = POINTER TO RECORD
key, count: INTEGER; next: Word
END;
VAR W: Texts.Writer; root, sentinel: Word;
(* фрагмент из книги, с. 180: ******************************)
PROCEDURE search ( x: INTEGER; VAR root: Word );
VAR w: Word;
BEGIN
w := root; sentinel.key := x;
WHILE w.key # x DO w := w.next END;
(* (w = NIL) OR (w.key = x) *)
IF w = sentinel THEN (* новый элемент *)
w := root;
NEW( root ); root.key := x; root.count := 1; root.next := w
ELSE
INC( w.count )
END
END search;
(* конец фрагмента **************************************)
PROCEDURE PrintList ( w: Word );
BEGIN
(* используется глобальный объект записи W *)
(* простой проход по списку: *)
WHILE w # sentinel DO
Texts.WriteInt( W, w.key, 8 ); Texts.WriteInt( W, w.count, 8 );
Texts.WriteLn( W );
w := w.next
END
END PrintList;
PROCEDURE Do*;
VAR n: INTEGER;
BEGIN
NEW( sentinel ); root := sentinel;
Texts.OpenWriter( W, Texts.log, Texts.Length( Texts.log ) );
(* читаем и обрабатываем поток чисел: *)
In.Open; ASSERT( In.done );
In.Int( n );
WHILE In.done DO
search( n, root );
In.Int( n )
END;
PrintList( root );
END Do;
END ADruS432_List2.
ADruS432_List2.Do 4 6 6 9 2 4 1 1 1 0 1 0 1
| ADru/Mod/S432_List2.odc |
(* Общие сведения о примерах: Справка *)
(* Исправления и подготовка примеров: (С) Ф.В.Ткачев, 2009, info21 AT inr.ac.ru *)
MODULE ADruS432_List3; (* Процедура поиска с включением в упорядоченный линейный список, раздел 4.3.2. *)
IMPORT Log := StdLog, In := i21sysIn, Math, Texts := ADruS174_Texts;
TYPE
Word = POINTER TO RECORD
key, count: INTEGER; next: Word
END;
VAR W: Texts.Writer; root: Word;
(* фрагмент из книги, с. 182: **********************************)
PROCEDURE search ( x: INTEGER; VAR root: Word );
VAR w1, w2, w3: Word;
BEGIN
w2 := root; w1 := w2.next;
WHILE (w1 # NIL) & (w1.key < x) DO
w2 := w1; w1 := w2.next
END;
(* (w1 = NIL) OR (w1.key >= x) *)
IF (w1 = NIL) OR (w1.key > x) THEN (* новый элемент *)
NEW( w3 ); w2.next := w3;
w3.key := x; w3.count := 1; w3.next := w1
ELSE
INC( w1.count )
END
END search;
(* конец фрагмента ******************************************)
PROCEDURE PrintList ( w: Word );
BEGIN
(* используется глобальный объект записи W *)
(* простой проход по списку: *)
WHILE w # NIL DO
Texts.WriteInt( W, w.key, 8 ); Texts.WriteInt( W, w.count, 8 );
Texts.WriteLn( W );
w := w.next
END
END PrintList;
PROCEDURE Do*;
VAR n: INTEGER;
BEGIN
NEW( root ); root.next := NIL;
Texts.OpenWriter( W, Texts.log, Texts.Length( Texts.log ) );
(* читаем и обрабатываем поток чисел: *)
In.Open; ASSERT( In.done );
In.Int( n );
WHILE In.done DO
search( n, root );
In.Int( n )
END;
PrintList( root.next );
END Do;
END ADruS432_List3.
ADruS432_List3.Do 4 6 6 9 2 4 1 1 1 0 1 0 1
| ADru/Mod/S432_List3.odc |
(* Общие сведения о примерах: Справка *)
(* Исправления и подготовка примеров: (С) Ф.В.Ткачев, 2009, info21 AT inr.ac.ru *)
MODULE ADruS432_List4; (* Процедура поиска с включением в линейный список с переупорядочением, раздел 4.3.2. *)
IMPORT Log := StdLog, In := i21sysIn, Math, Texts := ADruS174_Texts;
TYPE
Word = POINTER TO RECORD
key, count: INTEGER; next: Word
END;
VAR W: Texts.Writer; root, sentinel: Word;
(* фрагмент из книги, с. 183: **********************************)
PROCEDURE search ( x: INTEGER; VAR root: Word );
VAR w1, w2: Word;
BEGIN
w1 := root; sentinel.key := x;
IF w1 = sentinel THEN (* первый элемент *)
NEW( root ); root.key := x; root.count := 1; root.next := sentinel
ELSIF w1.key = x THEN
INC( w1.count )
ELSE (* поиск *)
REPEAT w2 := w1; w1 := w2.next
UNTIL w1.key = x;
IF w1 = sentinel THEN (* новый элемент *)
w2 := root;
NEW( root ); root.key := x; root.count := 1; root.next := w2
ELSE (* нашли, переупорядочиваем *)
INC( w1.count );
w2.next := w1.next; w1.next := root; root := w1
END
END
END search; (* конец фрагмента *******************************************)
PROCEDURE PrintList ( w: Word );
BEGIN
(* используется глобальный объект записи W *)
(* простой проход по списку: *)
WHILE w # sentinel DO
Texts.WriteInt( W, w.key, 8 ); Texts.WriteInt( W, w.count, 8 );
Texts.WriteLn( W );
w := w.next
END
END PrintList;
PROCEDURE Do*;
VAR n: INTEGER;
BEGIN
NEW( sentinel ); root := sentinel;
Texts.OpenWriter( W, Texts.log, Texts.Length( Texts.log ) );
(* читаем и обрабатываем поток чисел: *)
In.Open; ASSERT( In.done );
In.Int( n );
WHILE In.done DO
search( n, root );
In.Int( n )
END;
PrintList( root );
END Do;
END ADruS432_List4.
ADruS432_List4.Do 4 6 6 9 2 4 1 1 1 0 1 0 1
| ADru/Mod/S432_List4.odc |
(* Общие сведения о примерах: Справка *)
(* Исправления и подготовка примеров: (С) Ф.В.Ткачев, 2009, info21 AT inr.ac.ru *)
MODULE ADruS433_TopSort; (* Топологическая сортировка, раздел 4.3.3. *)
IMPORT Log := StdLog, In := i21sysIn, Texts := ADruS174_Texts;
TYPE (* определения типов, с. 187 *******************)
Leader = POINTER TO LeaderDesc;
Trailer = POINTER TO TrailerDesc;
LeaderDesc = RECORD
key, count: INTEGER;
trail: Trailer;
next: Leader
END;
TrailerDesc = RECORD
id: Leader;
next: Trailer
END;
VAR W: Texts.Writer;
(* фрагмент из книги, с. 189: **********************************)
VAR head, tail: Leader; n: INTEGER;
PROCEDURE find ( w: INTEGER ): Leader;
VAR h: Leader;
BEGIN
h := head; tail.key := w; (* барьер *)
WHILE h.key # w DO h := h.next END;
IF h = tail THEN
NEW( tail ); INC( n );
h.count := 0; h.trail := NIL; h.next := tail
END;
RETURN h
END find;
PROCEDURE TopSort ( VAR S: Texts.Scanner );
VAR p, q: Leader; t: Trailer; (* используется глобальный объект записи W *)
x, y: INTEGER;
BEGIN
(* инициализировать список ведущих фиктивным элементом-барьером *)
NEW( head ); tail := head; n := 0;
(* фаза ввода *)
Texts.Scan( S );
WHILE S.class = Texts.Int DO
x := S.i; Texts.Scan( S ); y := S.i; p := find( x ); q := find( y );
NEW(t); t.id := q; t.next := p.trail;
p.trail := t; INC( q.count ); Texts.Scan( S )
END;
(* поиск ведущих без предшественников *)
p := head; head := NIL;
WHILE p # tail DO
q := p; p := q.next;
IF q.count = 0 THEN (* включить q в новую цепочку *)
q.next := head; head := q
END
END;
(* фаза вывода *)
q := head;
WHILE q # NIL DO
Texts.WriteLn( W ); Texts.WriteInt( W, q.key, 8 ); DEC( n );
t := q.trail; q := q.next;
WHILE t # NIL DO
p := t.id; DEC( p.count );
IF p.count = 0 THEN (* включить p в список ведущих *)
p.next := q; q := p
END;
t := t.next
END
END;
IF n # 0 THEN
Texts.WriteString( W, "Набор не является частично упорядоченным" )
END;
Texts.WriteLn( W )
END TopSort;
(* конец фрагмента **********************************)
PROCEDURE Do*;
VAR S: Texts.Scanner;
BEGIN
Texts.OpenInput;
Texts.OpenWriter( W, Texts.log, Texts.Length( Texts.log ) );
Texts.WriteString( W, 'TopSort' ); Texts.WriteLn( W );
Texts.OpenScanner( S, Texts.input, 0 ); (* читается тот же текст, что и при In.Open *)
TopSort( S );
END Do;
END ADruS433_TopSort.
ADruS433_TopSort.Do 1 2 2 4 4 6 2 10 4 8 6 3 1 3
3 5 5 8 7 5 7 9 9 4 9 10
| ADru/Mod/S433_TopSort.odc |
(* Общие сведения о примерах: Справка *)
(* Исправления и подготовка примеров: (С) Ф.В.Ткачев, 2009, info21 AT inr.ac.ru *)
MODULE ADruS441_BalancedTree; (* Построение идеально сбалансированного дерева, раздел 4.4.1. *)
IMPORT Log := StdLog, In := i21sysIn, Texts := ADruS174_Texts;
(* фрагмент из книги, с. 196: ******************************)
TYPE
Node = POINTER TO RECORD
key: INTEGER;
left, right: Node
END;
VAR R: Texts.Reader; W: Texts.Writer; root: Node;
PROCEDURE Tree ( n: INTEGER ): Node;
VAR new: Node;
x, nl, nr: INTEGER;
BEGIN
(* построить идеально сбалансированное дерево с n узлами *)
IF n = 0 THEN
new := NIL
ELSE
nl := n DIV 2; nr := n-nl-1;
NEW( new ); Texts.ReadInt( R, x );
new.key := x; new.left := Tree( nl ); new.right := Tree( nr )
END;
RETURN new
END Tree;
PROCEDURE PrintTree ( t: Node; h: INTEGER );
VAR i: INTEGER;
BEGIN
(* распечатать дерево t с h отступами *)
IF t # NIL THEN
PrintTree( t.left, h+1 );
FOR i := 1 TO h DO Texts.WriteTab( W ) END;
Texts.WriteInt( W, t.key, 3 ); Texts.WriteLn( W );
PrintTree( t.right, h+1 )
END
END PrintTree;
(* конец фрагмента **************************************)
PROCEDURE Do*;
VAR root: Node;
BEGIN
(* приготовление ввода-вывода: *)
Texts.OpenWriter( W, Texts.log, Texts.Length( Texts.log ) );
(* будем читать из входного потока после командира
(точнее, из потока, определяемого по правилам i21sysIn) *)
Texts.OpenInput; Texts.OpenReader( R, Texts.input, 0 );
(* собственно вычисления: *)
root := Tree( 21 );
PrintTree( root, 0 );
END Do;
END ADruS441_BalancedTree.
ADruS441_BalancedTree.Do 8 9 11 15 19 20 21 7 3 2 1 5 6 4 13 14 10 12 17 16 18
| ADru/Mod/S441_BalancedTree.odc |
End of preview. Expand
in Dataset Viewer.
Dataset created from BlackBox system for BlackBox system and Component Pascal language copilot.
- Downloads last month
- 10