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

List of usage examples for org.apache.commons.lang3 ArrayUtils toPrimitive

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.lang3.*
  5. ArrayUtils
  6. 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.microflexdouble.math.DivisionTest.java

/**
 * Tests the division of an array to a well using indices.
 *//* w  ww .j a  v  a2  s.co m*/
@Test
public void testWellArrayIndices() {

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

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

        Well[] well1 = plates1[i].dataSet().toWellArray();
        Well[] well2 = plates2[i].dataSet().toWellArray();
        Well[] 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()]));

            int begin = 1 + random.nextInt(list1.size() - 1);
            int end = begin + random.nextInt(list1.size() - begin);

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

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

            for (int l = list1.size(); l < end; l++) {
                resultUneven.add(arrayUneven[l]);
            }

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

    }

}

From source file:com.github.jessemull.microflexdouble.math.AdditionTest.java

/**
 * Tests the addition of an array to a well using indices.
 *//*  w w w  .j av a  2 s  . co  m*/
@Test
public void testWellArrayIndices() {

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

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

        Well[] well1 = plates1[i].dataSet().toWellArray();
        Well[] well2 = plates2[i].dataSet().toWellArray();
        Well[] 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()]));

            int begin = 1 + random.nextInt(list1.size() - 1);
            int end = begin + random.nextInt(list1.size() - begin);

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

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

            for (int l = list1.size(); l < end; l++) {
                resultUneven.add(arrayUneven[l]);
            }

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

    }

}

From source file:com.github.jessemull.microflexinteger.math.AdditionTest.java

/**
 * Tests the addition of an array to a well using indices.
 *///ww  w.ja  v a  2 s  .c o  m
@Test
public void testWellArrayIndices() {

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

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

        Well[] well1 = plates1[i].dataSet().toWellArray();
        Well[] well2 = plates2[i].dataSet().toWellArray();
        Well[] 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()]));

            int begin = 1 + random.nextInt(list1.size() - 1);
            int end = begin + random.nextInt(list1.size() - begin);

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

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

            for (int l = list1.size(); l < end; l++) {
                resultUneven.add(arrayUneven[l]);
            }

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

    }

}

From source file:com.github.jessemull.microflexinteger.math.DivisionTest.java

/**
 * Tests the division of an array to a well using indices.
 *///from   w w w .  j  a va 2  s .  c  o  m
@Test
public void testWellArrayIndices() {

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

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

        Well[] well1 = plates1[i].dataSet().toWellArray();
        Well[] well2 = plates2[i].dataSet().toWellArray();
        Well[] 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()]));

            int begin = 1 + random.nextInt(list1.size() - 1);
            int end = begin + random.nextInt(list1.size() - begin);

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

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

            for (int l = list1.size(); l < end; l++) {
                resultUneven.add(arrayUneven[l]);
            }

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

    }

}

From source file:com.github.jessemull.microflexdouble.math.ModulusTest.java

/**
 * Tests the modulus operation using an array, a well and indices.
 *///from   w w  w .  java 2 s  . c  om
@Test
public void testWellArrayIndices() {

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

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

        Well[] well1 = plates1[i].dataSet().toWellArray();
        Well[] well2 = plates2[i].dataSet().toWellArray();
        Well[] 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()]));

            int begin = 1 + random.nextInt(list1.size() - 1);
            int end = begin + random.nextInt(list1.size() - begin);

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

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

            for (int l = list1.size(); l < end; l++) {
                resultUneven.add(arrayUneven[l]);
            }

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

    }

}

From source file:com.github.jessemull.microflexdouble.math.SubtractionTest.java

/**
 * Tests the subtraction of an array to a well using indices.
 *//*ww w.  j  a  va 2  s .c o  m*/
@Test
public void testWellArrayIndices() {

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

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

        Well[] well1 = plates1[i].dataSet().toWellArray();
        Well[] well2 = plates2[i].dataSet().toWellArray();
        Well[] 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()]));

            int begin = 1 + random.nextInt(list1.size() - 1);
            int end = begin + random.nextInt(list1.size() - begin);

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

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

            for (int l = list1.size(); l < end; l++) {
                resultUneven.add(arrayUneven[l]);
            }

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

    }

}

From source file:com.github.jessemull.microflexinteger.math.ModulusTest.java

/**
 * Tests the modulus operation using an array, a well and indices.
 *//* w  w  w . ja  va2 s  . c  om*/
@Test
public void testWellArrayIndices() {

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

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

        Well[] well1 = plates1[i].dataSet().toWellArray();
        Well[] well2 = plates2[i].dataSet().toWellArray();
        Well[] 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()]));

            int begin = 1 + random.nextInt(list1.size() - 1);
            int end = begin + random.nextInt(list1.size() - begin);

            List<Integer> result = new ArrayList<Integer>();
            List<Integer> resultUneven = new ArrayList<Integer>();
            List<Integer> returned = modulus.wells(well1[j], array, begin, end - begin);
            List<Integer> returnedUneven = modulus.wells(well1[j], arrayUneven, begin, end - begin);

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

            for (int l = list1.size(); l < end; l++) {
                resultUneven.add(arrayUneven[l]);
            }

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

    }

}

From source file:com.github.jessemull.microflexinteger.math.SubtractionTest.java

/**
 * Tests the subtraction of an array to a well using indices.
 *//*w w w. j  a va 2 s . c o m*/
@Test
public void testWellArrayIndices() {

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

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

        Well[] well1 = plates1[i].dataSet().toWellArray();
        Well[] well2 = plates2[i].dataSet().toWellArray();
        Well[] 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()]));

            int begin = 1 + random.nextInt(list1.size() - 1);
            int end = begin + random.nextInt(list1.size() - begin);

            List<Integer> result = new ArrayList<Integer>();
            List<Integer> resultUneven = new ArrayList<Integer>();
            List<Integer> returned = subtraction.wells(well1[j], array, begin, end - begin);
            List<Integer> returnedUneven = subtraction.wells(well1[j], arrayUneven, begin, end - begin);

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

            for (int l = list1.size(); l < end; l++) {
                resultUneven.add(arrayUneven[l]);
            }

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

    }

}

From source file:com.github.jessemull.microflexdouble.math.MultiplicationTest.java

/**
 * Tests the multiplication of an array to a well using indices.
 *///from  w  w  w . ja va2 s.c o m
@Test
public void testWellArrayIndices() {

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

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

        Well[] well1 = plates1[i].dataSet().toWellArray();
        Well[] well2 = plates2[i].dataSet().toWellArray();
        Well[] 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()]));

            int begin = 1 + random.nextInt(list1.size() - 1);
            int end = begin + random.nextInt(list1.size() - begin);

            List<Double> result = new ArrayList<Double>();
            List<Double> resultUneven = new ArrayList<Double>();
            List<Double> returned = multiplication.wells(well1[j], array, begin, end - begin);
            List<Double> returnedUneven = multiplication.wells(well1[j], arrayUneven, begin, end - begin);

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

            for (int l = list1.size(); l < end; l++) {
                resultUneven.add(arrayUneven[l]);
            }

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

    }

}

From source file:com.github.jessemull.microflexinteger.math.MultiplicationTest.java

/**
 * Tests the multiplication of an array to a well using indices.
 *//*from  ww w  .  ja v  a 2s. c  o m*/
@Test
public void testWellArrayIndices() {

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

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

        Well[] well1 = plates1[i].dataSet().toWellArray();
        Well[] well2 = plates2[i].dataSet().toWellArray();
        Well[] 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()]));

            int begin = 1 + random.nextInt(list1.size() - 1);
            int end = begin + random.nextInt(list1.size() - begin);

            List<Integer> result = new ArrayList<Integer>();
            List<Integer> resultUneven = new ArrayList<Integer>();
            List<Integer> returned = multiplication.wells(well1[j], array, begin, end - begin);
            List<Integer> returnedUneven = multiplication.wells(well1[j], arrayUneven, begin, end - begin);

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

            for (int l = list1.size(); l < end; l++) {
                resultUneven.add(arrayUneven[l]);
            }

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

    }

}