Arrays 带索引数组的凿子排序

我想在凿子中实现以下算法：

• 两个矩阵，dataX=数组双精度数组，dataY=表示dataX中数据标签的字符串数组
• 计算两个数据向量v1、v2的欧氏距离，并将相应结果作为固定点返回

def euclideanDist（v1:Array[Double]，v2:Array[Double]）：定点

• 计算从dataX中的向量x到dataX的每个向量的距离，并返回距离向量

def mydistance（x:Array[Double]）：Array[FixedPoint]

• 对于dataX中的每个向量x，我们执行以下操作：
  • 距离=我的距离（x）

  • 对向量“距离”进行排序，以便在最后对向量进行排序，并将相应初始点的索引存储在另一个向量“向量索引”中

使用索引排序将帮助我跟踪dataY中的标签。 因此，我想对向量和索引进行排序，就像我们在scala中所做的那样，如下

distance.zipWithIndex.sortBy（u.\u 1）。

我能得到这方面的帮助吗

例如，如果我有

distance=Array（7.0,99.0,3.50,2.9）

我想在凿子中排序为

Array（（2.9,3）、（3.5,2）、（7.0,0）、（99.0,1））

---

谢谢

这是我对这个问题的看法。这是一个3模块，它将对固定点编号的输入向量进行排序，返回与最低数值对应的选定数量的索引。我认为不需要将它们按元组排序，因为数组中已经有了值

class SortIndexAndTake(val inputSize: Int, val outputSize: Int, val fixedType: FixedPoint)
  extends Module {
  val io = IO(new Bundle {
    val inputs    = Input(Vec(inputSize, fixedType))
    val newInputs = Input(Bool())
    val outputs   = Output(Vec(outputSize, UInt((log2Ceil(inputSize) + 1).W)))
    val sortDone  = Output(Bool())
  })

  val sortReg      = Reg(Vec(inputSize, UInt((log2Ceil(inputSize) + 1).W)))
  val busy         = RegInit(false.B)
  val sortCounter  = RegInit(0.U(log2Ceil(inputSize).W))
  val isEvenCycle  = RegInit(false.B)

  when(io.newInputs) {
    // when parent module loads new inputs to be sorted, we load registers and prepare to sort
    sortReg.zipWithIndex.foreach { case (reg, index) => reg := index.U }

    busy := true.B
    sortCounter := 0.U
    isEvenCycle := false.B
  }
    .elsewhen(busy) {
      isEvenCycle := ! isEvenCycle

      sortCounter := sortCounter + 1.U
      when(sortCounter >= inputSize.U) {
        busy := false.B
      }

      when(isEvenCycle) {
        sortReg.toList.sliding(2, 2).foreach {
          case regA :: regB :: Nil =>
            when(io.inputs(regA) > io.inputs(regB)) {
              // a is bigger than b, so flip this pair
              regA := regB
              regB := regA
            }
          case _ =>
          // this handles end case when there is nothing to compare register to
        }
      }
        .otherwise {
          sortReg.tail.toList.sliding(2, 2).foreach {
            case regA :: regB :: Nil =>
              when(io.inputs(regA) > io.inputs(regB)) {
                // a is bigger than b, so flip this pair
                regA := regB
                regB := regA
              }
            case _ =>
              // this handles end case when there is nothing to compare register to
          }
        }
    }

  io.sortDone := ! busy

  io.outputs.zip(sortReg).foreach { case (out, reg) =>
    out := reg
  }
}

此模块包括一个执行此操作的示例Main