2 Программирование в системе Scilab

ФЕДЕРАЛЬНОЕ ГОСУДАРСТВЕННОЕ БЮДЖЕТНОЕ ОБРАЗОВАТЕЛЬНОЕ УЧРЕЖДЕНИЕ
ВЫСШЕГО ПРОФЕССИОНАЛЬНОГО ОБРАЗОВАНИЯ
«МОРДОВСКИЙ ГОСУДАРСТВЕННЫЙ ПЕДАГОГИЧЕСКИЙ
ИНСТИТУТ ИМЕНИ М.Е.ЕВСЕВЬЕВА»
ФИЗИКО-МАТЕМАТИЧЕСКИЙ ФАКУЛЬТЕТ
КАФЕДРА ИНФОРМАТИКИ И ВЫЧИСЛИТЕЛЬНОЙ ТЕХНИКИ
КУРСОВАЯ РАБОТА
по информатике
Программирование в системах Scilab и Maxima
Автор курсовой работы: И.Р. Исхакова, студент IV курса группы МДИ-110
очной формы обучения.
Специальность: 050202 «Информатика» с дополнительной специальностью
050201.65 «Математика»
Руководитель: Т.В. Кормилицына, кандидат физико-математических наук, доцент
Саранск 2014
2
Содержание
Введение ....................................................................................................................... 4
1 Программирование в системе Maxima ................................................................... 6
1.1Программирование базовых алгоритмических структур ............................... 6
1.2Дополнительные возможности для пользователя ......................................... 13
2 Программирование в системе Scilab .................................................................... 20
2.1 Средства программирования условных конструкций и циклов ................. 20
2.2 Программирование функций пользователя................................................... 24
Заключение ................................................................................................................ 32
Список использованных источников ...................................................................... 34
3
Введение
В данной курсовой будут рассматриваться вопросы программирования в
системах компьютерной алгебры Maxima и Scilab.
Актуальность темы состоит в том, что линия алгоритмизации программирования реализуется в школьном курсе в недостаточном объеме. Обычно в
школах изучают алгоритмические языки высокого уровня, а на примере мощных систем Maxima и Scilab можно показать важность программирования непосредственно для пользователей, так как разработчики этих систем сочли необходимым оставить инструменты программирования пользователям для реализации всех базовых алгоритмов. Эти системы предоставляются для свободного
использования в сфере образования, что делает их привлекательными для применения в образовательных учреждениях.
Scilab – это кроссплатформенная система компьютерной алгебры (СКА),
обладающая сходным с Matlab синтаксисом встроенного языка. Разработка системы Scilab ведется сотрудниками французского Национального института
информатики и автоматизации (INRIA – Institut National de Recherche en
Informatique et Automatique) с 80-х годов прошлого века.
Изначально это был коммерческий проект под названием Blaise, а затем
Basile. С 2003 года продукт получил новое имя Scilab и стал бесплатным. В
настоящее время он распространяется по свободной лицензии CeCILL.
Сама система Scilab, как и Matlab, предназначена прежде всего для численных расчетов и работы с матрицами. Кроме того, она обладает развитыми
средствами программирования (включая отладчик скриптов), так что ее в какой-то мере можно рассматривать как систему разработки высокотехнологичных приложений.
Для системы имеется достаточно большое число пакетов расширений, которые можно найти на официальном сайте в разделе Toolbox center. Однако,
чем больше будет хороших пакетов, тем более полезной станет система.
4
Maxima – свободная система компьютерной алгебры, написанная на языке Common Lisp.
Maxima
произошла
от
системы
Macsyma,
разрабатывавшейся
в MIT с 1968 по 1982 годы в рамках проекта Project MAC, финансируемого
Министерством энергетики США (DOE) и другими государственными организациями. Профессор Уильям Шелтер (англ. William F. Schelter) из Техасского
университета в Остине поддерживал один из вариантов системы, известный
как DOE Macsyma, с 1982 года до самой своей смерти в 2001 году.
В 1998 году Шелтер получил от Министерства энергетики разрешение
опубликовать исходный код DOE Macsyma под лицензией GPL, и в 2000 году он создал проект на SourceForge.net для поддержания и дальнейшего развития DOE Macsyma под именем Maxima.
Maxima имеет широчайший набор средств для проведения аналитических
вычислений, численных вычислений и построения графиков. По набору возможностей
система
близка
к
таким
коммерческим
системам
как Maple и Mathematica. В то же время она обладает высочайшей степенью переносимости: она может работать на всех основных современных операционных системах на компьютерах, начиная от наладонных компьютеров, вплоть до самых мощных.
Цель работы: исследование возможностей программирования в системах
Scilab и Maxima и реализация основных видов алгоритмов.
Объект исследования: системы Scilab и Maxima.
Предмет исследования: возможности и инструменты программирования
в системах Scilab и Maxima.
Методы исследования: анализ и синтез, методы сравнения и обобщения,
метод классификации, расчетный метод, эксперимент.
5
1 Программирование в системе Maxima
1.1Программирование базовых алгоритмических структур
Основная форма условного оператора: if cond1 then expr1 else expr0. Если
условие cond1 истинно, то выполняется выражение expr1, иначе – выполняется
выражение expr2. Пакет Maxima позволяет использовать различные формы оператора if, например: if cond1 then expr1 elseif cond2 then expr2 elseif ...else expr0.
Если выполняется условие cond1, то выполняется выражение expr1, иначе – проверяется условие cond2, и если оно истинно – выполняется выражение expr2, и
т.д. Если ни одно из условий не является истинным – выполняется выражение
expr0. Альтернативные выражения expr1, expr2,... ,exprk – произвольные выражения Maxima (в т.ч. вложенные операторы if). Условия – действительно или потенциально логические выражения, сводимые к значениям true или false. Способ интерпретации условий зависит от значения флага prederror. Если prederror
= true, выдаётся ошибка, если значения какого-либо из выражений cond1,...
,condn отличается от true или false. Если prederror = false и значения какого-либо
из выражений cond1,... ,condn отличается от true или false, результат вычисления
if – условное выражение.[3, c. 207]
Для выполнения итераций используется оператор textttdo. Могут использоваться три варианта его вызова, отличающиеся условием окончания цикла:
for variable: init_value step increment thru limit do body
for variable: init_value step increment while condition do body
for variable: init_value step increment unless condition do body
Здесь variable – переменная цикла; init_value – начальное значение;
increment – шаг (по умолчанию равен 1); limit – конечное значение переменной
цикла; body – операторы тела цикла. Ключевые слова thru, while, unless указывают на способ завершения цикла:
по достижении переменной цикла значения limit;
пока выполняется условие condition;
пока не будет достигнуто условие condition.
6
Параметры init_value, increment, limit, и body могут быть произвольными
выражениями. Контрольная переменная по завершении цикла предполагается
положительной (при этом начальное значение может быть и отрицательным).
Выражения limit, increment, условия завершения (condition) вычисляются на
каждом шаге цикла, поэтому их сложность влияет на время выполнения цикла.
При нормальном завершении цикла возвращаемая величина – атом done. Принудительный выход из цикла осуществляется при помощи оператора return, который может возвращать произвольное значение. [7, c. 35]
Контрольная переменная цикла – локальная внутри цикла, поэтому её изменение в цикле не влияет на контекст (даже при наличии вне цикла переменной с тем же именем).
Примеры реализации циклов (рис. 1–2).
Рисунок 1. – Арифметический цикл.
7
Рисунок 2. – Арифметический цикл.
Условия инициализации и завершения цикла можно опускать.
Пример (цикл без явного указания переменной цикла на примере вычисления
) (рис. 3):
Рисунок 3. – Цикл без явного указания переменной цикла.
Из вычислительного эксперимента видно, что за 20 итераций достигается
точное значение с точностью до 14 десятичных знаков.
8
Несколько более изощрённый пример – реализация метода Ньютона для
уравнения с одной неизвестной (вычисляется та же величина – корень из пяти):
(при сравнении с предыдущим результатам достигается точность до 5 десятичных знаков) (рис. 4):
Рисунок 4. – Реализация метода Ньютона для уравнения с одной неизвестной
Ещё одна форма оператора цикла характеризуется выбором значений переменной цикла из заданного списка. Синтаксис вызова: for variable in list
end_tests do body. Проверка условия завершения end_tests до исчерпания списка
list может отсутствовать (рис. 5).
Пример:
Рисунок 5. – Цикл с заданными значениями переменных из заданного списка.
Как в условных выражениях, так и в циклах вместо простых операторов
можно писать составные операторы, т.е. блоки. Стандартный блок имеет вид:
block ([r, s, t], r:1, s:r+1, t:s+1, x:t, t*t); сначала идет список локальных переменных блока (глобальные переменные с теми же именами никак не связаны с эти9
ми локальными переменными). Список локальных переменных может быть пустым. Далее идет набор операторов. Упрощенный блок имеет вид: (x:1, x: x+2,
a: x).
Обычно в циклах и в условных выражениях применяют именно эту форму блока. Значением блока является значение последнего из его операторов.
Внутри данного блока допускаются оператор перехода на метку и оператор
return. Оператор return прекращает выполнение текущего блока и возвращает в
качестве значения блока свой аргумент block([], x:2, x: x*x, return(x), x: x*x);
В отсутствие оператора перехода на метку, операторы в блоке выполняются последовательно. (В данном случае слово «метка» означает отнюдь не
метку типа «%i5» или «%o7»). Оператор go выполняет переход на метку metka,
расположенную в этом же блоке (рис. 6):
Рисунок 6. – Цикл, содержащий блок с меткой metka.
В этом блоке реализован цикл, который завершается по достижении «переменной цикла» значения 1001. Меткой может быть произвольный идентификатор [3, c. 215].
Следует иметь в виду, что цикл сам по себе является блоком, так что (в
отличие от языка C) прервать выполнение циклов (особенно вложенных циклов) с помощью оператора go невозможно, т.к. оператор go и метка окажутся в
разных блоках. То же самое относится к оператору return. Если цикл, расположенный внутри блока, содержит оператор return, то при исполнении оператора
return произойдет выход из цикла, но не выход из блока (рис. 7):
10
Рисунок 7. – Цикл с оператором return.
Если необходимо выйти из нескольких вложенных блоков сразу (или нескольких блоков и циклов сразу) и при этом возвратить некоторое значение, то
следует применять блок (рис. 8):
Рисунок 8. – Пример блока catch.
В данном блоке выполнение цикла завершается, как только значение i достигает 2. Возвращаемое блоком catch значение равно 555.
11
В данном блоке цикл выполняется полностью, и возвращаемое блоком
catch значение равно 777 (условия выхода из цикла при помощи throw не достигаются) [5].
Рисунок 9. – Пример блока catch с полным выполнением цикла.
Оператор throw – аналог оператора return, но он обрывает не текущий
блок, а все вложенные блоки вплоть до первого встретившегося блока catch.
Наконец, блок errcatch позволяет перехватывать некоторые (к сожалению, не
все!) из ошибок, которые в нормальной ситуации привели бы к завершению
счета (рис. 10).
Пример:
Рисунок 10. – Пример блока errcatch.
Выполнение последовательности операций прерывается на первой операции, приводящей к ошибке. Остальные выражения блока не выполняются (значение c остаётся неопределённым). Сообщение об возникшей ошибке может
быть выведено функцией errormsg () [6].
12
1.2 Дополнительные возможности для пользователя
Наряду с простейшим способом задания функции, Maxima допускает создание функции в виде последовательности операторов:
f(x):= (expr1, expr2, ..., exprn);
Значение, возвращаемое функцией – значение последнего выражения exprn. Чтобы использовать оператор return и изменять возвращаемое значение в
зависимости от логики работы функции, следует применять конструкцию block,
например: f(x)=block ([], expr1, ..., if (a> 10) then return(a), ..., exprn). При a> 10
выполняется оператор return и функция возвращает значение a, в противном
случае – значение выражения exprn.
Формальные параметры функции или блока – локальные, и являются видимыми только внутри них. Кроме того, при задании функции можно объявить
локальные переменные (в квадратных скобках в начале объявления функции
или блока) [4].
Пример:
block ([a: a], expr1, ..., a: a+3, ..., exprn)
В данном случае при объявлении блока в локальной переменной a сохраняется значение глобальной переменной a, определённой извне блока.
13
Пример:
Рисунок 10. – Задание переменной вне тела функции.
В данном примере значение переменной a задаётся вне тела функции, но
результат, возвращаемый ею, зависит от значения a (рис. 10). Начальные значения локальных переменных функции могут задаваться двумя способами:
1) Задание функции f(x): = (expr1, exprn); вызов функции f(1); – начальное значение локальной переменной x равно 1.
2) Задание блока block ([x: 1], expr1, ..., exprn), при этом начальное значение локальной переменной x также равно 1 [7, c. 50].
Наряду с именованными функциями, Maxima позволяет использовать и
безымянные функции (лямбда-функции). Синтаксис использования лямбда-
14
выражений (правда, при использовании с лямбда-выражениями всё-таки ассоциируется имя – см. пример):
f1: lambda ([x1,... ,xm],expr1,... , exprn)
f2: lambda ([[L]], expr1,... , exprn)
f3: lambda ([x1,... ,xm, [L]],expr1,... , exprn)
Пример:
(%i1) f: lambda ([x], x^2);
(%o1)
lambda ([x], x2)
(%i2) f(a);
(%o2) a2
Более сложный пример (лямбда-выражения могут использоваться в контексте, когда ожидается имя функции):
(%i3) lambda ([x], x^2) (a);
(%o3)
a2
(%i4) apply (lambda ([x], x^2), [a]);
(%o4)
a2
(%i5) map (lambda ([x], x^2), [a, b, c, d, e]);
(%o5) [a2,b2,c2,d2,e2]
Аргументы лямбда-выражений – локальные переменные. Другие переменные при вычислении лямбда-выражений рассматриваются как глобальные.
Исключения отмечаются специальным символом – прямыми кавычками (см.
лямбда-функцию g2 в примере).
(%i6) a: %pi$ b: %e$ g: lambda ([a], a*b);
(%o8) lambda ([a],ab)
(%i9) b: %gamma$ g(1/2);
(%o10) γ/2
(%i11) g2: lambda ([a], a*”b);
(%o11) lambda ([a],aγ)
(%i12) b: %e$ g2 (1/2);
(%o13) γ/2
15
Лямбда-функции могут быть вложенными. При этом локальные переменные внешнего выражения доступны как глобальные для внутреннего (одинаковые имена переменных маскируются) (рис. 11).
Пример:
Рисунок 11. – Пример вложенной лямбда-функции.
Подобно обычным функциям, лямбда-функции могут иметь список параметров переменной длины.
Пример:
(%i1) f: lambda ([aa, bb, [cc]], aa * cc + bb);
(%o1) lambda ([aa,bb, [cc]],aacc + bb)
(%i2) f (3,2, a,b,c);
(%o2) [3 a + 2,3b + 2,3c + 2]
Список [cc] при вызове лямбда-функции f включает три элемента: [a,b,c].
Формула для расчёта f применяется к каждому элементу списка. Локальные переменные могут быть объявлены и посредством функции local (переменные
v1,v2,... ,vn объявляются локальными вызовом local(v1,v2,... ,vn) независимо от
контекста) [3, c. 230].
Определив ту или иную функцию, можно заметно ускорить ее выполнение, если ее оттранслировать или откомпилировать. Это происходит потому,
что если не оттранслировать и не откомпилировать определенную функцию, то
при каждом очередном ее вызове Maxima каждый раз будет заново выполняет
16
те действия, которые входят в определение функции, т.е. фактически разбирает
соответствующее выражение на уровне синтаксиса Maxima.
Функция translate транслирует функцию Maxima на язык Lisp. Например,
выражение: f(x) := 1+x+ x2+x3+x4+x5+x6+x7 транслируется командой: translate(f);.
После этого функция, как правило, начинает вычисляться быстрее.
Пример, иллюстрирующий выигрыш по времени после трансляции функции:
(%i1) f (n):=block ([sum,k],sum:0, for k:1 thru n do (sum:sum+k^2),sum)$
Функция f(n), организованная в виде блока, позволяет вычислить сумму.
При непосредственном обращении к функции f время вычисления
f(1000000) составило 7,86 с., после трансляции – 3,19 с. Для оценки времени
вычисления использована функция time [3, с. 19].
(%i2) f(1000000);
(%o2) 333333833333500000
(%i3) time(%o2);
(%o3) [7.86]
(%i4) translate(f);
(%o4) [f]
(%i5) f(1000000);
(%o5) 333333833333500000
(%i6) time(%o5);
(%o6)
Функция time (%o1, %o2,...) возвращает список периодов времени в секундах, израсходованных для вычисления результатов %o1, %o2,... Аргументом
функции time могут быть только номера строк вывода, для любых других переменных функция возвращает значение unknown.
17
Функция compile сначала транслирует функцию Maxima на язык Lisp, а
затем компилирует эту функцию Lisp до двоичных кодов и загружает их в память.
Пример:
(%i9) compile (f);
Compiling /tmp/gazonk_1636_0.lsp.
End of Pass 1.
End of Pass 2.
OPTIMIZE levels: Safety=2,
Space=3, Speed=3
Finished compiling /tmp/gazonk_1636_0.lsp.
(%o92) [f]
После этого функция (как правило) начинает считаться еще быстрее, чем
после трансляции. Например, после компиляции функции f из последнего примера время вычисления f(1000000) составило 2,17 с. Следует иметь в виду, что
как при трансляции, так и при компиляции Maxima старается оптимизировать
функцию по скорости. Однако Maxima работает преимущественно с целыми
числами произвольной длины либо текстовыми выражениями. Поэтому при работе с большими по объёму функциями могут возникнуть проблемы, связанные
с преобразованием типов данных. В этом случае следует отказаться от трансляции или компиляции, либо переписать функцию, упорядочив использование
типов [5].
Пример: рассмотрим две функции, вычисляющие одно и то же выражение. В функции f2 явно указано, что функция возвращает действительные значения (в формате с плавающей точкой):
f1(x,n):=block([sum,k], sum:1,
for k:1 thru n do (sum:sum+1/x^k),sum)$
f2(x,n):=block([sum,k],
mode_declare ([function (f2),x], float),
sum:1, for k:1 thru n do (sum:sum+1/x^k),sum)$
18
Время выполнения функции f1 при запуске f1(5,10000) составило 1,8 с.
После компиляции время выполнения составило 1,49 с., после трансляции –
1,39 с. Попытка обратиться к откомпилированной функции f1 командой
f1(5.0,10000.0) завершилась неудачей вследствие возникающей ошибки (плавающее переполнение). При использовании функции с декларированным типом
результата (f2) время выполнения f2(5,10000) оказалось меньше, чем f1(1,65 с.
вместо 1,8 с.). Однако время выполнения той же функции после трансляции или
компиляции превышает 10 с. Следует учесть, в данном случае результат расчёта – рациональное число. Преобразование его к форме с плавающей точкой при
вычислении очередного значения суммы требует дополнительных вычислительных затрат. При обращении к f2 с действительными аргументами
f2(5.0,10000.0) время счёта составило всего 0,16 с. Для функции, возвращающей результат, который представляется в виде числа с плавающей точкой, компиляция или трансляция может дать уменьшение времени счёта в несколько
раз.
Пример: рассмотрим функцию, вычисляющую действительное выражение (в данном случае суммируются иррациональные числа):
f3(x,n):=block([sum,k],
mode_declare ([function (f3),x], float),
sum:1, for k:1 thru n do (sum:sum+sqrt(x^k)),sum)$
Время вычисления выражения f3(5,2000) для не откомпилированной и не
оттранслированной функции составило 7,47 с., после трансляции время вычисления f3(5,2000) составило 0,03 с., после компиляции – 0,02 с.
Рассмотрим ещё один пример:
f4(x,n):=block([sum,k], sum:1,
for k:1 thru n do (sum:sum+k/x),sum)$
Время вычисления выражения f4(5,1000000) составило 10,89 с., время
вычисления выражения f4(5.0,1000000) составило 6,71 с. После трансляции f4
время вычисления выражения f4(5,1000000) составило 9,1 с. (выигрыш по времени практически отсутствует), а для f4(5.0,1000000) – 2,49 с. (выигрыш по
19
времени за счёт выполнения вычислений с плавающей точкой примерно в 2,5
раза) [6].
2 Программирование в системе Scilab
2.1 Средства программирования условных конструкций и циклов
Средства программирования (Tools): циклы, условные конструкции. В
условных конструкциях и циклах используются следующие операторы сравнения:
== равно
< меньше чем
> больше чем
<= меньше или равно чем
>= больше или равно чем
<> или = не равно
Определены следующие типы циклов:
for
while
1) Цикл for
Синтаксис
for variable=n1:step:n2,<тело цикла>,end
В качестве индекса цикла могут выступать переменные различных типов
(вектора, списки и др.).
Замечание: Если шаг цикла step=1, его можно не писать: x=1; for
k=1:4,x=x*k, end эквивалентно x=1;for k=1:1:4,x=x*k,end.
Пример цикла for. Вычисление факториала (арифметический цикл с прямым счетчиком – параметр цикла – переменная k. Система выдает результаты
счета в виде 4 значений) (рис. 12).
20
Рисунок 12. – Листинг программы.
Замечание: Поскольку внутри цикла в этом примере в качестве разделителя стоят запятые (","), выводятся все промежуточные значения "x". Если использовать конструкцию с разделителем "точка с запятой" (";"), то никаких сообщений ни будет и по специальному запросу можно будет узнать конечное
значение "x".
x=1;for k=1:4;x=x*k;end
2) Цикл while
Синтаксис
while <тело цикла> end
21
Пример цикла while (рис. 13).
Рисунок 13. – Листинг программы.
Циклы while и for могут быть прерваны с помощью оператора break.
Пример:
-->a=0; for i=1:5:100, a=a+1; if i>10 then break, end;end
--> a
a=
3.
Замечание: Если мы хотим прервать извне выполнение цикла (например,
видно, что произошло зацикливание), используйте функциональное меню
управления окна: Control - Abort. Посмотрите также команды return и pause. [1,
c. 135]
Допустимы следующие условные конструкции:
1) Конструкция if-then-else.
Синтаксис
if expr1 then statements
elseif expri then statements
....
else stataments
22
end,
end
Замечание: Число символьных знаков, используемых для определения
тела условной конструкции (if while for или select/case) должно быть ограничено 16 Кб.
Пример:
i=2
for j = 1:3,
if i == j then
a(i,j) = 2;
elseif abs(i-j) == 1 then
a(i,j) = -1;
else a(i,j) = 0;
end,
end
Результат:
a=
! 0. 0. 0. !
! - 1. 2. - 1. !
Там, где, например, в языке C++ используются фигурные скобки { } для
разделения текста, в Scilab используется запятая.
2) Синтаксис конструкции " select-case"
select expr0,
case expr1 then instructions1,
case expr2 then instructions2,
...
case exprn then instructionsn,
[else instructions],
end
Пример:
23
x=-1
select x, case 1,y=x+5,case -1,y=sqrt(36),end
Результат:
y=6 [2, c. 80]
2.2 Программирование функций пользователя
Функции играют роль подпрограмм. Удобнее всего набирать функции в
текстовом редакторе и хранить их в отдельных файлах (внешние функции), но
можно их использовать и непосредственно в системе Scilab.
Синтаксис
function[y1,...,yn]=foo(x1,...,xm)
..... тело функции ....
еndfunction
где,
foo – имя функции,
xi - входные аргументы функции (их m штук),
yi - выходные аргументы функции (их n штук).
Пример:
Вычисление факториала.
function [x]=fact(k)
k=int(k)
if k<1 then k=1, end
x=1;
for j=1:k,x=x*j;end
endfunction [8, c. 240]
Вспомогательные алгоритмы. Создание функции пользователя foo
(частное от деления x1 на x2) (рис. 14).
24
Рисунок 14. – Скриншот с функцией пользователя foo.
Наберем этот текст в любом текстовом редакторе и сохраним его в файле
с именем fact.sci. Расширение *.sci является для Sclab "родным", но не обязательным. Затем следует вызвать эти файлы с из Scilab помощью команд
getf(filename) или exec(filename,-1); Те же операции можно произвести с помощью команд меню File-getf или File-exec. Для нашего примера этот вызов будет:
getf('D:\zzz\fact.sci');
До вызова функции желательно проверить, не была ли уже загружена такая
функция ранее. Для этого:
exists('fact')
Результат:
ans =
0.
Так же можно было использовать для этого команду who.
После загрузки функции с помощью
-->exec('D:\zzz\fact.sci');
25
-->exists('fact')
Получим:
ans =
1.
Теперь мы можем пользоваться этой функцией:
-->x=fact(5)
x=
120
Для загрузки функций применяются команды exec, deff и getf [10].
При определении функции function[y1,...,yn]=foo(x1,...,xm) входные и выходные параметры xi и yi могут быть любыми объектами Scilab, кроме самих
этих функций. Если функция предварительно не загружена в Scilab с помощью
getf(filename) или exec(filename,-1), то она и не выполняется. Загружаемый файл
может содержать несколько функций. Функции можно определять и непосредственно в сеансе Scilab, используя конструкцию function/endfunction или используя функцию deff. Это полезно, если мы хотим определить функцию как
выходной параметр другой функции [4].
Способ 1.
Вызов функции с помощью exec.
Синтаксис
exec(fun [,mode])
exec(path [,mode])
ierr=exec(path,'errcatch' [,mode])
ierr=exec(fun,'errcatch' [,mode])
Параметры
fun : имя файла, в котором находится Scilab функция (функция определена
непосредственно в Scilab)
path : строка, содержащая полный путь к файлу, содержащему функцию
ierr : целое, 0 или номер ошибки
mode : целый скаляр, могущий принимать следующие выражения:
26
0 : по умолчанию
-1 : ничего не печатать
1 : сообщение (echo) для каждой командной строки
2 : prompt --> печатает
3 : echoes + prompts
4 4 : stops остановка перед каждым "prompt"
7 : stops + prompts + echoes : полезно для демонстраций.
Пример:
exec('C:\scilab\macros\algebre\aff2ab.sci')
Замечание: Файл aff2ab.sci является файлом сценария.
Способ 2.
Вызов функции с помощью deff
Синтаксис
deff('[s1,s2,...]=newfunction(e1,e2,....)',text [,opt])
Параметры
e1,e2,..., : входные переменные
s1,s2,..., : выходные переменные
text : матрица из символьных значений (character strings)
opt : необязательная переменная типа character string. Возможные значения opt:
'c' : функция скомпилирована для большей эффективности (по умолчанию)
'n' : функция не скомпилирована
Пример:
deff('[x]=myplus(y,z)','x=y+z')
deff('[x]=mymacro(y,z)',['a=3*y+1'; 'x=a*z+y'])
Замечание: на первый взгляд это выглядит достаточно неудобно.
Способ 3.
Вызов функции с помощью getf
Синтаксис
getf(file-name [,opt])
Параметры
27
filename : Имя файла (Scilab string)
opt : необязательная переменная типа character string. Возможные значения opt:
'c': функция скомпилирован на для большей эффективности (по умолчанию)
'n': функция не скомпилирована
"p": загружаемая функция скомпилирована и приготовлена для профилирования.
Пример:
getf('SCI/macros/xdess/plot.sci')
Замечание: Метод вызова функций с помощью getf считается устаревшим, предпочтительнее пользоваться exec [9, c. 60].
Переменные могут являться локальными и глобальными.
1) Локальные переменные
Если значения переменных в функции не определены (и не являются
входными параметрами), то их значения берутся как переменные из вызывающей среды.
Пример:
Наберем в любом текстовом редакторе в ASCII кодах:
function [y1,y2]=f(x1,x2)
y1=x1+x2;
y2=x1-x2;
endfunction
Запишем эту функцию в файл D:\zzz\fact.sci.
exec('D:\zzz\fact.sci') // загрузка функции
[y1,y2]=f(1,1)
Результат:
y2 =
0.
y1 =
2.
28
Лучше все же при вызове пользоваться не именами переменных, используемых в определении функции, а вводить новые.
Пример:
[a,b]=f(1,1)
При этом x1 x2 остаются локальными переменными и после вызова
функции остаются неизвестными для Scilab.
2) Глобальные переменные
Могут быть определены с помощью команды global.
Синтаксис
global('nam1',...,'namn')
global nam1 ... namn
Параметры
nam1,..., namn : имена переменных
Пример:
globalabc
a=1;b=2;c=3;
Для уничтожения глобальных переменных служит команда clearglobal.
clearglobal() уничтожает все глобальные переменные.
clearglobal nam1 .. namn уничтожает глобальные переменные с заданными именами. [10]
Специальные команды для функций:
– функция argn возвращает число входных и выходных аргументов в вызове функции;
– функция error используется для печати сообщений об ошибке или разветвлений на случай детектирования ошибок;
– функция pause мода ожидания, используется для отладки;
– функция abort служит для выхода из режима ожидания;
– функция warning ожидание сообщений;
– функция break прерывание цикла;
29
– функция return и resume служат для передачи локальных переменных из
функции в основное тело программы [4].
Замечание: Все эти служебные команды используются исключительно
внутри функций.
Пример:
function [z]=foo(x,y)
if x==0 then,
error('division by zero');
end,
z=x/y
endfunction
Результат применения функции foo (рис. 15):
Рисунок 15. – Листинг программы.
Наиболее простой способ отладки Scilab-функции состоит во введении в
функцию одной из специальных команд. Остановить выполнение функции
можно с помощью оператора abort. Удобно вставлять в функцию прерывания.
Посмотрите команды setbpt, delbpt и disbpt. Для отслеживания ошибок также
удобны errclear и errcatch. Эксперты в Scilab могут использовать функцию
debug(i), где i=0,...,4) означают уровень отладки.
30
Существует возможность определить фундаментальные операции для новых типов данных. Для этого можно выполнить команду help overloading. Пользователь может дать собственное определение, например, операции умножения.
Новые операторы, определенные пользователем, должны начинаться со знака
% и состоять из 3 или 4 полей [1, c. 180].
31
Заключение
Целью данной курсовой работы являлось рассмотрение основных структур встроенных языков систем Scilab и Maxima. При подготовке курсовой работы была изучена соответствующая литература и отобран наиболее удачный материал. Использовались такие методы исследования как анализ и синтез, методы сравнения и обобщения, метод классификации, расчетный метод.
В первой главе рассматривается программирование в системе Maxima на
встроенном макроязыке. В Maxima имеется возможность написания скриптов и
даже трансляции их в код на Common Lisp с последующей компиляцией. В виду того, что Maxima писалась и разрабатывалась программистами Lisp, ее синтаксис кажется сложным, поскольку язык является сразу и императивным, и
функциональным. Maxima имеет широчайший набор средств для проведения
аналитических вычислений, численных вычислений и построения графиков. По
набору возможностей система близка к таким коммерческим системам как
Maple и Mathematica. В то же время она обладает высочайшей степенью переносимости: она может работать на всех основных современных операционных
системах на компьютерах, начиная от самых маломощных, вплоть до наладонных компьютеров. В курсовой рассматривались условные операторы, операторы цикла, блоки и функции, трансляция и компиляция. Для каждого вида оператора приводятся примеры.
Во второй главе исследуется возможность программирования в системе
Scilab. Система Scilab, как и ее коммерческий аналог Matlab, предназначена для
численных расчетов и работы с матрицами. Кроме того, она обладает развитыми средствами программирования (включая отладчик скриптов), так что ее
можно рассматривать и как систему разработки высокотехнологичных приложений. В Scilab встроен мощный язык программирования с поддержкой объектов. Работа в Scilab может осуществляться в режиме командной строки и в программном режиме. Особенностью пакета является то, что он предназначен исключительно для реализации численных методов и по умолчанию оперирует с
32
любыми значениями как с числами с плавающей точкой. В этой программе
очень хорошо реализована линейная алгебра, матричное исчисление, работа со
статистическими функциями, а также графика и симуляция различных процессов. В данной работе исследовались проблемы реализации условных и циклических программ и использование функций пользователя, их структура и загрузка, глобальные и локальные переменные, а также специальные команды
для функций. Для каждого вопроса приведены примеры с комментариями.
В ходе исследования получены следующие результаты:
1) Описаны методы реализации базовых алгоритмических структур (следование, ветвление, цикл) и вспомогательных алгоритмов в системе Maxima.
2) Исследованы средства программирования условных конструкций и
циклов входного языка системы Scilab.
3) Составлены алгоритмы решения задач в виде программ различной
структуры.
4) Исследованы дополнительные возможности входного языка системы
Maxima: создание, трансляция и компиляция функций пользователя.
5) Рассмотрены функции пользователя как подпрограммы и составлены
алгоритмы их создания в виде script-файлов в системе Scilab.
6) Составлены примеры – решены 32 задачи.
Работа имеет практическое значение и может быть использована в учебной работе при решении вычислительных задач различного типа и в исследовательской работе студентов.
33
Список использованных источников
1. Боден, М. Программирование в Scilab [Электронный ресурс]. – Режим
доступа : http://forge.scilab.org/.
2. Акчурин, Э. А. Программирование в системе Scilab [Электронный ресурс]. – Режим доступа : http://www.twirpx.com/file/901949.
3. Чичкарёв, Е. А. Компьютерная математика с Maxima : Руководство для
школьников и студентов / Е. А. Чичкарёв. – М. : ALT Linux, 2012. – 384 с.
4. Нигма – Википедия [Электронный ресурс]. – Режим доступа :
http://ru.wikipedia.org/wiki/%CD%E8%E3%EC%E0.
5. Система компьютерной алгебры Maxima [Электронный ресурс]. – Режим доступа : http://maxima.sourceforge.net/ru/maxima-tarnavsky-1.html.
6. Maxima|Программы и утилиты| 4 Debian.Info [Электронный ресурс]. –
Режим доступа : http://4debian.info/wiki/f/maxima.
7. Стахин, Н. А. Основы работы с системой аналитических (символьных)
вычислений Maxima. (ПО для решения задач аналитических (символьных)
вычислений): учебное пособие / Н. А. Стахин. – М. : Alt Linux, 2008. – 86 с.
8. Алексеев, Е. Р. Scilab: Решение инженерных и математических задач /
Е. Р. Алексеев, Е. А. Чеснокова, Е. А. Рудченко [Электронный ресурс]. – Режим
доступа : http://linux.armd.ru/common/img/uploaded/files.
9. Кормилицына, Т. В. Цифровое моделирование гармонического сигнала
в пакете SCILAB / Т. В. Кормилицына, А. Р. Азисов // Информационное образовательное пространство педагогического вуза: Материалы II Всерос. науч.
Интернет-конференции 22 октября 2012 года, г. Саранск / Редкол.:
Н. В. Вознесенская; Е. В. Черемухина; МордГПИ. – Саранск, 2012. – С. 77–79.
10. Сайт разработчиков системы Scilab [Электронный ресурс]. – Режим
доступа : www.scilab.org.
34