在堆叠条形图的Incanter中对多列进行排序

Question

我希望对堆栈元素进行排序(group-by-k)，同时保持全局栏中的顺序(Col)。

$order函数不允许一次对多列进行排序。所以这个函数两次，虽然最后一次排序不会保留前一次排序。因此，我可以对全局条块进行排序，也可以对条块的堆叠元素进行排序，但不能同时对两者都进行排序！

我如何才能做到这一点？我怀疑我们需要一个在$fn中工作的sorted-map，但不确定如何实现它……

在这里，我编写了一个函数来尝试多重排序。

(require
   (incanter '[core :as core]
             '[charts :as charts])

(defn sorted-barchart [data col-k & {:keys [group-by-k 
                                            order-k 
                                            order-sign 
                                            order-group-k 
                                            order-group-sign 
                                            title 
                                            x-label 
                                            y-label 
                                            legend]}]
  (core/with-data
    (let [d (core/to-dataset data)
          d1 (core/$where {group-by-k {:$fn #(not (empty? %))}} d)
          d2 (core/$where {col-k {:$fn #(not (empty? %))}} d1)
          d3 (core/$rollup :count :counts (if group-by-k [col-k group-by-k] [col-k]) d2)
          d4 (core/$order (or order-k col-k) (or order-sign nil) d3)
          d5 (core/$order (or order-group-k group-by-k)
                          (or order-group-sign nil) d4)]
      d5) 
    (let [chart (charts/stacked-bar-chart col-k :counts
                                           :group-by group-by-k 
                                           :vertical false
                                           :x-label (or x-label " ")
                                           :y-label (or y-label " ")
                                           :title (or title " ")
                                           :legend (or legend true)
                                           :series-label "Total")]
      chart)))

编辑:当按col和group-k排序时，这实际上是有效的。但是，当你想要首先按计数排序时，当你想要对堆栈元素进行排序时，当你想要按计数排序时，保持col顺序就变得更加棘手了。

Answer 1

我们可以只在主键(col-k)上索引计数，然后按索引和堆叠键(group-by-k)排序。

因此，在sorted-barchart函数中，我们可以用以下代码替换d4和d5：

(if
  (and group-by-k order-k (not= order-k col-k))
  (let [d-count (core/$ col-k 
                        (core/$order :c 
                                     :desc 
                                     (core/$rollup :count :c [col-k] d2)))
        d-index (core/dataset [:index col-k] 
                              (map-indexed vector d-count))
        d-join (core/$join [col-k col-k] d-index d3)]
    (->> d-join
         (core/$order (or order-group-k group-by-k)
                      (or order-group-sign :asc))
         (core/$order :index :asc)))
  (let [d-new (if group-by-k 
                (core/$order (or order-group-k group-by-k)
                             (or order-group-sign :asc) d3)
                d3)]
    (core/$order (or order-k col-k) (or order-sign :desc) d-new)))