鑿具有索引

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