凿具有索引

Question

数组的排序我有以下算法我想在凿以实现：

• 两个矩阵，DATAX =阵列的阵列加倍，并DATAY =串代表的标签阵列dataX中的数据。
• 计算两个数据向量v1，v2的欧式距离，并返回相应的结果作为FixedPoint。

DEF euclideanDist（V1：数组[双]，第二版：数组[双]）：定点

• 计算从在DATAX矢量x到DATAX的每个矢量的距离，并返回的向量距离。

def myDistances（x：Array [Double]）：Array [FixedPoint]。

• 对于DATAX每个矢量x，我们做：

  • 距离= myDistances（X）

  • 排序的载体“距离”，使得在最后我们能有矢量排序并存储在另一个矢量“vecIndices”中的相应初始点的索引

使用索引排序将帮助我跟踪dataY中的标签。 所以，我想要排序矢量以及像我们在scala中所做的那样的索引distances.zipWithIndex.sortBy(_._1).我可以得到这个帮助吗？

例如，如果我有distances=Array(7.0,99.0,3.50,2.9)我想用凿子排序为Array((2.9,3), (3.5,2), (7.0,0), (99.0,1))。

谢谢！

Answer 1

这是我对这个问题的看法。这里是一个Chisel3模块，它将对输入的FixedPoint数字的Vec进行排序，返回与最低数值相对应的选定数量的索引。我不认为你需要将它们作为元组排序，你已经有了数组中的值。

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 
    } 
} 

该模块包括样品主要执行此在此github gist