Gemmini测试test文件chisel源码详解（四）

 矩阵生成TestUtils.scala

// See README.md for license details.
package gemmini
 
object TestUtils {
  type Matrix[T] = Seq[Seq[T]]
 
  def rows[T](m: Matrix[T]) = m.length
  def cols[T](m: Matrix[T]) = m.head.length
  def dims[T](m: Matrix[T]) = (rows(m), cols(m))
 
  def mult[A](a: Matrix[A], b: Matrix[A])(implicit n: Numeric[A]): Matrix[A] = {
    import n._
    for (row <- a)
      yield for(col <- b.transpose)
        yield row zip col map Function.tupled(_*_) reduceLeft (_+_)
  }
 
  def add[A](a: Matrix[A], b: Matrix[A])(implicit n: Numeric[A]): Matrix[A] = {
    import n._
    for ((ra, rb) <- a zip b)
      yield for ((elema, elemb) <- ra zip rb)
        yield elema + elemb
  }
 
  def identity(dim: Int): Matrix[Int] = {
    for (i <- 0 until dim)
      yield Seq.fill(i)(0) ++ Seq(1) ++ Seq.fill(dim-i-1)(0)
  }
 
  def consecutive(dim: Int): Matrix[Int] = {
    (1 to dim*dim).grouped(dim).toSeq
  }
 
  def zero(dim: Int): Matrix[Int] = Seq.fill(dim, dim)(0)
 
  def rand(dim: Int, max: Int = 32): Matrix[Int] = Seq.fill(dim, dim)(scala.util.Random.nextInt(max))
 
  def print2DArray[A](a: Matrix[A]): Unit = {
    a.foreach {
      line => println(line.map(_.toString).reduce(_ + "\t" + _))
    }
  }
}

• TestUtils 对象中定义了一个类型别名 Matrix[T]，表示一个由 T 类型的元素组成的二维序列。
• rows[T] 函数接受一个 Matrix[T] 类型的参数 m，并返回它的行数，即 m 的长度。
• cols[T] 函数接受一个 Matrix[T] 类型的参数 m，并返回它的列数，即 m 的第一行的长度。
• dims[T] 函数接受一个 Matrix[T] 类型的参数 m，并返回它的维度，即 (rows(m), cols(m)) 的元组。
• mult[A] 函数接受两个 Matrix[A] 类型的参数 a 和 b，并返回它们的矩阵乘积。这个函数要求 A 类型是一个数值类型，可以进行加法和乘法运算。函数中使用了 for 推导式和 map、reduceLeft 等高阶函数来实现矩阵乘法的算法。
• add[A] 函数接受两个 Matrix[A] 类型的参数 a 和 b，并返回它们的矩阵加法。这个函数要求 A 类型是一个数值类型，可以进行加法运算。函数中使用了 for 推导式和 zip 函数来实现矩阵加法的算法。
• identity 函数接受一个整数参数 dim，并返回一个 dim x dim 的单位矩阵，即对角线上为 1，其余为 0 的矩阵。函数中使用了 for 推导式和 Seq.fill 函数来构造单位矩阵。
• consecutive 函数接受一个整数参数 dim，并返回一个 dim x dim 的连续矩阵，即从 1 到 dim*dim 的整数按行排列的矩阵。函数中使用了 to 和 grouped 方法来构造连续矩阵。
• zero 函数接受一个整数参数 dim，并返回一个 dim x dim 的零矩阵，即所有元素都为 0 的矩阵。函数中使用了 Seq.fill 函数来构造零矩阵。
• rand 函数接受一个整数参数 dim，以及一个可选的整数参数 max，默认值为 32。函数返回一个 dim x dim 的随机矩阵，即所有元素都是从 0 到 max-1 中随机选择的整数。函数中使用了 Seq.fill 和 scala.util.Random.nextInt 方法来构造随机矩阵。
• print2DArray[A] 函数接受一个 Matrix[A] 类型的参数 a，并打印出它的内容。函数中使用了 foreach 方法和 reduce 方法来格式化并输出每一行元素。

// See README.md for license details.
package gemmini
 
object TestUtils {
//定义二维矩阵
  type Matrix[T] = Seq[Seq[T]]
//获取矩阵的行数、列数和维度的函数。rows函数返回矩阵的行数，cols函数返回矩阵的列数，dims函数返回矩阵的维度
  def rows[T](m: Matrix[T]) = m.length
  def cols[T](m: Matrix[T]) = m.head.length
  def dims[T](m: Matrix[T]) = (rows(m), cols(m))
//用于矩阵乘法
  def mult[A](a: Matrix[A], b: Matrix[A])(implicit n: Numeric[A]): Matrix[A] = {
//函数使用嵌套的for推导式来遍历矩阵a的每一行和矩阵b的每一列
//在每个元素位置上，它使用row zip col将两个对应位置的元素组成一个元组，然后对该元组应用乘法操
//使用Function.tupled将乘法操作应用到每个元素上
//最后，使用reduceLeft和+_将每一行中的乘积相加，得到最终的结果矩阵。
    import n._
    for (row <- a)
      yield for(col <- b.transpose)
        yield row zip col map Function.tupled(_*_) reduceLeft (_+_)
  }
//矩阵加法
  def add[A](a: Matrix[A], b: Matrix[A])(implicit n: Numeric[A]): Matrix[A] = {
    import n._
    for ((ra, rb) <- a zip b)
      yield for ((elema, elemb) <- ra zip rb)
        yield elema + elemb
  }
//生成单位矩阵
  def identity(dim: Int): Matrix[Int] = {
    for (i <- 0 until dim)
      yield Seq.fill(i)(0) ++ Seq(1) ++ Seq.fill(dim-i-1)(0)
  }
//生成连续数字矩阵
  def consecutive(dim: Int): Matrix[Int] = {
    (1 to dim*dim).grouped(dim).toSeq
  }
//生成全零矩阵
  def zero(dim: Int): Matrix[Int] = Seq.fill(dim, dim)(0)
//生成随机整数矩阵
  def rand(dim: Int, max: Int = 32): Matrix[Int] = Seq.fill(dim, dim)(scala.util.Random.nextInt(max))
//打印
  def print2DArray[A](a: Matrix[A]): Unit = {
    a.foreach {
      line => println(line.map(_.toString).reduce(_ + "\t" + _))
    }
  }
}