Как в матлабе составить программу - Исправление недочетов и поиск решений вместе с Examum.ru

This example shows how to create and run a programmatic app using MATLAB® functions. The example guides you through the process of building a runnable app in which users can interactively explore different types of plots. Build the app using these steps:

Design the app layout by creating the main figure window, laying out the UI components in it, and configuring the appearance of the components by setting properties.
Program the app to respond when a user interacts with it.
Run the app to verify that your app looks and behaves as expected.

Define Main App Function

To create a programmatic app, write your app code in a function file. This allows users to run your app from the Command Window by entering the name of the function.

Create a new function named simpleApp and save it to a file named simpleApp.m in a folder that is on the MATLAB path. Provide context and instructions for using the app by adding help text to your function. Users can see this help text by entering help simpleApp in the Command Window.

function simpleApp
% SIMPLEAPP Interactively explore plotting functions
%   Choose the function used to plot the sample data to see the
%   differences between surface plots, mesh plots, and waterfall plots

end

Write all of your app code inside the simpleApp.m file. To view the full example code, see Run the App.

Create UI Figure Window

Every programmatic app requires a UI figure window to serve as the primary app container. This is the window that appears when a user runs your app, and it holds the UI components that make up the app. Create a UI figure window configured specifically for app building by calling the uifigure function. Return the resulting Figure object as a variable so that you can access the object later in your code. You can modify the size, appearance, and behavior of your figure window by setting figure properties using dot notation.

In this example, add this code to the simpleApp function to create a UI figure window and specify its title.

fig = uifigure;
fig.Name = "My App";

Manage App Layout

Manage the position and size of UI components in your figure window using a grid layout manager. This allows you to lay out your UI components in a grid by specifying a row and column for each component.

Add a grid layout manager to your app by using the uigridlayout function. Create the grid in the figure window by passing in fig as the first argument, and then specify the grid size. In this example, create a 2-by-2 grid by adding this code to the simpleApp function.

gl = uigridlayout(fig,[2 2]);

Control the size of each grid row and column by setting the RowHeight and ColumnWidth properties of the grid layout manager. In this example, ensure that the focal point of your app is the plotted data. Specify that the top row of the app is 30 pixels tall, and that the second row fills the rest of the figure window. Fit the width of the first column to the content it holds.

gl.RowHeight = {30,'1x'};
gl.ColumnWidth = {'fit','1x'};

For more information about how to lay out apps, see Lay Out Apps Programmatically.

Create and Position UI Components

Users interact with your app by interacting with different UI components, such as buttons, drop-downs, or edit fields. For a list of all available UI components, see App Building Components.

This example uses three different UI components:

A label to provide instruction
A drop-down to let users choose a plotting function
A set of axes to plot the data on

Create a UI component and add it to the grid by calling the corresponding component creation function and specifying the grid layout manager as the first input argument. Store the components as variables to access them later in your code. To create and store these three components, add this code to the simpleApp function.

lbl  = uilabel(gl);
dd = uidropdown(gl);
ax = uiaxes(gl);

After you create the components for your app, position them in the correct rows and columns of the grid. To do this, set the Layout property of each component. Position the label in the upper-left corner of the grid and the drop-down in the upper-right corner. Make the Axes object span both columns in the second row by specifying Layout.Column as a two-element vector.

% Position label
lbl.Layout.Row = 1;
lbl.Layout.Column = 1;
% Position drop-down
dd.Layout.Row = 1;
dd.Layout.Column = 2;
% Position axes
ax.Layout.Row = 2;
ax.Layout.Column = [1 2];

Configure UI Component Appearance

Every UI component object has many properties that determine its appearance. To change a property, set it using dot notation. For a list of component properties, see the corresponding properties page. For example, DropDown Properties lists all the properties of the drop-down component.

Modify the label text to provide context for the drop-down options by setting the Text property.

lbl.Text = "Choose Plot Type:";

Specify the plotting functions that users can choose from in the drop-down by setting the Items property. Set the value of the drop-down that the user sees when they first run the app.

dd.Items = ["Surf","Mesh","Waterfall"];
dd.Value = "Surf";

Program App Behavior

Program your app to respond to user interactions by using callback functions. A callback function is a function that executes when the app user performs a specific interaction, such as selecting a drop-down item. Every UI component has multiple callback properties, each of which corresponds to a different user interaction. Write a callback function and assign it to an appropriate callback property to control the behavior of your app.

In this example, program your app to update the plot when a user selects a new drop-down item. In the simpleApp.m file, after the simpleApp function, define a callback function named changePlotType. MATLAB automatically passes two input arguments to every callback function when the callback is triggered. These input arguments are often named src and event. The first argument contains the component that triggered the callback, and the second argument contains information about the user interaction. Define changePlotType to accept src and event in addition to a third input argument that specifies the axes to plot on. In the callback function, access the new drop-down value using the event argument and then use this value to determine how to update the plot data. Call the appropriate plotting function and specify the input axes as the axes to plot on.

function changePlotType(src,event,ax)
type = event.Value;
switch type
    case "Surf"
        surf(ax,peaks);
    case "Mesh"
        mesh(ax,peaks);
    case "Waterfall"
        waterfall(ax,peaks);
end
end

To associate the changePlotType function with the drop-down component, in the simpleApp function, set the ValueChangedFcn property of the drop-down component to be a cell array. The first element of the cell array is a handle to the changePlotType callback function. The second element is the Axes object to plot the data on. When an app user selects a drop-down option, MATLAB calls the callback function and passes in the source, event, and axes arguments. The callback function then updates the plot in the app.

dd.ValueChangedFcn = {@changePlotType,ax};

For more information about writing callback functions, see Create Callbacks for Apps Created Programmatically.

Finally, to make sure the plotted data is consistent with the drop-down value even before changePlotType first executes, call the surf function.

Run the App

After adding all of the app elements, your simpleApp function should look like this:

function simpleApp
% SIMPLEAPP Interactively explore plotting functions
%   Choose the function used to plot the sample data to see the
%   differences between surface plots, mesh plots, and waterfall plots

% Create figure window
fig = uifigure;
fig.Name = "My App";

% Manage app layout
gl = uigridlayout(fig,[2 2]);
gl.RowHeight = {30,'1x'};
gl.ColumnWidth = {'fit','1x'};

% Create UI components
lbl = uilabel(gl);
dd = uidropdown(gl);
ax = uiaxes(gl);

% Lay out UI components
% Position label
lbl.Layout.Row = 1;
lbl.Layout.Column = 1;
% Position drop-down
dd.Layout.Row = 1;
dd.Layout.Column = 2;
% Position axes
ax.Layout.Row = 2;
ax.Layout.Column = [1 2];

% Configure UI component appearance
lbl.Text = "Choose Plot Type:";
dd.Items = ["Surf" "Mesh" "Waterfall"];
dd.Value = "Surf";
surf(ax,peaks);

% Assign callback function to drop-down
dd.ValueChangedFcn = {@changePlotType,ax};
end

% Program app behavior
function changePlotType(src,event,ax)
type = event.Value;
switch type
    case "Surf"
        surf(ax,peaks);
    case "Mesh"
        mesh(ax,peaks);
    case "Waterfall"
        waterfall(ax,peaks);
end
end

View the help text for your app.

  SIMPLEAPP Interactively explore plotting functions
    Choose the function used to plot the sample data to see the
    differences between surface plots, mesh plots, and waterfall plots

Run the app by entering the app name in the Command Window. Update the plot by choosing a different plotting option from the drop-down.

Writing Apps

Because an app has a GUI that a user interacts with, writing an app differs in certain respects from writing other MATLAB programs. When you write an app, you are creating an event-driven program. Once your app is on the screen, it typically remains idle until a user causes an event by interacting with the app—for instance, by entering text or clicking a button. In response to that action, a callback function is executed. That callback function, provided by the app’s author, executes some code in response to the event that triggered it. For example, clicking a Run button might execute a callback function that performs some engineering calculations and updates a plot shown in the GUI.

In event-driven programming, each event callback is a short function that must obtain the data that it needs to do its job, update the app as necessary, and store its results where other callbacks can access them. The underlying app is essentially a collection of small functions working together to accomplish the larger task. When writing an event-driven program, you face the issues of writing the callbacks for the controls in your app and managing the information to be shared among these callbacks.

MATLAB supports two approaches to writing apps. You can:

Write the code from scratch
Use GUIDE, the MATLAB Graphical User Interface Design Environment

Most users find it easier to use GUIDE to graphically lay out the GUI and generate an event-driven framework for the app. Some, however, prefer the extra control they get from authoring apps from scratch. This article describes a method for writing apps from scratch using object-oriented programming. We’ve found this method to be an efficient way to create robust user interfaces.

Working with Objects: A Stock Ticker App Example

An object manages a collection of related functions and the data they share. Objects are particularly useful for writing event-driven programs. Unfortunately, however, many programmers avoid using objects, either because they think they are too complicated or because they find the task of learning object-oriented programming daunting.

Don’t worry. You do not need to become an expert in object-oriented programming to use objects to build an app. You just need to understand a few basic concepts.

When you create an object, you need to define two things: its list of Properties—the data stored within the object—and its methods—the functions that operate on the data stored in the properties of the object.

Let’s look at a simple stock ticker app that updates a graph of stock prices over time for a given ticker symbol (Figure 2).

Figure 2. Simple stock ticker app.

The simpleStockTicker MATLAB program creates the object that implements the app.

The first line of the program tells MATLAB that you are defining a new class.

The classdef keyword defines a new type of object (a “class”). The name of the class, simpleStockTicker, must match the name of the MATLAB file. The last part of the line, < handle, instructs MATLAB not to make copies of this object. All your apps will start like this; only the class name (simpleStockTicker in our example) will change.

The properties section comes next. The properties section is defined by the properties...end syntax. It is where you define the data that will be used by the object.

This class uses two groups of properties. The first five properties store the handles to the visual components of the user interface—the figure, the axis, the line plotted for the prices, the ‘Symbol’ label, and the edit box where you can type the ticker symbol name. The last four properties store data that is used to obtain and plot the stock prices. These properties can be used by any method of the class.

Using properties helps address a common problem in authoring apps: where to store data that needs to be shared by different parts of the app. Traditionally, the most common approaches have been to use guidata or global variables to store shared data, but these approaches have limitations. It can be difficult to keep guidata up-to-date and to access that data when the app needs it. Shared data stored as properties is easy to define and easy to access from anywhere in the app.

After defining the object’s properties, you define its methods using the methods...end syntax. The first method, the constructor, is used to create the object. The name of the constructor is always the same as the name of the class.

Note that the constructor must have one output variable. The output variable is used to refer to the object created by the constructor function. You can give it any name you like. The class in our example uses the name app. The output variable is special in that it is used inside the class definition file to refer to the object’s properties and methods. For example, you would refer to the object’s NumValues property by using the syntax app.NumValues. All methods of the class are defined with this special variable as their first argument.

In our example, the constructor function performs three tasks: It creates all the visual objects in the user interface, initializes the prices to be plotted, and creates a Timer object that will update periodically to get the latest stock price. The update rate is controlled by the app.TimerUpdateRate property of the class.

The next three methods in this class are the callbacks. Below is the CloseRequestFcn callback for the figure window. It is called when the figure is closed. It looks like other callback functions you may have written, with one exception: The variable app must be inserted at the beginning of the argument list for the method.

Note that a class definition file can contain other methods that are not callbacks—for example, the getQuote method. This method is called by other methods of the class.

Advantages of Using Classes

Programmers often promote the advantages of object-oriented programming over traditional functional programming. They cite encapsulation, abstraction, and polymorphism as reasons for using an object-oriented approach. While these are all useful concepts, you do not need to understand them to write your app as a MATLAB class. The most important reason for using a class to create your app is that the class provides a useful way to manage data shared by different parts of your app. The properties of the object hold all the data that needs to be shared among the methods (callbacks) of your app. You no longer need to worry about using guidata or global variables because now all the data is stored in the properties of the class.

For more examples of apps built using a class, see the Learn More section.

Published 2012
—
92062v00

Learn More

Источник

Лекция 3
Лекция 3. Программирование в среде MATLAB.
1. М-файлы.…………………………………………………………………………………………………………………………………	1
1.1. Работа в редакторе М-файлов.………………………………………………………………………………………….	2
1.2. Типы М-файлов. Файл-программы.…………………………………………………………………………………..	3
1.3. Файл-функции.…………………………………………………………………………………………………………………..	4
Файл-функции с одним входным аргументом. …………………………………………………………………………..	5
Файл-функции с несколькими входными аргументами.……………………………………………………………..	6
Файл-функции с несколькими выходными аргументами.…………………………………………………………..	7
1.4. Подфункции. ……………………………………………………………………………………………………………………..	8
2. Управляющие конструкции языка программирования. ………………………………………………………….	8
2.1. Операторы цикла. ……………………………………………………………………………………………………………..	8
Цикл for. ………………………………………………………………………………………………………………………………	8
Цикл while. ………………………………………………………………………………………………………………………..	10
2.2. Операторы ветвления.…………………………………………………………………………………………………….	11
Условный оператор if.………………………………………………………………………………………………………….	11
Оператор switch. ……………………………………………………………………………………………………………………	12
2.3. Операторы break, continue и return. …………………………………………………………………………..	13
2.4. О рациональной техники программирования в MATLAB.……………………………………………….	13

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

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

Система MATLAB имеет входной язык, напоминающий Бейсик (с примесью средств Фортрана и Паскаля). Запись программ в системе традиционна и потому привычна для большинства пользователей компьютеров. К тому же система дает возможность редактировать программы с помощью любого, привычного для пользователя текстового редактора. Имеет она и собственный редактор с отладчиком. Язык системы MATLAB в части программирования математических вычислений намного богаче любого универсального языка программирования высокого уровня. Он реализует почти все известные средства программирования, в том числе объектно-ориентированное и визуальное программирование. Это дает опытным программистам необъятные возможности для самовыражения.

1.М-файлы.

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

сохранение переменных рабочей среды или ведение дневника при помощи diary незначительно

Лекция 3

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

1.1. Работа в редакторе М-файлов.

Для подготовки, редактирования и отладки m-файлов служит специальный многооконный редактор. Он выполнен как типичное приложение Windows. Редактор можно вызвать командой edit из командной строки или командой главного меню File | New | M-file. После этого в окне редактора можно создавать свой файл, пользоваться средствами его отладки и запуска. Перед запуском файла его необходимо записать на диск, используя команду File | Save as в меню редактора.

На рис.1 показано окно редактора/отладчика. Подготовленный текст файла (это простейшая и наша первая программа на языке программирования MATLAB) можно записать на диск. Для этого используется команда Save As, которая использует стандартное окно Windows для записи файла с заданным именем. Следует отметить, что имя М-файла должно быть уникально, а требование к имени файла такое же, как для имен переменных среды MATLAB. После записи файла на диск можно запустить команду Run на панели инструментов или меню Debug, или просто нажать <F5>., для того чтобы исполнить m-файл.

На первый взгляд может показаться, что редактор/отладчик — просто лишнее звено в цепочке «пользователь — MATLAB». И в самом деле, текст файла можно было бы ввести в окно системы и получить тот же результат. Однако на деле редактор/отладчик выполняет важную роль. Он позволяет создать m-файл (программу) без той многочисленной «шелухи», которая сопровождает работу в командном режиме. Текст такого файла подвергается тщательной синтаксической проверке, в ходе которой выявляются и отсеиваются многие ошибки пользователя. Таким образом, редактор обеспечивает синтаксический контроль файла.

Редактор имеет и другие важные отладочные средства — он позволяет устанавливать в тексте файла специальные метки, именуемые точками прерывания (breakpoints). При их достижении вычисления приостанавливаются, и пользователь может оценить промежуточные результаты вычислений (например, значения переменных), проверить правильность выполнения циклов и т. д. Наконец, редактор позволяет записать файл в текстовом формате и увековечить ваши труды в файловой системе MATLAB.

Для удобства работы с редактором/отладчиком строки программы в нем нумеруются в последовательном порядке. Редактор является многооконным. Окно каждой программы оформляется как вкладка. Редактор-отладчик позволяет легко просматривать значения переменных. Для этого достаточно подвести к имени переменной курсор мыши и задержать его — появится всплывающая подсказка с именем переменной и ее значением.

Очень удобной возможностью редактора М-файлов является выполнение части команд. Для этого используется команда Evaluate Selection из контекстного меню или главного меню Text, или просто функциональная клавиша <F9>, которые позволяют выполнить выделенный текст программы.

Лекция 3

Рис. 1. Окно редактора М-файлов.

1.2. Типы М-файлов. Файл-программы.

М-файлы в MATLAB бывают двух типов: файл-программы (Script M-Files), содержащие последовательность команд, и файл-функции (Function M-Files), в которых описываются функции, определяемые пользователем.

Файл-программы представляют собой простейший тип М-файлов. Они не имеют входных и выходных аргументов и оперируют переменными, существующими в рабочей среде, или могут создавать новые переменные. Файл-программу mydemo вы написали при прочтении предыдущего раздела. Все переменные, объявленные в файл-программе, становятся доступными в рабочей среде после ее выполнения. Запустите файл-программу mydemo, приведенную в листинге рис.1. Перейдите в окно Workspace и убедитесь, что все введенные в М-файле переменные появились в рабочей среде. Все созданные при исполнении М-файла переменные остаются в рабочей среде после его завершения, и их можно использовать в других файл-программах и в командах, выполняемых из командной строки.

Запуск файл-программы осуществляется двумя способами.

1.Из редактора М-файлов так, как описано выше.

2.Из командной строки или другой файл-программы, при этом в качестве команды используется имя М-файла (без расширения). Применение второго способа намного удобнее, особенно если созданная файл-программа будет неоднократно использоваться впоследствии. Фактически созданный М-файл становится командой, которую понимает MATLAB.

Закройте все графические окна и наберите в командной строке mydemo, появляется графическое окно, соответствующее командам файл-программы mydemo.m. После ввода команды mydemo MATLAB производит следующие действия.

Лекция 3

1.Проверяет, является ли введенная команда именем какой-либо из переменных, определенных

врабочей среде. Если введена переменная, то выводится ее значение.

2.Если введена не переменная, то MATLAB ищет введенную команду среди встроенных функций. Если команда оказывается встроенной функцией, то происходит ее выполнение.

3.Если введена не переменная и не встроенная функция, то MATLAB начинает поиск М-файла с названием команды и расширением m. Поиск начинается с текущего каталога (Current Directory); если М-файл в нем не найден, то MATLAB просматривает каталоги, установленные в пути поиска (Path). (Для установки текущего каталога можно использовать окно выбора с одноименным названием на панели инструментов или команду cd. Установка путей поиска осуществляется с

помощью команды Set Path команды меню File или с помощью команды addpath).

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

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

Во-вторых, имя файла не должно начинаться с цифры, знаков «+» или «-«, словом с тех символов, которые могут быть интерпретированы MATLAB как ошибка при вводе выражения. Например, если вы назовете М-файл с файл-программой 5prog.m, то при ее запуске из меню редактора или по <F5> получите сообщение об ошибке. Это не удивительно, т. к. MATLAB ждет от вас 5 + prog (или 5, prog) для вычисления арифметического выражения с переменной prog (или добавления 5 в качестве первого элемента к вектор-строке prog). Следовательно, правильным было бы имя prog5.m (или хотя бы p5rog.m), но только начинающееся с буквы.

Обратите внимание, что если вы запускаете на выполнение выделенные команды (могут быть выделены все команды) М-файла с неверным именем при помощи <F9>, то ошибки не будет. Фактически происходит последовательное выполнение команд, не отличающееся от их вызова из командной строки, а не работа файл-программы.

Очень распространена еще одна ошибка при задании имени файл-программы, которая на первый взгляд имеет необъяснимые последствия: программа запускается только один раз. Повторный запуск не приводит к выполнению программы. Разберем эту ситуацию на примере файл-программы из листинга 5.1, которую вы сохранили в файле mydemo.m. Переименуйте файл в x.m, затем удалите все переменные рабочей среды из окна браузера переменных Workspace или из командной строки:

>> clear all

Выполните файл-программу, например, из редактора, нажав <F5>. Появляется графическое окно с двумя графиками и ничего не предвещает подвоха. Закройте теперь графическое окно и запустите программу снова. Графическое окно больше не создается, зато в командное окно вывелись значения массива x в соответствии с первым пунктом приведенного выше алгоритма поиска MATLAB. Эти обстоятельства следует учитывать при выборе имени файл-программы. Не менее важный вопрос связан с третьим пунктом алгоритма поиска MATLAB – текущим каталогом и путями поиска. Как правило, собственные М-файлы хранятся в каталогах пользователя. Для того чтобы система MATLAB могла найти их, следует установить пути, указывающие расположение М-файлов.

1.3. Файл-функции.

Рассмотренные выше файл-программы являются последовательностью команд MATLAB, они не имеют входных и выходных аргументов. Для решения вычислительных задач и написания собственных приложений в MATLAB часто требуется программировать файл-функции, которые производят необходимые действия с входными аргументами и возвращают результат в выходных аргументах. Число входных и выходных аргументов зависит от решаемой задачи – может быть только один входной и один выходной аргумент, несколько и тех и других, или только входные аргументы.

Лекция 3

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

Файл-функции с одним входным аргументом.

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


e	−x x2	+1
x4	+0.1

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

function f = myfun(x)

f = exp(-x)*sqrt((x^2 + 1)/(x^4 + 0.1));

Слово function в первой строке определяет, что данный файл содержит файл-функцию. Первая строка является заголовком функции, в которой размещаются имя функции и списки входных и выходных аргументов. Входные аргументы записываются в круглых скобках после имени функции. В нашем примере есть только один входной аргумент – х. Выходной аргумент f указывается слева от знака равенства в заголовке функции. При выборе имени файл-функции следует позаботиться об отсутствии конфликтов с занятыми именами в MATLAB. Аналогичный вопрос мы обсуждали выше: как сохранить файл-программу в файле с уникальным именем. Тот же самый подход, основанный на обращении к функции exist, вы можете применить для задания имени файл-функции.

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

Теперь необходимо сохранить файл в рабочем каталоге или в другом, известном для MATLAB, месте. При выборе пунктов Save или Save as… меню File по-умолчанию предлагается имя файла, совпадающее с названием функции myfun. Необходимо сохранить файл-функцию с этим предложенным именем. Теперь созданную функцию можно использовать так же, как и встроенные sin, cos и другие, например, из командной строки:

>> y=myfun(1.3) y =

0.2600

При создании файл-функции myfun мы подавили вывод значения f в командное окно, завершив оператор присваивания точкой с запятой. Если этого не сделать, то оно выведется при обращении y=myfun(1.3). Как правило, лучше избегать вывода в командное окно результатов промежуточных вычислений внутри файл-функции.

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

>>x=[1.3 7.2];

>>y=myfun(x)

???Error using ==> ^ Matrix must be square.

Error in ==> C:MATLAB6p5workmyfun.m

On line 2 ==> f = exp(-x)*sqrt((x^2 + 1)/(x^4 + 0.1));

Лекция 3

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

function f = myfun(x)

f = exp(-x).*sqrt((x.^2 + 1)./(x.^4 + 0.1));

Теперь аргументом функции myfun может быть как число, так и вектор или матрица значений, например:

>>x=[1.3 7.2];

>>y=myfun(x)

y =

0.2600 0.0001

Переменная y, в которую записывается результат вызова функции myfun, автоматически становится вектором нужного размера.

Рассмотрим пример использования функций. Cтроим график функции myfun на отрезке [0,4] при помощи файл-программы или из командной строки:

>>x=0:0.5:4;

>>y=myfun(x);

>>plot(x,y)

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

Мы рассмотрим сейчас только один простой пример того, как использование файл-функций упрощает визуализацию математических функций. Только что мы построили график при помощи plot. Заметьте, что для вычисления вектора y не обязательно было вызывать myfun – можно сразу записать выражение для него и потом указать пару x и y в plot. Имеющаяся в нашем распоряжении файл-функция myfun позволяет обратиться к специальной функции fplot, которой требуется указать имя нашей файл-функции (в апострофах) или указатель на нее (с оператором @ перед именем функции) и границы отрезка для построения графика (в векторе из двух элементов)

>> fplot(‘myfun’, [0 4])

или

>> fplot(@myfun, [0 4])

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

Файл-функции с несколькими входными аргументами.

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

пространства x2 + y 2 + z 2 .

function r = radius3(x,y,z) r = sqrt(x.^2 + y.^2 + z.^2);

Для вычисления длины радиус-вектора теперь можно использовать функцию radius3, например:

>> R = radius3(1, 1, 1)

Лекция 3

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

Файл-функции с несколькими выходными аргументами.

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

function [hour, minute, second] = hms(sec) hour = floor(sec/3600);

minute = floor((sec — hour*3600)/60); second = sec — hour*3600 — minute*60;

При вызове файл-функций с несколькими выходными аргументами результат следует записывать в вектор соответствующей длины:

>> [H, M, S] = hms(10000) H =

M =

S =

Если при использовании данной функции явно не указывать выходные параметры, то результатом вызова функции будет только первый выходной аргумент:

>> hms(10000) ans =

Если список выходных аргументов пуст, т. е. заголовок выглядит так: function myfun(a, b) или function [ ] = myfun(a, b),

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

Функции MATLAB обладают еще одним полезным качеством — возможностью получения информации о них при помощи команды help, например, help fplot. Собственные файлфункции так же можно наделить этим свойством, используя строки комментариев. Все строки комментариев после заголовка и до тела функции или пустой строки выводятся в командное окно командой help. Например для нашей функции можно создать подсказку:

function [hour, minute, second] = hms(sec) %hms — перевод секунд в часы, минуты и секунды

%Функция hms предназначена для перевода секунд

%в часы минуты и секунды.

%[hour, minute, second] = hms(sec)

hour = floor(sec/3600);

minute = floor((sec — hour*3600)/60); second = sec — hour*3600 — minute*60;

Лекция 3

1.4. Подфункции.

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

function simple;

% Основная функция a = 2*pi;

fl = f(1.1, 2.1) f2 = f(3.1, 4.2)-a f3 = f(-2.8, 0.7)+a

function z = f(x, y) % Подфункция

z = x^3 — 2*y^3 — x*y + 9;

Первая функция simple является основной функцией в simple.m, именно ее операторы выполняются, если пользователь вызывает simple, например, из командной строки. Каждое обращение к подфункции f в основной функции приводит к переходу к размещенным в подфункции операторам и последующему возврату в основную функцию.

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

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

2. Управляющие конструкции языка программирования.

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

2.1. Операторы цикла.

Схожие и повторяющиеся действия выполняются при помощи операторов цикла for и while. Цикл for предназначен для выполнения заданного числа повторяющихся действий, a while – для действий, число которых заранее не известно, но известно условие продолжения цикла.

Цикл for.

Использование for осуществляется следующим образом:

for count = start:step:final

команды MATLAB

end

Лекция 3

Здесь count— переменная цикла, start – ее начальное значение, final – конечное значение, a step – шаг, на который увеличивается count при каждом следующем заходе в цикл. Цикл заканчивается, как только значение count становится больше final. Переменная цикла может принимать не только целые, но и вещественные значения любого знака. Приведем пример применения цикла for. Пусть требуется вывести графики семейства кривых для x [0, 2π], которое

задано функцией y(x, a) = e−ax sin x , зависящей от параметра a , для значений параметра а от -0.1 до

0.1 с шагом 0.02. Можно, конечно, последовательно вычислять у(х,а) и строить ее графики для различных значений а, но гораздо удобнее использовать цикл for. Текст файл-программы:

figure % создание графического окна

x = 0:pi/30:2*pi; % вычисление вектора значений аргумента

%перебор значений параметра в цикле for a = -0.1:0.02:0.1

%вычисление вектора значений функции для текущего значения …

параметра

y = exp(-a*x).*sin(x); % добавление графика функции hold on

plot(x, y) end

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

Рис. 2. Семейство кривых.

Циклы for могут быть вложены друг в друга, при этом переменные вложенных циклов должны быть разными. Вложенные циклы удобны для заполнения матриц. Пример создания матрицы Гильберта:

n = 4;

a = zeros(n); for i = 1:n

for j = 1:n

a(i, j) = 1/(i+j-1);

end

Лекция 3

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

for count = A

команды MATLAB

end

Если А — вектор-строка, то count последовательно принимает значение ее элементов при каждом заходе в цикл. В случае двумерного массива А на i-ом шаге цикла count содержит столбец А(:,i). Разумеется, если А является вектор-столбцом, то цикл выполнится всего один раз со значением count, равным А.

Цикл for оказывается полезным при выполнении определенного конечного числа действий. Существуют алгоритмы с заранее неизвестным количеством повторений, реализовать которые позволяет более гибкий цикл while.

Цикл while.

Цикл while служит для организации повторений однотипных действий в случае, когда число повторений заранее неизвестно и определяется выполнением некоторого условия. Рассмотрим пример разложение sin(x) в ряд:

∞	k	x2k +1
S (x) = ∑(−1)
(2k +1)!
k =0

Конечно, до бесконечности суммировать не удастся, но можно накапливать сумму с заданной точностью, например, 10-10. Очевидно, что число членов ряда в данном случае неизвестно, поэтом использование оператора for невозможно. Выход состоит в применении цикла while, который работает, пока выполняется условие цикла:

while условие повторения цикла

команды MATLAB

end

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

x2k +1(2k +1)! больше 10-10. Текст файл-функции mysin, вычисляющей сумму ряда на основе

рекуррентного соотношения:

a	k	=	x2	a	k −1
2k (2k +1)

function s = mysin(x)

%Вычисление синуса разложением в ряд

%Использование: у = mysin(x), -pi < х < pi

%вычисление первого слагаемого суммы для к = О k = 0;

u = x; s = u;

%вычисление вспомогательной переменной

x2 = x*x;

while abs(u) > 1.0e-10 k = k + 1;

u = -u* x2/(2*k)/(2*k + 1); s = s + u;

end

Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]

Источник

Define Main App Function

Create UI Figure Window

Manage App Layout

Create and Position UI Components

Configure UI Component Appearance

Program App Behavior

Run the App

Related Topics

Writing Apps

Working with Objects: A Stock Ticker App Example

Advantages of Using Classes

Learn More