toxiclibs 0.2-java → 0.5.0-java

data/src/toxi/util/datatypes/ArraySet.java

@@ -0,0 +1,128 @@
+package toxi.util.datatypes;
+
+/*
+ * Copyright (c) 2007 by L. Paul Chew.
+ *
+ * Permission is hereby granted, without written agreement and without
+ * license or royalty fees, to use, copy, modify, and distribute this
+ * software and its documentation for any purpose, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+import java.util.AbstractSet;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+
+/**
+ * An ArrayList implementation of Set. An ArraySet is good for small sets; it
+ * has less overhead than a HashSet or a TreeSet.
+ * 
+ * @author Paul Chew
+ * 
+ *         Created December 2007. For use with Voronoi/Delaunay applet.
+ * @param <E>
+ * 
+ */
+public class ArraySet<E> extends AbstractSet<E> {
+
+    private ArrayList<E> items; // Items of the set
+
+    /**
+     * Create an empty set (default initial capacity is 3).
+     */
+    public ArraySet() {
+        this(3);
+    }
+
+    /**
+     * Create a set containing the items of the collection. Any duplicate items
+     * are discarded.
+     * 
+     * @param collection
+     *            the source for the items of the small set
+     */
+    public ArraySet(Collection<? extends E> collection) {
+        items = new ArrayList<>(collection.size());
+        collection.stream().filter((item) -> (!items.contains(item))).forEach((item) -> {
+            items.add(item);
+        });
+    }
+
+    /**
+     * Create an empty set with the specified initial capacity.
+     * 
+     * @param initialCapacity
+     *            the initial capacity
+     */
+    public ArraySet(int initialCapacity) {
+        items = new ArrayList<>(initialCapacity);
+    }
+
+    /**
+     *
+     * @param item
+     * @return
+     */
+    @Override
+    public boolean add(E item) {
+        if (items.contains(item)) {
+            return false;
+        }
+        return items.add(item);
+    }
+
+    /**
+     * True if any member of the collection is also in the ArraySet.
+     * 
+     * @param collection
+     *            the Collection to check
+     * @return true if any member of collection appears in this ArraySet
+     */
+    public boolean containsAny(Collection<?> collection) {
+        return collection.stream().anyMatch((item) -> (this.contains((E)item)));
+    }
+
+    /**
+     * Get the item at the specified index.
+     * 
+     * @param index
+     *            where the item is located in the ListSet
+     * @return the item at the specified index
+     * @throws IndexOutOfBoundsException
+     *             if the index is out of bounds
+     */
+    public E get(int index) throws IndexOutOfBoundsException {
+        return items.get(index);
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public Iterator<E> iterator() {
+        return items.iterator();
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public int size() {
+        return items.size();
+    }
+
+}

data/src/toxi/util/datatypes/ArrayUtil.java

@@ -0,0 +1,404 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * Copyright (c) 2006-2011 Karsten Schmidt
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * http://creativecommons.org/licenses/LGPL/2.1/
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+package toxi.util.datatypes;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Random;
+
+/**
+ * A collection of array utilities.
+ */
+public class ArrayUtil {
+
+    /**
+     * Adds all array elements to the given collection of the same type.
+     * 
+     * @param <T>
+     * @param array
+     *            array
+     * @param collection
+     *            existing collection or null (to create a new {@link ArrayList}
+     *            automatically)
+     */
+    public static <T> void addArrayToCollection(T[] array,
+            Collection<T> collection) {
+        if (collection == null) {
+            collection = new ArrayList<>();
+        }
+        collection.addAll(Arrays.asList(array));
+    }
+
+    /**
+     * Converts the generic array into an {@link ArrayList} of the same type.
+     * 
+     * @param <T>
+     * @param array
+     * @return array list version
+     */
+    public static <T> ArrayList<T> arrayToList(T[] array) {
+        ArrayList<T> list = new ArrayList<>(array.length);
+        list.addAll(Arrays.asList(array));
+        return list;
+    }
+
+    /**
+     * Creates a normalized version of the values of the given int[] array.
+     * Supports packed integers (e.g. ARGB data) by allowing to specify a
+     * bitshift amount & bitmask, e.g. do this to get the normalized
+     * representation of the red channel of an ARGB array:
+     * 
+     * <pre>
+     * 
+     * // use 16 bits as shift offset for accessing red channel
+     * float[] red = ArrayUtil.getAsNormalizedFloatArray(argbPixels, 16, 255, 255);
+     * </pre>
+     * 
+     * @param source
+     *            source data
+     * @param bits
+     *            number of bits to right shift each value
+     * @param mask
+     *            bitmask to apply after bitshifting
+     * @param peak
+     *            peak value (in the source domain) to normalize against
+     * @param target
+     *            peak of the normalized values
+     * @return normalized values
+     */
+    public static float[] getAsNormalizedFloatArray(int[] source, int bits,
+            int mask, int peak, float target) {
+        float invPeak = target / peak;
+        float[] normalized = new float[source.length];
+        for (int i = 0; i < source.length; i++) {
+            int val = source[i];
+            if (bits > 0) {
+                val >>= bits;
+            }
+            val &= mask;
+            normalized[i] = val * invPeak;
+        }
+        return normalized;
+    }
+
+    /**
+     * Returns the index of the element where the given value is found in the
+     * array.
+     * 
+     * @param needle
+     *            number to find
+     * @param stack
+     *            array to search
+     * @param maxLen
+     *            number of elements to search
+     * @return array index or -1 if value couldn't be found in array
+     */
+    public static int indexInArray(float needle, float[] stack, int maxLen) {
+        for (int i = 0; i < maxLen; i++) {
+            if (stack[i] == needle) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    /**
+     * Returns the index of the element where the given value is found in the
+     * array.
+     * 
+     * @param needle
+     *            number to find
+     * @param stack
+     *            array to search
+     * @param maxLen
+     *            number of elements to search
+     * @return array index or -1 if value couldn't be found in array
+     */
+    public static int indexInArray(int needle, int[] stack, int maxLen) {
+        for (int i = 0; i < maxLen; i++) {
+            if (stack[i] == needle) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    /**
+     * Returns the index of the element where the given value is found in the
+     * array. The comparison uses {@link Object#equals(Object)}.
+     * 
+     * @param needle
+     *            number to find
+     * @param stack
+     *            array to search
+     * @param maxLen
+     *            number of elements to search
+     * @return array index or -1 if value couldn't be found in array
+     */
+    public static int indexInArray(Object needle, Object[] stack, int maxLen) {
+        for (int i = 0; i < maxLen; i++) {
+            if (stack[i].equals(needle)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    /**
+     * Normalizes the values in the given array to the new absolute target
+     * value. The original values are overridden.
+     * 
+     * @param buffer
+     *            array
+     * @param peak
+     *            current peak in the source domain
+     * @param target
+     *            new peak in the target domain
+     * @return normalized array
+     */
+    public static float[] normalizeFloatArray(float[] buffer, float peak,
+            float target) {
+        float invPeak = target / peak;
+        for (int i = 0; i < buffer.length; i++) {
+            buffer[i] *= invPeak;
+        }
+        return buffer;
+    }
+
+    /**
+     * Reverses the item order of the supplied byte array.
+     * 
+     * @param array
+     */
+    public static void reverse(byte[] array) {
+        int len = array.length - 1;
+        int len2 = array.length / 2;
+        for (int i = 0; i < len2; i++) {
+            byte tmp = array[i];
+            array[i] = array[len - i];
+            array[len - i] = tmp;
+        }
+    }
+
+    /**
+     * Reverses the item order of the supplied char array.
+     * 
+     * @param array
+     */
+    public static void reverse(char[] array) {
+        int len = array.length - 1;
+        int len2 = array.length / 2;
+        for (int i = 0; i < len2; i++) {
+            char tmp = array[i];
+            array[i] = array[len - i];
+            array[len - i] = tmp;
+        }
+    }
+
+    /**
+     * Reverses the item order of the supplied float array.
+     * 
+     * @param array
+     */
+    public static void reverse(float[] array) {
+        int len = array.length - 1;
+        int len2 = array.length / 2;
+        for (int i = 0; i < len2; i++) {
+            float tmp = array[i];
+            array[i] = array[len - i];
+            array[len - i] = tmp;
+        }
+    }
+
+    /**
+     * Reverses the item order of the supplied int array.
+     * 
+     * @param array
+     */
+    public static void reverse(int[] array) {
+        int len = array.length - 1;
+        int len2 = array.length / 2;
+        for (int i = 0; i < len2; i++) {
+            int tmp = array[i];
+            array[i] = array[len - i];
+            array[len - i] = tmp;
+        }
+    }
+
+    /**
+     * Reverses the item order of the supplied short array.
+     * 
+     * @param array
+     */
+    public static void reverse(short[] array) {
+        int len = array.length - 1;
+        int len2 = array.length / 2;
+        for (int i = 0; i < len2; i++) {
+            short tmp = array[i];
+            array[i] = array[len - i];
+            array[len - i] = tmp;
+        }
+    }
+
+    /**
+     * Reverses the item order of the supplied array (generic types).
+     * 
+     * @param <T>
+     * @param array
+     */
+    public static <T> void reverse(T[] array) {
+        int len = array.length - 1;
+        int len2 = array.length / 2;
+        for (int i = 0; i < len2; i++) {
+            T tmp = array[i];
+            array[i] = array[len - i];
+            array[len - i] = tmp;
+        }
+    }
+
+    /**
+     * Rearranges the array items in random order using the default
+     * java.util.Random generator. Operation is in-place, no copy is created.
+     * 
+     * @param <T>
+     * @param array
+     */
+    public static <T> void shuffle(T[] array) {
+        shuffle(array, new Random());
+    }
+
+    /**
+     * Rearranges the array items in random order using the given RNG. Operation
+     * is in-place, no copy is created.
+     * 
+     * @param <T>
+     * @param array
+     * @param rnd
+     */
+    public static <T> void shuffle(T[] array, Random rnd) {
+        int N = array.length;
+        for (int i = 0; i < N; i++) {
+            int r = i + rnd.nextInt(N - i); // between i and N-1
+            T swap = array[i];
+            array[i] = array[r];
+            array[r] = swap;
+        }
+    }
+
+    /**
+     *
+     * @param array
+     * @return
+     */
+    public static String toString(byte[] array) {
+        StringBuilder s = new StringBuilder();
+        s.append('{');
+        final int max = array.length - 1;
+        for (int i = 0; i < array.length; i++) {
+            s.append(array[i]);
+            if (i < max) {
+                s.append(',');
+            }
+        }
+        return s.append('}').toString();
+    }
+
+    /**
+     *
+     * @param array
+     * @return
+     */
+    public static String toString(double[] array) {
+        StringBuilder s = new StringBuilder();
+        s.append('{');
+        final int max = array.length - 1;
+        for (int i = 0; i < array.length; i++) {
+            s.append(array[i]);
+            if (i < max) {
+                s.append(',');
+            }
+        }
+        return s.append('}').toString();
+    }
+
+    /**
+     *
+     * @param array
+     * @return
+     */
+    public static String toString(float[] array) {
+        StringBuilder s = new StringBuilder();
+        s.append('{');
+        final int max = array.length - 1;
+        for (int i = 0; i < array.length; i++) {
+            s.append(array[i]);
+            if (i < max) {
+                s.append(',');
+            }
+        }
+        return s.append('}').toString();
+    }
+
+    /**
+     *
+     * @param array
+     * @return
+     */
+    public static String toString(int[] array) {
+        StringBuilder s = new StringBuilder();
+        s.append('{');
+        final int max = array.length - 1;
+        for (int i = 0; i < array.length; i++) {
+            s.append(array[i]);
+            if (i < max) {
+                s.append(',');
+            }
+        }
+        return s.append('}').toString();
+    }
+
+    /**
+     *
+     * @param <T>
+     * @param array
+     * @return
+     */
+    public static <T> String toString(T[] array) {
+        StringBuilder s = new StringBuilder();
+        s.append('{');
+        final int max = array.length - 1;
+        for (int i = 0; i < array.length; i++) {
+            s.append(array[i]);
+            if (i < max) {
+                s.append(',');
+            }
+        }
+        return s.append('}').toString();
+    }
+}