commit 4c737817408c7f6026a6a461497e9b9a2e1eeb58
Author: Leszek Koltunski <leszek@koltunski.pl>
Date:   Wed Jun 16 17:41:39 2021 +0200

    Minor.

diff --git a/src/main/java/org/distorted/objects/TwistyMinx.java b/src/main/java/org/distorted/objects/TwistyMinx.java
index becc83d5..0f8859d3 100644
--- a/src/main/java/org/distorted/objects/TwistyMinx.java
+++ b/src/main/java/org/distorted/objects/TwistyMinx.java
@@ -465,6 +465,13 @@ abstract class TwistyMinx extends TwistyObject
     return layer==0 ? ran : numLayers-1-ran;
     }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  private boolean areOpposite(int oldAxis, int newAxis, int oldRow, int nom)
+    {
+    return OPPOSITE_ROWS[oldAxis][newAxis]^(oldRow<nom);
+    }
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   private int retNewRotationIndex(Random rnd, int nom, int[] oldRot)
@@ -476,8 +483,7 @@ abstract class TwistyMinx extends TwistyObject
       if( ax!=oldRot[0] )
         {
         mPossibleAxis[index] = ax;
-        boolean low = OPPOSITE_ROWS[oldRot[0]][ax]^(oldRot[1]<nom);
-        mPossibleLayers[index] = low ? 0:1;
+        mPossibleLayers[index] = areOpposite(oldRot[0],ax,oldRot[1],nom) ? 0:1;
         int tmp = mScrambleTable[mPossibleAxis[index]][mPossibleLayers[index]];
         if( tmp>max ) max=tmp;
         index++;
@@ -490,12 +496,11 @@ abstract class TwistyMinx extends TwistyObject
       mNumOccurences[ax] = max - value + (ax==0 ? 0 : mNumOccurences[ax-1]);
       }
 
-    float random= rnd.nextFloat();
-    int total = mNumOccurences[NUM_AXIS-2];
+    float random= rnd.nextFloat()*mNumOccurences[NUM_AXIS-2];
 
     for(int ax=0; ax<NUM_AXIS-1; ax++)
       {
-      if( random*total <= mNumOccurences[ax] )
+      if( random <= mNumOccurences[ax] )
         {
         index=ax;
         break;
@@ -514,11 +519,11 @@ abstract class TwistyMinx extends TwistyObject
     {
     int numLayers = getNumLayers();
     int nom = (numLayers-1)/2;
-    int row = rnd.nextInt(nom);
 
     if( curr==0 )
       {
       int lf = rnd.nextInt(2);
+      int row= rnd.nextInt(nom);
       scramble[curr][0] = rnd.nextInt(NUM_AXIS);
       scramble[curr][1] = (lf==0 ? row : numLayers-1-row);
       initializeScrambleTable(scramble[curr],numLayers);
diff --git a/src/main/java/org/distorted/objects/TwistyRedi.java b/src/main/java/org/distorted/objects/TwistyRedi.java
index 17ae4a34..4b2a4703 100644
--- a/src/main/java/org/distorted/objects/TwistyRedi.java
+++ b/src/main/java/org/distorted/objects/TwistyRedi.java
@@ -205,6 +205,7 @@ public class TwistyRedi extends TwistyObject
 
   private static int[][] mScrambleTable;
   private static int[] mPossibleAxis, mPossibleLayers;
+  private static int[] mNumOccurences;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -429,6 +430,7 @@ public class TwistyRedi extends TwistyObject
     if( mScrambleTable ==null ) mScrambleTable = new int[NUM_AXIS][2];
     if( mPossibleAxis  ==null ) mPossibleAxis  = new int[NUM_AXIS-1];
     if( mPossibleLayers==null ) mPossibleLayers= new int[NUM_AXIS-1];
+    if( mNumOccurences ==null ) mNumOccurences = new int[NUM_AXIS-1];
 
     for(int i=0; i<NUM_AXIS; i++)
       for(int j=0; j<2; j++)
@@ -441,7 +443,14 @@ public class TwistyRedi extends TwistyObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private int retNewRotationIndex(Random rnd, int[] oldRot)
+  private boolean areOpposite(int oldAxis, int newAxis, int oldRow, int nom)
+    {
+    return (oldAxis+newAxis==3)^(oldRow<nom);
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  private int retNewRotationIndex(Random rnd, int nom, int[] oldRot)
     {
     int index=0, max=0;
 
@@ -450,23 +459,29 @@ public class TwistyRedi extends TwistyObject
       if( ax!=oldRot[0] )
         {
         mPossibleAxis[index] = ax;
-        mPossibleLayers[index] = oldRot[0]+ax==3 ? 1-oldRot[1]/2 : oldRot[1]/2;
+        mPossibleLayers[index] = areOpposite(oldRot[0],ax,oldRot[1],nom) ? 0:1;
         int tmp = mScrambleTable[mPossibleAxis[index]][mPossibleLayers[index]];
         if( tmp>max ) max=tmp;
         index++;
         }
       }
 
-    int a0 = max-mScrambleTable[mPossibleAxis[0]][mPossibleLayers[0]];
-    int a1 = max-mScrambleTable[mPossibleAxis[1]][mPossibleLayers[1]];
-    int a2 = max-mScrambleTable[mPossibleAxis[2]][mPossibleLayers[2]];
+    for(int ax=0; ax<NUM_AXIS-1; ax++)
+      {
+      int value = mScrambleTable[mPossibleAxis[ax]][mPossibleLayers[ax]];
+      mNumOccurences[ax] = max - value + (ax==0 ? 0 : mNumOccurences[ax-1]);
+      }
 
-    float total = a0+a1+a2;
-    float random= rnd.nextFloat();
+    float random= rnd.nextFloat()*mNumOccurences[NUM_AXIS-2];
 
-         if( random*total < a0    ) index=0;
-    else if( random*total < a0+a1 ) index=1;
-    else                            index=2;
+    for(int ax=0; ax<NUM_AXIS-1; ax++)
+      {
+      if( random <= mNumOccurences[ax] )
+        {
+        index=ax;
+        break;
+        }
+      }
 
     mScrambleTable[mPossibleAxis[index]][mPossibleLayers[index]]++;
 
@@ -474,6 +489,7 @@ public class TwistyRedi extends TwistyObject
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
+// PUBLIC API
 
   public void randomizeNewScramble(int[][] scramble, Random rnd, int curr, int total)
     {
@@ -485,7 +501,7 @@ public class TwistyRedi extends TwistyObject
       }
     else
       {
-      int index = retNewRotationIndex(rnd,scramble[curr-1]);
+      int index = retNewRotationIndex(rnd,1,scramble[curr-1]);
       scramble[curr][0] = mPossibleAxis[index];
       scramble[curr][1] = 2*mPossibleLayers[index];
       }