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.microflex.math.mathinteger.AdditionIntegerTest.java

/**
 * Tests the addition of an array to a well.
 *///from   www .  ja va 2 s.c om
@Test
public void testWellArray() {

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

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

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

    }

}

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

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

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

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

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

    }

}

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

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

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

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

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

    }

}

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

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

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

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

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

    }

}

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

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

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

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

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

    }

}

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

/**
 * Tests the multiplication of an array to a well.
 *///from  www.ja va 2 s.  c  om
@Test
public void testWellArray() {

    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 = multiplication.wells(well1[j], array);
            List<Integer> returnedUneven = multiplication.wells(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]);
            }

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

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

    }

}

From source file:com.money.manager.ex.reports.IncomeVsExpensesListFragment.java

private void showChartInternal() {
    // take a adapter and cursor
    IncomeVsExpensesAdapter adapter = ((IncomeVsExpensesAdapter) getListAdapter());
    if (adapter == null)
        return;/*from  w ww  . j  av a2 s.  c o m*/
    Cursor cursor = adapter.getCursor();
    if (cursor == null)
        return;
    // Move to the first record.
    if (cursor.getCount() <= 0)
        return;

    // arrays
    ArrayList<Double> incomes = new ArrayList<>();
    ArrayList<Double> expenses = new ArrayList<>();
    ArrayList<String> titles = new ArrayList<>();

    // Reset cursor to initial position.
    cursor.moveToPosition(-1);
    // cycle cursor
    while (cursor.moveToNext()) {
        int month = cursor.getInt(cursor.getColumnIndex(IncomeVsExpenseReportEntity.Month));
        // check if not subtotal
        if (month != IncomeVsExpensesActivity.SUBTOTAL_MONTH) {
            // incomes and expenses
            incomes.add(cursor.getDouble(cursor.getColumnIndex(IncomeVsExpenseReportEntity.Income)));
            expenses.add(
                    Math.abs(cursor.getDouble(cursor.getColumnIndex(IncomeVsExpenseReportEntity.Expenses))));
            // titles
            int year = cursor.getInt(cursor.getColumnIndex(IncomeVsExpenseReportEntity.YEAR));

            // format month
            Calendar calendar = Calendar.getInstance();
            calendar.set(year, month - 1, 1);
            // titles
            titles.add(Integer.toString(year) + "-" + new SimpleDateFormat("MMM").format(calendar.getTime()));
        }
    }
    //compose bundle for arguments
    Bundle args = new Bundle();
    args.putDoubleArray(IncomeVsExpensesChartFragment.KEY_EXPENSES_VALUES,
            ArrayUtils.toPrimitive(expenses.toArray(new Double[0])));
    args.putDoubleArray(IncomeVsExpensesChartFragment.KEY_INCOME_VALUES,
            ArrayUtils.toPrimitive(incomes.toArray(new Double[0])));
    args.putStringArray(IncomeVsExpensesChartFragment.KEY_XTITLES, titles.toArray(new String[titles.size()]));
    //get fragment manager
    FragmentManager fragmentManager = getActivity().getSupportFragmentManager();
    if (fragmentManager != null) {
        IncomeVsExpensesChartFragment fragment;
        fragment = (IncomeVsExpensesChartFragment) fragmentManager
                .findFragmentByTag(IncomeVsExpensesChartFragment.class.getSimpleName());
        if (fragment == null) {
            fragment = new IncomeVsExpensesChartFragment();
        }
        fragment.setChartArguments(args);
        fragment.setDisplayHomeAsUpEnabled(true);

        if (fragment.isVisible())
            fragment.onResume();

        FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
        if (((IncomeVsExpensesActivity) getActivity()).mIsDualPanel) {
            fragmentTransaction.replace(R.id.fragmentChart, fragment,
                    IncomeVsExpensesChartFragment.class.getSimpleName());
        } else {
            fragmentTransaction.replace(R.id.fragmentMain, fragment,
                    IncomeVsExpensesChartFragment.class.getSimpleName());
            fragmentTransaction.addToBackStack(null);
        }
        fragmentTransaction.commit();
    }
}

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

/**
 * Tests the OR operation using an array, a well and indices.
 *//*from w  w  w  .jav  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<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.wells(well1[j], array, begin, end - begin);
            List<Integer> returnedUneven = or.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.ANDTest.java

/**
 * Tests the AND operation using an array, a well and indices.
 *//*from  www . ja  v a2s .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 = and.wells(well1[j], array, begin, end - begin);
            List<Integer> returnedUneven = and.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.XORTest.java

/**
 * Tests the XOR operation using an array, a well and indices.
 *///  w ww .j  a  v  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<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.wells(well1[j], array, begin, end - begin);
            List<Integer> returnedUneven = xor.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);
        }

    }

}