Mixiot Lua 数学库函数手册

标准 Lua 的数学计算功能非常有限，无法进行复杂的数学计算。Mixiot Lua 数学库是标准 Lua 在数学计算方面的扩展，Mixiot 应用中的 Lua 脚本可以直接引用的数学函数。

Mixiot Lua 有四部分，也就是四个数学库：

1. 基本计算相关函数库 mixnum；
2. 统计相关的计算函数库 mixstat；
3. 矩阵相关的函数库 mixmat；
4. 最优化相关的函数库 mixopt

mixnum（计算相关函数库）

Abs(x)

参数:

• X number

返回:

• res number

Abs 返回 x 的绝对值。

local mixnum = require("mixnum")

x = mixnum.Abs(-0.5)

Output:
0.5

Acos(x)

参数:

• X number

返回:

• res number

Acos 返回 x 的反余弦，单位是弧度。

x = mixnum.Acos(1)

Output:
0

Acosh(x)

参数:

• X number

返回:

• res number

Acosh 返回逆双曲 cos (x)。

x = mixnum.Acosh(1)

Output:
0

Asin(x)

参数:

• X number

返回:

• res number

Asin 返回 x 的反正弦，以弧度为单位。

x = mixnum.Asin(0)

Output:
0

Asinh(x)

参数:

• X number

返回:

• res number

Asinh 返回反双曲 sinx。

x = mixnum.Asinh(0)

Output:
0

Atan(x)

参数:

• X number

返回:

• res number

Atan 返回 x 的 arctan，以弧度为单位。

x = mixnum.Atan(0)

Output:
0

Atanh(x)

参数:

• X number

返回:

• res number

Atanh返回x的逆双曲正切。

x = mixnum.Atanh(0)

Output:
0

Cbrt(x)

参数:

• X number

返回:

• res number

Cbrt 返回 x 的立方根。

x = mixnum.Cbrt(27)

Output:
3

Ceil(x)

参数:

• X number

返回:

• res number

Ceil 返回大于或等于 x 的最小整数值。

x = mixnum.Ceil(1.49)

Output:
2

Cos(x)

参数:

• X number

返回:

• res number

Cos 返回弧度参数 x 的余弦。

x = mixnum.Cos(0)

Output:
0

Cosh(x)

参数:

• X number

返回:

• res number

Cosh 返回 x 的双曲余弦。

x = mixnum.Cosh(0)

Output:
1

Exp(x)

参数:

• X number

返回:

• res number

Exp返回 $e^x$，即 x 的 e 为底数的指数。

非常大的值溢出到0或 +∞。非常小的值下溢到 1。

x = mixnum.Exp(-1)

Output:
0.36787944117144233

Exp2(x)

参数:

• X number

返回:

• res number

Exp2 返回 $2^x$，x 的基数为2的指数。

x = mixnum.Exp2(1)

Output:
2

Expm1(x)

参数:

• X number

返回:

• res number

Expm1 返回 $e^x - 1$，即 x 的 e 为底数的指数减去 1。当 x 接近零时，它比 Exp(x) - 1 更准确。

非常大的值溢出到 -1 或 +∞。

x = mixnum.Expm1(-1)

Output:
-0.6321205588285577

Floor(x)

参数:

• X number

返回:

• res number

Floor 返回小于或等于 x 的最大整数值。

x = mixnum.Floor(1.51)

Output:
1

Gamma(x)

参数:

• X number

返回:

• res number

Gamma 返回 x 的 Gamma 函数。

x = mixnum.Gamma(3)

Output:
2

Log(x)

参数:

• X number

返回:

• res number

Log 返回 x 的自然对数。

x = mixnum.Log(2.7183)
y = mixnum.Log(-2.7183)

Output:
1
NaN

Log10(x)

参数:

• X number

返回:

• res number

Log10 返回 x 的十进制对数。其特殊情况与 Log 相同。

x = mixnum.Log10(100)

Output:
2

Log2(x)

参数:

• X number
  返回:
• res number

Log2 返回 x 的二进制对数。特殊情况与 Log 同。

x = mixnum.Log2(256)

Output:
8

Pow10(x)

参数:

• X number

返回:

• res number

Pow10返回$10^n$, 即n的基数为10的指数。

x = mixnum.Pow10(2)

Output:
100

Round(x)

参数:

• X number

返回:

• res number

Round返回最接近的整数，将零舍入一半。

x = mixnum.Round(10.5)

Output:
11

Sin(x)

参数:

• X number

返回:

• res number

Sin 返回弧度参数 x 的正弦值。

x = mixnum.Sin(1)

Output:
0.8414709848078965

Sinh(x)

参数:

• X number

返回:

• res number

Sinh 返回双曲 sinx。

x = mixnum.Sinh(0)

Output:
0

Sqrt(x)

参数:

• X number

返回:

• res number

Sqrt 返回 x 的平方根。

x = mixnum.Sqrt(4)

Output:
2

Tan(x)

参数:

• X number

返回:

• res number

Tan 返回弧度参数 x 的正切值。

x = mixnum.Tan(0)

Output:
0

Tanh(x)

参数:

• X number

返回:

• res number

Tanh返回双曲 tanx。

x = mixnum.Tan(0)

Output:
0

Trunc(x)

参数:

• X number

返回:

• res number

Trunc 返回 x 的整数值。

x = mixnum.Trunc(-1.2345)

Output:
-1

RoundToEven(x)

参数:

• X number

返回:

• res number

RoundToEven 返回最接近的整数，四舍五入时向偶数靠齐。

x = mixnum.RoundToEven(11.2345)

Output:
12

Atan2(x,y)

参数:

• X number
  • Y number

返回:

• res number

Atan2返回y/x的反正切，使用这两个的符号来确定返回值的象限。

x = mixnum.Atan2(0, 0)

Output:
0

Copysign(x,y)

参数:

• X number
  • Y number

返回:

• res number

Copysign返回一个大小为f、符号为of的值。

x = mixnum.Copysign(3.2, -1)

Output:
-3.2

Dim(x,y)

参数:

• X number
  • Y number

返回:

• res number

Dim返回x-y的最大值或0。

x = mixnum.Dim(4, -2)
y = mixnum.Dim(-4, 2)

Output:
6
0

Mod(x,y)

参数:

• X number
  • Y number

返回:

• res number

Mod 返回 x/y 的浮点余数。结果的大小小于 y，其符号与x的符号一致。

x = mixnum.Mod(7, 4)

Output:
3

Modf(x,y)

参数:

• X number

返回:

• a number 整数部分
• b number 小数部分

Modf返回和为f的整数和分数浮点数。这两个值都有与f相同的符号。

x,y = mixnum.Mod(3.14)
x,y = mixnum.Mod(-2.71)

Output:
3, 0.14
-2, -0.71

Pow(x,y)

参数:

• X number
  • Y number

返回:

• res number

Pow 返回 $x^y$, y 的以 x 为底的指数。

x = mixnum.Pow(2, 3)

Output:
8

Remainder(x,y)

参数:

• X number
  • Y number

返回:

• res number

Remainder 返回 x 除以 y 的 IEEE 754 浮点数余数。

x = mixnum.Remainder(80,30)

Output:
-10

Sincos(x,y)

参数:

• X number
  • Y number

返回:

• res number

Sincos 返回 Sin(x)，Cos(x)。

sin,cos = mixnum.Sincos(0)

Output:
0,1

mixstat（统计相关函数库）

Mean(x,w)

参数:

• X{table} 数组，自变量数值
• w{table} 数组，权重

返回:

• res {number}

平均值，计算数据集的加权平均值。

local mixstat = require("mixstat")
x = {1,2,3,4.5}
mean= mixstat.mean(x,{})

Output:
2.625

也可以计算加权平均值，如果权重不为零，则x长度必须等于权重w长度

w = {2, 2, 6, 7}
x = {1,2,3,4.5}
weightedMean = mixstat.Mean(x, w)

Output:
3.264705882352941

Max(x)

参数:

• X{table} 数组，待计算数据

返回:

• res {number}

Max 返回数据中的最大值。

Max =  mixstat.Max(x)

Output:
4.5

Min(x)

参数:

• X{table} 数组，待计算数据

返回:

• res {number}

Min 返回数据中的最小值。

Min =  mixstat.Min(x)

Output:
1

Sum(x)

参数:

• X{table} 数组，待计算数据

返回:

• res {number}

Sum 返回数据中的累加和。

Max =  mixstat.Sum(x)

Output:
10.5

GeometricMean(x,w)

参数:

• X{table} 数组，自变量数值
• w{table} 数组，权重

返回:

• res {number}

仅适用于正数和正权重。如果权重为零，则所有权重都为 1。如果权重不为零，则 x 长度必须等于权重 w 长度。

GeometricMean =  mixstat.GeometricMean(x, w)

Output:
2.970167141053521

ExKurtosis(x,w)

参数:

• X{table} 数组，自变量数值
• w{table} 数组，权重

返回:

• res {number}

ExKurtosis 返回样本的总体过量峰度。峰度定义为平均值的4阶矩除以方差的平方。过量峰度减去 3.0，使得正态分布的过量峰度为零。如果权重为零，则所有权重都为1。如果权重不为零，则 len（x）必须等于 len（权重）。

ExKurtosis = mixstat.ExKurtosis(x, w)

Output:
-0.7944640949068495

HarmonicMean(x,w)

参数:

• X{table} 数组，自变量数值
• w{table} 数组，权重

返回:

• res {number}

HarmonicMean 返回数据集的加权谐波平均值
仅适用于正数和正权重。如果权重为零，则所有权重都为 1。如果权重不为零，则 x 长度必须等于权重 w 长度

HarmonicMean = mixstat.HarmonicMean(x, w)

Output:
2.593220338983051

PopStdDev(x,w)

参数:

• X{table} 数组，自变量数值
• w{table} 数组，权重

返回:

• res {number}

PopStdDev 返回总体标准差，即偏差方差估计的平方根。

PopStdDev = mixstat.PopStdDev(x, w)

Output:
1.2019303965707382

PopVariance(x,w)

参数:

• X{table} 数组，自变量数值
• w{table} 数组，权重

返回:

• res {number}

PopVariance 计算无偏加权样本方差
仅适用于正数和正权重。如果权重为零，则所有权重都为 1。如果权重不为零，则x长度必须等于权重 w 长度。

PopVariance =  mixstat.PopVariance(x, w)

Output:
1.444636678200692

Skew(x,w)

参数:

• X{table} 数组，自变量数值
• w{table} 数组，权重

返回:

• res {number}

Skew 计算样本数据的倾斜度。如果权重为零，则所有权重都为 1。如果权重不为零，则 len（x）必须等于 len（权重）。当权重总和为 1 或更小时，应使用有偏方差估计器。

Skew = mixstat.Skew(x, w)

Output:
-0.5286614709349826

StdDev(x,w)

参数:

• X{table} 数组，自变量数值
• w{table} 数组，权重

返回:

• res {number}

StdDev返回样本标准偏差。如果权重不为零，则x长度必须等于权重w长度。

StdDev = mixstat.StdDev(x, w)
Output:
1.238921494925419

Variance(x,w)

参数:

• X{table} 数组，自变量数值
• w{table} 数组，权重

返回:

• res {number}

方差计算无偏加权样本方差。如果权重不为零，则 x 长度必须等于权重 w 长度。

Variance = mixstat.Variance(x, w)

Output:
1.5349264705882353

CircularMean(x,w)

参数:

• X{table} 数组，自变量数值
• w{table} 数组，权重

返回:

• res {number}

CircularMean 返回数据集的循环平均值。如果权重不为零，则 x 长度必须等于权重 w 长度。

CircularMean = mixstat.CircularMean(x, w)

Output:
-2.8066679185144134

Correlation(x,y,w)

参数:

• X{table} 数组，自变量数值
• Y{table} 数组，因变量数值
• w{table} 数组，权重

返回:

• res {number}

Correlation返回具有给定平均值的 x 和 y 样本之间的加权相关性。

y = {10, 5, 6,-1}
w = {2, 2, 6, 7}
x = {1,2,3,4.5}
Correlation = mixstat.Correlation(x, y, w)

Output:
-0.9378289071812984

Covariance(x,y,w)

参数:

• X{table} 数组，自变量数值
• Y{table} 数组，因变量数值
• w{table} 数组，权重

返回:

• res {number}

协方差返回 x 和 y 样本之间的加权协方差。

Covariance = mixstat.Covariance(x, y, w)

Output:
-4.757352941176471

Kendall(x,y,w)

参数:

• X{table} 数组，自变量数值
• Y{table} 数组，因变量数值
• w{table} 数组，权重

返回:

• res {number}

Kendall 返回加权的 Tau—— x 和 y 样本之间的 Kendall 相关性。Kendall 相关测量一致和不一致数字对的数量。如果指定了权重，则通过$weights[i]*weights[j]$ 对每对进行加权，并将最终和归一化为保持在 -1 和 1 之间。x 和 y 的长度必须相等。如果权重为零，则所有权重都为 1。如果权重不为零，则 len（x）必须等于 len（权重）。

Kendall = mixstat.Kendall(x, y, w)

Output:
-4.757352941176471

LinearRegression(x,y,w,origin)

参数:

• X{table} 数组，自变量数值
• Y{table} 数组，因变量数值
• w{table} 数组，权重
• origin {bool} 是否过零点

返回:

• alpha {number}
• beta {number}

LinearRegression 计算最佳拟合线y=α+β*x,到具有给定权重的x和y中的数据。如果 origin 为真，则回归将被迫通过原点。

具体来说，LinearRegression 计算 α 和 β 的值，使得总残差被最小化。如果原点为真，则α强制为零。
x 和 y 的长度必须相等。如果权重为零，则所有权重都为 1。如果权重不为零，则 len（x）必须等于 len（权重）。

x = {0.00,1.00,2.00,3.00,4.00,5.00,6.00,7.00,8.00,9.00}
y = {1.06,4.01,6.99,9.87,12.92,16.01,18.93,21.99,25.06,28.04}
w = {1.06,1.01,0.99,0.87,0.92,1.01,0.93,0.99,1.06,1.04}
origin = false
alpha, beta = mixstat.LinearRegression(x, y, w, origin)

Output:
0.9807619645190151      3.002405366843155

Bhattacharyya(x,y)

参数:

• X{table} 数组
• y{table} 数组

返回:

• res {number}

Bhattacharyya计算概率分布p和q之间的距离，由下式给出：

p 和 q 的长度必须相等。假设 p 和 q 的总和为1。

x = {0.3}
y = {0.7}
alpha = mixstat.Bhattacharyya(x,y)

Output:
0.7803238741323342

CrossEntropy(x,y)

参数:

• X{table} 数组
• y{table} 数组

返回:

• res {number}

交叉熵计算 p 和 q 中指定的两个分布之间的交叉熵。

res = mixstat.CrossEntropy(x,y)

Output:
0.10700248318161973

Hellinger(x,y)

参数:

• X{table} 数组
• y{table} 数组

返回:

• res {number}

Hellinger 计算概率分布p和q之间的距离，由下式给出：

\sqrt{ 1 - \sum_i \sqrt{p_i q_i} }

p 和 q 的长度必须相等。假设 p 和 q 的总和为 1。

res = mixstat.Hellinger(x,y)

Output:
0.7360315417863666

KullbackLeibler(x,y)

参数:

• X{table} 数组
• y{table} 数组

返回:

• res {number}

Kullback-Leibler计算分布p和q之间的Kullback-Reibler距离。使用自然对数。

sum_i（p_i*log（p_i/q_i））

请注意，Kullback-Leibler距离不是对称的；$KullbackLeibler（p，q）！=KullbackLeibler（q，p）$

res = mixstat.KullbackLeibler(x,y)

Output:
-0.2541893581161611

JensenShannon(x,y)

参数:

• X{table} 数组
• y{table} 数组

返回:

• res {number}

JensenShannon计算分布p和q之间的Jensen Shannon散度。Jensen Shannon散度定义为
$m=0.5*（p+q）$
$JS（p，q）=0.5（KL（p，m）+KL（q，m））$
与Kullback-Leibler 不同，Jensen Shannon 距离是对称的。该值介于 0 和 ln（2）之间。

res = mixstat.JensenShannon(x,y)

Output:
0.04114143925252586

Mode(x,w)

参数:

• X{table} 数组
• w{table} 数组，权重值列表

返回:

• a {number} 数值
• b {number} 个数

Mode返回由x和给定权重指定的数据集中最常见的值。比较值时使用了严格的 number64 等式，因此用户应该小心。如果有几个值是众数，则可以返回其中任何一个值。

w = {1.06,1.01,0.99,0.87,0.92,1.01,0.93,0.99,1.06,1.04}
x = {1.06,4.01,6.99,9.87,12.92,16.01,18.93,21.99,25.06,28.04}
a,b = mixstat.Mode(x, w)

Output:
1.06    1.06

MeanVariance(x,w)

参数:

• X{table} 数组
• w{table} 数组，权重值列表

返回:

• a {number} 均值
• b {number} 方差

MeanVariance计算样本均值和无偏方差，其中均值和方差为
\frac{\sum_i w_i \cdot x_i}{\sum_i w_i}

\frac{\sum_i w_i \cdot (x_i - \text{mean})^2}{\sum_i w_i - 1}

分别地如果权重为零，则所有权重都为1。如果权重不为零，则 len（x）必须等于 len（权重）。当权重总和为 1 或更小时，应使用有偏方差估计器。

a,b = mixstat.MeanVariance(x, w)

Output:
14.55844129554656       86.07248873828283

MeanStdDev(x,w)

参数:

• X{table} 数组
• w{table} 数组，权重值列表

返回:

• a {number} 样本平均值
• b {number} 无偏标准差

MeanStdDev 返回样本平均值和无偏标准差。当权重总和为 1 或更小时，应使用有偏方差估计器。

a,b = mixstat.MeanStdDev(x, w)

Output:
14.55844129554656       9.277526003104644

PopMeanStdDev(x,w)

参数:

• X{table} 数组
• w{table} 数组，权重值列表

返回:

• a {number} 样本平均值
• b {number} 偏差标准差

a,b = mixstat.PopMeanStdDev(x, w)

Output:
14.55844129554656       8.795493072031666

PopMeanStdDev 返回样本平均值和偏差标准差（也称为“总体标准差”）。

PopMeanVariance(x,w)

参数:

• X{table} 数组
• w{table} 数组，权重值列表

返回:

• a {number} 样本平均值
• b {number} 总体方差

PopMeanVariance计算样本均值和有偏方差（也称为“总体方差”），其中均值和方差为

\frac{\sum_i w_i \cdot x_i}{\sum_i w_i}

\frac{\sum_i w_i \cdot (x_i - \text{mean})^2}{\sum_i w_i}

分别地如果权重为零，则所有权重都为 1。如果权重不为零，则 len（x）必须等于 len（权重）。

a,b = mixstat.PopMeanVariance(x, w)

Output:
14.55844129554656       77.36069838015703

RSquared(x,y,w, a, b)

参数:

• X{table} 数组，自变量数值
• Y{table} 数组，因变量数值
• w{table} 数组，权重
• a {number} 样本均值
• b{number} 样本标准差

返回:

• res {number}

RSquared 返回决定系数，其定义为
R^2 = 1 - \frac{\sum_{i} w[i] \times (y[i] - \alpha - \beta \times x[i])^2}{\sum_{i} w[i] \times (y[i] - \text{mean}(y))^2}

用于直线 y=α+β*x 以及给定权重下的 x 和 y 数据。

x 和 y 的长度必须相等。如果权重为 nil，则所有权重均为 1。如果权重不为 nil，则 len(x) 必须等于 len(w)。

x = {0.00 ,1.00 ,2.00 ,3.00 ,4.00 ,5.00 ,6.00 ,7.00 ,8.00 ,9.00  }
w = {1.06,1.01,0.99,0.87,0.92,1.01,0.93,0.99,1.06,1.04}
y = {1.06,4.01,6.99,9.87,12.92,16.01,18.93,21.99,25.06,28.04}
a = 0.9807619645190151      
b = 3.002405366843155
res = mixstat.RSquared(x,y, w,a,b)

Output:
0.9999559572881411

StdErr(x,w)

参数:

• X{number} 样本数据点
• mean {number} 样本均值
• std{number} 样本标准差

返回:

• res {number}

StdErr返回具有给定值的平均值的标准误差。

x = {0.00 ,1.00 ,2.00 ,3.00 ,4.00 ,5.00 ,6.00 ,7.00 ,8.00 ,9.00  }
w = {1.06,1.01,0.99,0.87,0.92,1.01,0.93,0.99,1.06,1.04}
res = mixstat.StdErr(x, w)

Output:
2.9515742169435266

StdScore(x, mean, std )

参数:

• X{number} 样本数据点
• mean {number} 样本均值
• std{number} 样本标准差

返回:

• res {number}

StdScore 返回具有给定平均值和标准偏差的值x的标准分数（也称为 z 分数、z 值），即：

\frac{(x - \text{mean})}{\text{std}}

data = {0.00 ,1.00 ,2.00 ,3.00 ,4.00 ,5.00 ,6.00 ,7.00 ,8.00 ,9.00  }
weights = {1.06,1.01,0.99,0.87,0.92,1.01,0.93,0.99,1.06,1.04}
x=3.002405366843155
mean = mixstat.Mean(data, weights)
std = mixstat.StdDev(data, weights)
res = mixstat.StdScore(x, mean,std)

Output:
-0.4918705519912511

CorrelationMatrix(x,dim,weights)

参数:

• X{table} n×n矩阵
• dim {number} 矩阵维数
• weights{table} 数组，权重列表

返回:

• res {number}

CorrelationMatrix 函数通过双遍算法从数据矩阵 x 中计算相关系数矩阵。

如果 weights 不为空，则计算 x 的加权相关系数。weights 的长度必须等于输入数据矩阵的行数，并且不能包含负元素。dim必须为输入数据矩阵x具有相同的列数的整数。

x = {{1, 2, 3}, {4, 5, 6},{7, 8, 9}}
weights = {1.06,4.01,6.99}
res = mixstat.CorrelationMatrix(x,3,weights)

Output:
{{1 ,1 ,1},{1 ,1 ,1},{1 ,1 ,1}}

CovarianceMatrix(x,dim,weights)

参数:

• X{table} n×n矩阵
• dim {number} 矩阵维数
• weights{table} 数组，权重列表

返回:

• res {number}

CovarianceMatrix函数通过双遍算法从数据矩阵 x 中计算协方差矩阵

x = {{1, 2, 3}, {4, 5, 6},{7, 8, 9}}
weights = {1.06,4.01,6.99}
res = mixstat.CovarianceMatrix(x,3,weights)

Output:
{[1 ,1 ,1},{1 ,1 ,1},{1 ,1 ,1}}

ChiSquare(x,y)

参数:

• X{table} 数组
• Y{table} 数组

返回:

• res {number}

ChiSquare计算观测频率“obs”和预期频率“exp”之间的卡方距离，其公式为：

\sum_i \frac{(obs_i - exp_i)^2}{exp_i}

obs和exp的长度必须相等。

observed = {1.06,1.01,0.99,0.87,0.92,1.01,0.93,0.99,1.06,1.04}
expected = {1.06,4.01,6.99,9.87,12.92,16.01,18.93,21.99,25.06,28.04}
res = mixstat.ChiSquare (observed,expected)

Output:
126.95418731321983

mixmat（矩阵相关函数库）

Mul(x,y)

参数:

• X{table, matrix} m×n矩阵
• Y{table, matrix} n×m矩阵

返回:

• w: table m×m矩阵

local mixmat = require("mixmat")

x = {{4, 0}, {0,4}}
y = {{4, 0, 0},{ 0, 0, 4}}
res = mixmat.Mul(x,y)

Output:
{{16 ,0 ,0},{0 ,0 ,16}}

Mul取a和b的矩阵乘积，如果a中的列数不等于b中的行数，Mul将发生错误。

Pow(x,n)

参数:

• X{table, matrix} m×n矩阵

返回:

• w: table m×n矩阵

res = mixmat.Pow(x,2)

Output:
{{16 ,0},{0 16}}

Pow 计算矩阵 a 的 n 次幂，如果 n 为负数或者 a 不是方阵，Pow 将发生错误。

Sub(x,y)

参数:

• X{table, matrix} m×n矩阵
• Y{table, matrix} m×n矩阵

返回:

• w: table m×n矩阵

res = mixmat.Sub(y,y)

Output:
{{0 ,0 ,0},{0 ,0 ,0}}

Sub从a中减去矩阵b，如果两个矩阵的形状不相同，Sub将发生错误。

Eigenvalues(x)

参数:

• X{table, matrix} n×n矩阵
• kind ‘left’或者’right’，要得到左或者右特征矩阵

返回:

• w:（…，M）table

x = {{1, -1}, {1, 1}}
res = mixmat.Eigenvalues(x)

Output:
{{1, 1}, {1, -1}}

特征值是一种用于创建和使用稠密矩阵的特征值分解的类型。结果返回的是特征值。

Eigenvectors(x ,kind)

参数:

• X{table, matrix} n×n矩阵
• kind ‘left’或者’right’，要得到左或者右特征矩阵

返回:

• w:（…，M,M）数组

  得到的数组将是复数类型，计算出的特征向量会被归一化，使得其欧几里得范数等于1，并且具有最大的实部组件。

kind为’left’或者’right’，右特征值/特征向量组合定义为：

A * x_r = λ * x_r

其中 x_r 是称为特征向量的列向量，λ 是对应的特征值。类似地，左特征值/特征向量组合定义为：

x_l * A = λ * x_l

对于两种分解，特征值是相同的，但特征向量不同。

通常，特征向量指的是右特征向量。kind 参数指定了要计算哪些特征向量（如果有的话）。如果输入矩阵不是方阵，Eigenvectors 会发生错误。

x = {{1, -1}, {1, 1}}
res = mixmat.Eigenvectors(x,'left')
res = mixmat.Eigenvectors(x,'right')
x ={{1,0},{0,-1}}
res = mixmat.Eigenvectors(x,'left')

Output:
{{-0.7071067811865475+0i} {-0.7071067811865475-0i} {0+0.7071067811865475i} {0-0.7071067811865475i}}

{{0.7071067811865475+0i} {0.7071067811865475-0i} {0-0.7071067811865475i} {0+0.7071067811865475i}}

{{1+0i} {0+0i} {0+0i} {1+0i}}

mixopt（优化相关函数库）

结果类型

Status 状态

状态表示优化的状态。状态有可能变化，程序不应依赖于状态底层数值的恒定不变。

状态量有以下可能：

• NotTerminated - 未终止
• Success - 成功
• FunctionThreshold - 函数阈值
• FunctionConvergence - 函数收敛
• GradientThreshold - 梯度阈值
• StepConvergence - 步长收敛
• FunctionNegativeInfinity - 函数负无穷
• MethodConverge - 方法收敛
• Failure - 失败
• IterationLimit - 迭代限制
• RuntimeLimit - 运行时间限制
• FunctionEvaluationLimit - 函数评估限制
• GradientEvaluationLimit - 梯度评估限制
• HessianEvaluationLimit - 海森评估限制

Stats 统计量

包含运行的统计信息。

• MajorIterations number 主要迭代总数
• FuncEvaluations number Func的评价次数
• GradEvaluations number Grad的评估次数
• HessEvaluations number Hess的评估次数
• Runtime number 优化的总运行时间

优化函数

Minimize(data)

参数:

• data{table} 数组 ，待优化数据

返回:

• Status ：string， 状态代表优化的状态。
• F：number ，F是在X处对函数求值的结果。
• X：{table} ,数组，X是位置的函数输入。
• Stats ：{table} ,数组，包含运行的统计信息。

最小化使用优化器来搜索函数的最小值。通过将函数乘以 -1，可以将最大化问题转化为最小化问题。

local mixopt = require("mixopt")
data = {1.06,4.01,6.99,9.87,12.92,16.01,18.93,21.99,25.06,28.04}
Status,F,X,Stats = mixopt.Minimize (data)

Output:
GradientThreshold
9.071160852942991e-28
{0.9999999999999999,0.9999999999999999,1.0000000000000002,1.0000000000000004,1.0000000000000007,1.0000000000000016,1.0000000000000033,1.0000000000000069,1.000000000000015,1.0000000000000322}
{"MajorIterations": 99,"FuncEvaluations": 114,"GradEvaluations": 104,"HessEvaluations": 0,"Runtime": 1498798}

GradientDescent(data)

参数:

• data{table} 数组 ，待优化数据

返回:

• Status ：string， 状态代表优化的状态。
• F：number ，F是在X处对函数求值的结果。
• X：{table} ,数组，X是位置的函数输入。
• Stats ：{table} ,数组，包含运行的统计信息。

GradientDescent 实现了最速下降优化方法，该方法沿着负梯度方向进行连续步骤。

data = {1.06,4.01,6.99,9.87,12.92,16.01,18.93,21.99,25.06,28.04}
Status,F,X,Stats = mixopt.GradientDescent(data)

Output:
FunctionConvergence
8.085550719660137e-10
{1.0000000908917197, 1.0000001969713455, 1.0000003666122044, 1.0000007739252663, 1.0000015059764993, 1.0000030675644895, 1.0000061047366293, 1.0000122789410986, 1.0000245911560919, 1.0000493207342906}
{"MajorIterations" : 199822,"FuncEvaluations" : 688823,"GradEvaluations" : 199822,"HessEvaluations" : 0,"Runtime" : 3165519092}

BFGS(data, GradStopThreshold)

参数:

• data:{table} 数组 ，待优化数据
• GradStopThreshold : number，可不填。GradStopThreshold 设置了梯度范数过小时的停止阈值。如果 GradStopThreshold 设置为 0，则默认值为 1e-12；如果设置为 NaN，则该设置将不被使用。

返回:

• Status ：string， 状态代表优化的状态。
• F：number ，F是在X处对函数求值的结果。
• X：{table} ,数组，X是位置的函数输入。
• Stats ：{table} ,数组，包含运行的统计信息。

BFGS 实现了 Broyden–Fletcher–Goldfarb–Shanno 优化方法。它是一种拟牛顿法，通过对目标函数逆海森矩阵的估计进行连续的一阶更新。当接近局部最小值时，它表现出超线性收敛。相对于输入维度，其内存成本为 O(n^2)。

data = {1.2, 1.0,0.7}
Status,F,X,Stats = mixopt.BFGS(data)
---------------------
Status,F,X,Stats = mixopt.BFGS(data,0.5)

Output:
GradientThreshold
1.829787521563425e-28
{0.9999999999999997, 1.0000000000000007, 1.000000000000001}
{"MajorIterations":23, "FuncEvaluations":24, "GradEvaluations":23, "HessEvaluations":0, "Runtime":475405}
-----------------
GradientThreshold
1.2936366379310135e-06
{0.9995718942286979, 0.9992131938638286, 0.998415994145926}
{}"MajorIterations":18, "FuncEvaluations":19, "GradEvaluations":18, "HessEvaluations":0, "Runtime":644084}

LBFGS(data, GradStopThreshold)

参数:

• data:{table} 数组 ，待优化数据
• GradStopThreshold : number，可不填。GradStopThreshold 设置了梯度范数过小时的停止阈值。如果 GradStopThreshold 设置为 0，则默认值为 1e-12；如果设置为 NaN，则该设置将不被使用。
• Store : number，可不填。Store是有限内存存储的大小。如果Store为0，则默认为15。

返回:

• Status ：string， 状态代表优化的状态。
• F：number ，F是在X处对函数求值的结果。
• X：{table} ,数组，X是位置的函数输入。
• Stats ：{table} ,数组，包含运行的统计信息。

LBFGS 实现了基于梯度的无约束最小化问题的有限内存 BFGS 方法。

它隐式地存储了从最近 Store 次迭代中得到的逆 Hessian 近似 H 的修改版本，而标准的 BFGS 方法则是直接将 H 作为稠密矩阵进行存储和操作。因此，对于大型问题，LBFGS 比 BFGS 更合适，因为 LBFGS 的成本随 Store * dim 的数量级变化，而 BFGS 的成本则随 dim^2 的数量级变化。LBFGS 的“遗忘”特性也可能使其在处理 Hessian 在空间上快速变化的函数时比 BFGS 表现更好。

data = {1.2, 1.0 ,0.7}
Status,F,X,Stats = mixopt.LBFGS(data)
-------------------
Status,F,X,Stats = mixopt.LBFGS(data,0.05,10)

Output:
GradientThreshold
2.822642926493933e-30
0.9999999999999998, 0.9999999999999994, 0.999999999999999
"MajorIterations":24, "FuncEvaluations":26, "GradEvaluations":25, "HessEvaluations":0, "Runtime":337976
-------------------------------
GradientThreshold
1.6099830449217552e-06
{1.0004099390453693, 1.0007743908466982, 1.0016289936382687}
{"MajorIterations":17, "FuncEvaluations":19, "GradEvaluations":18, "HessEvaluations":0, "Runtime":354000}

CG(data, GradStopThreshold,IterationRestartFactor,AngleRestartThreshold)

参数:

• data:{table} 数组 ，待优化数据
• GradStopThreshold : number，可不填。GradStopThreshold 设置了梯度范数过小时的停止阈值。如果 GradStopThreshold 设置为 0，则默认值为 1e-12；如果设置为 NaN，则该设置将不被使用。
• IterationRestartFactor : number，可不填。IterationRestartFactor 决定了根据问题维度进行重启的频率。每当未发生重启的情况下，经过 ceil(IterationRestartFactor(问题维度)) 次迭代，就会采用负梯度方向。对于中等规模和大规模问题，IterationRestartFactor 应设为 1；对于低维度问题，应选择一个较大的值。请注意，如果 ceil 函数返回 1，则共轭梯度法（CG）将与梯度下降法相同。如果 IterationRestartFactor 为 0，它将被设置为 6。如果 IterationRestartFactor 为负数，则共轭梯度法将引发错误。
• AngleRestartThreshold : number，可不填。AngleRestartThreshold 设置了重启的阈值角度。如果两个连续梯度之间的夹角的余弦值小于或等于 AngleRestartThreshold，即$$ ∇f_k·∇f_{k+1} / (|∇f_k| |∇f_{k+1}|) <= AngleRestartThreshold$$，则算法会进行重启。AngleRestartThreshold 的值越接近 -1（连续梯度完全相反的方向），重启的次数往往会越少。如果 AngleRestartThreshold 为 0，它将被设置为 -0.9。如果 AngleRestartThreshold 不在区间 [-1, 0] 内，共轭梯度法将引发错误。

返回:

• Status ：string， 状态代表优化的状态。
• F：number ，F是在X处对函数求值的结果。
• X：{table} ,数组，X是位置的函数输入。
• Stats ：{table} ,数组，包含运行的统计信息。

CG 实现了用于解决非线性无约束优化问题的非线性共轭梯度法。它是一种线搜索方法，根据公式生成搜索方向 d_k：

d_{k+1} = -\nabla f_{k+1} + \beta_k \cdot d_k, \quad d_0 = -\nabla f_0

共轭梯度法的不同变体在选择参数 β_k 上有所差异。共轭梯度法通常需要的函数评估次数少于梯度下降法，且无需存储矩阵，但 L-BFGS 通常更为高效。

CG 实现了一种重启策略，在以下任一条件成立时，采用最速下降方向（即 d_{k+1} = -∇f_{k+1}）：

• 已经过一定数量的迭代而没有重启。这个数量可通过 IterationRestartFactor 控制，如果等于 0，则根据问题维度设置为一个合理的默认值。
• 两个连续迭代$$ ∇f_k$$ 和 $$∇f_{k+1}$$ 的梯度之间的角度过大。
• 方向 $$ d_{k+1} $$不是下降方向。
• CGVariant.Beta 返回的$$ β_k$$ 等于零。

CG 的线搜索必须在每次迭代时产生满足强 Wolfe 条件的步长，否则生成的搜索方向可能不是下降方向。与牛顿法之类的方法相比，线搜索应该更为严格，这可以通过将强 Wolfe 条件中的梯度常数设置为较小值来实现。

另请参阅 William Hager 和 Hongchao Zhang 撰写的《非线性共轭梯度法综述》，发表于 Pacific Journal of Optimization, 2 (2006)，第 35-58 页，以及其中的参考文献。

data = {1.2, 1.0 ,0.7}
Status,F,X,Stats = mixopt.CG(data)
------------------------------
Status,F,X,Stats = mixopt.CG(data,0.001,20,0)

Output:
GradientThreshold
2.982880297866951e-29
1.0000000000000024, 1.0000000000000049, 1.0000000000000098
"MajorIterations":44, "FuncEvaluations":108, "GradEvaluations":108, "HessEvaluations":0, "Runtime":547330
------------------------------
GradientThreshold
2.2412051449504442e-07
{0.9997884599069785, 0.9995765136355318, 0.9991528861577788}
{"MajorIterations":64, "FuncEvaluations":130, "GradEvaluations":130, "HessEvaluations":0, "Runtime":653743}

CmaEsChol(data,InitStepSize,Population,StopLogDet)

参数:

• data:{table} 数组 ，待优化数据
• InitStepSize: number，可不填。初始化步长设置算法的步长大小。如果InitStepSize为0，则使用默认值$$4 + math.Floor(3*math.Log(float64(dim)))$$。InitStepSize不能是负数，否则CmaEsChol将发生panic（异常）。
• Population: number，可不填。Population设置算法的种群大小。如果Population为0，则使用默认值$$4 + math.Floor(3*math.Log(float64(dim)))$$。Population不能是负数，否则CmaEsChol将发生panic（异常）。
• StopLogDet: number，可不填。StopLogDet设置优化停止的阈值，如果分布变得过于集中则停止优化。对数行列式是衡量正态分布（对数）“体积”的指标，当其过小时，样本几乎相同。如果协方差矩阵的对数行列式小于StopLogDet，则优化运行结束。如果StopLogDet为0，则使用默认值$$dim*log(1e-16)$$。如果StopLogDet为NaN，则不使用停止准则，尽管这可能导致算法中的数值不稳定。

返回:

• Status ：string， 状态代表优化的状态。
• F：number ，F是在X处对函数求值的结果。
• X：{table} ,数组，X是位置的函数输入。
• Stats ：{table} ,数组，包含运行的统计信息。

CmaEsChol实现了基于Cholesky分解的协方差矩阵自适应进化策略（CMA-ES）。完整的算法描述在以下文献中：

Krause, Oswin, Dídac Rodríguez Arbonès, and Christian Igel. “CMA-ES with optimal covariance update and storage complexity.” Neural Information Processing Systems Advances. 2016.

https://papers.nips.cc/paper/6457-cma-es-with-optimal-covariance-update-and-storage-complexity.pdf

CMA-ES是一种全局优化方法，它逐步调整样本群体。CMA-ES结合了局部优化和全局优化的技术。具体来说，CMA-ES算法使用初始多元正态分布来生成输入位置的群体。使用具有最低函数值的输入位置来更新正态分布的参数，生成新的输入位置群体，并重复此过程直到收敛。初始采样分布将具有由初始x位置指定的均值和由InitCholesky字段指定的协方差。

随着正态分布根据最佳样本逐步更新，分布的均值可能会以类似梯度下降的方式更新，随后协方差会缩小。建议多次运行该算法（使用不同的InitMean），以更好地找到全局最小值。

CMA-ES-Chol算法与标准CMA-ES算法的不同之处在于它直接更新正态分布的Cholesky分解。这改变了运行时间，从O(dimension^3) 变为O(dimension^2*population)。多元正态分布的进化将与基线CMA-ES算法相似，但协方差更新方程并不相同。

data = {1.2, 1.0, 0.7}
Status,F,X,Stats = mixopt.CmaEsChol(data)
------------------
Status,F,X,Stats = mixopt.CmaEsChol(data,0,0,0)

Output:
FunctionConvergence
0.08842634770784413
{0.9364037337997013, 0.8518652410832522, 0.7254650991698176}
{"MajorIterations":360, "FuncEvaluations":2520, "GradEvaluations":0, "HessEvaluations":0, "Runtime":27660176}
----------------------
FunctionConvergence
0.08842634770784413
{0.9364037337997013, 0.8518652410832522, 0.7254650991698176}
{"MajorIterations":360, "FuncEvaluations":2520, "GradEvaluations":0, "HessEvaluations":0, "Runtime":28183277}

NelderMead(data,InitialVertices,InitialValues,Reflection,Expansion,Contraction,Shrink,SimplexSize)

参数:

• data:{table} 数组 ，待优化数据
• InitialVertices : number，可不填。初始顶点
• InitialValues : number，可不填。初始值
• Reflection : number，可不填。反射， 反射参数（大于0）
• Expansion : number，可不填。扩张，扩张参数（大于1）
• Contraction : number，可不填。收缩，收缩参数（大于0，小于1）
• Shrink : number，可不填。缩减， 缩减参数（大于0，小于1）
• SimplexSize : number，可不填。自动构建的初始单纯形的大小

返回:

• Status ：string， 状态代表优化的状态。
• F：number ，F是在X处对函数求值的结果。
• X：{table} ,数组，X是位置的函数输入。
• Stats ：{table} ,数组，包含运行的统计信息。

Nelder-Mead 是一种无梯度非线性优化的单纯形算法的实现（不要与用于线性规划的 Danzig 单纯形算法混淆）。该实现遵循以下算法描述：

http://epubs.siam.org/doi/pdf/10.1137/S1052623496303470

如果提供了初始单纯形，则使用它并忽略 initLoc。如果 InitialVertices 和 InitialValues 均为 nil，则会自动生成一个初始单纯形，以初始位置作为一个顶点，每个额外的顶点在某一维度上距离 SimplexSize 远。

如果单纯形更新参数（如 Reflection 等）为零，则它们将根据维度的建议自动设置。

data = {1.2, 1.0,0.7}
Status,F,X,Stats = mixopt.NelderMead(data)
---------------------------------------
initialVertices = {{0, 0,0},{0, 0,0},{0, 0,0},{0, 0, 0}}
initialValues = {1, 0,0, 0}
Status,F,X,Stats = mixopt.NelderMead(data,0,0,0)

Output:
FunctionConvergence
6.555146804453785e-25
{0.9999999999996712, 0.9999999999993155, 0.9999999999986225}
{"MajorIterations":224, "FuncEvaluations":410, "GradEvaluations":0, "HessEvaluations":0, "Runtime":1879400}
---------------------------------------
FunctionConvergence
0
{4, 5, 6}
{"MajorIterations":102, "FuncEvaluations":486, "GradEvaluations":0, "HessEvaluations":0, "Runtime":1419329}