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.mathinteger.ORIntegerTest.java

/**
 * Tests the strict OR operation using an array, a well and indices.
 *//*from ww  w  .j  av a 2s  .co  m*/
@Test
public void testWellStrictArrayIndices() {

    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()]));

            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 = or.wellsStrict(well1[j], array, begin, end - begin);
            List<Integer> returnedUneven = or.wellsStrict(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]);
            }

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

---

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

/**
 * Tests the strict modulus operation using an array, a well and indices.
 *//*www.j a v  a 2  s .  c  o m*/
@Test
public void testWellStrictArrayIndices() {

    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()]));

            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.wellsStrict(well1[j], array, begin, end - begin);
            List<Double> returnedUneven = modulus.wellsStrict(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]);
            }

            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, a well and indices.
 *///ww  w .  j av  a 2  s.c o  m
@Test
public void testWellStrictArrayIndices() {

    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()]));

            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 = and.wellsStrict(well1[j], array, begin, end - begin);
            List<Integer> returnedUneven = and.wellsStrict(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]);
            }

            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, a well and indices.
 *//*from   w w  w  . j a  v  a 2  s.  co m*/
@Test
public void testWellStrictArrayIndices() {

    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()]));

            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 = xor.wellsStrict(well1[j], array, begin, end - begin);
            List<Integer> returnedUneven = xor.wellsStrict(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]);
            }

            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 using indices.
 *///  w w w .j a  v  a  2  s.  c  om
@Test
public void testWellStrictArrayIndices() {

    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()]));

            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.wellsStrict(well1[j], array, begin, end - begin);
            List<Double> returnedUneven = subtraction.wellsStrict(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]);
            }

            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 using indices.
 *///from w  w w.  j  a  va  2  s  .c o  m
@Test
public void testWellStrictArrayIndices() {

    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()]));

            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.wellsStrict(well1[j], array, begin, end - begin);
            List<Integer> returnedUneven = addition.wellsStrict(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]);
            }

            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 using indices.
 *//*from w  w w  .  j  av a  2 s  .co m*/
@Test
public void testWellStrictArrayIndices() {

    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()]));

            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.wellsStrict(well1[j], array, begin, end - begin);
            List<Integer> returnedUneven = division.wellsStrict(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]);
            }

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

---

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

/**
 * Tests the strict multiplication of an array to a well using indices.
 *//*from   www  .j a  v a2  s.  c  om*/
@Test
public void testWellStrictArrayIndices() {

    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()]));

            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.wellsStrict(well1[j], array, begin, end - begin);
            List<Double> returnedUneven = multiplication.wellsStrict(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]);
            }

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

---

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

/**
 * Tests the strict modulus operation using an array, a well and indices.
 *///from  w  w  w .  j  av a2s.  co m
@Test
public void testWellStrictArrayIndices() {

    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()]));

            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.wellsStrict(well1[j], array, begin, end - begin);
            List<Integer> returnedUneven = modulus.wellsStrict(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]);
            }

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

---

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

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

    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()]));

            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.wellsStrict(well1[j], array, begin, end - begin);
            List<Integer> returnedUneven = subtraction.wellsStrict(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]);
            }

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

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• »