numpy_basic3

numpy_basic3

矩陣

1. 矩阵是numpy.matrix类类型的对象，该类继承自numpy.ndarray，任何针对多维数组的操作，对矩阵同样有效，但是作为子类矩阵又结合其自身的特点，做了必要的扩充，比如：乘法计算、求逆等。

2. 矩阵对象的创建可以通过以下三种方式：
   • numpy.matrix(任何可被解释为矩阵的二维容器,copy=是否复制数据(缺省值为True，即复制数据))
     • 如果copy的值为True(缺省)，所得到的矩阵对象与参数中的源容器共享同一份数据，否则，各自拥有独立的数据拷贝。
   • numpy.mat(任何可被解释为矩阵的二维容器)等价于numpy.matrix(..., copy=False)
     • 由该函数创建的矩阵对象与参数中的源容器一定共享数据，无法拥有独立的数据拷贝。
   • numpy.bmat(拼块规则)
     • 包含若干小矩阵数据的大矩阵，拼接规则由参数指定

3. 以上函数也可以接受字符串形式的矩阵描述：数据项通过空格分隔，数据行通过分号分隔。例如：
   '1 2 3; 4 5 6'
   / 1 2 3  4 5 6 /

#mat.py
import numpy as np
a = np.array([
    [1, 2, 6],
    [3, 5, 7],
    [4, 8, 9]])
print(a, type(a))
b = np.matrix(a)
print(b, type(b))
b += 10
print(b)
print(a)

c = np.matrix(a, copy=False)
print(c, type(c))
c += 10
print(c)
print(a)

d = np.mat(a)
print(d, type(d))
d -= 10
print(d)
print(a)

e = np.mat('1 2 6; 3 5 7; 4 8 9')
print(e)

f = np.bmat('b e')
print(f)
g = np.bmat('b e; e b')

# 多維數組的乘法：對應元素相乘
h = a * a
print('h等於\n', h)
# 矩陣相乘：乘積矩陣的第i行第j列元素等於被乘矩陣的第i行於乘數矩陣的第j列的點積
i = e * e
print('i等於\n', i)
j = e.I
print('e的逆矩陣為\n', j)
print(j * e)

k = a.dot(a) # 數組使用矩陣乘法
l = np.linalg.inv(a) # 數組使用逆矩陣

[[1 2 6]
 [3 5 7]
 [4 8 9]] <class 'numpy.ndarray'>
[[1 2 6]
 [3 5 7]
 [4 8 9]] <class 'numpy.matrixlib.defmatrix.matrix'>
[[11 12 16]
 [13 15 17]
 [14 18 19]]
[[1 2 6]
 [3 5 7]
 [4 8 9]]
[[1 2 6]
 [3 5 7]
 [4 8 9]] <class 'numpy.matrixlib.defmatrix.matrix'>
[[11 12 16]
 [13 15 17]
 [14 18 19]]
[[11 12 16]
 [13 15 17]
 [14 18 19]]
[[11 12 16]
 [13 15 17]
 [14 18 19]] <class 'numpy.matrixlib.defmatrix.matrix'>
[[1 2 6]
 [3 5 7]
 [4 8 9]]
[[1 2 6]
 [3 5 7]
 [4 8 9]]
[[1 2 6]
 [3 5 7]
 [4 8 9]]
[[11 12 16  1  2  6]
 [13 15 17  3  5  7]
 [14 18 19  4  8  9]]
h等於
 [[ 1  4 36]
 [ 9 25 49]
 [16 64 81]]
i等於
 [[ 31  60  74]
 [ 46  87 116]
 [ 64 120 161]]
e的逆矩陣為
 [[-0.73333333  2.         -1.06666667]
 [ 0.06666667 -1.          0.73333333]
 [ 0.26666667  0.         -0.06666667]]
[[ 1.00000000e+00  1.77635684e-15  3.55271368e-15]
 [ 0.00000000e+00  1.00000000e+00 -1.11022302e-16]
 [ 0.00000000e+00  0.00000000e+00  1.00000000e+00]]

通用函数

1. frompyfunc->ufunc对象

def 标量函数(标量参数1, 标量参数2, ...):
    ...
    return 标量返回值1, 标量返回值2, ...
矢量参数1
矢量参数2
...
numpy.frompyfunc(标量函数, 参数个数, 返回值个数)
    ->矢量函数 # numpy.ufunc类类型的对象，可调用对象
矢量函数(矢量参数1, 矢量参数2, ...)
    ->矢量返回值1, 矢量返回值2

# ufunc.py
import numpy as np

def foo(x, y):
    return x + y, x - y, x * y

def hum(x):
    def fun(y):
        return x + y, x - y, x * y
    return np.frompyfunc(fun, 1, 1)

x, y = 1, 4
print(foo(x, y))
X, Y = np.array([1, 2, 3]), np.array([4, 5, 6])
bar = np.frompyfunc(foo, 2, 3)
print(bar(X, Y))
print(np.frompyfunc(foo, 2, 3)(X, Y))
print(hum(100)(X))

(5, -3, 4)
(array([5, 7, 9], dtype=object), array([-3, -3, -3], dtype=object), array([4, 10, 18], dtype=object))
(array([5, 7, 9], dtype=object), array([-3, -3, -3], dtype=object), array([4, 10, 18], dtype=object))
[(101, 99, 100) (102, 98, 200) (103, 97, 300)]

2. 加法通用函数：add

add.reduce() - 累加和
add.accumulate() - 累加和过程
add.reduceat() - 分段累加和
add.outer() - 外和

# add.py
a = np.arange(1, 7)
print(a)
b = a + a
print(b)

b = np.add(a, a)
print(b)

c = np.add.reduce(a)
print(c)
d = np.add.accumulate(a)
print(d)
e = np.add.reduceat(a, [0, 2, 4]) # 按照下標分段
print(e)
f = np.add.outer([10, 20, 30], a)
print(f)

g = np.outer([10, 20, 30], a) # 不加add的話是外積
print(g)

[1 2 3 4 5 6]
[ 2  4  6  8 10 12]
[ 2  4  6  8 10 12]
21
[ 1  3  6 10 15 21]
[ 3  7 11]
[[11 12 13 14 15 16]
 [21 22 23 24 25 26]
 [31 32 33 34 35 36]]
[[ 10  20  30  40  50  60]
 [ 20  40  60  80 100 120]
 [ 30  60  90 120 150 180]]

3. 除法通用函数

[5 5 -5 -5]<真除>[2 -2 2 -2] = [2.5 -2.5 -2.5 2.5]
    numpy.true_divide()
    numpy.divide()
    /
    
[5 5 -5 -5]<地板除>[2 -2 2 -2] = [2 -3 -3 2]
    numpy.floor_divide()
    //
    
[5 5 -5 -5]<天花板除>[2 -2 2 -2] = [3 -2 -2 3]
    天花板取整(真除的结果)：numpy.ceil()
    
[5 5 -5 -5]<截断除>[2 -2 2 -2] = [2 -2 -2 2]
    截断取整(真除的结果)：numpy.trunc()

# div.py
a = np.array([5, 5, -5, -5])
b = np.array([2, -2, 2, -2])
print(a, b)
# c = np.true_divide(a, b)
# c = np.divide(a, b)
c = a / b
print(c)
# d = np.floor_divide(a, b)
d = a // b
print(d)
e = np.ceil(a / b).astype(int)
print(e)
f = np.trunc(a / b).astype(int)
print(f)

[ 5  5 -5 -5] [ 2 -2  2 -2]
[ 2.5 -2.5 -2.5  2.5]
[ 2 -3 -3  2]
[ 3 -2 -2  3]
[ 2 -2 -2  2]

4. 取余通用函数

被除数/除数=商...余数
除数 * 商 + 余数 = 被除数

[5 5 -5 -5]<地板除>[2 -2 2 -2] = [2 -3 -3 2]...[1 -1 1 -1]
numpy.remainder()
numpy.mod()
%

[5 5 -5 -5]<截断除>[2 -2 2 -2] = [2 -2 -2 2]...[1 1 -1 -1]
numpy.fmod()

Numpy将Python语言中针对标量的运算符，通过通用函数加以重载定义，以支持数组形式的矢量运算。

# fib.py
import numpy as np
n = 35

# 递归方法
# def fibo(n):
#     return 1 if n < 3 else fibo(n - 1) + fibo(n - 2)
# print(fibo(n))

# 循环换位方法
fn_1, fn_2 = 0, 1
for i in range(n):
    fn = fn_1 + fn_2
    fn_1, fn_2 = fn, fn_1
print(fn)

# 矩阵乘方
print(int((np.mat('1. 1.; 1. 0.') ** (n - 1))[0, 0]))

# 斐波那契公式
r = np.sqrt(5)
print(int((((1 + r) / 2) ** n -
           ((1 - r) / 2) ** n) / r))

9227465
9227465
9227465

5. Numpy中的所有三角函数都是通用函数

x = Asin(at+pi/2)
y = Bsin(bt)

# lissa.py
import numpy as np
import matplotlib.pyplot as mp
t = np.linspace(0, 2