Java Code Examples for org.apache.commons.lang3.ArrayUtils#toPrimitive()

@Override
public Object aggregate( List<Double> values, List<Double> args )
{
    Double fraction = args.get( 0 );

    if ( values.size() == 0 || fraction == null || fraction < 0d || fraction > 1d )
    {
        return null;
    }

    Collections.sort( values );

    if ( fraction == 0d )
    {
        return values.get( 0 );
    }

    double[] vals = ArrayUtils.toPrimitive( values.toArray( new Double[0] ) );

    return percentile.evaluate( vals, fraction * 100. );
}
 

/**
 * Returns a copy of the series with each distinct value of the
 * source series appearing exactly once.
 *
 * <br/><b>NOTE:</b> the values may be reordered
 *
 * @return series copy with distinct unique values
 */
public Series unique() {
  if(this.size() <= 1)
    return this;

  Series sorted = this.sorted();
  List<Integer> indices = new ArrayList<>();

  indices.add(0);
  for(int i=1; i<this.size(); i++) {
    if(!sorted.equals(sorted, i-1, i))
      indices.add(i);
  }

  int[] fromIndex = ArrayUtils.toPrimitive(indices.toArray(new Integer[indices.size()]));
  return sorted.project(fromIndex);
}
 

/**
 *
 * @param info
 */
public static void deriveClusterInfoDistanceStatistics(ClusterInfo info) {
    int pointCount = info.getPointDistancesFromCenter().size();
    if (pointCount == 0)
        return;

    double[] distances =
                    ArrayUtils.toPrimitive(info.getPointDistancesFromCenter().values().toArray(new Double[] {}));
    double max = info.isInverse() ? MathUtils.min(distances) : MathUtils.max(distances);
    double total = MathUtils.sum(distances);
    info.setMaxPointDistanceFromCenter(max);
    info.setTotalPointDistanceFromCenter(total);
    info.setAveragePointDistanceFromCenter(total / pointCount);
    info.setPointDistanceFromCenterVariance(MathUtils.variance(distances));
}
 

@Override
public long[] toLongArray() {
	if (isPrimitiveArray) {
		return (long[]) array;
	}
	checkNoNull();
	return ArrayUtils.toPrimitive((Long[]) array);
}
 

private int[] createMergedPage(int skip, int count, List<Integer> s1, int[] s2)
{
    int[] s1Primitive = (s1 == null || s1.isEmpty()) ? new int[] {} : ArrayUtils.toPrimitive((Integer[]) s1
                .toArray(new Integer[s1.size()]));

    return createMergedPage(skip,
                            count,
                            s1Primitive,
                            s2);
}
 

/**
 * This method updates the internal array only if the bit vector has been
 * changed since the last update or creation of this class.
 */
void updateCount() {
	if (this.hasChanged) {
		this.positionArray = ArrayUtils.toPrimitive(getPositionList()
				.toArray(new Long[0]));
		this.hasChanged = false;
	}
}
 

public static int[] getNullFilterKeys(boolean[] filterNulls) {
	checkNotNull(filterNulls);
	List<Integer> nullFilterKeyList = new ArrayList<>();
	for (int i = 0; i < filterNulls.length; i++) {
		if (filterNulls[i]) {
			nullFilterKeyList.add(i);
		}
	}
	return ArrayUtils.toPrimitive(nullFilterKeyList.toArray(new Integer[0]));
}
 

public static int[] getDimensions(Object data) {
    List<Integer> dims = new ArrayList<>();
    dims.add(Array.getLength(data));

    while (Array.get(data, 0).getClass().isArray()) {
        data = Array.get(data, 0);
        dims.add(Array.getLength(data));
    }
    return ArrayUtils.toPrimitive(dims.toArray(new Integer[0]));
}
 

private int[] getDimensions(Object data) {
	List<Integer> dims = new ArrayList<>();
	dims.add(Array.getLength(data));

	while (Array.get(data, 0).getClass().isArray()) {
		data = Array.get(data, 0);
		dims.add(Array.getLength(data));
	}
	return ArrayUtils.toPrimitive(dims.toArray(new Integer[0]));
}
 

@Override
public float[] toFloatArray() {
	if (isPrimitiveArray) {
		return (float[]) array;
	}
	checkNoNull();
	return ArrayUtils.toPrimitive((Float[]) array);
}
 

@Override
public int[] getSpecs() {
	Log.d(LOG, "RECALCULATING FOR IMAGE");
	
	List<Integer> specs = new ArrayList<Integer>(Arrays.asList(ArrayUtils.toObject(super.getSpecs())));
	
	for(float i : matrixTranslate) {
		specs.add((int) i/2);
	}
	
	/*
	int[] locationInWindow = new int[2];
	mediaHolder_.getLocationInWindow(locationInWindow);
	for(int i : locationInWindow) {
		specs.add(i);
	}
	*/
	
	specs.add(mediaHolder_.getWidth());
	specs.add(mediaHolder_.getHeight());
	
	// these might not be needed
	specs.add(media_.width);
	specs.add(media_.height);
	
	return ArrayUtils.toPrimitive(specs.toArray(new Integer[specs.size()]));
}
 

@Override
public double[] toDoubleArray() {
	if (isPrimitiveArray) {
		return (double[]) array;
	}
	checkNoNull();
	return ArrayUtils.toPrimitive((Double[]) array);
}
 

@Override
public int[] toIntArray() {
	if (isPrimitiveArray) {
		return (int[]) array;
	}
	checkNoNull();
	return ArrayUtils.toPrimitive((Integer[]) array);
}
 

protected CloseableIterator<Object> queryConstraints(
    final List<Short> adapterIdsToQuery,
    final Index index,
    final QueryConstraints sanitizedQuery,
    final DedupeFilter filter,
    final BaseQueryOptions sanitizedQueryOptions,
    final PersistentAdapterStore tempAdapterStore,
    final boolean delete) {
  final BaseConstraintsQuery constraintsQuery =
      new BaseConstraintsQuery(
          ArrayUtils.toPrimitive(adapterIdsToQuery.toArray(new Short[0])),
          index,
          sanitizedQuery,
          filter,
          sanitizedQueryOptions.getScanCallback(),
          sanitizedQueryOptions.getAggregation(),
          sanitizedQueryOptions.getFieldIdsAdapterPair(),
          IndexMetaDataSet.getIndexMetadata(
              index,
              adapterIdsToQuery,
              statisticsStore,
              sanitizedQueryOptions.getAuthorizations()),
          DuplicateEntryCount.getDuplicateCounts(
              index,
              adapterIdsToQuery,
              statisticsStore,
              sanitizedQueryOptions.getAuthorizations()),
          DifferingFieldVisibilityEntryCount.getVisibilityCounts(
              index,
              adapterIdsToQuery,
              statisticsStore,
              sanitizedQueryOptions.getAuthorizations()),
          FieldVisibilityCount.getVisibilityCounts(
              index,
              adapterIdsToQuery,
              statisticsStore,
              sanitizedQueryOptions.getAuthorizations()),
          DataIndexUtils.getDataIndexRetrieval(
              baseOperations,
              adapterStore,
              internalAdapterStore,
              index,
              sanitizedQueryOptions.getFieldIdsAdapterPair(),
              sanitizedQueryOptions.getAggregation(),
              sanitizedQueryOptions.getAuthorizations(),
              baseOptions.getDataIndexBatchSize()),
          sanitizedQueryOptions.getAuthorizations());

  return constraintsQuery.query(
      baseOperations,
      baseOptions,
      tempAdapterStore,
      internalAdapterStore,
      sanitizedQueryOptions.getMaxResolutionSubsamplingPerDimension(),
      sanitizedQueryOptions.getTargetResolutionPerDimensionForHierarchicalIndex(),
      sanitizedQueryOptions.getLimit(),
      sanitizedQueryOptions.getMaxRangeDecomposition(),
      delete);
}
 

public static Data singleton(@NonNull String key, @NonNull Object data) {
        Data instance = new JData();
        if (data instanceof String) {
            instance.put(key, (String)data);
        }
        else if (data instanceof Boolean) {
            instance.put(key, (Boolean)data);
        }
        else if (data instanceof  Integer) {
            instance.put(key, ((Integer) data).longValue());
        }
        else if (data instanceof Long) {
            instance.put(key, (Long)data);
        }
        else if (data instanceof Float) {
            instance.put(key, ((Float) data).doubleValue());
        }
        else if (data instanceof Double) {
            instance.put(key, (Double)data);
        }
        else if (data instanceof Image) {
            instance.put(key, (Image)data);
        }
        else if (data instanceof Byte[]) {
            byte[] input = ArrayUtils.toPrimitive((Byte[])data);
            instance.put(key, input);
        }
        else if (data instanceof byte[]) {
            instance.put(key, (byte[]) data);
        }
        else if (data instanceof Data) {
            instance.put(key, (Data)data);
        }
        else if(data instanceof NDArray){
            instance.put(key, (NDArray)data);
        }
        else if (data instanceof Image) {
            instance.put(key, (Image)data);
        } else if(data instanceof BoundingBox){
            instance.put(key, (BoundingBox)data);
        } else if(data instanceof Point){
            instance.put(key, (Point)data);
        } else if (data instanceof NDArray) {
            instance.put(key, (NDArray) data);
        }
//        else if (data instanceof Object) {
//            instance.put(key, (Object)data);
//        }
        else {
            throw new IllegalStateException("Trying to put data of not supported type: " + data.getClass());
        }
        return instance;
    }
 

protected static int[] integerListToPrimitiveArray(final List<Integer> internalList) {
  return ArrayUtils.toPrimitive(internalList.toArray(new Integer[internalList.size()]));
}
 

@Override
public byte[] getContent() {
    return ArrayUtils.toPrimitive(binaryContent);
}
 

private ForecastResult forecastWithR(final int numForecastSteps) throws InvalidREvaluationResultException {
	final ITimeSeries<Double> history = this.getTsOriginal();
	final ITimeSeries<Double> tsForecast = this.prepareForecastTS();

	final String varNameValues = RBridgeControl.uniqueVarname();
	final String varNameModel = RBridgeControl.uniqueVarname();
	final String varNameForecast = RBridgeControl.uniqueVarname();

	final List<Double> allHistory = new ArrayList<>(history.getValues());
	final Double[] histValuesNotNull = AbstractRForecaster.removeNullValues(allHistory);
	final double[] values = ArrayUtils.toPrimitive(histValuesNotNull);

	double fcQuality = Double.NaN;
	// 0. Assign values to temporal variable

	AbstractRForecaster.RBRIDGE.assign(varNameValues, values);

	if (history.getFrequency() != 0) {
		if (this.strategy != ForecastMethod.ARIMA) {
			// frequency for time series object in R --> needed for MASE calculation.
			AbstractRForecaster.RBRIDGE.toTS(varNameValues, history.getFrequency());
		} else {
			AbstractRForecaster.RBRIDGE.toTS(varNameValues);
		}
	}

	// 1. Compute stochastic model for forecast

	if (this.modelFunc == null) {
		// In this case, the values are the model ...
		AbstractRForecaster.RBRIDGE.assign(varNameModel, values);
		if (history.getFrequency() != 0) {
			if (this.strategy != ForecastMethod.ARIMA) {
				// frequency for time series object in R --> needed for MASE calculation.
				AbstractRForecaster.RBRIDGE.toTS(varNameValues, history.getFrequency());
			} else {
				AbstractRForecaster.RBRIDGE.toTS(varNameValues);
			}
		}
	} else {
		final String[] additionalModelParams = this.getModelFuncParams();

		final StringBuffer params = new StringBuffer();
		params.append(varNameValues);
		if (null != additionalModelParams) {
			for (final String param : additionalModelParams) {
				params.append(',');
				params.append(param);
			}
		}
		AbstractRForecaster.RBRIDGE.evalWithR(String.format("%s <- %s(%s)", varNameModel, this.modelFunc, params));
	}
	// remove temporal variable:
	AbstractRForecaster.RBRIDGE.evalWithR(String.format("rm(%s)", varNameValues));

	// 2. Perform forecast based on stochastic model

	if ((this.getConfidenceLevel() == 0) || !this.supportsConfidence()) {
		AbstractRForecaster.RBRIDGE.evalWithR(String.format("%s <- %s(%s, h=%d)", varNameForecast, this.forecastFunc, varNameModel,
				numForecastSteps));
	} else {
		AbstractRForecaster.RBRIDGE.evalWithR(String.format("%s <- %s(%s, h=%d, level=c(%d))", varNameForecast, this.forecastFunc, varNameModel,
				numForecastSteps, this.getConfidenceLevel()));
	}

	final double[] forecastValues = AbstractRForecaster.RBRIDGE.eDblArr(this.forecastOperationOnResult(varNameForecast));

	// 3. Calculate Forecast Quality Metric

	if (forecastValues.length > 1) {
		if ((this.modelFunc == null)) { // Re-enable when TBATS included: || (this.strategy == ForecastMethod.TBATS)
			fcQuality = AbstractRForecaster.RBRIDGE.eDbl("accuracy(" + varNameForecast + ")[6]");
		} else {
			fcQuality = AbstractRForecaster.RBRIDGE.eDbl("accuracy(" + varNameModel + ")[6]");
		}
	}

	tsForecast.appendAll(ArrayUtils.toObject(forecastValues));
	final ITimeSeries<Double> tsLower;
	final ITimeSeries<Double> tsUpper;

	if ((this.getConfidenceLevel() == 0) || !this.supportsConfidence()) {
		tsLower = tsForecast;
		tsUpper = tsForecast;
	} else {
		final double[] lowerValues = AbstractRForecaster.RBRIDGE.eDblArr(this.lowerOperationOnResult(varNameForecast));
		final double[] upperValues = AbstractRForecaster.RBRIDGE.eDblArr(this.upperOperationOnResult(varNameForecast));
		tsLower = this.prepareForecastTS();
		tsLower.appendAll(ArrayUtils.toObject(lowerValues));
		tsUpper = this.prepareForecastTS();
		tsUpper.appendAll(ArrayUtils.toObject(upperValues));
	}

	// remove temporal variable:
	AbstractRForecaster.RBRIDGE.evalWithR(String.format("rm(%s)", varNameModel));
	AbstractRForecaster.RBRIDGE.evalWithR(String.format("rm(%s)", varNameValues));
	AbstractRForecaster.RBRIDGE.evalWithR(String.format("rm(%s)", varNameForecast));

	return new ForecastResult(tsForecast, this.getTsOriginal(), this.getConfidenceLevel(), fcQuality, tsLower, tsUpper, this.strategy);
}
 

@Override
public int[] getRows() {
    // TODO this sucks
    return ArrayUtils.toPrimitive(rows.toArray(new Integer[rows.size()]));
}
 

@Override
public int[] getDimensionsInOrbit(BlockPos pos) {
	Set<Integer> intSet = getDimensionProperties(pos).getChildPlanets();
	Integer[] intArray = new Integer[intSet.size()];
	return ArrayUtils.toPrimitive(getDimensionProperties(pos).getChildPlanets().toArray(intArray));
}