init

Author: lemire

README.md

@@ -0,0 +1,72 @@
+## JavaFastPFOR demo
+
+This small Maven project shows how to use JavaFastPFOR (from the fast-pack/JavaFastPFOR repository) to compress and uncompress an int[] using `FastPFOR128`.
+
+## Prerequisites
+
+- JDK 21 installed and available on your PATH
+- Maven 3.6+ (tested with Maven 3.9)
+
+Verify with:
+
+```bash
+mvn -v
+java -version
+```
+
+## Maven dependency (JitPack)
+
+Add the JitPack repository to your `pom.xml` and use the exact coordinates published for this project. The project exposes the artifact as `JavaFastPFOR` with a tag-style version. For example:
+
+```xml
+<repositories>
+    <repository>
+        <id>jitpack.io</id>
+        <url>https://jitpack.io</url>
+    </repository>
+</repositories>
+
+<dependency>
+    <groupId>com.github.fast-pack</groupId>
+    <artifactId>JavaFastPFOR</artifactId>
+    <version>JavaFastPFOR-0.3.0</version>
+</dependency>
+```
+
+Note: coordinates are case-sensitive. Using `JavaFastPFor` (different case) or a short `0.3.0` version may fail if that exact artifact/version was not published.
+
+## Build
+
+Download dependencies and compile:
+
+```bash
+mvn -U package
+```
+
+If Maven cached a failed resolution you can clear the specific cached artifact and retry:
+
+```bash
+rm -rf ~/.m2/repository/com/github/fast-pack/JavaFastPFOR
+mvn -U package
+```
+
+## Run the demo
+
+Run the `Main` class included in this project:
+
+```bash
+mvn exec:java -Dexec.mainClass=org.example.Main
+```
+
+The demo compresses an array of length 9984, then uncompresses it and prints a small verification summary. Example output:
+
+```
+N=9984 compressedSizeWords=XXX mismatches=0
+first 20 original: [0, 0, 0, ...]
+first 20 recovered: [0, 0, 0, ...]
+```
+
+## Troubleshooting
+
+- "Could not find artifact ..." when building: check that the `artifactId` and `version` in your `pom.xml` exactly match what JitPack exposes (case-sensitive). Use the repository page `https://jitpack.io/#fast-pack/JavaFastPFOR` to inspect available versions/tags.
+- If JitPack builds are failing for a tag, try using the exact commit hash or `master-SNAPSHOT` while debugging.

pom.xml

@@ -0,0 +1,30 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>org.example</groupId>
+    <artifactId>javafastpfor-demo</artifactId>
+    <version>0.1.0-SNAPSHOT</version>
+    <name>JavaFastPFor Demo</name>
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.source>21</maven.compiler.source>
+        <maven.compiler.target>21</maven.compiler.target>
+        <maven.compiler.release>21</maven.compiler.release>
+    </properties>
+
+    <repositories>
+        <repository>
+            <id>jitpack.io</id>
+            <url>https://jitpack.io</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+    <dependency>
+            <groupId>com.github.fast-pack</groupId>
+            <artifactId>JavaFastPFor</artifactId>
+            <version>JavaFastPFOR-0.3.1</version>
+        </dependency>
+    </dependencies>
+</project>

src/main/java/org/example/Main.java

@@ -0,0 +1,41 @@
+package org.example;
+
+import me.lemire.integercompression.FastPFOR128;
+import me.lemire.integercompression.IntWrapper;
+
+import java.util.Arrays;
+
+public class Main {
+    public static void main(String[] args) {
+        FastPFOR128 fastpfor = new FastPFOR128();
+
+        int N = 9984;
+        int[] data = new int[N];
+        for (var i = 0; i < N; i += 150) {
+            data[i] = i;
+        }
+
+        int[] compressedoutput1 = new int[N + 1024];
+
+        IntWrapper inputoffset1 = new IntWrapper(0);
+        IntWrapper outputoffset1 = new IntWrapper(0);
+
+        fastpfor.compress(data, inputoffset1, N, compressedoutput1, outputoffset1);
+        int compressedsize1 = outputoffset1.get();
+
+        int[] recovered1 = new int[N];
+        inputoffset1 = new IntWrapper(0);
+        outputoffset1 = new IntWrapper(0);
+        fastpfor.uncompress(compressedoutput1, outputoffset1, compressedsize1, recovered1, inputoffset1);
+
+        // quick verification: count mismatches
+        int mismatches = 0;
+        for (int i = 0; i < N; i++) {
+            if (data[i] != recovered1[i]) mismatches++;
+        }
+
+        System.out.println("N=" + N + " compressedSizeWords=" + compressedsize1 + " mismatches=" + mismatches);
+        System.out.println("first 20 original: " + Arrays.toString(Arrays.copyOf(data, 20)));
+        System.out.println("first 20 recovered: " + Arrays.toString(Arrays.copyOf(recovered1, 20)));
+    }
+}