Remove rounding from cudf java (#20110)

This has been moved to spark-rapids-jni, where we've implement rounding of floats since that is deprecated in cudf. [This](NVIDIA/spark-rapids-jni#3770) is the merged sr-jni PR implementing this rounding there, and [this](NVIDIA/spark-rapids#13497) is the merged spark-rapids PR switching the rounding calls to the new code.  All of the spark-rapids integration tests pass with this old code deleted.

Authors:
  - Paul Mattione (https://github.com/pmattione-nvidia)
  - Nghia Truong (https://github.com/ttnghia)

Approvers:
  - Nghia Truong (https://github.com/ttnghia)

URL: #20110

Author: pmattione-nvidia

java/src/main/java/ai/rapids/cudf/ColumnView.java

@@ -1105,51 +1105,6 @@ public final ColumnVector dateTimeRound(DateTimeRoundingFrequency freq) {
     return new ColumnVector(dateTimeRound(getNativeView(), freq.getNativeId()));
   }
 
-  /**
-   * Rounds all the values in a column to the specified number of decimal places.
-   *
-   * @param decimalPlaces Number of decimal places to round to. If negative, this
-   *                      specifies the number of positions to the left of the decimal point.
-   * @param mode          Rounding method(either HALF_UP or HALF_EVEN)
-   * @return a new ColumnVector with rounded values.
-   */
-  public ColumnVector round(int decimalPlaces, RoundMode mode) {
-    return new ColumnVector(round(this.getNativeView(), decimalPlaces, mode.nativeId));
-  }
-
-  /**
-   * Rounds all the values in a column with decimal places = 0. Default number of decimal places
-   * to round to is 0.
-   *
-   * @param round Rounding method(either HALF_UP or HALF_EVEN)
-   * @return a new ColumnVector with rounded values.
-   */
-  public ColumnVector round(RoundMode round) {
-    return round(0, round);
-  }
-
-  /**
-   * Rounds all the values in a column to the specified number of decimal places with HALF_UP
-   * (default) as Rounding method.
-   *
-   * @param decimalPlaces Number of decimal places to round to. If negative, this
-   *                      specifies the number of positions to the left of the decimal point.
-   * @return a new ColumnVector with rounded values.
-   */
-  public ColumnVector round(int decimalPlaces) {
-    return round(decimalPlaces, RoundMode.HALF_UP);
-  }
-
-  /**
-   * Rounds all the values in a column with these default values:
-   * decimalPlaces = 0
-   * Rounding method = RoundMode.HALF_UP
-   *
-   * @return a new ColumnVector with rounded values.
-   */
-  public ColumnVector round() {
-    return round(0, RoundMode.HALF_UP);
-  }
 
   /////////////////////////////////////////////////////////////////////////////
   // ARITHMETIC
@@ -4709,7 +4664,6 @@ private static native long stringReplaceWithBackrefs(long columnView, String pat
 
   private static native long findAndReplaceAll(long valuesHandle, long replaceHandle, long myself) throws CudfException;
 
-  private static native long round(long nativeHandle, int decimalPlaces, int roundingMethod) throws CudfException;
 
   private static native long reverseStringsOrLists(long inputHandle);
 

java/src/main/java/ai/rapids/cudf/RoundMode.java

@@ -1162,20 +1162,6 @@ JNIEXPORT jlong JNICALL Java_ai_rapids_cudf_ColumnView_unaryOperation(JNIEnv* en
   JNI_CATCH(env, 0);
 }
 
-JNIEXPORT jlong JNICALL Java_ai_rapids_cudf_ColumnView_round(
-  JNIEnv* env, jclass, jlong input_ptr, jint decimal_places, jint rounding_method)
-{
-  JNI_NULL_CHECK(env, input_ptr, "input is null", 0);
-  JNI_TRY
-  {
-    cudf::jni::auto_set_device(env);
-    cudf::column_view* input     = reinterpret_cast<cudf::column_view*>(input_ptr);
-    cudf::rounding_method method = static_cast<cudf::rounding_method>(rounding_method);
-    return release_as_jlong(cudf::round(*input, decimal_places, method));
-  }
-  JNI_CATCH(env, 0);
-}
-
 JNIEXPORT jlong JNICALL Java_ai_rapids_cudf_ColumnView_extractDateTimeComponent(JNIEnv* env,
                                                                                 jclass,
                                                                                 jlong input_ptr,

java/src/main/native/src/ColumnViewJni.cpp

@@ -1,6 +1,6 @@
 /*
  *
- *  Copyright (c) 2019-2024, NVIDIA CORPORATION.
+ *  Copyright (c) 2019-2025, NVIDIA CORPORATION.
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
@@ -817,77 +817,6 @@ void isNotNanTestAllNans() {
     }
   }
 
-  @Test
-  void roundFloatsHalfUp() {
-    try (ColumnVector v = ColumnVector.fromBoxedFloats(1.234f, 25.66f, null, 154.9f, 2346f);
-         ColumnVector result1 = v.round();
-         ColumnVector result2 = v.round(1, RoundMode.HALF_UP);
-         ColumnVector result3 = v.round(-1, RoundMode.HALF_UP);
-         ColumnVector expected1 = ColumnVector.fromBoxedFloats(1f, 26f, null, 155f, 2346f);
-         ColumnVector expected2 = ColumnVector.fromBoxedFloats(1.2f, 25.7f, null, 154.9f, 2346f);
-         ColumnVector expected3 = ColumnVector.fromBoxedFloats(0f, 30f, null, 150f, 2350f)) {
-      assertColumnsAreEqual(expected1, result1);
-      assertColumnsAreEqual(expected2, result2);
-      assertColumnsAreEqual(expected3, result3);
-    }
-  }
-
-  @Test
-  void roundFloatsHalfEven() {
-    try (ColumnVector v = ColumnVector.fromBoxedFloats(1.5f, 2.5f, 1.35f, null, 1.25f, 15f, 25f);
-         ColumnVector result1 = v.round(RoundMode.HALF_EVEN);
-         ColumnVector result2 = v.round(1, RoundMode.HALF_EVEN);
-         ColumnVector result3 = v.round(-1, RoundMode.HALF_EVEN);
-         ColumnVector expected1 = ColumnVector.fromBoxedFloats(2f, 2f, 1f, null, 1f, 15f, 25f);
-         ColumnVector expected2 = ColumnVector.fromBoxedFloats(1.5f, 2.5f, 1.4f, null, 1.2f, 15f, 25f);
-         ColumnVector expected3 = ColumnVector.fromBoxedFloats(0f, 0f, 0f, null, 0f, 20f, 20f)) {
-      assertColumnsAreEqual(expected1, result1);
-      assertColumnsAreEqual(expected2, result2);
-      assertColumnsAreEqual(expected3, result3);
-    }
-  }
-
-  @Test
-  void roundIntsHalfUp() {
-    try (ColumnVector v = ColumnVector.fromBoxedInts(12, 135, 160, -1454, null, -1500, -140, -150);
-         ColumnVector result1 = v.round(2, RoundMode.HALF_UP);
-         ColumnVector result2 = v.round(-2, RoundMode.HALF_UP);
-         ColumnVector expected1 = ColumnVector.fromBoxedInts(12, 135, 160, -1454, null, -1500, -140, -150);
-         ColumnVector expected2 = ColumnVector.fromBoxedInts(0, 100, 200, -1500, null, -1500, -100, -200)) {
-      assertColumnsAreEqual(expected1, result1);
-      assertColumnsAreEqual(expected2, result2);
-    }
-  }
-
-  @Test
-  void roundIntsHalfEven() {
-    try (ColumnVector v = ColumnVector.fromBoxedInts(12, 24, 135, 160, null, 1450, 1550, -1650);
-         ColumnVector result1 = v.round(2, RoundMode.HALF_EVEN);
-         ColumnVector result2 = v.round(-2, RoundMode.HALF_EVEN);
-         ColumnVector expected1 = ColumnVector.fromBoxedInts(12, 24, 135, 160, null, 1450, 1550, -1650);
-         ColumnVector expected2 = ColumnVector.fromBoxedInts(0, 0, 100, 200, null, 1400, 1600, -1600)) {
-      assertColumnsAreEqual(expected1, result1);
-      assertColumnsAreEqual(expected2, result2);
-    }
-  }
-
-  @Test
-  void roundDecimal() {
-    final int dec32Scale1 = -2;
-    final int resultScale1 = -3;
-
-    final int[] DECIMAL32_1 = new int[]{14, 15, 16, 24, 25, 26} ;
-    final int[] expectedHalfUp = new int[]{1, 2, 2, 2, 3, 3};
-    final int[] expectedHalfEven = new int[]{1, 2, 2, 2, 2, 3};
-    try (ColumnVector v = ColumnVector.decimalFromInts(-dec32Scale1, DECIMAL32_1);
-         ColumnVector roundHalfUp = v.round(-3, RoundMode.HALF_UP);
-         ColumnVector roundHalfEven = v.round(-3, RoundMode.HALF_EVEN);
-         ColumnVector answerHalfUp = ColumnVector.decimalFromInts(-resultScale1, expectedHalfUp);
-         ColumnVector answerHalfEven = ColumnVector.decimalFromInts(-resultScale1, expectedHalfEven)) {
-      assertColumnsAreEqual(answerHalfUp, roundHalfUp);
-      assertColumnsAreEqual(answerHalfEven, roundHalfEven);
-    }
-  }
 
   @Test
   void decimal128Cv() {