refactor(array): hoist elementCount into AbstractMaterializedArray

Derive the broadcast element count once in the base class from the dtype's
PType byteSize instead of duplicating buffer.byteSize() / width in all six
numeric Materialized* leaves. Bool and Float16 (never broadcast) fall back
to length.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: dfa1

reader/src/main/java/io/github/dfa1/vortex/reader/array/AbstractMaterializedArray.java

@@ -23,11 +23,19 @@ abstract class AbstractMaterializedArray {
     final DType dtype;
     final long length;
     final MemorySegment buffer;
+    /// Number of physical elements the buffer actually holds, derived from its byte size
+    /// and the element width. Equals [#length] except for broadcast buffers (e.g. a
+    /// `ConstantEncoding` of one element), where the leaf hot loops take `i % elementCount`.
+    final long elementCount;
 
     AbstractMaterializedArray(DType dtype, long length, MemorySegment buffer) {
         this.dtype = dtype;
         this.length = length;
         this.buffer = buffer;
+        this.elementCount = switch (dtype) {
+            case DType.Primitive p -> buffer.byteSize() / p.ptype().byteSize();
+            default -> length;
+        };
     }
 
     public final DType dtype() {

reader/src/main/java/io/github/dfa1/vortex/reader/array/MaterializedByteArray.java

@@ -12,16 +12,13 @@
 /// either materialises the output eagerly or has no lazy variant of its own.
 public final class MaterializedByteArray extends AbstractMaterializedArray implements ByteArray {
 
-    private final long elementCount;
-
     /// Constructs a `MaterializedByteArray` backed by the given buffer.
     ///
     /// @param dtype  logical type, must be a [io.github.dfa1.vortex.core.DType.Primitive] with ptype I8 or U8
     /// @param length number of logical elements
     /// @param buffer raw byte data (one byte per element)
     public MaterializedByteArray(DType dtype, long length, MemorySegment buffer) {
         super(dtype, length, buffer);
-        this.elementCount = buffer.byteSize();
     }
 
     @Override

reader/src/main/java/io/github/dfa1/vortex/reader/array/MaterializedDoubleArray.java

@@ -11,16 +11,13 @@
 /// either materialises the output eagerly or has no lazy variant of its own.
 public final class MaterializedDoubleArray extends AbstractMaterializedArray implements DoubleArray {
 
-    private final long elementCount;
-
     /// Constructs a `MaterializedDoubleArray` backed by the given buffer.
     ///
     /// @param dtype  logical type, must be a [io.github.dfa1.vortex.core.DType.Primitive] with ptype F64
     /// @param length number of logical elements
     /// @param buffer raw double data (8 bytes per element, little-endian)
     public MaterializedDoubleArray(DType dtype, long length, MemorySegment buffer) {
         super(dtype, length, buffer);
-        this.elementCount = buffer.byteSize() / PTypeIO.LE_DOUBLE.byteSize();
     }
 
     @Override

reader/src/main/java/io/github/dfa1/vortex/reader/array/MaterializedFloatArray.java

@@ -11,16 +11,13 @@
 /// either materialises the output eagerly or has no lazy variant of its own.
 public final class MaterializedFloatArray extends AbstractMaterializedArray implements FloatArray {
 
-    private final long elementCount;
-
     /// Creates a new `MaterializedFloatArray` backed by the given memory segment.
     ///
     /// @param dtype  logical type, must be F32
     /// @param length number of elements
     /// @param buffer little-endian float data (4 bytes per element)
     public MaterializedFloatArray(DType dtype, long length, MemorySegment buffer) {
         super(dtype, length, buffer);
-        this.elementCount = buffer.byteSize() / PTypeIO.LE_FLOAT.byteSize();
     }
 
     @Override

reader/src/main/java/io/github/dfa1/vortex/reader/array/MaterializedIntArray.java

@@ -12,16 +12,13 @@
 /// either materialises the output eagerly or has no lazy variant of its own.
 public final class MaterializedIntArray extends AbstractMaterializedArray implements IntArray {
 
-    private final long elementCount;
-
     /// Creates a new `MaterializedIntArray` backed by the given memory segment.
     ///
     /// @param dtype  logical type, must be I32 or U32
     /// @param length number of elements
     /// @param buffer little-endian int data (4 bytes per element)
     public MaterializedIntArray(DType dtype, long length, MemorySegment buffer) {
         super(dtype, length, buffer);
-        this.elementCount = buffer.byteSize() / PTypeIO.LE_INT.byteSize();
     }
 
     @Override

reader/src/main/java/io/github/dfa1/vortex/reader/array/MaterializedLongArray.java

@@ -12,16 +12,13 @@
 /// either materialises the output eagerly or has no lazy variant of its own.
 public final class MaterializedLongArray extends AbstractMaterializedArray implements LongArray {
 
-    private final long elementCount;
-
     /// Creates a new `MaterializedLongArray` backed by the given memory segment.
     ///
     /// @param dtype  logical type, must be I64 or U64
     /// @param length number of elements
     /// @param buffer little-endian long data (8 bytes per element)
     public MaterializedLongArray(DType dtype, long length, MemorySegment buffer) {
         super(dtype, length, buffer);
-        this.elementCount = buffer.byteSize() / PTypeIO.LE_LONG.byteSize();
     }
 
     @Override

reader/src/main/java/io/github/dfa1/vortex/reader/array/MaterializedShortArray.java

@@ -12,16 +12,13 @@
 /// either materialises the output eagerly or has no lazy variant of its own.
 public final class MaterializedShortArray extends AbstractMaterializedArray implements ShortArray {
 
-    private final long elementCount;
-
     /// Creates a new `MaterializedShortArray` backed by the given memory segment.
     ///
     /// @param dtype  logical type, must be I16 or U16
     /// @param length number of elements
     /// @param buffer little-endian short data (2 bytes per element)
     public MaterializedShortArray(DType dtype, long length, MemorySegment buffer) {
         super(dtype, length, buffer);
-        this.elementCount = buffer.byteSize() / PTypeIO.LE_SHORT.byteSize();
     }
 
     @Override