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:at.tugraz.sss.serv.util.SSFileU.java

public static String readImageToBase64Str(final String filePath, final Integer transmissionSize) throws SSErr {

    try {/*from  w ww . j  a  v a2 s  .c o m*/
        final DataInputStream fileReader = new DataInputStream(new FileInputStream(new File(filePath)));
        final List<Byte> bytes = new ArrayList<>();
        byte[] chunk = new byte[transmissionSize];
        int fileChunkLength;

        while (true) {

            fileChunkLength = fileReader.read(chunk);

            if (fileChunkLength == -1) {
                break;
            }

            for (int counter = 0; counter < fileChunkLength; counter++) {
                bytes.add(chunk[counter]);
            }
        }

        return "data:image/png;base64," + DatatypeConverter
                .printBase64Binary(ArrayUtils.toPrimitive(bytes.toArray(new Byte[bytes.size()])));
    } catch (Exception error) {
        SSServErrReg.regErrThrow(error);
        return null;
    }
}

From source file:de.hpi.isg.mdms.benchmark.ConstraintInsertPerfomanceBenchmark.java

@Test
public void testInsertUniqueColumnCombinationsIntoRDBMSMetadataStore() throws Exception {

    LOGGER.info("Creating RDBMS metadata store...");
    File metadataStoreFile = createTempFile("sqlite");
    MetadataStore metadataStore = RDBMSMetadataStore
            .createNewInstance(SQLiteInterface.createForFile(metadataStoreFile));

    LOGGER.info("Creating schema...");
    int numTables = 1000;
    int numColumnsPerTable = 100;
    int numColumns = numTables * numColumnsPerTable;
    Schema schema = createSchema(metadataStore, numTables, numColumnsPerTable);
    metadataStore.flush();//www .  j a v a2s .  c  om

    LOGGER.info("Generating UCCs...");
    int numDesiredInds = 100000;
    double indProbablity = numDesiredInds / Math.pow(numTables * numColumnsPerTable, 2);
    // Boost probablity to speed up generation.
    indProbablity = Math.sqrt(indProbablity);

    Collection<Column[]> inclusionDependencies = new LinkedList<Column[]>();
    Random random = new Random();
    OuterLoop: for (final Table table1 : schema.getTables()) {
        for (final Table table2 : schema.getTables()) {
            for (final Column column1 : table1.getColumns()) {
                for (final Column column2 : table2.getColumns()) {
                    if (column1 != column2 && random.nextDouble() <= indProbablity) {
                        inclusionDependencies.add(new Column[] { column1, column2 });
                        if (inclusionDependencies.size() >= numDesiredInds) {
                            break OuterLoop;
                        }
                    }
                }
            }
        }
    }

    LOGGER.info("Inserting the {} generated UCCs...", inclusionDependencies.size());
    long startTimeGross = System.currentTimeMillis();
    ConstraintCollection<UniqueColumnCombination> constraintCollection = metadataStore
            .createConstraintCollection(null, UniqueColumnCombination.class);
    long startTimeNet = System.currentTimeMillis();
    for (Column[] columnPair : inclusionDependencies) {
        Collection<Column> uniqueColumns = Collections.singleton(columnPair[0]);
        List<Integer> ids = new ArrayList<>();
        for (Column c : uniqueColumns) {
            ids.add(c.getId());
        }
        int[] intArray = ArrayUtils.toPrimitive(ids.toArray(new Integer[ids.size()]));
        final UniqueColumnCombination.Reference reference = new UniqueColumnCombination.Reference(intArray);
        UniqueColumnCombination.buildAndAddToCollection(reference, constraintCollection);
    }
    long endTimeNet = System.currentTimeMillis();
    metadataStore.flush();
    long endTimeGross = System.currentTimeMillis();
    double numInsertsPerSecGross = 1000d * numColumns / (endTimeGross - startTimeGross);
    double numInsertsPerSecNet = 1000d * numColumns / (endTimeNet - startTimeNet);
    LOGGER.info("[gross] Inserted in {} ms ({} inserts/s)", endTimeGross - startTimeGross,
            numInsertsPerSecGross);
    LOGGER.info("[net]   Inserted in {} ms ({} inserts/s)", endTimeNet - startTimeNet, numInsertsPerSecNet);
    LOGGER.info("File size: {} MB", metadataStoreFile.length() / (1024 * 1024));

}

From source file:com.cdd.bao.importer.ImportControlledVocab.java

private int[] mostSimilarAssignments(String name) {
    int[] sim = new int[assignments.length];
    for (int n = 0; n < assignments.length; n++)
        sim[n] = stringSimilarity(name, assignments[n].name);

    Integer[] idx = new Integer[assignments.length];
    for (int n = 0; n < assignments.length; n++)
        idx[n] = n;/*from  w  ww.  ja  va 2 s.c  om*/
    Arrays.sort(idx, (i1, i2) -> sim[i1] - sim[i2]);

    /*Util.writeln("["+name+"]:");
    for (int n = 0; n < idx.length && n < 50; n++)
       Util.writeln("sim="+sim[idx[n]]+" : [" + assignments[idx[n]].name + "]");*/

    return ArrayUtils.toPrimitive(idx);
}

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

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

    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 = 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.microflex.math.mathdouble.AdditionDoubleTest.java

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

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

/**
 * Tests the OR operation using an array, a well and indices.
 *//*from w w w.  j a  v  a  2s .com*/
@Test
public void testWellArrayIndices() {

    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.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.microflex.math.mathdouble.ModulusDoubleTest.java

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

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

/**
 * Tests the AND operation using an array, a well and indices.
 *//*from  ww  w  .  ja v a2s .  c om*/
@Test
public void testWellArrayIndices() {

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

/**
 * Tests the XOR operation using an array, a well and indices.
 *//*from  www  . jav a  2 s .c  o  m*/
@Test
public void testWellArrayIndices() {

    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.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);
        }

    }

}

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

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

    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.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);
        }

    }

}