MATLAB-基本运算

变量命名规则

1. 以字母开头，可以包含63个字母、数字和下划线（字母区分大小写）。
2. 不能使用Matlab关键字。
3. 避免与已经定义的变量或函数同名。

根据变量的生存时间和可访问特性，Matlab定义了三种类型的变量：

1. local 局部变量（默认）
2. global 全局变量
3. persistent 永久变量（仅用于函数中）

Matlab搜索路径

搜索路径指的是Matlab所有文件所在目录的列表。

当Matlab读取用户输入的命名（变量、函数或文件名），Matlab按以下顺序查找：
1） 是不是Matlab工作区的变量，如果不是，执行下一步。
2） 是不是Matlab内置函数，……
3） 是不是当前目录下的M文件，……
4） 按Matlab搜索路径顺序查找，……
5） 没有找到，提示错误信息。

更改搜索路径的方法：

1. 用户可以通过path组函数调用，对搜索路径内容进行添加、删除、排序等操作。
2. 更简便的方法是在Matlab桌面→File菜单→Set Path选项中进行操作。
3. 也可以在Current Folder窗口，按在线提示直接设置。

help exist % 查看返回值的意义
doc exist % 查看帮助文档
which exist %查看变量或文件位置

基本数据类型

Matlab定义了15种基本数据类型

1. 默认的数据类型为double（双精度浮点型）；
2. 除了function_handle（函数句柄），所有数据类型均支持数组运算；
3. cell（单元体）和struct（结构体）为承载其它数据的容器；
4. 函数class和whos查看数据类型。

整数型数值数据

1. 整型数据必须用相应的函数说明
   int8, int16, int32, int64
   uint8, uint16, uint32, uint64
2. intmax, intmin查看数值范围
3. 注意整型数的运算规则

% 整型数数据范围
intmax(‘int8’)
intmin(‘int8’)
intmin(‘uint8’)

% 整型数的运算
a = int8(pi) #3
b = int16(3.5) #4

class(a) % 查看变量类型
class(b)
whos % 查看当前工作区内所有的变量

c = a*b % 不同类型整数不能直接运算

d = a*pi % 注意整数和浮点数的运算结果

whos

浮点型数值数据

1. 单、双精度浮点数分别用single、double函数说明
2. realmax, realmin查看数值范围
3. format改变数据显示格式
4. eps显示数据精度

% 浮点数据范围
realmax single
realmin single
realmax
realmin

% 数据显示格式
pi
format long
pi

help format

% eps：一个浮点数能够取得的最小增量。
eps
eps(‘single’)
eps(‘double’)

eps(1)
eps(10)
eps(1e10)

% 浮点数的计算精度
sin(pi)
tan(pi/2)
exp(pi*i)

% 大数和小数的运算
a = 1 + 1e-16
b = 1
a == b % 关系运算符==判别两个操作数是否相等

% 运算次序
format long
a = 0.1+0.4-0.3
b = 0.1-0.3+0.4

if(a==b)
disp( ‘okay.’ ) % disp显示字符串内容
else
disp( ‘this is a bug!’ ) %显示这条 bug
end

a – b

% 避免用运算后浮点数结果是否相等作为判别条件。
% 一般浮点数都不能准确表达。
% 整数可以用浮点格式准确表达。

% 用format hex查看整数的存储
%…

% 浮点数代替整数的运算

% flintmax 浮点数能表达的连续整数的最大值2^53
% bitmax 浮点数能表达的最大整数2^53-1（现版本已删除）
% fix 取整数部分
% round 按舍入原则取整
% rem 计算余数

%
format long
m = 2^53
n = flintmax
m == n

a = 1.5, b = 1.4999
fix(a)
round(a)

rem(10, 3)
ream(1, 0.3)

% 验证Fermat数： F(n) = 2⁽²n) + 1, n = 0,1,2…
% F(5)不是质数

n = 5
N = 2⁽²n) + 1

for i = 2:sqrt(N)
if( rem(N, i)==0 )
disp(‘A factor is found!’)
break;
end;
end

复数运算

复数可以直接用i, j生成，也可以用complex函数
常用函数：real, imag, angle, abs, isreal
几乎所有的Matlab运算符和数学函数都支持复数运算
对复数矩阵，操作符 ’ 表示共轭转置运算

%
a = 1
b = 2
z = 1 + 2i
z = a + b1j % 写成1j避免与下标j混淆
z = complex(a, b)

real(z)
imag(z)
angle(z)
abs(z)

isreal(z)
isreal(zz’)
isreal(zz.’) % 注意操作符.和.'的差别
isreal( exp(pi*1j) ) % 注意浮点计算精度的影响

z^2
2/z
z\2
sqrt(z)
exp(z)

数组和数组运算

矩阵（matrix）是长度为mn的二维数值数组。
向量（vector）是长度为n的一维数组，可看做1n或n1的矩阵。
标量（scalar）指的是一个数字，可看做11的矩阵。

向量的创建

1. 方括号内直接输入
2. 冒号操作符
3. linspace和logspace函数

% 直接创建
a = [1 2 3]
b = [1*2 3-4]
c = [1+i 2-3i]

% 注意：
% 方括号内，表达式最好写成紧凑格式（不留空格）。
% 空格号与逗号的功能相同。

%下列表达易产生错误
d = [1 +2 3- 4] % 加减号可以是一元，也可以是二元操作符
e = [1 *i 2/ i]

% 冒号操作符
a = 1:6 % 缺省的步长为1
b = 0:0.1:0.5
c = -1:3:10

% 函数创建
d = linspace(1, 6, 6)
e = logspace(1, 3, 3)

% first:step:end 指定步长step（缺省为step = 1）
% linspace(first, end, n) 指点节点数n
% logspace(first, end, n) 10first ~ 10end

% Matlab数学函数支持向量输入，计算结果也是以向量返回
sqrt(a)
log10(e)

一维数组寻址

% 数组下标用 ( ) 表达

a = 1:10

a(1), a(3), a(10), a(end)

%下标可以是向量
a(1:5)
a(5:-1负一:1)
a(7:end)
a([1 3 5 7])

% 下标只能是正整数
a(3.14) % x
a(0) % x

% 下标不能超出end
a(12) % x

数组方向：行向量与列向量

Matlab的冒号操作符和linspace创建的均为行向量

创建列向量：
1） 分号操作符
2） 转置操作符（撇号）

a = [1 2 3]
b = [1; 2; 3] % 分号的换行功能
c = a.’ % 转置操作

% 复数问题
a = 1:3
c = a + a*1i
c’ % ’ 表示复数共轭转置，对非复数与.’ 功能相同
c.’ % .’ 表示非复数共轭转置

二维数组的创建

1. 直接创建
2. 由向量或数组合成
3. 利用标准数组

% 直接创建
a = [1 2 3; 4 5 6] % 分号的功能
b = [1 2 3; 4 5 6 7] % x

%数组合成
a = 1:4
b = 2:5
c = [a; b] % 注意数组的方向
d = [a.’, b.’]

e = [c, 3:6] % …
……

标准数组

zeros % 全0数组
ones % 全1数组
rand % （0~1）随机数数组
randn % 正态分布（0,1）随机数组
eye % 单位矩阵
diag % 对角矩阵
magic % 魔方矩阵
% 注：前4个函数可以用于多维数组

% Matlab中函数的输入、输出是可变的
eye(5)
eye(3, 4)
eye(3, 4, 2) % x

%
diag( [1 3 5 7] )
diag( 1:2:7 )

%
magic(3)
magic(5)

数组运算

标量-数组运算
加减乘除幂等运算是对数组中所有元素进行。Matlab通过标量扩展，将标量转换为相应大小的数组。

a = magic(3)
b = a-3
c = (a-3)*2
d = 2\a

数组-数组运算
大小相同的数组可以进行元素-元素的运算：
符号 .* ./ .\ .^

    数组-数组运算遵循矩阵运算规则
            符号 * / \ ^

1./a % 标量扩展
a^-1 % 求逆阵
1/a % x

数组操作

数组生成后，可以通过特定的下标，完成提取、赋值、重排等多种功能。

% 赋值
a = ones(3)
a(2,2) = 9

a(:, 1) = [0 0 0].’
a(:, 1) = 0 % 标量扩展

% 赋值语句中，当下标超出范围时，Matlab将自动扩展，未定义的位置填充0
x(2, 3) = 10 % 数组x是未创建的数组
x(5, 5) = 100 % 合法的
% !不推荐使用此类赋值方法

% 提取
b = a(1:2, 2:3)
% 提取数组元素时，下标超出范围不合法
c = a(10, 10) % x

%%多维数组的单下标寻址（线性索引）
d = magic(3)
d(1), d(6)
d(：) % Matlab多维数组的存储：列优先原则

d(3:7)
d(10) % x索引号不能超出总元素数
d(10) = 0 % x 数组形状不能改变

d(end, 1) % 注意end的取值
d(end)

% 了解函数sub2ind, ind2sub的用法

% 查找：函数find的使用
a = magic(4)
ind = find(a == 5)
[r, c] = find(a==5) % 赋值号左边’[ ]'的用法

% 多个返回值
b = magic(4)
ind = find(b<3)
[r, c] = find(b<3)

doc find %了解find更多的用法

% 排序：函数sort的使用
s = randperm(6) % 生成1~n随机排列的数组
sort(s) % 元素排序，缺省为ascend
sort(s, ‘ascend’)
sort(s,‘descend’)

% 矩阵或多维数组
t = magic(4)
sort(t) % 缺省为列优先、升序
sort(t,1) %1 表示列优先 2表示对行排列
sort(t,2)
sort(t, 2, ‘descend’)
[st, index] = sort(t, 2, ‘descend’)

% 熟悉函数sum, mean, max, min的用法
% 了解函数reshape和repmat 的用法

数组大小

函数size, length, numel, ndims

%
a = [1:4; 5:8]
size(a) % 返回一个行向量 [行数, 列数, 页数…] 1 2 3

length(a) % 返回数组的最大长度
max(size(a))

numel(a) % 返回数组的元素总数

ndims(a) % 数组维数
length(size(a))

向量的乘积—内积、外积、混合积

Matlab定义了函数dot和cross分别计算向量的内积和外积
向量u, v, w的混合积的定义为u.(v*w)

% 注意：函数cross只能对长度为3的向量进行运算

%
u = [1 2 3]
v = [1 3 5]
w = [2 1 1]

% 直接按定义计算
dot(u, cross(v, w))

% 另一方法
det ( [u; v; w] ) % 函数det计算方阵的行列式
det ( [u’ v’ w’] )

线性方程组—矩阵的乘法和除法

线性方程组ax = b的解为x = a\b 或 a^-1b

%
a = [1 2 3; 4 5 6; 7 8 9]
b = [1 2 3]’
x = a\b

a*x - b

x = inv(a)b % inv计算逆阵, inv(a)等同于a^-1
ax - b

% 问题的分析
inv(a)*a

% 线性方程组有唯一解的条件？
rank(a), rank( [a,b]) % rank计算矩阵的秩

%
a(3,3) = 0
rank(a), rank([a,b])
x = a\b
x = inv(a)*b
inv(a)*a

多维数组

格式：Array(row, column, page, …)

第三维称为页，更高的维数无统一的名称
创建方法、元素运算与二维类似
乘除运算无定义

%
a(:, :,1) = ones(3);
a(:,:,2) =eye(3);
a % 分页显示

% 函数zeros, ones, rand, randn可以创建多维数组
randn(2, 3, 4)
ones(2, 3, 3, 3)

% 多维数组的运算次序：列-行-页

b(:,:,1) = diag([1 10 100]);
b(:,:,2) = magic(3);
b

sum(b)
sum(b, 1) % 1/2/3分别表示对列/行/页进行求和
sum(b, 2)
sum(b, 3)

sum(sum(sum(b)))
sum( b(😃 )

稀疏矩阵

当矩阵的非0元素小于总元素数的1%，称为稀疏矩阵。存贮大量的0元素消耗内存资源，对0元素的运算也浪费大量机器时间。

a = eye(10)
s = sparse(a) % 函数sparse将普通矩阵转换为稀疏矩阵
whos

s(1,5) = 100 % 稀疏矩阵的操作与普通矩阵相同
size(s), length(s), numel(s)
c = s(2,2)

b = full(s) % 函数full将稀疏矩阵转换为普通矩阵
d = full©

% 以上仅仅是说明sparse用法，创建稀疏矩阵最好用speye, spdiags等函数
s = speye(1000);
a = eye(1000);
whos

% 创建稀疏数组必须用Matlab指定的函数
aa(1000, 1000) = 1; % 尽管非0元素极少，aa仍然是普通矩阵
whos
ss = sparse(aa)
whos

字符串

字符串是以字符显示显示的ASCII数值型数组。
Matlab中，字符串是用单引号括起来的一串字符；每个字符称为一个元素，通常用两个字节存储。

%
s = ‘Hellow, Matlab.’
d = double(s) %看到每个字符对应的ASCII
char(d)

% 内容提取
s(2)
s(1:6)
s(9:14)’

% 字符串中还有单引号，必须写成两个单引号
‘It doesn’‘t work unless…’

% 字符串合成
a = 'Hellow, ’
b = ‘Matlab.’
[a, b]

% 函数disp显示字符串内容，不显示变量名
disp(s)
disp(‘Very good’)

% 汉字和英文字符的处理方法相同

h = ‘汉字处理’
d = double(h)
char(d)

whos

字符串数组

多行字符构成字符串数组，单每行的元素必须相同。字符数少的串后面填充空格。

% 直接输入
s = [ 'one ’
'two ’
‘three’
'four ’ ]

size(s)

% 用函数char可以避免输入空格
t = char(‘one’, ‘two’, ‘three’, ‘four’)
size(t)

zh = char( ‘中国’, ‘安徽省合肥市’, ‘中国科学技术大学’, ‘230026’)
size(zh)

% 内容提取
t(2,1)
t(1,4)
t(:, 3)
t(3, 1:3)
t(12) % 线性索引

% 赋值和替换
t(4,1) = ‘F’
t(1,:) = ‘ONE’ % x，字符数目必须相等

t(:, 3) = ‘C’ % 标量扩展

格式化输入输出和格式转换

% 函数disp回显字符串或数组，无返回参数
disp(‘Matlab is matrix language.’);
disp( magic(3) );

% 函数sprintf将数据格式化写入到字符串
str = sprintf(‘Equation:\n%d x %.5f = %.2e’, 1000, pi, 1000*pi);
disp(str);
% sscanf从字符串中读取格式化数据
% …

% 函数num2str/str2num数字/字符串转换
a = 3.14
s = num2str(a)
str2num(s)
a == s

% 函数dec2bin/bin2dec无符号十进制数/二进制数显示的转换
a = 14
bits = dec2bin(a,8) % 整数显示为二进制8位字符串
bin2dec(bits)
bin2dec( ‘000111’ ) % 二进制字符串转换为整数

% 例：判别一个十进制整数中是否有某个数字

a = 31*137
s = num2str(a)
aa = str2num(s.’)
find(aa == 3) %

单元数组和结构体

单元数组（cell array）和结构体（structure）将不同类型的数据集成到一个变量中，方便相关数据的处理。

单元数组和结构仅仅是承载其它数据类型的容器，具体的运算主要针对其包含的数据。

单元数组和结构体的差别在于标识的方式：
cell array通过数字（下标）标识
structure通过名称（字段）标识

单元数组的创建

1） 直接用赋值语句创建
2） 函数cell创建

% 直接创建的两种格式：
% （1）按单元索引，待赋给单元的值必须用{}
a(1,1) = { 1:10 };
a(1,2) = { 1+i };
a(2,1) = { ‘this is a test.’ };
a(2,2) = { magic(3) }

% （2）按内容索引，将{}写在等式左边
b{1,1} = 1:10;
b{1,2} = 1+i;
b{2,1} = ‘this is a test.’;
b{2,2} = magic(3)

% 两种方法完全等效
% { }用于访问单元的值，( )用于标识单元

% 单元体比较简单时，可一步直接写出
c = { 1:10, 1+i; ‘this is a test.’, magic(3) }

% 比较a, b, c是否等同
isequal(a, b, c) % 所有收入参数均相等返回1

% 单元的内容很长，可能无法回显
a(1,1)
a{1,1}
a(1,2)
a{1,2}

% 回显单元体全部内容用celldisp函数，或用冒号操作符

celldisp(a)
a{:, :}

% 函数cellplot图示单元体结构

cellplot(a)

cell 函数

a = cell(3,4) % 生成3x4的空单元组数

a(1,1) = ‘this doesn’t work’ % x

a(1,1) = { ‘this does work’ }

单元数组的处理

%
% 注意与普通的数值型数组的差异
% { }和( )的差异

a = { 1:10, 1+i; ‘this is a test.’, magic(3) }

size(a)
numel(a)

size(a(1,1))
size(a{1,1})

class(a(1,1))
class(a{1,1})

% （）不能用于处理单元的内容
% 内容提取
b = a(1,1) % b是1x1单元数组
c = a{1,1} % c是1x10普通数组

% 赋值和替换
a(1,1) = eye(4) % x
a(1,1) = { eye(4) }
a{1,1} = eye(4)

字符串单元数组

c = { ‘one’; ‘two’; ‘three’; ‘four’ }
s = char(‘one’, ‘two’, ‘three’, ‘four’)
whos

% 函数cellstr将字符串数组转换为字符串单元数组，其功能与char相反

cellstr(s)
char©

isequal( cellstr(s), c )
isequal( char©, s)

c{1,1} = ‘a long word’
s(1,1) = ‘a long word’ %

结构体的创建

结构体用字段（fields）来进行索引，用点号访问字段中的数据。

创建方法：
1） 直接赋值创建
2） 函数struct创建

% 创建结构体circle
circle.radius = 2.3;
circle.center = [1, 2];
circle.linestyle = ‘–’

% 结构体数组
circle(2).linestyle = ‘-.’; %
circle(2).radius = 3^2;
circle(2).center = [2, 3]

% 函数struct

a1 = { 2.3, 3^2 } ; % 特定的字段值必须写成单元数组形式
a2 = { [1, 2], [2, 3] } ;
a3 = { ‘–’, ‘-.’ } ;
C = struct( ‘radius’, a1, ‘center’, a2, ‘linestyle’, a3 ) % 注意struct函数的输入参数格式

% 比较两种创建方法结果是否等同
isequal( circle, C)

结构体处理

% 添加新字段

C(1).color = ‘red’

C.color % 未定义的内容填充空数组

C(2).color = ‘blue’
C.color

% 内容提取

r1 = C(1).radius
r2 = C(2).radius

% 同时提取不同元素同字段的值
[r1, r2] = C.radius % 注意输出格式
[c1, c2] = C.center

关系和逻辑运算

关系和逻辑运算主要用于‘真/假’判断，控制程序执行。
运算结果为True/False （1/0），占一个字节。
关系和逻辑运算中，所有非0值视为True。

% 函数logical将数组转换为逻辑数组
a = diag( 1:5 )
b = logical(a)

%
a = eye(3)
b = logical(a)
whos % 查看a和b的数据类型和存储

关系运算符

<
<=

=
==
~=

关系运算主要用来比较两个尺度相等的数组对应元素大小，返回与原数组尺度相同的逻辑数组。
对于数组和标量比较，按标量扩展进行。

a = rand(3)
b = rand(3)
a > b
a > 0.5

% 关系表达式可以和数学表达式进行混合运算；运算中，逻辑值转换为浮点数。
b - (a>0.5)

% 例：除数为0问题
1/0 % 结果为无穷大，Inf
0/0 % 结果不确定，非数值，NaN (Not a Number)

%
x = -2:0.5:2
sin(x)./x

x = x + (x==0)*eps
sin(x)./x

逻辑数寻址

% 按逻辑数组的索引，根据其内容（1/0）完成相应操作。

a = magic(3)
index = logical( [1 0 1 0 1] ) % 生成逻辑数组
b = a(index) % 提取
a(index) = 0 % 赋值

a = magic(4)
ii = logical( eye(3) )
a(ii)
a(ii) = -1

%%
a = [1, pi, 0, -2.3]
index = find(a)
logical(a)

index = find( a>=1 )
a>=1

逻辑运算符

& 数组间元素与操作
| 数组间元素或操作
~ 数据元素反操作
&& 标量关系表达式的短路式(short-circuiting)与操作
|| 标量关系表达式的短路式或操作

%
a = randperm(5)
b = randperm(5)
c = a>b
d = ~c

% short-circuiting是指当已知逻辑运算结果时，就不再执行后面的表达式。

a = 1, b = 2
a == 1 || b ~= 1
a == 2 && b ==2

关系和逻辑函数

xor(x, y) 逻辑异或
any(x) 判别数组中 是否 含非零元素
all(x) 判别数组中 是否 全为非零元素

%
a = [ 3 1 0 0 ]
b = [ 2 0 4 0 ]
xor(a, b)
any(a)
all(a)

% 注意运算次序：列优先原则
a = [ 1 0 0; 2 0 0; 3 4 0]
any(a) % 缺省：按每列处理
any(a, 1)
any(a, 2) % 按每行处理

% 函数max/min的使用
b = magic(3)
max( b, 6 ) % 比较矩阵相应元素的大小

max( b) % 查找每列元素中的最大值
max( b, [ ], 2 ) % 查找每行元素中的最大值

mb = max(max(b))
[i, j] = find(b == mb) %
b(i, j) % i,j可能不是标量
index = find( b == mb ) %
b(index)

% is-簇函数：
% 检验特定条件是否成立，返回逻辑值。

isvarname, iskeyword, isequal
ischar, iscell, isstruct, islogical
isinf, isnan, isempty……

doc is* % 查看is-簇函数

特殊变量：Inf, NaN, [ ]

Inf, -Inf 计算结果超出能表达的范围，无穷大。
NaN 计算结果不确定，非数值
[ ] 是指一维或多维的长度为0的数组变量。

%
a = exp(1000)
log(a)
a*0
0/0

a = [ 1 NaN Inf -Inf NaN ]
a.^2
log(a)

% 关系运算检测计算结果是否含NaN或Inf，通常是不可取的
a == NaN
a == Inf

% 正确的方法是采用Matlab函数
isnan(a)
isinf(a)

% 替换NaN为0
i = find( isnan(a) )
a(i) = zeros( size(i) ) % a( find(isnan(a)) ) = 0;

% 替换Inf为一个数字
i = find( isinf(a) )
a(i) = 1e10*ones( size(i) )

空数组[ ]运算

% 空数组的维数和大小
a = ones(3, 0)
size(a)
length(a) % length和numel不计空数组
numel(a)

% 空数组直接进行关系运算，结果不确定
a = [ ]
a == [ ]
a == 1
a ~= 1

% 正确的方法是用函数isempty判别
isempty(a)

% 空数组用途1：函数返回值
a = 1:5
b = find(a>10)

isempty(b)

% 空数组用途2：数值操作
a = 1:7
a(3:6) = [] % 删除指定元素

b = magic(4)
b(:, 3) = [] % 删除整列
b(1:3, 2) = [] % x矩阵形状不能改变

c = zeros(1, 3)
n = 2 % repeat for 0 & -1
d = [ ones(1, n), c ] % 数组合成

运算符和特殊符号

doc special characters % 查看Matlab符号的功能

help precedence % 查看运算符优先权

注：

1. 同级运算按从左到右次序进行
2. 圆括号（）可以改变优先权
3. 注意&, |, &&, ||的优先权顺序

% 例：逻辑运算的优先权

L1 = 3|2&0
L2 = 3|(2&0)
L3 = (3|2)&0

位运算

% 主要用于底层的编程，如设备的控制程序，通讯数据处理，解码等。
% 位运算函数：bitand, bitor, bitxor, bitcmp, bitget, bitset, bitshift
% 位运算针对无符号整数，Matlab中可以直接用浮点数
% Matlab中二进制各位从低到高标识为1,2,…

%
a = 14, b = 7
dec2bin(a,8), dec2bin(b, 8)

bitand(a,b) % 位与
dec2bin( bitand(a,b), 8 ) % 显示为字符串

dec2bin( bitor(a,b), 8 ) % 位或
dec2bin( bitxor(a,b), 8 ) % 位异或
dec2bin( bitcmp(a, ‘uint8’) ) % 位补，指定格式

bitget(a, 3) % 提取一个二进制位
bitget(a, 8👎1) % 提取多位，返回数组

bitset(b, 4) % 设置某位为1
bitset(0, 1:8) % 设置不同位，返回数组

bitshift(1, 1) % 左移1位，低位补0
bitshift(4, -1) % 右移1位，高位补0

bitshift(1, 1:7, ‘uint8’)

时间运算

Matlab内部，日期和时间保存为一个双精度的日期值，其整数部分为从公元0年1月1日到当前的天数，小数部分为当前的时刻。

Matlab支持的时间格式：
1） 双精度日期数字now
2） 日期字符串datestr
3） 日期向量clock

%
now % 当前日期数值

datestr(now) % 当前日期字符串

date % 只显示年月日

help datestr % 查看datestr的用法

datestr(now, 31) % 中国日期格式

clock % 显示日期的数组

datestr(clock) % 将日期向量转换为字符串

weekday(date) % 返回当前是一个星期的第几天
[n,w]=weekday(date) % 周日是第一天

calendar(date) % 日历
calendar(now)
calendar(2008, 8)

计数函数

cputime % Matlab占用CPU的时间
etime % 利用clock函数记录时间差
tic / toc % 启动/读取计时器（推荐）

%%检测代码运行时间

tc0 = cputime;
te0 = clock;
tic;

x = 0:0.1:2*pi;
plot (x, sin(x)); % 绘制正弦函数图形

t1 = cputime - tc0
t2 = etime (clock, te0)
t3 = toc

%

n = 2000;
A = rand(n); B = rand(n,1);

tic, X1 = A\B; toc
tic, X2 = A^-1*B; toc