Breeze常用函数

下面列举了三个不同库，相同功能的函数列表：

示例代码如下：

package sparkMlibDemo.breeze


import breeze.linalg._
import breeze.numerics._
import breeze.stats.distributions.Rand

/**
  * Created by fishjar on 2018/9/9.
  */
object BreezeOperate {

  def main(args: Array[String]): Unit = {
    //1.1）创建一个 2 x 3的矩阵
    val m1 = DenseMatrix.zeros[Double](2,3)
    println(m1)
    val m2 = DenseMatrix.ones[Double](2,3)
    println(m2)

    //1.2) 创建一个向量
    //1.2.1)创建一个全 0 向量
    val v1 = DenseVector.zeros[Double](3)
    println(v1)
    //1.2.2)创建一个全 1 向量
    val v2 = DenseVector.ones[Double](3)
    println(v2)
    //1.2.3) 根据数组填充向量
    val v3 = DenseVector.fill(3){2.0}
    println(v3)
//  打印结果：DenseVector(2.0, 2.0, 2.0)
    //1.2.4) 根据间隔生成 向量
    val v4 = DenseVector.range(1,10,2)
    println(v4)
//  打印结果：DenseVector(1, 3, 5, 7, 9)

    //1.2.5) 创建单位矩阵
    val m3 = DenseMatrix.eye[Double](3)
    println(m3)
//打印结果：
//    1.0  0.0  0.0
//    0.0  1.0  0.0
//    0.0  0.0  1.0

    //1.2.6) 创建对角矩阵
    println("*******创建对角矩阵*******")
    val m4=diag(DenseVector(3.0, 4.0 , 5.0))
    println(m4)

    //1.2.7）指定值创建向量
    val v8 = DenseVector(1,2,3,4)
    println(v8)

    //1.2.8）将行矩阵 转 为 列 向量
    println("*****列****")
    val v9 = DenseVector(1,2,3,4).t
    println(v9)

    //1.2.9) 根据下标 创建 向量
    println("*********根据下标 创建 向量**********")
    val v10 = DenseVector.tabulate(3){i => i +10}
    println(v10)

    //1.2.10）根据下标 创建 矩阵
    val v11 = DenseMatrix.tabulate(3,2){case(i,j) => i+j}
    println("******v11")
    println(v11)

    //1.2.11) 根据数组 创建 向量
    println("*********根据数组 创建 向量**********")
    val v12 = DenseVector(Array(1,2,3,4))
    println(v12)

    //1.2.12) 根据数组 创建 矩阵
    println("************根据数组 创建 矩阵************")
    val v13 = new DenseMatrix(2,3,Array(1,2,3,4,5,6))
    println(v13)

    //1.2.13 创建随机数向量
    println("********创建随机数向量*******")
    val v14 = DenseVector.rand(6)
    println(v14)

    //1.2.14 创建随机 矩阵
    println("********创建随机 矩阵******")
    val v15 = DenseMatrix.rand(2,3)
    println(v15)

    //1.2.15 向量 访问
    println("**********向量 访问**********")
    val v16 = DenseVector(1,2,3,4,5,6,7,8,9,10)
    //1.2.15.1 取第三个元素
    println(v16(2))
    //1.2.15.2 取 下标为1 到 下标为3的三个元素
    println(v16(1 to 3))
    //1.2.15.3 取下标5 到 下标 0 的元素
    println(v16(5 to 0 by -1))
    // 输出结果为：DenseVector(6, 5, 4, 3, 2, 1)
    println(v16(5 to 0 by -2))
    // 输出结果为：DenseVector(6, 4, 2)

    //1.2.16 矩阵 访问
    println("************矩阵 访问**************")
    val v17 = DenseMatrix((1.0,2.0,3.0),(3.0,4.0,5.0))
    println(v17(1,1))
    //返回向量
    //打印结果为：DenseVector(2.0, 4.0)
    println(v17(::,1))
    // 打印结果为：1.0  2.0  3.0
    println(v17(0,::))

    //2.1 矩阵 元素 操作
    println("********* 矩阵 元素 操作************")
    //2.1.1 矩阵 转换 按照列 来转换 元素
    val m5 = DenseMatrix((1,2,3),(4,5,6))
    println(m5)
    println(m5.reshape(3,2))

    //2.1.2 将矩阵 转换 为向量
    println("******将矩阵 转换 为向量*********")
    val m6 = DenseMatrix((1,2,3),(4,5,6))
    println(m6.toDenseVector)

    //2.1.3  取矩阵的 下 三角
    println("*********取矩阵的 下 三角***********")
    val m7 = DenseMatrix((1,2,3),(4,5,6),(7,8,9))
    println(lowerTriangular(m7))

    //2.1.4 取矩阵的 上 三角
    println("***********取矩阵的 上 三角***********")
    val m8 = DenseMatrix((1,2,3),(4,5,6),(7,8,9))
    println(upperTriangular(m8))

    //2.1.5 复制 矩阵
    println("********复制 矩阵*******")
    val m9 = DenseMatrix((1,2,3),(4,5,6),(7,8,9))
    val m9_1 = m9.copy
    println(m9_1)

    //2.1.6 对角 矩阵 ,返回 向量
    println("*******对角 矩阵*******")
    val m10 =DenseMatrix((1,2,3),(4,5,6),(7,8,9))
    println(diag(m10))

    //2.1.7 对矩阵位子上的所有元素进行赋值
    println("********对矩阵位子上的所有元素进行赋值*******")
    val m11 =DenseMatrix((1,2,3),(4,5,6),(7,8,9))
    println("将第一列值赋值")
    m11(::,0):=8
    println(m11)

    println("将第一行到第二行与 第一列赋值 ")
    val m11_1 =DenseMatrix((1,2,3),(4,5,6),(7,8,9))
    m11_1(0 to 1,0 ) :=7
    println(m11_1)

    //2.1.8 给向量赋值：
    println("")
    val v20 = DenseVector(1,2,3,4,5,6,7,8,9,10)
    v20(1 to 4):=5
    //打印结果：DenseVector(1, 5, 5, 5, 5, 6, 7, 8, 9, 10)
    println(v20)
    v20(1 to 5) := DenseVector(10,11,12,13,14)
    println(v20)

    //2.1.9 矩阵垂直 相连
    println("向量 垂直相连")
    val v21 = DenseMatrix((1.0,2.0,3.0),(4.0,5.0,6.0))
    val v21_2 = DenseMatrix((1.0,1.0,1.0),(2.0,2.0,2.0))
    val v21_3 =DenseMatrix.vertcat(v21,v21_2)
    println(v21_3)

    //2.1.10 矩阵 横向 连接
    println("向量 横向相连")
    val v22 = DenseMatrix((1.0,2.0,3.0),(4.0,5.0,6.0))
    val v22_2 = DenseMatrix((1.0,1.0,1.0),(2.0,2.0,2.0))
    val v22_3 =DenseMatrix.horzcat(v21,v21_2)
    println(v22_3)

    //2.1.11 向量连接
    //    println("向量连接 垂直连接")
    val v23 = DenseVector(1,2,3,4)
    val v23_2 = DenseVector(6,7,8)
    val v23_3 = DenseVector.vertcat(v23,v23_2)
    println(v23_3)

    //3.1 数值计算
    //3.1.1 矩阵 加法 运算
    val v31 =DenseMatrix((1.0,2.0,3.0),(4.0,5.0,6.0))
    val v31_2 = DenseMatrix((5.0,6.0,7.0),(5.0,6.0,7.0))
    val v31_3 = v31 + v31_2;
    println(v31_3)

    //3.1.2 矩阵 乘法 运算
    println("矩阵 乘法 运算")
    val v32 =DenseMatrix((1.0,2.0,3.0),(4.0,5.0,6.0))
    val v32_2 = DenseMatrix((5.0,6.0,7.0),(5.0,6.0,7.0))
    val v32_3 = v32 :* v32_2
    println(v32_3)

    //3.1.3 矩阵 除法 运算
    println("矩阵 除法 运算")
    val v33 =DenseMatrix((1.0,2.0,3.0),(4.0,5.0,6.0))
    val v33_2 = DenseMatrix((5.0,6.0,7.0),(5.0,6.0,7.0))
    val v33_3 = v33 :/ v33_2
    println(v33_3)

    //3.1.4 矩阵 比较 运算
    println("**************矩阵 比较 运算")
    val v34 =DenseMatrix((1.0,2.0,3.0),(4.0,5.0,6.0))
    val v34_2 = DenseMatrix((5.0,6.0,7.0),(5.0,3.0,7.0))
    println(v34 :< v34_2)

    //3.1.5 元素 相等 判断
    println("************元素 相等 判断")
    val v35 =DenseMatrix((1.0,2.0,3.0),(4.0,5.0,6.0))
    val v35_2 = DenseMatrix((5.0,6.0,7.0),(5.0,3.0,6.0))
    println(v35 :==v35_2)

      //3.1.6 元素 追加
      println("**********3.1.5 元素 追加")
      val v36 = DenseMatrix((1.0,2.0,3.0),(4.0,5.0,6.0))
      println(v36 :+= 1.0 )
//      结果输出为：
//      2.0  3.0  4.0
//      5.0  6.0  7.0

      //3.1.7 元素追乘
      println("************3.1.6 元素追乘")
      val v37 =DenseMatrix((1.0,2.0,3.0),(4.0,5.0,6.0))
      println( v37 :*= 2.0)

      //3.1.8 向量点积 运算
      println("***********3.1.8 向量点积 运算")
      val v38 = DenseVector(1,2,3,4)
      val v38_2 = DenseVector(2,2,2,1)
      println(v38 dot v38_2)

      //3.1.9 元素最大值
      println("**************元素最大值")
      import breeze.linalg._
      val v39 = DenseMatrix((1.0,2.0,3.0),(4.0,5.0,6.0))
      println(max(v39))

      //3.1.10 元素最大值 及 位置
      println("*************元素最大值 及 位置")
      val v40 =DenseMatrix((1.0,2.0,3.0),(4.0,5.0,6.0))
      println(argmax(v40))
      println(argmin(v40))

      //3.1.11 元素 求和
      println("**************元素 求和")
      val v41 =DenseMatrix((1.0,2.0,3.0),(4.0,5.0,6.0))
      val v41_2 =DenseVector(1.0,2.0,3.0,4.0,5.0,6.0,7.0)
      println(sum(v41))
      println(sum(v41_2))

      //3.1.12 每一列求和
      println("**************每一列求和")
      val v42 =DenseMatrix((1.0,2.0,3.0),(4.0,5.0,6.0))
      println(sum(v42, Axis._0) )

      //3.1.13 每一行 求和
      println("************每一行 求和")
      val v43 =DenseMatrix((1.0,2.0,3.0),(4.0,5.0,6.0))
      println(sum(v43, Axis._1) )

      //3.1.14 对角线元素 求和
      println("************对角线元素 求和")
      val v44 =DenseMatrix((1.0,2.0,3.0),(4.0,5.0,6.0),(7.0,8.0,9.0))
      println(trace(v44))

      //3.1.15 累积和
      println("*************累积和")
      val v45_2 = DenseVector(1,2,3,4)
      println(accumulate(v45_2))
//    输出结果：DenseVector(1, 3, 6, 10)

    //4.1 布尔函数
    //4.1.1 元素 与 操作
    println("**************元素 与 操作")
    val v46 = DenseVector(true, false, true)
    val v46_2 =DenseVector(false, true, true)
    println(v46 :& v46_2)
//    输出结果：DenseVector(false, false, true)

    //4.1.2 元素 或 操作
    println("**************元素 或 操作")
    val v47 = DenseVector(true, false, true)
    val v47_2 =DenseVector(false, true, true)
    println(v47 :| v47_2)

    //4.1.3 元素 非 操作
    println("*********元素非操作")
    val v48 = DenseVector(true, false, true)
    println( !v48)

    //4.1.4 任意元素 非 0
    println("************任意元素 非 0")
    val v49 = DenseVector(1.0, 0.0, -2.0)
    println(any(v49))

    //4.1.5 所有元素 非 0
    println("************任意元素 非 0")
    val v50  = DenseVector(1.0, 0.0, -2.0)
    println(all(v50))

    // 5.1 线性代数 函数
    // 5.1.1 线性求解
    println("**************5.1.1 线性求解")
    val v51 =DenseMatrix((1.0,2.0,3.0), (4.0,5.0,6.0) , (7.0,8.0,9.0))
    val v51_1 = DenseMatrix((1.0,1.0,1.0), (1.0,1.0,1.0) , (1.0,1.0,1.0))
    println(v51  v51_1)

    //5.1.2 转置
    println("***************转置")
    val v52 =DenseMatrix((1.0,2.0,3.0), (4.0,5.0,6.0) , (7.0,8.0,9.0),(10.0,11.0,12.0))
    println(v52)
    println(v52.t)

    //5.1.3 求特征值
    println("************求特征值")
    val v53 =DenseMatrix((1.0,2.0,3.0), (4.0,5.0,6.0) , (7.0,8.0,9.0))
    val v53_2 =DenseMatrix((1.0,1.0,3.0,1.0), (4.0,2.0,6.0,7.0) , (7.0,8.0,9.0,10.0),(8.0,9.0,10.0,11.0))
    println(det(v53))
    println(det(v53_2))

    //5.1.4 求逆
    println("************求逆")
    val v54=DenseMatrix((1.0,2.0,3.0), (4.0,5.0,6.0) , (7.0,8.0,9.0))
    println(inv(v54))

    //5.1.5 求伪逆
    println("************求伪逆")
    val v55 = DenseMatrix((1.0,2.0,3.0), (4.0,5.0,6.0) , (7.0,8.0,9.0))
    println(pinv(v55))

    //5.1.6 求范数
//    println("************求范数")
//    val v56 = DenseMatrix((1.0,2.0,3.0), (4.0,5.0,6.0) , (7.0,8.0,9.0))
//    println(norm(1.0,20.0))

  }
}