matopy.lib package¶

Submodules¶

matopy.lib.libmatopy module¶

matopy.lib.libmatopy.abs(a)¶

matopy.lib.libmatopy.all(a)¶

matopy.lib.libmatopy.any(a)¶

matopy.lib.libmatopy.arange(start, stop, step=1, **kwargs)¶

创建范围行向量 :argument start: 开始下标 :argument stop: 结束下标，返回的数组包含该下标 :argument step: 步长，可以是负数 :returns: 按步长从 start 到 stop 排列的一组数，类型是 matlabarray。

Examples¶

>>> a=arange(1,10) # 1:10
>>> size(a)
matlabarray([[ 1, 10]])

>>> arange(0,1,0.5)
matlabarray([[0. , 0.5, 1. ]])

>>> a=arange(0, 1, 0.00025)
>>> length(a)
4001

>>> a=arange(0, 0.14700000000000001, 0.00025)
>>> length(a)
589

支持空序列: >>> length(arange(2,1)) 0

小数问题: >>> r=arange(18.5495, 25.212249999999997, 0.00025) >>> r.shape[1] 26652

matopy.lib.libmatopy.assert_(a, b=None, c=None)¶

matopy.lib.libmatopy.ceil(a)¶

matopy.lib.libmatopy.cell(*args)¶

class matopy.lib.libmatopy.cellarray(a=[])¶

基类：matlabarray

Cell array corresponds to matlab {}

class matopy.lib.libmatopy.cellstr(a)¶

基类：matlabarray

转换为字符向量元胞数组，在 matopy 中，元胞数组也是 matlabarray。

对应 matlab 中的 cellstr() 函数。注意：本类还未通过测试，不可用！！！

# >>> s=cellstr(chararray(‘helloworldkitty’).reshape((3,5))) # >>> s # >>> s = cellstr([[‘hello’, ‘world’, ‘kitty’]], dtype=object) # >>> s # hello # world # kitty # >>> s.shape # (1, 3)

class matopy.lib.libmatopy.chararray(a='')¶

基类：matlabarray

实现 matlab 中`字符数组` char array 的功能。

python 的 str 对象对应于 matlab 的字符串而不是字符数组。

它继承自 matlabarray，除了 dtype 不一样。字符编码统一用 utf8。还不支持 unicode 字符。

可以使用 [:] 下标索引，将返回一个 chararray() 对象。

语法¶

chararray(str) 用字符串构造 chararray 对象。

chararray([int]) 用数字列表构造 chararray 对象。数字是字符的unicode代码（Unicode code point），可以用 chr(n) 转换为字符。

Examples¶

>>> s=chararray()
>>> s.shape
(0, 0)

>>> s=chararray('helloworld')
>>> reshape(s, [2,5])
hlool
elwrd

>>> s=chararray([104, 101, 108, 108, 111, 119, 111, 114, 108, 100])
>>> s.shape = 2,5
>>> print(s)
hello
world

用下标索引：

>>> s=chararray('helloworld')
>>> s[1:3]
hel

支持 unicode:

>>> s=chararray('你好matlab世界！')
>>> s[1:3]

你好m

赋值给元胞数组，应该作为整体赋值：

>>> table_stat=cellarray()
>>> table_stat[1,1]=chararray('2023年')
>>> type(table_stat[1,1])   
<class '...chararray'>
>>> table_stat[1,1].shape
(1, 5)
>>> table_stat[1,1]
2023年

reshape(shape, order='C')¶

Returns an array containing the same data with a new shape.

Refer to numpy.reshape for full documentation.

Notes¶

Unlike the free function numpy.reshape, this method on ndarray allows the elements of the shape parameter to be passed in as separate arguments. For example, a.reshape(10, 11) is equivalent to a.reshape((10, 11)).

matopy.lib.libmatopy.check_matlabarray_(A)¶: 要求 A 必须是 matlabarray 类型，否则抛出异常

matopy.lib.libmatopy.clc()¶

matopy.lib.libmatopy.clear(*args)¶

matopy.lib.libmatopy.close(*args)¶

matopy.lib.libmatopy.close_(*args)¶

matopy.lib.libmatopy.concat_(*args)¶

水平合并 2 个数组, 实现 matalb 的 [ 1:2 , 3:4 ] 这些的语句。

可以按行水平合并，concat_([1,2,3,4,5] , [1,2,3,4,5])

废弃按列垂直合并的用法，改为用 vconcat_：: 按列垂直合并，concat_([[1,2,3,4,5] , [1,2,3,4,5]]) <==废弃原来的 concat_([[1,2,3], [4,5,6]]) 将返回水平合并的结果： matlabarray([1,2,3,4,5,6])

matlab 函数中没有此函数。

Examples¶

按行合并：

>>> concat_([1,2,3,4,5] , [1,2,3,4,5])
matlabarray([[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]])

支持 matlabarray 2d 的行向量:

>>> concat_(arange(1,3), arange(4,6))
matlabarray([[1, 2, 3, 4, 5, 6]])

按行合并，且支持空数组： >>> concat_(matlabarray([1,2,3,4,5]), matlabarray(), matlabarray([1,2,3,4,5])) matlabarray([[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]])

支持合并标量 >>> concat_(1, 2.3) matlabarray([[1. , 2.3]])

如果参数都是空数组，则返回空数组： >>> concat_(matlabarray(),matlabarray(),matlabarray()) matlabarray([], shape=(0, 0), dtype=float64)

支持垂直合并，当然也可以用 vconcat_： >>> concat_([[1,2,3] , [4,5,6]]) matlabarray([[1, 2, 3],

[4, 5, 6]])

支持外面加 [ ] 的列表形式，将其中的元素水平合并: >>> concat_([arange(1,3) , arange(4,6)]) matlabarray([[1, 2, 3, 4, 5, 6]])

matopy.lib.libmatopy.copy(a)¶

拷贝一个矩阵， :param a: 矩阵 :return: 和矩阵 a 相同类型的副本矩阵

Examples¶

复制矩阵保持 cellarray 类型: >>> A = cellarray([1,2,3]) >>> B = copy(A) >>> type(B) <class ‘matopy.lib.libmatopy.cellarray’>

>>> A = matlabarray([1,2,3])
>>> B = copy(A)
>>> type(B)
<class 'matopy.lib.libmatopy.matlabarray'>

# cellstr 转换为字符向量元胞数组的类、函数还不可用，所以先不测试这种情况 # >>> A = cellstr(chararray(‘helloworldkitty’).reshape((3,5))) # >>> B = copy(A) # >>> type(B) # <class ‘matopy.lib.libmatopy.cellstr’>

>>> A = chararray('abc')
>>> B = copy(A)
>>> type(B)
<class 'matopy.lib.libmatopy.chararray'>
>>> B.shape
(1, 3)

拷贝要保持 dtype： >>> A = matlabarray([1,2,3], dtype=np.int8) >>> B = copy(A) >>> B.dtype dtype(‘int8’)

matopy.lib.libmatopy.deal(a, **kwargs)¶

matopy.lib.libmatopy.disp(*args)¶

matopy.lib.libmatopy.eig(a)¶

class matopy.lib.libmatopy.end¶

基类：object

matlab 中的 end 索引符号

matopy.lib.libmatopy.error(s)¶

matopy.lib.libmatopy.exist(a, b)¶

matopy.lib.libmatopy.false(*args)¶

matopy.lib.libmatopy.fflush(fp)¶

matopy.lib.libmatopy.find(a, n=None, d='first', nargout=1)¶

查找非零元素的索引和值 TODO 应该尽可能返回一个有内存的对象

语法¶

k = find(X)

k = find(X,n) 返回与 X 中的非零元素对应的前 n 个索引。

k = find(X,n,direction) 【未实现】

[row,col] = find(___)

[row,col,v] = find(___) 【未实现】

说明¶

k = find(X) 返回一个包含数组 X 中每个非零元素的线性索引的向量。

如果 X 为向量，则 find 返回方向与 X 相同的向量。

如果 X 为多维数组，则 find 返回由结果的线性索引组成的列向量。注意：一点区别，matlab中find返回的是**列向量**，这里返回的是**行向量**。

k = find(X,n) 返回与 X 中的非零元素对应的前 n 个索引。按列优先方式排列的前 n 个。

k = find(X,n,direction)（其中 direction 为 ‘last’）查找与 X 中的非零元素对应的最后 n 个索引。: direction 的默认值为 ‘first’，即查找与非零元素对应的前 n 个索引。【未实现】

[row,col] = find(___) 使用前面语法中的任何输入参数返回数组 X 中每个非零元素的行和列下标。按列优先排列的元素下标。

[row,col,v] = find(___) 还返回包含 X 的非零元素的向量 v。【未实现】

Examples¶

注意：python 中’比较运算符构成的表达式’要用’()’圆括弧包起来才行，否则会提示错误。

>>> A = matlabarray([[10,20,30],[40,50,60]])
>>> find( (A>=20) & (A<=50) )               # 注意：一点区别，matlab中find返回的是列向量，这里返回的是行向量。
matlabarray([[2, 3, 4, 5]], dtype=int64)

在 3×3 矩阵中查找非零元素。 >>> X = matlabarray([[1, 0, 2], … [0, 1, 1], … [0, 0, 4]]) >>> find(X) matlabarray([[1, 5, 7, 8, 9]], dtype=int64)

对 X 使用逻辑 not 运算符以查找零值。 matlab 中用 ~X 取反，~做的是逻辑运算，而 numpy 是用 not( >>> find(logical_not(X)) matlabarray([[2, 3, 4, 6]], dtype=int64)

如果 X 为多维数组，则 find 返回由结果的线性索引组成的列向量: >>> A = matlabarray([[10,20,30], … [40,50,60]]) >>> idx = find( (A>=20) & (A<=50) ) >>> A[idx] matlabarray([[40, 20, 50, 30]])

取前 n 个数 >>> X = matlabarray([[1, 0, 2], … [0, 1, 1], … [0, 0, 4]]) >>> find(X, 3) matlabarray([[1, 5, 7]], dtype=int64)

返回行列下标： >>> X = matlabarray([[1, 0, 2], … [0, 1, 1], … [0, 0, 4]]) >>> row, col = find(X, nargout=2) >>> row matlabarray([[1, 2, 1, 2, 3]])

>>> col
matlabarray([[1, 2, 3, 3, 3]])

返回行列下标，前 n 个： >>> X = matlabarray([[1, 0, 2], … [0, 1, 1], … [0, 0, 4]]) >>> row, col = find(X, 3, nargout=2) >>> row matlabarray([[1, 2, 1]])

>>> col
matlabarray([[1, 2, 3]])

对列进行查找： >>> X = matlabarray([[1, 0, 2], … [2, 1, 1], … [2, 0, 4]]) >>> find(X[:,1]==2) matlabarray([[2],

[3]], dtype=int64)

比较的目标对象是 matlabarray >>> target = matlabarray([[2]]) >>> X = matlabarray([[1, 0, 2], … [2, 1, 1], … [2, 0, 4]]) >>> find(X[:,1]==target) matlabarray([[2],

[3]], dtype=int64)

如果是字符串矩阵，需要先转换为对应的数字矩阵再比较才正确： >>> disp_switch = matlabarray([[‘18’,’18’]]) >>> no_sw = disp_switch[1,1].astype(np.float_) >>> distance_table = matlabarray([[ 12, 37800, 29], … [ 12, 37907, 31], … [ 12, 43200, 30], … [ 12, 43000, 30], … [ 12, 43202, 30], … [ 18, 61800, 46], … [ 18, 64217, 50], … [ 18, 69000, 53], … [ 30, 102000, 79], … [ 30, 102400, 79], … [ 39, 136945, 111], … [ 41, 140599, 107], … [ 42, 157200, 113], … [ 42, 157000, 113], … [ 42, 136926, 113], … [ 50, 181363, 149], … [ 50, 176129, 149], … [ 62, 201000, 149]]) >>> find(distance_table[:,1] == no_sw) matlabarray([[6],

[7], [8]], dtype=int64)

find 返回与 x 相同形状的结果矩阵： >>> A = matlabarray([1,2,3]).T >>> B = find(A !=0 ) >>> B.shape (3, 1)

返回最后 n 个下标： >>> from matopy.lib.libbasic import magic >>> X = magic(6) >>> X[1::2] = 0 >>> X matlabarray([[ 0, 0, 0, 0, 0, 0],

[ 3, 32, 7, 21, 23, 25], [ 0, 0, 0, 0, 0, 0], [ 8, 28, 33, 17, 10, 15], [ 0, 0, 0, 0, 0, 0], [ 4, 36, 29, 13, 18, 11]])

>>> find(X,4,'last')
matlabarray([[30, 32, 34, 36]], dtype=int64)

matopy.lib.libmatopy.first_g1_dimension(A)¶

查找大小大于1的第一个数组维度，从 0 开始，是 numpy 约定

如果是标量，返回 0

matopy.lib.libmatopy.floor(a)¶

此 MATLAB 函数将 X 的每个元素四舍五入到小于或等于该元素的最接近整数。 :param a: 输入数组，标量 | 向量 | 矩阵 | 多维数组 :return: 输出数组

Examples¶

>>> floor(1.2)
1
>>> floor(-1.2)
-2

matopy.lib.libmatopy.fprintf(fp, fmt, *args)¶

matopy.lib.libmatopy.fullfile(*args)¶

matopy.lib.libmatopy.function(f)¶

表示本函数使用 matlab 约定开发，例如：下标从 1 开始等。

还会自动将位置参数、关键字参数转换为 matlabarray 类型，除非参数是 chararray 类型。

matopy.lib.libmatopy.horzcat(*args)¶

水平合并 2 个数组, 实现 matalb 的 [ 1:2 , 3:4 ] 这些的语句。

可以按行水平合并，concat_([1,2,3,4,5] , [1,2,3,4,5])

废弃按列垂直合并的用法，改为用 vconcat_：: 按列垂直合并，concat_([[1,2,3,4,5] , [1,2,3,4,5]]) <==废弃原来的 concat_([[1,2,3], [4,5,6]]) 将返回水平合并的结果： matlabarray([1,2,3,4,5,6])

matlab 函数中没有此函数。

Examples¶

按行合并：

>>> concat_([1,2,3,4,5] , [1,2,3,4,5])
matlabarray([[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]])

支持 matlabarray 2d 的行向量:

>>> concat_(arange(1,3), arange(4,6))
matlabarray([[1, 2, 3, 4, 5, 6]])

按行合并，且支持空数组： >>> concat_(matlabarray([1,2,3,4,5]), matlabarray(), matlabarray([1,2,3,4,5])) matlabarray([[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]])

支持合并标量 >>> concat_(1, 2.3) matlabarray([[1. , 2.3]])

如果参数都是空数组，则返回空数组： >>> concat_(matlabarray(),matlabarray(),matlabarray()) matlabarray([], shape=(0, 0), dtype=float64)

支持垂直合并，当然也可以用 vconcat_： >>> concat_([[1,2,3] , [4,5,6]]) matlabarray([[1, 2, 3],

[4, 5, 6]])

支持外面加 [ ] 的列表形式，将其中的元素水平合并: >>> concat_([arange(1,3) , arange(4,6)]) matlabarray([[1, 2, 3, 4, 5, 6]])

matopy.lib.libmatopy.is_column_vector(a)¶

是否为`列向量`

一维数组认为是`行向量`不是列向量。

Examples¶

>>> is_column_vector([1,2,3])
False
>>> is_column_vector(np.array([1,2,3]))
False
>>> is_column_vector(np.array([1,2,3]).T)   # 一维数组转置后，还是一维数组，所以还不是列向量
False
>>> is_column_vector([[1],[2]])
True
>>> is_column_vector(matlabarray([1,2,3]))
False
>>> is_column_vector(matlabarray([[1],[2]]))
True
>>> is_column_vector(matlabarray())
False

matopy.lib.libmatopy.is_row_vector(a)¶

是否为`行向量`

一维数组认为是`行向量`。

Examples¶

>>> is_row_vector([1,2,3])
True
>>> is_row_vector(np.array([1,2,3]))
True
>>> is_row_vector([[1],[2]])
False
>>> is_row_vector(matlabarray([1,2,3]))
True
>>> is_row_vector(matlabarray([[1],[2]]))
False
>>> is_row_vector(matlabarray())
False

matopy.lib.libmatopy.isa(a, b)¶

matopy.lib.libmatopy.iscellstr(a)¶

matopy.lib.libmatopy.ischar(a)¶

matopy.lib.libmatopy.isempty(a)¶: 判断集合a是否为空数组 :argument a: 要判断的参数，可以是 list, ndarray, matlabarray 或任意类型的数据，非集合类型的参数 a 一律认为非空。 :returns: True 如果 a 是集合且为空，非集合类型的参数 a 一律认为非空。

matopy.lib.libmatopy.isequal(a, b)¶

matopy.lib.libmatopy.isfield(a, b)¶

matopy.lib.libmatopy.ismatrix(a)¶

确定输入是否为矩阵

矩阵是大小为 m×n 的二维数组，其中 m 和 n 是非负整数。

如果 A 是矩阵，TF = ismatrix(A) 将返回逻辑值 1 (true)。否则，将返回逻辑值 0 (false)。

Returns¶

1 如果 a 是矩阵；否则返回 0

只有 matlabarray 和 np.ndarray 才有可能是矩阵，list、tuple 不算矩阵，即便他们是2维的。

Examples¶

>>> ismatrix(matlabarray([[1,2],[3,4]]))
1
>>> ismatrix(matlabarray([[1,2]]))
1

matlabarray 对象默认构造就是2维矩阵： >>> ismatrix(matlabarray([1,2])) 1

除非显式拉平： >>> ismatrix(matlabarray([1,2,3]).flatten()) 0

>>> ismatrix(1)
0

>>> ismatrix([[1,2],[3,4]])
0

matopy.lib.libmatopy.isnan(a)¶

确定哪些数组元素为 NaN

语法¶

TF = isnan(A)

TF = isnan(A) 返回一个逻辑数组，其中的 1 (true) 对应 A 中的 NaN 元素，0 (false) 对应其他元素。

未实现、测试：如果 A 包含复数，则 isnan(A) 中的 1 对应实部或虚部为 NaN 值的元素，0 对应实部和虚部均非 NaN 值的元素。

Examples¶

>>> d = NA
>>> r = isnan(d)
>>> print(r)
True

>>> isnan(1)
False

>>> r=isnan(matlabarray([1, NA]))
>>> print(r)
[[False  True]]

matopy.lib.libmatopy.isnumeric(a)¶

matopy.lib.libmatopy.isreal(a)¶

matopy.lib.libmatopy.isscalar(a)¶

是否为标量

遵循 matlab 的标准，标量是大小为 1×1 的二维数组。

python变化¶

加上 python、numpy 的规则：

1、如果 a 是 matlabarray 或 numpy.ndarray，那么标量是大小为 1×1 的二维数组。或者只有1个元素的多维数组。 2、如果 a 是其他python类型对象，那么用 numpy.isscalar() 定义的规则，尤其注意： * zero-dimensional numpy arrays 不是 scalar。 * 不可变容器， str 和 tuple 算标量，而 list 不算标量。

Examples¶

>>> isscalar(0)
1

list 不算标量 >>> isscalar([1]) 0

1x1的矩阵算标量 >>> isscalar(matlabarray([0])) 1 >>> isscalar(‘0’) 1

matopy.lib.libmatopy.isvector(a)¶

是否为向量

向量是大小为 1×N 或 N×1 的二维数组，其中 N 是非负整数。

如果 a 是 list，转换为 matlabarray 对象再检查。

注意：本函数认为空数组不算向量。只有一个元素的矩阵在 matlab 中算‘向量’。

python变化¶

只有 a 是 matlabarray 或 numpy.ndarray 对象才用上面的规则：向量是大小为 1×N 或 N×1 的二维数组，其中 N 是非负整数。

如果 a 是其他 python 类型，例如 int、tuple 等，那么不算向量，算标量。

Returns¶

int: 如果是向量返回 1，否则返回 0

Examples¶

>>> isvector(matlabarray([1,2,3]))
1

只有一个元素的矩阵在 matlab 中算‘向量’: >>> isvector(matlabarray([1])) 1 >>> isvector(matlabarray([[1,2],[3,4]])) 0

list的标准同 matlabarrayar: >>> isvector([1]) 1 >>> isvector([1,2]) 1

空数组不算向量 >>> isvector([]) 0 >>> isvector(matlabarray()) 0

matopy.lib.libmatopy.isvector_or_scalar(a)¶

是向量或标量

一维数组形状是 [N], 行列矩阵形状分别是 [1 N] 和 [N 1], 以及他们的一般形式 [1 1 … N … 1 1 1].

如果 a 是 matlabarray对象，如果形状是 [1 1 … 1]，也算标量.

空数组也算向量。

Examples¶

>>> isvector_or_scalar(1)
1

一个元素的 list 算 vector: >>> isvector_or_scalar([1]) 1

>>> isvector_or_scalar(matlabarray([1]))
1

空向量不算向量: >>> isvector_or_scalar(matlabarray([])) 0

matopy.lib.libmatopy.length(a)¶

最大数组维度的长度

L = length(X) 返回 X 中最大数组维度的长度。对于向量，长度仅仅是元素数量。对于具有更多维度的数据，长度为 max(size(X))。空数组的长度为零。

>>> length(matlabarray())
0
>>> length(matlabarray([1,2,3]))
3

空数组的长度为 0 的 numpy 数字对象

>>> length(matlabarray().reshape(0, 11))
0

支持作为分母而不产生异常：

>>> length(matlabarray().reshape(0, 11))/length(matlabarray().reshape(0, 11))
nan

参数 a 是标量则返回 1 >>> length(1) 1

matopy.lib.libmatopy.logical_and(a, b)¶

matopy.lib.libmatopy.logical_not(a)¶

matopy.lib.libmatopy.logical_or(a, b)¶

class matopy.lib.libmatopy.matlabarray(a=[], dtype=None)¶

基类：ndarray

替换matlab矩阵的类

Examples¶

创建空向量：

>>> matlabarray()
matlabarray([], shape=(0, 0), dtype=float64)

默认创建行向量:

>>> a = matlabarray([1,2,3])
>>> a.shape
(1, 3)

合并多个行向量，创建一个行向量(需要编译器添加 concat() 函数调用，即将 [arange(1,5), arange(1,5)] 变为 concat_(arange(1,5), arange(1,5)))：

>>> concat_(arange(1,5), arange(1,5))
matlabarray([[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]])

合并多个字符串为一个字符串行向量(需要编译器添加 concat() 函数):

>>> concat_("hello","world")
helloworld

支持维度扩展 a = a[:, None] 写法: 正常应该用 np.expand_dims(a, axis)

>>> a = matlabarray([1,2,3]).flatten()
>>> a.shape
(3,)
>>> a = a[:, None]
>>> a.shape
(3, 1)
>>> a
matlabarray([[1],
       [2],
       [3]])

matlabarray 行向量添加新维度：

>>> a = matlabarray([1,2,3])
>>> a.shape
(1, 3)
>>> a = a[1, :, None]
>>> a
matlabarray([[[1],
        [2],
        [3]]])
>>> a.shape
(1, 3, 1)

空索引返回空数组：

>>> a = matlabarray([1,2,3])
>>> b = a[matlabarray()]
>>> b.shape
(1, 0)
>>> b
matlabarray([], shape=(1, 0), dtype=int32)

可以用赋值空list、空数组的方式删除指定的元素:

>>> m = matlabarray([[1,2,3],[4,5,6]])
>>> m[1, :]=[]
>>> m
matlabarray([[4, 5, 6]])

支持删除指定范围的行:

>>> m = matlabarray([[1,2,3],
...                  [4,5,6],
...                  [7,8,9]])
>>> m[2:3, :]=[]
>>> m
matlabarray([[1, 2, 3]])

支持删除 bool（逻辑）矩阵索引中为 True 的行、列：

>>> A = matlabarray([[1,2,3],
...                  [4,5,6]])
>>> logic_array = A[:,1]>2
>>> logic_array
matlabarray([[False],
       [ True]])
>>> A[logic_array,:] = matlabarray()
>>> A
matlabarray([[1, 2, 3]])

用空数组当索引下标，删除记录，应该不改变原矩阵的内容：

>>> m = matlabarray([[1,2,3],[4,5,6]])
>>> m[matlabarray(),:]=matlabarray()
>>> m.shape
(2, 3)

用‘向量创建’表达式 ‘:’ 创建列:

>>> A = matlabarray()
>>> A[:,1] = arange(1, 3, 1)
>>> A
matlabarray([[1.],
       [2.],
       [3.]])

然后用单值创建新的列：

>>> A = matlabarray()
>>> A[:,1] = arange(10, 30, 10)
>>> A[:,2] = 1
>>> A
matlabarray([[10.,  1.],
       [20.,  1.],
       [30.,  1.]])

用‘向量创建’表达式 ‘:’ 创建行:

>>> A = matlabarray()
>>> A[1,:] = arange(1, 3, 1)
>>> A
matlabarray([[1., 2., 3.]])

>>> A = matlabarray()
>>> A[2,:] = arange(1, 3, 1)
>>> A
matlabarray([[0., 0., 0.],
       [1., 2., 3.]])
>>> A[3,:] = 3
>>> A
matlabarray([[0., 0., 0.],
       [1., 2., 3.],
       [3., 3., 3.]])

中间补0的情况：

>>> A = matlabarray()
>>> A[1,:] = arange(1, 3, 1)
>>> A[3,:] = 3
>>> A
matlabarray([[1., 2., 3.],
       [0., 0., 0.],
       [3., 3., 3.]])

>>> A = matlabarray()
>>> A[:,1] = arange(1, 3, 1)
>>> A[:,3] = 3
>>> A
matlabarray([[1., 0., 3.],
       [2., 0., 3.],
       [3., 0., 3.]])

和 matlab 一样，如果索引是小数则四舍五入到整数，并提示警告信息：

>>> A = matlabarray(arange(1, 10))
>>> A[5/2: end()]
matlabarray([[ 3,  4,  5,  6,  7,  8,  9, 10]])

>>> A[5/3: end()]
matlabarray([[ 2,  3,  4,  5,  6,  7,  8,  9, 10]])

>>> A[5/2.3: end()]
matlabarray([[ 2,  3,  4,  5,  6,  7,  8,  9, 10]])

bool 索引应该返回正确的值：

>>> A = matlabarray([1, 2, 3])
>>> idx = A >= 1
>>> A[idx]
matlabarray([[1, 2, 3]])

创建 0x1 的空数组:

>>> A = matlabarray([])
>>> A = A.reshape(0,1)
>>> A
matlabarray([], shape=(0, 1), dtype=float64)
>>> A.shape
(0, 1)

用切片表达式对矩阵赋值： >>> A = matlabarray([[1,2,3], … [4,5,6], … [7,8,9]]) >>> B = matlabarray([[1,2,3], … [4,5,6], … [7,8,9]]) * 10 >>> A[1:3, :] = B >>> A matlabarray([[10, 20, 30],

[40, 50, 60], [70, 80, 90]])

用 arange 切片: >>> A = rand(5,4) >>> B = arange(1., 20.).reshape(5,4) >>> A[arange(1,5), :] = B[:, arange(1,4)] >>> A matlabarray([[ 1., 2., 3., 4.],

[ 5., 6., 7., 8.], [ 9., 10., 11., 12.], [13., 14., 15., 16.], [17., 18., 19., 20.]])

用切片扩展空矩阵: >>> A = matlabarray() >>> B = arange(1, 20).reshape(5,4) >>> A[arange(1,5), :] = B[:, arange(1,4)] >>> A matlabarray([[ 1., 2., 3., 4.],

[ 5., 6., 7., 8.], [ 9., 10., 11., 12.], [13., 14., 15., 16.], [17., 18., 19., 20.]])

>>> A = matlabarray()
>>> A[:, arange(1,4)] = B[:, arange(1,4)]
>>> A
matlabarray([[ 1.,  2.,  3.,  4.],
       [ 5.,  6.,  7.,  8.],
       [ 9., 10., 11., 12.],
       [13., 14., 15., 16.],
       [17., 18., 19., 20.]])

全数字下标：

>>> A = matlabarray()
>>> B = arange(1, 20).reshape(5,4)
>>> A[arange(1,5), arange(1,4)] = B[:, arange(1,4)]
>>> A
matlabarray([[ 1.,  2.,  3.,  4.],
       [ 5.,  6.,  7.,  8.],
       [ 9., 10., 11., 12.],
       [13., 14., 15., 16.],
       [17., 18., 19., 20.]])

compute_indices(index)¶

将 matlab 模式的下标对象（通常是 tuple of slice 对象）转换为 python模式的下标对象。这里索引的开始约定用 matlab 的，即从 1 开始。

Parameters¶

index: list of index: 索引列表，元素可以是 slice、int 或者 list of int。索引对象是matlab模式的，未经转换的索引，索引下标从1开始。也可以是 bool 数组，用来实现 matlab 的’逻辑矩阵下标索引’，matlab 用逻辑索引下标索引得到的结构也是列向量。

Returns¶

Python模式(下标从0开始)的索引对象，用 ndarray 对象表示，每个元素代表一个维度索引。slice切片对象会被展开为ndarray对象。

空切片对象 slice(None) 或 ‘[:]’ 冒号下标，会被展开为本矩阵对应维度的下标列表，列表长度为该维度的长度值。如维度 0 长度是 3 那么 [:,2] index 会返回 ([0,1,2], 1)。

注意：matlab 中冒号表达式的末尾索引是包含关系，如 “1:1:5” 会生成 1,2,3,4,5；但 python 中对应的 slice 表达式末尾是排除关系，即 python “1:5” 会生成 1,2,3,4；所以返回的索引要正确包含末尾元素。

Examples¶

>>> a = matlabarray([1,2,3])
>>> a.shape
(1, 3)

>>> a.compute_indices((1, slice(None,None,None), None))
(0, array([0, 1, 2]), 0)

支持 end() 用在索引中：

>>> A = matlabarray([1,2,3])
>>> A[1, 1:end()-1]
matlabarray([[1, 2]])
>>> A[1:end()-1]
matlabarray([[1, 2]])
>>> A[end()]
3

和 matlab 一样，如果索引是小数则四舍五入到整数，并提示警告信息：

>>> A = matlabarray(arange(1, 10))
>>> A[5/2: end()]
matlabarray([[ 3,  4,  5,  6,  7,  8,  9, 10]])

>>> A[5/3: end()]
matlabarray([[ 2,  3,  4,  5,  6,  7,  8,  9, 10]])

>>> A[5/2.3: end()]
matlabarray([[ 2,  3,  4,  5,  6,  7,  8,  9, 10]])

支持逻辑矩阵索引：

>>> A = matlabarray([[1, 2, 3],[4,5,6]])
>>> idx = A >= 3
>>> A[idx]
matlabarray([[4, 5, 3, 6]])

>>> A = matlabarray([[1, 2, 3],[4,5,6]])
>>> idx = A >= 10
>>> A[idx]
matlabarray([], shape=(0, 0), dtype=int32)

>>> A = matlabarray([[1, 2, 3],[4,5,6]])
>>> A[A[:,1]>10, :]
matlabarray([], shape=(0, 3), dtype=float64)

支持带步长的 slice(切片) 表达式:

>>> A = matlabarray([[1, 2, 3],[4,5,6]])
>>> A[1:1:2, :]
matlabarray([[1, 2, 3],
       [4, 5, 6]])

>>> A = matlabarray([[1, 2, 3],[4,5,6]])
>>> A[2:-1:1, :]
matlabarray([[4, 5, 6],
       [1, 2, 3]])

支持生成倒排索引：

>>> A = matlabarray([[1, 2, 3],[4,5,6]])
>>> A[end():-1:1, :]
matlabarray([[4, 5, 6],
       [1, 2, 3]])

>>> A = matlabarray([[1, 2, 3],[4,5,6]])
>>> A[:, end():-1:1]
matlabarray([[3, 2, 1],
       [6, 5, 4]])

验证索引访问的正确性： >>> A = matlabarray(arange(1, 60001, 1)) >>> A matlabarray([[ 1, 2, 3, …, 59999, 60000, 60001]]) >>> B = A[13164:-1:13164-100] >>> isequal(arange(13164,13164-101,-1), B) True

compute_shape(indices)¶

用 python索引对象计算 shape

Arguments¶

indices: ndarray: 索引对象，用 compute_index() 计算得到的 python模式索引对象。是展开的下标索引对象，而不包含 slice 对象。

Returns¶

tuple: 像 ndarray.shape 一样的元组对象

Examples¶

>>> a = matlabarray([1,2,3])
>>> indices = a.compute_indices((1, slice(None,None,None), None))
>>> print(indices)
(0, array([0, 1, 2]), 0)

>>> a.compute_shape(indices)
(1, 3, 1)

get(index)¶: 用下标获取本数组的内容

m_delete_(index)¶

实现 matlab 中的’空赋值’功能，用来删除行、列。

matlab 中空赋值只能具有一个非冒号索引。因为这样删除后的矩阵才整齐。

正确： a(1,:)=[] a(:,:)=[] a(1,:,:)=[] 错误： a(1,1)=[] a(1,2,:)=[]

Arguments¶

index: list of index: 索引列表，是 numpy 类型，从 0 开始，一个元素是一个维度的索引。冒号下标[:]用 np.empty(0) 表示。

Returns¶

ndarray 删除后的数组拷贝；或者原来的数组对象 self，如果 indices 中没有空 slice，即索引中没有 ‘:’，如 a[1,:]=[]

Examples¶

删除 bool（逻辑）矩阵索引中为 True 的行、列：

>>> A = matlabarray([[1,2,3],
...                  [4,5,6]])
>>> logic_array = A[:,1]>2
>>> logic_array
matlabarray([[False],
       [ True]])
>>> A[logic_array,:] = matlabarray()
>>> A
matlabarray([[1, 2, 3]])

删除列：

>>> A = matlabarray([[1,2,3],
...                  [4,5,6]])
>>> logic_array = A[1,:]==2
>>> logic_array
matlabarray([[False,  True, False]])
>>> A[:,logic_array] = matlabarray()
>>> A
matlabarray([[1, 3],
       [4, 6]])

支持删除 bool 索引矩阵全为 False 的情况，此时应该不删除任何行、列：

>>> A = matlabarray([[1,2,3],
...                  [4,5,6]])
>>> logic_array = A[:,1]>10
>>> logic_array
matlabarray([[False],
       [False]])
>>> A[logic_array,:] = matlabarray()
>>> A
matlabarray([[1, 2, 3],
       [4, 5, 6]])

删除列：

>>> A = matlabarray([[1,2,3],
...                  [4,5,6]])
>>> logic_array = A[1, :]>10
>>> logic_array
matlabarray([[False, False, False]])
>>> A[logic_array,:] = matlabarray()
>>> A
matlabarray([[1, 2, 3],
       [4, 5, 6]])

删除行： >>> A = copy(matlabarray([1,2,3,4,5,6]).T) >>> idx = find(A<5) >>> A[idx] = matlabarray() >>> A matlabarray([[5],

[6]])

>>> A = matlabarray([[1,2,3],[4,5,6],[7,8,9]])
>>> idx = [1,2]
>>> A[idx] = matlabarray()
>>> A
matlabarray([[7, 2, 5, 8, 3, 6, 9]])

sizeof(ix)¶: size of index @return -1 if index is empty array.

tolist()¶

返回对应的 list 对象，会将多余嵌套去除。

>>> matlabarray([1,2,3]).tolist()
[1, 2, 3]
>>> matlabarray([[1,2,3]]).tolist()
[1, 2, 3]
>>> matlabarray([[1,2], [3,4]]).tolist()
[[1, 2], [3, 4]]

matopy.lib.libmatopy.max(a, b=[], d=0, nargout=0)¶

数组的最大元素

语法¶

M = max(A)

C = max(A,B)

其他语法未实现。

Examples¶

>>> max([1,2,3])
3
>>> max(1, 2)
2

比较 2 个数组:

>>> max([1,2,3], [4,5,1])
matlabarray([[4, 5, 3]])

matopy.lib.libmatopy.min(a, b=[], d=0, nargout=0)¶

数组最小元素

语法¶

M = min(A)

C = min(A,B)

其他语法未实现。

Examples¶

>>> min([1,2,3])
1
>>> min(1, 2)
1

比较 2 个数组:

>>> min([1,2,3], [4,5,1])
matlabarray([[1, 2, 1]])

matopy.lib.libmatopy.mod(a, b)¶

matopy.lib.libmatopy.ndims(a)¶

matopy.lib.libmatopy.normcdf(x)¶

matopy.lib.libmatopy.normpdf(x)¶

matopy.lib.libmatopy.numel(a)¶

matopy.lib.libmatopy.ones(*args, **kwargs)¶

matopy.lib.libmatopy.print_usage()¶

matopy.lib.libmatopy.qr(a)¶

matopy.lib.libmatopy.rand(*args, **kwargs)¶

均匀分布的随机数, 此 MATLAB 函数返回一个在区间 (0,1) 内均匀分布的随机数。 :returns: 在区间 (0,1) 内均匀分布的随机数，float 类型

语法¶

X = rand
X = rand(n)
X = rand(sz1,...,szN)
X = rand(sz)

输入参数
    n - 方阵的大小
        整数值
    sz1,...,szN - 每个维度的大小（作为单独参数）
        整数值
    sz - 每个维度的大小（作为行向量）
        整数值

Examples¶

>>> a=rand()
>>> isinstance(a,float) and 0<= a <=1
True

matopy.lib.libmatopy.randn(*args, **kwargs)¶

matopy.lib.libmatopy.ravel(a)¶

matopy.lib.libmatopy.reshape(A, *args)¶

reshape - 重构数组

此 MATLAB 函数使用大小向量 sz 重构 A 以定义 size(B)。例如，reshape(A,[2,3]) 将 A 重构为一个 2×3 矩阵。sz 必须至少包含 2 个元素，prod(sz) 必须与 numel(A) 相同。

B = reshape(A,sz)
B = reshape(A,sz1,...,szN)

输入参数

A - 输入数组: 向量 | 矩阵 | 多维数组
sz - 输出大小: 由整数组成的行向量
sz1,…,szN - 每个维度的大小: 两个或以上的整数 | []（可选）

输出参数

B - 重构的数组: 向量 | 矩阵 | 多维数组 | 元胞数组

Examples¶

>>> A = arange(1, 10)
>>> B = reshape(A, 2, 5)
>>> B
matlabarray([[ 1,  3,  5,  7,  9],
       [ 2,  4,  6,  8, 10]])

reshape 不会造成 ‘not own data’: >>> B.base is None True

再次 reshape： >>> reshape(B, 5, 2) matlabarray([[ 1, 6],

[ 2, 7], [ 3, 8], [ 4, 9], [ 5, 10]])

支持 sz 行向量参数： >>> A = arange(1, 10) >>> reshape(A, [2, 5]) matlabarray([[ 1, 3, 5, 7, 9],

[ 2, 4, 6, 8, 10]])

可以指定 [] 的单个维度大小，以便自动计算维度大小: >>> A = arange(1, 10) >>> reshape(A, 2, []) matlabarray([[ 1, 3, 5, 7, 9],

[ 2, 4, 6, 8, 10]])

matopy.lib.libmatopy.roots(a)¶

matopy.lib.libmatopy.round(a, decimals=0)¶

实现 matlab 的round()函数，但注意，这里还不是精确的matlab round 函数，不是精确的四舍五入法，而是银行家算法。即取最近的偶数，例如对 0.5, 1.5 取整，那么 0.5=>0，而 1.5=>2。这和 matlab 中的四舍五入是不一样的。这会让取整后的数更平均，更符合统计学要求。

实现 matlab 的四舍五入取整在 round_half_up 函数中。

Parameters¶

a: 要取整的数 decimals: 小数位数

Returns¶

取整后的数

Examples¶

>>> A = matlabarray([0.5, 1.5, -0.5, -1.5])
>>> round(A)
matlabarray([[ 0.,  2., -0., -2.]])

支持 dtype=object 的 matlabarray 参数对象，会转为 float_ 类型。 python的 round 是银行家算法，向最近的偶数对齐：

>>> a = matlabarray(1.2345, dtype=np.object_)
>>> a.shape
(1, 1)
>>> round(a, 3)
1.234

matopy.lib.libmatopy.round_half_up(a)¶

四舍五入取整

Examples¶

>>> round_half_up(0.5)
1
>>> round_half_up(1.5)
2
>>> round_half_up(-0.5)
-1
>>> round_half_up(-1.5)
-2

matopy.lib.libmatopy.rows(a)¶: 返回矩阵a的行数

matopy.lib.libmatopy.schur(a)¶: Compute Schur decomposition of a matrix.

matopy.lib.libmatopy.shared(a)¶

matopy.lib.libmatopy.size(a, dim=0, nargout=1)¶

计算矩阵的尺寸

matlab语法¶

sz = size(A) szdim = size(A,dim) szdim = size(A,dim1,dim2,…,dimN) [sz1,…,szN] = size(___)

Parameters¶

a: 矩阵, 支持的类型有 numpy 的 ndarray、matopy 的 matlabarray 以及 pandas 的 DataFrame b: 维度, dim 从 1 开始，指定要返回的维度，例如 dim=1 返回第一维度的尺寸，dim=2返回第二维度的大小； dim = 0 表示不指定维度。

Returns¶

单个数字：如果指定了 dim 参数。数组：如果 nargout>1且没有指定 dim 参数，数组元素是对应维度的尺寸，第一个元素是第一维度的尺寸、第二元素是第二维度的尺寸，以此类推。

>>> size(zeros(3,3)) + 1
matlabarray([[4, 4]])

>>> size(matlabarray())
matlabarray([[0, 0]])

>>> size(())
0

>>> size(np.asarray([1,2,3]))
3

matopy.lib.libmatopy.size_equal(a, b)¶

matopy.lib.libmatopy.sort(A, dim=None, direction='ascend')¶

对数组元素排序。如果 A 是向量，则 sort(A) 对向量元素进行排序。如果 A 是矩阵，则 sort(A) 会将 A 的列视为向量并对每列进行排序。如果 A 是多维数组，则 sort(A) 会沿大小不等于 1 的第一个数组维度计算，并将这些元素视为向量。

参数:

A – 输入数组
dim – 沿其运算的维度，1 沿列排序，2 沿行排序；None 按第一个大小不为1的维度排序，但如果 A 是矩阵则按列排序。
direction – 排序方向, ‘ascend’ （默认） | ‘descend’ 分别对应升序、降序

返回:

B 排序

语法¶

B = sort(A)
B = sort(A,dim)
B = sort(___,direction)
B = sort(___,Name,Value)
[B,I] = sort(___)

Examples¶

如果 A 是向量，则 sort(A) 对向量元素进行排序。

>>> A = matlabarray([1,3,2])
>>> sort(A)
matlabarray([[1, 2, 3]])

>>> A = matlabarray([1,3,2]).T
>>> sort(A)
matlabarray([[1],
       [2],
       [3]])

指定排序的维度: >>> A = matlabarray([[2,3,1], [1,2,3]]) >>> sort(A, dim=2) matlabarray([[1, 2, 3],

[1, 2, 3]])

>>> sort(A, dim=1)
matlabarray([[1, 2, 1],
       [2, 3, 3]])

对 list 排序： >>> sort([3,1,2]) matlabarray([[1, 2, 3]])

倒序排列: >>> A = matlabarray([[2,3,1], [1,2,3]]) >>> sort(A, dim=2, direction=’descend’) matlabarray([[3, 2, 1],

[3, 2, 1]])

matopy.lib.libmatopy.strcmp(a, b)¶

matopy.lib.libmatopy.strread(s, format='', nargout=1)¶

matopy.lib.libmatopy.strrep(a, b, c)¶

class matopy.lib.libmatopy.struct(*args)¶

基类：object

模拟 matlab 的 struct ’结构体数组‘ 类型。

结构体数组是使用名为字段的数据容器将相关数据组合在一起的数据类型。每个字段都可以包含任意类型的数据。可以使用 structName.fieldName 格式的圆点表示法来访问字段中的数据。

创建对象¶

当您有数据要放入新的结构体中时，可以使用圆点表示法创建结构体，每次为结构体命名一个字段:

s.a = 1;
s.b = ['A','B','C']

语法¶

s = struct
s = struct(field,value)
s = struct(field1,value1,...,fieldN,valueN)
s = struct([])
s = struct(obj)

matopy.lib.libmatopy.sum(a, dim=1)¶

数组元素总和

如果 A 是矩阵，则 sum(A) 将返回包含每列总和的行向量。

>>> sum(matlabarray([[1,2,3],
...                  [4,5,6]]))
matlabarray([5, 7, 9])

>>> sum(matlabarray([1,2,3]))
6

matopy.lib.libmatopy.tic()¶

matopy.lib.libmatopy.toc(t)¶

matopy.lib.libmatopy.toupper(a)¶

matopy.lib.libmatopy.true(*args)¶: 生成全为 true 的矩阵。 :param args: 可以是一个参数 n，也可以是 size1, size2, … 的形式。 :return: 指定大小的矩阵，元素全为 true。

matopy.lib.libmatopy.try_to_scalar(marray)¶: 将单值的 matlabarray 对象变为 scale 数值

matopy.lib.libmatopy.unwrap_list(a_list)¶

删除多余的list嵌套，就是将 [[[1,2]]] 变为 [1,2] >>> unwrap_list([[[1,2,3]]]) [1, 2, 3]

>>> unwrap_list([[1]])
[1]

matopy.lib.libmatopy.vconcat_(*args)¶

垂直合并数组

参数:: args – 要合并的数组
返回:: 合同后的数组

Examples¶

垂直堆叠 arrays： >>> A = matlabarray([[1,2,3],[4,5,6]]) >>> B = matlabarray([7,8,9]) >>> vconcat_(A, B) matlabarray([[1, 2, 3],

[4, 5, 6], [7, 8, 9]])

垂直堆叠不同 shape 的空数组不会报错，会先统一 shape: >>> A = matlabarray().reshape((1, 0)) >>> A.shape (1, 0) >>> B = matlabarray().reshape((0, 0)) >>> B.shape (0, 0) >>> C = vconcat_(A, B) >>> C.shape (1, 0)

matopy.lib.libmatopy.version()¶

matopy.lib.libmatopy.vertcat(*args)¶

垂直合并数组

参数:: args – 要合并的数组
返回:: 合同后的数组

Examples¶

垂直堆叠 arrays： >>> A = matlabarray([[1,2,3],[4,5,6]]) >>> B = matlabarray([7,8,9]) >>> vconcat_(A, B) matlabarray([[1, 2, 3],

[4, 5, 6], [7, 8, 9]])

垂直堆叠不同 shape 的空数组不会报错，会先统一 shape: >>> A = matlabarray().reshape((1, 0)) >>> A.shape (1, 0) >>> B = matlabarray().reshape((0, 0)) >>> B.shape (0, 0) >>> C = vconcat_(A, B) >>> C.shape (1, 0)

matopy.lib.libmatopy.zeros(*args, **kwargs)¶

创建全零数组

返回:: 全零数组或单个数字

matlab 语法¶

X = zeros
X = zeros(n)
X = zeros(sz1,...,szN)
X = zeros(sz)
X = zeros(___,typename)
X = zeros(___,'like',p)

X = zeros(___,typename) 返回一个由零组成并且数据类型为 typename 的数组。例如，zeros(‘int8’) 将返回一个 8 位整数标量 0。您可以使用上述语法中的任何输入参数。

X = zeros(___,’like’,p) 将返回一个与 p 类似的由零值组成的数组，它具有与 p 相同的数据类型（类）、稀疏度和复/实性。您可以指定 typename 或 ‘like’，但不能同时指定二者。

Examples¶

>>> zeros()
0.0

>>> zeros(3)
matlabarray([[0., 0., 0.],
       [0., 0., 0.],
       [0., 0., 0.]])

>>> zeros(3, 2)
matlabarray([[0., 0.],
       [0., 0.],
       [0., 0.]])

>>> zeros((3, 2))
matlabarray([[0., 0.],
       [0., 0.],
       [0., 0.]])

>>> zeros(3, "uint8")
matlabarray([[0, 0, 0],
       [0, 0, 0],
       [0, 0, 0]], dtype=uint8)

>>> z = zeros(3, "uint8")
>>> zeros(3, 'like', z)
matlabarray([[0, 0, 0],
       [0, 0, 0],
       [0, 0, 0]], dtype=uint8)

matopy.lib.libbasic module¶

实现 matlab 语言基础函数

matopy.lib.libbasic.cell2mat(C)¶: 将元胞数组或 pandas 的 DataFrame 对象转换为基础数据类型的普通数组。简单来说就是将多个元胞数组合并为一个大矩阵。

语法¶

A = cell2mat(C)

A = cell2mat(C) 将元胞数组转换为普通数组。元胞数组的元素必须全都包括相同的数据类型，并且生成的数组也是该数据类型。

C 的内容必须支持串联到 N 维矩形中。否则，结果将不确定。例如，同一列中的元胞的内容必须具有相同的列数，但不需要具有相同的行数（见图）。

Arguments¶

C: 要转换的元胞数组对象

Returns¶

基础数据类型的普通数组

matopy.lib.libbasic.cumsum(A, *args)¶

cumsum - 累积和此 MATLAB 函数从 A 中的第一个其大小不等于 1 的数组维度开始返回 A 的累积和。如果 A 是向量，则 cumsum(A) 返回包含 A 元素累积和的向量。如果 A 是矩阵，则 cumsum(A) 返回包含 A 每列的累积和的矩阵。如果 A 为多维数组，则 cumsum(A) 沿第一个非单一维运算。

B = cumsum(A) B = cumsum(A,dim) B = cumsum(___,direction) B = cumsum(___,nanflag)

输入参数

A - 输入数组: 向量 | 矩阵 | 多维数组
dim - 沿其运算的维度: 正整数标量
direction - 累积方向: ‘forward’ (默认值) | ‘reverse’
nanflag - NaN 条件: ‘includenan’ (默认值) | ‘omitnan’

输出参数

B - 累积和数组: 向量 | 矩阵 | 多维数组

Examples¶

>>> A = arange(1, 5)
>>> cumsum(A)
matlabarray([[ 1,  3,  6, 10, 15]])

>>> A = arange(1, 5).T
>>> cumsum(A)
matlabarray([[ 1],
       [ 3],
       [ 6],
       [10],
       [15]])

>>> A = matlabarray([[1, 4, 7], [2, 5, 8], [3, 6, 9]])
>>> cumsum(A)
matlabarray([[ 1,  4,  7],
       [ 3,  9, 15],
       [ 6, 15, 24]])

matopy.lib.libbasic.fliplr(A)¶

将数组从左向右翻转

语法¶

B = fliplr(A) 返回 A，围绕垂直轴按左右方向翻转其各列。

如果 A 是一个行向量，则 fliplr(A) 返回一个相同长度的向量，其元素的顺序颠倒。如果 A 是一个列向量，则 fliplr(A) 只返回 A。对于多维数组，fliplr 作用于由第一个和第二个维度构成的平面。

return:: 返回 A，围绕垂直轴按左右方向翻转其各列。

Examples¶

>>> A = matlabarray(arange(1,10))
>>> A
matlabarray([[ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10]])
>>> fliplr(A)
matlabarray([[10,  9,  8,  7,  6,  5,  4,  3,  2,  1]])

>>> A = matlabarray(arange(1,10)).T
>>> A
matlabarray([[ 1],
       [ 2],
       [ 3],
       [ 4],
       [ 5],
       [ 6],
       [ 7],
       [ 8],
       [ 9],
       [10]])
>>> fliplr(A)
matlabarray([[ 1],
       [ 2],
       [ 3],
       [ 4],
       [ 5],
       [ 6],
       [ 7],
       [ 8],
       [ 9],
       [10]])

>>> A = matlabarray([[1,2], [3,4]])
>>> fliplr(A)
matlabarray([[2, 1],
       [4, 3]])

matopy.lib.libbasic.flipud(A)¶

将数组从上向下翻转

此 MATLAB 函数返回 A，围绕水平轴按上下方向翻转其各行。

B = flipud(A)

输入参数

A - 输入数组: 向量 | 矩阵 | 多维数组 | 表 | 时间表

Examples¶

>>> A = arange(1, 10).T
>>> flipud(A)
matlabarray([[10],
       [ 9],
       [ 8],
       [ 7],
       [ 6],
       [ 5],
       [ 4],
       [ 3],
       [ 2],
       [ 1]])

>>> A = cellarray([['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']])
>>> flipud(A)
cellarray([['g', 'h', 'i'],
       ['d', 'e', 'f'],
       ['a', 'b', 'c']], dtype=object)

matopy.lib.libbasic.hex2dec(hexStr)¶

将十六进制整数的文本表示转换为双精度值 :param hexStr: 要转换的十六进制数字符串 :return: float 类型的数字，双精度浮点数

Examples¶

>>> hex2dec("3FF")
1023

matopy.lib.libbasic.imag(Z)¶

取复数的虚部

语法¶

X = imag(Z)

说明¶

X = imag(Z) 返回数组 Z 中每个元素的虚部。

Examples¶

复数的虚部: >>> Z = 2+3j; >>> imag(Z) 3.0

复数值向量的虚部: >>> Z = matlabarray([0.5j, 1+3j, -2.2]) >>> imag(Z) matlabarray([[0.5, 3. , 0. ]])

>>> Z = matlabarray([[0.5j, 1+3j, -2.2],
...                  [0.5j, 1+3j, -2.2]])
>>> imag(Z)
matlabarray([[0.5, 3. , 0. ],
       [0.5, 3. , 0. ]])

返回的向量方向同参数向量： >>> Z = matlabarray([0.5j, 1+3j, -2.2]).T >>> imag(Z).shape (3, 1)

matopy.lib.libbasic.linspace(x1, x2, n=100)¶

生成线性间距向量

语法¶

y = linspace(x1,x2)

y = linspace(x1,x2,n)

说明¶

y = linspace(x1,x2) 返回包含 x1 和 x2 之间的 100 个等间距点的行向量。

y = linspace(x1,x2,n) 生成 n 个点。这些点的间距为 (x2-x1)/(n-1)。

linspace 类似于冒号运算符“:”，但可以直接控制点数并始终包括端点。“linspace”名称中的“lin”指示生成线性间距值而不是同级函数 logspace，后者会生成对数间距值。

Examples¶

等间距数字向量: 创建一个由区间 [-5,5] 中的 100 个等间距点组成的向量。

>>> lin = linspace(-5,5)
>>> lin.shape
(100,)
>>> lin
matlabarray([-5.        , -4.8989899 , -4.7979798 , -4.6969697 , -4.5959596 ,
       -4.49494949, -4.39393939, -4.29292929, -4.19191919, -4.09090909,
       -3.98989899, -3.88888889, -3.78787879, -3.68686869, -3.58585859,
       -3.48484848, -3.38383838, -3.28282828, -3.18181818, -3.08080808,
       -2.97979798, -2.87878788, -2.77777778, -2.67676768, -2.57575758,
       -2.47474747, -2.37373737, -2.27272727, -2.17171717, -2.07070707,
       -1.96969697, -1.86868687, -1.76767677, -1.66666667, -1.56565657,
       -1.46464646, -1.36363636, -1.26262626, -1.16161616, -1.06060606,
       -0.95959596, -0.85858586, -0.75757576, -0.65656566, -0.55555556,
       -0.45454545, -0.35353535, -0.25252525, -0.15151515, -0.05050505,
        0.05050505,  0.15151515,  0.25252525,  0.35353535,  0.45454545,
        0.55555556,  0.65656566,  0.75757576,  0.85858586,  0.95959596,
        1.06060606,  1.16161616,  1.26262626,  1.36363636,  1.46464646,
        1.56565657,  1.66666667,  1.76767677,  1.86868687,  1.96969697,
        2.07070707,  2.17171717,  2.27272727,  2.37373737,  2.47474747,
        2.57575758,  2.67676768,  2.77777778,  2.87878788,  2.97979798,
        3.08080808,  3.18181818,  3.28282828,  3.38383838,  3.48484848,
        3.58585859,  3.68686869,  3.78787879,  3.88888889,  3.98989899,
        4.09090909,  4.19191919,  4.29292929,  4.39393939,  4.49494949,
        4.5959596 ,  4.6969697 ,  4.7979798 ,  4.8989899 ,  5.        ])

由均匀分布的复数组成的向量:

>>> linspace(1+2j, 10+10j, 8)
matlabarray([ 1.         +2.j        ,  2.28571429 +3.14285714j,
        3.57142857 +4.28571429j,  4.85714286 +5.42857143j,
        6.14285714 +6.57142857j,  7.42857143 +7.71428571j,
        8.71428571 +8.85714286j, 10.        +10.j        ])

matopy.lib.libbasic.magic(n)¶

magic - 幻方矩阵此 MATLAB 函数返回由 1 到 n2 的整数构成并且总行数和总列数相等的 n×n 矩阵。n 的阶数必须是大于或等于 3 的标量才能创建有效的幻方矩阵。

M = magic(n)

输入参数

n - 矩阵的阶次: 整数标量 magic - 幻方矩阵

此 MATLAB 函数返回由 1 到 n2 的整数构成并且总行数和总列数相等的 n×n 矩阵。n 的阶数必须是大于或等于 3 的标量才能创建有效的幻方矩阵。

M = magic(n)

输入参数

n - 矩阵的阶次: 整数标量

Examples¶

>>> A=magic(6)
>>> A
matlabarray([[35,  1,  6, 26, 19, 24],
       [ 3, 32,  7, 21, 23, 25],
       [31,  9,  2, 22, 27, 20],
       [ 8, 28, 33, 17, 10, 15],
       [30,  5, 34, 12, 14, 16],
       [ 4, 36, 29, 13, 18, 11]])

>>> sum(A, 1)
matlabarray([111, 111, 111, 111, 111, 111])

>>> sum(A, 2)
matlabarray([111, 111, 111, 111, 111, 111])

matopy.lib.libbasic.msgbox(msg)¶

创建消息对话框，python版本只是简单输出到 stdout，类似 print 函数。

参数:: msg –
返回:

matopy.lib.libbasic.mtimes(A, B)¶

矩阵乘法，也是 matlab 中的 * 运算符对应的函数。

语法¶

C = mtimes(A,B)

说明¶

C = A*B 是 A 和 B 的矩阵乘积。如果 A 是 m×p 矩阵，B 是 p×n 矩阵，则 C 是 m×n 矩阵.

A,B 可以为标量.

对于非标量 A 和 B，A 的列数必须等于 B 的行数。对于非标量输入，矩阵乘法不一定能互换位置。也就是说，A*B 不一定等于 B*A。至少一方输入为标量时，A*B 等于 A.*B，这时可以互换位置。

扩展：会自动将 shape为 (N,) 的一维向量变为二维矩阵 (N,1)，然后再进行乘法运算。

Examples¶

标量乘法：

>>> mtimes(1, 2)
2

标量乘向量：

>>> mtimes(2, matlabarray([1,2,3]))
matlabarray([[2, 4, 6]])

>>> mtimes(2, matlabarray([1,2,3]).flatten())
matlabarray([[2, 4, 6]])

向量乘法：

>>> A = matlabarray([1, 1, 0, 0])
>>> B = matlabarray([1, 2, 3, 4]).transpose()
>>> mtimes(A, B)
3

矩阵乘法：

>>> A = matlabarray([1, 1, 0, 0])
>>> B = matlabarray([1, 2, 3, 4]).transpose()
>>> mtimes(B, A)
matlabarray([[1, 1, 0, 0],
       [2, 2, 0, 0],
       [3, 3, 0, 0],
       [4, 4, 0, 0]])

自动将 shape为 (N,) 的一维向量变为二维矩阵 (N,1):

>>> A = matlabarray([1, 1, 0, 0]).flatten()
>>> B = matlabarray([1, 2, 3, 4]).transpose()
>>> mtimes(B, A)
matlabarray([[1, 1, 0, 0],
       [2, 2, 0, 0],
       [3, 3, 0, 0],
       [4, 4, 0, 0]])

支持 1x1 的 matlabarray 做为参数: >>> A = matlabarray(3) >>> B = matlabarray([[1,2],[3,4]]) >>> mtimes(A, B) matlabarray([[ 3., 6.],

[ 9., 12.]])

matopy.lib.libbasic.norm(X, p=2, frob=<no value>)¶

向量范数和矩阵范数

语法¶

n = norm(v)

n = norm(v,p)

n = norm(X)

n = norm(X,p)

n = norm(X,’fro’)

说明¶

n = norm(v) 返回向量 v 的欧几里德范数。此范数也称为 2-范数、向量模或欧几里德长度。

n = norm(v,p) 返回广义向量 p-范数。

n = norm(X) 返回矩阵 X 的 2-范数或最大奇异值，该值近似于 max(svd(X))。

n = norm(X,p) 返回矩阵 X 的 p-范数，其中 p 为 1、2 或 Inf：

如果 p = 1，则 n 是矩阵的最大绝对列之和。

如果 p = 2，则 n 近似于 max(svd(X))。这与 norm(X) 等效。

如果 p = Inf，则 n 是矩阵的最大绝对行之和。

n = norm(X,’fro’) 返回矩阵 X 的 Frobenius 范数。【未实现】

Examples¶

>>> v = matlabarray([1, -2, 3])
>>> norm(v)
3.7416573867739413

>>> v = matlabarray([1, -2, 3])
>>> norm(v, 2)
3.7416573867739413

>>> v = matlabarray([1, -2, 3])
>>> norm(v, 1)
6

计算矩阵的 2-范数，该范数为最大奇异值。

>>> X = matlabarray([[2, 0, 1],
...                  [-1, 1, 0],
...                  [-3, 3, 0]]);
>>> norm(X)
5.0

计算矩阵的 1-范数，该范数为最绝对列之和。

>>> X = matlabarray([[2, 0, 1],
...                  [-1, 1, 0],
...                  [-3, 3, 0]]);
>>> norm(X, 1)
6

matopy.lib.libbasic.prod(A, *args)¶

数组元素的乘积，按列将元素相乘，得到一个数。例如：prod([1,2,3]) = 1x2x3 = 6

参数:

A – 输入数组。
'all' – 计算 A 的所有元素的乘积。
dim – 沿其运算的维度。正整数标量。使用 matlab 约定，从 1 开始。沿其运算的维度，指定为正整数标量。如果未指定值，则默认值是大小不等于 1 的第一个数组维度。维度 dim 表示长度减至 1 的维度。size(B,dim) 为 1，而所有其他维度的大小保持不变。以一个二维输入数组 A 为例。如果 dim = 1，则 prod(A,1) 返回包含每一列中元素的乘积的行向量。如果 dim = 2，则 prod(A,2) 返回包含每一行中元素的乘积的列向量。

返回:

乘积数组

Matlab 语法¶

B = prod(A)
B = prod(A,'all')
B = prod(A,dim)
B = prod(A,vecdim)
B = prod(___,outtype)
B = prod(___,nanflag)

说明¶

B = prod(A) 返回 A 的数组元素的乘积。

如果 A 是向量，则 prod(A) 返回元素的乘积。

如果 A 为非空矩阵，则 prod(A) 将 A 的各列视为向量，并返回一个包含每列乘积的行向量。

如果 A 为 0×0 空矩阵，prod(A) 返回 1。

如果 A 为多维数组，则 prod(A) 沿第一个非单一维度运算并返回乘积数组。此维度的大小将减少至 1，而所有其他维度的大小保持不变。

如果输入 A 为 single 类型，则 prod 会计算并将 B 以 single 类型返回。如果为任何其他数值和逻辑数据类型，prod 会计算并将 B 以 double 类型返回。

Examples¶

如果 A 是向量，则 prod(A) 返回元素的乘积: >>> A = matlabarray([4,5,6]) >>> prod(A) 120

>>> A = matlabarray([4,5,6]).T
>>> prod(A)
120

如果 A 为非空矩阵，则 prod(A) 将 A 的各列视为向量，并返回一个包含每列乘积的行向量:

>>> A = matlabarray([[1,2,3],[4,5,6]])
>>> prod(A)
matlabarray([[ 4, 10, 18]])

>>> prod(matlabarray([]))
1.0

支持 ‘all’ 参数： >>> A = matlabarray([[1,2,3],[4,5,6]]) >>> prod(A, ‘all’) 720

支持 dim 参数： >>> A = matlabarray([[1,2,3],[4,5,6]]) >>> prod(A, 2) matlabarray([[ 6, 120]])

matopy.lib.libbasic.real(Z)¶

取复数的实部

语法¶

X = real(Z)

说明¶

X = real(Z) 返回数组 Z 中每个元素的实部。

Examples¶

复数的实部: >>> Z = 2+3j; >>> real(Z) 2.0

复数值向量的实部: >>> Z = matlabarray([0.5j, 1+3j, -2.2]) >>> real(Z) matlabarray([[ 0. , 1. , -2.2]])

>>> Z = matlabarray([[0.5j, 1+3j, -2.2],
...                  [0.5j, 1+3j, -2.2]])
>>> real(Z)
matlabarray([[ 0. ,  1. , -2.2],
       [ 0. ,  1. , -2.2]])

返回的向量方向同参数向量： >>> Z = matlabarray([0.5j, 1+3j, -2.2]).T >>> real(Z).shape (3, 1)

matopy.lib.libbasic.reshape_vector_as(A, B)¶

将 A 向量转换为 B 向量的方向，返回转换后的向量矩阵。

>>> A=reshape_vector_as(matlabarray([1,2,3]), matlabarray([7,8]))
>>> A.shape
(1, 3)
>>> A=reshape_vector_as(matlabarray([1,2,3]), matlabarray([7,8]).transpose())
>>> A.shape
(3, 1)

matopy.lib.libbasic.sqrt(X)¶

平方根

语法¶

B = sqrt(X)

说明¶

B = sqrt(X) 返回数组 X 的每个元素的平方根。对于 X 的负元素或复数元素，sqrt(X) 生成复数结果。

sqrt 函数的域包含负数和复数，如果使用不当，可能会导致意外结果。对于负的复数 z = u + i*w，复数方根 sqrt(z) 返回

sqrt(r)*(cos(phi/2) + 1i*sin(phi/2))

其中 r = abs(z) 是半径，phi = angle(z) 是在闭区间 -pi <= phi <= pi 内的相位角。

如果想要负数和复数返回错误消息而不是返回复数结果，改用 realsqrt。

Examples¶

向量元素的平方根:

>>> X = arange(-2,2)
>>> X
matlabarray([[-2, -1,  0,  1,  2]])

>>> sqrt(X)     
matlabarray([[0. +1.41421356j, 0. +1.j ,
        0. +0.j , 1. +0.j ,
        1.41421356+0.j ]])

matopy.lib.libbasic.times(A, B)¶

.*乘法，元素乘法

C = times(A,B)

C = A.*B 通过将对应的元素相乘来将数组 A 和 B 相乘。A 和 B 的大小必须相同或兼容。

如果 A 和 B 的大小兼容，则这两个数组会隐式扩展以相互匹配。例如，如果 A 或 B 中的一个是标量，则该标量与另一个数组的每个元素相结合。此外，具有不同方向的向量（一个为行向量，另一个为列向量）会隐式扩展以形成矩阵。

Examples¶

>>> times([1,2,3], [2,3,2])
matlabarray([[2, 6, 6]])

>>> times(2, [2,3,2])
matlabarray([[4, 6, 4]])

>>> times(matlabarray([2,3,2]), matlabarray(2))
matlabarray([[4, 6, 4]])

>>> times(matlabarray([1, 2]), matlabarray([1, 2]).transpose())
matlabarray([[1, 2],
       [2, 4]])

matopy.lib.libbasic.to_row_or_column_vector(A)¶: 尝试将 A 变为2维的行、列向量矩阵

matopy.lib.libbasic.try_1d_to_row_vector(A)¶

尝试将一维数组转换为2维行向量矩阵，如果A不是一维数组，那么不做改变返回 A 本身。

Examples¶

>>> A = np.array([1,2,3])
>>> A.shape
(3,)
>>> B = try_1d_to_row_vector(A)
>>> B.shape
(1, 3)

matopy.lib.libbasic.try_to_column_vector(A)¶

尝试将 A 转换为列向量。如果 A 不是 1维数组，则返回原始 A.

参数:: A – 1维数组
返回:: 列向量, nx1 形式

Examples¶

>>> A = [1,2,3]
>>> try_to_column_vector(A)
matlabarray([[1],
       [2],
       [3]])

>>> A = matlabarray([1,2,3])
>>> try_to_column_vector(A)
matlabarray([[1],
       [2],
       [3]])

>>> A = matlabarray()
>>> try_to_column_vector(A)
matlabarray([], shape=(0, 0), dtype=float64)

matopy.lib.libstring module¶

matopy.lib.libstring.contains(str, pat, *args)¶

确定字符串中是否有模式

此 MATLAB 函数将返回 1 (true)，否则返回 0 (false)。

TF = contains(str,pat) TF = contains(str,pat,’IgnoreCase’,true)

输入参数

str - 输入文本: 字符串数组 | 字符向量 | 字符向量元胞数组
pat - 搜索模式: 字符串数组 | 字符向量 | 字符向量元胞数组 | pattern 数组（自 R2020b 开始提供）

Examples¶

>>> contains(["Mary Ann Jones","Paul Jay Burns","John Paul Smith"], "Paul")
matlabarray([[0, 1, 1]])

>>> contains("Paul Jay Burns", "Paul")
1

>>> contains(matlabarray(["Paul Jay Burns", "Mary Ann Jones"]), "Paul")
matlabarray([[1, 0]])

matopy.lib.libstring.str2num(S, nargout=1)¶

将字符数组或字符串转换为数值数组

语法¶

X = str2num(chr) [X,tf] = str2num(chr)

说明¶

X = str2num(chr) 将字符数组或字符串标量转换为数值矩阵。输入可以包含空格、逗号和分号，以指示单独的元素。如果 str2num 不能将输入解析为数值，则返回空矩阵。 str2num 函数不转换元胞数组或非标量字符串数组，并且对 + 和 - 运算符前后的空格敏感。

示例¶

>>> str2num('100')
100.0

>>> str2num('100 200 300 400')
matlabarray([[100., 200., 300., 400.]])

>>> str2num('100, 200, 300, 400')
matlabarray([[100., 200., 300., 400.]])

>>> str2num('100;200; 300; 400')
matlabarray([[100., 200., 300., 400.]])

matopy.lib.libstring.strcat(*args)¶

matlab函数，水平串联字符串

语法¶

s = strcat(s1,…,sN)

说明¶

s = strcat(s1,…,sN) 水平串联其输入参数中的文本。

每个输入参数都可以是字符数组、字符向量元胞数组或字符串数组。

如果任一输入是字符串数组，则结果是字符串数组。

如果任一输入是元胞数组，并且没有输入是字符串数组，则结果是字符向量元胞数组。

如果所有输入都是字符数组，则结果是字符数组。

对于字符数组输入，strcat 会删除尾部的 ASCII 空白字符：空格、制表符、垂直制表符、换行符、回车和换页符。

对于元胞数组和字符串数组输入，strcat 不删除尾部空白。

Examples¶

串联多个字符向量:

>>> strcat('abc', 'def')
'abcdef'

>>> strcat('中', '国', '贵州')
'中国贵州'

串联两个元胞数组:

>>> s1 = matlabarray(['abcde','你'])
>>> s2 = matlabarray(['jkl','好'])
>>> strcat(s1,s2)
matlabarray([['abcdejkl', '你好']], dtype='<U8')

将两个元胞数组与标量元胞数组串联:

>>> firstnames = matlabarray([['Abraham'], ['George']])
>>> lastnames = matlabarray([['Lincoln'], ['Washington']])
>>> strcat(lastnames, firstnames)
matlabarray([['LincolnAbraham'],
       ['WashingtonGeorge']], dtype='<U17')

将`字符数组(chararray)`和`str`相拼接：

>>> strcat(chararray('2023'), '年', chararray('11'), '月')
'2023年11月'

matopy.lib.libstring.strcmpi(s1, s2)¶

比较字符串（不区分大小写）

语法¶

tf = strcmpi(s1,s2)

说明¶

tf = strcmpi(s1,s2) 将比较 s1 和 s2，并忽略字母大小写差异。如果二者相同，函数将返回 1 (true)，否则返回 0 (false)。

如果文本的大小和内容相同，则它们将视为相等，不考虑大小写。返回结果 tf 的数据类型为 logical。

输入参数可以是字符串数组、字符向量和字符向量元胞数组的任何组合。

Examples¶

比较两个字符向量并忽略大小写

>>> s1 = 'Yes'
>>> s2 = 'No'
>>> strcmpi(s1,s2)
0
>>> s1 = 'Yes'
>>> s2 = 'yes'
>>> strcmpi(s1,s2)
1

查找元胞数组中不区分大小写的匹配项

>>> s1 = 'once'
>>> s2 = matlabarray([['Once','upon'],
...  ['a','time']])
>>> strcmpi(s1,s2)
matlabarray([[1, 0],
       [0, 0]])

>>> s2 = matlabarray([['Once','upon'],
...  ['a','once']])
>>> strcmpi(s1,s2)
matlabarray([[1, 0],
       [0, 1]])

比较元胞数组并忽略大小写, 比较字符串数组并忽略大小写

>>> s1 = matlabarray([['Tinker', 'Tailor'],
... ['  Soldier', 'Spy']])
>>> s2 = matlabarray([['Tinker', 'Baker'],
... ['Soldier', 'SPY']])
>>> strcmpi(s1,s2)
matlabarray([[1, 0],
       [0, 1]])

比较字符: >>> strcmpi(‘X’, ‘x’) 1 >>> strcmpi(b’X’, ‘x’) 1

比较 cellarray： >>> c = cellarray([[‘ABC’, ‘Def’], [‘GHI’, ‘JM’]]) >>> strcmpi(c, ‘ghI’) matlabarray([[0, 0],

[1, 0]])

matopy.lib.libstring.strfind(s, pat)¶

在其他字符串中查找字符串

语法¶

k = strfind(s,pat)

k = strfind(s,pat,’ForceCellOutput’,cellOutput) 【未实现】

说明¶

k = strfind(s,pat) 在 str 中搜索出现的 pat。输出 k 指示 str 中每次出现的 pat 的起始索引。

如果未找到 pat，则 strfind 返回一个空数组 []。strfind 函数执行区分大小写的搜索。

如果 str 是字符向量或字符串标量，则 strfind 返回 double 类型的向量。

如果 str 是字符向量元胞数组或字符串数组，则 strfind 返回 double 类型的向量元胞数组。【未实现】

Parameters¶

str: unicode string or chararray

unicode string: 返回所有匹配的下标，从 1 开始 chararray : 会转换为 string 进行查找

Examples¶

在字符向量中查找子字符串

>>> s = 'Find the starting indices of substrings in a character vector'
>>> strfind(s,'in')
matlabarray([[ 2, 15, 19, 36, 41]])

>>> s = chararray('Find the starting indices of substrings in a character vector')
>>> strfind(s,'in')
matlabarray([[ 2, 15, 19, 36, 41]])

>>> strfind(s,'In')
matlabarray([], shape=(0, 0), dtype=int32)

>>> strfind(s,' ')    
matlabarray([[ 5,  9, 18, 26, 29, 40, 43, 45, 55]])

matopy.lib.libstring.string(A)¶

转换为字符串或字符串数组。

参数:: A – 要转换的字符数组、其他类型数组。
返回:: 字符串或字符串数组。如果 A 是一维行向量 (即1xn) 的 ’字符数组‘ 那么输出就是一个字符串对象。

Examples¶

>>> c = chararray('abc')
>>> string(c)
'abc'

对头尾有的字符： >>> b = b’abc’ + bytes(2) >>> len(b) 5 >>> b b’abcx00x00’ >>> c = chararray(b.decode(‘ISO8859-1’)) >>> string(c) ‘abc’

matopy.lib.libstring.strip(str_, side='both', stripCharacter=' ')¶

删除字符串中的前导和尾部字符

参数:

str (字符串数组 | 字符向量 | 字符向量元胞数组) – 输入文本
side – 要去除字符的字符串侧. ‘left’ | ‘right’ | ‘both’ (默认值)
stripCharacter – 要从输入文本中去除的字符，必须和 str 是同一种类型，例如都是 str 或都是 bytes。

返回:

输出文本

Examples¶

>>> s = "  abc  "
>>> strip(s)
'abc'

matopy.lib.ismember module¶

判断数组元素是否为集数组成员

语法¶

Lia = ismember(A,B) Lia = ismember(A,B,’rows’) [Lia,Locb] = ismember(___) [Lia,Locb] = ismember(___,’legacy’)

说明¶

Lia = ismember(A,B) 如果 A 中某位置的数据能在 B 中找到，Lia = ismember(A,B) 将返回一个在该位置包含逻辑值 1 (true) 的数组。数组中的其他位置将包含逻辑值 0 (false)。【未实现：如果 A 和 B 是表或时间表，ismember 将为每一行返回一个逻辑值。对于时间表，ismember 在确定相等性时会考虑行时间。输出 Lia 是一个列向量。】

示例¶

>>> A = matlabarray([5, 3, 4, 2])
>>> B = matlabarray([2, 4, 4, 4, 6, 8])
>>> ismember(A,B)
matlabarray([[0, 0, 1, 1]])

matopy.lib.diff module¶

matopy.lib.diff.diff(X, n=1, dim=1)¶

实现 matlab 的 diff(X) 函数，如果 X 是矩阵，会沿行求差分而不是沿列。

用法: Y = diff(X) Y = diff(X,n) Y = diff(X,n,dim)

参数： X - matlabarray 数组或矩阵 n - int，可选，求导次数 dim - int, 正整数标量，沿 dim 指定的维计算，和 matlab 中一样从 1 开始，1表示行维度，2表示列维度。

返回: matlabarray 结果对象

Examples¶

>>> a = matlabarray([[1,3,6]])
>>> d = diff(a)
>>> print(d)
[[2 3]]

>>> a = matlabarray([[1,3,6], [2,4,7]])
>>> d = diff(a,1)
>>> print(d)
[[1 1 1]]

>>> a = matlabarray([[1,3,6], [2,4,7]])
>>> d = diff(a, 1, dim=2)
>>> print(d)
[[2 3]
 [2 3]]

matlab¶

diff 差分和近似导数

语法: Y = diff(X) Y = diff(X,n) Y = diff(X,n,dim)

Y = diff(X) 计算沿大小不等于 1 的第一个数组维度的 X 相邻元素之间的差分：

如果 X 是长度为 m 的向量，则 Y = diff(X) 返回长度为 m-1 的向量。Y 的元素是 X 相邻元素之间的差分。: Y = [X(2)-X(1) X(3)-X(2) … X(m)-X(m-1)]
如果 X 是不为空的非向量 p×m 矩阵，则 Y = diff(X) 返回大小为 (p-1)×m 的矩阵，其元素是 X 的行之间的差分。: Y = [X(2,:)-X(1,:); X(3,:)-X(2,:); … X(p,:)-X(p-1,:)]

如果 X 是 0×0 的空矩阵，则 Y = diff(X) 返回 0×0 的空矩阵。

matlab 版本：在 R2006a 之前推出

python 实现¶

用 numpy.diff() 实现。

注意：matlab 中默认是沿‘row’求差分，而 numpy 是沿最后一个维度求差分，所以需要修正这一点。

matopy.lib.libdsp module¶

matopy.lib.libdsp.fft(X)¶

快速傅里叶变换

参数:

X – 要计算的数据矩阵, array_like
n – 要计算的 X 中的点数
dim – 按照 X 中的指定维度 dim 计算 fft。

语法¶

Y = fft(X)

Y = fft(X,n)

Y = fft(X,n,dim)

说明¶

Y = fft(X) 用快速傅里叶变换 (FFT) 算法计算 X 的离散傅里叶变换 (DFT)。

如果 X 是向量，则 fft(X) 返回该向量的傅里叶变换。返回的向量，方向与 X 一致，即 X 是行向量就返回行向量，是列向量就返回列向量。

如果 X 是矩阵，则 fft(X) 将 X 的各列视为向量，并返回每列的傅里叶变换。

如果 X 是一个多维数组，则 fft(X) 将沿大小不等于 1 的第一个数组维度的值视为向量，并返回每个向量的傅里叶变换。

Examples¶

>>> Fs = 1000                       # Sampling frequency
>>> T = 1/Fs                        # Sampling period
>>> L = 1500                        # Length of signal
>>> t = np.arange(0, L) * T         # Time vector
>>> S = 0.7*np.sin(2*np.pi*50*t) + np.sin(2*np.pi*120*t)
>>> Y = fft(S)
>>> Y.shape
(1, 1500)
>>> Yr = np.real(Y)
>>> Yr[181]
-4.0009795820042397e-11
>>> Yr[1321]
-4.005929922419812e-11
>>> Yi = np.imag(Y)

>>> Yi[76]
-524.9999999999995
>>> Yi[181]
-749.9999999999999
>>> Yi[1321]
749.9999999999998
>>> Yi[1426]
524.9999999999998

返回的向量，方向与 X 一致，即 X 是行向量就返回行向量，是列向量就返回列向量: >>> fft(matlabarray([1,2,3,4,5])).shape (1, 5) >>> fft(matlabarray([1,2,3,4,5]).transpose()).shape (5, 1)

matopy.lib.libdsp.hilbert(xr, n=None)¶

Discrete-time analytic signal using Hilbert transform.

参数:

xr (vector | matrix) – Input signal.
n – DFT length

返回:

Analytic signal, returned as a vector or matrix.

Matlab语法¶

x = hilbert(xr) x = hilbert(xr,n)

x = hilbert(xr) returns the analytic signal, x, from a real data sequence, xr. If xr is a matrix, then hilbert finds the analytic signal corresponding to each column.

x = hilbert(xr,n) uses an n-point fast Fourier transform (FFT) to compute the Hilbert transform. The input data is zero-padded or truncated to length n, as appropriate.

Examples¶

>>> _xr = matlabarray([1, 2, 3, 4])
>>> hilbert(_xr)
matlabarray([[1.+1.j, 2.-1.j, 3.-1.j, 4.+1.j]])

>>> _xr = matlabarray([[0.1, 0.2, 0.3, 0.2, 0.1]]).T
>>> hilbert(_xr)
matlabarray([[0.1-4.70228202e-02j],
       [0.2-1.08576491e-01j],
       [0.3+1.11022302e-17j],
       [0.2+1.08576491e-01j],
       [0.1+4.70228202e-02j]])

matopy.lib.libdsp.ifft(X)¶

快速傅里叶逆变换

语法¶

X = ifft(Y)

X = ifft(Y,n)

X = ifft(Y,n,dim)

X = ifft(___,symflag)

说明¶

X = ifft(Y) 使用快速傅里叶变换算法计算 Y 的逆离散傅里叶变换。X 与 Y 的大小相同。

如果 Y 是向量，则 ifft(Y) 返回该向量的逆变换，返回行向量。

如果 Y 是矩阵，则 ifft(Y) 返回该矩阵每一列的逆变换。

如果 Y 是多维数组，则 ifft(Y) 将大小不等于 1 的第一个维度上的值视为向量，并返回每个向量的逆变换。

Returns¶

matlabarray, 离散傅里叶逆变换的结果。

Examples¶

向量的逆变换:

>>> A = matlabarray([1, 2, 3, 4, 5])
>>> Y = fft(A)
>>> ifft(Y)
matlabarray([[1.+0.j, 2.+0.j, 3.+0.j, 4.+0.j, 5.+0.j]])

返回的向量，方向与 X 一致，即 X 是行向量就返回行向量，是列向量就返回列向量: >>> ifft(matlabarray([1,2,3,4,5])).shape (1, 5) >>> ifft(matlabarray([1,2,3,4,5]).transpose()).shape (5, 1)

matopy.lib.libplot module¶

matopy.lib.libplot.figure(*args, **kwargs)¶

matopy.lib.libplot.hold(*args, **kwargs)¶

matopy.lib.libplot.legend(*args, **kwargs)¶

matopy.lib.libplot.plot(*args, **kwargs)¶

matopy.lib.libplot.subplot(*args, **kwargs)¶

matopy.lib.libplot.title(*args, **kwargs)¶

matopy.lib.libplot.xlim(*args, **kwargs)¶

matopy.lib.libstat module¶

实现 matlab 统计相关函数

matopy.lib.libstat.corrcoef(A, B=<no value>, nargout=1)¶: 相关系数

语法¶

R = corrcoef(A)

R = corrcoef(A,B)

[R,P] = corrcoef(___) 【未实现】

[R,P,RL,RU] = corrcoef(___) 【未实现】

___ = corrcoef(___,Name,Value) 【未实现】

说明¶

R = corrcoef(A) 返回 A 的相关系数的矩阵，其中 A 的列表示随机变量，行表示观测值。

R = corrcoef(A,B) 返回两个随机变量 A 和 B 之间的系数。如果 A 和 B 是矩阵或多维数组，则 corrcoef(A,B) 将每个输入转换为其向量表示形式，等效于 corrcoef(A(:),B(:)) 或 corrcoef([A(:) B(:)])。

Examples¶

两个随机变量的相关系数: >>> A = matlabarray([[-0.21381234], … [-0.82984046], … [-0.94919337], … [ 0.97231459], … [-0.74512405]]) >>> B = matlabarray([[0.77190877], … [ 0.5880136 ], … [-0.72834881], … [-0.90180688], … [-0.88694698]]) >>> corrcoef(A,B) matlabarray([[ 1. , -0.22086666],

[-0.22086666, 1. ]])

产生相关随机变量: >>> C = concat_(A, A*2+1) >>> C.shape (5, 2) >>> D = concat_(B, A*B) >>> R = corrcoef(C, D) >>> R matlabarray([[ 1. , -0.4332221],

[-0.4332221, 1. ]])

matopy.lib.mean module¶

matopy.lib.mean.mean(A, all_dim_vecdim=<no value>, outtype=<no value>, nanflag=<no value>)¶

matlab mean函数. 计算数组的均值

Parameters¶

A : matlabarray 矩阵或 array_like

all_dim_vecdim‘all’ 或 int 或 int list, 可选参数: ‘all’ 字符串: 对整个矩阵取均值 int: dim 参数，表示固定该 dim 维度，求均值，也是结果中长度变为1的维度。dim=1表示对列求均值；dim=2表示对行求均值 list: 沿多个指定的维度取均值

matlab语法¶

M = mean(A) M = mean(A,’all’) M = mean(A,dim) M = mean(A,vecdim) M = mean(___,outtype) 未实现 M = mean(___,nanflag) 未实现

说明¶

M = mean(A) 返回 A 沿大小不等于 1 的第一个数组维度的元素的均值。: 如果 A 是向量，则 mean(A) 返回元素均值。如果 A 为矩阵，那么 mean(A) 返回包含每列均值的行向量。如果 A 是多维数组，则 mean(A) 沿大小不等于 1 的第一个数组维度计算，并将这些元素视为向量。此维度会变为 1，而所有其他维度的大小保持不变。

示例¶

对向量取均值得到一个数 >>> A = matlabarray([1,2,3]) >>> mean(A) 2.0

>>> A = matlabarray([1,2,3])
>>> mean(A, 'all')
2.0

列向量均值 >>> A = matlabarray([1,2,3]).transpose() >>> mean(A) 2.0

矩阵列均值 >>> A = matlabarray([[0, 1, 1], [2, 3, 2], [1, 3, 2], [4, 2, 2]]) >>> mean(A) matlabarray([[1.75, 2.25, 1.75]])

矩阵行均值 >>> A = matlabarray([[0, 1, 1], [2, 3, 2], [3, 0, 1], [1, 2, 3]]) >>> mean(A, 2) matlabarray([[0.66666667],

[2.33333333], [1.33333333], [2. ]])

维度向量: 维度向量，指定为正整数向量。每个元素代表输入数组的一个维度。指定的操作维度的输出长度为 1，而其他保持不变。以 2×3×3 输入数组 A 为例。然后 mean(A,[1 2]) 返回一个 1×1×3 数组，其元素是 A 的每个页面的均值。

>>> A = matlabarray([[0, 1, 1],                         [2, 3, 2],                         [3, 0, 1],                         [1, 2, 3]])
>>> mean(A, [1, 2])
1.5833333333333333

matopy.lib.round module¶

matopy.lib.round.round(A, N=0)¶

matlab 取近似值函数

语法¶

Y = round(X)            【实现】
Y = round(X,N)          【实现】
Y = round(X,N,type)     【未实现】
Y = round(t)            【未实现】
Y = round(t,unit)       【未实现】

说明¶

Y = round(X) 将 X 的每个元素四舍五入为最近的整数。在对等情况下，即有元素的小数部分恰为 0.5 时，round 函数会偏离零四舍五入到具有更大幅值的整数。

Y = round(X,N) 四舍五入到 N 位数::: N > 0：舍入到小数点右侧的第 N 位数。 N = 0：四舍五入到最接近的整数。 N < 0：舍入到小数点左侧的第 N 位数。

示例¶

对矩阵元素四舍五入

>>> A = matlabarray([[2.11, 3.5],                         [-3.5, 0.78]]);
>>> round(A)
matlabarray([[ 2.,  4.],
       [-4.,  1.]])

matopy.lib.round.roundn(A, N)¶

对 A 的每个元素取近似值，到最近的 10^n Matlab 不推荐使用了，请使用 round() 函数。

示例¶

>>> roundn(3.1415926, -2)
3.14

>>> roundn(3.1415926, -3)
3.142

>>> roundn(3.1415926, 0)
3.0

matopy.lib.sign module¶

matopy.lib.sign.sign(x)¶

matlab Sign 函数（符号函数）

语法¶

sign(x)

说明¶

Y = sign(x) 返回与 x 大小相同的数组 Y，其中 Y 的每个元素是： 1，前提是 x 的对应元素大于 0。 0，前提是 x 的对应元素等于 0。 -1，前提是 x 的对应元素小于 0。 x./abs(x)，前提是 x 为复数。

示例¶

>>> sign(2)
1
>>> sign(-1.5)
-1.0
>>> sign(0)
0

复数 >>> sign(1+1j) (0.7071067811865475+0.7071067811865475j)

>>> z = 4 - 3j;
>>> sign(z)
(0.8-0.6j)

复数数组 >>> c=matlabarray([1+1j, 4-3j]) >>> sign(c) # doctest: +NORMALIZE_WHITESPACE matlabarray([[0.70710678+0.70710678j, 0.8 -0.6j ]])

matopy.lib.std module¶

matopy.lib.std.std(A, w=0)¶

matlab std 标准差函数

语法¶

S = std(A) 【实现】 S = std(A,w) 【部分实现，不支持w为权重向量】 S = std(A,w,’all’) 【未实现】 S = std(A,w,dim) 【未实现】 S = std(A,w,vecdim) 【未实现】 S = std(___,nanflag) 【未实现】

说明¶

S = std(A) 返回 A 沿大小不等于 1 的第一个数组维度的元素的标准差。如果 A 是观测值的向量，则标准差为标量。如果 A 是一个列为随机变量且行为观测值的矩阵，则 S 是一个包含与每列对应的标准差的行向量。如果 A 是多维数组，则 std(A) 会沿大小不等于 1 的第一个数组维度计算，并将这些元素视为向量。此维度的大小将变为 1，而所有其他维度的大小保持不变。默认情况下，标准差按 N-1 实现归一化，其中 N 是观测值数量。

S = std(A,w) 为上述任意语法指定一个权重方案。当 w = 0 时（默认值），S 按 N-1 进行归一化。当 w = 1 时，S 按观测值数量 N 进行归一化。【未实现：w 也可以是包含非负元素的权重向量。在这种情况下，w 的长度必须等于 std 将作用于的维度的长度。】

示例¶

求矩阵列的标准差:

>>> A = matlabarray([[4, -5, 1],                         [2, 3, 5],                         [-9, 1, 7]]);
>>> std(A)
matlabarray([[7.        , 4.163332  , 3.05505046]])

矩阵列的标准差，指定归一化 w=1，即除以 N 进行归一化:

>>> A = matlabarray([[1, 5], [3, 7], [-9, 2]]);
>>> w = 1;
>>> std(A,w)
matlabarray([[5.24933858, 2.05480467]])

matopy.lib.unique module¶

matopy.lib.unique.unique(A, nargout=1, **kwargs)¶

返回数组中的唯一值，元素索引、反向索引

Returns¶

C 唯一元素数组，且排序了 ia index of A, 即构成 C 的元素在原始数组 A 中的索引值，即用 A 元素中的索引构造 C，C = A[ia] ic index of C, 反向索引，即用 C 中的元素构造 A，ic 是 C 中元素的索引值，A = C[ic]

语法¶

C = unique(A) [C,ia,ic] = unique(___)

TODO 下面语法未实现 C = unique(A,setOrder) C = unique(A,occurrence) C = unique(A,___,’rows’) C = unique(A,’rows’,___) [C,ia,ic] = unique(A,’legacy’) [C,ia,ic] = unique(A,’rows’,’legacy’) [C,ia,ic] = unique(A,occurrence,’legacy’) [C,ia,ic] = unique(A,’rows’,occurrence,’legacy’)

说明¶

C = unique(A) 返回与 A 中相同的数据，但是不包含重复项。C 已排序。

示例¶

>>> A = matlabarray([9, 2, 9, 5])
>>> unique(A)
matlabarray([[2, 5, 9]])

>>> A = matlabarray([9, 2, 9, 5])
>>> unique(A, nargout=3)
(matlabarray([[2, 5, 9]]), matlabarray([[2, 4, 1]], dtype=int64), matlabarray([[3, 1, 3, 2]], dtype=int64))

matopy.lib.file module¶

class matopy.lib.file.Precision(precision_str, source_type, output_type, num_source)¶

基类：object

精度，用来解析、代表 matlab 的 fread(), fwrite(), fopen() 等函数的 precision 参数。

Examples¶

简单的精度串解析¶

>>> p = Precision.parse('uint32')
>>> print(p)
Precision(p='uint32',
source_type=PrecisionType(type=UNSIGNED_INTEGER, p=uint32, bits=32, bytes=4),
output_type=PrecisionType(type=FLOAT, p=double, bits=64, bytes=8),
num_source=1)
>>> print(p.source_type)
PrecisionType(type=UNSIGNED_INTEGER, p=uint32, bits=32, bytes=4)

一些看上去特殊的格式串：

>>> p = Precision.parse('char*1')
>>> print(p)
Precision(p='char*1',
source_type=PrecisionType(type=CHARACTER, p=char*1, bits=8, bytes=1),
output_type=PrecisionType(type=FLOAT, p=double, bits=64, bytes=8),
num_source=1)

“source=>output” 格式¶

用 “source=>output” 格式指定 output 的精度：

>>> p = Precision.parse('int8=>char')
>>> print(p)
Precision(p='int8=>char',
source_type=PrecisionType(type=SIGNED_INTEGER, p=int8, bits=8, bytes=1),
output_type=PrecisionType(type=CHARACTER, p=char, bits=8, bytes=1),
num_source=1)

“*source” 格式¶

output 等于 source 的精度。

>>> p = Precision.parse('*ubit18')
>>> print(p)
Precision(p='*ubit18',
source_type=PrecisionType(type=UNSIGNED_INTEGER, p=ubitn, bits=18, bytes=3),
output_type=PrecisionType(type=UNSIGNED_INTEGER, p=ubitn, bits=18, bytes=3),
num_source=1)
>>> print(p.output_type)
PrecisionType(type=UNSIGNED_INTEGER, p=ubitn, bits=18, bytes=3)

“N*source” 格式¶

指定元素重复次数的格式。

>>> p = Precision.parse('100*char*1')
>>> print(p)
Precision(p='100*char*1',
source_type=PrecisionType(type=CHARACTER, p=char*1, bits=8, bytes=1),
output_type=PrecisionType(type=FLOAT, p=double, bits=64, bytes=8),
num_source=100)

classmethod parse(precision)¶

解析 precision 格式的字符串，返回 Precision 对象.

参数:: precision –
返回:: Precision 对象

source_type: 输入(source)元素的’类型’，是 PrecisionType 对象，可以是 matlab 文档中的任意精度类型，例如 ‘int16’, ‘char*1’。 precision_type 类包括下面的属性:

- value_type (值类型)：可以是 "unsigned integer"无符号整数、"signed integer"有符号整数、"float"浮点数、"character"字符。
- precision (精度)：可以是 'uint16' 等 matlab 文档中定义的精度字符串，它也是 source 中用来判断精度的字符串内容。
- bits (位数)：类型所占位数
- bytes (字节数)：类型所占字节数，对于 ubitn 和 bitn 会取能够存放它们位数的最小字节数。

output_type: 返回的A矩阵的类型。和 source_type 一样，但对于 bitn 或 ubitn 精度，输出具有可包含输入的最小类。

示例：'*ubit18'
这等同于 'ubit18=>uint32'

num_source: 要读取的 ‘元素’ 的个数，由 precision 字符串中类似 “3*int16” 中的 ‘3’ 决定，例子中 num_source=3。

需要调用方自己计算 source元素占用的总字节数，也就是 precision 串所表示的‘元素’总字节数。

例如 "int16" 表示输入(source)‘元素’为一个int16整数、字节数是2，因此这里 element_size = 2。
例如 "*int16" 也表示输入、输出(source,output)‘元素’都是int16整数、element_size = 2。
例如 "char*1" 表示 source 的元素是1个字节的字符
例如 "3*int16" 表示 source 元素是3个int16整数，element_size = 3*2 = 6 字节。

Examples¶

>>> precision_ = Precision.parse("*int16")
>>> print(precision_)
Precision(p='*int16',
source_type=PrecisionType(type=SIGNED_INTEGER, p=int16, bits=16, bytes=2),
output_type=PrecisionType(type=SIGNED_INTEGER, p=int16, bits=16, bytes=2),
num_source=1)

property precision_bytes¶: 计算source精度的字节数，包括根据‘精度类型’得到的字节数和重复个数

exception matopy.lib.file.PrecisionException¶

基类：Exception

解析精度遇到的异常

class matopy.lib.file.PrecisionType(type_category, precision, bits, bytes_)¶

基类：object

精度类型，fread、fwrite 函数使用的 source 和 output 的取值，例如：’int32’、’integer*1’等。

classmethod parse(source)¶: 解析精度类型字符串，返回对应的 PrecisionType 对象。如果不是有效的精度类型字符串，则返回 None

class matopy.lib.file.PrecisionTypeCategory(value)¶

基类：Enum

精度类型所属大类，matlab文档称为值类型，可以是 ‘无符号整数、有符号整数、浮点数和字符’ 四类。

CHARACTER = 4¶

FLOAT = 3¶

SIGNED_INTEGER = 2¶

UNSIGNED_INTEGER = 1¶

matopy.lib.file.fclose(fileID)¶

关闭一个或所有打开的文件 :param fileID: 要关闭的文件id :return: 0 成功；-1 失败

matlab语法¶

fclose(fileID)
fclose('all')
status = fclose(___)

实现的语法¶

fclose(fileID)
fclose('all')
status = fclose(___)

matopy.lib.file.fopen(*args)¶

打开文件或获得有关打开文件的信息.

参数:: args – 输入参数，包括 filename, permission, machinefmt 和 encoding、fileId。
返回:: fileID 文件句柄数字

打开的文件流对象有 meta 属性，包含以信息：

fobj.meta.file_name 文件名，绝对路径
fobj.meta.encodingIn 文件编码
fobj.meta.permission 打开文件使用的 matlab 的文件 permission 字符串
fobj.meta.mode 打开文件使用的 python 的文件mode字符串

Matlab语法¶

fileID = fopen(filename)
fileID = fopen(filename,permission)
fileID = fopen(filename,permission,machinefmt,encodingIn)
[fileID,errmsg] = fopen(___)
fIDs = fopen('all')
filename = fopen(fileID)
[filename,permission,machinefmt,encodingOut] = fopen(fileID)

permission 参数描述:

'r' 打开要读取的文件。
'w' 打开或创建要写入的新文件。放弃现有内容（如果有）。
'a' 打开或创建要写入的新文件。追加数据到文件末尾。
'r+'        打开要读写的文件。不会自动创建文件。
'w+'        打开或创建要读写的新文件。放弃现有内容（如果有）。
'a+'        打开或创建要读写的新文件。追加数据到文件末尾。
'A' 打开文件以追加（但不自动刷新）当前输出缓冲区。
'W' 打开文件以写入（但不自动刷新）当前输出缓冲区。

实现说明¶

Matlab中的 permission 默认是二进制，如果要以文本模式打开，需要加上 ‘t’ 字母，而 python 中默认是文本模式，要以二进制模式打开，需要加上字母 ‘b’。

这里我们将使用 Matlab 的约定，所以调用 fopen() 函数时，请使用 matlab 的 permission 约定。

Examples¶

设置文件编码：

>>> fid = fopen('./data/test_fread.bin')
>>> stream = _get_stream_by_file_id(fid)
>>> stream.meta.encodingIn
'UTF-8'

matopy.lib.file.fread(*args, nargout=1)¶

读取二进制文件中的数据.

参数:

fileID – 文件对象，用 fopen() 打开的文件
sizeA –
返回的 A 矩阵尺寸，也就是要读取的长度。sizeA 的有效值有： N read N elements into a column vector. inf read to the end of the file. [M,N] read elements to fill an M-by-N matrix, in column order.

注意读取的矩阵是按列存储的，就是文件中相邻的字节写入A的同一列中。 N can be inf, but M can’t.
precision – 要读取的值的类和大小，是一个字符串，默认为 “uint8=>double”
skip – 读取一个单元的内容后要跳过的字节数
machinefmt – 读取字节的顺序

返回:

A 矩阵，读取的二进制文件内容；count 读取到 A 中的字符数。

precision:

要读取的值的类和大小（以位为单位），以下列形式之一指定为字符向量或字符串标量。（可选）输入可指定输出矩阵 A 的类。
precision 输入的格式说明:
    source: 输入值属于 source 指定的类。输出矩阵 A 为类 double。示例：'int16'
    source=>output:     输入值属于 source 指定的类。输出矩阵 A 的类由 output 指定。示例：'int8=>char'
    *source: 输入值和输出矩阵 A 属于 source 指定的类。对于 bitn 或 ubitn 精度，输出具有可包含输入的最小类。示例：'*ubit18'
        这等同于 'ubit18=>uint32'
    N*source 或 N*source=>output: 在跳过 skip 参数指定的字节数之前读取 N 值。例如：'4*int8'。

machinefmt:

读取文件中的字节的顺序，指定为字符向量或字符串标量。将 machinefmt 指定为下表中列出的值之一。对于 bitn 和 ubitn 精度，machinefmt 指定字节中位的读取顺序，而字节的读取顺序仍与系统字节顺序相同。

'n' 或 'native' : 系统字节排序方式（默认）
'b' 或 'ieee-be': Big-endian 排序
'l' 或 'ieee-le': Little-endian 排序
's' 或 'ieee-be.l64': Big-endian 排序，64 位长数据类型
'a' 或 'ieee-le.l64': Little-endian 排序，64 位长数据类型

文件的字符编码¶

source、output 中的”char*1”是固定的1个字节、对应的字符编码就是ASCII，而”char”类型字节数取决于与文件关联的编码方案。使用 fopen 设置编码，该参数是 encodingIn，默认是UTF-8编码。

matlab语法¶

A = fread(fileID)
A = fread(fileID,sizeA)
A = fread(fileID,precision)
A = fread(fileID,sizeA,precision)
A = fread(___,skip)
A = fread(___,machinefmt)
[A,count] = fread(___)

A = fread(fileID) 将打开的二进制文件中的数据读取到列向量 A 中，并将文件指针定位在文件结尾标记处。
该二进制文件由文件标识符 fileID 指示。使用 fopen 可打开文件并获取 fileID 值。读取文件后，请调用 fclose(fileID) 来关闭文件。

数据不足时的处理逻辑¶

fread()当数据不够时，如何处理？是自动补0还是丢弃？

答：会丢弃，少读取一个元素。例如: 文件只有3个字节，那么按’int16’读取时，只会读取完整的 1 个元素，也就是2个字节，多余的1个字节被丢弃。如果按’int32’读取，那么会读取0个字节，因为全部数据不足int32所需的4字节。

Examples¶

先写入一个3字节长的文件，准备后面读取。

>>> from matopy.lib import fopen, fwrite
>>> fid = fopen('./data/test_fread.bin', 'r+')

>>> A = fread(fid, [1, 3], '*uint8')
>>> print(A)
[[ 52  86 120]]

测试不同的精度参数：

>>> fseek(fid, 0, 'bof')
0
>>> A = fread(fid, None, 'uint16')
>>> print(A)
22068.0

测试不同的字节序：

>>> fseek(fid, 0, 'bof')
0
>>> A = fread(fid, None, 'uint16', 'b')
>>> print(A)
13398.0

测试指定 sizeA 大于文件内容的情况，对于列长度不够的情况会补0：

>>> fseek(fid, 0, 'bof')
0
>>> A = fread(fid, [2, 2], 'uint8', 'n')
>>> print(A)
[[ 52. 120.]
 [ 86.   0.]]

支持 sizeA=[2,inf] 无限列的情况：

>>> fseek(fid, 0, 'bof')
0
>>> A = fread(fid, [2, inf], 'uint8', 'n')
>>> print(A)
[[ 52. 120.]
 [ 86.   0.]]

支持 sizeA=[2,inf] 无限列+skip的情况：

>>> fseek(fid, 0, 'bof')
0
>>> A = fread(fid, [2, inf], 'uint8', 1, 'n')
>>> print(A)
[[52.]
 [86.]]

>>> fclose(fid)

支持指定 int 类型的 size：

>>> fid = fopen('./data/test_fread.bin', 'r+')
>>> fread(fid,1,'*int16')
22068

matopy.lib.file.fseek(fileId, offset, origin)¶

移至文件中的指定位置

参数:

fileId (int) – 文件标识符
offset (int) – 字节数
origin (int | str) – 起始位置

返回:

当操作成功时，返回 0。否则，fseek 将返回 -1。

matopy.lib.file.fwrite(*args)¶

fwrite - 将数据写入二进制文件

此 MATLAB 函数将数组 A 的元素按列顺序以 8 位无符号整数的形式写入一个二进制文件。该二进制文件由文件标识符 fileID 指示。使用 fopen 可打开文件并获取 fileID 值。完成写入后，请调用 fclose(fileID) 来关闭文件。

fwrite(fileID,A)
fwrite(fileID,A,precision)
fwrite(fileID,A,precision,skip)
fwrite(fileID,A,precision,skip,machinefmt)

count = fwrite(___) 返回 A 中 fwrite 已成功写入到文件的元素数。

输入参数

fileID - 文件标识符: 整数 | 1 | 2
A - 要写入的数据: 数值数组 | 字符数组 | 字符串数组
precision - 要写入的值的类和大小: ‘uint8’ (默认值) | 字符向量 | 字符串标量
skip - 要跳过的字节数，写入每个值之前要跳过的字节数，指定为标量。注意：是每个元素前跳过skip字节，不是每一行跳过！: 0 (默认值) | 标量
machinefmt - 字节写入顺序: ‘n’ (默认值) | ‘b’ | ‘l’ | ‘s’ | ‘a’

Examples¶

写入一个 uint8 的矩阵：

>>> fid = fopen('./data/test_fwrite.bin', 'w')
>>> A = matlabarray([[1,2,3],[4,5,6]], dtype=np.uint8)
>>> fwrite(fid, A.T, 'uint8')
6
>>> fclose(fid)

读取写入的数据并验证:

>>> fid = fopen('./data/test_fwrite.bin', 'r')
>>> A=fread(fid, [3, 2], '*uint8')
>>> A.T
matlabarray([[1, 2, 3],
       [4, 5, 6]], dtype=uint8)

写入 float 的矩阵并验证:

>>> fid = fopen('./data/test_fwrite.bin', 'w')
>>> A = matlabarray([[1.112233445566778899, 2.112233445566, 3.112233445566],[4,5,6]], dtype=np.float64)
>>> fwrite(fid, A.T, 'float64')
6
>>> fclose(fid)
>>> fid = fopen('./data/test_fwrite.bin', 'r')
>>> B = fread(fid, [3, 2], '*float64').T
>>> B
matlabarray([[1.11223345, 2.11223345, 3.11223345],
       [4.        , 5.        , 6.        ]])
>>> B[1].item()         # float64 十进制，小数点后最多有 15-17 位有效数字，这里是 16 位
1.1122334455667788
>>> fclose(fid)

带 skip 写入部分数据:

# 文件中的数据是这样的(行优先模式)：
# matlabarray([[1.11223345, 2.11223345, 3.11223345],
#            [4.        , 5.        , 6.        ]])

>>> fid = fopen('./data/test_fwrite.bin', 'r+')
>>> A = matlabarray([11,22,33], dtype=np.float64)
>>> fwrite(fid, A.T, 'float64', 8)    # 跳过 1 个字段
3
>>> fclose(fid)

>>> fid = fopen('./data/test_fwrite.bin', 'r')
>>> B = fread(fid, [3, 2], '*float64').T
>>> B
matlabarray([[ 1.11223345, 11.        ,  3.11223345],
       [22.        ,  5.        , 33.        ]])

带 skip、seek 写入一列数据:

>>> fid = fopen('./data/test_fwrite.bin', 'r+')
>>> A = arange(1, 100).reshape((-1, 4))
>>> A.shape
(25, 4)
>>> fwrite(fid, A, 'float')
100
>>> fclose(fid)
>>> fid = fopen('./data/test_fwrite.bin', 'r+')
>>> fseek(fid, 16+1, 'bof')
0

>>> fid = fopen('./data/test_fwrite.bin', 'w')
>>> A = matlabarray([[1,2,3],[4,5,6]], dtype=np.float32).T
>>> fwrite(fid, A, 'float32')
6
>>> fclose(fid)
>>> fid = fopen('./data/test_fwrite.bin', 'r+')
>>> fseek(fid, 4, 'bof')
0
>>> A = matlabarray([11,22], dtype=np.float32)
>>> fwrite(fid, A, 'float32', 1*4)
2
>>> fclose(fid)
>>> fid = fopen('./data/test_fwrite.bin', 'r')
>>> B = fread(fid, [3,2], '*float32').T
>>> B
matlabarray([[ 1.,  2., 11.],
       [ 4., 22.,  6.]], dtype=float32)

matopy.lib.file.isfile(file_name)¶: 检查文件是否存在

matopy.lib.file.load(filename)¶

将文件变量加载到工作区中

参数:: filename – 文件名
返回:: 装载的数据，如果 filename 是 csv,ascii 数据，则返回包含该文件数据的双精度数组。

如果 filename 是 mat 文件，则返回一个结构数组。

matopy.lib.file.m_dir(name='.', nargout=1)¶

列出目录下的内容及其属性，支持通配符，例如 “c:/data/*.txt”

参数:

name – 文件或文件夹名称。
nargout – 输出变量个数，如果 nargout=0 则只打印子文件、子目录名。

返回:

文件属性 struct 数组，结构体中的字段看下面的文档。如果 name 是一个文件，则返回包含一个 struct 对象的cellarray数组；

如果 name 是目录，则返回目录下所有文件、子目录的属性struct, 形式是 Nx1 的struct数组。

语法¶

dir 列出当前文件夹中的文件和文件夹。

dir name 列出与 name 匹配的文件和文件夹。如果 name 为文件夹，dir 列出该文件夹的内容。使用绝对或相对路径名称指定 name。

name 参数的文件名可以包含 * 通配符，路径名称可以包含 * 和 ** 通配符。与 ** 通配符相邻的字符必须为文件分隔符。如果使用 “*” 通配符，则只会列出目录名而不会列出目录的内容。

listing = dir(name) 返回 name 的属性。

文件属性，以 n×1 结构体数组形式返回，其中 n 是 dir 命令返回的文件和文件夹的数量。

下表显示了结构体中的字段:

+-----------+----------------------------------------+--------+
| 字段名称   | 说明                                    | 类型    |
+===========+========================================+========+
| name      | 文件或文件夹名称                         | char   |
+-----------+----------------------------------------+--------+
| folder    | 文件或文件夹的位置                        | char   |
+-----------+----------------------------------------+--------+
| date      | 修改日期时间戳                           | char   |
+-----------+----------------------------------------+--------+
| bytes     | 文件大小（以字节为单位）                   | double |
+-----------+----------------------------------------+--------+
| isdir     | 如果名称为文件夹，则为 1；如果名称为        | logical|
|           | 文件，则为 0                            |        |
+-----------+----------------------------------------+--------+
| datenum   | 修改日期是一个日期序列值                   | double |
+-----------+----------------------------------------+--------+

Examples¶

列出目录下的内容：

>>> files = m_dir("c:/")
>>> len(files) > 0
True

>>> files = m_dir(matlabarray("c:/windows/*.exe"))
>>> len(files) > 0
True

打印指定目录内容到标准输出终端：

>>> m_dir('./data/dir', nargout=0)
test_fread.bin

打印当前目录的内容：

>>> m_dir(nargout=0)    
all_doctest_suite.py...

返回目录内容的属性列表: >>> m_dir(‘./data/dir’, nargout=1) # doctest: +ELLIPSIS 包含以下字段的 struct:

name: test_fread.bin

folder: ./data/dir

date: …

bytes: 3 isdir: 0

datenum: … <BLANKLINE>

matopy.lib.file.save(filename, variables_dict)¶

将工作区变量保存到文件中

参数:

filename (str) – 要写入的matlab数据文件名.
variables_dict (dict) – 要保存的变量字典，key是变量名，value是变量对象。

返回:

void

返回类型:

void

matlab语法¶

save(filename)
save(filename,variables)
save(filename,variables,fmt)
save(filename,variables,version)
save(filename,variables,version,'-nocompression')
save(filename,variables,'-append')
save(filename,variables,'-append','-nocompression')

实现的语法¶

save(filename)
save(filename,variables)

matopy.lib.file.xlsread(file, sheet=None, header=None)¶

读取 excel 文件，可以指定要读取的表单，默认读取第一个表单

Parameters¶

file: str: excel 文件，要计算的数据矩阵
sheet:: 要读取的表单名
header:: 用作列名的行号。header=None表示没有列头，自动创建列头；header=0表示第一行是列头，数据从第1行开始。

Returns¶

DataFrame: 返回 pandas 的 DataFrame 对象

Notes¶

Matlab 格式:

num = xlsread(filename)
num = xlsread(filename,sheet)
num = xlsread(filename,xlRange)
num = xlsread(filename,sheet,xlRange)
num = xlsread(filename,sheet,xlRange,'basic')
[num,txt,raw] = xlsread(___)

matopy.lib package¶

Submodules¶

matopy.lib.libmatopy module¶

Examples¶

语法¶

Examples¶

See Also¶

Notes¶

Examples¶

Examples¶

语法¶

说明¶

Examples¶

Examples¶

Examples¶

Examples¶

Examples¶

Returns¶

Examples¶

语法¶

Examples¶

python变化¶

Examples¶

python变化¶

Returns¶

Examples¶

Examples¶

Examples¶

Parameters¶

Returns¶

Examples¶

Arguments¶

Returns¶

Examples¶

Arguments¶

Returns¶

Examples¶

语法¶

Examples¶

语法¶

Examples¶

语法¶

Examples¶

Examples¶

Parameters¶

Returns¶

Examples¶

Examples¶

matlab语法¶

Parameters¶

Returns¶

语法¶

Examples¶

创建对象¶

语法¶

Examples¶

Examples¶

matlab 语法¶

Examples¶

matopy.lib.libbasic module¶

语法¶

Arguments¶

Returns¶

Examples¶

语法¶

Examples¶

Examples¶

Examples¶

语法¶

说明¶

Examples¶

语法¶

说明¶

Examples¶

Examples¶

语法¶

说明¶

Examples¶

语法¶

说明¶