Для чего нужен scilab

Scilab — от поиска факториала до крестиков-ноликов

За картинку спасибо DrZugrik

Итак для начала краткая справка. Что же такое Scilab?
Подробный ответ на этот вопрос можно узнать на Википедии или на официальном сайте сообщества
Если рассказать своими словами – то Scilab, это открытий аналог Matlab. С очень похожим синтаксисом, с похожими процедурами (многие процедуры Matlab имеют свой аналог в Scilab), Интерфейс самой свежей Scilab 5.4.1, чем-то отдаленно напоминает Matlab пятилетней давности, теперь в нем вполне комфортно работать. Ну и самое главное Scilab имеет схожие возможности, безусловно меньшие чем у коммерческого гиганта, но все же для студента, начинающего ученого или просто любопытного инженера вполне достаточные. У Scilab есть свой аналог Simulink (правда явно уступающий), также можно подключать различные модули, например Maxima для символьных вычислений (у меня работало не очень надежно, но работало).Scilab есть под Windows и Linux, есть исходники, выпускается под открытой лицензией. Чем не замена пиратским копиям Matlab, установленным в колледжах и университетах?
Пример работы пакета прикладных математических программ можно увидеть на скриншотах под спойлером.

графики в Scilab

пример функции — нахождение факториала

Какая стояла задача.
С помощью возможностей по созданию графических интерфейсов в Scilab, написать простенькие крестики нолики для игры с компьютером.

Исходный код (выложены на GitHub ) представлен под спойлером

Если вкратце его описать, то вначале создается графическое окно, на нем размещается 9 кнопок игрового поля, текстовая метка и кнопка перезапуска. При нажатии на кнопку на игровом поле начинается игра. Искусственный интеллект, чисто с потолка берет значение от 1 до 9 и если оно свободно «ходит» туда, если нет копает дальше. В конце каждого обработчика нажатия, вызывается проверка выполнения условия победы (ячейки поля представляем как матрицу и всячески над ней издеваемся) В итоге получились простенькие крестики нолики для игры с AI, который в ходе тестов иногда меня неожиданно обыгрывал.

Выглядит это как-то так:

Безусловно код плохой, но надеюсь, что я смогу кого-нибудь мотивировать на изучение этого безусловно полезного математического инструмента.
Всем хорошей пятницы и прекрасных выходных 🙂

Источник

Основы работы с системой технических расчетов Scilab

Одной из областей использования персональных компьютеров является выполнение математических расчетов. Для этого используются специализированные математические системы, составляющие особый класс прикладного программного обеспечения. Математические системы широко используются как для выполнения инженерных расчетов, так и для проведения научных исследований. Они позволяют выполнять сложные алгебраические преобразования, вычислять пределы, суммы, произведения, производные и интегралы, находить решение дифференциальных уравнений или их систем. При помощи этих систем можно решать задачи аналитической геометрии, теории вероятности и математической статистики, тензорного анализа и линейной алгебры, дискретной математики, теории групп и многих других. Все они имеют замечательные возможности построения двух- и трехмерных графиков, что дает возможность представить в графической форме данные и результаты решения задач. Такие системы постоянно совершенствуются и развиваются на стыке математики и информатики.

Наиболее популярными среди математических систем является Maple, MATLAB, Mathematica и MathCad. Но все эти программы являются коммерческими. В то же время при использовании программного обеспечения все большую остроту приобретает проблема лицензионной чистоты программных продуктов, то есть защита интеллектуальной собственности разработчиков этих продуктов. Одним из путей решения этой проблемы есть использование программ, которые принадлежат к классу freeware, то есть бесплатного программного обеспечения. Очень важным является то, что достаточно часто такое программное обеспечение является еще и «открытым», то есть предоставляет возможность всем желающим не только ознакомиться с исходным программным кодом и уяснить его алгоритм, но и усовершенствовать программный код. Это, в свою очередь, привлекают много желающих для тестирования и усовершенствования такого программного обеспечения, которое зачастую приводит к стремительному развитию программных продуктов. Как раз это и присущее прикладному пакету для выполнения численных расчетов Scilab, о котором в дальнейшем и пойдет речь.

Пакет Scilab позволяет решать ряд задач:

Программа принадлежит к классу freeware, она построена как открытая система и предоставляет возможность каждому желающему получить доступ к своим программным кодам и внести в них изменения, добавив новые функции, типы данных или просто настроить систему «под себя». Поддержку системы обеспечивает консорциум Scilab, в состав которого входят больше двадцати участников, в том числе французские компании Mandriva, INRIA и ENPC.

Далее рассматривается версия системы для Windows 5.3.3. Эта версия содержит в своем составе дополнения ATOMS (AutomaTic mOdules Management for Scilab) для управления внешними модулями и Xcos для моделирования и эмуляции гибридных динамических систем. Упреждая вопросы и комментарии, замечу, что имеется версия и для Linux.

Понятие «вектор», «матрица», «массив»

Форма представления данных в Scilab является табличной. Это дает возможность решать разные задачи, связанные с инженерно-техническими вычислениями (особенно там, где используются матрицы и векторы) с очень высокой скоростью. В свою очередь, достаточно часто и в математике приходится работать с данными, представленными в виде таблиц. Например, при помощи табличного представления данных удобно решать системы линейных уравнений. Для лучшего понимания дальнейшего материала считаю целесообразным напомнить математические понятия вектора и матрицы.

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

Учитывая важность табличного представления данных, все популярные математические системы (кстати, как и все алгоритмические языки) имеют особый тип данных для работы с векторами и матрицами: одномерные (для работы с векторами) и двумерные (для работы с матрицами) массивы. Впрочем, одномерные массивы можно рассматривать как частный случай (когда одна из размерностей равняется единице) двумерных. Массивом в математических системах называют данные особого типа, которые являются совокупностью конечного числа однотипных (например, числовых) элементов с уникальным именем. В дальнейшем термин «массив» используется как обобщающее название векторов и матриц.

Интерфейс системы

Окно команд (Command Window)

Для очистки окна команд следует выполнить команду Clc, нажать функциональную клавишу или выполнить команду Настройки > Очистить командное окно.

Окно пересмотра переменных (BrowseVar)

Сессия

Сеанс работы с системой называют сессией. Сессия, по сути, является текущим документом, содержащим работу пользователя с системой: строки ввода, вывода, сообщения об ошибках. Определение переменных и функций, которые расположены в рабочей области памяти, (но не саму сессию!) можно записать на диск командою Файл > Сохранить окружение. Файл хранится с расширением BIN. Следует отметить, что возможности сохранения всего текста сессии команда Сохранить окружение не дает. Это сделано преднамеренно: сессия является результатом проб и ошибок, ее текст вместе с правильными операциями может содержать сообщения об ошибках, ненужные выводы и т.п. Необходимости хранить все это, как правило, нет. Однако это не значит, что вообще отсутствует возможность запомнить адекватную часть расчетов. Для этого следует воспользоваться редактором и отладчиком, которые позволяют (после отладки расчета) получить документ в корректной форме без синтаксических и других ошибок. Загрузка с диска данных рабочей области происходит командою Файл > Загрузить окружение. Если все же есть необходимость полностью сохранить сессию, то это можно сделать при помощи команды diary, которая предназначена для ведения дневника сессии. Команда имеет два формата, при помощи которых начинается и прекращается процесс записи сессии:

По умолчанию система после загрузки ищет документы в системной папке Documents and Setting/Имя пользователя. Для изменения местоположения папки с документами следует выполнить команду Файл > Сменить текущий каталог или на панели инструментов щелкнуть кнопку , выбрать нужную папку и щелкнуть «OK». Определить папку, где именно хранятся документы, можно командою Файл > Отобразить текущий каталог.

После формирования сценария пользователь может загрузить его в Scilab, то есть выполнить его. Однако, понятно, что сценарий создается для многократного выполнения, потому после отладки программы-расчета ее сохраняют на диске, откуда она может быть в любой момент загружена в сессию Scilab. Это осуществляется командою Файл > Сохранить как. Файл сценария создается с расширением SCE.

Загрузка сценария в сессию Scilab осуществляется командой Файл > Выполнить.

Но вовсе не обязательно создавать сценарий. Любые вычисления (временами достаточно сложные) в системе можно выполнить в режиме прямых вычислений, то есть без подготовки программы. Это превращает Scilab в мощный калькулятор, способный осуществлять не только обычные для калькуляторов вычисления (например, выполнять арифметические операции и вычислять элементарные функции), но и осуществлять операции с векторами и матрицами, комплексными числами, рядами и полиномами, решать системы линейных уравнений и т.д.

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

Правила ввода информации в документ

Обращение к справочной системе производится командой Справка > Содержание или щелчком кнопки на панели стандартных инструментов. Получить справку по конкретной команде можно также путем использования команды Help. Например, для получения справки про команду Exec следует ввести Help Exec.

Система содержит библиотеку демонстрационных примеров (необходимость ее установки на компьютере пользователя определяется во время инсталляции системы). Обращение к ней происходит командою Справка > Примеры. Демонстрационные примеры открываются в новом окне, которое нужно закрывать по окончанию пересмотра примера.

Источник

Scilab

Scilab — это мощное открытое окружение для инженерных и научных расчётов. К сожалению, при ознакомлении с данной средой автор этого учебника столкнулся с достаточно скудным набором русскоязычной литературы, которая не охватывала всех возможностей этого прекрасного окружения. В этом учебнике автор желает вместить всё, что необходимо знать для полноценной работы в среде.

Как читать учебник [ править ]

Повествование в этом учебнике идёт по нарастанию, от простого к сложному, поэтому настоятельно рекомендуется читать его последовательно. Для понимания материала от пользователя требуются умение работать с операционной системой, в которую установлена среда. Поскольку Scilab это в первую очередь математический пакет, от пользователя требуются знания некоторых математических разделов (арифметика, алгебра, математическая статистика). Также желательно, чтобы пользователь знал, что такое компьютерная программа и структурное программирование.

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

Для эффективного обучения обязательно повторяйте все примеры в этом учебнике и выполняйте задачи для самостоятельного решения.

Источник

Scilab/Объекты

В среду Scilab встроены типы данных, которые в большинстве случаев являются основой для проведения математических расчетов. Мы будем называть их объектами. Внутренняя структура объектов заранее предопределена внутри среды и скрыта от глаз пользователей. Работу с памятью при обработке объектов среда также берет на себя. В дальнейшем эти предопределенные объекты могут послужить для создания пользовательских объектов.

В основе своей объекты представляют собой массивы, в которых сохранены определенные данные. В этом разделе мы научимся создавать и манипулировать основными предопределенными объектами, без которых не обходится ни один из сеансов работы с программой.

Содержание

Переменная [ править ]

Переменная в Scilab (англ. Variable ) — это именованный массив всего с одним полем, которое хранит данные некоторого типа.

Среди типов данных можно выделить:

Создать переменную в среде не составляет труда. Для этого, как вы уже знаете, достаточно ввести ее имя и присвоить ей какое-либо начальное значение. Для переменной будет автоматически выделено место в памяти, а ее область видимости по умолчанию становится локальной.

Для того, чтобы посмотреть текущее значение переменной, достаточно просто обратиться к ней по имени, либо воспользоваться редактором переменных. В дальнейшем вы убедитесь, что редактор крайне удобен для матриц.

Запомните следующие правила, которым должны удовлетворять имена переменных и вообще любых объектов среды:

Для начала попробуем создать несколько переменных

В результате мы получили 4 переменных, 3 из которых хранят вещественные числа и одна — комплексное число. Обратите внимание, как вводится мнимая единица. В среде Scilab мнимая единица является предопределенной константой с именем ‘ i ‘. Знак процента указывает на то, что вы обращаетесь к константе.

Несмотря на то, что в переменной n1 нет дробной части, с точки зрения хранения этого числа в памяти оно вещественно и имеет тип double. Убедимся, что переменные хранят числа, для чего вызовем внутреннюю функцию type(). Чтобы не вызывать функцию четыре раза, мы объединим наши переменные в вектор. Для объединения объектов в вектор необходимо перечислить их через запятую внутри квадратных скобок

В ответ функция возвращает число 1. Данным числом функция закодировала информацию о том, что в качестве аргумента была передана матрица, содержащая вещественные или комплексные числа удвоенной точности.

Создадим текстовую переменную следующей командой

Вызовем функцию type() для переменной n5

Снова отметим, что число 10 кодирует информацию о том, что в массиве n5 хранятся текстовые строки. Не стоит заучивать наизусть что означает то или иное число, возвращаемое функцией type(), так как вы всегда можете воспользоваться справочной информацией.

Введите команду, которая откроет окно справки и перейдет к разделу, описывающему функцию type()

Запомните команду help и всегда применяйте её в подобных случаях.

Логические переменные могут хранить в себе одну из двух предопределенных констант: %T (от англ. True — Истина) и %F (от англ. False — Ложь). Для логических типов данных применяются особые (логические) операции, тем не менее, этот тип данных совместим с числовым типом данных: любое ненулевое значение является эквивалентом %T, а соответственно нулевое значение — %F.

Убедимся в последнем на следующем поучительном примере.

Обратите внимание, что логическая операция успешно прошла даже с комплексной переменной. Запомните это свойство, так как им пользуются при написании сценариев, чтобы лишний раз не создавать логические переменные.

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

Запишите следующий сценарий

Переменной n4, хранящей комплексное число, мы последовательно присвоили сначала текстовую строку, а затем вектор из числовых значений. Обратите внимание, что такие действия не приводят к ошибке интерпретатора. Если заглянуть вглубь этого процесса переприсваивания, то можно увидеть, что это многошаговый процесс: сначала необходимо освободить память от предыдущих данных, затем выделить столько памяти, сколько нужно для хранения другого типа данных и, наконец, заполнить память данными. Разумеется, что все эти действия умело скрыты от глаз пользователя.

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

Вы уже умеете создавать переменные, однако этого не достаточно для работы. Рано или поздно вы наталкнетесь на вполне естественные вопросы: «Сколько переменных сейчас в памяти?», «Какие имена свободны, а какие заняты?», «Как очистить память от ненужных мне объектов?» и другие.

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

Функции, которые приведены, следует запомнить со всеми возможными аргументами, так как они используются при работе со средой повсеместно.

Надеюсь вы не удалили последствия предыдущего упражнения. Вызовите команду whos. В ответ вы увидите следующее

В данном списке перечислены объекты, которые были объявлены средой во время инициализации и во время сессии. Из данного списка пользователь получает информацию о типе объекта, его размере в полях (если это массив) и размере в байтах. Именно поэтому данный список называется длинным. Попытаемся во всем этом многообразии отыскать только те переменные, которые мы объявили в предыдущем упражнении. Для этого введем команду

Обратите внимание, что функция вернула список из объектов, начинающихся на символ ‘n’. Среди таких объектов оказалась также библиотека функций neldermeadlib.

К сожалению функция whos не поддерживает одновременное использование своих параметров, поэтому в каждый отдельный вызов вы можете искать объект либо по его имени, либо по типу данных, которые он хранит. Попытаемся найти все объекты, хранящие строки, для чего введем

Обратите внимание на символ звездочки у некоторых переменных в колонке их типа. Данный символ означает, что переменная глобальная, то есть зона ее видимости распространяется на все функции, загруженные в данной сессии. Мы вернемся к этому вопросу, когда будем изучать программирование в среде, а пока просто запомните смысл этого символа.

Отметим, что аргументы функции также можно передавать в скобках, несмотря на то, что об этом не было упомянуто в таблице выше. Делается это так

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

Мы научились искать объекты, однако, еще не научились искать только те, которые были объявлены в данной сессии. Для этого следует использовать команду who_user

Обратите внимание, что функция вернула список объектов текущей сессии. Несмотря на то, что мы не создавали объекты help, whos и home, среда все равно отнесла их к пользовательским. Так как никакой информации об объектах мы теперь не наблюдаем, то данная запись называется короткой. Обратите внимание, что внизу отображается информация о заполненности стека. Отметим также, что функция в версии для Windows записывает этот массив в ans (или другой адресат). В версии для Unix-подобных систем этого замечено не было.

Обратите внимание на достоинства и недостатки функций whos и who_user: первая выводит исчерпывающую информацию о стеке и позволяет искать объекты в стеке, однако, вся информация об объектах иногда бывает не нужна; вторая функция возвращает только пользовательские переменные в коротком виде, что бывает полезно для проверки свободных имен.

Функция who сочетает в себе особенности whos() и who_user. Мы предлагаем читателю утолить свое любопытство и поэкспериментировать с вызовом функции who() с разными наборами аргументов, которые, в отличие от whos, можно комбинировать.

Теперь выясним тип объекта help.

О том, что это функция, вы могли догадаться ранее, когда вызывали, например, help type, где строка type являлась аргументом. Обратите внимание, что, в отличие от функции type, функция typeof возвращает не число, а строку, что намного понятнее человеку. Коды функции type очевидно намного полезнее в программировании сценариев.

Защитим наши переменные

В ответ функция возвратила два значения: первое — сколько переменных было защищено до вызова и второе — сколько защищенных переменных стало.

Если вы попытаетесь теперь удалить, например, переменную n1, то получите в ответ сообщение об ошибке

С этого момента мы натыкаемся на одно неудобство функции predef(), а именно то, что она не позволяет защищать переменные и снимать защиту с переменных по отдельности. В результате чего необходимо быть очень внимательным, вызывая функцию clear и очень тщательно обдумывать какие переменные стоит защищать, а какие не стоит.

Давайте преднамеренно совершим очень неприятную ошибку, а именно освободим стек от библиотек с системными функциями. Не следует бояться, что мы разрушим среду, так как данная проблема решается простым перезапуском программы. Выполните команду

Обратите внимание, что осталось защищенными только 13 объектов. Теперь вызовите функцию очистки

Как вы знаете, без аргументов функция удаляет все незащищенные объекты. Теперь попытаемся воспользоваться функцией whos

Очевидно, что функция перестала работать. Такой же результат вы можете наблюдать и с функцией help. Это произошло потому, что неосторожным вводом команды clear мы выгрузили все библиотеки с функциями, которые прописаны в главном сценарии среды. Так как вы не исправляли сам сценарий, то при следующем его запуске все возвратится на круги своя, а пока вы остались наедине со средой с минимальным набором компонент. Тем не менее, функция who должна работать, потому что она защищена от такой ситуации, и вы можете понаблюдать, что осталось в памяти.

Закройте среду и запустите ее заново.

В последнем упражнении последний пример показывает как важно аккуратно обращаться с памятью. Давайте разберем ситуацию «а как удалить все переменные с n1 по n7?». Вспомним правило, по которому работает стек: первым зашел — последним вышел. Это означает, что объекты как бы наслаиваются друг на друга при каждом объявлении, следовательно наши переменные в стеке были одними из последних.

Можно было запомнить сколько объектов было защищено до вызова функции predef(‘a’) и вернуть защиту именно этому числу объектов вызовом predef(n) (если вы обратили внимание, в упражнении это число было равно 79, то есть введя predef(79)). Соответственно предыдущее число защищенных объектов мы можем получить вызвав predef() без аргументов. Если на верхушке стека оказывались бы только наши переменные, то с чистой совестью мы можем вызвать команду clear, так как библиотеки мы уже защитили. Если в верхушке стека вместе с нашими переменными есть еще какие-то объекты, то clear вызывать уже нельзя и следует перечислить удаляемые объекты через пробел в качестве аргументов.

С этого момента в учебнике будут появляться блоки, в которых читателю предлагается закрепить полученные знания. В этом блоке предлагается решить следующую задачу.

Целые числа [ править ]

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

Для хранения целого числа в памяти может быть использовано разное число битов, а именно 8, 16 и 32. От количества используемых битов зависит диапазон целых чисел. Кроме того, имеется возможность включения и отключения знакового бита, что бывает полезно, когда отрицательные целые числа не требуются.

В таблице ниже приведены функции для создания целых чисел и диапазоны возможных значений. Во всех случаях функция возвращает целое число, указанное в качестве аргумента, с определенным способом его хранения в памяти.

Какой тип целочисленной переменной следует применить, пользователь решает сам. Целые числа могут быть использованы как в чисто математических задачах, так и программировании, в качестве счетчиков.

Для работы с целочисленными переменными существует две функции:

Создадим целочисленную переменную

Обратите внимание на то, что пропала точка, разделяющая целую и дробную части. Прибавим к целому числу вещественное

Обратите внимание, что вещественное число не влияет на тип данных. Теперь из результат вычтем 49.

Вместо −1 мы получили 255. Так как мы используем беззнакоый тип целого числа этого и следовало ожидать. Ситуация, когда мы выходим за диапазон возможных значений, называется переполнением. Переполнение практически всегда нежелательное явление, поэтому следует четко представлять в каких диапазонах решается та или иная задача.

Отметим, что в функциях можно указывать более сложные алгебраические конструкции, например

Введем команду, устанавливающую тип целочисленной переменной

Посмотрев по таблице код внутреннего представления, приходим к выводу, что это действительно целая 32-битная знаковая переменная. Вызовем команду, меняющую внутреннее представление переменной, например, отключим знаковый бит

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

Разберемся, почему получилось именно такое число. Несложно представить двоичную форму числа 4290866677, а именно

1111 1111 1100 0001 0110 1101 1111 0101.

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

0110 1101 1111 0101.

Если выполнить обратное преобразование в десятиричную систему счисления, то получается как раз число 28149.

Комплексные числа [ править ]

Теперь поговорим о комплексных числах. Показанный ранее способ ввода комплексного числа не всегда удобен и требует ввода знаков ‘+’ и ‘%i’. Ввод комплексного числа в значительной мере можно упростить, если воспользоваться функцией complex(a, b), в которой в качестве аргументов указать действительную и мнимую части соответственно. Согласно справочной информации, данная функция позволяет избежать проблем в объявлении комплексных переменных, в которых возможно появление констант %nan и %inf.

Попутно познакомим читателя с константами %nan и %inf. Константа %nan (англ. Not-a-Number ) кодирует особое состояние вещественного числа и возвращается, когда результат не может быть определен числовым значением (например, при неопределенности типа ноль на ноль). По умолчанию, режим, при котором в случае неопределенного результата формируется %nan, отключен и, если вы попробуете разделить на ноль, интерпретатор вернет сообщение об ошибке. Для включения режима необходимо вызвать функцию ieee(), где в качестве аргумента следует передать 2.

Константа %inf (англ. Infinity ) является машинным представлением бесконечно большого числа. Обе эти константы могут быть использованы для объявления комплексных чисел, например

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

Очевидно, что инициализация прошла с ошибкой, потому что в действительной части ожидалось %inf. Это произошло потому, что системой произведение %i*%inf интерпретируется как (0+%i)*(%inf+%i*0), что дает промежуточное выражение 0*%inf = %nan.

Корректно проинициализировать значение в этом случае возможно только с помощью функции

Для работы с комплексными числами также существует небольшой набор функций:

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

Строки [ править ]

Строковый тип данных образуется заключением символов в одинарные или двойные кавычки.

В памяти строка представляет собой массив кодов символов, из которых она образуется. Однако, после объявления строки, она представляется для пользователя единым куском, поэтому без специальных функций для работы со строками вы не сможете добраться до отдельно взятого символа строки.

Функций для работы со строками уже несколько больше, чем для работы, например, с теми же комплексными числами, и простое их перечисление будет просто не эффективным способом их изучить. Мы познакомимся с этими функциями чуть позже, когда будем решать практические задачи.

Пока вам следует запомнить, что строки сами по себе поддерживают лишь операцию конкатенации (объединения), которая вызывается с помощью оператора сложения. Например,

Переменная ans [ править ]

Переменная ans (от англ. answer — ответ) — это зарезервированная переменная, в которую сохраняется любой последний «безымянный» результат. Переменная ans является особой, например, на нее не действуют функции predef и clear. Зона ее видимости всегда остается локальной.

Переменная ans может быть использована для проведения цепочки вычислений, промежуточные результаты которых вам не нужны.

Матрицы и векторы [ править ]

Вектор в Scilab — это упорядоченная совокупность элементов (одномерный массив) одного типа данных. Упорядоченность для пользователя в этом смысле проявляется в том, что к каждому элементу вектора можно обратиться по его уникальному порядковому номеру или индексу. В среде Scilab все индексы начинаются с единицы, что немного не привычно, так как например в программировании на языке Си те же индексы массивов начинаются с нуля.

Ранее мы уже не раз создавали вектора и вы уже знаете, что для этого нужно элементы заключить в квадратные скобки, то есть

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

Вектор, элементы которого представляют собой числовую последовательность в виде арифметической прогрессии, может быть создан особым образом. Для этого используется конструкция

Например, создадим вектор с начальным значением −5, конечным значением 10 и шагом между элементами 2

Вообще говоря, шаг можно не указывать. В этом случае его значение по умолчанию принимается равным 1. Если шаг не указывается, то начальное значение всегда должно быть меньше конечного, иначе Scilab создаст пустой вектор.

Вектор может быть записан столбцом или строкой. В первом случае он называется вектор-столбцом, а во втором — вектор-строкой. От того, как представлен вектор (столбцом или строкой), зависит применимость некоторых операторов. Например, из линейной алгебры вы знаете что скалярное произведение двух векторов возможно только, если первый множитель представлен строкой, а второй — столбцом.

Выше мы создавали векторы-строки. Векторы-столбцы создаются путем отделения каждого элемента точкой с запятой, то есть

Вектор-столбец также может быть получен операцией транспонирования (оператор в виде апострофа)

что иногда бывает намного удобнее, чем создание с помощью точки с запятой.

Так как каждый элемент внутри вектора имеет свой идентификатор в виде индекса, то к нему можно обратиться. Для того, чтобы обратиться к элементу вектора, необходимо записать имя вектора, а затем в круглых скобках указать индекс.

В любой момент вы можете удалить элемент вектора. Для этого достаточно на желаемой позиции создать, так называемую, пустую матрицу в виде конструкции ‘[]’.

Если вы хотите обратиться к последнему элементу вектора, но не знаете его размер, вы можете воспользоваться служебным символом в виде знака доллара ‘$’.

Мы не зря начали свое изложение именно с понятия вектора, так как матрица по сути является расширением этого понятия.

Матрица в Scilab — это двухмерный массив однотипных элементов. Можно понимать матрицу как несколько векторов-строк, записанных столбцом.

Создать матрицу в Scilab можно одним из нескольких способов:

В общем случае синтаксическая конструкция имеет вид

[x11, x12, …, x1n; x21, x22, …, x2n; …; xm1, xm2, …, xmn]

Таким образом, вы создаете векторы-строки, которые отделяете точкой с запятой. Запятая в этом случае, как и с вектором, не обязательна.

Матрицу можно собрать из векторов. Вот два поучительных примера

Обратите внимание на второй случай, как сначала мы транспонируем векторы, создаваемые особой конструкцией, а затем присоединяем их столбцами друг к другу.

В любом случае, вы всегда должны помнить, что нельзя допускать конфликты с размерами векторов. Например, если вы образуете матрицу из векторов-строк, то число элементов в них должно быть одинаковым, иначе произойдет ошибка.

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

Разберем эти принципы в следующем упражнении.

Для начала сгенерируем матрицу, над которой будем экспериментировать. Так как нам по существу все равно, чем она будет заполнена, воспользуемся стандартной функцией rand(), которая генерирует массивы, заполняя их псевдослучайными числами.

Обратимся к элементу, стоящему во второй строке и третьем столбце

Кроме простого обращения к элементам, можно обратиться ко всему столбцу или строке. Для этого используется символ двоеточия ‘:’, который кодирует слово «все». Например,

При использовании такого обращения на первых порах очень легко запутаться и вообще перестать понимать к чему вы обращаетесь. Чтобы этого не происходило, начинайте про себя проговаривать «я обращаюсь к столбцу (строке)», при этом держа взгляд не на двоеточии, а на индексе с числом.

Теперь обратимся к последней строке

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

В качестве индексов матриц могут выступать векторы. В этом случае они выполняют роль диапазона индексов по строке или столбцу, что позволяет извлекать из матрицы сразу несколько отдельных элементов. Извлечем из нашей матрицы середину.

Следующая конструкция может показаться очень запутанной и непонятной

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

Последняя запись эквивалентна следующей

В матрице вы также можете удалять строки и столбцы. Для этого вам нужно к ним обратиться и на их место поставить пустую матрицу. Удалим столбец 3 и строку 2.

Векторами и матрицами все не заканчивается. Пользователь может создавать массивы больших размерностей, например, создадим трехмерный массив

Для того, чтобы представить себе трехмерный массив, воспользуйтесь следующей аналогией. Представьте себе лист бумаги, на котором вы мысленно можете записать матрицу. Из примера это матрица с адресом (. 1). Один лист представляет первые два измерения (строки и столбцы матрицы). Теперь вы откладываете первый лист и берете второй, на котором пишите уже вторую матрицу (. 2). Затем второй листок вы накладываете поверх первого. Если бы в нашем примере было, скажем, не 2 матрицы, а 30, то столб из листков был бы относительно высоким. Именно высота этого столба представляет третье измерение.

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

Количество измерений массива упирается в текущий размер стека, иными словами, пока есть память для хранения таких массивов. Хотя вам никто не запрещает пользоваться многомерными массивами, по возможности лучше держаться в пределах двух-, трехмерных массивов. Это связано не сколько с ограничением размера памяти, сколько неудобством ручной обработки таких массивов. Например, ввести вручную многомерный массив невозможно — для этого нужно воспользоваться специальной функцией hypermat().

Все принципы работы с массивами, рассмотренные ранее, распространяются и на многомерный случай.

Операции над матрицами [ править ]

Для матриц и векторов предусмотрены следующие операции:

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

Примечание: в пункте 9 мы надеемся, что находчивый читатель догадался до следующей конструкции

Если вы поступили по-другому, то не переживайте, потому что в Scilab одна и та же задача может решаться многими способами, и на ранних порах важно достигли ли вы требуемого результата.

Функции для работы с матрицами [ править ]

Так как все объекты в Scilab являются представлением массивов данных, то большинство функций «заточены» на работу с объектами как с массивами. Для работы с векторами и матрицами существует большое количество внутренних функций и простое их перечисление так же не эффективно в рамках обучения работе в среде. Необходимо пробовать их на практике и учиться на результатах.

Тем не менее, можно выделить ограниченный набор функций для работы с массивами, используемые так часто, что их заучивание является приоритетной целью. Именно этому мы посвятим данный раздел. Ниже в таблице перечислены функции, которые рекомендуется запомнить.

Разреженная матрица [ править ]

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

В разреженных матрицах большая часть элементов несет нулевое значение, что делает обычное выделение памяти на всю матрицу не эффективным. В системе Scilab предусмотрено создание разреженных матриц, в котором хранение элементов оптимизировано: память выделяется только на ненулевые элементы. Создать разреженную матрицу можно с помощью функции

В качестве аргументов данной функции необходимо передать два вектора:

Обратите внимание на особый формат представления разреженной матрицы. Разреженная матрица ничем не отличается, кроме способом выделения памяти, следовательно к этим матрицам применимы все операции рассмотренные ранее.

Иногда формат вывода разреженных матриц, используемый по умолчанию, не всегда удобен, поэтому специально для них используется функция full().

Списки [ править ]

Список в Scilab — это массив (или структура), состоящий из элементов разных типов данных.

Список может быть создан вручную или с помощью одной из следующих функций:

Типизованные списки используются главным образом для создания классов объектов в рамках объектно-ориентированного программирования.

Для начала создадим простой список с помощью функции list(). Для этого достаточно вызвать функцию и в качестве аргументов перечислить объекты списка. При этом мы не ограничены типами объектов.

Чтобы обратится к элементу списка, достаточно указать его индекс. Например, обратимся к первому элементу и к элементу (4,4) матрицы

Обратите внимание, как происходит обращение к матрице, хранящейся в списке: сначала индекс списка, а затем индекс матрицы. Список может наращиваться с начала и с конца. Для наращивания с начала необходимо обратиться к нулевому элементу списка, после чего добавленный элемент станет первым, а все остальные сместятся на позицию вправо. Для добавления элемента в конец нужно обратится к элементу списка с индексом ($+1).

В любой момент можно удалить элемент списка. Для этого нужно воспользоваться специальной функцией null().

Во многом работа со списком схожа с работой над вектором. Список list() обычно используется, когда данные в нем обезличены. В остальных случаях удобно использовать типизованный список.

Типизованный список [ править ]

Типизованные списки используются в среде главным образом для определения новых структур данных. Многие функции в Scilab перегружены с помощью типизованных списков. Также некоторые объекты в среде на самом деле являются типизованными списками, просто-напросто это скрыто от глаз пользователя.

Коренным отличием типизованного списка является то, что у него есть поля. Полем по сути является элемент списка, однако, каждому полю списка присваивается уникальный идентификатор или, говоря проще, имя.

Для работы с типизованными списками служат следующие функции:

Для примера создадим типизованный список, который будет хранить информацию о некотором двигателе. Пусть у этого списка будет три поля: тип двигателя, маркировка, мощность и размерность мощности.

В предыдущем вызове мы создали типизованный список с именем Engine. Именно наличие имени отличает этот вид списков от обычных list-списков. В самом вызове вы можете заметить, что первый аргумент является вектором, в котором вы должны последовательно передать имя списка и имена полей этого списка.

Последующие аргументы являются необязательными и в них вы можете проинициализировать поля нового списка. В данном примере мы присвоили полю type строку ‘П61’, полю power — число 5 и полю dim — строку ‘кВт’. Теперь, чтобы обратится к конкретному значению списка, вы должны знать имя поля в котором оно хранится и тип данных того, что в этом поле хранится. Например так

В последнем вызове мы сначала написали имя типизованного списка, к которому хотим обратиться, а затем через точку имя поля, к которому обращаемся.

Типизованные списки наследует все приемы работы, присущие обычным list-спискам. Например,

Вы можете задаться вопросом: «зачем нужен типизованный список, если он отличается от обычного списка разве что именем?». Ответ на этот вопрос кроется в его названии «типизованный». Типизованные списки позволяют создавать пользовательские типы данных. На текущем этапе вероятнее всего это вам ни о чем не говорит, но вы все поймете, когда начнете писать программы в Scilab.

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

Вы наверное уже обратили внимание, что на операции извлечения из списка и присваивание значения элементу в списке наложены две функции getfield() и setfield() соответственно. Они могут использоваться во всех типах списков, но скорее всего они написаны больше для типизованных списков. Вообще говоря, они не приносят большого преимущества, но их желательно использовать в сценариях, чтобы создать единообразие обращения к спискам. Это увеличивает удобочитаемость кода.

Кроме, условно говоря, tlist-списка, в Scilab есть еще одна разновидность типизованного списка — mlist-список. При обычной работе с этими списками пользователь не почувствует между ними разницы. Разница начинает проявляться при программировании пользовательских структур данных. Этот вопрос мы будем рассматривать чуть позже в главе Программирование.

Из этой части вы должны вынести, что типизованные списки являются надстройками над списками типа list и позволяют создавать пользовательские типы данных с уникальным именем в виде строки. Кроме того, к элементам типизованного списка можно обращаться по их уникальным именам, что позволяет писать удобные для пользователя интерфейсы.

Другие [ править ]

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

Полином [ править ]

Из алгебры вы знаете, что полиномом называется алгебраическое уравнение вида

Полином в среде Scilab может быть определен как объект polynomial, с которым работают специальные функции, например функции поиска корней. Полином можно определить через функцию poly().

Для работы с полиномами существует несколько функций:

Введем полином второго порядка, который мы разрешали ранее в разделе «Работа с сессией». Напомним, что его коэффициенты −10, 4, 2.

Теперь попробуем поменять символьную переменную на ‘s’.

Для поиска корней полинома в Scilab существует функция roots(). Применим ее на данном полиноме.

Если бы вы знали об этой функции и об объекте polynomial раньше, то упражнение по работе с командным окном показалось бы вам по меньшей мере странным, так как вы добились того же результата всего в две строки. Теперь относительно этих корней сгенерируем тот же полином

Обратите внимание на то, что Scilab учел кратность.

В качестве первого аргумента вы можете передавать матрицу, однако генерировать полином можно будет только с флагом ‘r’. Например так

Объект rational [ править ]

Еще одним объектом, который является скорее производным от объекта polinomial, является rational. Объект rational (от «рациональное число») образуется делением одного полинома на другой, при этом этот объект имеет свой внутренний идентификатор и инициируется именно как rational.

Объект rational полностью наследует все функции полинома, например, для него также применима функция horner().

Если углубиться во внутреннее устройство, то вы можете увидеть, что и rational, и полином являются типизованными списками. Объявить объект rational можно также через специальную функцию rlist, которая на самом деле является макросом, использующим tlist().

Объекты rational могут использоваться в теории систем, для объявления передаточных функций.

Математическая функция [ править ]

В Scilab есть предопределенные математические функции, такие как тригонометрические, экспонента и другие. Но что, если вам необходимо определить собственную функцию? Далее мы будем отличать математические функции и программируемые функции. Разница между ними заключается в том, что программируемые функции призваны реализовывать некоторый алгоритм, в то время как математическая функция отражает связь между множеством аргументов и множеством значений функции.

Отметим, что математическую функцию можно объявить через программирование, но так как обычно ее тело состоит из одной строчки, то рациональнее всего объявлять ее через специальную функцию deff(). Общий синтаксис имеет вид

Данная конструкция поначалу кажется сложной и неизбежны ошибки при ее вводе. Главное не забывать, что аргументы для функции deff() вы передаете в виде строк, которые затем разбиваются на лексемы и из которых среда строит программируемую функцию.

Объявим квадратичную функцию следующим образом

Убедимся в том, что мы объявили функцию

Отметим, что наша функция хранится в памяти в компилированном или бинарном виде, так как по умочанию был применен флаг ‘c’. Компилированные функции работают быстрее, однако после компиляции они привязываются к операционной системе, в которой работает Scilab. В большинстве случаев вам не нужно задумываться над тем «компилировать функцию или нет?». О компиляции функций мы поговорим, когда будем учиться писать библиотеки функций, а сейчас попробуем вызвать функцию

Очевидно, что функция работает правильно. Отметим, что deff() еще и интегрирует функцию в среду, в связи с чем вы можете передавать в качестве аргументов векторы. Например так

Усложним функцию следующим образом

Созданная функция переопределится, о чем вам скажет предупреждающее сообщение. Если вы не хотите постоянно видеть это предупреждение, то воспользуйтесь функцией funcprot(0).

Этой строкой мы создали сложную функцию, которая принимает уже два обязательных аргумента и возвращает вектор результатов. Функция сложная потому, что ее тело состоит уже из двух строк. Обратите внимание, что тело сложной функции должно передаваться deff() вектором-столбцом, каждая строка которого является инструкцией, записываемой строковым типом данных.

Вызовем нашу функцию

Очевидно, что мы получили не то, что хотели, ведь функция должна была вернуть вектор. К сожалению, в данном случае ans не переопределилась автоматически системой в вектор и был записан только результат расчета переменной x, потому что при объявлении в deff() мы ее записали первой. Чтобы получить ответ целиком, мы должны слева от вызова явно показать вектор. В этом случае мы должны объявить некоторые переменные, в которые будет записываться результат, либо воспользоваться переменной ans вот так

В этом случае в ans сначала запишется результат первой инструкции, а затем результат второй инструкции. Такой способ записи результата приемлем, если мы хотим просто посмотреть результат расчета, но сам результат не планируем никак использовать. Запишем результат расчета в вектор следующим образом

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

В дальнейшем мы научимся обходить это ограничение, перегружая функцию.

Обратите внимание на функцию funcprot() (от англ. function protection ). С помощью funcprot() вы можете защитить ваши функции от случайного их переопределения. Функция принимает один целочисленный аргумент:

Вообще говоря, при определении функции через deff() она может иметь сколь угодно много инструкций, которые необходимо записывать в вектор, как это было показано в упражнении. Однако, запись становится неудобочитаемой и в этом случае целесообразнее использовать уже вторую конструкцию function…endfunction, а также пользоваться редактором scinotes, о котором мы будем говорить дальше. Общий синтаксис выглядит так

Данная конструкция, как правило, используется для написания пользовательских программируемых функций, однако, в зависимости от предпочтений пользователя, она может использовать и вместо функции deff(). Использовать эту конструкцию можно в интерпретаторе, который воспринимает ее по особому. Сначала необходимо ввести первую строку с ключевым словом function, именем функции, аргументами и выходными переменными. Далее вы можете нажать и интерпретатор будет воспринимать все, что вы вводите, как инструкции для данной функции до тех пор, пока вы не введете ключевое слово endfunction. Если вы не допустили синтаксических ошибок в теле функции, то она будет готова к использованию, в противном случае интерпретатор выведет вам ошибку и объявлять придется заново. Именно поэтому при написании больших функции следует пользоваться исключительно scinotes.

В рамках данного раздела покажем как можно объявить функцию f через конструкцию function…endfunction.

И еще структуры [ править ]

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

Первый особый тип данных это Struct (структура), который был введен для переносимости сценариев между Scilab и двумя другими математическими пакетами MATLAB и Octave. Внешне Struct очень похож на типизованный список. В отличие от типизованного списка, который хранит имя в себе, именем структуры является переменная, в которую вы эту структуру записываете. В остальном структура похожа на обычный список, в котором есть имена полей и значения им присвоенные. Например,

При объявлении структуры на нечетным позициях в аргументах всегда стоят имена полей, а на четных — присваиваемые значения. В отличии от списков Scilab, у структур сразу удобочитаемый для пользователя формат вывода, когда как в Scilab формат нужно назначать перегрузкой.

Неудобства структуры проявляют себя при программировании. Новые поля создаются за один ход

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

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

Другой тип структурных данных это cell (ячейка). Этот тип данных частично совместим с MATLAB и Octave. Cell сочетает в себе особенности списка и матрицы. Как вы помните, в матрицах можно хранить данные только одного типа данных, но в cell это ограничение не действует. Таким образом cell — это матрица, которая способна хранить данные разных типов.

Чтобы создать cell нужно вызвать одноименную функцию

В отличие от массивов, к элементу cell нельзя обратиться по индексам для заполнения, как мы это знаем. Чтобы заполнить позицию в cell-матрице, нужно воспользоваться специальным служебным словом

Индексы в cell сами по себе используются исключительно для извлечения по всем правилам как в матрицах

Из cell можно создавать гиперматрицы, как это было с помощью функции hypermat(), но, в отличие от простой гиперматрицы, cell-гиперматрицы будут способны хранить данные разных типов.

Таким образом, cell удобно использовать, когда вы «меньшей кровью» хотите получить объект, обладающий свойствами матриц и list-списков.

Если вы предполагаете более сложные действия над собственными объектами и не предполагаете переносимость, лучше всего все же пользоваться типизованными списками Scilab.

Источник