bench: add jniReadClose/javaReadClose benchmarks for ALP-encoded F64

ALP result: JNI 57.3 ops/s vs Java 44.3 ops/s — Rust ALP decode
currently faster; per-element float multiply loop is next target.

Update README with full comparison table (volume + close).

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

Author: dfa1

README.md

@@ -6,17 +6,19 @@ Pure-Java reader/writer for the [Vortex](https://github.com/spiraldb/vortex) col
 
 ## Performance
 
-`RustVsJavaReadBenchmark` — 10M OHLC rows, project + sum `volume` (I64) column,
-JMH throughput (higher = better), Apple M-series, Java 25:
+`RustVsJavaReadBenchmark` — 10M OHLC rows, JMH throughput (higher = better), Apple M-series, Java 25:
 
-| Reader        | Throughput  | vs JNI  |
-|---------------|-------------|---------|
-| vortex-jni    | 51.9 ops/s  | 1×      |
-| vortex-java   | 120.7 ops/s | **2.3×** |
+| Column          | Encoding      | vortex-jni  | vortex-java  | ratio        |
+|-----------------|---------------|-------------|--------------|--------------|
+| `volume` (I64)  | primitive     | 51.9 ops/s  | 120.7 ops/s  | **Java 2.3×** |
+| `close` (F64)   | ALP           | 57.3 ops/s  | 44.3 ops/s   | JNI 1.3×     |
 
-JNI overhead: Arrow C Data Interface handshake + JNI boundary crossing + `VectorSchemaRoot`
-materialisation per batch. vortex-java reads directly from the mmap region via `MemorySegment`
-with zero copies and no intermediate format.
+`volume` (I64, primitive encoding): vortex-java wins decisively — no JNI boundary, no Arrow
+materialisation, direct `MemorySegment` read from the mmap region.
+
+`close` (F64, ALP-encoded): JNI currently wins — the Rust ALP inverse transform is more
+optimised than the Java implementation. The per-element float multiply loop is the next
+target for improvement.
 
 ## Motivation
 

performance/src/main/java/io/github/dfa1/vortex/performance/RustVsJavaReadBenchmark.java

@@ -157,6 +157,32 @@ public long jniReadVolume() throws IOException {
 		return sum;
 	}
 
+	/// JNI read: project on "close" (F64, ALP-encoded), sum all values.
+	@Benchmark
+	public double jniReadClose() throws IOException {
+		String uri = benchFile.toAbsolutePath().toUri().toString();
+		var opts = ScanOptions.builder()
+				.projection(Expression.select(new String[]{"close"}, Expression.root()))
+				.build();
+
+		double sum = 0.0;
+		DataSource ds = DataSource.open(SESSION, uri);
+		Scan scan = ds.scan(opts);
+		while (scan.hasNext()) {
+			Partition partition = scan.next();
+			try (ArrowReader reader = partition.scanArrow(allocator)) {
+				while (reader.loadNextBatch()) {
+					VectorSchemaRoot root = reader.getVectorSchemaRoot();
+					Float8Vector closeVec = (Float8Vector) root.getVector("close");
+					for (int i = 0; i < root.getRowCount(); i++) {
+						sum += closeVec.get(i);
+					}
+				}
+			}
+		}
+		return sum;
+	}
+
 	// ── JNI file generation ───────────────────────────────────────────────────
 
 	/// Java read: project on "volume", sum all values.
@@ -179,6 +205,26 @@ public long javaReadVolume() throws IOException {
 		return sum;
 	}
 
+	/// Java read: project on "close" (F64, ALP-encoded), sum all values.
+	@Benchmark
+	public double javaReadClose() throws IOException {
+		double sum = 0.0;
+		try (VortexReader vf = VortexReader.open(benchFile, registry)) {
+			var iter = vf.scan(io.github.dfa1.vortex.scan.ScanOptions.columns("close"));
+			while (iter.hasNext()) {
+				ScanResult r = iter.next();
+				Array arr = r.columns().get("close");
+				var layout = ValueLayout.JAVA_DOUBLE_UNALIGNED;
+				MemorySegment buffer = arr.buffer(0);
+				long count = buffer.byteSize() / layout.byteSize();
+				for (long i = 0; i < count; i++) {
+					sum += buffer.getAtIndex(layout, i);
+				}
+			}
+		}
+		return sum;
+	}
+
 	private void writeJni(Path path) throws IOException {
 		String uri = path.toAbsolutePath().toUri().toString();
 		try (dev.vortex.api.VortexWriter writer = dev.vortex.api.VortexWriter.create(