Version 1.8.0.

- Random-based functions take `RandomGenerator` arguments instead of `Random`.
- Add a `isPowerOf2` extension.

Author: charpov

.scalafmt.conf

@@ -1,5 +1,5 @@
-version = 3.8.3
-runner.dialect = scala3
+version = 3.9.10
+runner.dialect = scala36
 
 fileOverride {
   "glob:**/*.sbt" {
@@ -24,6 +24,7 @@ newlines {
   usingParamListModifierPrefer = before
   avoidForSimpleOverflow = [tooLong,punct,slc]
   avoidInResultType = true
+  forceBeforeMultilineAssign = def
 }
 
 spaces {
@@ -33,10 +34,6 @@ spaces {
 }
 
 literals {
-  long = Upper
-  float = Lower
-  double = Lower
-  hexPrefix = Lower
   hexDigits = Upper
   scientific = Upper
 }

J/src/main/java/tinyscalautils/java/Collection.java

@@ -1,6 +1,7 @@
 package tinyscalautils.java;
 
 import java.util.*;
+import java.util.random.RandomGenerator;
 
 public class Collection {
   private Collection() {
@@ -13,15 +14,15 @@ public static <A> Iterator<A> circular(Iterable<A> iterable) {
     return collection.circular(iterable);
   }
 
-  public static <A> Iterator<A> randomly(Iterable<A> iterable, Random rand) {
+  public static <A> Iterator<A> randomly(Iterable<A> iterable, RandomGenerator rand) {
     return collection.randomly(iterable, rand);
   }
 
-  public static <A> A pickOne(Iterable<A> iterable, Random rand) {
+  public static <A> A pickOne(Iterable<A> iterable, RandomGenerator rand) {
     return collection.pickOne(iterable, rand);
   }
 
-  public static <A> Optional<A> pickOneOption(Iterable<A> iterable, Random rand) {
+  public static <A> Optional<A> pickOneOption(Iterable<A> iterable, RandomGenerator rand) {
     return collection.pickOneOption(iterable, rand);
   }
 

J/src/main/java/tinyscalautils/java/Text.java

@@ -24,6 +24,10 @@ public static void print(Object ignoredArg) {
     public static void println(Object ignoredArg) {
     }
 
+    // added so SILENT_MODE.println() can easily replace STANDARD_MODE.println()
+    public static void println() {
+    }
+
     public static void printf(String ignoredFormat, Object... ignoredArgs) {
     }
   }
@@ -41,6 +45,11 @@ public static void println(Object arg) {
       textScala.standardMode().print(arg, true);
     }
 
+    // added so STANDARD_MODE.println() can easily replace System.out.println()
+    public static void println() {
+      println("");
+    }
+
     public static void printf(String format, Object... arg) {
       textScala.standardMode().print(String.format(format, arg), false);
     }
@@ -157,6 +166,10 @@ public static void info() {
     textScala.info();
   }
 
+  public static void info(int newlines) {
+    textScala.info(newlines);
+  }
+
   public static String plural(Number x, String singularForm, String pluralForm) {
     return textScala.plural(x, singularForm, pluralForm);
   }

J/src/main/java/tinyscalautils/java/Util.java

@@ -0,0 +1,41 @@
+package tinyscalautils.java;
+
+public class Util {
+  private Util() {
+    throw new AssertionError("this class cannot be instantiated");
+  }
+
+  private static final UtilScala util = new UtilScala();
+
+  public static boolean isEven(int n) {
+    return (n & 1) == 0;
+  }
+
+  public static boolean isEven(long n) {
+    return (n & 1L) == 0L;
+  }
+
+  public static boolean isOdd(int n) {
+    return (n & 1) != 0;
+  }
+
+  public static boolean isOdd(long n) {
+    return (n & 1L) != 0L;
+  }
+
+  public static int pow(int n, int m) {
+    return util.pow(n, m);
+  }
+
+  public static long pow(long n, int m) {
+    return util.pow(n, m);
+  }
+  
+  public static boolean isPowerOf2(int n) {
+    return util.isPowerOf2(n);
+  }
+
+  public static boolean isPowerOf2(long n) {
+    return util.isPowerOf2(n);
+  }
+}

J/src/main/scala/tinyscalautils/java/CollectionScala.scala

@@ -1,23 +1,30 @@
 package tinyscalautils.java
 
-import tinyscalautils.collection.{ circular, pickOne, randomly, pickOneOption }
+import tinyscalautils.collection.{ circular, pickOne, pickOneOption, randomly }
+import tinyscalautils.util.RandomAdapter
 
+import java.{ lang as jl, util as ju }
+import java.util.random.RandomGenerator
 import scala.jdk.CollectionConverters.{ IterableHasAsScala, IteratorHasAsJava }
-import scala.util.Random
 import scala.jdk.OptionConverters.RichOption
+import scala.util.Random
 
 private final class CollectionScala:
-   def circular[A](iterable: java.lang.Iterable[A]): java.util.Iterator[A] =
-      iterable.asScala.circular.asJava
+   def circular[A](iterable: jl.Iterable[A]): ju.Iterator[A] = iterable.asScala.circular.asJava
+
+   def randomly[A](iterable: jl.Iterable[A], rand: RandomGenerator): ju.Iterator[A] =
+      iterable.asScala.randomly(using Random(adapt(rand))).asJava
+
+   def pickOne[A](iterable: java.lang.Iterable[A], rand: RandomGenerator): A =
+      iterable.asScala.pickOne(using Random(adapt(rand)))
 
-   def randomly[A](iterable: java.lang.Iterable[A], rand: java.util.Random): java.util.Iterator[A] =
-      iterable.asScala.randomly(using Random(rand)).asJava
+   def pickOneOption[A](iterable: jl.Iterable[A], rand: RandomGenerator): ju.Optional[A] =
+      iterable.asScala.pickOneOption(using Random(adapt(rand))).toJava
 
-   def pickOne[A](iterable: java.lang.Iterable[A], rand: java.util.Random): A =
-      iterable.asScala.pickOne(using Random(rand))
+   private def adapt(randGen: RandomGenerator): ju.Random =
+      randGen match
+         case rand: ju.Random => rand
+         case _               => RandomGeneratorAdapter(randGen)
 
-   def pickOneOption[A](
-       iterable: java.lang.Iterable[A],
-       rand: java.util.Random
-   ): java.util.Optional[A] =
-      iterable.asScala.pickOneOption(using Random(rand)).toJava
+   private final class RandomGeneratorAdapter(randGen: RandomGenerator) extends RandomAdapter:
+      protected def rand = randGen

J/src/main/scala/tinyscalautils/java/TextScala.scala

@@ -9,6 +9,8 @@ private final class TextScala:
       )
 
    def info(): Unit = tinyscalautils.text.info()
+   
+   def info(newlines: Int): Unit = tinyscalautils.text.info(newlines)
 
    def plural(x: Number, singularForm: String, pluralForm: String): String =
       tinyscalautils.text.plural(x.doubleValue(), singularForm, pluralForm)

J/src/main/scala/tinyscalautils/java/UtilScala.scala

@@ -0,0 +1,11 @@
+package tinyscalautils.java
+
+import tinyscalautils.util.pow
+import tinyscalautils.util.isPowerOf2
+
+private final class UtilScala:
+   def pow(n: Int, m: Int): Int   = n.pow(m)
+   def pow(n: Long, m: Int): Long = n.pow(m)
+
+   def isPowerOf2(n: Int) = n.isPowerOf2
+   def isPowerOf2(n: Long) = n.isPowerOf2

J/src/test/java/PrintoutSuite.java

@@ -9,12 +9,14 @@ public class PrintoutSuite {
   @Test
   void testPrintout() {
     assertEquals("X\n", printout(() -> println("X")));
+    assertEquals("\n", printout(() -> println()));
     assertEquals("X", printout(() -> printf("%s","X")));
   }
 
   @Test
   void testPrintoutStandard() {
     assertEquals("X\n", printout(() -> System.out.println("X")));
+    assertEquals("\n", printout(() -> System.out.println()));
     assertEquals("X", printout(() -> System.out.printf("%s","X")));
   }
 }

J/src/test/java/TextSuite.java

@@ -1,8 +1,6 @@
 import org.junit.jupiter.api.Test;
 import tinyscalautils.java.Text;
 
-import java.util.stream.Collectors;
-
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static tinyscalautils.java.Text.*;
@@ -12,13 +10,15 @@ public class TextSuite {
   void testSilent() {
     assertTrue(printout(() -> SILENT_MODE.print("X")).isEmpty());
     assertTrue(printout(() -> SILENT_MODE.println("X")).isEmpty());
+    assertTrue(printout(() -> SILENT_MODE.println()).isEmpty());
     assertTrue(printout(() -> SILENT_MODE.printf("%s", "X")).isEmpty());
   }
 
   @Test
   void testStandard() {
     assertEquals("X", printout(() -> STANDARD_MODE.print("X")));
     assertEquals("X\n", printout(() -> STANDARD_MODE.println("X")));
+    assertEquals("\n", printout(() -> STANDARD_MODE.println()));
     assertEquals("X", printout(() -> STANDARD_MODE.printf("%s", "X")));
   }
 
@@ -80,11 +80,22 @@ void testPlural() {
 
   @Test
   void testInfo() {
-    var lines = printout(Text::info).lines().collect(Collectors.toList());
-    assertEquals(3, lines.size());
-    assertTrue(lines.get(0).startsWith("Java"));
-    assertTrue(lines.get(1).endsWith("processors") || lines.get(1).endsWith("processor"));
-    assertTrue(lines.get(2).endsWith("maximum memory"));
+    var lines = printout(Text::info).lines().toList();
+    assertEquals(4, lines.size());
+    assertTrue(lines.get(0).contains("Java"));
+    assertTrue(lines.get(2).endsWith("processors") || lines.get(2).endsWith("processor"));
+    assertTrue(lines.get(3).endsWith("maximum memory"));
+  }
+
+  @Test
+  void testInfoNewlines() {
+    var lines = printout(() -> Text.info(2)).lines().toList();
+    assertEquals(6, lines.size());
+    assertTrue(lines.get(0).contains("Java"));
+    assertTrue(lines.get(2).endsWith("processors") || lines.get(2).endsWith("processor"));
+    assertTrue(lines.get(3).endsWith("maximum memory"));
+    assertTrue(lines.get(4).isEmpty());
+    assertTrue(lines.get(5).isEmpty());
   }
 
   @Test

J/src/test/java/UtilSuite.java

@@ -0,0 +1,74 @@
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static tinyscalautils.java.Util.*;
+
+public class UtilSuite {
+  @Test
+  void testPow() {
+    assertThrows(IllegalArgumentException.class, () -> pow(2, -1));
+    assertEquals(1, pow(0, 0));
+    assertEquals(0, pow(0, 1));
+    assertEquals(1, pow(1, 0));
+    assertEquals(1, pow(1, 100_000));
+    assertEquals(1, pow(2, 0));
+    assertEquals(1024, pow(2, 10));
+    assertEquals(2048, pow(2, 11));
+    assertEquals(1L, pow(2L, 0));
+    assertEquals(1073741824L, pow(2L, 30));
+    assertEquals(536870912L, pow(2L, 29));
+    assertEquals(576460752303423488L, pow(2L, 59));
+    assertEquals(59049, pow(3, 10));
+    assertEquals(205891132094649L, pow(3L, 30));
+  }
+
+  @Test
+  void testEvenOddInt() {
+    assertTrue(isEven(42));
+    assertTrue(isEven(-42));
+    assertFalse(isEven(41));
+    assertFalse(isEven(-41));
+    assertFalse(isOdd(42));
+    assertFalse(isOdd(-42));
+    assertTrue(isOdd(41));
+    assertTrue(isOdd(-41));
+  }
+
+  @Test
+  void testEvenOddLong() {
+    assertTrue(isEven(42L));
+    assertTrue(isEven(-42L));
+    assertFalse(isEven(41L));
+    assertFalse(isEven(-41L));
+    assertFalse(isOdd(42L));
+    assertFalse(isOdd(-42L));
+    assertTrue(isOdd(41L));
+    assertTrue(isOdd(-41L));
+  }
+
+  @Test
+  void testIsPowerOf2Int() {
+    assertThrows(IllegalArgumentException.class, () -> isPowerOf2(-1));
+    assertFalse(isPowerOf2(3));
+    assertFalse(isPowerOf2(5));
+    assertFalse(isPowerOf2(6));
+    assertFalse(isPowerOf2(7));
+    for (int n = 1073741825; n < 2147483647; n++)
+         assertFalse(isPowerOf2(n));
+    for (int n = 1, c = 0; c < 31; c++, n <<= 1)
+         assertTrue(isPowerOf2(n));
+  }
+
+  @Test
+  void testIsPowerOf2Long() {
+    assertThrows(IllegalArgumentException.class, () -> isPowerOf2(-1L));
+    assertFalse(isPowerOf2(3L));
+    assertFalse(isPowerOf2(5L));
+    assertFalse(isPowerOf2(6L));
+    assertFalse(isPowerOf2(7L));
+    for (long n = 2147483649L; n <= 4294967295L; n++)
+         assertFalse(isPowerOf2(n));
+    for (long n = 1L, c = 0; c < 63; c++, n <<= 1)
+         assertTrue(isPowerOf2(n));
+  }
+}