MATLAB - 快速指南

---

---

MATLAB - 概述

MATLAB（矩阵实验室）是一种第四代高级编程语言和交互式环境，用于数值计算、可视化和编程。

MATLAB 由 MathWorks 开发。

它允许进行矩阵操作；函数和数据的绘图；算法的实现；用户界面的创建；与用其他语言编写的程序接口，包括 C、C++、Java 和 FORTRAN；分析数据；开发算法；以及创建模型和应用程序。

它具有许多内置命令和数学函数，可帮助您进行数学计算、生成绘图和执行数值方法。

MATLAB 的计算数学能力

MATLAB 用于计算数学的各个方面。以下是它最常用于的一些常用数学计算：

• 处理矩阵和数组
• 2D 和 3D 绘图和图形
• 线性代数
• 代数方程
• 非线性函数
• 统计
• 数据分析
• 微积分和微分方程
• 数值计算
• 积分
• 变换
• 曲线拟合
• 各种其他特殊函数

MATLAB 的特性

以下是 MATLAB 的基本特性：

• 它是一种用于数值计算、可视化和应用程序开发的高级语言。

• 它还提供了一个交互式环境，用于迭代探索、设计和解决问题。

• 它提供了丰富的数学函数库，用于线性代数、统计、傅里叶分析、滤波、优化、数值积分和求解常微分方程。

• 它提供了用于可视化数据和创建自定义绘图的内置图形。

• MATLAB 的编程接口提供了开发工具，用于提高代码质量、可维护性和最大化性能。

• 它提供了用于构建具有自定义图形界面的应用程序的工具。

• 它提供了用于将基于 MATLAB 的算法与外部应用程序和语言（如 C、Java、.NET 和 Microsoft Excel）集成的函数。

MATLAB 的用途

MATLAB 广泛用作科学和工程中的计算工具，涵盖物理学、化学、数学和所有工程学科。它用于各种应用，包括：

• 信号处理和通信
• 图像和视频处理
• 控制系统
• 测试和测量
• 计算金融
• 计算生物学

MATLAB - 环境设置

本地环境设置

设置 MATLAB 环境只需点击几下即可。安装程序可以从这里下载。

MathWorks 提供许可产品、试用版和学生版。您需要登录网站并等待一段时间以获得他们的批准。

下载安装程序后，可以通过点击几下安装软件。

了解 MATLAB 环境

MATLAB 开发 IDE 可以从桌面上创建的图标启动。MATLAB 中的主要工作窗口称为桌面。启动 MATLAB 时，桌面将以其默认布局显示：

桌面包含以下面板：

• 当前文件夹 - 此面板允许您访问项目文件夹和文件。



• 命令窗口 - 这是在命令行输入命令的主要区域。它由命令提示符（>>）指示。



• 工作区 - 工作区显示从文件创建和/或导入的所有变量。



• 命令历史记录 - 此面板显示或返回在命令行输入的命令。

设置 GNU Octave

如果您想在您的机器（Linux、BSD、OS X 或 Windows）上使用 Octave，请从下载 GNU Octave下载最新版本。您可以查看给定的机器安装说明。

MATLAB - 基本语法

MATLAB 环境的行为类似于一个超级复杂的计算器。您可以在 >> 命令提示符下输入命令。

MATLAB 是一个解释型环境。换句话说，您发出一个命令，MATLAB 会立即执行它。

实践操作

输入一个有效的表达式，例如：

5 + 5

然后按 ENTER

当您单击“执行”按钮或键入 Ctrl+E 时，MATLAB 会立即执行它，并返回以下结果：

ans = 10

让我们再举几个例子：

3 ^ 2	       % 3 raised to the power of 2

当您单击“执行”按钮或键入 Ctrl+E 时，MATLAB 会立即执行它，并返回以下结果：

ans = 9

另一个例子：

sin(pi /2)	  % sine of angle 90o

当您单击“执行”按钮或键入 Ctrl+E 时，MATLAB 会立即执行它，并返回以下结果：

ans = 1

另一个例子：

7/0		      % Divide by zero

当您单击“执行”按钮或键入 Ctrl+E 时，MATLAB 会立即执行它，并返回以下结果：

ans = Inf
warning: division by zero

另一个例子：

732 * 20.3	

当您单击“执行”按钮或键入 Ctrl+E 时，MATLAB 会立即执行它，并返回以下结果：

ans =  1.4860e+04

MATLAB 为某些数学符号提供了一些特殊表达式，例如 pi 代表 π，Inf 代表 ∞，i（和 j）代表 √-1 等。Nan 代表“非数字”。

在 MATLAB 中使用分号 (;)

分号 (;) 表示语句的结束。但是，如果您想抑制和隐藏表达式的 MATLAB 输出，请在表达式后添加分号。

例如：

x = 3;
y = x + 5

当您单击“执行”按钮或键入 Ctrl+E 时，MATLAB 会立即执行它，并返回以下结果：

y =  8

添加注释

百分号 (%) 用于指示注释行。例如：

x = 9	     % assign the value 9 to x

您还可以使用块注释运算符 % { 和 % } 编写注释块。

MATLAB 编辑器包含工具和上下文菜单项，可帮助您添加、删除或更改注释的格式。

常用运算符和特殊字符

MATLAB 支持以下常用运算符和特殊字符：

特殊变量和常量

MATLAB 支持以下特殊变量和常量：

变量命名

变量名由一个字母后跟任意数量的字母、数字或下划线组成。

MATLAB区分大小写。

变量名可以是任意长度，但是MATLAB只使用前N个字符，其中N由函数namelengthmax给出。

保存您的工作

save命令用于将工作区中的所有变量保存为一个文件，该文件具有.mat扩展名，位于当前目录中。

例如：

save myfile

您可以稍后随时使用load命令重新加载该文件。

load myfile

MATLAB - 变量

在MATLAB环境中，每个变量都是一个数组或矩阵。

您可以用简单的方式分配变量。例如，

x = 3	       % defining x and initializing it with a value

MATLAB将执行上述语句并返回以下结果：

x = 3

它创建一个名为x的1×1矩阵，并在其元素中存储值3。让我们再看一个例子，

x = sqrt(16) 	% defining x and initializing it with an expression

MATLAB将执行上述语句并返回以下结果：

x = 4

请注意：

• 一旦将变量输入系统，您以后就可以引用它。

• 变量必须在使用前具有值。

• 当表达式返回的结果未分配给任何变量时，系统将其分配给名为ans的变量，该变量以后可以使用。

例如：

sqrt(78)

MATLAB将执行上述语句并返回以下结果：

ans =  8.8318

您可以使用此变量ans：

sqrt(78);
9876/ans

MATLAB将执行上述语句并返回以下结果：

ans =  1118.2

让我们看另一个例子：

x = 7 * 8;
y = x * 7.89

MATLAB将执行上述语句并返回以下结果：

y =  441.84

多重赋值

您可以在同一行进行多次赋值。例如，

a = 2; b = 7; c = a * b

MATLAB将执行上述语句并返回以下结果：

c = 14

我忘记了变量！

who命令显示您使用过的所有变量名。

who

MATLAB将执行上述语句并返回以下结果：

Your variables are:
a    ans  b    c   

whos命令显示有关变量的更多信息：

• 当前内存中的变量
• 每个变量的类型
• 分配给每个变量的内存
• 它们是否是复数变量

whos

MATLAB将执行上述语句并返回以下结果：

Attr Name        Size        Bytes      Class
==== ====        ====        ====       ===== 
   a             1x1           8        double
   ans           1x70         757        cell
   b             1x1           8        double
   c             1x1           8        double

Total is 73 elements using 781 bytes     

clear命令从内存中删除所有（或指定的）变量。

clear x     % it will delete x, won't display anything
clear       % it will delete all variables in the workspace
            %  peacefully and unobtrusively 

长赋值

长赋值可以使用省略号(...)扩展到另一行。例如，

initial_velocity = 0;
acceleration = 9.8;
time = 20;
final_velocity = initial_velocity + acceleration * time

MATLAB将执行上述语句并返回以下结果：

final_velocity = 196

format命令

默认情况下，MATLAB以四位小数显示数字。这称为短格式。

但是，如果您需要更高的精度，则需要使用format命令。

format long命令显示小数点后16位数字。

例如：

format long
x = 7 + 10/3 + 5 ^ 1.2

MATLAB将执行上述语句并返回以下结果：

x = 17.2319816406394

另一个例子：

format short
x = 7 + 10/3 + 5 ^ 1.2

MATLAB将执行上述语句并返回以下结果：

x = 17.232

format bank命令将数字四舍五入到两位小数。例如，

format bank
daily_wage = 177.45;
weekly_wage = daily_wage * 6

MATLAB将执行上述语句并返回以下结果：

weekly_wage = 1064.70

MATLAB使用指数表示法显示大数字。

format short e命令允许以四位小数加指数的指数形式显示。例如，

例如：

format short e
4.678 * 4.9

MATLAB将执行上述语句并返回以下结果：

ans = 2.2922e+01

format long e命令允许以四位小数加指数的指数形式显示。例如，

format long e
x = pi

MATLAB将执行上述语句并返回以下结果：

x = 3.141592653589793e+00

format rat命令给出计算结果的最接近的有理表达式。例如，

format rat
4.678 * 4.9

MATLAB将执行上述语句并返回以下结果：

ans = 34177/1491 

创建向量

向量是一维数字数组。MATLAB允许创建两种类型的向量：

• 行向量
• 列向量

行向量通过将元素集括在方括号中创建，使用空格或逗号分隔元素。

例如：

r = [7 8 9 10 11]

MATLAB将执行上述语句并返回以下结果：

r =

   7    8    9   10   11 

另一个例子：

r = [7 8 9 10 11];
t = [2, 3, 4, 5, 6];
res = r + t

MATLAB将执行上述语句并返回以下结果：

res =

         9         11         13         15         17

列向量通过将元素集括在方括号中创建，使用分号（;）分隔元素。

c = [7;  8;  9;  10; 11]

MATLAB将执行上述语句并返回以下结果：

c =
       7       
       8       
       9       
      10       
      11  

创建矩阵

矩阵是二维数字数组。

在MATLAB中，矩阵是通过将每一行输入为一系列空格或逗号分隔的元素来创建的，行的末尾用分号分隔。例如，让我们创建一个3×3矩阵：

m = [1 2 3; 4 5 6; 7 8 9]

MATLAB将执行上述语句并返回以下结果：

m =
       1              2              3       
       4              5              6       
       7              8              9       

MATLAB - 命令

MATLAB是一个用于数值计算和数据可视化的交互式程序。您可以通过在MATLAB提示符“>>”上键入命令在命令窗口中输入命令。

在本节中，我们将提供常用的一般MATLAB命令列表。

管理会话的命令

MATLAB提供了各种用于管理会话的命令。下表提供了所有此类命令：

与系统一起工作的命令

MATLAB提供了各种用于与系统一起工作的有用命令，例如将当前工作保存到工作区中作为文件，以及稍后加载文件。

它还提供了各种用于其他与系统相关的活动的命令，例如，显示日期、列出目录中的文件、显示当前目录等。

下表显示了一些常用的与系统相关的命令：

输入和输出命令

MATLAB提供以下输入和输出相关命令：

fscanf和fprintf命令的行为类似于C scanf和printf函数。它们支持以下格式代码：

format函数具有以下用于数字显示的形式：

向量、矩阵和数组命令

下表显示了用于处理数组、矩阵和向量的各种命令：

绘图命令

MATLAB提供了许多用于绘制图形的命令。下表显示了一些常用的绘图命令：

MATLAB - M 文件

到目前为止，我们一直使用 MATLAB 环境作为计算器。但是，MATLAB 也是一种强大的编程语言，以及一个交互式计算环境。

在前面的章节中，您已经学习了如何从 MATLAB 命令提示符输入命令。MATLAB 还允许您将一系列命令写入文件，并将该文件作为一个完整的单元执行，就像编写函数并调用它一样。

M 文件

MATLAB 允许编写两种程序文件：

• 脚本 − 脚本文件是具有.m 扩展名的程序文件。在这些文件中，您编写要一起执行的一系列命令。脚本不接受输入也不返回任何输出。它们对工作区中的数据进行操作。

• 函数 − 函数文件也是具有.m 扩展名的程序文件。函数可以接受输入并返回输出。内部变量对函数是局部的。

您可以使用 MATLAB 编辑器或任何其他文本编辑器来创建您的.m文件。在本节中，我们将讨论脚本文件。脚本文件包含多行连续的 MATLAB 命令和函数调用。您可以通过在命令行键入其名称来运行脚本。

创建和运行脚本文件

要创建脚本文件，您需要使用文本编辑器。您可以通过两种方式打开 MATLAB 编辑器：

• 使用命令提示符
• 使用 IDE

如果您使用的是命令提示符，请在命令提示符中键入edit。这将打开编辑器。您可以直接键入edit，然后键入文件名（带有 .m 扩展名）

edit 
Or
edit <filename>

上述命令将在默认的 MATLAB 目录中创建文件。如果您想将所有程序文件存储在特定文件夹中，则必须提供完整路径。

让我们创建一个名为 progs 的文件夹。在命令提示符 (>>) 处键入以下命令：

mkdir progs    % create directory progs under default directory
chdir progs    % changing the current directory to progs
edit  prog1.m  % creating an m file named prog1.m

如果您是第一次创建文件，MATLAB 会提示您确认。单击“是”。

或者，如果您使用的是 IDE，请选择“新建” -> “脚本”。这也会打开编辑器并创建一个名为 Untitled 的文件。您可以在键入代码后命名并保存文件。

在编辑器中键入以下代码：

NoOfStudents = 6000;
TeachingStaff = 150;
NonTeachingStaff = 20;
Total = NoOfStudents + TeachingStaff ...
   + NonTeachingStaff;
disp(Total);

创建并保存文件后，您可以通过两种方式运行它：

• 单击编辑器窗口上的运行按钮或

• 只需在命令提示符中键入文件名（不带扩展名）：>> prog1

命令窗口提示符显示结果：

6170

示例

创建一个脚本文件，并键入以下代码：

a = 5; b = 7;
c = a + b
d = c + sin(b)
e = 5 * d
f = exp(-d)

编译并执行上述代码后，会产生以下结果：

c =  12
d =  12.657
e =  63.285
f =    3.1852e-06

MATLAB - 数据类型

MATLAB 不需要任何类型声明或维度语句。每当 MATLAB 遇到一个新的变量名时，它都会创建该变量并分配适当的内存空间。

如果变量已存在，则 MATLAB 会用新内容替换原始内容，并在必要时分配新的存储空间。

例如：

Total = 42

上述语句创建一个名为“Total”的 1×1 矩阵，并在其中存储值 42。

MATLAB 中可用的数据类型

MATLAB 提供 15 种基本数据类型。每种数据类型存储的数据都以矩阵或数组的形式存在。此矩阵或数组的大小至少为 0×0，并且可以增长到任何大小的矩阵或数组。

下表显示了 MATLAB 中最常用的数据类型：

示例

创建一个包含以下代码的脚本文件：

str = 'Hello World!'
n = 2345
d = double(n)
un = uint32(789.50)
rn = 5678.92347
c = int32(rn)

编译并执行上述代码后，会产生以下结果：

str = Hello World!
n =  2345
d =  2345
un = 790
rn = 5678.9
c =  5679

数据类型转换

MATLAB 提供各种函数用于将值从一种数据类型转换为另一种数据类型。下表显示了数据类型转换函数：

数据类型的确定

MATLAB 提供各种函数用于识别变量的数据类型。

下表提供了用于确定变量数据类型的函数：

示例

创建一个包含以下代码的脚本文件：

x = 3
isinteger(x)
isfloat(x)
isvector(x)
isscalar(x)
isnumeric(x)
 
x = 23.54
isinteger(x)
isfloat(x)
isvector(x)
isscalar(x)
isnumeric(x)
 
x = [1 2 3]
isinteger(x)
isfloat(x)
isvector(x)
isscalar(x)
 
x = 'Hello'
isinteger(x)
isfloat(x)
isvector(x)
isscalar(x)
isnumeric(x)

运行该文件时，会产生以下结果：

x = 3
ans = 0
ans = 1
ans = 1
ans = 1
ans = 1
x = 23.540
ans = 0
ans = 1
ans = 1
ans = 1
ans = 1
x =

          1          2          3

ans = 0
ans = 1
ans = 1
ans = 0
x = Hello
ans = 0
ans = 0
ans = 1
ans = 0
ans = 0

MATLAB - 运算符

运算符是告诉编译器执行特定数学或逻辑操作的符号。MATLAB 旨在主要对整个矩阵和数组进行操作。因此，MATLAB 中的运算符既作用于标量数据也作用于非标量数据。MATLAB 允许以下类型的基本运算：

• 算术运算符
• 关系运算符
• 逻辑运算符
• 按位运算
• 集合运算

算术运算符

MATLAB 允许两种不同类型的算术运算：

• 矩阵算术运算
• 数组算术运算

矩阵算术运算与线性代数中定义的相同。数组运算对一维和多维数组都进行逐元素执行。

矩阵运算符和数组运算符通过句点 (.) 符号区分。但是，由于加法和减法运算对于矩阵和数组来说是相同的，因此这两种情况下的运算符相同。下表简要描述了这些运算符：

显示示例

关系运算符

关系运算符也可以作用于标量和非标量数据。数组的关系运算符对两个数组执行逐元素比较，并返回大小相同的逻辑数组，其中关系为真的元素设置为逻辑 1（真），关系为假的元素设置为逻辑 0（假）。

下表显示了 MATLAB 中可用的关系运算符 -

显示示例

逻辑运算符

MATLAB 提供两种类型的逻辑运算符和函数 -

• 逐元素 - 这些运算符作用于逻辑数组的对应元素。

• 短路 - 这些运算符作用于标量和逻辑表达式。

逐元素逻辑运算符对逻辑数组逐元素进行运算。符号 &、| 和 ~ 分别是逻辑数组运算符 AND、OR 和 NOT。

短路逻辑运算符允许对逻辑运算进行短路。符号 && 和 || 分别是逻辑短路运算符 AND 和 OR。

显示示例

按位运算

按位运算符作用于位并执行逐位运算。&、| 和 ^ 的真值表如下 -

假设 A = 60；B = 13；现在以二进制格式，它们将如下所示 -

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A  = 1100 0011

MATLAB 提供了各种用于按位运算的函数，如“按位与”、“按位或”和“按位非”运算、移位运算等。

下表显示了常用的按位运算 -

显示示例

集合运算

MATLAB 提供了各种用于集合运算的函数，如并集、交集和测试集合成员资格等。

下表显示了一些常用的集合运算 -

显示示例

MATLAB - 决策

决策结构要求程序员指定一个或多个条件，由程序进行评估或测试，以及在确定条件为真时要执行的语句或语句，以及可选地在确定条件为假时要执行的其他语句。

以下是大多数编程语言中典型的决策结构的一般形式 -

MATLAB 提供以下类型的决策语句。单击以下链接以查看其详细信息 -

MATLAB - 循环类型

可能存在需要执行代码块多次的情况。通常，语句按顺序执行。函数中的第一个语句首先执行，然后是第二个语句，依此类推。

编程语言提供各种控制结构，允许更复杂的执行路径。

循环语句允许我们多次执行语句或语句组，以下是大多数编程语言中循环语句的一般形式 -

MATLAB 提供以下类型的循环来处理循环需求。单击以下链接以查看其详细信息 -

循环控制语句

循环控制语句将其执行从正常顺序更改。当执行离开作用域时，在该作用域中创建的所有自动对象都会被销毁。

MATLAB 支持以下控制语句。单击以下链接以查看其详细信息。

MATLAB - 向量

向量是一维数字数组。MATLAB允许创建两种类型的向量：

• 行向量
• 列向量

行向量

行向量通过将元素集括在方括号中创建，使用空格或逗号分隔元素。

r = [7 8 9 10 11]

MATLAB将执行上述语句并返回以下结果：

r =

   7    8    9   10   11 

列向量

列向量是通过将元素集括在方括号中创建的，使用分号分隔元素。

c = [7;  8;  9;  10; 11]

MATLAB将执行上述语句并返回以下结果：

c =
      7       
      8       
      9       
      10       
      11  
 

引用向量的元素

您可以通过多种方式引用向量的一个或多个元素。向量 v 的第 i 个分量称为 v(i)。例如 -

v = [ 1; 2; 3; 4; 5; 6];	% creating a column vector of 6 elements
v(3)

MATLAB将执行上述语句并返回以下结果：

ans =  3

当您使用冒号引用向量时，例如 v(:)，将列出向量的所有分量。

v = [ 1; 2; 3; 4; 5; 6];	% creating a column vector of 6 elements
v(:)

MATLAB将执行上述语句并返回以下结果：

ans =
     1
     2
     3
     4
     5
     6

MATLAB 允许您从向量中选择一系列元素。

例如，让我们创建一个具有 9 个元素的行向量 rv，然后我们将通过编写 rv(3:7) 引用元素 3 到 7 并创建一个名为 sub_rv 的新向量。

rv = [1 2 3 4 5 6 7 8 9];
sub_rv = rv(3:7)

MATLAB将执行上述语句并返回以下结果：

sub_rv =

   3   4   5   6   7

向量运算

在本节中，让我们讨论以下向量运算 -

• 向量的加法和减法

• 向量的标量乘法

• 向量的转置

• 向量追加

• 向量的模

• 向量的点积

• 具有均匀间隔元素的向量

MATLAB - 矩阵

矩阵是二维数字数组。

在 MATLAB 中，您可以通过输入每一行中以逗号或空格分隔的数字作为元素，并使用分号标记每一行的结束来创建矩阵。

例如，让我们创建一个 4×5 矩阵 a -

a = [ 1 2 3 4 5; 2 3 4 5 6; 3 4 5 6 7; 4 5 6 7 8]

MATLAB将执行上述语句并返回以下结果：

a =
      1     2     3     4     5
      2     3     4     5     6
      3     4     5     6     7
      4     5     6     7     8

引用矩阵的元素

要引用矩阵mx中第m行和第n列的元素，我们写成−

mx(m, n);

例如，要引用上一节中创建的矩阵a的第2行第5列的元素，我们键入−

a = [ 1 2 3 4 5; 2 3 4 5 6; 3 4 5 6 7; 4 5 6 7 8];
a(2,5)

MATLAB将执行上述语句并返回以下结果：

ans =  6

要引用第m列中的所有元素，我们键入A(:,m)。

让我们从矩阵a的第4行的元素创建一个列向量v−

a = [ 1 2 3 4 5; 2 3 4 5 6; 3 4 5 6 7; 4 5 6 7 8];
v = a(:,4)

MATLAB将执行上述语句并返回以下结果：

v =
      4
      5
      6
      7

您还可以选择第m列到第n列的元素，为此我们写成−

a(:,m:n)

让我们创建一个较小的矩阵，取第二列和第三列的元素−

a = [ 1 2 3 4 5; 2 3 4 5 6; 3 4 5 6 7; 4 5 6 7 8];
a(:, 2:3)

MATLAB将执行上述语句并返回以下结果：

ans =
      2     3
      3     4
      4     5
      5     6

同样，您可以创建一个子矩阵，取矩阵的一部分。

a = [ 1 2 3 4 5; 2 3 4 5 6; 3 4 5 6 7; 4 5 6 7 8];
a(:, 2:3)

MATLAB将执行上述语句并返回以下结果：

ans =
      2     3
      3     4
      4     5
      5     6

同样，您可以创建一个子矩阵，取矩阵的一部分。

例如，让我们创建一个子矩阵sa，取a的内部子部分−

3     4     5     
4     5     6     

为此，请写−

a = [ 1 2 3 4 5; 2 3 4 5 6; 3 4 5 6 7; 4 5 6 7 8];
sa = a(2:3,2:4)

MATLAB将执行上述语句并返回以下结果：

sa =
      3     4     5
      4     5     6

删除矩阵中的行或列

您可以通过将空方括号集[]分配给该行或列来删除矩阵的整行或整列。基本上，[]表示空数组。

例如，让我们删除a的第四行−

a = [ 1 2 3 4 5; 2 3 4 5 6; 3 4 5 6 7; 4 5 6 7 8];
a( 4 , : ) = []

MATLAB将执行上述语句并返回以下结果：

a =
      1     2     3     4     5
      2     3     4     5     6
      3     4     5     6     7

接下来，让我们删除a的第五列−

a = [ 1 2 3 4 5; 2 3 4 5 6; 3 4 5 6 7; 4 5 6 7 8];
a(: , 5)=[]

MATLAB将执行上述语句并返回以下结果：

a =
      1     2     3     4
      2     3     4     5
      3     4     5     6
      4     5     6     7

示例

在这个例子中，让我们创建一个3x3的矩阵m，然后我们将这个矩阵的第二行和第三行复制两次，创建一个4x3的矩阵。

创建一个包含以下代码的脚本文件：

a = [ 1 2 3 ; 4 5 6; 7 8 9];
new_mat = a([2,3,2,3],:)

运行文件时，它会显示以下结果−

new_mat =
      4     5     6
      7     8     9
      4     5     6
      7     8     9

矩阵运算

在本节中，让我们讨论以下基本且常用的矩阵运算−

• 矩阵的加法和减法

• 矩阵的除法

• 矩阵的标量运算

• 矩阵的转置

• 矩阵的连接

• 矩阵乘法

• 矩阵的行列式

• 矩阵的逆

MATLAB - 数组

MATLAB 中所有数据类型的变量都是多维数组。向量是一维数组，矩阵是二维数组。

我们已经讨论了向量和矩阵。在本章中，我们将讨论多维数组。但是，在此之前，让我们讨论一些特殊类型的数组。

MATLAB中的特殊数组

在本节中，我们将讨论一些创建一些特殊数组的函数。对于所有这些函数，单个参数创建一个正方形数组，双参数创建一个矩形数组。

zeros()函数创建一个全为零的数组−

例如：

zeros(5)

MATLAB将执行上述语句并返回以下结果：

ans =
      0     0     0     0     0
      0     0     0     0     0
      0     0     0     0     0
      0     0     0     0     0
      0     0     0     0     0

ones()函数创建一个全为一的数组−

例如：

ones(4,3)

MATLAB将执行上述语句并返回以下结果：

ans =
      1     1     1
      1     1     1
      1     1     1
      1     1     1

eye()函数创建一个单位矩阵。

例如：

eye(4)

MATLAB将执行上述语句并返回以下结果：

ans =
      1     0     0     0
      0     1     0     0
      0     0     1     0
      0     0     0     1

rand()函数创建一个(0,1)上均匀分布的随机数数组−

例如：

rand(3, 5)

MATLAB将执行上述语句并返回以下结果：

ans =
   0.8147    0.9134    0.2785    0.9649    0.9572
   0.9058    0.6324    0.5469    0.1576    0.4854
   0.1270    0.0975    0.9575    0.9706    0.8003

幻方

幻方是一个正方形，当其元素按行、按列或对角线相加时，会产生相同的和。

magic()函数创建一个幻方数组。它接受一个单一参数，该参数给出正方形的大小。参数必须是大于或等于3的标量。

magic(4)

MATLAB将执行上述语句并返回以下结果：

ans =
   16     2     3    13
   5    11    10     8
   9     7     6    12
   4    14    15     1

多维数组

在MATLAB中，具有两个以上维度的数组称为多维数组。MATLAB中的多维数组是普通二维矩阵的扩展。

通常，要生成多维数组，我们首先创建一个二维数组并对其进行扩展。

例如，让我们创建一个二维数组a。

a = [7 9 5; 6 1 9; 4 3 2]

MATLAB将执行上述语句并返回以下结果：

a =
   7     9     5
   6     1     9
   4     3     2

数组a是一个3x3的数组；我们可以通过提供如下值来向a添加第三个维度−

a(:, :, 2)= [ 1 2 3; 4 5 6; 7 8 9]

MATLAB将执行上述语句并返回以下结果：

a =

ans(:,:,1) =

   0   0   0
   0   0   0
   0   0   0

ans(:,:,2) =

   1   2   3
   4   5   6
   7   8   9

我们也可以使用ones()、zeros()或rand()函数创建多维数组。

例如：

b = rand(4,3,2)

MATLAB将执行上述语句并返回以下结果：

b(:,:,1) =
   0.0344    0.7952    0.6463
   0.4387    0.1869    0.7094
   0.3816    0.4898    0.7547
   0.7655    0.4456    0.2760

b(:,:,2) =
   0.6797    0.4984    0.2238
   0.6551    0.9597    0.7513
   0.1626    0.3404    0.2551
   0.1190    0.5853    0.5060

我们还可以使用cat()函数构建多维数组。它沿着指定的维度连接数组列表−

cat()函数的语法为−

B = cat(dim, A1, A2...)

其中，

• B是创建的新数组

• A1、A2、...是要连接的数组

• dim是沿其连接数组的维度

示例

创建一个脚本文件，并将以下代码输入其中−

a = [9 8 7; 6 5 4; 3 2 1];
b = [1 2 3; 4 5 6; 7 8 9];
c = cat(3, a, b, [ 2 3 1; 4 7 8; 3 9 0])

运行文件时，它会显示−

c(:,:,1) =
      9     8     7
      6     5     4
      3     2     1
c(:,:,2) =
      1     2     3
      4     5     6
      7     8     9
c(:,:,3) =
      2     3     1
      4     7     8
      3     9     0

数组函数

MATLAB 提供以下函数来排序、旋转、置换、重塑或移动数组内容。

示例

以下示例说明了上面提到的某些函数。

长度、维度和元素数量−

创建一个脚本文件，并将以下代码输入其中−

x = [7.1, 3.4, 7.2, 28/4, 3.6, 17, 9.4, 8.9];
length(x)      % length of x vector
y = rand(3, 4, 5, 2);
ndims(y)       % no of dimensions in array y
s = ['Zara', 'Nuha', 'Shamim', 'Riz', 'Shadab'];
numel(s)       % no of elements in s

运行文件时，它会显示以下结果−

ans =  8
ans =  4
ans =  23

数组元素的循环移位−

创建一个脚本文件，并将以下代码输入其中−

a = [1 2 3; 4 5 6; 7 8 9]  % the original array a
b = circshift(a,1)         %  circular shift first dimension values down by 1.
c = circshift(a,[1 -1])    % circular shift first dimension values % down by 1 
                           % and second dimension values to the left % by 1.

运行文件时，它会显示以下结果−

a =
   1     2     3
   4     5     6
   7     8     9

b =
   7     8     9
   1     2     3
   4     5     6

c =
   8     9     7
   2     3     1
   5     6     4

排序数组

创建一个脚本文件，并将以下代码输入其中−

v = [ 23 45 12 9 5 0 19 17]  % horizontal vector
sort(v)                      % sorting v
m = [2 6 4; 5 3 9; 2 0 1]    % two dimensional array
sort(m, 1)                   % sorting m along the row
sort(m, 2)                   % sorting m along the column

运行文件时，它会显示以下结果−

v =
   23    45    12     9     5     0    19    17
ans =
   0     5     9    12    17    19    23    45
m =
   2     6     4
   5     3     9
   2     0     1
ans =
   2     0     1
   2     3     4
   5     6     9
ans =
   2     4     6
   3     5     9
   0     1     2

元胞数组

元胞数组是索引单元的数组，其中每个单元可以存储不同维度和数据类型的数组。

cell函数用于创建元胞数组。cell函数的语法为−

C = cell(dim)
C = cell(dim1,...,dimN)
D = cell(obj)

其中，

• C是元胞数组；

• dim是标量整数或整数向量，指定元胞数组C的维度；

• dim1, ... , dimN是指定C维度的标量整数；

• obj是以下之一−

  • Java数组或对象
  • .NET类型为System.String或System.Object的数组

示例

创建一个脚本文件，并将以下代码输入其中−

c = cell(2, 5);
c = {'Red', 'Blue', 'Green', 'Yellow', 'White'; 1 2 3 4 5}

运行文件时，它会显示以下结果−

c = 
{
   [1,1] = Red
   [2,1] =  1
   [1,2] = Blue
   [2,2] =  2
   [1,3] = Green
   [2,3] =  3
   [1,4] = Yellow
   [2,4] =  4
   [1,5] = White
   [2,5] =  5
}

访问元胞数组中的数据

有两种方法可以引用元胞数组的元素−

• 将索引括在第一个括号()中，以引用单元集
• 将索引括在大括号{}中，以引用单个单元中的数据

当您将索引括在第一个括号中时，它指的是单元集。

圆括号中的元胞数组索引指的是单元集。

例如：

c = {'Red', 'Blue', 'Green', 'Yellow', 'White'; 1 2 3 4 5};
c(1:2,1:2)

MATLAB将执行上述语句并返回以下结果：

ans = 
{
   [1,1] = Red
   [2,1] =  1
   [1,2] = Blue
   [2,2] =  2
}

您还可以通过使用花括号索引来访问单元的内容。

例如：

c = {'Red', 'Blue', 'Green', 'Yellow', 'White'; 1 2 3 4 5};
c{1, 2:4}

MATLAB将执行上述语句并返回以下结果：

ans = Blue
ans = Green
ans = Yellow

MATLAB - 冒号表示法

冒号(:)是MATLAB中最有用的运算符之一。它用于创建向量、数组下标和指定迭代。

如果要创建一个包含从1到10的整数的行向量，您可以写−

1:10

MATLAB执行该语句并返回一个包含从1到10的整数的行向量−

ans =                                                                           
                                                                                
   1    2    3    4    5    6    7    8    9   10 

如果要指定除1以外的增量值，例如−

100: -5: 50

MATLAB执行该语句并返回以下结果−

ans =
   100    95    90    85    80    75    70    65    60    55    50

让我们再举一个例子−

0:pi/8:pi

MATLAB执行该语句并返回以下结果−

ans =
   Columns 1 through 7
      0    0.3927    0.7854    1.1781    1.5708    1.9635    2.3562
   Columns 8 through 9
      2.7489    3.1416

您可以使用冒号运算符创建索引向量以选择数组的行、列或元素。

下表描述了为此目的而使用的它（让我们有一个矩阵A）−

示例

创建一个脚本文件，并在其中键入以下代码−

A = [1 2 3 4; 4 5 6 7; 7 8 9 10]
A(:,2)      % second column of A
A(:,2:3)    % second and third column of A
A(2:3,2:3)  % second and third rows and second and third columns

运行文件时，它会显示以下结果−

A =
      1     2     3     4
      4     5     6     7
      7     8     9    10

ans =
      2
      5
      8

ans =
      2     3
      5     6
      8     9

ans =
      5     6
      8     9

MATLAB - 数字

MATLAB 支持各种数值类，包括有符号和无符号整数以及单精度和双精度浮点数。默认情况下，MATLAB 将所有数值存储为双精度浮点数。

您可以选择将任何数字或数字数组存储为整数或单精度数字。

所有数值类型都支持基本数组运算和数学运算。

转换为各种数值数据类型

MATLAB 提供以下函数来转换为各种数值数据类型−

示例

创建一个脚本文件，并键入以下代码−

x = single([5.32 3.47 6.28]) .* 7.5
x = double([5.32 3.47 6.28]) .* 7.5
x = int8([5.32 3.47 6.28]) .* 7.5
x = int16([5.32 3.47 6.28]) .* 7.5
x = int32([5.32 3.47 6.28]) .* 7.5
x = int64([5.32 3.47 6.28]) .* 7.5

运行文件时，它会显示以下结果−

x =

   39.900   26.025   47.100

x =

   39.900   26.025   47.100

x =

   38  23  45

x =

   38  23  45

x =

   38  23  45

x =

   38  23  45

示例

让我们再扩展一下前面的例子。创建一个脚本文件，并键入以下代码−

x = int32([5.32 3.47 6.28]) .* 7.5
x = int64([5.32 3.47 6.28]) .* 7.5
x = num2cell(x)

运行文件时，它会显示以下结果−

x =

   38  23  45

x =

   38  23  45

x = 
{
   [1,1] = 38
   [1,2] = 23
   [1,3] = 45
}

最小和最大整数

intmax()和intmin()函数返回所有类型的整数可以表示的最大值和最小值。

这两个函数都将整数数据类型作为参数，例如intmax(int8)或intmin(int64)，并返回可以使用整数数据类型表示的最大值和最小值。

示例

以下示例说明如何获取整数的最小值和最大值。创建一个脚本文件，并在其中编写以下代码−

% displaying the smallest and largest signed integer data
str = 'The range for int8 is:\n\t%d to %d ';
sprintf(str, intmin('int8'), intmax('int8'))
str = 'The range for int16 is:\n\t%d to %d ';
sprintf(str, intmin('int16'), intmax('int16'))
str = 'The range for int32 is:\n\t%d to %d ';
sprintf(str, intmin('int32'), intmax('int32'))
str = 'The range for int64 is:\n\t%d to %d ';
sprintf(str, intmin('int64'), intmax('int64'))
 
% displaying the smallest and largest unsigned integer data
str = 'The range for uint8 is:\n\t%d to %d ';
sprintf(str, intmin('uint8'), intmax('uint8'))
str = 'The range for uint16 is:\n\t%d to %d ';
sprintf(str, intmin('uint16'), intmax('uint16'))
str = 'The range for uint32 is:\n\t%d to %d ';
sprintf(str, intmin('uint32'), intmax('uint32'))
str = 'The range for uint64 is:\n\t%d to %d ';
sprintf(str, intmin('uint64'), intmax('uint64'))

运行文件时，它会显示以下结果−

ans = The range for int8 is:
	-128 to 127 
ans = The range for int16 is:
	-32768 to 32767 
ans = The range for int32 is:
	-2147483648 to 2147483647 
ans = The range for int64 is:
	0 to 0 
ans = The range for uint8 is:
	0 to 255 
ans = The range for uint16 is:
	0 to 65535 
ans = The range for uint32 is:
	0 to -1 
ans = The range for uint64 is:
	0 to 18446744073709551616 

最小和最大浮点数

realmax()和realmin()函数返回可以用浮点数表示的最大值和最小值。

这两个函数在使用参数'single'调用时，返回可以使用单精度数据类型表示的最大值和最小值，而在使用参数'double'调用时，返回可以使用双精度数据类型表示的最大值和最小值。

示例

以下示例说明如何获取最小和最大浮点数。创建一个脚本文件，并在其中编写以下代码−

% displaying the smallest and largest single-precision 
% floating point number
str = 'The range for single is:\n\t%g to %g and\n\t %g to  %g';
sprintf(str, -realmax('single'), -realmin('single'), ...
   realmin('single'), realmax('single'))

% displaying the smallest and largest double-precision 
% floating point number
str = 'The range for double is:\n\t%g to %g and\n\t %g to  %g';
sprintf(str, -realmax('double'), -realmin('double'), ...
   realmin('double'), realmax('double'))

运行文件时，它会显示以下结果−

ans = The range for single is:                                                  
        -3.40282e+38 to -1.17549e-38 and                                        
         1.17549e-38 to  3.40282e+38                                            
ans = The range for double is:                                                  
        -1.79769e+308 to -2.22507e-308 and                                      
         2.22507e-308 to  1.79769e+308

MATLAB - 字符串

在 MATLAB 中创建字符数组非常简单。事实上，我们已经多次使用过它。例如，您可以在命令提示符中键入以下内容：

my_string = 'Tutorials Point'

MATLAB将执行上述语句并返回以下结果：

my_string = Tutorials Point

MATLAB 将所有变量视为数组，字符串被视为字符数组。让我们使用 **whos** 命令来检查上面创建的变量：

whos

MATLAB将执行上述语句并返回以下结果：

Name           Size            Bytes  Class    Attributes
my_string      1x16               32  char

有趣的是，您可以使用数值转换函数（如 **uint8** 或 **uint16**）将字符串中的字符转换为其数值代码。**char** 函数将整数向量转换回字符：

示例

创建一个脚本文件，并将以下代码输入其中−

my_string = 'Tutorial''s Point';
str_ascii = uint8(my_string)        % 8-bit ascii values
str_back_to_char= char(str_ascii)  
str_16bit = uint16(my_string)       % 16-bit ascii values
str_back_to_char = char(str_16bit)  

运行文件时，它会显示以下结果−

str_ascii =

   84  117  116  111  114  105   97  108   39  115   32   80  111  105  110  116

str_back_to_char = Tutorial's Point
str_16bit =

   84  117  116  111  114  105   97  108   39  115   32   80  111  105  110  116

str_back_to_char = Tutorial's Point

矩形字符数组

到目前为止，我们讨论的字符串是一维字符数组；但是，我们需要存储更多内容。我们需要在程序中存储更多维度的文本数据。这是通过创建矩形字符数组来实现的。

创建矩形字符数组最简单的方法是将两个或多个一维字符数组垂直或水平连接起来，具体取决于需要。

您可以通过以下任一方式垂直组合字符串：

• 使用 MATLAB 连接运算符 **[]** 并用分号 (;) 分隔每一行。请注意，在此方法中，每一行必须包含相同数量的字符。对于长度不同的字符串，应根据需要用空格字符填充。

• 使用 **char** 函数。如果字符串长度不同，char 会用尾随空格填充较短的字符串，以便每一行具有相同数量的字符。

示例

创建一个脚本文件，并将以下代码输入其中−

doc_profile = ['Zara Ali                             '; ...
               'Sr. Surgeon                          '; ...
               'R N Tagore Cardiology Research Center']
doc_profile = char('Zara Ali', 'Sr. Surgeon', ...
                  'RN Tagore Cardiology Research Center')

运行文件时，它会显示以下结果−

doc_profile =
Zara Ali                             
Sr. Surgeon                          
R N Tagore Cardiology Research Center
doc_profile =
Zara Ali                            
Sr. Surgeon                         
RN Tagore Cardiology Research Center

您可以通过以下任一方式水平组合字符串：

• 使用 MATLAB 连接运算符 **[]** 并用逗号或空格分隔输入字符串。此方法保留输入数组中的任何尾随空格。

• 使用字符串连接函数 **strcat**。此方法会删除输入中的尾随空格。

示例

创建一个脚本文件，并将以下代码输入其中−

name =     'Zara Ali                             ';
position = 'Sr. Surgeon                          '; 
worksAt =  'R N Tagore Cardiology Research Center';
profile = [name ', ' position ', ' worksAt]
profile = strcat(name, ', ', position, ', ', worksAt)

运行文件时，它会显示以下结果−

profile = Zara Ali      , Sr. Surgeon      , R N Tagore Cardiology Research Center
profile = Zara Ali,Sr. Surgeon,R N Tagore Cardiology Research Center

将字符串组合到元胞数组中

从我们之前的讨论中可以清楚地看出，组合长度不同的字符串可能很麻烦，因为数组中的所有字符串都必须具有相同的长度。我们已在字符串末尾使用空格来使它们的长度相等。

但是，组合字符串的更有效方法是将结果数组转换为元胞数组。

MATLAB 元胞数组可以在数组中保存不同大小和类型的数。元胞数组提供了一种更灵活的方式来存储不同长度的字符串。

**cellstr** 函数将字符数组转换为字符串的元胞数组。

示例

创建一个脚本文件，并将以下代码输入其中−

name =     'Zara Ali                             ';
position = 'Sr. Surgeon                          '; 
worksAt =  'R N Tagore Cardiology Research Center';
profile = char(name, position, worksAt);
profile = cellstr(profile);
disp(profile)

运行文件时，它会显示以下结果−

{                                                                               
   [1,1] = Zara Ali                                                              
   [2,1] = Sr. Surgeon                                                           
   [3,1] = R N Tagore Cardiology Research Center                                 
}   

MATLAB 中的字符串函数

MATLAB 提供了许多用于创建、组合、解析、比较和操作字符串的字符串函数。

下表简要描述了 MATLAB 中的字符串函数：

示例

以下示例说明了一些上述字符串函数：

格式化字符串

创建一个脚本文件，并将以下代码输入其中−

A = pi*1000*ones(1,5);
sprintf(' %f \n %.2f \n %+.2f \n %12.2f \n %012.2f \n', A)

运行文件时，它会显示以下结果−

ans =  3141.592654 
   3141.59 
   +3141.59 
      3141.59 
   000003141.59 

连接字符串

创建一个脚本文件，并将以下代码输入其中−

%cell array of strings
str_array = {'red','blue','green', 'yellow', 'orange'};

% Join strings in cell array into single string
str1 = strjoin(str_array, "-")
str2 = strjoin(str_array, ",")

运行文件时，它会显示以下结果−

str1 = red-blue-green-yellow-orange
str2 = red,blue,green,yellow,orange

查找和替换字符串

创建一个脚本文件，并将以下代码输入其中−

students = {'Zara Ali', 'Neha Bhatnagar', ...
            'Monica Malik', 'Madhu Gautam', ...
            'Madhu Sharma', 'Bhawna Sharma',...
            'Nuha Ali', 'Reva Dutta', ...
            'Sunaina Ali', 'Sofia Kabir'};
 
% The strrep function searches and replaces sub-string.
new_student = strrep(students(8), 'Reva', 'Poulomi')
% Display first names
first_names = strtok(students)

运行文件时，它会显示以下结果−

new_student = 
{
   [1,1] = Poulomi Dutta
}
first_names = 
{
   [1,1] = Zara
   [1,2] = Neha
   [1,3] = Monica
   [1,4] = Madhu
   [1,5] = Madhu
   [1,6] = Bhawna
   [1,7] = Nuha
   [1,8] = Reva
   [1,9] = Sunaina
   [1,10] = Sofia
}

比较字符串

创建一个脚本文件，并将以下代码输入其中−

str1 = 'This is test'
str2 = 'This is text'
if (strcmp(str1, str2))
   sprintf('%s and %s are equal', str1, str2)
else
   sprintf('%s and %s are not equal', str1, str2)
end

运行文件时，它会显示以下结果−

str1 = This is test
str2 = This is text
ans = This is test and This is text are not equal

MATLAB - 函数

函数是一组一起执行任务的语句。在 MATLAB 中，函数在单独的文件中定义。文件和函数的名称应相同。

函数在其自己的工作区（也称为 **局部工作区**）中操作变量，该工作区与您在 MATLAB 命令提示符下访问的工作区（称为 **基本工作区**）分开。

函数可以接受多个输入参数，并且可以返回多个输出参数。

函数语句的语法为：

function [out1,out2, ..., outN] = myfun(in1,in2,in3, ..., inN)

示例

名为 *mymax* 的以下函数应写入名为 *mymax.m* 的文件中。它以五个数字作为参数，并返回这些数字中的最大值。

创建一个名为 mymax.m 的函数文件，并在其中键入以下代码：

function max = mymax(n1, n2, n3, n4, n5)

%This function calculates the maximum of the
% five numbers given as input
max =  n1;
if(n2 > max)
   max = n2;
end
if(n3 > max)
   max = n3;
end
if(n4 > max)
   max = n4;
end
if(n5 > max)
   max = n5;
end

函数的第一行以关键字 **function** 开头。它给出函数的名称和参数的顺序。在我们的示例中，*mymax* 函数有五个输入参数和一个输出参数。

紧跟在函数语句之后的注释行提供帮助文本。当您键入以下内容时，将打印这些行：

help mymax

MATLAB将执行上述语句并返回以下结果：

This function calculates the maximum of the
   five numbers given as input

您可以这样调用函数：

mymax(34, 78, 89, 23, 11)

MATLAB将执行上述语句并返回以下结果：

ans = 89

匿名函数

匿名函数类似于传统编程语言中的内联函数，在单个 MATLAB 语句中定义。它包含一个 MATLAB 表达式和任意数量的输入和输出参数。

您可以在 MATLAB 命令行或函数或脚本中定义匿名函数。

这样，您就可以创建简单的函数，而无需为它们创建文件。

从表达式创建匿名函数的语法为

f = @(arglist)expression

示例

在此示例中，我们将编写一个名为 power 的匿名函数，它将以两个数字作为输入，并返回第一个数字的第二个数字次幂。

创建一个脚本文件，并在其中键入以下代码−

power = @(x, n) x.^n;
result1 = power(7, 3)
result2 = power(49, 0.5)
result3 = power(10, -10)
result4 = power (4.5, 1.5)

运行文件时，它会显示−

result1 =  343
result2 =  7
result3 =  1.0000e-10
result4 =  9.5459

主函数和子函数

除匿名函数之外的任何函数都必须在文件中定义。每个函数文件都包含一个必需的主函数（首先出现）和任意数量的可选子函数（出现在主函数之后并由其使用）。

主函数可以从定义它们的外部文件调用，无论是从命令行还是从其他函数调用，但子函数不能从命令行或其他函数调用，不能在函数文件外部调用。

子函数仅对定义它们的函数文件中的主函数和其他子函数可见。

示例

让我们编写一个名为 quadratic 的函数，该函数将计算二次方程的根。该函数将接收三个输入，即二次系数、线性系数和常数项。它将返回根。

函数文件 quadratic.m 将包含主函数 *quadratic* 和子函数 *disc*，后者计算判别式。

创建一个函数文件 *quadratic.m*，并在其中键入以下代码：

function [x1,x2] = quadratic(a,b,c)

%this function returns the roots of 
% a quadratic equation.
% It takes 3 input arguments
% which are the co-efficients of x2, x and the 
%constant term
% It returns the roots
d = disc(a,b,c); 
x1 = (-b + d) / (2*a);
x2 = (-b - d) / (2*a);
end   % end of quadratic

function dis = disc(a,b,c) 
%function calculates the discriminant
dis = sqrt(b^2 - 4*a*c);
end   % end of sub-function

您可以从命令提示符处调用上述函数，如下所示：

quadratic(2,4,-4)

MATLAB将执行上述语句并返回以下结果：

ans = 0.7321

嵌套函数

您可以在另一个函数的主体中定义函数。这些称为嵌套函数。嵌套函数包含任何其他函数的任何或所有组件。

嵌套函数在另一个函数的作用域内定义，并且它们共享对包含函数工作区的访问权限。

嵌套函数遵循以下语法：

function x = A(p1, p2)
...
B(p2)
   function y = B(p3)
   ...
   end
...
end

示例

让我们重写上一个示例中的 *quadratic* 函数，但是，这次 disc 函数将是一个嵌套函数。

创建一个函数文件 *quadratic2.m*，并在其中键入以下代码：

function [x1,x2] = quadratic2(a,b,c)
function disc  % nested function
d = sqrt(b^2 - 4*a*c);
end   % end of function disc

disc;
x1 = (-b + d) / (2*a);
x2 = (-b - d) / (2*a);
end   % end of function quadratic2

您可以从命令提示符处调用上述函数，如下所示：

quadratic2(2,4,-4)

MATLAB将执行上述语句并返回以下结果：

ans =  0.73205

私有函数

私有函数是一个主函数，它仅对有限数量的其他函数可见。如果您不想公开函数的实现，则可以将其创建为私有函数。

私有函数驻留在名称为 **private** 的 **子文件夹** 中。

它们仅对父文件夹中的函数可见。

示例

让我们重写 *quadratic* 函数。但是，这次计算判别式的 *disc* 函数将是一个私有函数。

在工作目录中创建一个名为 private 的子文件夹。将以下函数文件 *disc.m* 存储在其中：

function dis = disc(a,b,c) 
%function calculates the discriminant
dis = sqrt(b^2 - 4*a*c);
end      % end of sub-function

在您的工作目录中创建一个函数 quadratic3.m，并在其中键入以下代码：

function [x1,x2] = quadratic3(a,b,c)

%this function returns the roots of 
% a quadratic equation.
% It takes 3 input arguments
% which are the co-efficient of x2, x and the 
%constant term
% It returns the roots
d = disc(a,b,c); 

x1 = (-b + d) / (2*a);
x2 = (-b - d) / (2*a);
end      % end of quadratic3

您可以从命令提示符处调用上述函数，如下所示：

quadratic3(2,4,-4)

MATLAB将执行上述语句并返回以下结果：

ans =  0.73205

全局变量

全局变量可以被多个函数共享。为此，您需要在所有函数中将变量声明为全局变量。

如果要从基本工作区访问该变量，则在命令行中声明该变量。

全局声明必须在函数中实际使用变量之前发生。最好对全局变量的名称使用大写字母，以将其与其他变量区分开来。

示例

让我们创建一个名为 average.m 的函数文件，并在其中键入以下代码：

function avg = average(nums)
global TOTAL
avg = sum(nums)/TOTAL;
end

创建一个脚本文件，并在其中键入以下代码−

global TOTAL;
TOTAL = 10;
n = [34, 45, 25, 45, 33, 19, 40, 34, 38, 42];
av = average(n)

运行该文件时，它将显示以下结果：

av =  35.500

MATLAB - 数据导入

在 MATLAB 中导入数据意味着从外部文件加载数据。**importdata** 函数允许加载各种不同格式的数据文件。它具有以下五种形式：

默认情况下，Octave 不支持 *importdata()* 函数，因此您需要搜索并安装此软件包才能使以下示例与您的 Octave 安装一起使用。

示例 1

让我们加载并显示一个图像文件。创建一个脚本文件，并在其中键入以下代码：

filename = 'smile.jpg';
A = importdata(filename);
image(A);

运行该文件时，MATLAB 会显示图像文件。但是，您必须将其存储在当前目录中。

示例 2

在此示例中，我们导入一个文本文件并指定分隔符和列标题。让我们创建一个以空格分隔的带列标题的 ASCII 文件，命名为 *weeklydata.txt*。

我们的文本文件 weeklydata.txt 如下所示：

SunDay  MonDay  TuesDay  WednesDay  ThursDay  FriDay  SaturDay
95.01   76.21   61.54    40.57       55.79    70.28   81.53
73.11   45.65   79.19    93.55       75.29    69.87   74.68
60.68   41.85   92.18    91.69       81.32    90.38   74.51
48.60   82.14   73.82    41.03       0.99     67.22   93.18
89.13   44.47   57.63    89.36       13.89    19.88   46.60

创建一个脚本文件，并在其中键入以下代码−

filename = 'weeklydata.txt';
delimiterIn = ' ';
headerlinesIn = 1;
A = importdata(filename,delimiterIn,headerlinesIn);

% View data
for k = [1:7]
   disp(A.colheaders{1, k})
   disp(A.data(:, k))
   disp(' ')
end

运行文件时，它会显示以下结果−

SunDay
   95.0100
   73.1100
   60.6800
   48.6000
   89.1300
 
MonDay
   76.2100
   45.6500
   41.8500
   82.1400
   44.4700
 
TuesDay
   61.5400
   79.1900
   92.1800
   73.8200
   57.6300

WednesDay
   40.5700
   93.5500
   91.6900
   41.0300
   89.3600
 
ThursDay
   55.7900
   75.2900
   81.3200
   0.9900
   13.8900
 
FriDay
   70.2800
   69.8700
   90.3800
   67.2200
   19.8800

SaturDay
   81.5300
   74.6800
   74.5100
   93.1800
   46.6000

示例 3

在此示例中，让我们从剪贴板导入数据。

将以下行复制到剪贴板：

数学很简单

创建一个脚本文件，并键入以下代码−

A = importdata('-pastespecial')

运行文件时，它会显示以下结果−

A = 
   'Mathematics is simple'

低级文件 I/O

importdata 函数是一个高级函数。MATLAB 中的低级文件 I/O 函数允许对读取或写入文件的数据进行最精细的控制。但是，这些函数需要有关文件的更多详细信息才能有效地工作。

MATLAB 提供以下函数用于字节或字符级别的读写操作：

使用低级 I/O 导入文本数据文件

MATLAB 提供以下函数用于文本数据文件的低级导入：

• fscanf 函数读取文本或 ASCII 文件中的格式化数据。

• fgetl 和 fgets 函数每次读取文件的一行，其中换行符分隔每一行。

• fread 函数以字节或位级别读取数据流。

示例

我们在工作目录中保存了一个名为“myfile.txt”的文本数据文件。该文件存储了 2012 年 6 月、7 月和 8 月三个月的降雨数据。

myfile.txt 中的数据包含五个地点重复的时间、月份和降雨量测量值集。标题数据存储月份数 M；因此我们有 M 个测量值集。

文件如下所示：

Rainfall Data
Months: June, July, August
 
M = 3
12:00:00
June-2012
17.21  28.52  39.78  16.55 23.67
19.15  0.35   17.57  NaN   12.01
17.92  28.49  17.40  17.06 11.09
9.59   9.33   NaN    0.31  0.23 
10.46  13.17  NaN    14.89 19.33
20.97  19.50  17.65  14.45 14.00
18.23  10.34  17.95  16.46 19.34
09:10:02
July-2012
12.76  16.94  14.38  11.86 16.89
20.46  23.17  NaN    24.89 19.33
30.97  49.50  47.65  24.45 34.00
18.23  30.34  27.95  16.46 19.34
30.46  33.17  NaN    34.89  29.33
30.97  49.50  47.65  24.45 34.00
28.67  30.34  27.95  36.46 29.34
15:03:40
August-2012
17.09  16.55  19.59  17.25 19.22
17.54  11.45  13.48  22.55 24.01
NaN    21.19  25.85  25.05 27.21
26.79  24.98  12.23  16.99 18.67
17.54  11.45  13.48  22.55 24.01
NaN    21.19  25.85  25.05 27.21
26.79  24.98  12.23  16.99 18.67

我们将从该文件导入数据并显示此数据。请执行以下步骤：

• 使用 fopen 函数打开文件并获取文件标识符。

• 使用 格式说明符（例如字符串的“%s”、整数的“%d”或浮点数的“%f”）描述文件中的数据。

• 要跳过文件中的文字字符，请将它们包含在格式描述中。要跳过数据字段，请在说明符中使用星号（“*”）。

  例如，要读取标题并返回 M 的单个值，我们编写：

  M = fscanf(fid, '%*s %*s\n%*s %*s %*s %*s\nM=%d\n\n', 1);
  

• 默认情况下，fscanf 会根据我们的格式描述读取数据，直到它找不到任何匹配的数据，或者到达文件末尾。这里我们将使用 for 循环读取 3 组数据，每次读取 7 行 5 列。

• 我们将在工作区中创建一个名为 mydata 的结构来存储从文件中读取的数据。该结构具有三个字段 - time、month 和 raindata 数组。

创建一个脚本文件，并在其中键入以下代码−

filename = '/data/myfile.txt';
rows = 7;
cols = 5;
 
% open the file
fid = fopen(filename);
 
% read the file headers, find M (number of months)
M = fscanf(fid, '%*s %*s\n%*s %*s %*s %*s\nM=%d\n\n', 1);
 
% read each set of measurements
for n = 1:M
   mydata(n).time = fscanf(fid, '%s', 1);
   mydata(n).month = fscanf(fid, '%s', 1);
 
   % fscanf fills the array in column order,
   % so transpose the results
   mydata(n).raindata  = ...
      fscanf(fid, '%f', [rows, cols]);
end
for n = 1:M
   disp(mydata(n).time), disp(mydata(n).month)
   disp(mydata(n).raindata)
end
 
% close the file
fclose(fid);

运行文件时，它会显示以下结果−

12:00:00
June-2012
   17.2100   17.5700   11.0900   13.1700   14.4500
   28.5200       NaN    9.5900       NaN   14.0000
   39.7800   12.0100    9.3300   14.8900   18.2300
   16.5500   17.9200       NaN   19.3300   10.3400
   23.6700   28.4900    0.3100   20.9700   17.9500
   19.1500   17.4000    0.2300   19.5000   16.4600
   0.3500   17.0600   10.4600   17.6500   19.3400

09:10:02
July-2012
   12.7600       NaN   34.0000   33.1700   24.4500
   16.9400   24.8900   18.2300       NaN   34.0000
   14.3800   19.3300   30.3400   34.8900   28.6700
   11.8600   30.9700   27.9500   29.3300   30.3400
   16.8900   49.5000   16.4600   30.9700   27.9500
   20.4600   47.6500   19.3400   49.5000   36.4600
   23.1700   24.4500   30.4600   47.6500   29.3400

15:03:40
August-2012
   17.0900   13.4800   27.2100   11.4500   25.0500
   16.5500   22.5500   26.7900   13.4800   27.2100
   19.5900   24.0100   24.9800   22.5500   26.7900
   17.2500       NaN   12.2300   24.0100   24.9800
   19.2200   21.1900   16.9900       NaN   12.2300
   17.5400   25.8500   18.6700   21.1900   16.9900
   11.4500   25.0500   17.5400   25.8500   18.6700

MATLAB - 数据输出

MATLAB 中的数据导出（或输出）意味着写入文件。MATLAB 允许您在读取 ASCII 文件的其他应用程序中使用您的数据。为此，MATLAB 提供了多种数据导出选项。

您可以创建以下类型的文件：

• 来自数组的矩形、分隔的 ASCII 数据文件。

• 键击和生成的文本输出的日记（或日志）文件。

• 使用低级函数（如 fprintf）的专用 ASCII 文件。

• MEX 文件以访问写入特定文本文件格式的 C/C++ 或 Fortran 例程。

除此之外，您还可以将数据导出到电子表格。

有两种方法可以将数值数组导出为分隔的 ASCII 数据文件：

• 使用 save 函数并指定 -ascii 限定符

• 使用 dlmwrite 函数

使用 save 函数的语法为：

save my_data.out num_array -ascii

其中，my_data.out 是创建的分隔的 ASCII 数据文件，num_array 是数值数组，−ascii 是说明符。

使用 dlmwrite 函数的语法为：

dlmwrite('my_data.out', num_array, 'dlm_char')

其中，my_data.out 是创建的分隔的 ASCII 数据文件，num_array 是数值数组，dlm_char 是分隔符字符。

示例

以下示例演示了该概念。创建一个脚本文件并键入以下代码：

num_array = [ 1 2 3 4 ; 4 5 6 7; 7 8 9 0];
save array_data1.out num_array -ascii;
type array_data1.out
dlmwrite('array_data2.out', num_array, ' ');
type array_data2.out

运行文件时，它会显示以下结果−

   1.0000000e+00   2.0000000e+00   3.0000000e+00   4.0000000e+00
   4.0000000e+00   5.0000000e+00   6.0000000e+00   7.0000000e+00
   7.0000000e+00   8.0000000e+00   9.0000000e+00   0.0000000e+00

1 2 3 4
4 5 6 7
7 8 9 0

请注意，save -ascii 命令和 dlmwrite 函数不适用于单元数组作为输入。要从单元数组的内容创建分隔的 ASCII 文件，您可以

• 或者，使用 cell2mat 函数将单元数组转换为矩阵

• 或者使用低级文件 I/O 函数导出单元数组。

如果使用 save 函数将字符数组写入 ASCII 文件，它会将字符的 ASCII 等效项写入文件。

例如，让我们将单词“hello”写入文件：

h = 'hello';
save textdata.out h -ascii
type textdata.out

MATLAB 执行上述语句并显示以下结果。即字符串“hello”的字符以 8 位 ASCII 格式显示。

1.0400000e+02   1.0100000e+02   1.0800000e+02   1.0800000e+02   1.1100000e+02

写入日记文件

日记文件是 MATLAB 会话的活动日志。diary 函数在磁盘文件中创建会话的精确副本，但不包括图形。

要打开 diary 函数，请键入：

diary

可选地，您可以给出日志文件的名称，例如：

diary logdata.out

要关闭 diary 函数：

diary off

您可以在文本编辑器中打开日记文件。

使用低级 I/O 将数据导出到文本数据文件

到目前为止，我们已经导出了数值数组。但是，您可能需要创建其他文本文件，包括数值和字符数据的组合、非矩形输出文件或使用非 ASCII 编码方案的文件。为此，MATLAB 提供了低级 fprintf 函数。

与低级 I/O 文件活动一样，在导出之前，您需要使用 fopen 函数打开或创建文件并获取文件标识符。默认情况下，fopen 以只读方式打开文件。您应该指定写入或追加的权限，例如“w”或“a”。

处理完文件后，您需要使用 fclose(fid) 函数关闭它。

以下示例演示了该概念：

示例

创建一个脚本文件，并在其中键入以下代码−

% create a matrix y, with two rows
x = 0:10:100;
y = [x; log(x)];
 
% open a file for writing
fid = fopen('logtable.txt', 'w');
 
% Table Header
fprintf(fid, 'Log     Function\n\n');
 
% print values in column order
% two values appear on each row of the file
fprintf(fid, '%f    %f\n', y);
fclose(fid);

% display the file created
type logtable.txt

运行文件时，它会显示以下结果−

Log         Function

0.000000    -Inf
10.000000    2.302585
20.000000    2.995732
30.000000    3.401197
40.000000    3.688879
50.000000    3.912023
60.000000    4.094345
70.000000    4.248495
80.000000    4.382027
90.000000    4.499810
100.000000    4.605170

MATLAB - 绘图

要绘制函数的图形，您需要执行以下步骤：

• 定义 x，指定变量 x 的 值范围，在此范围内要绘制函数

• 定义函数 y = f(x)

• 调用 plot 命令，如 plot(x, y)

以下示例将演示该概念。让我们绘制从 0 到 100 的 x 值范围内的简单函数 y = x，增量为 5。

创建一个脚本文件，并键入以下代码−

x = [0:5:100];
y = x;
plot(x, y)

运行文件时，MATLAB 将显示以下图形：

让我们再举一个绘制函数 y = x² 的例子。在此示例中，我们将绘制两个具有相同函数的图形，但在第二次绘制时，我们将减少增量值。请注意，随着我们减少增量，图形变得更平滑。

创建一个脚本文件，并键入以下代码−

x = [1 2 3 4 5 6 7 8 9 10];
x = [-100:20:100];
y = x.^2;
plot(x, y)

运行文件时，MATLAB 将显示以下图形：

稍微修改代码文件，将增量减少到 5：

x = [-100:5:100];
y = x.^2;
plot(x, y)

MATLAB 绘制了一个更平滑的图形：

在图形上添加标题、标签、网格线和缩放

MATLAB 允许您添加标题、沿 x 轴和 y 轴的标签、网格线以及调整轴以美化图形。

• xlabel 和 ylabel 命令在 x 轴和 y 轴上生成标签。

• title 命令允许您在图形上放置标题。

• grid on 命令允许您在图形上放置网格线。

• axis equal 命令允许使用相同的比例因子和两个轴上的空间生成图形。

• axis square 命令生成一个正方形图形。

示例

创建一个脚本文件，并键入以下代码−

x = [0:0.01:10];
y = sin(x);
plot(x, y), xlabel('x'), ylabel('Sin(x)'), title('Sin(x) Graph'),
grid on, axis equal

MATLAB 生成以下图形：

在同一图形上绘制多个函数

您可以在同一图形上绘制多个图形。以下示例演示了该概念：

示例

创建一个脚本文件，并键入以下代码−

x = [0 : 0.01: 10];
y = sin(x);
g = cos(x);
plot(x, y, x, g, '.-'), legend('Sin(x)', 'Cos(x)')

MATLAB 生成以下图形：

在图形上设置颜色

MATLAB 提供了八种基本颜色选项用于绘制图形。下表显示了颜色及其代码：

示例

让我们绘制两个多项式的图形

• f(x) = 3x⁴ + 2x³+ 7x² + 2x + 9 和

• g(x) = 5x³ + 9x + 2

创建一个脚本文件，并键入以下代码−

x = [-10 : 0.01: 10];
y = 3*x.^4 + 2 * x.^3 + 7 * x.^2 + 2 * x + 9;
g = 5 * x.^3 + 9 * x + 2;
plot(x, y, 'r', x, g, 'g')

运行文件时，MATLAB 将生成以下图形：

设置轴刻度

axis 命令允许您设置轴刻度。您可以使用以下方式的 axis 命令为 x 轴和 y 轴提供最小值和最大值：

axis ( [xmin xmax ymin ymax] )

以下示例说明了这一点：

示例

创建一个脚本文件，并键入以下代码−

x = [0 : 0.01: 10];
y = exp(-x).* sin(2*x + 3);
plot(x, y), axis([0 10 -1 1])

运行文件时，MATLAB 将生成以下图形：

生成子图

当您在同一图形中创建一系列图形时，这些图形中的每一个都称为子图。subplot 命令用于创建子图。

该命令的语法为：

subplot(m, n, p)

其中，m 和 n 是图形数组的行数和列数，p 指定放置特定图形的位置。

使用 subplot 命令创建的每个图形都可以具有自己的特性。以下示例演示了该概念：

示例

让我们生成两个图形：

y = e^−1.5xsin(10x)

y = e^−2xsin(10x)

创建一个脚本文件，并键入以下代码−

x = [0:0.01:5];
y = exp(-1.5*x).*sin(10*x);
subplot(1,2,1)
plot(x,y), xlabel('x'),ylabel('exp(–1.5x)*sin(10x)'),axis([0 5 -1 1])
y = exp(-2*x).*sin(10*x);
subplot(1,2,2)
plot(x,y),xlabel('x'),ylabel('exp(–2x)*sin(10x)'),axis([0 5 -1 1])

运行文件时，MATLAB 将生成以下图形：

MATLAB - 图形

本章将继续探索 MATLAB 的绘图和图形功能。我们将讨论：

• 绘制条形图
• 绘制等值线
• 三维图形

绘制条形图

bar 命令绘制二维条形图。让我们举一个例子来演示这个想法。

示例

让我们假设一个有 10 名学生的虚拟教室。我们知道这些学生获得的分数百分比分别为 75、58、90、87、50、85、92、75、60 和 95。我们将为这些数据绘制条形图。

创建一个脚本文件，并键入以下代码−

x = [1:10];
y = [75, 58, 90, 87, 50, 85, 92, 75, 60, 95];
bar(x,y), xlabel('Student'),ylabel('Score'),
title('First Sem:')
print -deps graph.eps

运行文件时，MATLAB 将显示以下条形图：

绘制等值线

双变量函数的等值线是函数具有恒定值的曲线。等值线用于通过连接高于给定水平（例如平均海平面）的相同高度的点来创建等高线图。

MATLAB 提供了一个 contour 函数用于绘制等高线图。

示例

让我们生成一个等高线图，显示给定函数 g = f(x, y) 的等值线。此函数有两个变量。因此，我们将不得不生成两个自变量，即两个数据集 x 和 y。这是通过调用 meshgrid 命令完成的。

meshgrid 命令用于生成元素矩阵，这些元素给出 x 和 y 上的范围以及每种情况下增量的规范。

让我们绘制我们的函数 g = f(x, y)，其中 −5 ≤ x ≤ 5，−3 ≤ y ≤ 3。让我们为这两个值取 0.1 的增量。变量设置为：

[x,y] = meshgrid(–5:0.1:5, –3:0.1:3);

最后，我们需要分配函数。让我们的函数为：x² + y²

创建一个脚本文件，并键入以下代码−

[x,y] = meshgrid(-5:0.1:5,-3:0.1:3);   %independent variables
g = x.^2 + y.^2;                       % our function
contour(x,y,g)                         % call the contour function
print -deps graph.eps

运行文件时，MATLAB 将显示以下等高线图：

让我们稍微修改一下代码以美化地图

[x,y] = meshgrid(-5:0.1:5,-3:0.1:3);   %independent variables
g = x.^2 + y.^2;                       % our function
[C, h] = contour(x,y,g);               % call the contour function
set(h,'ShowText','on','TextStep',get(h,'LevelStep')*2)
print -deps graph.eps

运行文件时，MATLAB 将显示以下等高线图：

三维图形

三维图形基本上显示由双变量函数 g = f (x,y) 定义的曲面。

和之前一样，为了定义g，我们首先使用**meshgrid**命令在函数的定义域上创建一组(x,y)点。接下来，我们赋值给函数本身。最后，我们使用**surf**命令创建一个曲面图。

以下示例演示了该概念：

示例

让我们为函数g = xe^{-(x2 + y2)}创建一个3D曲面图。

创建一个脚本文件，并键入以下代码−

[x,y] = meshgrid(-2:.2:2);
g = x .* exp(-x.^2 - y.^2);
surf(x, y, g)
print -deps graph.eps

当你运行文件时，MATLAB将显示以下3D图 -

你也可以使用**mesh**命令生成三维曲面。但是，**surf**命令以彩色显示连接线和曲面的面，而**mesh**命令创建一个线框曲面，用彩色线连接定义点。

MATLAB - 代数

到目前为止，我们已经看到所有示例都可以在MATLAB及其GNU版本（也称为Octave）中运行。但是对于求解基本代数方程，MATLAB和Octave略有不同，因此我们将尝试在单独的部分中介绍MATLAB和Octave。

我们还将讨论代数表达式的因式分解和化简。

在MATLAB中求解基本代数方程

**solve**函数用于求解代数方程。在其最简单的形式中，solve函数将用引号括起来的方程作为参数。

例如，让我们求解方程x-5 = 0中的x。

solve('x-5=0')

MATLAB将执行上述语句并返回以下结果：

ans =
   5

你也可以这样调用solve函数 -

y = solve('x-5 = 0')

MATLAB将执行上述语句并返回以下结果：

y =
   5

你甚至可以不包含方程的右侧 -

solve('x-5')

MATLAB将执行上述语句并返回以下结果：

ans =
   5

如果方程包含多个符号，那么MATLAB默认情况下假设你正在求解x，但是，solve函数还有另一种形式 -

solve(equation, variable)

其中，你也可以提及变量。

例如，让我们求解方程v – u – 3t² = 0关于v的解。在这种情况下，我们应该写 -

solve('v-u-3*t^2=0', 'v')

MATLAB将执行上述语句并返回以下结果：

ans =
   3*t^2 + u

在Octave中求解基本代数方程

**roots**函数用于在Octave中求解代数方程，你可以将上述示例写成如下形式 -

例如，让我们求解方程x-5 = 0中的x。

roots([1, -5])

Octave将执行上述语句并返回以下结果 -

ans = 5

你也可以这样调用solve函数 -

y = roots([1, -5])

Octave将执行上述语句并返回以下结果 -

y = 5

在MATLAB中求解二次方程

**solve**函数也可以求解高阶方程。它通常用于求解二次方程。该函数将方程的根返回到一个数组中。

以下示例求解二次方程x² -7x +12 = 0。创建一个脚本文件并输入以下代码 -

eq = 'x^2 -7*x + 12 = 0';
s = solve(eq);
disp('The first root is: '), disp(s(1));
disp('The second root is: '), disp(s(2));

运行文件时，它会显示以下结果−

The first root is: 
   3
The second root is: 
   4

在Octave中求解二次方程

以下示例在Octave中求解二次方程x² -7x +12 = 0。创建一个脚本文件并输入以下代码 -

s = roots([1, -7, 12]);

disp('The first root is: '), disp(s(1));
disp('The second root is: '), disp(s(2));

运行文件时，它会显示以下结果−

The first root is: 
   4
The second root is: 
   3

在MATLAB中求解高阶方程

**solve**函数也可以求解高阶方程。例如，让我们求解三次方程(x-3)²(x-7) = 0。

solve('(x-3)^2*(x-7)=0')

MATLAB将执行上述语句并返回以下结果：

ans =
   3
   3
   7

对于高阶方程，根很长，包含很多项。你可以通过将它们转换为double来获取这些根的数值。以下示例求解四次方程x⁴ − 7x³ + 3x² − 5x + 9 = 0。

创建一个脚本文件，并键入以下代码−

eq = 'x^4 - 7*x^3 + 3*x^2 - 5*x + 9 = 0';
s = solve(eq);
disp('The first root is: '), disp(s(1));
disp('The second root is: '), disp(s(2));
disp('The third root is: '), disp(s(3));
disp('The fourth root is: '), disp(s(4));

% converting the roots to double type
disp('Numeric value of first root'), disp(double(s(1)));
disp('Numeric value of second root'), disp(double(s(2)));
disp('Numeric value of third root'), disp(double(s(3)));
disp('Numeric value of fourth root'), disp(double(s(4)));

当你运行文件时，它将返回以下结果 -

The first root is: 
6.630396332390718431485053218985
 The second root is: 
1.0597804633025896291682772499885
 The third root is: 
- 0.34508839784665403032666523448675 - 1.0778362954630176596831109269793*i
 The fourth root is: 
- 0.34508839784665403032666523448675 + 1.0778362954630176596831109269793*i
Numeric value of first root
   6.6304
Numeric value of second root
   1.0598
Numeric value of third root
   -0.3451 - 1.0778i
Numeric value of fourth root
   -0.3451 + 1.0778i

请注意，最后两个根是复数。

在Octave中求解高阶方程

以下示例求解四次方程x⁴ − 7x³ + 3x² − 5x + 9 = 0。

创建一个脚本文件，并键入以下代码−

v = [1, -7,  3, -5, 9];
s = roots(v);

% converting the roots to double type
disp('Numeric value of first root'), disp(double(s(1)));
disp('Numeric value of second root'), disp(double(s(2)));
disp('Numeric value of third root'), disp(double(s(3)));
disp('Numeric value of fourth root'), disp(double(s(4)));

当你运行文件时，它将返回以下结果 -

Numeric value of first root
 6.6304
Numeric value of second root
-0.34509 + 1.07784i
Numeric value of third root
-0.34509 - 1.07784i
Numeric value of fourth root
 1.0598

在MATLAB中求解方程组

**solve**函数还可以用来生成包含多个变量的方程组的解。让我们举一个简单的例子来演示这种用法。

让我们求解以下方程 -

5x + 9y = 5

3x – 6y = 4

创建一个脚本文件，并键入以下代码−

s = solve('5*x + 9*y = 5','3*x - 6*y = 4');
s.x
s.y

运行文件时，它会显示以下结果−

ans =
   22/19
ans =
   -5/57

同样地，你可以求解更大的线性系统。考虑以下方程组 -

x + 3y -2z = 5

3x + 5y + 6z = 7

2x + 4y + 3z = 8

在Octave中求解方程组

我们有一个稍微不同的方法来求解'n'个未知数的'n'个线性方程组。让我们举一个简单的例子来演示这种用法。

让我们求解以下方程 -

5x + 9y = 5

3x – 6y = 4

这样的线性方程组可以写成单个矩阵方程Ax = b，其中A是系数矩阵，b是包含线性方程右侧的列向量，x是表示解的列向量，如下面的程序所示 -

创建一个脚本文件，并键入以下代码−

A = [5, 9; 3, -6];
b = [5;4];
A \ b

运行文件时，它会显示以下结果−

ans =

   1.157895
  -0.087719

同样地，你可以求解如下所示的更大的线性系统 -

x + 3y -2z = 5

3x + 5y + 6z = 7

2x + 4y + 3z = 8

在MATLAB中展开和收集方程

**expand**和**collect**函数分别展开和收集方程。以下示例演示了这些概念 -

当你使用许多符号函数时，你应该声明你的变量是符号变量。

创建一个脚本文件，并键入以下代码−

syms x   %symbolic variable x
syms y   %symbolic variable x
% expanding equations
expand((x-5)*(x+9))
expand((x+2)*(x-3)*(x-5)*(x+7))
expand(sin(2*x))
expand(cos(x+y))
 
% collecting equations
collect(x^3 *(x-7))
collect(x^4*(x-3)*(x-5))

运行文件时，它会显示以下结果−

ans =
   x^2 + 4*x - 45
ans =
   x^4 + x^3 - 43*x^2 + 23*x + 210
ans =
   2*cos(x)*sin(x)
ans =
   cos(x)*cos(y) - sin(x)*sin(y)
ans =
   x^4 - 7*x^3
ans =
   x^6 - 8*x^5 + 15*x^4

在Octave中展开和收集方程

你需要安装**symbolic**包，它提供了**expand**和**collect**函数，分别用于展开和收集方程。以下示例演示了这些概念 -

当你使用许多符号函数时，你应该声明你的变量是符号变量，但Octave定义符号变量的方法不同。注意**Sin**和**Cos**的使用，它们也在symbolic包中定义。

创建一个脚本文件，并键入以下代码−

% first of all load the package, make sure its installed.
pkg load symbolic

% make symbols module available
symbols

% define symbolic variables
x = sym ('x');
y = sym ('y');
z = sym ('z');

% expanding equations
expand((x-5)*(x+9))
expand((x+2)*(x-3)*(x-5)*(x+7))
expand(Sin(2*x))
expand(Cos(x+y))
 
% collecting equations
collect(x^3 *(x-7), z)
collect(x^4*(x-3)*(x-5), z)

运行文件时，它会显示以下结果−

ans =

-45.0+x^2+(4.0)*x
ans =

210.0+x^4-(43.0)*x^2+x^3+(23.0)*x
ans =

sin((2.0)*x)
ans =

cos(y+x)
ans =

x^(3.0)*(-7.0+x)
ans =

(-3.0+x)*x^(4.0)*(-5.0+x)

代数表达式的因式分解和化简

**factor**函数对表达式进行因式分解，**simplify**函数对表达式进行化简。以下示例演示了这个概念 -

示例

创建一个脚本文件，并键入以下代码−

syms x
syms y
factor(x^3 - y^3)
factor([x^2-y^2,x^3+y^3])
simplify((x^4-16)/(x^2-4))

运行文件时，它会显示以下结果−

ans =
   (x - y)*(x^2 + x*y + y^2)
ans =
   [ (x - y)*(x + y), (x + y)*(x^2 - x*y + y^2)]
ans =
   x^2 + 4

MATLAB - 微积分

MATLAB提供了多种方法来解决微积分问题，求解任意阶的微分方程以及计算极限。最棒的是，你可以轻松地绘制复杂函数的图形，并通过求解原始函数及其导数来检查图形上的最大值、最小值和其他驻点。

本章将讨论微积分问题。在本章中，我们将讨论预备微积分的概念，即计算函数的极限并验证极限的性质。

在下一章“微分”中，我们将计算表达式的导数，并在图形上找到局部最大值和最小值。我们还将讨论求解微分方程。

最后，在“积分”一章中，我们将讨论积分学。

计算极限

MATLAB提供了**limit**函数用于计算极限。在其最基本的形式中，**limit**函数将表达式作为参数，并找到当自变量趋于零时表达式的极限。

例如，让我们计算函数f(x) = (x³ + 5)/(x⁴ + 7)在x趋于零时的极限。

syms x
limit((x^3 + 5)/(x^4 + 7))

MATLAB将执行上述语句并返回以下结果：

ans =
   5/7

limit函数属于符号计算的范畴；你需要使用**syms**函数来告诉MATLAB你正在使用哪些符号变量。你还可以计算函数的极限，当变量趋于某个非零数时。为了计算lim _x->a(f(x))，我们使用带有参数的limit命令。第一个是表达式，第二个是x接近的数字，这里它是a。

例如，让我们计算函数f(x) = (x-3)/(x-1)在x趋于1时的极限。

limit((x - 3)/(x-1),1)

MATLAB将执行上述语句并返回以下结果：

ans =
   NaN

让我们再举一个例子，

limit(x^2 + 5, 3)

MATLAB将执行上述语句并返回以下结果：

ans =
   14

使用Octave计算极限

以下是使用**symbolic**包的上述示例的Octave版本，尝试执行并比较结果 -

pkg load symbolic
symbols

x = sym("x");
subs((x^3+5)/(x^4+7),x,0)

Octave将执行上述语句并返回以下结果 -

ans =
   0.7142857142857142857

验证极限的基本性质

代数极限定理提供了一些极限的基本性质。它们如下 -

让我们考虑两个函数 -

• f(x) = (3x + 5)/(x - 3)
• g(x) = x² + 1。

让我们计算这两个函数在x趋于5时的极限，并使用这两个函数和MATLAB验证极限的基本性质。

示例

创建一个脚本文件，并将以下代码输入其中−

syms x
f = (3*x + 5)/(x-3);
g = x^2 + 1;
l1 = limit(f, 4)
l2 = limit (g, 4)
lAdd = limit(f + g, 4)
lSub = limit(f - g, 4)
lMult = limit(f*g, 4)
lDiv = limit (f/g, 4)

运行文件时，它会显示−

l1 =
   17
  
l2 =
   17
  
lAdd =
   34
 
lSub =
   0
  
lMult =
   289
  
lDiv =
   1

使用Octave验证极限的基本性质

以下是使用**symbolic**包的上述示例的Octave版本，尝试执行并比较结果 -

pkg load symbolic
symbols

x = sym("x");
f = (3*x + 5)/(x-3);
g = x^2 + 1;

l1 = subs(f, x, 4)
l2 = subs (g, x, 4)
lAdd = subs (f+g, x, 4)
lSub = subs (f-g, x, 4)
lMult = subs (f*g, x, 4)
lDiv = subs (f/g, x, 4)

Octave将执行上述语句并返回以下结果 -

l1 =
   17.0
l2 =
   17.0
lAdd =
   34.0
lSub =
   0.0
lMult =
   289.0
lDiv =
   1.0

左侧和右侧极限

当函数在变量的某个特定值处存在间断时，该点的极限不存在。换句话说，当x从左侧逼近a时的极限值不等于x从右侧逼近a时的极限值时，函数f(x)在x = a处存在间断。

这导致了左侧极限和右侧极限的概念。左侧极限定义为x从左侧趋于a时的极限，即x逼近a，且x < a。右侧极限定义为x从右侧趋于a时的极限，即x逼近a，且x > a。当左侧极限和右侧极限不相等时，极限不存在。

让我们考虑一个函数 -

f(x) = (x - 3)/|x - 3|

我们将证明lim_x->3 f(x)不存在。MATLAB通过两种方式帮助我们证实这一点 -

• 通过绘制函数的图形并显示间断点。
• 通过计算极限并显示两者不同。

左侧和右侧极限是通过将字符字符串'left'和'right'作为最后一个参数传递给limit命令来计算的。

示例

创建一个脚本文件，并将以下代码输入其中−

f = (x - 3)/abs(x-3);
ezplot(f,[-1,5])
l = limit(f,x,3,'left')
r = limit(f,x,3,'right')

当你运行文件时，MATLAB将绘制以下图形

之后将显示以下输出 -

l =
   -1
  
r =
   1

MATLAB - 微分

MATLAB提供了**diff**命令用于计算符号导数。在其最简单的形式中，你将要微分的函数作为参数传递给diff命令。

例如，让我们计算函数f(t) = 3t² + 2t^-2的导数。

示例

创建一个脚本文件，并将以下代码输入其中−

syms t
f = 3*t^2 + 2*t^(-2);
diff(f)

编译并执行上述代码后，会产生以下结果：

ans =
6*t - 4/t^3

以下是上述计算的Octave等价物 -

pkg load symbolic
symbols

t = sym("t");
f = 3*t^2 + 2*t^(-2);
differentiate(f,t)

Octave执行代码并返回以下结果 -

ans =
   -(4.0)*t^(-3.0)+(6.0)*t

验证微分的基本规则

让我们简要说明函数微分的各种方程或规则，并验证这些规则。为此，我们将使用f'(x)表示一阶导数，f"(x)表示二阶导数。

以下是微分的规则 -

规则1

对于任何函数f和g以及任何实数a和b，函数 -

**h(x) = af(x) + bg(x)**关于x的导数由 -

h'(x) = af'(x) + bg'(x)

规则2

**加法**和**减法**规则指出，如果f和g是两个函数，f'和g'分别是它们的导数，则，

(f + g)' = f' + g'

(f - g)' = f' - g'

规则3

**乘积**规则指出，如果f和g是两个函数，f'和g'分别是它们的导数，则，

(f.g)' = f'.g + g'.f

规则4

**商**规则指出，如果f和g是两个函数，f'和g'分别是它们的导数，则，

(f/g)' = (f'.g - g'.f)/g²

规则5

**多项式**或基本幂规则指出，如果y = f(x) = xⁿ，则f' = n. x^(n-1)

该规则的一个直接结果是任何常数的导数为零，即如果y = k，任何常数，则

f' = 0

规则6

链式法则指出，函数的函数h(x) = f(g(x))关于x的导数为：

h'(x)= f'(g(x)).g'(x)

示例

创建一个脚本文件，并将以下代码输入其中−

syms x
syms t

f = (x + 2)*(x^2 + 3)
der1 = diff(f)
f = (t^2 + 3)*(sqrt(t) + t^3)
der2 = diff(f)
f = (x^2 - 2*x + 1)*(3*x^3 - 5*x^2 + 2)
der3 = diff(f)
f = (2*x^2 + 3*x)/(x^3 + 1)
der4 = diff(f)
f = (x^2 + 1)^17
der5 = diff(f)
f = (t^3 + 3* t^2 + 5*t -9)^(-6)
der6 = diff(f)

运行文件后，MATLAB 显示以下结果：

f =
   (x^2 + 3)*(x + 2)
 
   der1 =
   2*x*(x + 2) + x^2 + 3
  
f =
   (t^(1/2) + t^3)*(t^2 + 3)
 
   der2 =
   (t^2 + 3)*(3*t^2 + 1/(2*t^(1/2))) + 2*t*(t^(1/2) + t^3)
  
f =
   (x^2 - 2*x + 1)*(3*x^3 - 5*x^2 + 2)
  
der3 =
   (2*x - 2)*(3*x^3 - 5*x^2 + 2) - (- 9*x^2 + 10*x)*(x^2 - 2*x + 1)
 
f =
   (2*x^2 + 3*x)/(x^3 + 1)
  
der4 =
   (4*x + 3)/(x^3 + 1) - (3*x^2*(2*x^2 + 3*x))/(x^3 + 1)^2
  
f =
   (x^2 + 1)^17
  
der5 =
   34*x*(x^2 + 1)^16
  
f =
   1/(t^3 + 3*t^2 + 5*t - 9)^6
  
der6 =
   -(6*(3*t^2 + 6*t + 5))/(t^3 + 3*t^2 + 5*t - 9)^7

以下是上述计算的Octave等价物 -

pkg load symbolic
symbols

x = sym("x");
t = sym("t");
f = (x + 2)*(x^2 + 3) 
der1 = differentiate(f,x) 
f = (t^2 + 3)*(t^(1/2) + t^3) 
der2 = differentiate(f,t) 
f = (x^2 - 2*x + 1)*(3*x^3 - 5*x^2 + 2) 
der3 = differentiate(f,x) 
f = (2*x^2 + 3*x)/(x^3 + 1) 
der4 = differentiate(f,x) 
f = (x^2 + 1)^17 
der5 = differentiate(f,x) 
f = (t^3 + 3* t^2 + 5*t -9)^(-6) 
der6 = differentiate(f,t)

Octave执行代码并返回以下结果 -

f =

(2.0+x)*(3.0+x^(2.0))
der1 =

3.0+x^(2.0)+(2.0)*(2.0+x)*x
f =

(t^(3.0)+sqrt(t))*(3.0+t^(2.0))
der2 =

(2.0)*(t^(3.0)+sqrt(t))*t+((3.0)*t^(2.0)+(0.5)*t^(-0.5))*(3.0+t^(2.0))
f =

(1.0+x^(2.0)-(2.0)*x)*(2.0-(5.0)*x^(2.0)+(3.0)*x^(3.0))
der3 =

(-2.0+(2.0)*x)*(2.0-(5.0)*x^(2.0)+(3.0)*x^(3.0))+((9.0)*x^(2.0)-(10.0)*x)*(1.0+x^(2.0)-(2.0)*x)
f =

(1.0+x^(3.0))^(-1)*((2.0)*x^(2.0)+(3.0)*x)
der4 =

(1.0+x^(3.0))^(-1)*(3.0+(4.0)*x)-(3.0)*(1.0+x^(3.0))^(-2)*x^(2.0)*((2.0)*x^(2.0)+(3.0)*x)
f =

(1.0+x^(2.0))^(17.0)
der5 =

(34.0)*(1.0+x^(2.0))^(16.0)*x
f =

(-9.0+(3.0)*t^(2.0)+t^(3.0)+(5.0)*t)^(-6.0)
der6 =

-(6.0)*(-9.0+(3.0)*t^(2.0)+t^(3.0)+(5.0)*t)^(-7.0)*(5.0+(3.0)*t^(2.0)+(6.0)*t)

指数函数、对数函数和三角函数的导数

下表提供了常用指数函数、对数函数和三角函数的导数：

示例

创建一个脚本文件，并将以下代码输入其中−

syms x
y = exp(x)
diff(y)
y = x^9
diff(y)
y = sin(x)
diff(y)
y = tan(x)
diff(y)
y = cos(x)
diff(y)
y = log(x)
diff(y)
y = log10(x)
diff(y)
y = sin(x)^2
diff(y)
y = cos(3*x^2 + 2*x + 1)
diff(y)
y = exp(x)/sin(x)
diff(y)

运行文件后，MATLAB 显示以下结果：

y =
   exp(x)
   ans =
   exp(x)

y =
   x^9
   ans =
   9*x^8
  
y =
   sin(x)
   ans =
   cos(x)
  
y =
   tan(x)
   ans =
   tan(x)^2 + 1
 
y =
   cos(x)
   ans =
   -sin(x)
  
y =
   log(x)
   ans =
   1/x
  
y =
   log(x)/log(10)
   ans =
   1/(x*log(10))
 
y =
   sin(x)^2
   ans =
   2*cos(x)*sin(x)
 
y =
   cos(3*x^2 + 2*x + 1)
   ans =
   -sin(3*x^2 + 2*x + 1)*(6*x + 2)
  
y =
   exp(x)/sin(x)
   ans =
   exp(x)/sin(x) - (exp(x)*cos(x))/sin(x)^2

以下是上述计算的Octave等价物 -

pkg load symbolic
symbols

x = sym("x");
y = Exp(x)
differentiate(y,x)

y = x^9
differentiate(y,x)

y = Sin(x)
differentiate(y,x)

y = Tan(x)
differentiate(y,x)

y = Cos(x)
differentiate(y,x)

y = Log(x)
differentiate(y,x)

% symbolic packages does not have this support
%y = Log10(x)
%differentiate(y,x)

y = Sin(x)^2
differentiate(y,x)

y = Cos(3*x^2 + 2*x + 1)
differentiate(y,x)

y = Exp(x)/Sin(x)
differentiate(y,x)

Octave执行代码并返回以下结果 -

y =

exp(x)
ans =

exp(x)
y =

x^(9.0)
ans =

(9.0)*x^(8.0)
y =

sin(x)
ans =

cos(x)
y =

tan(x)
ans =

1+tan(x)^2
y =

cos(x)
ans =

-sin(x)
y =

log(x)
ans =

x^(-1)
y =

sin(x)^(2.0)
ans =

(2.0)*sin(x)*cos(x)
y =

cos(1.0+(2.0)*x+(3.0)*x^(2.0))
ans =

-(2.0+(6.0)*x)*sin(1.0+(2.0)*x+(3.0)*x^(2.0))
y =

sin(x)^(-1)*exp(x)
ans =

sin(x)^(-1)*exp(x)-sin(x)^(-2)*cos(x)*exp(x)

计算高阶导数

要计算函数 f 的高阶导数，我们使用语法diff(f,n)。

让我们计算函数 y = f(x) = x .e^-3x 的二阶导数。

f = x*exp(-3*x);
diff(f, 2)

MATLAB 执行代码并返回以下结果：

ans =
9*x*exp(-3*x) - 6*exp(-3*x)

以下是上述计算的Octave等价物 -

pkg load symbolic
symbols

x = sym("x");
f = x*Exp(-3*x);
differentiate(f, x, 2)

Octave执行代码并返回以下结果 -

ans =

(9.0)*exp(-(3.0)*x)*x-(6.0)*exp(-(3.0)*x)

示例

在这个例子中，让我们解决一个问题。给定一个函数y = f(x) = 3 sin(x) + 7 cos(5x)。我们需要找出方程f" + f = -5cos(2x)是否成立。

创建一个脚本文件，并将以下代码输入其中−

syms x
y = 3*sin(x)+7*cos(5*x);  % defining the function
lhs = diff(y,2)+y;        %evaluting the lhs of the equation
rhs = -5*cos(2*x);        %rhs of the equation
if(isequal(lhs,rhs))
   disp('Yes, the equation holds true');
else
   disp('No, the equation does not hold true');
end
disp('Value of LHS is: '), disp(lhs);

运行文件时，它会显示以下结果−

No, the equation does not hold true
Value of LHS is: 
-168*cos(5*x)

以下是上述计算的Octave等价物 -

pkg load symbolic
symbols

x = sym("x");
y = 3*Sin(x)+7*Cos(5*x);           % defining the function
lhs = differentiate(y, x, 2) + y;  %evaluting the lhs of the equation
rhs = -5*Cos(2*x);                 %rhs of the equation

if(lhs == rhs)
   disp('Yes, the equation holds true');
else
   disp('No, the equation does not hold true');
end
disp('Value of LHS is: '), disp(lhs);

Octave执行代码并返回以下结果 -

No, the equation does not hold true
Value of LHS is: 
-(168.0)*cos((5.0)*x)

寻找曲线的极大值和极小值

如果我们正在寻找图形的局部极大值和极小值，我们基本上是在寻找函数图形在特定局部或特定符号变量值范围内最高或最低的点。

对于函数 y = f(x)，图形上斜率为零的点称为驻点。换句话说，驻点是 f'(x) = 0 的点。

为了找到函数的驻点，我们需要求导，并将导数设为零并求解方程。

示例

让我们找到函数 f(x) = 2x³ + 3x² − 12x + 17 的驻点。

采取以下步骤：

首先，让我们输入函数并绘制其图形。

syms x
y = 2*x^3 + 3*x^2 - 12*x + 17;   % defining the function
ezplot(y)

MATLAB 执行代码并返回以下图形：

以下是上述示例的 Octave 等效代码：

pkg load symbolic
symbols

x = sym('x');
y = inline("2*x^3 + 3*x^2 - 12*x + 17");

ezplot(y)
print -deps graph.eps

我们的目标是在图形上找到一些局部极大值和极小值，因此让我们在图形的区间 [-2, 2] 上找到局部极大值和极小值。

syms x
y = 2*x^3 + 3*x^2 - 12*x + 17;   % defining the function
ezplot(y, [-2, 2])

MATLAB 执行代码并返回以下图形：

以下是上述示例的 Octave 等效代码：

pkg load symbolic
symbols

x = sym('x');
y = inline("2*x^3 + 3*x^2 - 12*x + 17");

ezplot(y, [-2, 2])
print -deps graph.eps

接下来，让我们计算导数。

g = diff(y)

MATLAB 执行代码并返回以下结果：

g =
   6*x^2 + 6*x - 12

以下是上述计算的 Octave 等效代码：

pkg load symbolic
symbols

x = sym("x");
y = 2*x^3 + 3*x^2 - 12*x + 17;
g = differentiate(y,x)

Octave执行代码并返回以下结果 -

g =
   -12.0+(6.0)*x+(6.0)*x^(2.0)

让我们求解导数函数 g，以获得其变为零的值。

s = solve(g)

MATLAB 执行代码并返回以下结果：

s =
   1
   -2

以下是上述计算的Octave等价物 -

pkg load symbolic
symbols

x = sym("x");
y = 2*x^3 + 3*x^2 - 12*x + 17;
g = differentiate(y,x)
roots([6, 6, -12])

Octave执行代码并返回以下结果 -

g =

-12.0+(6.0)*x^(2.0)+(6.0)*x
ans =

  -2
   1

这与我们的图形一致。因此，让我们在临界点 x = 1, -2 处计算函数 f 的值。 我们可以使用subs命令在符号函数中替换一个值。

subs(y, 1), subs(y, -2)

MATLAB 执行代码并返回以下结果：

ans =
   10
ans =
   37

以下是上述计算的Octave等价物 -

pkg load symbolic
symbols

x = sym("x");
y = 2*x^3 + 3*x^2 - 12*x + 17;
g = differentiate(y,x)

roots([6, 6, -12])
subs(y, x, 1), subs(y, x, -2)

ans =
   10.0
ans =
   37.0-4.6734207789940138748E-18*I

因此，函数 f(x) = 2x³ + 3x² − 12x + 17 在区间 [-2,2] 上的最小值和最大值分别为 10 和 37。

求解微分方程

MATLAB 提供了dsolve命令来符号求解微分方程。

dsolve命令用于求解单个方程的最基本形式是

dsolve('eqn') 

其中eqn是用于输入方程的文本字符串。

它返回一个符号解，其中包含一组 MATLAB 标记为 C1、C2 等的任意常数。

您还可以为问题指定初始条件和边界条件，作为方程后面的逗号分隔列表，如下所示：

dsolve('eqn','cond1', 'cond2',…)  

为了使用 dsolve 命令，导数用 D 表示。例如，方程 f'(t) = -2*f + cost(t) 输入为：

'Df = -2*f + cos(t)'

高阶导数用 D 后跟导数的阶数表示。

例如，方程 f"(x) + 2f'(x) = 5sin3x 应输入为：

'D2y + 2Dy = 5*sin(3*x)'

让我们举一个一阶微分方程的简单例子：y' = 5y。

s = dsolve('Dy = 5*y')

MATLAB 执行代码并返回以下结果：

s =
   C2*exp(5*t)

让我们再举一个二阶微分方程的例子：y" - y = 0，y(0) = -1，y'(0) = 2。

dsolve('D2y - y = 0','y(0) = -1','Dy(0) = 2')

MATLAB 执行代码并返回以下结果：

ans =
   exp(t)/2 - (3*exp(-t))/2

MATLAB - 积分

积分处理两种本质上不同的问题类型。

• 在第一种类型中，给定函数的导数，我们想要找到该函数。因此，我们基本上是反转微分过程。这个反向过程称为反微分、求原函数或求不定积分。

• 第二类问题涉及将非常多的非常小的量加起来，然后取这些量的大小接近零时的极限，而项数趋于无穷大。这个过程导致了定积分的定义。

定积分用于求面积、体积、重心、惯性矩、力做的功以及许多其他应用。

使用 MATLAB 求不定积分

根据定义，如果函数 f(x) 的导数是 f'(x)，那么我们说 f'(x) 关于 x 的不定积分是 f(x)。例如，由于 x² 关于 x 的导数是 2x，所以我们可以说 2x 的不定积分是 x²。

用符号表示：

f'(x²) = 2x，因此，

∫ 2xdx = x²。

不定积分不是唯一的，因为对于任意常数 c 的值，x² + c 的导数也将是 2x。

用符号表示为：

∫ 2xdx = x² + c.

其中，c 称为“任意常数”。

MATLAB 提供了一个int命令来计算表达式的积分。要推导出函数不定积分的表达式，我们写：

int(f);

例如，从我们之前的例子：

syms x 
int(2*x)

MATLAB 执行上述语句并返回以下结果：

ans =
   x^2

示例 1

在这个例子中，让我们找到一些常用表达式的积分。创建一个脚本文件，并在其中键入以下代码：

syms x n

int(sym(x^n))
f = 'sin(n*t)'
int(sym(f))
syms a t
int(a*cos(pi*t))
int(a^x)

运行文件时，它会显示以下结果−

ans =
   piecewise([n == -1, log(x)], [n ~= -1, x^(n + 1)/(n + 1)])
f =
sin(n*t)
ans =
   -cos(n*t)/n
   ans =
   (a*sin(pi*t))/pi
   ans =
   a^x/log(a)

示例 2

创建一个脚本文件，并在其中键入以下代码−

syms x n
int(cos(x))
int(exp(x))
int(log(x))
int(x^-1)
int(x^5*cos(5*x))
pretty(int(x^5*cos(5*x)))
int(x^-5)
int(sec(x)^2)
pretty(int(1 - 10*x + 9 * x^2))
int((3 + 5*x -6*x^2 - 7*x^3)/2*x^2)
pretty(int((3 + 5*x -6*x^2 - 7*x^3)/2*x^2))

请注意，pretty函数以更易读的格式返回表达式。

运行文件时，它会显示以下结果−

ans =
   sin(x)
 
ans =
   exp(x)
 
ans =
   x*(log(x) - 1)
 
ans =
   log(x)
 
ans =
(24*cos(5*x))/3125 + (24*x*sin(5*x))/625 - (12*x^2*cos(5*x))/125 + (x^4*cos(5*x))/5 - (4*x^3*sin(5*x))/25 + (x^5*sin(5*x))/5
                                    2             4 
   24 cos(5 x)   24 x sin(5 x)   12 x  cos(5 x)   x  cos(5 x) 
   ----------- + ------------- - -------------- + ------------ 
      3125            625             125              5 
   
        3             5 
 
   4 x  sin(5 x)   x  sin(5 x) 
   ------------- + ----------- 
         25              5
 
ans =
-1/(4*x^4)
 
ans =
tan(x)
        2 
  x (3 x  - 5 x + 1)
 
ans = 
- (7*x^6)/12 - (3*x^5)/5 + (5*x^4)/8 + x^3/2
 
      6      5      4    3 
    7 x    3 x    5 x    x 
  - ---- - ---- + ---- + -- 
     12     5      8     2

使用 MATLAB 求定积分

根据定义，定积分基本上是和的极限。我们使用定积分来求面积，例如曲线与 x 轴之间的面积以及两条曲线之间的面积。定积分也可以用于其他情况，其中所需的数量可以表示为和的极限。

int函数可以通过传递要计算积分的极限来用于定积分。

计算

我们写：

int(x, a, b)

例如，要计算的值，我们写：

int(x, 4, 9)

MATLAB 执行上述语句并返回以下结果：

ans =
   65/2

以下是上述计算的Octave等价物 -

pkg load symbolic
symbols

x = sym("x");
f = x;
c = [1, 0];
integral = polyint(c);

a = polyval(integral, 9) - polyval(integral, 4);
display('Area: '), disp(double(a));

Octave执行代码并返回以下结果 -

Area: 

   32.500

可以使用 Octave 提供的 quad() 函数给出另一种解决方案，如下所示：

pkg load symbolic
symbols

f = inline("x");
[a, ierror, nfneval] = quad(f, 4, 9);

display('Area: '), disp(double(a));

Octave执行代码并返回以下结果 -

Area: 
   32.500

示例 1

让我们计算 x 轴、曲线 y = x³−2x+5 和纵坐标 x = 1 和 x = 2 所包围的面积。

所需面积由下式给出：

创建一个脚本文件，并键入以下代码−

f = x^3 - 2*x +5;
a = int(f, 1, 2)
display('Area: '), disp(double(a));

运行文件时，它会显示以下结果−

a =
23/4
Area: 
   5.7500

以下是上述计算的Octave等价物 -

pkg load symbolic
symbols

x = sym("x");
f = x^3 - 2*x +5;
c = [1, 0, -2, 5];
integral = polyint(c);

a = polyval(integral, 2) - polyval(integral, 1);
display('Area: '), disp(double(a));

Octave执行代码并返回以下结果 -

Area: 

   5.7500

可以使用 Octave 提供的 quad() 函数给出另一种解决方案，如下所示：

pkg load symbolic
symbols

x = sym("x");
f = inline("x^3 - 2*x +5");

[a, ierror, nfneval] = quad(f, 1, 2);
display('Area: '), disp(double(a));

Octave执行代码并返回以下结果 -

Area: 
   5.7500

示例 2

求曲线 f(x) = x² cos(x) 在 −4 ≤ x ≤ 9 范围内的面积。

创建一个脚本文件，并编写以下代码：

f = x^2*cos(x);
ezplot(f, [-4,9])
a = int(f, -4, 9)
disp('Area: '), disp(double(a));

运行文件后，MATLAB 会绘制图形：

输出如下：

a = 
8*cos(4) + 18*cos(9) + 14*sin(4) + 79*sin(9)
 
Area: 
   0.3326

以下是上述计算的Octave等价物 -

pkg load symbolic
symbols

x = sym("x");
f = inline("x^2*cos(x)");

ezplot(f, [-4,9])
print -deps graph.eps

[a, ierror, nfneval] = quad(f, -4, 9);
display('Area: '), disp(double(a));

MATLAB - 多项式

MATLAB 将多项式表示为包含按降幂排序的系数的行向量。例如，方程 P(x) = x⁴ + 7x³ - 5x + 9 可以表示为：

p = [1 7 0 -5 9];

评估多项式

polyval函数用于在指定值处评估多项式。例如，要评估我们之前在 x = 4 处的多项式p，键入：

p = [1 7 0  -5 9];
polyval(p,4)

MATLAB 执行上述语句并返回以下结果：

ans = 693

MATLAB 还提供了polyvalm函数来评估矩阵多项式。矩阵多项式是多项式，其变量为矩阵。

例如，让我们创建一个方阵 X 并评估多项式 p 在 X 处的值：

p = [1 7 0  -5 9];
X = [1 2 -3 4; 2 -5 6 3; 3 1 0 2; 5 -7 3 8];
polyvalm(p, X)

MATLAB 执行上述语句并返回以下结果：

ans =
      2307       -1769        -939        4499
      2314       -2376        -249        4695
      2256       -1892        -549        4310
      4570       -4532       -1062        9269

查找多项式的根

roots函数计算多项式的根。例如，要计算我们多项式 p 的根，键入：

p = [1 7 0  -5 9];
r = roots(p)

MATLAB 执行上述语句并返回以下结果：

r =
   -6.8661 + 0.0000i
   -1.4247 + 0.0000i
   0.6454 + 0.7095i
   0.6454 - 0.7095i

poly函数是 roots 函数的反函数，并返回到多项式系数。例如：

p2 = poly(r)

MATLAB 执行上述语句并返回以下结果：

p2 =

   Columns 1 through 3:

      1.00000 + 0.00000i   7.00000 + 0.00000i   0.00000 + 0.00000i

   Columns 4 and 5:

      -5.00000 - 0.00000i   9.00000 + 0.00000i

多项式曲线拟合

polyfit函数找到以最小二乘意义拟合一组数据的多项式的系数。如果 x 和 y 是两个包含要拟合到 n 次多项式的 x 和 y 数据的向量，那么我们可以通过编写以下代码获得拟合数据的多项式：

p = polyfit(x,y,n)

示例

创建一个脚本文件，并键入以下代码−

x = [1 2 3 4 5 6]; y = [5.5 43.1 128 290.7 498.4 978.67];   %data
p = polyfit(x,y,4)   %get the polynomial

% Compute the values of the polyfit estimate over a finer range, 
% and plot the estimate over the real data values for comparison:
x2 = 1:.1:6;          
y2 = polyval(p,x2);
plot(x,y,'o',x2,y2)
grid on

运行文件后，MATLAB 显示以下结果：

p =
   4.1056  -47.9607  222.2598 -362.7453  191.1250

并绘制以下图形：

MATLAB - 变换

MATLAB 提供了用于处理变换的命令，例如拉普拉斯变换和傅里叶变换。变换在科学和工程中用作简化分析和从另一个角度查看数据的工具。

例如，傅里叶变换允许我们将表示为时间函数的信号转换为频率函数。拉普拉斯变换允许我们将微分方程转换为代数方程。

MATLAB 提供了laplace、fourier和fft命令来处理拉普拉斯变换、傅里叶变换和快速傅里叶变换。

拉普拉斯变换

时间函数 f(t) 的拉普拉斯变换由以下积分给出：

拉普拉斯变换也表示为 f(t) 到 F(s) 的变换。您可以看到此变换或积分过程将 f(t)（符号变量 t 的函数）转换为另一个函数 F(s)，其变量为 s。

拉普拉斯变换将微分方程转换为代数方程。要计算函数 f(t) 的拉普拉斯变换，请编写：

laplace(f(t))

示例

在这个例子中，我们将计算一些常用函数的拉普拉斯变换。

创建一个脚本文件，并键入以下代码−

syms s t a b w

laplace(a)
laplace(t^2)
laplace(t^9)
laplace(exp(-b*t))
laplace(sin(w*t))
laplace(cos(w*t))

运行文件时，它会显示以下结果−

ans =
   1/s^2

ans =
   2/s^3

ans =
   362880/s^10

ans =
   1/(b + s)
  
ans =
   w/(s^2 + w^2)
  
ans =
   s/(s^2 + w^2)

拉普拉斯逆变换

MATLAB 允许我们使用ilaplace命令计算拉普拉斯逆变换。

例如：

ilaplace(1/s^3)

MATLAB 将执行上述语句并显示结果：

ans =
   t^2/2

示例

创建一个脚本文件，并键入以下代码−

syms s t a b w

ilaplace(1/s^7)
ilaplace(2/(w+s))
ilaplace(s/(s^2+4))
ilaplace(exp(-b*t))
ilaplace(w/(s^2 + w^2))
ilaplace(s/(s^2 + w^2))

运行文件时，它会显示以下结果−

ans =
   t^6/720

ans =
   2*exp(-t*w)

ans =
   cos(2*t)

ans =
   ilaplace(exp(-b*t), t, x)

ans =
   sin(t*w)

ans =
   cos(t*w)

傅里叶变换

傅里叶变换通常将时间数学函数 f(t) 转换为一个新函数，有时表示为或 F，其参数为频率，单位为周期/秒（赫兹）或弧度/秒。然后将新函数称为傅里叶变换和/或函数 f 的频谱。

示例

创建一个脚本文件，并在其中键入以下代码−

syms x 
f = exp(-2*x^2);     %our function
ezplot(f,[-2,2])     % plot of our function
FT = fourier(f)      % Fourier transform

运行文件后，MATLAB 会绘制以下图形：

显示以下结果：

FT =
   (2^(1/2)*pi^(1/2)*exp(-w^2/8))/2

绘制傅里叶变换为：

ezplot(FT)

给出以下图形：

傅里叶逆变换

MATLAB 提供了ifourier命令来计算函数的傅里叶逆变换。例如，

f = ifourier(-2*exp(-abs(w)))

MATLAB 将执行上述语句并显示结果：

f =
   -2/(pi*(x^2 + 1))

MATLAB - GNU Octave 教程

GNU Octave 是一种类似于 MATLAB 的高级编程语言，并且与 MATLAB 大部分兼容。它也用于数值计算。

Octave 与 MATLAB 具有以下共同特征：

• 矩阵是基本数据类型
• 它内置支持复数
• 它具有内置的数学函数和库
• 它支持用户定义的函数

GNU Octave 也是免费可再分发的软件。您可以根据自由软件基金会发布的 GNU 通用公共许可证 (GPL) 的条款重新分发和/或修改它。

MATLAB 与 Octave 的比较

大多数 MATLAB 程序都可以在 Octave 中运行，但一些 Octave 程序可能无法在 MATLAB 中运行，因为 Octave 允许某些 MATLAB 不支持的语法。

例如，MATLAB 仅支持单引号，但 Octave 支持单引号和双引号来定义字符串。如果您正在寻找 Octave 的教程，那么请从头到尾阅读本教程，它涵盖了 MATLAB 和 Octave。

兼容示例

本教程中涵盖的几乎所有示例都兼容 MATLAB 和 Octave。让我们在 MATLAB 和 Octave 中尝试以下示例，该示例在没有任何语法更改的情况下产生相同的结果。

此示例为函数 g = xe^{-(x2 + y2)} 创建一个 3D 表面图。创建一个脚本文件并键入以下代码：

[x,y] = meshgrid(-2:.2:2);
g = x .* exp(-x.^2 - y.^2);
surf(x, y, g)
print -deps graph.eps

当你运行文件时，MATLAB将显示以下3D图 -

不兼容的示例

尽管 Octave 中提供了 MATLAB 的所有核心功能，但也有一些功能（例如，微积分和积分），在两种语言中的匹配并不完全相同。本教程尝试提供两种类型的示例，其中它们的语法有所不同。

考虑以下示例，其中 MATLAB 和 Octave 使用不同的函数来获取曲线的面积：f(x) = x² cos(x)，其中 -4 ≤ x ≤ 9。以下是 MATLAB 版本的代码：

f = x^2*cos(x);
ezplot(f, [-4,9])
a = int(f, -4, 9)
disp('Area: '), disp(double(a));

运行文件后，MATLAB 会绘制图形：

显示以下结果

a =
8*cos(4) + 18*cos(9) + 14*sin(4) + 79*sin(9)
 
Area: 
   0.3326

但是，要在 Octave 中获得相同曲线的面积，您必须使用 **symbolic** 包，如下所示：

pkg load symbolic
symbols

x = sym("x");
f = inline("x^2*cos(x)");

ezplot(f, [-4,9])
print -deps graph.eps

[a, ierror, nfneval] = quad(f, -4, 9);
display('Area: '), disp(double(a));

MATLAB - Simulink

Simulink 是一个用于动态和嵌入式系统的仿真和基于模型的设计环境，与 MATLAB 集成在一起。Simulink 也是由 MathWorks 开发的，是一种用于建模、仿真和分析多领域动态系统的数据流图形编程语言工具。它基本上是一个图形化块图工具，具有可自定义的块库集。

它允许您将 MATLAB 算法集成到模型中，并将仿真结果导出到 MATLAB 以进行进一步分析。

Simulink 支持：

• 系统级设计
• 仿真
• 自动代码生成
• 嵌入式系统的测试和验证

MathWorks 提供了许多其他附加产品，以及可与 Simulink 一起使用的第三方硬件和软件产品。

以下列表简要介绍了其中一些：

• **Stateflow** 允许开发状态机和流程图。

• **Simulink Coder** 允许自动生成 C 源代码，以便实时实现系统。

• **xPC Target** 以及 **基于 x86 的实时系统** 提供了一个环境，可以在物理系统上实时仿真和测试 Simulink 和 Stateflow 模型。

• **Embedded Coder** 支持特定的嵌入式目标。

• **HDL Coder** 允许自动生成可综合的 VHDL 和 Verilog。

• **SimEvents** 提供了一个图形化构建块库，用于建模排队系统。

Simulink 能够通过建模风格检查、需求跟踪和模型覆盖率分析来系统地验证和确认模型。

Simulink Design Verifier 允许您识别设计错误并为模型检查生成测试用例场景。

使用 Simulink

要打开 Simulink，请在 MATLAB 工作空间中键入：

simulink

Simulink 将打开 **库浏览器**。库浏览器用于构建仿真模型。

在左侧窗口窗格中，您会发现几个根据各种系统分类的库，单击每个库将在右侧窗口窗格中显示设计块。

构建模型

要创建新模型，请单击库浏览器工具栏上的 **新建** 按钮。这将打开一个新的无标题模型窗口。

Simulink 模型是一个块图。

模型元素是通过从库浏览器中选择相应的元素并将其拖放到模型窗口中来添加的。

或者，您可以复制模型元素并将其粘贴到模型窗口中。

示例

从 Simulink 库中拖放项目以创建您的项目。

出于本示例的目的，将使用两个块进行仿真 - **源**（信号）和 **汇点**（示波器）。信号发生器（源）生成模拟信号，然后示波器（汇点）将以图形方式显示该信号。

首先将所需的块从库拖到项目窗口。然后，将块连接在一起，这可以通过将连接器从一个块上的连接点拖到另一个块上的连接点来完成。

让我们将一个“正弦波”块拖到模型中。

从库中选择“汇点”，并将“示波器”块拖到模型中。

将信号线从正弦波块的输出拖到示波器块的输入。

通过按下“**运行**”按钮运行仿真，保持所有参数为默认值（您可以从“仿真”菜单中更改它们）

您应该从示波器中获得以下图形。