Rewrite entropy util to use more memory friendly version

Author: patrickfav

src/main/java/at/favre/lib/bytes/Bytes.java

@@ -1402,13 +1402,13 @@ public int count(byte[] pattern) {
      * variables. Specifically, assuming for simplicity that each of the microscopic configurations is equally probable,
      * the entropy of the system is the natural logarithm of that number of configurations, multiplied by the Boltzmann constant kB.
      * <p>
-     * This implementation requires O(n) time and space complexity.
+     * This implementation requires O(n) time and O(1) space complexity.
      *
      * @return entropy value; higher is more entropy (simply: more different values)
      * @see <a href="https://en.wikipedia.org/wiki/Entropy">Entropy</a>
      */
     public double entropy() {
-        return new Util.Entropy<>(toList()).entropy();
+        return Util.Byte.entropy(internalArray());
     }
 
     /* CONVERTERS POSSIBLY REUSING THE INTERNAL ARRAY ***************************************************************/

src/main/java/at/favre/lib/bytes/Util.java

@@ -268,6 +268,36 @@ static boolean constantTimeEquals(byte[] obj, byte[] anotherArray) {
             }
             return result == 0;
         }
+
+        /**
+         * Calculates the entropy factor of a byte array.
+         * <p>
+         * This implementation will not create a copy of the internal array and will only internally initialize
+         * a int array with 256 elements as temporary buffer.
+         *
+         * @param array to calculate the entropy from
+         * @return entropy factor, higher means higher entropy
+         */
+        static double entropy(byte[] array) {
+            final int[] buffer = new int[256];
+            Arrays.fill(buffer, -1);
+
+            for (byte element : array) {
+                int unsigned = 0xff & element;
+                if (buffer[unsigned] == -1) {
+                    buffer[unsigned] = 0;
+                }
+                buffer[unsigned]++;
+            }
+
+            double entropy = 0;
+            for (int count : buffer) {
+                if (count == -1) continue;
+                double prob = (double) count / array.length;
+                entropy -= prob * (Math.log(prob) / Math.log(2));
+            }
+            return entropy;
+        }
     }
 
     /**
@@ -683,58 +713,6 @@ static byte[] readFromFile(java.io.File file, int offset, int length) {
     private Util() {
     }
 
-    /*
-    =================================================================================================
-     Copyright 2011 Twitter, Inc.
-     -------------------------------------------------------------------------------------------------
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this work except in compliance with the License.
-     You may obtain a copy of the License in the LICENSE file, or at:
-
-      http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
-     =================================================================================================
-     */
-
-    /**
-     * Class that calculates the entropy factor
-     *
-     * @param <T>
-     */
-    @SuppressWarnings("WeakerAccess")
-    static final class Entropy<T> {
-        private final Map<T, Integer> map = new HashMap<>();
-        private int total = 0;
-
-        public Entropy(Iterable<T> elements) {
-            for (T element : elements) {
-                if (!map.containsKey(element)) {
-                    map.put(element, 0);
-                }
-                map.put(element, map.get(element) + 1);
-                total++;
-            }
-        }
-
-        private double Log2(double n) {
-            return Math.log(n) / Math.log(2);
-        }
-
-        public double entropy() {
-            double entropy = 0;
-            for (int count : map.values()) {
-                double prob = (double) count / total;
-                entropy -= prob * Log2(prob);
-            }
-            return entropy;
-        }
-    }
-
     /**
      * A simple iterator for the bytes class, which does not support remove
      */

src/test/java/at/favre/lib/bytes/UtilByteTest.java

@@ -234,4 +234,15 @@ public void testRightShiftAgainstRefImpl() {
             }
         }
     }
+
+    @Test
+    public void entropy() {
+        assertEquals(0, Util.Byte.entropy(new byte[0]), 0.1d);
+        assertEquals(0, Util.Byte.entropy(new byte[1]), 0.1d);
+        assertEquals(0, Util.Byte.entropy(new byte[256]), 0.1d);
+        assertEquals(0, Util.Byte.entropy(new byte[]{1}), 0.1d);
+        assertTrue(Util.Byte.entropy(new byte[]{(byte) 0x8E, (byte) 0xD1, (byte) 0xFD, (byte) 0xAA, 0x12, (byte) 0xAF, (byte) 0x78, 0x09, 0x1E, (byte) 0xD1, (byte) 0xFD, (byte) 0xAA, 0x12, (byte) 0xAF, (byte) 0x00, 0x0A, (byte) 0xEE, (byte) 0xD1, (byte) 0xFD, (byte) 0xAA, 0x12, (byte) 0xAF, (byte) 0x78, 0x11}) > 3.5);
+        assertTrue(Util.Byte.entropy(new byte[]{0x4A, (byte) 0x94, (byte) 0xFD, (byte) 0xFF, 0x1E, (byte) 0xAF, (byte) 0xED}) > 2.5);
+        assertTrue(Util.Byte.entropy(new byte[]{0x1A, 0x6F}) > 0.5);
+    }
 }