简介
MATLAB（MATLAB实验室）是第四代高级编程语言和交互式环境，用于数值计算，可视化和编程。
MATLAB由MathWorks开发。
它允许矩阵操作; 绘制功能和数据; 算法的实现; 创建用户界面; 与用其他语言编写的程序连接，包括C，C ++，Java和FORTRAN; 分析数据; 开发算法; 并创建模型和应用程序。
它有许多内置命令和数学函数，可以帮助您进行数学计算，生成绘图和执行数值方法。
MATLAB的计算数学
MATLAB用于计算数学的各个方面。 以下是一些常用的数学计算，它最常用 −
- 处理矩阵和数组
- 二维和三维绘图和图形
- 线性代数
- 代数方程
- 非线性函数
- 统计
- 数据分析
- 微积分和微分方程
- 数值计算
- 积分
- 变换
- 曲线拟合
- 各种其他特殊功能
MATLAB的特点
以下是MATLAB的基本功能 −
- 它是数值计算，可视化和应用程序开发的高级语言。
- 它还为迭代探索，设计和解决问题提供了交互式环境。
- 它为线性代数，统计，傅立叶分析，滤波，优化，数值积分和求解常微分方程提供了大量的数学函数库。
- 它提供了内置图形，用于可视化数据和工具，用于创建自定义图。
- MATLAB的编程接口提供了用于提高代码质量可维护性和最大化性能的开发工具。
- 它提供了使用自定义图形界面构建应用程序的工具。
- 它提供了将基于MATLAB的算法与外部应用程序和语言（如C，Java，.NET和Microsoft Excel）集成的功能。
使用MATLAB
MATLAB被广泛用作科学和工程中的计算工具，包括物理，化学，数学和所有工程流。 它用于一系列应用，包括 −
- 信号处理和通信
- 图像和视频处理
- 控制系统
- 测试和测量
- 计算金融
- 计算生物学
开发环境设置
本地环境设置
设置MATLAB环境只需点击几下。
MathWorks还提供许可产品，试用版和学生版。 您需要登录该站点并等待一点他们的批准。
下载安装程序后，只需点击几下即可安装软件。
了解MATLAB环境
可以从桌面上创建的图标启动MATLAB开发IDE。 MATLAB中的主要工作窗口称为桌面。 启动MATLAB时，桌面将以默认布局显示 −
桌面有以下面板 −
- Current Folder − 此面板允许您访问项目文件夹和文件。
- Command Window − 这是可以在命令行输入命令的主要区域。 它由命令提示符(>>)指示。
- Workspace − Workspace显示从文件创建和/或导入的所有变量。
- Command History − 此面板显示或返回在命令行输入的命令。
设置GNU Octave
如果您愿意在您的机器上使用Octave（Linux，BSD，OS X或Windows），请下载GNU Octave最新版本。 您可以查看机器的给定安装说明。
基础语法
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支持以下特殊变量和常量 −
| 名称 | 含义 |
|---|---|
| ans | 默认的变量名，以应答最近依次操作运算结果。 |
| eps | 浮点数的相对误差。 |
| i,j | 虚数单位，定义为 i2 = j2 = -1。 |
| Inf | 代表无穷大。 |
| NaN | 代表不定值（不是数字）。 |
| pi | 圆周率 |
命名变量
变量名称由一个字母后跟任意数量的字母，数字或下划线组成。
MATLAB区分大小写。
变量名称可以是任意长度，但是，MATLAB仅使用前N个字符，其中N由函数namelengthmax给出。
保存你的工作
save命令用于将当前目录中工作空间中的所有变量保存为扩展名为.mat的文件。
例如,
save myfile
您可以稍后使用load命令重新加载文件。
load myfile
变量
在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
MATLAB可以多个赋值
您可以在同一行上进行多个赋值。 例如，
a = 2; b = 7; c = a * b
MATLAB将执行上述语句并返回以下结果 −
c = 14
MATLAB如何显示已经使用的变量名？
在MATLAB中可以使用 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 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
MATLAB格式命令
默认情况下，MATLAB 四个小数位值显示数字。这就是所谓的 short 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
ormat 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提示符'＆gt;＆gt;'处输入命令来输入命令 在命令窗口。
在本节中，我们将提供常用的常规MATLAB命令列表。
管理会话的命令
MATLAB提供了用于管理会话的各种命令。 下表提供了所有这些命令−
| 命令 | 目的/作用 |
|---|---|
| clc | 清除命令窗口。 |
| clear | 从内存中删除变量。 |
| exist | 检查存在的文件或变量。 |
| global | 声明变量为全局。 |
| help | 搜索帮助主题。 |
| lookfor | 搜索帮助关键字条目。 |
| quit | 停止MATLAB。 |
| who | 列出当前变量。 |
| whos | 列出当前变量（长显示）。 |
使用系统的命令
MATLAB提供了各种用于处理系统的有用命令，例如将工作区中的当前工作保存为文件并稍后加载文件。
它还为其他与系统相关的活动提供各种命令，如显示日期，在目录中列出文件，显示当前目录等。
下表显示了一些常用的系统相关命令−
| 命令 | 目的/作用 |
|---|---|
| cd | 改变当前目录。 |
| date | 显示当前日期。 |
| delete | 删除一个文件。 |
| diary | 日记文件记录开/关切换。 |
| dir | 列出当前目录中的所有文件。 |
| load | 负载工作区从一个文件中的变量。 |
| path | 显示搜索路径。 |
| pwd | 显示当前目录。 |
| save | 保存在一个文件中的工作区变量。 |
| type | 显示一个文件的内容。 |
| what | 列出所有MATLAB文件在当前目录中。 |
| wklread | 读取.wk1电子表格文件。 |
MATLAB输入和输出命令
MATLAB提供了以下输入和输出相关的命令：
| 命令 | 作用/目的 |
|---|---|
| disp | 显示一个数组或字符串的内容。 |
| fscanf | 阅读从文件格式的数据。 |
| format | 控制屏幕显示的格式。 |
| fprintf | 执行格式化写入到屏幕或文件。 |
| input | 显示提示并等待输入。 |
| ; | 禁止显示网版印刷 |
fscanf和fprintf命令的行为像C scanf和printf函数。他们支持格式如下代码：
| 格式代码 | 目的/作用 |
|---|---|
| %s | 输出字符串 |
| %d | 输出整数 |
| %f | 输出浮点数 |
| %e | 显示科学计数法形式 |
| %g | %f 和%e 的结合，根据数据选择适当的显示方式 |
用于数字显示格式的函数有以下几种形式：
| Format函数 | 最多可显示 |
|---|---|
| format short | 四位十进制数（默认） |
| format long | 15位定点表示 |
| format short e | 五位浮点表示 |
| format long e | 15位浮点表示 |
| format bank | 两个十进制数字 |
| format + | 正，负或零 |
| format rat | 有理数近似 |
| format compact | 变量之间没有空行 |
| format loose | 变量之间有空行 |
MATLAB向量，矩阵和阵列命令
下表列出了MATLAB用于工作数组、矩阵和向量的各种命令：
| 命令 | 作用/目的 |
|---|---|
| cat | 连接数组 |
| find | 查找非零元素的索引 |
| length | 计算元素数量 |
| linspace | 创建间隔向量 |
| logspace | 创建对数间隔向量 |
| max | 返回最大元素 |
| min | 返回最小元素 |
| prod | 计算数组元素的连乘积 |
| reshape | 重新调整矩阵的行数、列数、维数 |
| size | 计算数组大小 |
| sort | 排序每个列 |
| sum | 每列相加 |
| eye | 创建一个单位矩阵 |
| ones | 生成全1矩阵 |
| zeros | 生成零矩阵 |
| cross | 计算矩阵交叉乘积 |
| dot | 计算矩阵点积 |
| det | 计算数组的行列式 |
| inv | 计算矩阵的逆 |
| pinv | 计算矩阵的伪逆 |
| rank | 计算矩阵的秩 |
| rref | 将矩阵化成行最简形 |
| cell | 创建单元数组 |
| celldisp | 显示单元数组 |
| cellplot | 显示单元数组的图形表示 |
| num2cell | 将数值阵列转化为异质阵列 |
| deal | 匹配输入和输出列表 |
| iscell | 判断是否为元胞类型 |
MATLAB绘图命令
MATLAB提供了大量的命令绘制图表。下表列出了一些常用的命令绘制：
| 命令 | 作用/目的 |
|---|---|
| axis | 人功选择坐标轴尺寸 |
| fplot | 智能绘图功能 |
| grid | 显示网格线 |
| plot | 生成XY图 |
| 打印或绘图到文件 | |
| title | 把文字置于顶部 |
| xlabel | 将文本标签添加到x轴 |
| ylabel | 将文本标签添加到y轴 |
| axes | 创建轴对象 |
| close | 关闭当前的绘图 |
| close all | 关闭所有绘图 |
| figure | 打开一个新的图形窗口 |
| gtext | 通过鼠标在指定位置放注文 |
| hold | 保持当前图形 |
| legend | 鼠标放置图例 |
| refresh | 重新绘制当前图形窗口 |
| set | 指定对象的属性，如轴 |
| subplot | 在子窗口中创建图 |
| text | 在图上做标记 |
| bar | 创建条形图 |
| loglog | 创建双对数图 |
| polar | 创建极坐标图像 |
| semilogx | 创建半对数图（对数横坐标） |
| semilogy | 创建半对数图（对数纵坐标） |
| stairs | 创建阶梯图 |
| stem | 创建针状图 |
M-Files
到目前为止，我们已经使用MATLAB环境作为计算器。 但是，MATLAB也是一种功能强大的编程语言，也是一种交互式计算环境。
在前面的章节中，您学习了如何从MATLAB命令提示符输入命令。 MATLAB还允许您将一系列命令写入文件并将文件作为完整单元执行，如编写函数并调用它。
M 文件
MATLAB允许编写两种程序文件 −
- Scripts − 脚本文件是.m 扩展名的程序文件。 在这些文件中，您可以编写一系列要一起执行的命令。 脚本不接受输入，也不返回任何输出。 它们对工作空间中的数据进行操作。
- Functions − 函数文件也是.m 扩展名的程序文件。 函数可以接受输入和返回输出。 内部变量是函数的本地变量。
您可以使用MATLAB编辑器或任何其他文本编辑器来创建.m文件。 在本节中，我们将讨论脚本文件。 脚本文件包含多个MATLAB命令和函数调用的连续行。 您可以通过在命令行键入其名称来运行脚本。
创建和运行脚本文件
要创建脚本文件，您需要使用文本编辑器。 您可以通过两种方式打开MATLAB编辑器 −
- 使用命令提示符
- 使用IDE
如果使用命令提示符，请在命令提示符下键入编辑。 这将打开编辑器。 您可以直接输入编辑然后输入文件名（扩展名为.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，请选择NEW -> 脚本。 这也会打开编辑器并创建一个名为Untitled的文件。 输入代码后，您可以命名并保存文件。
在编辑器中键入以下代码 −
NoOfStudents = 6000; TeachingStaff = 150; NonTeachingStaff = 20; Total = NoOfStudents + TeachingStaff ... + NonTeachingStaff; disp(Total);
创建并保存文件后，您可以通过两种方式运行它 −
- 单击编辑器窗口上的Run按钮或
- 只需在命令提示符下键入文件名(不带扩展名):>> 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用新内容替换原始内容，并在必要时分配新的存储空间。
例如
Total = 42
上面的语句创建了一个名为“Total”的1×1矩阵，并将值42存储在其中.
MATLAB中可用的数据类型
MATLAB提供15种基本数据类型。 每种数据类型都存储矩阵或数组形式的数据。 该矩阵或数组的大小最小为0乘0，这可以增长到任何大小的矩阵或数组。
下表显示了MATLAB中最常用的数据类型 −
| 数据类型 | 描述 |
|---|---|
| int8 | 8位有符号整数 |
| uint8 | 8位无符号整数 |
| int16 | 16位有符号整数 |
| uint16 | 16位无符号整数 |
| int32 | 32位有符号整数 |
| uint32 | 32位无符号整数 |
| int64 | 64位有符号整数 |
| uint64 | 64位无符号整数 |
| single | 单精度数值数据 |
| double | 双精度数值数据 |
| logical | 逻辑值为1或0，分别代表true和false |
| char | 字符数据(字符串作为字符向量存储) |
| 单元格阵列 | 索引单元阵列，每个都能够存储不同维数和数据类型的数组 |
| 结构体 | C型结构，每个结构具有能够存储不同维数和数据类型的数组的命名字段 |
| 函数处理 | 指向一个函数的指针 |
| 用户类 | 用户定义的类构造的对象 |
| Java类 | 从Java类构造的对象 |
例子
使用以下代码创建脚本文件 −
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提供了各种函数，用于将值从一种数据类型转换为另一种数据类型。 下表显示了数据类型转换函数 −
| 函数 | 描述说明 |
|---|---|
| char | 转换为字符数组(字符串) |
| int2str | 将整数数据转换为字符串 |
| mat2str | 将矩阵转换为字符串 |
| num2str | 将数字转换为字符串 |
| str2double | 将字符串转换为双精度值 |
| str2num | 将字符串转换为数字 |
| native2unicode | 将数字字节转换为Unicode字符 |
| unicode2native | 将Unicode字符转换为数字字节 |
| base2dec | 将基数N字符串转换为十进制数 |
| bin2dec | 将二进制数字串转换为十进制数 |
| dec2base | 将十进制转换为字符串中的N数字 |
| dec2bin | 将十进制转换为字符串中的二进制数 |
| dec2hex | 将十进制转换为十六进制数字 |
| hex2dec | 将十六进制数字字符串转换为十进制数 |
| hex2num | 将十六进制数字字符串转换为双精度数字 |
| num2hex | 将单数转换为IEEE十六进制字符串 |
| cell2mat | 将单元格数组转换为数组 |
| cell2struct | 将单元格数组转换为结构数组 |
| cellstr | 从字符数组创建字符串数组 |
| mat2cell | 将数组转换为具有潜在不同大小的单元格的单元阵列 |
| num2cell | 将数组转换为具有一致大小的单元格的单元阵列 |
| struct2cell | 将结构转换为单元格数组 |
确定数据类型
MATLAB提供了各种用于识别变量数据类型的函数。
下表提供了确定变量数据类型的函数 −
| 函数 | 描述说明 |
|---|---|
| is | 检测状态 |
| isa | 确定输入是否是指定类的对象 |
| iscell | 确定输入是单元格数组 |
| iscellstr | 确定输入是字符串的单元格数组 |
| ischar | 确定项目是否是字符数组 |
| isfield | 确定输入是否是结构数组字段 |
| isfloat | 确定输入是否为浮点数组 |
| ishghandle | 确定是否用于处理图形对象句柄 |
| isinteger | 确定输入是否为整数数组 |
| isjava | 确定输入是否为Java对象 |
| islogical | 确定输入是否为逻辑数组 |
| isnumeric | 确定输入是否是数字数组 |
| isobject | 确定输入是否为MATLAB对象 |
| isreal | 检查输入是否为实数数组 |
| isscalar | 确定输入是否为标量 |
| isstr | 确定输入是否是字符数组 |
| isstruct | 确定输入是否是结构数组 |
| isvector | 确定输入是否为向量 |
| class | 确定对象的类 |
| validateattributes | 检查数组的有效性 |
| whos | 在工作区中列出变量，其大小和类型 |
例子
使用以下代码创建脚本文件 −
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 的工作针对的是整个矩阵和阵列，它允许两种不同类型的算术运算：
- 矩阵算术运算
- 阵列算术运算
矩阵的算术运算是线性代数中的定义相同。执行数组操作，无论是在一维和多维数组元素的元素。
矩阵运算符和数组运算符是有区别的句号（.）符号。然而，由于加法和减法运算矩阵和阵列是相同的，操作者这两种情况下是相同的。下表给出了运算符的简要说明：
详细例子
以下示例显示了算术运算符在标量数据上的使用。 使用以下代码创建脚本文件 −
a = 10; b = 20; c = a + b d = a - b e = a * b f = a / b g = a \ b x = 7; y = 3; z = x ^ y
运行该文件时，它会生成以下结果 −
c = 30 d = -10 e = 200 f = 0.50000 g = 2 z = 343
| 运算符 | 描述 |
|---|---|
| + | 加法或一元加号。A + B将A和B。 A和B必须具有相同的尺寸，除非一个人是一个标量。一个标量，可以被添加到任何大小的矩阵。 |
| - | 减法或一元减号。A - B，减去B从A和B必须具有相同的大小，除非是一个标量。可以从任意大小的矩阵中减去一个标量。 |
| * | 矩阵乘法；是一个更精确的矩阵A和B的线性代数积，矩阵乘法对于非纯量A和B，列一个数必须等于B.标量可以乘以一个任意大小的矩阵的行数。 |
| .* | 数组的乘法；A.*B是数组A和B的元素积，A和B必须具有相同的大小，除非A、B中有一个是标量。 |
| / | 斜线或矩阵右除法；B/A与B * inv（A）大致相同。更确切地说： B/A = (A'B')' |
| ./ | 矩阵右除法；矩阵A与矩阵B相应元素相除（A、B为同纬度的矩阵） |
| .\ | 反斜杠或矩阵左除；如果A是一个方阵，AB是大致相同的INV（A）* B，除非它是以不同的方式计算。如果A是一个n*n的矩阵，B是一个n组成的列向量，或是由若干这样的列的矩阵，则X = AB 是方程 AX = B ，如果A严重缩小或者几乎为单数，则显示警告消息。 |
| . | 数组左除法；A. B是元素B（i，j）/A（i，j）的矩阵。A和B必须具有相同的大小，除非其中一个是标量。 |
| ^ | 矩阵的幂。X^P是X到幂P，如果p是标量；如果p是一个整数，则通过重复平方计算功率。如果整数为负数，X首先反转。对P值的计算，涉及到特征值和特征向量，即如果[ D ] = V，EIG（x），那么X^P = V * D.^P / V。 |
| .^ | A.^B：A的每个元素的B次幂（A、B为同纬度的矩阵） |
| ' | 矩阵的转置；A'是复数矩阵A的线性代数转置，这是复共轭转置。 |
| .' | 数组的转置；A'是数组A的转置，对于复数矩阵，这不涉及共轭。 |
逻辑运算符
MATLAB提供了两种类型的逻辑运算符和函数：
- Element-wise -这些运算符的逻辑阵列上运行相应的元素。
- Short-circuit -这些运算上的标量，逻辑表达式。
Element-wise 的逻辑运算符操作元素元素逻辑阵列。符号＆，|和〜逻辑数组运算符AND，OR，NOT。
允许短路短路逻辑运算符，逻辑运算。符号 && 和 | | 是短路逻辑符 AND 和 OR。
详细例子
在MATLAB中建立一个脚本文件，并输入下面的代码：
a = 5;
b = 20;
if ( a && b )
disp('Line 1 - Condition is true');
end
if ( a || b )
disp('Line 2 - Condition is true');
end
% lets change the value of a and b
a = 0;
b = 10;
if ( a && b )
disp('Line 3 - Condition is true');
else
disp('Line 3 - Condition is not true');
end
if (~(a && b))
disp('Line 4 - Condition is true');
end
运行该文件，产生如下结果：
Line 1 - Condition is true Line 2 - Condition is true Line 3 - Condition is not true Line 4 - Condition is true
MATLAB逻辑运算功能
除了在上述的逻辑运算符，MATLAB 提供下面的命令或函数用于同样的目的：
| 函数 | 描述 |
|---|---|
| and(A, B) | 查找数组或标量输入的逻辑和；执行所有输入数组A，B等的逻辑AND，并返回包含设置为逻辑1（真）或逻辑0（假）的元素的数组。如果所有输入数组在同一个数组位置都包含一个非零元素，那么输出数组的一个元素将被设置为1；否则，该元素设置为0。 |
| not(A) | 查找数组或标量输入的逻辑NOT；执行输入数组A的逻辑NOT，并返回包含设置为逻辑1（真）或逻辑0（假）的元素的数组。如果输入数组在同一个数组位置包含一个零值元素，那么输出数组的一个元素将被设置为1；否则，该元素设置为0。 |
| or(A, B) | 查找数组或标量输入的逻辑或； 执行所有输入数组A，B等的逻辑或，并返回包含设置为逻辑1（真）或逻辑0（假）的元素的数组。如果任何输入数组在同一个数组位置包含一个非零元素，则输出数组的一个元素设置为1；否则，该元素设置为0。 |
| xor(A, B) | 逻辑异或; 对数组A和B的相应元素执行异或运算。如果A（i，j，...）或B（i，j）...，则所得到的元素C（i，j，...） j，...），但不是两者都是非零的。 |
| all(A) | 确定数组A的所有数组元素是否为非零或真。如果A是向量，则如果所有元素都为非零，则所有（A）返回逻辑1（真），如果一个或多个元素为零，则返回逻辑0（假）。如果A是非空矩阵，则所有（A）将A的列视为向量，返回逻辑1和0的行向量。如果A是空的0x0矩阵，则全部（A）返回逻辑1（真）。如果A是一个多维数组，则所有（A）都沿着第一个非指定维度行事，并返回一个逻辑值数组。 该尺寸的尺寸减小到1，而所有其他尺寸的尺寸保持不变。这个维度的大小减少到1，而其他所有维度的尺寸保持不变。 |
| all(A, dim) | 通过标量dim沿着维数A的维度进行测试。 |
| any(A) | 确定数组元素是否为非零；测试数组中不同维度的元素是否为非零数字，或是逻辑1（真）。 任何函数忽略NaN（不是数字）的条目。如果A是向量，任何（A）如果A的任何元素是非零数或逻辑1（真），则返回逻辑1（真），如果所有元素为零，则返回逻辑0（假）。如果A是非空矩阵，则任何（A）将A的列视为向量，返回逻辑1和0的行向量。如果A是一个空的0x0矩阵，任何（A）返回逻辑0（假）。如果A是一个多维数组，则任何（A）都沿着第一个非整数维进行操作，并返回一个逻辑值数组。该维度的尺寸减小到1，而所有其他维度的尺寸保持不变。 |
| any(A,dim) | 通过标量dim沿着维数A的维度进行测试。 |
| false | 逻辑0（假） |
| false(n) | 是逻辑0的n×n矩阵 |
| false(m, n) | 是逻辑0的一个m×n矩阵。 |
| false(m, n, p, ...) | 是由逻辑0的逐列逐列数组。 |
| false(size(A)) | 是与数组A大小相同的逻辑零数组。 |
| false(...,'like',p) | 是与逻辑阵列p相同的数据类型和稀疏性的逻辑零数组。 |
| ind = find(X) | 查找非零元素的索引和值；定位数组X的所有非零元素，并返回向量中这些元素的线性索引。 如果X是行向量，则返回的向量是行向量; 否则返回列向量。如果X不包含非零元素或是空数组，则返回一个空数组。 |
| ind = find(X, k) ind = find(X, k, 'first') | 最多返回与X的非零条目相对应的前k个索引。k必须是正整数，但它可以是任何数字数据类型。 |
| ind = find(X, k, 'last') | 最多返回与X的非零条目相对应的最后k个索引。 |
| [row,col] = find(X, ...) | 返回矩阵X中非零条目的行和列索引。使用稀疏矩阵时，此语法特别有用。 如果X是N>2的N维数组，col包含列的线性索引。 |
| [row,col,v] = find(X, ...) | 返回X中非零条目的列或行向量v，以及行和列索引。如果X是逻辑表达式，则v是逻辑数组。 输出v包含通过评估表达式X获得的逻辑数组的非零元素。 |
| islogical(A) | 确定输入是否为逻辑数组；如果A是逻辑数组，返回true，否则返回false。 如果A是从逻辑类派生的类的实例，它也返回true。 |
| logical(A) | 将数值转换为逻辑；返回一个可用于逻辑索引或逻辑测试的数组。 |
| true | 逻辑1（真） |
| true(n) | 是一个n×n逻辑矩阵。 |
| true(m, n) | 是一个mxn逻辑矩阵。 |
| true(m, n, p, ...) | 是由逻辑1的逐列逐列数组。 |
| true(size(A)) | 是与数组A大小相同的逻辑数组。 |
| true(...,'like', p) | 是与逻辑阵列p相同的数据类型和稀疏性的逻辑阵列。 |
关系运算符
关系运算符标和非标量数据上也能正常工作。关系运算符对数组进行元素元素元素设置为逻辑1（真）的关系是真实的和元素设置为逻辑0（假），它是两个阵列，并返回一个同样大小的逻辑阵列之间的比较。
下表显示了 MATLAB 中的关系运算符：
详细例子
创建脚本文件并键入以下代码 −
a = 100; b = 200; if (a >= b) max = a else max = b end
运行该文件时，它会产生以下结果 −
max = 200
| 运算符 | 描述 |
|---|---|
| < | 小于 |
| <= | 小于或等于 |
| > | 大于 |
| >= | 大于或等于 |
| == | 等于 |
| ~= | 不等于 |
位运算
位运算符位和执行位位操作。 ＆，|和^的真值表如下：
| p | q | p & q | p | q | p ^ q |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
| 1 | 0 | 0 | 1 | 1 |
假设如果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提供位运算，如'位'，'位或'和'位不操作，移位操作等各种函数
以下的表格显示了常用的按位运算：
| 函数 | 目的/作用 |
|---|---|
| bitand(a, b) | 整数a和b的逐位AND |
| bitcmp(a) | a的位补码 |
| bitget(a,pos) | 在指定位置pos中获取位，在整数数组A中 |
| bitor(a, b) | 整数a和b的逐位OR |
| bitset(a, pos) | 在某一位置上设置位 |
| bitshift(a, k) | 返回向左移位k位，相当于乘以2k。k的负值对应于向右移位或除以2 | k | 并舍入到最接近的整数到负无穷大。任何溢出位都被截断。 |
| bitxor(a, b) | 整数a和b的逐位异或 |
| swapbytes | 交换字节顺序 |
详细例子
在MATLAB中建立一个脚本文件，并输入下面的代码：
a = 60; % 60 = 0011 1100 b = 13; % 13 = 0000 1101 c = bitand(a, b) % 12 = 0000 1100 c = bitor(a, b) % 61 = 0011 1101 c = bitxor(a, b) % 49 = 0011 0001 c = bitshift(a, 2) % 240 = 1111 0000 */ c = bitshift(a,-2) % 15 = 0000 1111 */
运行该文件，显示以下结果：
c = 12 c = 61 c = 49 c = 240 c = 15
| 函数 | 目的/作用 |
|---|---|
| bitand(a, b) | 当a、b是一个或数个无符号整数或无符号整数数组，返回参数a和b位和， |
| bitcmp(a) | a的补码 |
| bitget(a,pos) | 在指定位置pos中获取位，在整数数组a中 |
| bitor(a, b) | 对数a和b按位或 |
| bitset(a, pos) | a的集合点在一个特定的位置pos |
| bitshift(a, k) | 返回一个移到左K位，相当于乘以2K。K负值对应的位权转移或除以2|K|向负无穷舍入到最近的整数。任何溢出位都被截断。 |
| bitxor(a, b) | 对数a和b按位异或 |
| swapbytes | 交换字节顺序 |
集合操作符
MATLAB提供各种功能集合运算，如集，交集和测试组成员等。
下表是对一些常用的设置操作的例举与描述：
详细例子
a = [7 23 14 15 9 12 8 24 35] b = [ 2 5 7 8 14 16 25 35 27] u = union(a, b) i = intersect(a, b) s = setdiff(a, b)
运行该文件，产生以下结果：
a = 7 23 14 15 9 12 8 24 35 b = 2 5 7 8 14 16 25 35 27 u = Columns 1 through 11 2 5 7 8 9 12 14 15 16 23 24 Columns 12 through 14 25 27 35 i = 7 8 14 35 s = 9 12 15 23 24
| 函数 | 描述 |
|---|---|
| intersect(A,B) | 设置两个数组的交集；返回A和B所共有的值。返回的值按排序顺序排列。 |
| intersect(A,B,'rows') | 将A和B的每一行作为单个实体处理，并返回A和B的公共行。返回的矩阵的行按排序顺序排列。 |
| ismember(A,B) | 返回与A大小相同的数组，包含1（true），其中A的元素在其他地方的B中找到，它返回0（false）。 |
| ismember(A,B,'rows') | 将A和B的每一行作为单个实体处理，并返回一个包含1（true）的向量，其中矩阵A的行也是B的行；否则，它返回0（false）。 |
| issorted(A) | 如果A的元素按排序顺序返回逻辑1（true），否则返回逻辑0（false）。输入A可以是向量，也可以是N-by-1或1-by-N的字符串数组。如果A和sort（A）的输出相等，则A被认为是排序的。 |
| issorted(A, 'rows') | 如果二维矩阵A的行按排序顺序返回逻辑1（真），否则返回逻辑0（假）。 如果A和排序（A）的输出相等，则认为矩阵A被排序。 |
| setdiff(A,B) | 设置两个数组的差值；返回不在B中的值。返回数组中的值按排序顺序排列。 |
| setdiff(A,B,'rows') | 将每一行A和B行作为单个实体处理，并返回一个不在B中的行。返回的矩阵的行按排序顺序排列。“行”选项不支持单元格数组。 |
| setxor | 设置两个数组的异或 |
| union | 设置两个数组的并集 |
| unique | 数组中唯一的值 |
判断
决策结构用来做什么？决策结构要求程序员能够使用一个或者多个的条件来对程序进行评估或者测试，沿着一条或多条语句执行，如果该条件被确定为真，则继续执行；如果条件确定是假的（false），执行其他要执行的语句。
下图是一个典型的决策结构，是大多数编程语言的一般形式：
MATLAB 提供的决策类型如下表，通过点击链接，查看各决策类型的作用：
| 语句 | 描述 |
|---|---|
| if ... end statement | 一个 if ... end 语句由一个布尔表达式组成，后跟一个或多个语句。 |
| if...else...end statement | 一个 if 语句可以跟随一个可选的 else 语句，当布尔表达式为false时，该语句将执行。 |
| if... elseif...elseif...else...end statements | 一个 if 语句后面可以有一个（或多个）可选 elseif ... 和一个 else 语句，这对于测试各种条件非常有用。 |
| nested if statements | 你可以在另一个 if 或 elseif 语句中使用一个 if 或 elseif 语句。 |
| switch statement | 一个 switch 语句允许根据值列表对变量进行相等的测试。 |
| nested switch statements | 你可以在另一个 switch 语句中使用一个 swicth 语句。 |
if ... end statement
一个 if 语句和一个布尔表达式后跟一个或多个语句，由 end 语句分隔，就是一个 if ... end 语句
MATLAB if 语句语法
在MATLAB中 的 if 语句的语法是：
if <expression> % statement(s) will execute if the boolean expression is true <statements> end
表达式的计算结果如果是“true”，那么在代码块中，如果语句会被执行。如果表达式计算结果为“false”，那么第一套代码结束后的语句会被执行。
MATLAB if 语句流程图：
在MATLAB中建立一个脚本文件，并输入下述代码：
a = 10;
% check the condition using if statement
if a < 20
% if condition is true then print the following
fprintf('a is less than 20
' );
end
fprintf('value of a is : %d', a);
运行该文件，显示下述结果：
a is less than 20 value of a is : 10
if...else...end statement
在MATLAB的 if...else...end 语句中，if 语句后面可以跟一个可选择的 else 语句，当执行的表达式为假的时候，执行 else 语句。
if...else...end 语句语法：
MATLAB 中一个 if ... else 语句的语法示例：
if <expression> % statement(s) will execute if the boolean expression is true <statement(s)> else <statement(s)> % statement(s) will execute if the boolean expression is false end
如果布尔表达式的值为 “true”，那么执行 if 的代码块；如果布尔表达式的值为 “false”，else 的代码块将被执行。
if...else...end 语句流程图：
在MATLAB中建立一个脚本文件，并输入下述的代码：
a = 100;
% check the boolean condition
if a < 20
% if condition is true then print the following
fprintf('a is less than 20
' );
else
% if condition is false then print the following
fprintf('a is not less than 20
' );
end
fprintf('value of a is : %d
', a);
编译和执行上述代码，产生下述结果：
a is not less than 20 value of a is : 100
if... elseif...elseif...else...end statements
MATLAB 的 if...elseif...elseif...else...end 语句中 if 语句可以跟随一个（或多个）可选的 elseif... else 语句，这是非常有用的，可以用来对各种条件进行测试。
使用 if... elseif...elseif...else 语句，要注意以下几点：
- 一个 if 可以有零个或多个 else，但是它必须跟在 elseif 后面（即只有 elseif 存在才会有 else）。
- 一个 if 可以有零个或多个 elseif ，必须出现else。
- 一旦 elseif 匹配成功，余下的 elseif 将不会被测试。
if... elseif...else...end 语法：
if <expression 1> % Executes when the expression 1 is true <statement(s)> elseif <expression 2> % Executes when the boolean expression 2 is true <statement(s)> Elseif <expression 3> % Executes when the boolean expression 3 is true <statement(s)> else % executes when the none of the above condition is true <statement(s)> end
在MATLAB中建立一个脚本文件，并输入下述代码：
a = 100;
%check the boolean condition
if a == 10
% if condition is true then print the following
fprintf('Value of a is 10
' );
elseif( a == 20 )
% if else if condition is true
fprintf('Value of a is 20
' );
elseif a == 30
% if else if condition is true
fprintf('Value of a is 30
' );
else
% if none of the conditions is true '
fprintf('None of the values are matching
');
fprintf('Exact value of a is: %d
', a );
end
编译和执行上述代码，产生如下结果：
None of the values are matching Exact value of a is: 100
nested if statements
在MATLAB中嵌套if语句始终是合法的，也就是说可以使用一个嵌套的 if-else语句 if 或 elseif 语句在另一个 if 或 elseif 语句。
MATLAB嵌套 if 语句语法:
详细语法如下：
if <expression 1> % Executes when the boolean expression 1 is true if <expression 2> % Executes when the boolean expression 2 is true end end
可以嵌套 elseif 或其他类似的方式，因为已经嵌套 if 语句。
在MATLAB中建立一个脚本文件，并输入下面的代码：
a = 100;
b = 200;
% check the boolean condition
if( a == 100 )
% if condition is true then check the following
if( b == 200 )
% if condition is true then print the following
fprintf('Value of a is 100 and b is 200
' );
end
end
fprintf('Exact value of a is : %d
', a );
fprintf('Exact value of b is : %d
', b );
运行该文件，它显示的结果如下：
Value of a is 100 and b is 200 Exact value of a is : 100 Exact value of b is : 200
switch statement
MATLAB中 switch 块有条件地执行一组语句，这些语句是从几个选项里选择执行的，其中每个选项涵盖了一个 case 语句。
- 计算 switch_expression 是一个标量或字符串。
- 计算 case_expression 是标量，标量或字符串的字符串或单元阵列。
switch 块的功能是测试每个 case ，直到被测试的其中一个 case 是 true 。
case 是 true 的情况如下：
- 对于数字，eq(case_expression,switch_expression).
- 对于字符串，strcmp(case_expression,switch_expression).
- 对于对象，支持 eq 函数，eq(case_expression,switch_expression).
- 对于单元阵列case_expression的，在单元阵列与switch_expression相匹配的元素中的至少一个，如上文所定义的数字，字符串和对象。
当上述有一个情况是 true，MATLAB 就执行与之相应的语句，然后不再执行以后的语句，直接退出 switch 块。
otherwise 块是可选的，任何情况下，只有当真正执行。
在MATLAB 中 switch 语句的语法如下：
switch <switch_expression> case <case_expression> <statements> case <case_expression> <statements> ... ... otherwise <statements> end
在MATLAB中建立一个脚本文件，并输入下述代码：
grade = 'B';
switch(grade)
case 'A'
fprintf('Excellent!
' );
case 'B'
fprintf('Well done
' );
case 'C'
fprintf('Well done
' );
case 'D'
fprintf('You passed
' );
case 'F'
fprintf('Better try again
' );
otherwise
fprintf('Invalid grade
' );
end
运行该文件，显示下述结果：
Well done Your grade is B
nested switch statements
在 MATLAB 中嵌套 switch 语句是可能的，可以在 switch 一部分外嵌套 switch 语句序列。即使 case 常量的内部和外部的 switch 含有共同的值，也不算冲突出现。
MATLAB嵌套switch语句语法
嵌套switch语句的语法如下：
switch(ch1)
case 'A'
fprintf('This A is part of outer switch');
switch(ch2)
case 'A'
fprintf('This A is part of inner switch' );
case 'B'
fprintf('This B is part of inner switch' );
end
case 'B'
fprintf('This B is part of outer switch' );
end
在MATLAB中建立一个脚本文件，并输入下面的代码：
a = 100;
b = 200;
switch(a)
case 100
fprintf('This is part of outer switch %d
', a );
switch(b)
case 200
fprintf('This is part of inner switch %d
', a );
end
end
fprintf('Exact value of a is : %d', a );
fprintf('Exact value of b is : %d', b );
当运行该文件时，它会显示：
This is part of outer switch 100 This is part of inner switch 100 Exact value of a is : 100 Exact value of b is : 200
循环
可能存在需要多次执行代码块的情况。 通常，语句按顺序执行。 首先执行函数中的第一个语句，然后执行第二个语句，依此类推。
编程语言提供各种控制结构，允许更复杂的执行路径。
MATLAB提供以下类型的循环来处理循环要求 −
| 序号 | 循环类型 & 描述 |
|---|---|
| 1 | while 循环一个给定的条件为真时重复语句或语句组。测试条件才执行循环体。 |
| 2 | for 循环执行的语句序列多次缩写管理循环变量的代码。 |
| 3 | 嵌套循环可以使用一个或多个环路内任何另一个循环。 |
while 循环
while循环在条件为真时重复执行语句。
语法
MATLAB中while循环的语法是 −
while <expression> <statements> end
只要表达式保持为真，while循环就会重复执行程序语句。
当结果为非空且包含所有非零元素（逻辑或实数）时，表达式为true。 否则，表达式为false。
例子
创建脚本文件并键入以下代码 −
a = 10;
% while loop execution
while( a < 20 )
fprintf('value of a: %d\n', a);
a = a + 1;
end
运行该文件时，它将显示以下结果 −
value of a: 10 value of a: 11 value of a: 12 value of a: 13 value of a: 14 value of a: 15 value of a: 16 value of a: 17 value of a: 18 value of a: 19
for 循环
for循环是一种重复控制结构，允许您有效地编写需要执行特定次数的循环。
语法
MATLAB中for循环的语法是 −
for index = values <program statements> ... end
values具有以下形式之一 −
| 序号 | 格式 & 描述 |
|---|---|
| 1 | initval:endval将索引变量从initval递增到endval 1，并重复执行程序语句，直到index大于endval的。 |
| 2 | initval:step:endval每次迭代时，通过值步骤递增index，或者当步长为负时递减index。 |
| 3 | valArray在每次迭代时，从数组valArray的后续列创建列向量index。 例如，在第一次迭代中，index = valArray(:,1)。 循环执行最多n次，其中n是valArray的列数，由numel(valArray,1,:)给出。 输入valArray可以是任何MATLAB数据类型，包括字符串，单元格数组或结构。 |
例子 1
创建脚本文件并键入以下代码 −
for a = 10:20
fprintf('value of a: %d\n', a);
end
运行该文件时，它将显示以下结果 −
value of a: 10 value of a: 11 value of a: 12 value of a: 13 value of a: 14 value of a: 15 value of a: 16 value of a: 17 value of a: 18 value of a: 19 value of a: 20
例子 2
创建脚本文件并键入以下代码 −
for a = 1.0: -0.1: 0.0 disp(a) end
运行该文件时，它将显示以下结果 −
1 0.90000 0.80000 0.70000 0.60000 0.50000 0.40000 0.30000 0.20000 0.10000 0
例子 3
创建脚本文件并键入以下代码 −
for a = [24,18,17,23,28] disp(a) end
运行该文件时，它将显示以下结果 −
24 18 17 23 28
嵌套循环
MATLAB允许在另一个循环中使用一个循环。 以下部分显示了几个例子来说明这个概念。
语法
MATLAB中嵌套for循环语句的语法如下 −
for m = 1:j for n = 1:k <statements>; end end
MATLAB中嵌套while循环语句的语法如下 −
while <expression1> while <expression2> <statements> end end
例子
让我们使用嵌套的for循环来显示从1到100的所有素数。创建一个脚本文件并键入以下代码 −
for i = 2:100
for j = 2:100
if(~mod(i,j))
break; % if factor found, not prime
end
end
if(j > (i/j))
fprintf('%d is prime\n', i);
end
end
运行该文件时，它将显示以下结果 −
2 is prime 3 is prime 5 is prime 7 is prime 11 is prime 13 is prime 17 is prime 19 is prime 23 is prime 29 is prime 31 is prime 37 is prime 41 is prime 43 is prime 47 is prime 53 is prime 59 is prime 61 is prime 67 is prime 71 is prime 73 is prime 79 is prime 83 is prime 89 is prime 97 is prime
循环控制语句
循环控制语句可以更改正常的执行顺序，当执行留下了范围，在该范围内所有自动创建的对象被销毁。
| 序号 | 控制语句 & 描述 |
|---|---|
| 1 | break 语句终止循环语句，将执行的语句紧随循环。 |
| 2 | continue 语句导致循环，跳过它的身体的其余部分，并立即重新再次测试前的状况。 |
break 语句
break语句终止执行for或while循环。 不执行break语句之后出现的循环语句。
在嵌套循环中，break仅从发生它的循环中退出。 控制传递到该循环结束后的语句。
Example
创建脚本文件并键入以下代码 −
a = 10;
% while loop execution
while (a < 20 )
fprintf('value of a: %d\n', a);
a = a + 1;
if( a > 15)
% terminate the loop using break statement
break;
end
end
运行该文件时，它将显示以下结果 −
value of a: 10 value of a: 11 value of a: 12 value of a: 13 value of a: 14 value of a: 15
continue 语句
continue语句用于将控制传递给for或while循环的下一次迭代。
MATLAB中的continue语句与break语句有点类似。 然而，"继续"不是强制终止，而是强制循环的下一次迭代发生，跳过其间的任何代码。
例子
创建脚本文件并键入以下代码 −
a = 9;
%while loop execution
while a < 20
a = a + 1;
if a == 15
% skip the iteration
continue;
end
fprintf('value of a: %d\n', a);
end
运行该文件时，它将显示以下结果 −
value of a: 10 value of a: 11 value of a: 12 value of a: 13 value of a: 14 value of a: 16 value of a: 17 value of a: 18 value of a: 19 value of a: 20
向量
向量是一维数字数组。 MATLAB允许创建两种类型的向量 −
- 行向量
- 列向量
行向量
行向量是通过将元素集括在方括号中创建的，使用空格或逗号分隔元素。
r = [7 8 9 10 11]
执行上述语句，返回下述结果 −
r = 7 8 9 10 11
列向量
列向量是通过将元素集括在方括号中创建的，使用分号分隔元素。
c = [7; 8; 9; 10; 11]
执行上述语句，返回下述结果 −
c = 7 8 9 10 11
引用向量的元素
您可以通过多种方式引用向量的一个或多个元素。 向量v的ith分量称为v(i)。 例如 −
v = [ 1; 2; 3; 4; 5; 6]; % creating a column vector of 6 elements v(3)
执行上述语句，返回下述结果 −
ans = 3
当您引用带冒号的向量，例如v(:)时，会列出向量的所有组件。
v = [ 1; 2; 3; 4; 5; 6]; % creating a column vector of 6 elements v(:)
执行上述语句，返回下述结果 −
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 向量运算s
在本节中，我们将讨论以下向量操作 −
- 向量的加减法
- 标量向量乘法
- 转置向量
- 追加向量
- 向量的模
- 向量点积
- 等差元素向量
向量的加减法
您可以添加或减去两个向量。 两个操作数向量必须是相同类型且具有相同数量的元素。
例子
使用以下代码创建脚本文件 −
A = [7, 11, 15, 23, 9]; B = [2, 5, 13, 16, 20]; C = A + B; D = A - B; disp(C); disp(D);
运行该文件时，它将显示以下结果 −
9 16 28 39 29 5 6 2 7 -11
标量向量乘法
将向量乘以数字时，这称为标量乘法。 标量乘法产生一个相同类型的新向量，原始向量的每个元素乘以数字。
例子
使用以下代码创建脚本文件 −
v = [ 12 34 10 8]; m = 5 * v
运行该文件时，它将显示以下结果 −
m = 60 170 50 40
请注意，您可以对向量执行所有标量操作。 例如，您可以使用标量来添加，减去和除以向量。
转置向量
转置操作将列向量更改为行向量，反之亦然。 转置操作由单引号（'）表示。
例子
使用以下代码创建脚本文件 −
r = [ 1 2 3 4 ]; tr = r'; v = [1;2;3;4]; tv = v'; disp(tr); disp(tv);
运行该文件时，它将显示以下结果 −
1 2 3 4 1 2 3 4
追加向量
MATLAB允许您将向量追加到一起以创建新向量。
如果你有两个行向量r1和r2，n和m个元素，要创建一个n加m个元素的行向量r，通过附加这些向量，你写 −
r = [r1,r2]
您还可以通过附加这两个向量来创建矩阵r，向量r2将是矩阵的第二行 −
r = [r1;r2]
但是，为此，两个向量应具有相同数量的元素。
类似地，您可以使用n和m个元素追加两个列向量c1和c2。 要创建n加m个元素的列向量c，可以通过附加这些向量来编写 −
c = [c1; c2]
您还可以通过附加这两个向量来创建矩阵c; 向量c2将是矩阵的第二列 −
c = [c1, c2]
但是，为此，两个向量应具有相同数量的元素。
例子
使用以下代码创建脚本文件 −
r1 = [ 1 2 3 4 ]; r2 = [5 6 7 8 ]; r = [r1,r2] rMat = [r1;r2] c1 = [ 1; 2; 3; 4 ]; c2 = [5; 6; 7; 8 ]; c = [c1; c2] cMat = [c1,c2]
运行该文件时，它将显示以下结果 −
r = Columns 1 through 7: 1 2 3 4 5 6 7 Column 8: 8 rMat = 1 2 3 4 5 6 7 8 c = 1 2 3 4 5 6 7 8 cMat = 1 5 2 6 3 7 4 8
向量的模
具有元素v1，v2，v3，...，vn的向量v的大小由等式给出 −
|v| = √(v12 + v22 + v32 + … + vn2)
您需要执行以下步骤来计算向量的大小 −
- 使用数组乘法（。*）获取向量的乘积。 这产生了矢量sv，其元素是矢量v的元素的平方。 sv = v.*v;
- 使用和函数得到向量v的元素的平方的和。这也称为向量v的点积。dp= sum(sv);
- 使用sqrt函数得到总和的平方根，也就是向量v的大小。mag = sqrt(s);
例子
使用以下代码创建脚本文件 −
v = [1: 2: 20];
sv = v.* v; %the vector with elements
% as square of v's elements
dp = sum(sv); % sum of squares -- the dot product
mag = sqrt(dp); % magnitude
disp('Magnitude:');
disp(mag);
运行该文件时，它将显示以下结果 −
Magnitude: 36.469
向量点积
两个向量a =（a1，a2，...，an）和b =（b1，b2，...，bn）的点积由下式给出 −
a.b = ∑(ai.bi)
使用dot函数计算两个向量a和b的点积。
dot(a, b);
例子
使用以下代码创建脚本文件 −
v1 = [2 3 4];
v2 = [1 2 3];
dp = dot(v1, v2);
disp('Dot Product:');
disp(dp);
运行该文件时，它将显示以下结果 −
Dot Product: 20
等差元素向量
MATLAB允许您创建具有均匀间隔元素的向量。
使用第一个元素f创建向量v，最后一个元素l，以及元素之间的差异是任何实数n，我们写 −
v = [f : n : l]
例子
使用以下代码创建脚本文件 −
v = [1: 2: 20]; sqv = v.^2; disp(v); disp(sqv);
运行该文件时，它将显示以下结果 −
1 3 5 7 9 11 13 15 17 19 1 9 25 49 81 121 169 225 289 361
矩阵
矩阵是二维数字数组。
在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的mth行和nth列中的元素，我们写 −
mx(m, n);
例如，要引用矩阵a的2nd行和5th列中的元素，如上一节中创建的那样 ，我们写 −
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
要引用mth列中的所有元素，我们键入A(:,m)。
让我们从矩阵a的4th行的元素创建列向量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
你也可以选择mth到nth列中的元素，为此我们写 −
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
例子
在这个例子中，让我们创建一个3乘3的矩阵m，然后我们将复制该矩阵的第二行和第三行两次以创建一个4乘3的矩阵。
使用以下代码创建脚本文件 −
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
矩阵运算
在本节中，我们将讨论以下基本和常用的矩阵运算 −
- 矩阵的加法和减法
- 矩阵除法
- 矩阵的标量操作
- 矩阵的转置
- 连接矩阵
- 矩阵乘法
- 矩阵的行列式
- 逆矩阵
矩阵的加法和减法
您可以添加或减去矩阵。 两个操作数矩阵必须具有相同数量的行和列。
例子
使用以下代码创建脚本文件 −
a = [ 1 2 3 ; 4 5 6; 7 8 9]; b = [ 7 5 6 ; 2 0 8; 5 7 1]; c = a + b d = a - b
运行该文件时，它将显示以下结果 −
c = 8 7 9 6 5 14 12 15 10 d = -6 -3 -3 2 5 -2 2 1 8
矩阵除法
您可以使用左（\）或右（/）除法运算符来划分两个矩阵。 两个操作数矩阵必须具有相同数量的行和列。
例子
使用以下代码创建脚本文件 −
a = [ 1 2 3 ; 4 5 6; 7 8 9]; b = [ 7 5 6 ; 2 0 8; 5 7 1]; c = a / b d = a \ b
运行该文件时，它将显示以下结果 −
c = -0.52542 0.68644 0.66102 -0.42373 0.94068 1.01695 -0.32203 1.19492 1.37288 d = -3.27778 -1.05556 -4.86111 -0.11111 0.11111 -0.27778 3.05556 1.27778 4.30556
矩阵的标量操作
MATLAB矩阵的标量操作就是加，减，乘或者除以一个数字矩阵。
标量运算产生具有相同行数和列数的新矩阵，其中原始矩阵的每个元素被添加，减去，乘以或除以数字。
例子
使用以下代码创建脚本文件 −
a = [ 10 12 23 ; 14 8 6; 27 8 9]; b = 2; c = a + b d = a - b e = a * b f = a / b
运行该文件时，它将显示以下结果 −
c = 12 14 25 16 10 8 29 10 11 d = 8 10 21 12 6 4 25 6 7 e = 20 24 46 28 16 12 54 16 18 f = 5.0000 6.0000 11.5000 7.0000 4.0000 3.0000 13.5000 4.0000 4.5000
矩阵的转置
转置操作以矩阵形式切换行和列。 它由单引号（'）表示。
例子
使用以下代码创建脚本文件 −
a = [ 10 12 23 ; 14 8 6; 27 8 9] b = a'
运行该文件时，它将显示以下结果 −
a = 10 12 23 14 8 6 27 8 9 b = 10 14 27 12 8 8 23 6 9
连接矩阵
您可以连接两个矩阵以创建更大的矩阵。 方括号'[]'是连接运算符。
MATLAB允许两种类型的连接 −
- 横向连接
- 垂直连接
通过使用逗号分隔两个矩阵来连接两个矩阵时，它们只是水平附加。 它被称为水平连接。
或者，如果通过使用分号分隔两个矩阵来连接两个矩阵，则会垂直附加它们。 它被称为垂直连接。
例子
使用以下代码创建脚本文件 −
a = [ 10 12 23 ; 14 8 6; 27 8 9] b = [ 12 31 45 ; 8 0 -9; 45 2 11] c = [a, b] d = [a; b]
运行该文件时，它将显示以下结果 −
a = 10 12 23 14 8 6 27 8 9 b = 12 31 45 8 0 -9 45 2 11 c = 10 12 23 12 31 45 14 8 6 8 0 -9 27 8 9 45 2 11 d = 10 12 23 14 8 6 27 8 9 12 31 45 8 0 -9 45 2 11
矩阵乘法
考虑两个矩阵A和B.如果A是mxn矩阵而B是nxp矩阵，它们可以相乘以产生mxn矩阵C.只有当A中的列数n等于数量时才可以进行矩阵乘法 在B.中的行n
在矩阵乘法中，第一矩阵中的行的元素与第二矩阵中的对应列相乘。
在得到的矩阵C中，(i，j)th位置中的每个元素是第一矩阵的ith行中的元素乘积与对应的元素的总和。 第二个矩阵的jth列中的元素。
MATLAB中的矩阵乘法是使用*运算符执行的。
例子
使用以下代码创建脚本文件 −
a = [ 1 2 3; 2 3 4; 1 2 5] b = [ 2 1 3 ; 5 0 -2; 2 3 -1] prod = a * b
运行该文件时，它将显示以下结果 −
a = 1 2 3 2 3 4 1 2 5 b = 2 1 3 5 0 -2 2 3 -1 prod = 18 10 -4 27 14 -4 22 16 -6
矩阵的行列式
使用MATLAB的det函数计算矩阵的行列式。 矩阵A的行列式由det(A)给出。
例子
使用以下代码创建脚本文件 −
a = [ 1 2 3; 2 3 4; 1 2 5] det(a)
运行该文件时，它将显示以下结果 −
a = 1 2 3 2 3 4 1 2 5 ans = -2
逆矩阵
矩阵A的倒数由A-1表示，使得以下关系成立 −
AA−1 = A−1A = 1
矩阵的逆矩阵并不总是存在。 如果矩阵的行列式为零，则逆不存在且矩阵是单数的。
使用inv函数计算MATLAB中矩阵的逆。 矩阵A的逆是由inv(A)给出的。
例子
使用以下代码创建脚本文件 −
a = [ 1 2 3; 2 3 4; 1 2 5] inv(a)
运行该文件时，它将显示以下结果 −
a = 1 2 3 2 3 4 1 2 5 ans = -3.5000 2.0000 0.5000 3.0000 -1.0000 -1.0000 -0.5000 0 0.5000
数组
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()函数创建一个包含所有1的数组 −
例如 −
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是一个3乘3的数组; 我们可以通过提供类似的值为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提供以下功能来排序，旋转，置换，重塑或移位数组内容。
| 函数 | 目地 |
|---|---|
| length | 矢量长度或最大阵列尺寸 |
| ndims | 数组维数 |
| numel | 数组元素的数量 |
| size | 数组大小 |
| iscolumn | 确定输入是否为列向量 |
| isempty | 确定数组是否为空 |
| ismatrix | 确定输入是否为矩阵 |
| isrow | 确定输入是否为行向量 |
| isscalar | 确定输入是否是标量 |
| isvector | 确定输入是否为矢量 |
| blkdiag | 根据输入参数构造块对角矩阵 |
| circshift | 循环移位阵列 |
| ctranspose | 复共轭转置 |
| diag | 矩阵的对角矩阵和对角线 |
| flipdim | 沿指定维度翻转数组 |
| fliplr | 从左到右翻转矩阵 |
| flipud | 将矩阵翻转到最低点 |
| ipermute | 逆变换N-D阵列的尺寸 |
| permute | 重新排列NDarray的尺寸 |
| repmat | 复制和平铺数组 |
| reshape | 重塑阵列 |
| rot90 | 将矩阵旋转90度 |
| shiftdim | 切换维度 |
| issorted | 确定集合元素是否按排序顺序排列 |
| sort | 按升序或降序对数组元素进行排序 |
| sortrows | 按升序对行进行排序 |
| squeeze | 删除单个维度 |
| transpose | 倒置 |
| vectorize | 矢量化表达 |
例如
以下示例说明了上面提到的一些功能。
长度，尺寸和元素数量 −
创建一个脚本文件并在其中键入以下代码 −
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 Array
单元阵列是索引单元的数组，其中每个单元可以存储不同维度和数据类型的数组。
cell功能用于创建单元阵列。 单元格函数的语法是 −
C = cell(dim) C = cell(dim1,...,dimN) D = cell(obj)
Where,
- C是cell array;
- dim 是一个标量整数或整数向量，指定单元格数组C的维数;
- dim1, ... , dimN 是标量整数，指定C的维数;
- obj 是以下之一 −
- Java数组或对象
- System.String或System.Object类型的.NET数组
例如
创建一个脚本文件并在其中键入以下代码 −
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中最有用的运算符之一。 它用于创建向量，下标数组，以及指定迭代。
如果要创建包含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(:,j) | 是A的第j列。 |
| A(i,:) | 是第i排A. |
| A(j:k) | A(j), A(j+1),...,A(k). |
| A(:,j:k) | A(:,j), A(:,j+1),...,A(:,k). |
| A(:,:,k) | 是三维数组A的k th页面。 |
| A(:) | 是A的所有元素，被视为单列。 在赋值语句的左侧，A(:)填充A，保留其之前的形状。 在这种情况下，右侧必须包含与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提供以下函数来转换为各种数字数据类型 −
| 函数 | 目的 |
|---|---|
| double | 转换为双精度数 |
| single | 转换为单精度数 |
| int8 | 转换为8位有符号整数 |
| int16 | 转换为16位有符号整数 |
| int32 | 转换为32位有符号整数 |
| int64 | 转换为64位有符号整数 |
| uint8 | 转换为8位无符号整数 |
| uint16 | 转换为16位无符号整数 |
| uint32 | 转换为32位无符号整数 |
| uint64 | 转换为64位无符号整数 |
例子
创建脚本文件并键入以下代码 −
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中创建字符串非常简单。 事实上，我们已多次使用它。 例如，您在命令提示符下键入以下内容 −
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中字符串函数的简要说明 −
| 函数 | 目的 |
|---|---|
| 用于在字符数组中存储文本，组合字符数组等的函数。 | |
| blanks | 创建空白字符串 |
| cellstr | 从字符数组创建字符串的单元格数组 |
| char | 转换为字符数组（字符串） |
| iscellstr | 确定输入是否是字符串的单元格数组 |
| ischar | 确定项是否为字符数组 |
| sprintf | 格式化数据到字符串 |
| strcat | 水平连接字符串 |
| strjoin | 将单元格数组中的字符串加入单个字符串 |
| 用于识别字符串部分，查找和替换子字符串的函数 | |
| ischar | 确定项是否为字符数组 |
| isletter | 数组元素是字母 |
| isspace | 数组元素是空格字符 |
| isstrprop | 确定字符串是否为指定的类别 |
| sscanf | 从字符串中读取格式化数据 |
| strfind | 找到另一个字符串 |
| strrep | 查找并替换子字符串 |
| strsplit | 在指定的分隔符处拆分字符串 |
| strtok | 字符串的选定部分 |
| validatestring | 检查文本字符串的有效性 |
| symvar | 确定表达式中的符号变量 |
| regexp | 匹配正则表达式（区分大小写） |
| regexpi | 匹配正则表达式（不区分大小写） |
| regexprep | 使用正则表达式替换字符串 |
| regexptranslate | 将字符串转换为正则表达式 |
| 字符串比较的函数 | |
| strcmp | 比较字符串（区分大小写） |
| strcmpi | 比较字符串（不区分大小写） |
| strncmp | 比较字符串的前n个字符（区分大小写） |
| strncmpi | 比较字符串的前n个字符（不区分大小写） |
| 用于将字符串更改为大写或小写，创建或删除空格的函数 | |
| deblank | 从字符串末尾剥去尾随空格 |
| strtrim | 从字符串中删除前导和尾随空格 |
| lower | 将字符串转换为小写 |
| upper | 将字符串转换为大写 |
| strjust | 对齐字符数组 |
例子
以下示例说明了上述一些字符串函数 −
格式化字符串
创建一个脚本文件并在其中键入以下代码 −
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命令提示符（称为基本工作空间）访问的工作空间分开。
函数可以接受多个输入参数，并且可以返回多个输出参数。
函数语句的语法是 −
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.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，但是，这次盘函数将是一个嵌套函数。
创建一个函数文件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 。
它们仅对父文件夹中的函数可见。
例子
让我们重写二次函数。 然而，这次计算判别式的 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中导入数据意味着从外部文件加载数据。 importdata函数允许加载不同格式的各种数据文件。 它有以下五种形式 −
| 序号 | 函数 & 描述 |
|---|---|
| 1 | A = importdata(filename)将数据从filename表示的文件加载到数组A. |
| 2 | A = importdata('-pastespecial')从系统剪贴板而不是从文件加载数据。 |
| 3 | A = importdata(___, delimiterIn)将delimiterIn解释为ASCII文件，文件名或剪贴板数据中的列分隔符。 您可以将delimiterIn与上述语法中的任何输入参数一起使用。 |
| 4 | A = importdata(___, delimiterIn, headerlinesIn)从ASCII文件，文件名或剪贴板加载数据，从行headerlinesIn+1开始读取数字数据。 |
| 5 | [A, delimiterOut, headerlinesOut] = importdata(___)使用先前语法中的任何输入参数，返回检测到的delimiterOut中输入ASCII文件的分隔符字符以及headerlinesOut中检测到的标题行数。 |
例子 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
在此示例中，让我们从剪贴板导入数据。
将以下行复制到剪贴板 −
Mathematics is simple
创建脚本文件并键入以下代码 −
A = importdata('-pastespecial')
运行该文件时，它将显示以下结果 −
A = 'Mathematics is simple'
低级文件I/O.
importdata函数是一个高级函数。 MATLAB中的低级文件I / O函数允许最大程度地控制对文件的读取或写入数据。 但是，这些功能需要有关您的文件的更详细信息才能有效工作。
MATLAB为字节或字符级别的读写操作提供以下功能 −
| 函数 | 描述 |
|---|---|
| fclose | 关闭一个或所有打开的文件 |
| feof | 测试文件结尾 |
| ferror | 有关文件I/O错误的信息 |
| fgetl | 从文件中读取行，删除换行符 |
| fgets | 从文件中读取行，保留换行符 |
| fopen | 打开文件，或获取有关打开文件的信息 |
| fprintf | 将数据写入文本文件 |
| fread | 从二进制文件中读取数据 |
| frewind | 将文件位置指示器移动到打开文件的开头 |
| fscanf | 从文本文件中读取数据 |
| fseek | 移动到文件中的指定位置 |
| ftell | 在打开文件中的位置 |
| fwrite | 将数据写入二进制文件 |
使用低级I/O导入文本数据文件
MATLAB为文本数据文件的低级导入提供以下功能 −
- fscanf函数以文本或ASCII文件读取格式化数据。
- 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允许您在另一个读取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执行上述语句并显示以下结果。 这是8位ASCII格式的字符串'hello'的字符。
1.0400000e+02 1.0100000e+02 1.0800000e+02 1.0800000e+02 1.1100000e+02
写日记文件
日记文件是MATLAB会话的活动日志。 日记功能在磁盘文件中创建会话的精确副本，不包括图形。
要打开日记功能，请键入 −
diary
或者，您可以提供日志文件的名称 −
diary logdata.out
要关闭日记功能 −
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
