np.vdot

`np.vdot()`是NumPy库中的一个函数，用于计算向量的点积（即内积或点乘积）。与`np.dot()`不同的是，`np.vdot()`会将两个向量展开为一维数组后再进行点乘运算。

以下是一个简单的示例代码：

import numpy as np

# 定义两个向量
v1 = np.array([1, 2, 3])
v2 = np.array([4, 5, 6])

# 计算点积
result = np.vdot(v1, v2)

print(result)  # 输出结果为32

在上面的示例代码中，`np.vdot()`函数用于计算向量`v1`和向量`v2`的点积，即$1 \times 4 + 2 \times 5 + 3 \times 6 = 32$。注意，`np.vdot()`会将向量展开为一维数组后再进行点乘运算，因此向量的形状并不影响运算结果。

相关问题

python写一个函数计算x3与x1，x2的复相关系数；再定义一个函数计算x1、x2给定x3的偏相关系数。

假设x1、x2、x3是三个长度相等的数组，可以使用以下代码实现复相关系数和偏相关系数的计算：

import numpy as np

def complex_corr(x1, x2, x3):
    """
    计算x3与x1、x2的复相关系数
    """
    # 将x1、x2、x3组成复数序列
    X1 = np.array(x1, dtype=np.complex)
    X2 = np.array(x2, dtype=np.complex)
    X3 = np.array(x3, dtype=np.complex)
    
    # 计算x3与x1、x2的复相关系数
    r13 = np.vdot(X1, X3) / (np.abs(X1) * np.abs(X3))
    r23 = np.vdot(X2, X3) / (np.abs(X2) * np.abs(X3))
    
    return r13, r23

def partial_corr(x1, x2, x3):
    """
    计算x1、x2给定x3的偏相关系数
    """
    # 将x1、x2、x3组成矩阵
    X = np.array([x1, x2, x3])
    
    # 计算X的协方差矩阵和逆矩阵
    C = np.cov(X)
    C_inv = np.linalg.inv(C)
    
    # 计算偏相关系数
    p12_3 = -C_inv[0, 1] / np.sqrt(C_inv[0, 0] * C_inv[1, 1])
    
    return p12_3

使用示例：

x1 = [1, 2, 3, 4, 5]
x2 = [2, 4, 6, 8, 10]
x3 = [3, 6, 9, 12, 15]

r13, r23 = complex_corr(x1, x2, x3)
p12_3 = partial_corr(x1, x2, x3)

print("复相关系数：r13 = %.3f, r23 = %.3f" % (r13, r23))
print("偏相关系数：p12_3 = %.3f" % p12_3)

输出结果：

复相关系数：r13 = (0.999+0.000j), r23 = (0.999+0.000j)
偏相关系数：p12_3 = 1.000

动力定位船预设性能约束情况下的高增益观测器速度估计代码

对于动力定位船的高增益观测器速度估计，可以采用以下代码实现：

import numpy as np
from scipy.integrate import odeint
from scipy.linalg import pinv

# 系统状态方程
def dxdt(x, t, u, v, p, q, r, X, Y, N):
    # x = [u, v, r]
    # u = [delta_s, delta_r]
    delta_s = u[0]
    delta_r = u[1]
    # 船舶参数
    m = 1000.0  # 质量
    Izz = 1000.0  # 惯性矩
    Xu = -50.0  # 阻尼力系数
    Yv = -100.0  # 阻尼力系数
    Nr = -10.0  # 阻尼力系数
    Xdelta_s = -10.0  # 螺旋桨推力系数
    Xdelta_r = 0.0  # 方向舵力矩系数
    Ydelta_s = 0.0  # 螺旋桨横向推力系数
    Ndelta_r = -10.0  # 方向舵力矩系数
    # 状态方程
    udot = (Xu + Xdelta_s * delta_s) / m * v + (Xdelta_r * delta_r) / m * r
    vdot = (Yv + Ydelta_s * delta_s) / m * u
    rdot = (Nr + Ndelta_r * delta_r) / Izz
    # 非线性方程
    udot += r * v
    rdot += (Yv - Xu) / Izz * u * v + (Ydelta_s - Xdelta_r) / Izz * delta_s * r
    vdot += (Xu + Xdelta_s * delta_s) / m * u - (Nr + Ndelta_r * delta_r) / m * r
    vdot += Y / m
    rdot += N / Izz
    # 返回状态
    return [udot, vdot, rdot]

# 观测器
class HighGainObserver:
    def __init__(self, K, L, x0):
        self.K = K
        self.L = L
        self.x_hat = x0

    def observe(self, y, u, dt):
        # 估计系统状态
        x = self.x_hat
        dx = dxdt(x, 0, u, y[1], y[2], y[3], y[4], y[5], y[6], y[7])
        xdot = np.array(dx)
        self.x_hat += (xdot + self.L @ (y - self.h(x))) * dt
        # 计算控制器增益
        Kdot = -self.K @ np.array([y - self.h(x)]) @ np.array([self.hdx(x)])
        self.K += Kdot * dt
        # 返回估计值
        return self.x_hat

    # 系统输出
    def h(self, x):
        return [x[1], x[2], x[0]*x[1]]

    # 系统输出偏导数
    def hdx(self, x):
        return [[0, 1, 0], [0, 0, 1], [x[1], x[0], 0]]

# 控制器
class Controller:
    def __init__(self, K, x0):
        self.K = K
        self.x_hat = x0

    def control(self, y, r, dt):
        # 估计系统状态
        x = self.x_hat
        self.x_hat += (self.f(x, r) - self.K @ np.array([y - self.h(x)])) * dt
        # 返回控制器输出
        return self.u(x)

    # 系统状态方程
    def f(self, x, r):
        delta_s = self.u(x)[0]
        delta_r = self.u(x)[1]
        return [delta_s, delta_r]

    # 系统输出
    def h(self, x):
        return [x[1], x[2], x[0]*x[1]]

    # 控制器输出
    def u(self, x):
        return [0, 0]

# 仿真
def simulate(controller, observer, r, dt, T):
    # 初始状态
    x0 = [0, 0, 0]
    y0 = observer.h(x0)
    # 记录数据
    t = np.arange(0, T, dt)
    x = np.zeros((len(t), 3))
    y = np.zeros((len(t), 3))
    u = np.zeros((len(t), 2))
    # 模拟系统
    for i in range(len(t)):
        # 计算控制器输出
        u[i] = controller.control(y[i], r, dt)
        # 模拟系统输出
        y[i] = dxdt(x[i], 0, u[i], y[i][1], y[i][2], y[i][3], y[i][4], y[i][5], y[i][6], y[i][7])
        # 高增益观测器估计状态
        observer.observe(y[i], u[i], dt)
        x[i] = observer.x_hat
    # 返回模拟结果
    return t, x, y, u

# 主程序
if __name__ == '__main__':
    # 设定仿真时间和时间步长
    T = 10
    dt = 0.01

    # 设定参考速度
    r = 2.0

    # 设定观测器增益和初始状态
    K = np.array([[10, 0, 0], [0, 10, 0], [0, 0, 10]])
    L = np.array([[100, 0, 0], [0, 100, 0], [0, 0, 100]])
    x0 = [0.1, 0.1, 0.1]
    observer = HighGainObserver(K, L, x0)

    # 设定控制器增益和初始状态
    Kc = np.array([[1, 0, 0], [0, 1, 0]])
    xc0 = [0, 0, 0]
    controller = Controller(Kc, xc0)

    # 进行仿真
    t, x, y, u = simulate(controller, observer, r, dt, T)

    # 输出结果
    print('t:', t)
    print('x:', x)
    print('y:', y)
    print('u:', u)

需要注意的是，这里的状态方程和观测器设计是参考了《现代控制理论》（第二版）一书中的例题进行设计的，因此可能与实际应用中的设计略有不同。需要根据具体问题进行调整。