feat(array): add fold to IntArray, FloatArray, ShortArray, ByteArray

Consistent with LongArray/DoubleArray. Uses appropriate functional interfaces:
IntBinaryOperator for IntArray, DoubleBinaryOperator for FloatArray,
LongBinaryOperator for ShortArray/ByteArray (avoids overflow).

Simplify non-nullable branches in numericSum to use fold.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: dfa1

core/src/main/java/io/github/dfa1/vortex/core/array/ByteArray.java

@@ -6,6 +6,7 @@
 
 import java.lang.foreign.MemorySegment;
 import java.lang.foreign.ValueLayout;
+import java.util.function.LongBinaryOperator;
 
 /// Concrete [Array] for I8/U8 primitive columns.
 public final class ByteArray implements Array {
@@ -53,4 +54,14 @@ public int getInt(long i) {
 		boolean unsigned = dtype instanceof DType.Primitive p && p.ptype() == PType.U8;
 		return unsigned ? Byte.toUnsignedInt(raw) : raw;
 	}
+
+	public long fold(long identity, LongBinaryOperator op) {
+		MemorySegment buf = buffer;
+		long n = length;
+		long result = identity;
+		for (long i = 0; i < n; i++) {
+			result = op.applyAsLong(result, buf.get(ValueLayout.JAVA_BYTE, i));
+		}
+		return result;
+	}
 }

core/src/main/java/io/github/dfa1/vortex/core/array/FloatArray.java

@@ -5,6 +5,7 @@
 import io.github.dfa1.vortex.encoding.PTypeIO;
 
 import java.lang.foreign.MemorySegment;
+import java.util.function.DoubleBinaryOperator;
 
 /// Concrete [Array] for F32 primitive columns.
 public final class FloatArray implements Array {
@@ -46,4 +47,14 @@ public MemorySegment buffer(int i) {
 	public float getFloat(long i) {
 		return buffer.getAtIndex(PTypeIO.LE_FLOAT, i);
 	}
+
+	public double fold(double identity, DoubleBinaryOperator op) {
+		MemorySegment buf = buffer;
+		long n = length;
+		double result = identity;
+		for (long i = 0; i < n; i++) {
+			result = op.applyAsDouble(result, buf.getAtIndex(PTypeIO.LE_FLOAT, i));
+		}
+		return result;
+	}
 }

core/src/main/java/io/github/dfa1/vortex/core/array/IntArray.java

@@ -4,6 +4,7 @@
 import io.github.dfa1.vortex.core.DType;
 import io.github.dfa1.vortex.encoding.PTypeIO;
 import java.lang.foreign.MemorySegment;
+import java.util.function.IntBinaryOperator;
 import java.util.function.IntConsumer;
 
 /// Concrete [Array] for I32/U32 primitive columns.
@@ -54,4 +55,14 @@ public void forEachInt(IntConsumer c) {
 			c.accept(buf.getAtIndex(PTypeIO.LE_INT, i));
 		}
 	}
+
+	public int fold(int identity, IntBinaryOperator op) {
+		MemorySegment buf = buffer;
+		long n = length;
+		int result = identity;
+		for (long i = 0; i < n; i++) {
+			result = op.applyAsInt(result, buf.getAtIndex(PTypeIO.LE_INT, i));
+		}
+		return result;
+	}
 }

core/src/main/java/io/github/dfa1/vortex/core/array/ShortArray.java

@@ -6,6 +6,7 @@
 import io.github.dfa1.vortex.encoding.PTypeIO;
 
 import java.lang.foreign.MemorySegment;
+import java.util.function.LongBinaryOperator;
 
 /// Concrete [Array] for I16/U16 primitive columns.
 public final class ShortArray implements Array {
@@ -53,4 +54,14 @@ public int getInt(long i) {
 		boolean unsigned = dtype instanceof DType.Primitive p && p.ptype() == PType.U16;
 		return unsigned ? Short.toUnsignedInt(raw) : raw;
 	}
+
+	public long fold(long identity, LongBinaryOperator op) {
+		MemorySegment buf = buffer;
+		long n = length;
+		long result = identity;
+		for (long i = 0; i < n; i++) {
+			result = op.applyAsLong(result, buf.getAtIndex(PTypeIO.LE_SHORT, i));
+		}
+		return result;
+	}
 }

integration/src/test/java/io/github/dfa1/vortex/integration/VortexHttpReaderJniComparisonIntegrationTest.java

@@ -339,27 +339,9 @@ private static Double numericSum(Array arr) {
 		return switch (arr) {
 			case LongArray v -> (double) v.fold(0L, Long::sum);
 			case DoubleArray v -> v.fold(0.0, Double::sum);
-			case IntArray v -> {
-				long s = 0;
-				for (long i = 0; i < v.length(); i++) {
-					s += v.getInt(i);
-				}
-				yield (double) s;
-			}
-			case FloatArray v -> {
-				double s = 0;
-				for (long i = 0; i < v.length(); i++) {
-					s += v.getFloat(i);
-				}
-				yield s;
-			}
-			case ShortArray v -> {
-				long s = 0;
-				for (long i = 0; i < v.length(); i++) {
-					s += v.getShort(i);
-				}
-				yield (double) s;
-			}
+			case IntArray v -> (double) v.fold(0, Integer::sum);
+			case FloatArray v -> v.fold(0.0, Double::sum);
+			case ShortArray v -> (double) v.fold(0L, Long::sum);
 			default -> null;
 		};
 	}