Example usage for org.apache.commons.lang3 ArrayUtils toPrimitive

Introduction

In this page you can find the example usage for org.apache.commons.lang3 ArrayUtils toPrimitive.

Prototype

public static boolean[] toPrimitive(final Boolean[] array)

Source Link

Document

Converts an array of object Booleans to primitives.

This method returns null for a null input array.

Usage

From source file:com.github.jessemull.microflex.math.mathdouble.DivisionDoubleTest.java

/**
 * Tests the strict division of an array to a well.
 *//*from   ww w.  java2s .  c om*/
@Test
public void testWellStrictArray() {

    PlateDouble[] plates1 = arrays1.get(0);
    PlateDouble[] plates2 = arrays2.get(0);
    PlateDouble[] unevenPlates = uneven.get(0);

    for (int i = 0; i < plates1.length; i++) {

        WellDouble[] well1 = plates1[i].dataSet().toWellArray();
        WellDouble[] well2 = plates2[i].dataSet().toWellArray();
        WellDouble[] wellUneven = unevenPlates[i].dataSet().toWellArray();

        for (int j = 0; j < well1.length; j++) {

            List<Double> list1 = well1[j].data();
            List<Double> list2 = well2[j].data();
            double[] array = ArrayUtils.toPrimitive(list2.toArray(new Double[list2.size()]));
            List<Double> unevenList = wellUneven[j].data();
            double[] arrayUneven = ArrayUtils.toPrimitive(unevenList.toArray(new Double[unevenList.size()]));

            List<Double> result = new ArrayList<Double>();
            List<Double> resultUneven = new ArrayList<Double>();
            List<Double> returned = division.wellsStrict(well1[j], array);
            List<Double> returnedUneven = division.wellsStrict(well1[j], arrayUneven);

            for (int k = 0; k < list1.size(); k++) {
                result.add(list1.get(k) / array[k]);
                resultUneven.add(list1.get(k) / arrayUneven[k]);
            }

            assertEquals(result, returned);
            assertEquals(resultUneven, returnedUneven);
        }

    }
}

From source file:com.github.jessemull.microflex.math.mathdouble.AdditionDoubleTest.java

/**
 * Tests the strict addition of an array to a well.
 *//*from  ww w  .ja va  2 s  . c  o m*/
@Test
public void testWellStrictArray() {

    PlateDouble[] plates1 = arrays1.get(0);
    PlateDouble[] plates2 = arrays2.get(0);
    PlateDouble[] unevenPlates = uneven.get(0);

    for (int i = 0; i < plates1.length; i++) {

        WellDouble[] well1 = plates1[i].dataSet().toWellArray();
        WellDouble[] well2 = plates2[i].dataSet().toWellArray();
        WellDouble[] wellUneven = unevenPlates[i].dataSet().toWellArray();

        for (int j = 0; j < well1.length; j++) {

            List<Double> list1 = well1[j].data();
            List<Double> list2 = well2[j].data();
            double[] array = ArrayUtils.toPrimitive(list2.toArray(new Double[list2.size()]));
            List<Double> unevenList = wellUneven[j].data();
            double[] arrayUneven = ArrayUtils.toPrimitive(unevenList.toArray(new Double[unevenList.size()]));

            List<Double> result = new ArrayList<Double>();
            List<Double> resultUneven = new ArrayList<Double>();
            List<Double> returned = addition.wellsStrict(well1[j], array);
            List<Double> returnedUneven = addition.wellsStrict(well1[j], arrayUneven);

            for (int k = 0; k < list1.size(); k++) {
                result.add(list1.get(k) + array[k]);
                resultUneven.add(list1.get(k) + arrayUneven[k]);
            }

            assertEquals(result, returned);
            assertEquals(resultUneven, returnedUneven);
        }

    }
}

From source file:com.github.jessemull.microflex.math.mathinteger.ORIntegerTest.java

/**
 * Tests the strict OR operation using an array and a well.
 *///  w  w  w.  j ava2 s. c o  m
@Test
public void testWellStrictArray() {

    PlateInteger[] plates1 = arrays1.get(0);
    PlateInteger[] plates2 = arrays2.get(0);
    PlateInteger[] unevenPlates = uneven.get(0);

    for (int i = 0; i < plates1.length; i++) {

        WellInteger[] well1 = plates1[i].dataSet().toWellArray();
        WellInteger[] well2 = plates2[i].dataSet().toWellArray();
        WellInteger[] wellUneven = unevenPlates[i].dataSet().toWellArray();

        for (int j = 0; j < well1.length; j++) {

            List<Integer> list1 = well1[j].data();
            List<Integer> list2 = well2[j].data();
            int[] array = ArrayUtils.toPrimitive(list2.toArray(new Integer[list2.size()]));
            List<Integer> unevenList = wellUneven[j].data();
            int[] arrayUneven = ArrayUtils.toPrimitive(unevenList.toArray(new Integer[unevenList.size()]));

            List<Integer> result = new ArrayList<Integer>();
            List<Integer> resultUneven = new ArrayList<Integer>();
            List<Integer> returned = or.wellsStrict(well1[j], array);
            List<Integer> returnedUneven = or.wellsStrict(well1[j], arrayUneven);

            for (int k = 0; k < list1.size(); k++) {
                result.add(list1.get(k) | array[k]);
                resultUneven.add(list1.get(k) | arrayUneven[k]);
            }

            assertEquals(result, returned);
            assertEquals(resultUneven, returnedUneven);
        }

    }
}

From source file:com.dotweblabs.twirl.gae.GaeUnmarshaller.java

/**
 * Get the <code>List</code> out of the Embedded entity.
 * The <code>List</code> is expected to be stored following a dot (.) notation.
 * E.g. A JSON array with a key of "numbers" will be stored as a <code>EmbeddedEntity</code>
 * with property names:/*w w w. j  a  v a 2s. c o m*/
 *
 * <code>
 * numbers.0
 * numbers.1
 * numbers.2
 * </code>
 *
 * And so on. And since it is stored a a  <code>EmbeddedEntity</code> then it is ambiguous to a
 * <code>Map</code> that is also stored in the same Datastore type.
 *
 * @param ee entity to unmarshall into {@code List}
 * @return
 */
public List<Object> getListFromEmbeddedEntity(final EmbeddedEntity ee) {
    List<Object> list = null;
    Iterator<Map.Entry<String, Object>> it = ee.getProperties().entrySet().iterator();
    Object[] arr = new Object[1024];
    List<Integer> indexToRemove = new ArrayList<Integer>();
    for (int i = 0; i < arr.length; i++) {
        indexToRemove.add(i);
    }
    while (it.hasNext()) {
        Map.Entry<String, Object> entry = it.next();
        try {
            if (list == null) {
                list = new LinkedList<Object>();
            }
            Object value = entry.getValue();
            Integer i = Integer.valueOf(entry.getKey());
            //                LOG.debug("Value="+entry.getValue());
            if (value instanceof String || value instanceof Boolean || value instanceof Number
                    || value instanceof Date || value instanceof User) // GAE supported type
            {
                arr[i] = value;
                indexToRemove.remove(i);
            } else if (value instanceof EmbeddedEntity) {
                arr[i] = getMapOrList((EmbeddedEntity) value);
                indexToRemove.remove(i);
            } else {
                throw new RuntimeException("Invalid JSON field type in embedded list entity");
            }
        } catch (Exception e) {
            // TODO Handle exception
            e.printStackTrace();
        }
    }
    int[] intArray = ArrayUtils.toPrimitive(indexToRemove.toArray(new Integer[indexToRemove.size()]));
    arr = copyArrayRemove(arr, intArray);
    return Arrays.asList(arr);
}

From source file:com.github.jessemull.microflex.math.mathdouble.ModulusDoubleTest.java

/**
 * Tests the strict modulus operation using an array and a well.
 */// ww  w .  j a va  2 s. c  o  m
@Test
public void testWellStrictArray() {

    PlateDouble[] plates1 = arrays1.get(0);
    PlateDouble[] plates2 = arrays2.get(0);
    PlateDouble[] unevenPlates = uneven.get(0);

    for (int i = 0; i < plates1.length; i++) {

        WellDouble[] well1 = plates1[i].dataSet().toWellArray();
        WellDouble[] well2 = plates2[i].dataSet().toWellArray();
        WellDouble[] wellUneven = unevenPlates[i].dataSet().toWellArray();

        for (int j = 0; j < well1.length; j++) {

            List<Double> list1 = well1[j].data();
            List<Double> list2 = well2[j].data();
            double[] array = ArrayUtils.toPrimitive(list2.toArray(new Double[list2.size()]));
            List<Double> unevenList = wellUneven[j].data();
            double[] arrayUneven = ArrayUtils.toPrimitive(unevenList.toArray(new Double[unevenList.size()]));

            List<Double> result = new ArrayList<Double>();
            List<Double> resultUneven = new ArrayList<Double>();
            List<Double> returned = modulus.wellsStrict(well1[j], array);
            List<Double> returnedUneven = modulus.wellsStrict(well1[j], arrayUneven);

            for (int k = 0; k < list1.size(); k++) {
                result.add(list1.get(k) % array[k]);
                resultUneven.add(list1.get(k) % arrayUneven[k]);
            }

            assertEquals(result, returned);
            assertEquals(resultUneven, returnedUneven);
        }

    }
}

From source file:com.github.jessemull.microflex.math.mathinteger.ANDIntegerTest.java

/**
 * Tests the strict AND operation using an array and a well.
 *///from  w  w  w.j  a v  a2  s . c  o m
@Test
public void testWellStrictArray() {

    PlateInteger[] plates1 = arrays1.get(0);
    PlateInteger[] plates2 = arrays2.get(0);
    PlateInteger[] unevenPlates = uneven.get(0);

    for (int i = 0; i < plates1.length; i++) {

        WellInteger[] well1 = plates1[i].dataSet().toWellArray();
        WellInteger[] well2 = plates2[i].dataSet().toWellArray();
        WellInteger[] wellUneven = unevenPlates[i].dataSet().toWellArray();

        for (int j = 0; j < well1.length; j++) {

            List<Integer> list1 = well1[j].data();
            List<Integer> list2 = well2[j].data();
            int[] array = ArrayUtils.toPrimitive(list2.toArray(new Integer[list2.size()]));
            List<Integer> unevenList = wellUneven[j].data();
            int[] arrayUneven = ArrayUtils.toPrimitive(unevenList.toArray(new Integer[unevenList.size()]));

            List<Integer> result = new ArrayList<Integer>();
            List<Integer> resultUneven = new ArrayList<Integer>();
            List<Integer> returned = and.wellsStrict(well1[j], array);
            List<Integer> returnedUneven = and.wellsStrict(well1[j], arrayUneven);

            for (int k = 0; k < list1.size(); k++) {
                result.add(list1.get(k) & array[k]);
                resultUneven.add(list1.get(k) & arrayUneven[k]);
            }

            assertEquals(result, returned);
            assertEquals(resultUneven, returnedUneven);
        }

    }
}

From source file:com.github.jessemull.microflex.math.mathinteger.XORIntegerTest.java

/**
 * Tests the strict XOR operation using an array and a well.
 *//*w  w w  .  ja v a  2  s.com*/
@Test
public void testWellStrictArray() {

    PlateInteger[] plates1 = arrays1.get(0);
    PlateInteger[] plates2 = arrays2.get(0);
    PlateInteger[] unevenPlates = uneven.get(0);

    for (int i = 0; i < plates1.length; i++) {

        WellInteger[] well1 = plates1[i].dataSet().toWellArray();
        WellInteger[] well2 = plates2[i].dataSet().toWellArray();
        WellInteger[] wellUneven = unevenPlates[i].dataSet().toWellArray();

        for (int j = 0; j < well1.length; j++) {

            List<Integer> list1 = well1[j].data();
            List<Integer> list2 = well2[j].data();
            int[] array = ArrayUtils.toPrimitive(list2.toArray(new Integer[list2.size()]));
            List<Integer> unevenList = wellUneven[j].data();
            int[] arrayUneven = ArrayUtils.toPrimitive(unevenList.toArray(new Integer[unevenList.size()]));

            List<Integer> result = new ArrayList<Integer>();
            List<Integer> resultUneven = new ArrayList<Integer>();
            List<Integer> returned = xor.wellsStrict(well1[j], array);
            List<Integer> returnedUneven = xor.wellsStrict(well1[j], arrayUneven);

            for (int k = 0; k < list1.size(); k++) {
                result.add(list1.get(k) ^ array[k]);
                resultUneven.add(list1.get(k) ^ arrayUneven[k]);
            }

            assertEquals(result, returned);
            assertEquals(resultUneven, returnedUneven);
        }

    }
}

From source file:com.github.jessemull.microflex.math.mathdouble.SubtractionDoubleTest.java

/**
 * Tests the strict subtraction of an array to a well.
 *//*from w w  w.j  av  a 2  s  . c om*/
@Test
public void testWellStrictArray() {

    PlateDouble[] plates1 = arrays1.get(0);
    PlateDouble[] plates2 = arrays2.get(0);
    PlateDouble[] unevenPlates = uneven.get(0);

    for (int i = 0; i < plates1.length; i++) {

        WellDouble[] well1 = plates1[i].dataSet().toWellArray();
        WellDouble[] well2 = plates2[i].dataSet().toWellArray();
        WellDouble[] wellUneven = unevenPlates[i].dataSet().toWellArray();

        for (int j = 0; j < well1.length; j++) {

            List<Double> list1 = well1[j].data();
            List<Double> list2 = well2[j].data();
            double[] array = ArrayUtils.toPrimitive(list2.toArray(new Double[list2.size()]));
            List<Double> unevenList = wellUneven[j].data();
            double[] arrayUneven = ArrayUtils.toPrimitive(unevenList.toArray(new Double[unevenList.size()]));

            List<Double> result = new ArrayList<Double>();
            List<Double> resultUneven = new ArrayList<Double>();
            List<Double> returned = subtraction.wellsStrict(well1[j], array);
            List<Double> returnedUneven = subtraction.wellsStrict(well1[j], arrayUneven);

            for (int k = 0; k < list1.size(); k++) {
                result.add(list1.get(k) - array[k]);
                resultUneven.add(list1.get(k) - arrayUneven[k]);
            }

            assertEquals(result, returned);
            assertEquals(resultUneven, returnedUneven);
        }

    }
}

From source file:com.github.jessemull.microflex.math.mathinteger.AdditionIntegerTest.java

/**
 * Tests the strict addition of an array to a well.
 *//*from  ww w  .ja va2  s.  c o m*/
@Test
public void testWellStrictArray() {

    PlateInteger[] plates1 = arrays1.get(0);
    PlateInteger[] plates2 = arrays2.get(0);
    PlateInteger[] unevenPlates = uneven.get(0);

    for (int i = 0; i < plates1.length; i++) {

        WellInteger[] well1 = plates1[i].dataSet().toWellArray();
        WellInteger[] well2 = plates2[i].dataSet().toWellArray();
        WellInteger[] wellUneven = unevenPlates[i].dataSet().toWellArray();

        for (int j = 0; j < well1.length; j++) {

            List<Integer> list1 = well1[j].data();
            List<Integer> list2 = well2[j].data();
            int[] array = ArrayUtils.toPrimitive(list2.toArray(new Integer[list2.size()]));
            List<Integer> unevenList = wellUneven[j].data();
            int[] arrayUneven = ArrayUtils.toPrimitive(unevenList.toArray(new Integer[unevenList.size()]));

            List<Integer> result = new ArrayList<Integer>();
            List<Integer> resultUneven = new ArrayList<Integer>();
            List<Integer> returned = addition.wellsStrict(well1[j], array);
            List<Integer> returnedUneven = addition.wellsStrict(well1[j], arrayUneven);

            for (int k = 0; k < list1.size(); k++) {
                result.add(list1.get(k) + array[k]);
                resultUneven.add(list1.get(k) + arrayUneven[k]);
            }

            assertEquals(result, returned);
            assertEquals(resultUneven, returnedUneven);
        }

    }
}

From source file:com.github.jessemull.microflex.math.mathinteger.DivisionIntegerTest.java

/**
 * Tests the strict division of an array to a well.
 *///from  w  w w.  j  av a  2s . c o  m
@Test
public void testWellStrictArray() {

    PlateInteger[] plates1 = arrays1.get(0);
    PlateInteger[] plates2 = arrays2.get(0);
    PlateInteger[] unevenPlates = uneven.get(0);

    for (int i = 0; i < plates1.length; i++) {

        WellInteger[] well1 = plates1[i].dataSet().toWellArray();
        WellInteger[] well2 = plates2[i].dataSet().toWellArray();
        WellInteger[] wellUneven = unevenPlates[i].dataSet().toWellArray();

        for (int j = 0; j < well1.length; j++) {

            List<Integer> list1 = well1[j].data();
            List<Integer> list2 = well2[j].data();
            int[] array = ArrayUtils.toPrimitive(list2.toArray(new Integer[list2.size()]));
            List<Integer> unevenList = wellUneven[j].data();
            int[] arrayUneven = ArrayUtils.toPrimitive(unevenList.toArray(new Integer[unevenList.size()]));

            List<Integer> result = new ArrayList<Integer>();
            List<Integer> resultUneven = new ArrayList<Integer>();
            List<Integer> returned = division.wellsStrict(well1[j], array);
            List<Integer> returnedUneven = division.wellsStrict(well1[j], arrayUneven);

            for (int k = 0; k < list1.size(); k++) {
                result.add(list1.get(k) / array[k]);
                resultUneven.add(list1.get(k) / arrayUneven[k]);
            }

            assertEquals(result, returned);
            assertEquals(resultUneven, returnedUneven);
        }

    }
}