refactor(core): add PType.isUnsigned, drop 3 private copies; test new helpers

isUnsigned(ptype) was copy-pasted in the Delta, Bitpacked and FrameOfReference
encoders. It is exactly the complement of the existing PType.isSigned() (every
non-unsigned ptype is a signed integer or floating-point), so add PType.isUnsigned()
returning !isSigned() and route the call sites through it.

Tests:
- PTypeTest: isUnsigned true/false partitions + an exact-complement-of-isSigned
  property over every enum constant.
- PrimitiveArraysTest (new, for the prior extraction): toLongs sign/zero-extension
  per width, I64 passthrough identity, floating-ptype throw carrying the caller's
  EncodingId; fromLongs round-trip through toLongs, little-endian I64 layout, and
  low-byte-only narrowing.

Ground truth green: JavaWritesRustReads (213) + JavaRoundTrip.

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

Author: dfa1

core/src/main/java/io/github/dfa1/vortex/core/PType.java

@@ -56,6 +56,14 @@ public boolean isSigned() {
                        || this == F16 || this == F32 || this == F64;
     }
 
+    /// Returns `true` for the unsigned integer types (`U8`–`U64`) — the complement of
+    /// [#isSigned()], since every non-unsigned ptype is either a signed integer or floating-point.
+    ///
+    /// @return `true` if this ptype is an unsigned integer
+    public boolean isUnsigned() {
+        return !isSigned();
+    }
+
     /// Returns the [PType] for the given enum ordinal — the integer value the wire format
     /// uses to identify a physical type.
     ///

core/src/test/java/io/github/dfa1/vortex/core/PTypeTest.java

@@ -51,6 +51,27 @@ void isSigned_falseForUnsigned(PType ptype) {
         assertThat(ptype.isSigned()).isFalse();
     }
 
+    @ParameterizedTest
+    @EnumSource(value = PType.class, names = {"U8", "U16", "U32", "U64"})
+    void isUnsigned_trueForUnsigned(PType ptype) {
+        // Given / When / Then
+        assertThat(ptype.isUnsigned()).isTrue();
+    }
+
+    @ParameterizedTest
+    @EnumSource(value = PType.class, names = {"I8", "I16", "I32", "I64", "F16", "F32", "F64"})
+    void isUnsigned_falseForSignedAndFloats(PType ptype) {
+        // Given / When / Then
+        assertThat(ptype.isUnsigned()).isFalse();
+    }
+
+    @ParameterizedTest
+    @EnumSource(PType.class)
+    void isUnsigned_isExactComplementOfIsSigned(PType ptype) {
+        // Given / When / Then — the two must partition every ptype; isUnsigned is defined as !isSigned
+        assertThat(ptype.isUnsigned()).isNotEqualTo(ptype.isSigned());
+    }
+
     @ParameterizedTest
     @EnumSource(PType.class)
     void fromOrdinal_roundTrips(PType ptype) {

core/src/test/java/io/github/dfa1/vortex/encoding/PrimitiveArraysTest.java

@@ -0,0 +1,170 @@
+package io.github.dfa1.vortex.encoding;
+
+import io.github.dfa1.vortex.core.PType;
+import io.github.dfa1.vortex.core.VortexException;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.EnumSource;
+
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.foreign.ValueLayout;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class PrimitiveArraysTest {
+
+    @Test
+    void toLongs_i8_signExtends() {
+        // Given a byte array with a negative value
+        byte[] data = {0, 1, -1, Byte.MIN_VALUE, Byte.MAX_VALUE};
+
+        // When
+        long[] result = PrimitiveArrays.toLongs(data, PType.I8, EncodingId.FASTLANES_DELTA);
+
+        // Then negatives sign-extend to 64 bits
+        assertThat(result).containsExactly(0L, 1L, -1L, -128L, 127L);
+    }
+
+    @Test
+    void toLongs_u8_zeroExtends() {
+        // Given a byte array whose high bit is set (would be negative if signed)
+        byte[] data = {0, 1, -1, Byte.MIN_VALUE};
+
+        // When
+        long[] result = PrimitiveArrays.toLongs(data, PType.U8, EncodingId.FASTLANES_DELTA);
+
+        // Then the raw byte is zero-extended into 0..255
+        assertThat(result).containsExactly(0L, 1L, 255L, 128L);
+    }
+
+    @Test
+    void toLongs_i16_signExtends() {
+        // Given
+        short[] data = {0, -1, Short.MIN_VALUE, Short.MAX_VALUE};
+
+        // When
+        long[] result = PrimitiveArrays.toLongs(data, PType.I16, EncodingId.FASTLANES_DELTA);
+
+        // Then
+        assertThat(result).containsExactly(0L, -1L, -32768L, 32767L);
+    }
+
+    @Test
+    void toLongs_u16_zeroExtends() {
+        // Given a value with the high bit set
+        short[] data = {-1, Short.MIN_VALUE};
+
+        // When
+        long[] result = PrimitiveArrays.toLongs(data, PType.U16, EncodingId.FASTLANES_DELTA);
+
+        // Then zero-extended into 0..65535
+        assertThat(result).containsExactly(65535L, 32768L);
+    }
+
+    @Test
+    void toLongs_i32_signExtends() {
+        // Given
+        int[] data = {0, -1, Integer.MIN_VALUE, Integer.MAX_VALUE};
+
+        // When
+        long[] result = PrimitiveArrays.toLongs(data, PType.I32, EncodingId.FASTLANES_DELTA);
+
+        // Then
+        assertThat(result).containsExactly(0L, -1L, (long) Integer.MIN_VALUE, (long) Integer.MAX_VALUE);
+    }
+
+    @Test
+    void toLongs_u32_zeroExtends() {
+        // Given a value with the high bit set
+        int[] data = {-1, Integer.MIN_VALUE};
+
+        // When
+        long[] result = PrimitiveArrays.toLongs(data, PType.U32, EncodingId.FASTLANES_DELTA);
+
+        // Then zero-extended into 0..2^32-1
+        assertThat(result).containsExactly(0xFFFF_FFFFL, 0x8000_0000L);
+    }
+
+    @Test
+    void toLongs_i64_returnsSameArrayNoCopy() {
+        // Given a long array
+        long[] data = {1L, -1L, Long.MIN_VALUE, Long.MAX_VALUE};
+
+        // When
+        long[] result = PrimitiveArrays.toLongs(data, PType.I64, EncodingId.FASTLANES_DELTA);
+
+        // Then the I64/U64 path is a passthrough — no copy
+        assertThat(result).isSameAs(data);
+    }
+
+    @ParameterizedTest
+    @EnumSource(value = PType.class, names = {"F16", "F32", "F64"})
+    void toLongs_floatingPtypes_throwWithSuppliedEncodingId(PType ptype) {
+        // Given floating ptypes are not integer-widen targets; When/Then it throws, attributed to
+        // the caller's encoding id (here FrameOfReference) rather than a hardcoded one
+        assertThatThrownBy(() -> PrimitiveArrays.toLongs(new float[1], ptype, EncodingId.FASTLANES_FOR))
+                .isInstanceOf(VortexException.class)
+                .hasMessageContaining("unsupported ptype: " + ptype);
+    }
+
+    @ParameterizedTest
+    @EnumSource(value = PType.class, names = {"I8", "U8", "I16", "U16", "I32", "U32", "I64", "U64"})
+    void fromLongs_roundTripsThroughToLongs(PType ptype) {
+        // Given values that exercise the low bytes at each width
+        long[] original = {0L, 1L, 2L, 7L, 42L};
+
+        try (Arena arena = Arena.ofConfined()) {
+            // When written to a segment and read back at the ptype's width
+            MemorySegment seg = PrimitiveArrays.fromLongs(original, ptype, arena);
+
+            // Then the segment has one element per value at the expected width...
+            assertThat(seg.byteSize()).isEqualTo((long) original.length * ptype.byteSize());
+            // ...and each element round-trips (values are small + positive, so width-narrowing is lossless)
+            for (int i = 0; i < original.length; i++) {
+                assertThat(readElement(seg, ptype, i)).isEqualTo(original[i]);
+            }
+        }
+    }
+
+    @Test
+    void fromLongs_i64_writesLittleEndian() {
+        // Given a single value with distinct bytes
+        long[] original = {0x0102_0304_0506_0708L};
+
+        try (Arena arena = Arena.ofConfined()) {
+            // When written via the bulk I64 path
+            MemorySegment seg = PrimitiveArrays.fromLongs(original, PType.I64, arena);
+
+            // Then it is stored little-endian (lowest byte first)
+            assertThat(seg.get(ValueLayout.JAVA_BYTE, 0)).isEqualTo((byte) 0x08);
+            assertThat(seg.getAtIndex(PTypeIO.LE_LONG, 0)).isEqualTo(0x0102_0304_0506_0708L);
+        }
+    }
+
+    @Test
+    void fromLongs_narrowWidth_keepsOnlyLowBytes() {
+        // Given a value whose high bytes exceed the target width
+        long[] original = {0x1234_5678L};
+
+        try (Arena arena = Arena.ofConfined()) {
+            // When narrowed to I8 (1 byte/elem)
+            MemorySegment seg = PrimitiveArrays.fromLongs(original, PType.I8, arena);
+
+            // Then only the low byte survives
+            assertThat(seg.byteSize()).isEqualTo(1L);
+            assertThat(seg.get(ValueLayout.JAVA_BYTE, 0)).isEqualTo((byte) 0x78);
+        }
+    }
+
+    private static long readElement(MemorySegment seg, PType ptype, int i) {
+        return switch (ptype) {
+            case I8, U8 -> seg.get(ValueLayout.JAVA_BYTE, i);
+            case I16, U16 -> seg.getAtIndex(PTypeIO.LE_SHORT, i);
+            case I32, U32 -> seg.getAtIndex(PTypeIO.LE_INT, i);
+            case I64, U64 -> seg.getAtIndex(PTypeIO.LE_LONG, i);
+            default -> throw new IllegalArgumentException("not an integer ptype: " + ptype);
+        };
+    }
+}

writer/src/main/java/io/github/dfa1/vortex/writer/encode/BitpackedEncodingEncoder.java

@@ -48,7 +48,7 @@ public EncodeResult encode(DType dtype, Object data, EncodeContext ctx) {
         int n = longs.length;
         int typeBits = ptype.byteSize() * 8;
         long typeMask = typeMask(typeBits);
-        boolean unsign = isUnsigned(ptype);
+        boolean unsign = ptype.isUnsigned();
 
         long signedMin = 0L;
         long signedMax = 0L;
@@ -243,15 +243,8 @@ private static long typeMask(int typeBits) {
         return typeBits == 64 ? -1L : (1L << typeBits) - 1L;
     }
 
-    private static boolean isUnsigned(PType ptype) {
-        return switch (ptype) {
-            case U8, U16, U32, U64 -> true;
-            default -> false;
-        };
-    }
-
     private static byte[] statsBytes(PType ptype, long value) {
-        if (isUnsigned(ptype)) {
+        if (ptype.isUnsigned()) {
             return ScalarValue.ofUint64Value(value).encode();
         }
         return ScalarValue.ofInt64Value(value).encode();

writer/src/main/java/io/github/dfa1/vortex/writer/encode/DeltaEncodingEncoder.java

@@ -42,7 +42,7 @@ public EncodeResult encode(DType dtype, Object data, EncodeContext ctx) {
         int typeBits = typeBits(ptype);
         int lanes = lanes(ptype);
         long mask = typeMask(ptype);
-        boolean unsign = isUnsigned(ptype);
+        boolean unsign = ptype.isUnsigned();
 
         long minVal = 0L;
         long maxVal = 0L;
@@ -117,15 +117,8 @@ private static void deltaChunk(long[] transposed, long[] bases, int lanes, int t
         }
     }
 
-    private static boolean isUnsigned(PType ptype) {
-        return switch (ptype) {
-            case U8, U16, U32, U64 -> true;
-            default -> false;
-        };
-    }
-
     private static byte[] statsBytes(PType ptype, long value) {
-        if (isUnsigned(ptype)) {
+        if (ptype.isUnsigned()) {
             return ScalarValue.ofUint64Value(value).encode();
         }
         return ScalarValue.ofInt64Value(value).encode();

writer/src/main/java/io/github/dfa1/vortex/writer/encode/FrameOfReferenceEncodingEncoder.java

@@ -60,7 +60,7 @@ public CascadeStep encodeCascade(DType dtype, Object data, EncodeContext encodeC
         // Skip when ref == 0 and ptype is unsigned: residuals == input, so FOR adds metadata
         // overhead (ref scalar + extra node) for zero compression benefit over plain bitpack.
         // Matches Rust IntFoRScheme's skip estimate for this case.
-        if (ref == 0L && isUnsigned(ptype)) {
+        if (ref == 0L && ptype.isUnsigned()) {
             return CascadeStep.notApplicable();
         }
         ByteBuffer meta = buildForMeta(ref, ptype);
@@ -70,12 +70,6 @@ public CascadeStep encodeCascade(DType dtype, Object data, EncodeContext encodeC
         return new CascadeStep(partialRoot, List.of(), List.of(slot), null, null, true);
     }
 
-    private static boolean isUnsigned(PType ptype) {
-        return switch (ptype) {
-            case U8, U16, U32, U64 -> true;
-            default -> false;
-        };
-    }
 
     private static long computeRef(long[] longs, int n) {
         long ref = n > 0 ? longs[0] : 0L;