zanmato1984 commented on code in PR #45259:
URL: https://github.com/apache/arrow/pull/45259#discussion_r1923084202


##########
cpp/src/arrow/compute/kernels/vector_sort_test.cc:
##########
@@ -2466,5 +2469,151 @@ TEST_F(TestRank, EmptyChunks) {
   }
 }
 
+class TestRankQuantile : public BaseTestRank {
+ public:
+  void AssertRankQuantile(const DatumVector& datums, SortOrder order,
+                          NullPlacement null_placement, double factor,
+                          const std::shared_ptr<Array>& expected) {
+    const std::vector<SortKey> sort_keys{SortKey("foo", order)};
+    RankQuantileOptions options(sort_keys, null_placement, factor);
+    ARROW_SCOPED_TRACE("options = ", options.ToString());
+    for (const auto& datum : datums) {
+      ASSERT_OK_AND_ASSIGN(auto actual, CallFunction("rank_quantile", {datum}, 
&options));
+      ValidateOutput(actual);
+      AssertDatumsEqual(expected, actual, /*verbose=*/true);
+    }
+  }
+
+  void AssertRankQuantile(const DatumVector& datums, SortOrder order,
+                          NullPlacement null_placement, double factor,
+                          const std::string& expected) {
+    AssertRankQuantile(datums, order, null_placement, factor,
+                       ArrayFromJSON(float64(), expected));
+  }
+
+  void AssertRankQuantile(SortOrder order, NullPlacement null_placement, 
double factor,
+                          const std::shared_ptr<Array>& expected) {
+    AssertRankQuantile(datums_, order, null_placement, factor, expected);
+  }
+
+  void AssertRankQuantile(SortOrder order, NullPlacement null_placement, 
double factor,
+                          const std::string& expected) {
+    AssertRankQuantile(datums_, order, null_placement, factor,
+                       ArrayFromJSON(float64(), expected));
+  }
+
+  void AssertRankQuantileEmpty(std::shared_ptr<DataType> type) {
+    for (auto null_placement : AllNullPlacements()) {
+      for (auto order : AllOrders()) {
+        AssertRankQuantile({ArrayFromJSON(type, "[]")}, order, null_placement,
+                           /*factor=*/1.0, "[]");
+        AssertRankQuantile({ArrayFromJSON(type, "[null]")}, order, 
null_placement,
+                           /*factor=*/1.0, "[0.5]");
+        AssertRankQuantile({ArrayFromJSON(type, "[null]")}, order, 
null_placement,
+                           /*factor=*/10.0, "[5]");
+        AssertRankQuantile({ArrayFromJSON(type, "[null, null, null]")}, order,
+                           null_placement, /*factor=*/1.0, "[0.5, 0.5, 0.5]");
+        AssertRankQuantile({ArrayFromJSON(type, "[null, null, null]")}, order,
+                           null_placement, /*factor=*/100.0, "[50, 50, 50]");
+      }
+    }
+  }
+
+  // Expecting an input ordered like [1, 2, 1, 2, 1]
+  void AssertRankQuantile_12121() {
+    for (auto null_placement : AllNullPlacements()) {
+      AssertRankQuantile(SortOrder::Ascending, null_placement, 100.0,
+                         "[30.0, 80.0, 30.0, 80.0, 30.0]");
+      AssertRankQuantile(SortOrder::Descending, null_placement, 100.0,
+                         "[70.0, 20.0, 70.0, 20.0, 70.0]");
+    }
+  }
+
+  // Expecting an input ordered like [null, 1, null, 2, null]
+  void AssertRankQuantile_N1N2N() {
+    AssertRankQuantile(SortOrder::Ascending, NullPlacement::AtStart, 1.0,
+                       "[0.3, 0.7, 0.3, 0.9, 0.3]");
+    AssertRankQuantile(SortOrder::Ascending, NullPlacement::AtEnd, 1.0,
+                       "[0.7, 0.1, 0.7, 0.3, 0.7]");
+    AssertRankQuantile(SortOrder::Descending, NullPlacement::AtStart, 1.0,
+                       "[0.3, 0.9, 0.3, 0.7, 0.3]");
+    AssertRankQuantile(SortOrder::Descending, NullPlacement::AtEnd, 1.0,
+                       "[0.7, 0.3, 0.7, 0.1, 0.7]");
+  }
+
+  void AssertRankQuantileNumeric(std::shared_ptr<DataType> type) {
+    ARROW_SCOPED_TRACE("type = ", type->ToString());
+    AssertRankQuantileEmpty(type);
+
+    // Reproduce the example from https://en.wikipedia.org/wiki/Quantile_rank

Review Comment:
   ```suggestion
       // Reproduce the example from 
https://en.wikipedia.org/wiki/Percentile_rank
   ```



##########
cpp/src/arrow/compute/kernels/vector_sort_test.cc:
##########
@@ -2466,5 +2469,151 @@ TEST_F(TestRank, EmptyChunks) {
   }
 }
 
+class TestRankQuantile : public BaseTestRank {
+ public:
+  void AssertRankQuantile(const DatumVector& datums, SortOrder order,
+                          NullPlacement null_placement, double factor,
+                          const std::shared_ptr<Array>& expected) {
+    const std::vector<SortKey> sort_keys{SortKey("foo", order)};
+    RankQuantileOptions options(sort_keys, null_placement, factor);
+    ARROW_SCOPED_TRACE("options = ", options.ToString());
+    for (const auto& datum : datums) {
+      ASSERT_OK_AND_ASSIGN(auto actual, CallFunction("rank_quantile", {datum}, 
&options));
+      ValidateOutput(actual);
+      AssertDatumsEqual(expected, actual, /*verbose=*/true);
+    }
+  }
+
+  void AssertRankQuantile(const DatumVector& datums, SortOrder order,
+                          NullPlacement null_placement, double factor,
+                          const std::string& expected) {
+    AssertRankQuantile(datums, order, null_placement, factor,
+                       ArrayFromJSON(float64(), expected));
+  }
+
+  void AssertRankQuantile(SortOrder order, NullPlacement null_placement, 
double factor,
+                          const std::shared_ptr<Array>& expected) {
+    AssertRankQuantile(datums_, order, null_placement, factor, expected);
+  }
+
+  void AssertRankQuantile(SortOrder order, NullPlacement null_placement, 
double factor,
+                          const std::string& expected) {
+    AssertRankQuantile(datums_, order, null_placement, factor,
+                       ArrayFromJSON(float64(), expected));
+  }
+
+  void AssertRankQuantileEmpty(std::shared_ptr<DataType> type) {
+    for (auto null_placement : AllNullPlacements()) {
+      for (auto order : AllOrders()) {
+        AssertRankQuantile({ArrayFromJSON(type, "[]")}, order, null_placement,
+                           /*factor=*/1.0, "[]");
+        AssertRankQuantile({ArrayFromJSON(type, "[null]")}, order, 
null_placement,
+                           /*factor=*/1.0, "[0.5]");
+        AssertRankQuantile({ArrayFromJSON(type, "[null]")}, order, 
null_placement,
+                           /*factor=*/10.0, "[5]");
+        AssertRankQuantile({ArrayFromJSON(type, "[null, null, null]")}, order,
+                           null_placement, /*factor=*/1.0, "[0.5, 0.5, 0.5]");
+        AssertRankQuantile({ArrayFromJSON(type, "[null, null, null]")}, order,
+                           null_placement, /*factor=*/100.0, "[50, 50, 50]");
+      }
+    }
+  }
+
+  // Expecting an input ordered like [1, 2, 1, 2, 1]
+  void AssertRankQuantile_12121() {
+    for (auto null_placement : AllNullPlacements()) {
+      AssertRankQuantile(SortOrder::Ascending, null_placement, 100.0,
+                         "[30.0, 80.0, 30.0, 80.0, 30.0]");
+      AssertRankQuantile(SortOrder::Descending, null_placement, 100.0,

Review Comment:
   You might want `/*factor=*/100.0` for this as well as the following cases.



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: [email protected]

For queries about this service, please contact Infrastructure at:
[email protected]

Reply via email to