ALP: Add cross-implementation tests and fix encode/decode to match C++

Add AlpCrossImplTest with 7 test cases that decode C++ reference blobs
and verify bit-identical output. Reference blobs were generated by the
C++ Arrow ALP implementation via generate_reference_blobs.cc.

Fix encode/decode math to use two-step multiplication matching C++:
- Encode: value * 10^exponent * 10^(-factor)
- Decode: encoded * 10^factor * 10^(-exponent)

The previous single-operation approach (value / (10^e / 10^f)) produced
1-ULP differences due to different intermediate floating-point rounding.

Author: sfc-gh-pgaur

parquet-column/src/main/java/org/apache/parquet/column/values/alp/AlpConstants.java

@@ -69,6 +69,12 @@ private AlpConstants() {
 
   static final float[] FLOAT_POW10 = {1e0f, 1e1f, 1e2f, 1e3f, 1e4f, 1e5f, 1e6f, 1e7f, 1e8f, 1e9f, 1e10f};
 
+  // Negative powers of 10 as float, matching C++ PowerOfTenFloat(-power).
+  // Used in the two-step encode/decode to match C++ floating-point rounding behavior.
+  static final float[] FLOAT_POW10_NEGATIVE = {
+    1e0f, 1e-1f, 1e-2f, 1e-3f, 1e-4f, 1e-5f, 1e-6f, 1e-7f, 1e-8f, 1e-9f, 1e-10f
+  };
+
   // ========== Double-specific ==========
   static final int DOUBLE_MAX_EXPONENT = 18;
   static final double MAGIC_DOUBLE = 6_755_399_441_055_744.0; // 2^51 + 2^52
@@ -80,6 +86,12 @@ private AlpConstants() {
     1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18
   };
 
+  // Negative powers of 10 as double, matching C++ PowerOfTenDouble(-power).
+  static final double[] DOUBLE_POW10_NEGATIVE = {
+    1e0, 1e-1, 1e-2, 1e-3, 1e-4, 1e-5, 1e-6, 1e-7, 1e-8, 1e-9, 1e-10,
+    1e-11, 1e-12, 1e-13, 1e-14, 1e-15, 1e-16, 1e-17, 1e-18
+  };
+
   // ========== Per-vector metadata sizes ==========
   public static final int ALP_INFO_SIZE = 4; // exponent(1) + factor(1) + num_exceptions(2)
   public static final int FLOAT_FOR_INFO_SIZE = 5; // frame_of_reference(4) + bit_width(1)

parquet-column/src/main/java/org/apache/parquet/column/values/alp/AlpEncoderDecoder.java

@@ -27,8 +27,8 @@
  * then applying Frame of Reference encoding and bit-packing.
  * Values that cannot be losslessly converted are stored as exceptions.
  *
- * <p>Encoding formula: encoded = round(value * 10^exponent / 10^factor)
- * <p>Decoding formula: value = encoded / 10^exponent * 10^factor
+ * <p>Encoding formula: encoded = round(value * 10^exponent * 10^(-factor))
+ * <p>Decoding formula: value = encoded * 10^factor * 10^(-exponent)
  *
  * <p>Exception conditions:
  * <ul>
@@ -45,26 +45,6 @@ private AlpEncoderDecoder() {
     // Utility class
   }
 
-  // ========== Float multiplier ==========
-
-  static float getFloatMultiplier(int exponent, int factor) {
-    float multiplier = FLOAT_POW10[exponent];
-    if (factor > 0) {
-      multiplier /= FLOAT_POW10[factor];
-    }
-    return multiplier;
-  }
-
-  // ========== Double multiplier ==========
-
-  static double getDoubleMultiplier(int exponent, int factor) {
-    double multiplier = DOUBLE_POW10[exponent];
-    if (factor > 0) {
-      multiplier /= DOUBLE_POW10[factor];
-    }
-    return multiplier;
-  }
-
   // ========== Float exception detection ==========
 
   /** NaN, Inf, and -0.0 can never be encoded regardless of exponent/factor. */
@@ -83,9 +63,8 @@ static boolean isFloatException(float value, int exponent, int factor) {
     if (isFloatException(value)) {
       return true;
     }
-    float multiplier = getFloatMultiplier(exponent, factor);
-    float scaled = value * multiplier;
-    if (scaled > Integer.MAX_VALUE || scaled < Integer.MIN_VALUE) {
+    float scaled = value * FLOAT_POW10[exponent] * FLOAT_POW10_NEGATIVE[factor];
+    if (scaled > FLOAT_ENCODING_UPPER_LIMIT || scaled < FLOAT_ENCODING_LOWER_LIMIT) {
       return true;
     }
     int encoded = encodeFloat(value, exponent, factor);
@@ -94,15 +73,18 @@ static boolean isFloatException(float value, int exponent, int factor) {
   }
 
   // ========== Float encode/decode ==========
+  // Two-step multiplication matching C++ to produce identical floating-point rounding.
+  // C++ encode: value * 10^exponent * 10^(-factor)
+  // C++ decode: (float)encoded * 10^factor * 10^(-exponent)
 
-  /** Encode: round(value * 10^exponent / 10^factor) */
+  /** Encode: round(value * 10^exponent * 10^(-factor)) */
   static int encodeFloat(float value, int exponent, int factor) {
-    return fastRoundFloat(value * getFloatMultiplier(exponent, factor));
+    return fastRoundFloat(value * FLOAT_POW10[exponent] * FLOAT_POW10_NEGATIVE[factor]);
   }
 
-  /** Decode: encoded / 10^exponent * 10^factor */
+  /** Decode: encoded * 10^factor * 10^(-exponent) */
   static float decodeFloat(int encoded, int exponent, int factor) {
-    return encoded / getFloatMultiplier(exponent, factor);
+    return (float) encoded * FLOAT_POW10[factor] * FLOAT_POW10_NEGATIVE[exponent];
   }
 
   // Uses the 2^22+2^23 magic-number trick to round without branching on the FPU.
@@ -130,9 +112,8 @@ static boolean isDoubleException(double value, int exponent, int factor) {
     if (isDoubleException(value)) {
       return true;
     }
-    double multiplier = getDoubleMultiplier(exponent, factor);
-    double scaled = value * multiplier;
-    if (scaled > Long.MAX_VALUE || scaled < Long.MIN_VALUE) {
+    double scaled = value * DOUBLE_POW10[exponent] * DOUBLE_POW10_NEGATIVE[factor];
+    if (scaled > DOUBLE_ENCODING_UPPER_LIMIT || scaled < DOUBLE_ENCODING_LOWER_LIMIT) {
       return true;
     }
     long encoded = encodeDouble(value, exponent, factor);
@@ -141,13 +122,16 @@ static boolean isDoubleException(double value, int exponent, int factor) {
   }
 
   // ========== Double encode/decode ==========
+  // Two-step multiplication matching C++ to produce identical floating-point rounding.
 
+  /** Encode: round(value * 10^exponent * 10^(-factor)) */
   static long encodeDouble(double value, int exponent, int factor) {
-    return fastRoundDouble(value * getDoubleMultiplier(exponent, factor));
+    return fastRoundDouble(value * DOUBLE_POW10[exponent] * DOUBLE_POW10_NEGATIVE[factor]);
   }
 
+  /** Decode: encoded * 10^factor * 10^(-exponent) */
   static double decodeDouble(long encoded, int exponent, int factor) {
-    return encoded / getDoubleMultiplier(exponent, factor);
+    return (double) encoded * DOUBLE_POW10[factor] * DOUBLE_POW10_NEGATIVE[exponent];
   }
 
   // Same trick but with 2^51+2^52 for double precision.