// the naive way of doing things - interesting as a discussion starter
public static void main(String[] args) {
for (int size = 1; size < 1000; size++) {
double[] array = DoubleStream.generate(Math::random).limit(size).toArray();
double[] copiedArray = Arrays.copyOf(array, size);
long parallelNanos =
Timing.time(() -> Arrays.parallelSort(copiedArray)).getDuration().toNanos();
long singleNanos = Timing.time(() -> Arrays.sort(array)).getDuration().toNanos();
System.out.println("Size:" + size);
System.out.println("Single threaded: " + singleNanos);
System.out.println("Parallel: " + parallelNanos);
System.out.println();
if (singleNanos > parallelNanos) {
return;
}
}
}
@Override
public List<T> aggregate(ListOfRanks<T> ranks) {
int m = ranks.countOfItems();
double n_ = DoubleStream.of(ranks.weights()).sum();
double subtrahend = 1 / (double) m;
double subtrahend2 = 1 / (m * n_);
double medium = n_ / 2.;
double[][] ma1 = new double[m][m];
double[][] ma2 = new double[m][m];
double[][] ma3 = new double[m][m];
for (int u = 0; u < m; u++) {
for (int v = 0; v < m; v++) {
final int finalU = u;
final int finalV = v;
double c =
ranks
.stream()
.filter(rank -> rank.position(finalU) > rank.position(finalV))
.mapToDouble(rank -> rank.weight)
.sum();
if (c > 0) { // MC1
ma1[u][v] = subtrahend;
}
if (c >= medium) { // MC2
ma2[u][v] = subtrahend;
}
ma3[u][v] = c * subtrahend2; // MC3
}
}
double[][] ma;
switch (type) {
case MC1:
ma = ma1;
break;
case MC2:
ma = ma2;
break;
default:
ma = ma3;
}
for (int i = 0; i < m; i++) {
ma[i][i] = 1 - DoubleStream.of(ma[i]).sum();
}
double[] weights = findStationaryDistribution(transfer(ma, 0.05));
return IntStream.range(0, m)
.mapToObj(i -> Pair.of(weights[i], ranks.itemByNumber(i)))
.sorted((o1, o2) -> -Double.compare(o1.first, o2.first))
.map(pair -> pair.second)
.collect(Collectors.toList());
}
public static void printStats(double[] values) {
System.out.println("Min;" + DoubleStream.of(values).min().getAsDouble());
System.out.println("Max;" + DoubleStream.of(values).max().getAsDouble());
System.out.println("Mean;" + new Mean().evaluate(values));
System.out.println("Median;" + new Median().evaluate(values));
System.out.println("Std. Dev.;" + new StandardDeviation().evaluate(values));
}
public static void main(String... args) {
/*
-------------------------------------------------------------------------
From obj to ...
-------------------------------------------------------------------------
*/
Stream<String> streamOfStrings = Stream.of("un", "deux", "trois");
Function<String, StringBuilder> function = StringBuilder::new;
streamOfStrings.map(function) /*.forEach(System.out::println)*/;
streamOfStrings = Stream.of("un", "deux", "trois");
ToIntFunction<String> toIntFunction = String::length;
IntStream streamOfInts = streamOfStrings.mapToInt(toIntFunction);
streamOfStrings = Stream.of("un", "deux", "trois");
ToDoubleFunction<String> toDoubleFunction = String::length;
DoubleStream streamOfDoubles = streamOfStrings.mapToDouble(toDoubleFunction);
streamOfStrings = Stream.of("un", "deux", "trois");
ToLongFunction<String> toLongFunction = String::length;
LongStream streamOfLongs = streamOfStrings.mapToLong(toLongFunction);
/*
-------------------------------------------------------------------------
From int to ...
-------------------------------------------------------------------------
*/
IntUnaryOperator plusplus = i -> i++;
IntStream.of(1, 2, 3).map(plusplus)
/*.forEach(x->System.out.println(x))*/ ;
IntFunction<String> intFunction = i -> "" + i;
IntStream.of(1, 2, 3).mapToObj(intFunction)
/*.forEach(System.out::println)*/ ;
IntToDoubleFunction itdf = i -> i;
IntStream.of(1, 2, 3).mapToDouble(itdf)
/*.forEach(System.out::println)*/ ;
IntToLongFunction itlf = i -> i;
IntStream.of(1, 2, 3).mapToLong(itlf)
/*.forEach(System.out::println)*/ ;
/*
-------------------------------------------------------------------------
From long to ...
-------------------------------------------------------------------------
*/
LongUnaryOperator times = l -> l * l;
LongStream.of(1L, 2L, 3L).map(times)
/*.forEach(System.out::println)*/ ;
LongFunction<String> lf = l -> "toto";
LongStream.of(1L, 2L, 3L).mapToObj(lf);
/*
-------------------------------------------------------------------------
From double to ...
-------------------------------------------------------------------------
*/
DoubleToIntFunction dtif = d -> (int) d;
DoubleStream.of(1.3, 1.5, 1.6).mapToInt(dtif).forEach(System.out::println);
}
@Override
public void processDocument(Document doc) {
doc.addFeatureSet(FEATURE_SET, usedForClassification);
clusters.forEach(
(i, c) -> {
DoubleStream stream =
c.stream()
.mapToDouble(
(fn) -> doc.getFeature(fn) == null ? 0 : doc.getFeature(fn).doubleValue());
Double v = 0.0;
if (isMaxCombiner) {
v = stream.max().orElse(0);
} else { // if isSumCombiner
v = stream.sum();
}
if (v > 0) {
doc.getFeatureSet(FEATURE_SET).add(i.toString(), v);
}
});
}
public static void main(String[] args) {
// Page 45
// ========
IntStream.iterate(1, i -> i * 2).limit(10).forEachOrdered(System.out::println);
IntStream.range(1, 6).forEach(System.out::print); // prints 123456
// Page 46
// ========
List<Integer> intList = Arrays.asList(1, 2, 3);
OptionalDouble maxDistance =
intList.stream().map(i -> new Point(i % 3, i / 3)).mapToDouble(p -> p.distance(0, 0)).max();
DoubleStream ds =
intList.stream().map(i -> new Point(i % 3, i / 3)).mapToDouble(p -> p.distance(0, 0));
OptionalDouble maxDistance1 = ds.max();
// Page 48
// ========
Optional<Integer> max =
Arrays.asList(1, 2, 3, 4, 5).stream().map(i -> i + 1).max(Integer::compareTo);
// Page 49
// ========
OptionalInt max1 = IntStream.rangeClosed(1, 5).map(i -> i + 1).max();
DoubleStream ds1 = IntStream.rangeClosed(1, 10).asDoubleStream();
Stream<Integer> is = IntStream.rangeClosed(1, 10).boxed();
Stream<Integer> integerStream = Stream.of(1, 2);
IntStream is1 = integerStream.mapToInt(Integer::intValue);
}
/**
* Randomly initializes this GaussianMixture for a given number of terms.
*
* @param random a {@link java.util.Random} object.
* @param numTerms a number of terms.
*/
public void randomInitialization(Random random, int numTerms) {
this.coefficients = new double[numTerms];
this.terms = new ArrayList<>(numTerms);
for (int k = 0; k < numTerms; k++) {
this.coefficients[k] = random.nextDouble();
Normal aux = new Normal(this.var);
aux.setMean(5 * random.nextGaussian());
aux.setVariance(random.nextDouble());
this.terms.add(aux);
}
;
DoubleStream aux = Arrays.stream(this.coefficients);
double suma = aux.sum();
aux = Arrays.stream(this.coefficients);
this.coefficients = aux.map(x -> x / suma).toArray();
// System.out.println(coefficients);
// this.coefficients = this.coefficients / .map().sum();
}
private <E extends RuntimeException> void assertDoubleToLongFunction(
DoubleToLongFunction test, Class<E> type) {
assertNotNull(test);
try {
test.applyAsLong(0.0);
fail();
} catch (RuntimeException e) {
assertException(type, e, "0.0");
}
try {
DoubleStream.of(1.0, 2.0, 3.0).mapToLong(test);
} catch (RuntimeException e) {
assertException(type, e, "1.0");
}
}
/**
* Check if the FlyWheel has reached a stable speed
*
* @param tolerance Stabilization check tolerance
* @return Stabilization status
*/
public boolean isStabilized(double tolerance) {
return (DoubleStream.of(errors).sum() / 30) < tolerance;
}
public DoubleStream getCoordinates(float factor) {
return DoubleStream.of(factor * x, factor * y, factor * z);
}
public DoubleStream getCoordinates() {
return DoubleStream.of(x, y, z);
}
/** @param args the command line arguments */
public static void main(String[] args) {
int dimension = 10;
int NP = 100;
int MAXFES = 10 * NP;
int funcNumber = 14;
TestFunction tf = new Schwefel();
int H = 10;
long seed = 10304050L;
util.random.Random generator;
S_SHADE shade;
int runs = 2;
double[] bestArray = new double[runs];
for (int k = 0; k < runs; k++) {
generator = new util.random.UniformRandomSeed(seed);
shade = new S_SHADE(dimension, MAXFES, tf, H, NP, generator);
shade.run();
// PrintWriter writer;
//
// try {
// writer = new PrintWriter("CEC2015-" + funcNumber + "-shade" + k + ".txt",
// "UTF-8");
//
// writer.print("{");
//
// for (int i = 0; i < shade.getBestHistory().size(); i++) {
//
// writer.print(String.format(Locale.US, "%.10f",
// shade.getBestHistory().get(i).fitness));
//
// if (i != shade.getBestHistory().size() - 1) {
// writer.print(",");
// }
//
// }
//
// writer.print("}");
//
// writer.close();
//
// } catch (FileNotFoundException | UnsupportedEncodingException ex) {
// Logger.getLogger(ShaDE.class.getName()).log(Level.SEVERE, null, ex);
// }
bestArray[k] = shade.getBest().fitness - tf.optimum();
System.out.println(shade.getBest().fitness - tf.optimum());
System.out.println(Arrays.toString(shade.getBest().vector));
}
System.out.println("=================================");
System.out.println("Min: " + DoubleStream.of(bestArray).min().getAsDouble());
System.out.println("Max: " + DoubleStream.of(bestArray).max().getAsDouble());
System.out.println("Mean: " + new Mean().evaluate(bestArray));
System.out.println("Median: " + new Median().evaluate(bestArray));
System.out.println("Std. Dev.: " + new StandardDeviation().evaluate(bestArray));
System.out.println("=================================");
}
public ScalarSequence(DoubleStream in) {
x = in.toArray();
index = capacity = x.length;
calcStats();
}
