introduce bitloops

src/main/java/puzzle/Export.java

@@ -3,14 +3,14 @@ package puzzle;
 import lombok.Getter;
 import lombok.experimental.Accessors;
 import lombok.experimental.Delegate;
-import puzzle.Export.Gridded;
 import puzzle.SwedishGenerator.Dict;
 import puzzle.SwedishGenerator.FillResult;
 import puzzle.SwedishGenerator.Grid;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
-import java.util.StringJoiner;
+import java.util.function.IntSupplier;
+import java.util.stream.IntStream;
 import static puzzle.SwedishGenerator.R;
 import static puzzle.SwedishGenerator.Lemma;
 import static puzzle.SwedishGenerator.Slot;
@@ -38,6 +38,55 @@ public record Export() {
    record Gridded(@Delegate Grid grid) {
       
       static boolean isLetter(byte b) { return (b & SwedishGenerator.B64) != SwedishGenerator.B0; }
+      public static IntStream walk(byte base, long lo, long hi) {
+         if (Slot.increasing(base)) {
+            return IntStream.concat(
+                    IntStream.generate(new IntSupplier() {
+                       
+                       long temp = lo;
+                       @Override
+                       public int getAsInt() {
+                          int res = Long.numberOfTrailingZeros(temp);
+                          temp &= temp - 1;
+                          return res;
+                       }
+                    }).limit(Long.bitCount(lo)),
+                    IntStream.generate(new IntSupplier() {
+                       
+                       long temp = hi;
+                       @Override
+                       public int getAsInt() {
+                          int res = 64 | Long.numberOfTrailingZeros(temp);
+                          temp &= temp - 1;
+                          return res;
+                       }
+                    }).limit(Long.bitCount(hi)));
+         } else {
+            return IntStream.concat(
+                    IntStream.generate(new IntSupplier() {
+                       
+                       long temp = hi;
+                       @Override
+                       public int getAsInt() {
+                          int msb = 63 - Long.numberOfLeadingZeros(temp);
+                          int res = 64 | msb;
+                          temp &= ~(1L << msb);
+                          return res;
+                       }
+                    }).limit(Long.bitCount(hi)),
+                    IntStream.generate(new IntSupplier() {
+                       
+                       long temp = lo;
+                       @Override
+                       public int getAsInt() {
+                          int msb = 63 - Long.numberOfLeadingZeros(temp);
+                          int res = msb;
+                          temp &= ~(1L << msb);
+                          return res;
+                       }
+                    }).limit(Long.bitCount(lo)));
+         }
+      }
       //public boolean isLetterSet(int idx)                { return isLetter(g[idx]); }
       char NOT_CLUE_NOT_LETTER_TO(byte b, char fallback) { return isLetter(b) ? (char) b : fallback; }
       String gridToString() {
@@ -123,8 +172,7 @@ public record Export() {
       Placed extractPlacedFromSlot(Slot s, long lemma) {
          var d = s.dir();
          
-         var cells = new int[s.len()];
+         var cells = s.walk().toArray();
-         for (int i = 0, len = s.len(); i < len; i++) cells[i] = s.pos(i);
          
          char direction;
          var  startRow = Grid.r(cells[0]);

src/main/java/puzzle/SwedishGenerator.java

@@ -3,7 +3,6 @@ package puzzle;
 import lombok.Getter;
 import lombok.val;
 import precomp.Neighbors9x8;
-import precomp.Neighbors9x8.nbrs_16;
 import precomp.Neighbors9x8.rci;
 import puzzle.Export.Bit;
 import puzzle.Export.Bit1029;
@@ -19,6 +18,7 @@ import java.util.Comparator;
 import java.util.HashMap;
 import java.util.Locale;
 import java.util.Map;
+import java.util.stream.IntStream;
 import static java.nio.charset.StandardCharsets.*;
 
 /**
@@ -321,37 +321,11 @@ public record SwedishGenerator(Rng rng) {
       public int clueIndex()                        { return key >>> BIT_FOR_DIR; }
       public int clueC()                            { return Grid.c((key >>> BIT_FOR_DIR)); }
       public int dir()                              { return key & 7; }
-      public boolean horiz()                      { return horiz(dir()); }
+      public boolean horiz()                        { return horiz(key); }
       public boolean reversed()                     { return (key & 2) == 0; }
       public boolean increasing()                   { return (key & 2) != 0; }
       public static boolean increasing(int dir)     { return (dir & 2) != 0; }
-      public int pos(int i) {
+      public IntStream walk()                       { return Gridded.walk((byte) key, lo, hi); }
-         if (increasing()) {
-            int bcLo = Long.bitCount(lo);
-            if (i < bcLo) {
-               long temp = lo;
-               for (int k = 0; k < i; k++) temp &= temp - 1;
-               return Long.numberOfTrailingZeros(temp);
-            } else {
-               i -= bcLo;
-               long temp = hi;
-               for (int k = 0; k < i; k++) temp &= temp - 1;
-               return 64 | Long.numberOfTrailingZeros(temp);
-            }
-         } else {
-            int bcHi = Long.bitCount(hi);
-            if (i < bcHi) {
-               long temp = hi;
-               for (int k = 0; k < i; k++) temp &= ~(1L << (63 - Long.numberOfLeadingZeros(temp)));
-               return 64 | (63 - Long.numberOfLeadingZeros(temp));
-            } else {
-               i -= bcHi;
-               long temp = lo;
-               for (int k = 0; k < i; k++) temp &= ~(1L << (63 - Long.numberOfLeadingZeros(temp)));
-               return 63 - Long.numberOfLeadingZeros(temp);
-            }
-         }
-      }
       public static boolean horiz(int d)            { return (d & 1) == 0; }
       public static int packSlotDir(int idx, int d) { return (idx << BIT_FOR_DIR) | d; }
    }

src/test/java/puzzle/MainTest.java

@@ -29,10 +29,11 @@ public class MainTest {
       assertEquals(1, slots.size());
       var s = slots.getFirst();
       assertEquals(8, s.len());
-      assertEquals(0, Grid.r(s.pos(0)));
+      var cells = s.walk().toArray();
-      assertEquals(1, Grid.c(s.pos(0)));
+      assertEquals(0, Grid.r(cells[0]));
-      assertEquals(0, Grid.r(s.pos(1)));
+      assertEquals(1, Grid.c(cells[0]));
-      assertEquals(2, Grid.c(s.pos(1)));
+      assertEquals(0, Grid.r(cells[1]));
+      assertEquals(2, Grid.c(cells[1]));
    }
    
    @Test

src/test/java/puzzle/SwedishGeneratorTest.java

@@ -152,12 +152,13 @@ public class SwedishGeneratorTest {
       assertEquals(3, s.clueC());
       assertEquals(3, s.dir());
       assertFalse(s.horiz());
-      assertEquals(2, Grid.r(s.pos(0)));
+      var cells = s.walk().toArray();
-      assertEquals(3, Grid.r(s.pos(1)));
+      assertEquals(2, Grid.r(cells[0]));
-      assertEquals(4, Grid.r(s.pos(2)));
+      assertEquals(3, Grid.r(cells[1]));
-      assertEquals(5, Grid.c(s.pos(0)));
+      assertEquals(4, Grid.r(cells[2]));
-      assertEquals(5, Grid.c(s.pos(1)));
+      assertEquals(5, Grid.c(cells[0]));
-      assertEquals(5, Grid.c(s.pos(2)));
+      assertEquals(5, Grid.c(cells[1]));
+      assertEquals(5, Grid.c(cells[2]));
       
       assertTrue(Slot.horiz(2)); // right
       assertFalse(Slot.horiz(3)); // down