matrix4cj 库

介绍

matrix4cj 是一个基本线性代数包，用于构造和操作真实密集矩阵的库。

1 构造和操作真实密集矩阵

需求来源：三方库 用户：仓颉开发者 场景：构造和操作真实密集矩阵 目标：实现构造和操作真实密集矩阵 验收标准：正确构造和操作真实密集矩阵

1.1 主要接口

/**
 * 矩阵存储顺序
 */
public enum StorageOrder {
    /** Column-major order */
    ColumnMajor |

    /** Row-major order */
    RowMajor
}

/**
 * 运算轴向
 */
public enum Axis {
    /** Row axis */
    Row |

    /** Column axis */
    Column
}

public class Matrix {

    /*
     * 矩阵行数
     */
    public prop rowNum: Int64

    /*
     * 矩阵列数
     */
    public prop colNum: Int64

    /*
     * 矩阵存储顺序
     */
    public prop storageOrder: StorageOrder

    /*
     * 内部存储的二维数组
     */
    internal prop data: Array<Float64>

    /*
     * 使用默认值value构造一个 m 乘 n 的常量矩阵，m,n 非法值时抛 NegativeArraySizeException
     * 参数 m - 行数
     * 参数 n - 列数
     * 参数 value - 用这个值填充矩阵
     */
    public init(m: Int64, n: Int64, value!: Float64 = 0.0)

    /*
     * 使用给定二维数组按照给定内存顺序构造矩阵，数组不符合矩阵格式抛 IllegalArgumentException
     * 参数 data - 二维 Float64 数组
     * 参数 order - 矩阵存储顺序 (默认 RowMajor) 
     */
    public init(data: Array<Array<Float64>>, order!: StorageOrder = StorageOrder.RowMajor)

    /*
     * 使用给定一维数组按照给定内存顺序构造矩阵，数组不符合矩阵格式抛 IllegalArgumentException
     * 参数 data - 一维 Float64 数组
     * 参数 rowNum - 矩阵行数
     * 参数 colNum - 矩阵列数 (默认 -1，将会通过rowNum计算)
     * 参数 order - 矩阵存储顺序 (默认 RowMajor)
     */
    public init(data: Array<Float64>, rowNum!: Int64, colNum!: Int64 = -1, order!: StorageOrder = StorageOrder.RowMajor)

    /*
     * 使用给定一维数组按照给定内存顺序 *不经过clone* 构造矩阵， 主要被用来Lib内部构造矩阵使用，数组不符合矩阵格式抛 IllegalArgumentException
     * 参数 data - 一维 Float64 数组
     * 参数 rowNum - 矩阵行数
     * 参数 colNum - 矩阵列数 (默认 -1，将会通过rowNum计算)
     * 参数 order - 矩阵存储顺序 (默认 RowMajor)
     * 参数 withoutClone - 不克隆数据（仅用来区分重载，这个变量不会在函数内被使用）
     */
    internal init(data: Array<Float64>, rowNum: Int64, colNum: Int64, order: StorageOrder, withoutClone!: Bool)

    /*
     * Matrix的拷贝构造函数
     * 参数 other - 其他矩阵
     * 返回值 Matrix - 复制的新矩阵
     */
    public init(other: Matrix)

    /*
     * 复制矩阵
     * 返回值 Matrix - 复制的新矩阵
     */
    public func clone(): Matrix

    /*
     * 获取内部一维数组的打包副本
     * 参数 order - 矩阵存储顺序 (默认 RowMajor)
     * 返回值 Array<Float64> - 内部一维数组
     */
    public func getOneDimensionalArray(order!: StorageOrder = StorageOrder.RowMajor): Array<Float64>

    /*
     * 比较两个矩阵是否相等
     * 参数 other - 其他矩阵
     * 返回值 Bool - 是否相等
     */
    public operator func == (other: Matrix): Bool

    /*
     * 比较两个矩阵是否不相等
     * 参数 other - 其他矩阵
     * 返回值 Bool - 是否不相等
     */
    public operator func != (other: Matrix): Bool

    /*
     * 获取单个元素，元素不存在抛 IndexOutOfBoundsException
     * 参数 row - 行索引
     * 参数 col - 列索引
     * 返回值 Float64 - 元素值
     */
    public func get(row: Int64, col: Int64): Float64
    public operator func [] (row: Int64, col: Int64): Float64

    /*
     * 设置单一元素， 索引对应的元素不存在时抛 IndexOutOfBoundsException
     * 参数 row - 行索引
     * 参数 col - 列索引
     * 参数 value - 元素值
     */
    public func set(row: Int64, col: Int64, value: Float64): Unit
    public operator func [] (row: Int64, col: Int64, value!: Float64): Unit

    /*
     * 获取指定行的元素数组的副本，行索引不存在抛 IndexOutOfBoundsException
     * 参数 row - 行索引
     * 参数 colRange - 列索引范围，步长为1
     * 返回值 Array<Float64> - 元素数组
     */
    public operator func [] (row: Int64, colRange: Range<Int64>): Array<Float64>

    /*
     * 设置指定行的元素数组，行索引不存在抛 IndexOutOfBoundsException
     * 参数 row - 行索引
     * 参数 colRange - 列索引范围，步长为1
     * 参数 value - 元素数组
     */
    public operator func [] (row: Int64, colRange: Range<Int64>, value!: Array<Float64>): Unit

    /*
     * 获取指定列的元素数组的副本，列索引不存在抛 IndexOutOfBoundsException
     * 参数 rowRange - 行索引范围，步长为1
     * 参数 col - 列索引
     * 返回值 Array<Float64> - 元素数组
     */
    public operator func [] (rowRange: Range<Int64>, col: Int64): Array<Float64>

    /*
     * 设置指定列的元素数组，列索引不存在抛 IndexOutOfBoundsException
     * 参数 rowRange - 行索引范围，步长为1
     * 参数 col - 列索引
     * 参数 value - 元素数组
     */
    public operator func [] (rowRange: Range<Int64>, col: Int64, value!: Array<Float64>): Unit

    /*
     * 获取子矩阵的副本
     * 参数 rowRange - 行索引范围，步长为1
     * 参数 colRange - 列索引范围，步长为1
     * 返回值 Matrix - 子矩阵
     */
    public operator func [] (rowRange: Range<Int64>, colRange: Range<Int64>): Matrix

    /*
     * 设置子矩阵，行列索引大于等于当前矩阵的行列值抛 IndexOutOfBoundsException
     * 参数 rowRange - 行索引范围，步长为1
     * 参数 colRange - 列索引范围，步长为1
     * 参数 value - 子矩阵
     */
    public operator func [] (rowRange: Range<Int64>, colRange: Range<Int64>, value!: Matrix): Unit

    /*
     * 挑选指定行的副本构成新的子矩阵
     * 参数 rowIndices - 行索引数组
     * 参数 colRange - 列索引范围，步长为1
     * 返回值 Matrix - 子矩阵
     * 示例：可以使用本方法将矩阵的偶数行挑选出来构成新的子矩阵
     */
    public operator func [] (rowIndices: Array<Int64>, colRange: Range<Int64>): Matrix

    /*
     * 将指定行的值赋值为给定矩阵的对应行
     * 参数 rowIndices - 行索引数组
     * 参数 colRange - 列索引范围，步长为1
     * 参数 value - 子矩阵
     * 示例：可以使用本方法批量修改矩阵的不同行的值
     * 注意：行索引数组的长度必须与 value 矩阵的行数相同
     */
    public operator func [] (rowIndices: Array<Int64>, colRange: Range<Int64>, value!: Matrix): Unit

    /*
     * 挑选指定列的副本构成新的子矩阵
     * 参数 rowRange - 行索引范围，步长为1
     * 参数 colIndices - 列索引数组
     * 返回值 Matrix - 子矩阵
     * 示例：可以使用本方法将矩阵的偶数列挑选出来构成新的子矩阵
     */
    public operator func [] (rowRange: Range<Int64>, colIndices: Array<Int64>): Matrix

    /*
     * 将指定列的值赋值为给定矩阵的对应列
     * 参数 rowRange - 行索引范围，步长为1
     * 参数 colIndices - 列索引数组
     * 参数 value - 子矩阵
     * 示例：可以使用本方法批量修改矩阵的不同行的值
     * 注意：行索引范围的长度必须与 value 矩阵的行数相同
     */
    public operator func [] (rowRange: Range<Int64>, colIndices: Array<Int64>, value!: Matrix): Unit

    /*
     * 挑选指定行和列的副本构成新的子矩阵
     * 参数 rowIndices - 行索引数组
     * 参数 colIndices - 列索引数组
     * 返回值 Matrix - 子矩阵
     * 示例：可以使用本方法将矩阵的偶数行和偶数列挑选出来构成新的子矩阵
     */
    public operator func [] (rowIndices: Array<Int64>, colIndices: Array<Int64>): Matrix

    /*
     * 将指定行和列的值赋值为给定矩阵的对应行和列
     * 参数 rowIndices - 行索引数组
     * 参数 colIndices - 列索引数组
     * 参数 value - 子矩阵
     * 示例：可以使用本方法批量修改矩阵的不同行和列的值
     * 注意：行索引数组的长度必须与 value 矩阵的行数相同，列索引数组的长度必须与 value 矩阵的列数相同
     */
    public operator func [] (rowIndices: Array<Int64>, colIndices: Array<Int64>, value!: Matrix): Unit

    /*
     * 将两个矩阵沿指定轴连接
     * 参数 other - 要连接的矩阵
     * 参数 axis - 连接轴，Row 表示行连接，Column 表示列连接
     * 返回值 Matrix - 连接后的矩阵
     * 注意：连接的两个矩阵在非连接轴上的维度必须相同
     */
    public func concat(other: Matrix, axis!: Axis): Matrix

    /*
     * 矩阵转置
     * 参数 fast - 当fast为true时，仅仅修改矩阵的存储顺序，而不实际转置数据
     *             当fast为false时，实际发生内存的拷贝
     * 返回值 Matrix - 运算后矩阵
     */
    public func transpose(fast!: Bool = false): Matrix

    /*
     * 矩阵的快速转置
     * 仅仅修改矩阵的存储顺序，而不实际发生内存的拷贝
     * 返回值 Matrix - 运算后矩阵
     */
    public prop T: Matrix

    /*
     * 矩阵的逆或伪逆
     * 如果矩阵是方阵，则返回逆矩阵，否则返回伪逆矩阵
     * 如果矩阵是奇异矩阵，则抛 IllegalArgumentException 异常
     * 返回值 Matrix - 逆矩阵或伪逆矩阵
     */
    public func inverse(): Matrix
    public prop I: Matrix

    /*
     * 矩阵取反
     * 返回值 Matrix - 运算后矩阵
     */
    public operator func - (): Matrix

    /*
     * 矩阵加法运算
     * 不符合矩阵加法规则抛 IllegalArgumentException
     * 参数 other - 要相加的矩阵
     * 返回值 Matrix - 运算后矩阵
     */
    public operator func + (other: Matrix): Matrix

    /*
     * 矩阵加法运算
     * 参数 value - 要相加的标量
     * 返回值 Matrix - 运算后矩阵
     */
    public operator func + (value: Float64): Matrix

    /*
     * 矩阵减法运算
     * 不符合矩阵减法规则抛 IllegalArgumentException
     * 参数 other - 要相减的矩阵
     * 返回值 Matrix - 运算后矩阵
     */
    public operator func - (other: Matrix): Matrix

    /*
     * 矩阵减法运算
     * 参数 value - 要相减的标量
     * 返回值 Matrix - 运算后矩阵
     */
    public operator func - (value: Float64): Matrix

    /*
     * 矩阵乘法运算
     * 参数 s: 要相乘的标量
     * 返回值 Matrix - 运算后矩阵
     */
    public operator func * (s: Float64): Matrix

    /*
     * 矩阵乘法运算
     * 不符合矩阵乘法规则抛 IllegalArgumentException
     * 参数 other - 要相乘的矩阵
     * 返回值 Matrix - 运算后矩阵
     */
    public operator func * (other: Matrix): Matrix
    public func matMul(other: Matrix): Matrix

    /*
     * 获取给定大小的单位矩阵
     * 参数 rowNum - 矩阵行数
     * 参数 colNum - 矩阵列数
     * 返回值 Matrix - rowNum * colNum 的单位矩阵
     */
    public static func Identity(rowNum: Int64, colNum: Int64): Matrix

    /*
     * 获取单位矩阵
     * 返回值 Matrix - 单位矩阵
     */
    public func identity(): Matrix

    /*
     * 用随机元素生成矩阵
     * 参数 rowNum - 矩阵行数
     * 参数 colNum - 矩阵列数
     * 返回值 Matrix - rowNum * colNum 的随机数矩阵
     */
    public static func Random(rowNum: Int64, colNum: Int64): Matrix

    /*
     * 用随机元素生成矩阵
     * 返回值 Matrix - m * n 的随机数矩阵
     */
    public func random(): Matrix

    /*
     * 矩阵L1范数计算
     * 返回值 Float64 - 运算值
     */
    public func normL1(): Float64

    /*
     * 矩阵L2范数计算
     * 返回值 Float64 - 运算值
     */
    public func normL2(): Float64 

    /*
     * 矩阵L∞范数计算
     * 返回值 Float64 - 运算值
     */
    public func normInf(): Float64

    /*
     * 矩阵F范数计算
     * 返回值 Float64 - 运算值
     */
    public func normFrobenius(): Float64

    /*
     * 矩阵LU分解
     * 返回值 LUDecomposition - LU分解后的LUDecomposition
     */
    public func lu(): LUDecomposition

    /*
     * 矩阵QR分解
     * 返回值 QRDecomposition - QR分解后的QRDecomposition
     */
    public func qr(): QRDecomposition

    /*
     * 矩阵乔里斯基分解
     * 返回值 CholeskyDecomposition - 乔里斯基分解后的CholeskyDecomposition
     */
    public func chol(): CholeskyDecomposition

    /*
     * 矩阵奇异值分解
     * 返回值 SingularValueDecomposition - 奇异值分解后的SingularValueDecomposition
     */
    public func svd(): SingularValueDecomposition

    /*
     * 矩阵特征值分解
     * 返回值 EigenvalueDecomposition - 特征值分解后的EigenvalueDecomposition
     */
    public func eig(): EigenvalueDecomposition

    /*
     * 求解 A*X = B ，A,B矩阵不符合矩阵计算规则抛 IllegalArgumentException
     * 参数 B - 矩阵
     * 返回值 Matrix - X 矩阵
     */
    public func solve(B: Matrix): Matrix

    /*
     * 求解 X*A = B，也就是 A'*X' = B'，A,B矩阵不符合矩阵计算规则抛 IllegalArgumentException
     * 参数 B - 矩阵
     * 返回值 Matrix - X 矩阵
     */
    public func solveTranspose(B: Matrix): Matrix

    /*
     * 矩阵行列式
     * 返回值 Float64 - 矩阵行列式的值
     */
    public func det(): Float64

    /*
     * 矩阵的秩
     * 返回值 Int64 - 矩阵的秩
     */
    public func rank(): Int64

    /*
     * 矩阵条件数
     * 返回值 Float64 - 矩阵条件数
     */
    public func cond(): Float64

    /*
     * 矩阵的迹
     * 返回值 Float64 - 矩阵的迹
     */
    public func trace(): Float64

    /*
     * 获取矩阵对象的elementWise包装器
     * 包装器中支持矩阵的按元素运算
     * 返回值 ElementWiseWapper<Matrix> - 矩阵的elementWise包装器
     */
    public func elementWise(): ElementWiseWapper<Matrix>

    /*
     * 矩阵的按元素乘法
     * 参数 other - 要相乘的矩阵的elementWise包装器
     * 返回值 Matrix - 运算后矩阵
     */
    public operator func *(other: ElementWiseWapper<Matrix>): Matrix 

    /*
     * 矩阵的按元素除法
     * 参数 other - 要相除的矩阵的elementWise包装器
     * 返回值 Matrix - 运算后矩阵
     */
    public operator func /(other: ElementWiseWapper<Matrix>): Matrix
}

public class Maths {
    /*
     * 计算 sqrt(a^2 + b^2)
     * 参数 a - 数字a
     * 参数 b - 数字a
     * 返回值 Float64 - 运算结果
     */
    public static func hypot(a: Float64, b: Float64): Float64
}

public class CholeskyDecomposition {
    /*
     * 构造 CholeskyDecomposition 实例
     * 参数 Arg - 矩阵
     */
    public init(Arg: Matrix)

    /*
     * 矩阵是否对称且正定
     * 返回值 Bool - 判断结果
     */
    public func isSPD(): Bool

    /*
     * 获取下三角矩阵
     * 返回值 Matrix - 下三角矩阵
     */
    public func getL(): Matrix

    /*
     * 求解 A*X = B，A 为当前矩阵， B 为入参矩阵， A 要为对称正定矩阵，否则抛 Matrix4cjException 异常
     * 参数 B - 矩阵
     * 返回值 Matrix - X 矩阵
     */
    public func solve(B: Matrix): Matrix 
}

public class EigenvalueDecomposition {
    /*
     * 初始化矩阵
     * 参数 Arg - 矩阵
     */
    public init(Arg: Matrix)

    /*
     * 返回特征向量矩阵
     * 返回值 Matrix - 矩阵
     */
    public func getV(): Matrix

    /*
     * 返回特征值的实部
     * 返回值 Array<Float64>  - 实部值
     */
    public func getRealEigenvalues(): Array<Float64> 

    /*
     * 返回特征值的虚部
     * 返回值 Array<Float64>  - 虚部值
     */
    public func getImagEigenvalues(): Array<Float64>

    /*
     * 返回对角线特征值矩阵 D
     * 返回值 Matrix  - 矩阵
     */
    public func getD(): Matrix
}

public class LUDecomposition {
    /*
     * 初始化矩阵
     * 参数 Arg - 矩阵
     */
    public init(A: Matrix)

    /*
     * 判断是否为非奇异矩阵
     * 返回值 Bool  - 判断结果
     */
    public func isNonsingular(): Bool

    /*
     * 获取下三角矩阵
     * 返回值 Matrix  - 矩阵
     */
    public func getL(): Matrix

    /*
     * 获取上三角矩阵
     * 返回值 Matrix  - 矩阵
     */
    public func getU(): Matrix

    /*
     * 获取 Int64 类型的主元序列
     * 返回值 Array<Int64>  - 向量值
     */
    public func getPivot(): Array<Int64>

    /*
     * 获取 Float64 类型的主元序列
     * 返回值 Array<Float64>  - 向量值
     */
    public func getDoublePivot(): Array<Float64>

    /*
     * 返回该矩阵的行列式的值
     * 返回值 Float64  - 该矩阵的行列式的值
     */
    public func det(): Float64

    /*
     * 求解 A*X = B，A 为当前矩阵， B 为入参矩阵, A 不是非奇异矩阵抛 Matrix4cjException
     * 参数 B - 矩阵
     * 返回值 Matrix - X 矩阵
     */
    public func solve(B: Matrix): Matrix
}

public class QRDecomposition {
    /*
     * 初始化矩阵
     * 参数 Arg - 矩阵
     */
    public init(A: Matrix) {

    /*
     * 判断一个矩阵是否是满秩
     * 返回值 Bool  - 判断结果
     */
    public func isFullRank(): Bool

    /*
     * 获取 Hessenberg 矩阵
     * 返回值 Matrix  - 矩阵
     */
    public func getH(): Matrix

    /*
     * 获取上三角矩阵
     * 返回值 Matrix  - 矩阵
     */
    public func getR(): Matrix

    /*
     * 返回正交矩阵
     * 返回值 Matrix  - 矩阵
     */
    public func getQ(): Matrix

    /*
     * 求解 A*X = B，A 为当前矩阵， B 为入参矩阵， A 不是满秩矩阵抛 Matrix4cjException
     * 参数 B - 矩阵
     * 返回值 Matrix - X 矩阵
     */
    public func solve(B: Matrix): Matrix
}

public class SingularValueDecomposition {
    /*
     * 初始化矩阵
     * 参数 Arg - 矩阵
     */
    public init(Arg: Matrix)

    /*
     * 返回左奇异矢量
     * 返回值 Matrix  - 矩阵
     */
    public func getU(): Matrix 

    /*
     * 返回右奇异矢量
     * 返回值 Matrix  - 矩阵
     */
    public func getV(): Matrix

    /*
     * 返回奇异值的一维数组
     * 返回值 Array<Float64> - 数组
     */
    public func getSingularValues(): Array<Float64>

    /*
     * 返回奇异值的对角矩阵
     * 返回值 Matrix - 矩阵
     */
    public func getDiagonalValues(): Matrix

    /*
     * 矩阵L2范数计算
     * 返回值 Float64 - 运算值
     */
    public func norm2(): Float64

    /*
     * 矩阵的矩阵条件数
     * 返回值 Float64 - 运算后值
     */
    public func cond(): Float64

    /*
     * 矩阵的秩
     * 返回值 Int64 - 运算后值
     */
    public func rank(): Int64
}