java.util.function.IntToDoubleFunction Java Examples

@Override
public final DoubleStream mapToDouble(IntToDoubleFunction mapper) {
    Objects.requireNonNull(mapper);
    return new DoublePipeline.StatelessOp<Integer>(this, StreamShape.INT_VALUE,
                                                   StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Integer> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedInt<Double>(sink) {
                @Override
                public void accept(int t) {
                    downstream.accept(mapper.applyAsDouble(t));
                }
            };
        }
    };
}
 

@Override
public final DoubleStream mapToDouble(IntToDoubleFunction mapper) {
    Objects.requireNonNull(mapper);
    return new DoublePipeline.StatelessOp<Integer>(this, StreamShape.INT_VALUE,
                                                   StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Integer> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedInt<Double>(sink) {
                @Override
                public void accept(int t) {
                    downstream.accept(mapper.applyAsDouble(t));
                }
            };
        }
    };
}
 

private static ExampleSet createExampleSetNumFloat(int columns, int rows, boolean allowIntegers) {
	List<Attribute> attributes =
			IntStream.range(0, columns).mapToObj(i -> "att-" + i + "-" + (allowIntegers && i % 2 == 1))
					.map(name -> AttributeFactory.createAttribute(name, name.endsWith("true") ? Ontology.INTEGER :
							Ontology.REAL))
					.collect(Collectors.toList());
	ExampleSetBuilder builder = ExampleSets.from(attributes).withBlankSize(rows);
	IntToDoubleFunction doubleFiller = i -> (float) rng.nextDouble();
	IntToDoubleFunction intFiller = i -> (float)rng.nextInt();
	attributes.forEach(att -> builder.withColumnFiller(att, att.getValueType() == Ontology.REAL ? doubleFiller :
			intFiller));
	ExampleSet build = builder.build();
	build.getAnnotations().put("bla", "blup");
	build.getAnnotations().put("blabla", "blupblup");
	build.recalculateAllAttributeStatistics();
	return build;
}
 

private static ExampleSet createExampleSetNum(int columns, int rows, boolean allowIntegers) {
	List<Attribute> attributes =
			IntStream.range(0, columns).mapToObj(i -> "att-" + i + "-" + (allowIntegers && i % 2 == 1))
					.map(name -> AttributeFactory.createAttribute(name, name.endsWith("true") ? Ontology.INTEGER :
							Ontology.REAL))
					.collect(Collectors.toList());
	ExampleSetBuilder builder = ExampleSets.from(attributes).withBlankSize(rows);
	IntToDoubleFunction doubleFiller = i -> rng.nextDouble();
	IntToDoubleFunction intFiller = i -> rng.nextInt();
	attributes.forEach(att -> builder.withColumnFiller(att, att.getValueType() == Ontology.REAL ? doubleFiller :
			intFiller));
	ExampleSet build = builder.build();
	build.getAnnotations().put("bla", "blup");
	build.getAnnotations().put("blabla", "blupblup");
	build.recalculateAllAttributeStatistics();
	return build;
}
 

private static ExampleSet createExampleSetNumNoFractions(int columns, int rows, boolean allowIntegers) {
	List<Attribute> attributes =
			IntStream.range(0, columns).mapToObj(i -> "att-" + i + "-" + (allowIntegers && i % 2 == 1))
					.map(name -> AttributeFactory.createAttribute(name, name.endsWith("true") ? Ontology.INTEGER :
							Ontology.REAL))
					.collect(Collectors.toList());
	ExampleSetBuilder builder = ExampleSets.from(attributes).withBlankSize(rows);
	IntToDoubleFunction doubleFiller = i -> (int) (rng.nextDouble() * 1000);
	IntToDoubleFunction intFiller = i -> rng.nextInt();
	attributes.forEach(att -> builder.withColumnFiller(att, att.getValueType() == Ontology.REAL ? doubleFiller :
			intFiller));
	ExampleSet build = builder.build();
	build.getAnnotations().put("bla", "blup");
	build.getAnnotations().put("blabla", "blupblup");
	build.recalculateAllAttributeStatistics();
	return build;
}
 

@Override
public RandomVariable cache() {
	synchronized (this)
	{
		if(realizationsArray == null) {
			realizationsArray = getRealizationsStream().toArray();
			realizations = new IntToDoubleFunction() {
				@Override
				public double applyAsDouble(final int i) {
					return realizationsArray[i];
				}
			};
		}
	}
	return this;
}
 

@Override
public final DoubleStream mapToDouble(IntToDoubleFunction mapper) {
    Objects.requireNonNull(mapper);
    return new DoublePipeline.StatelessOp<Integer>(this, StreamShape.INT_VALUE,
                                                   StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Integer> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedInt<Double>(sink) {
                @Override
                public void accept(int t) {
                    downstream.accept(mapper.applyAsDouble(t));
                }
            };
        }
    };
}
 

@Override
public final DoubleStream mapToDouble(IntToDoubleFunction mapper) {
    Objects.requireNonNull(mapper);
    return new DoublePipeline.StatelessOp<Integer>(this, StreamShape.INT_VALUE,
                                                   StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Integer> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedInt<Double>(sink) {
                @Override
                public void accept(int t) {
                    downstream.accept(mapper.applyAsDouble(t));
                }
            };
        }
    };
}
 

@Override
public final DoubleStream mapToDouble(IntToDoubleFunction mapper) {
    Objects.requireNonNull(mapper);
    return new DoublePipeline.StatelessOp<Integer>(this, StreamShape.INT_VALUE,
                                                   StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Integer> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedInt<Double>(sink) {
                @Override
                public void accept(int t) {
                    downstream.accept(mapper.applyAsDouble(t));
                }
            };
        }
    };
}
 

@Override
public RandomVariable apply(final DoubleUnaryOperator operator) {
	if(isDeterministic()) {
		return new RandomVariableLazyEvaluation(time, operator.applyAsDouble(valueIfNonStochastic));
	}
	else
	{
		final IntToDoubleFunction newRealizations = new IntToDoubleFunction() {
			@Override
			public double applyAsDouble(final int i) {
				return operator.applyAsDouble(realizations.applyAsDouble(i));
			}
		};
		return new RandomVariableLazyEvaluation(time, newRealizations, size());
	}
}
 

/**
 * Create a stochastic random variable.
 *
 * @param time the filtration time, set to 0.0 if not used.
 * @param realizations A map mapping integer (path or state) to double, representing this random variable.
 * @param size The size, i.e., number of paths.
 * @param typePriority The priority of this type in construction of result types. See "operator type priority" for details.
 */
public RandomVariableFromDoubleArray(final double time, final IntToDoubleFunction realizations, final int size, final int typePriority) {
	super();
	this.time = time;
	this.realizations = size == 1 ? null : new double[size];//IntStream.range(0,size).parallel().mapToDouble(realisations).toArray();
	valueIfNonStochastic = size == 1 ? realizations.applyAsDouble(0) : Double.NaN;
	if(size > 1) {
		IntStream.range(0,size).parallel().forEach(new IntConsumer() {
			@Override
			public void accept(final int i) {
				RandomVariableFromDoubleArray.this.realizations[i] = realizations.applyAsDouble(i);
			}
		}
				);
	}
	this.typePriority = typePriority;
}
 

@Override
public final DoubleStream mapToDouble(IntToDoubleFunction mapper) {
    Objects.requireNonNull(mapper);
    return new DoublePipeline.StatelessOp<Integer>(this, StreamShape.INT_VALUE,
                                                   StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Integer> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedInt<Double>(sink) {
                @Override
                public void accept(int t) {
                    downstream.accept(mapper.applyAsDouble(t));
                }
            };
        }
    };
}
 

@Override
public RandomVariable apply(final DoubleTernaryOperator operator, final RandomVariable argument1, final RandomVariable argument2) {
	double newTime = Math.max(time, argument1.getFiltrationTime());
	newTime = Math.max(newTime, argument2.getFiltrationTime());

	final int newSize = Math.max(Math.max(this.size(), argument1.size()), argument2.size());

	final IntToDoubleFunction argument0Operator = this.getOperator();
	final IntToDoubleFunction argument1Operator = argument1.getOperator();
	final IntToDoubleFunction argument2Operator = argument2.getOperator();
	final IntToDoubleFunction result = new IntToDoubleFunction() {
		@Override
		public double applyAsDouble(final int i) {
			return operator.applyAsDouble(argument0Operator.applyAsDouble(i), argument1Operator.applyAsDouble(i), argument2Operator.applyAsDouble(i));
		}
	};

	return new RandomVariableFromDoubleArray(newTime, result, newSize);
}
 

@Override
public final DoubleStream mapToDouble(IntToDoubleFunction mapper) {
    Objects.requireNonNull(mapper);
    return new DoublePipeline.StatelessOp<Integer>(this, StreamShape.INT_VALUE,
                                                   StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Integer> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedInt<Double>(sink) {
                @Override
                public void accept(int t) {
                    downstream.accept(mapper.applyAsDouble(t));
                }
            };
        }
    };
}
 

@Override
public final DoubleStream mapToDouble(IntToDoubleFunction mapper) {
    Objects.requireNonNull(mapper);
    return new DoublePipeline.StatelessOp<Integer>(this, StreamShape.INT_VALUE,
                                                   StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Integer> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedInt<Double>(sink) {
                @Override
                public void accept(int t) {
                    downstream.accept(mapper.applyAsDouble(t));
                }
            };
        }
    };
}
 

/** {@inheritDoc} */
@Override public Vector assign(IntToDoubleFunction fun) {
    assert fun != null;

    if (sto.isArrayBased()) {
        ensureReadOnly();

        Arrays.setAll(sto.data(), fun);
    }
    else {
        int len = size();

        for (int i = 0; i < len; i++)
            storageSet(i, fun.applyAsDouble(i));
    }

    return this;
}
 

@Override
public final DoubleStream mapToDouble(IntToDoubleFunction mapper) {
    Objects.requireNonNull(mapper);
    return new DoublePipeline.StatelessOp<Integer>(this, StreamShape.INT_VALUE,
                                                   StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Integer> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedInt<Double>(sink) {
                @Override
                public void accept(int t) {
                    downstream.accept(mapper.applyAsDouble(t));
                }
            };
        }
    };
}
 

@Override
public RandomVariable cache() {
	synchronized (this)
	{
		if(realizationsArray == null) {
			realizationsArray = getRealizationsStream().toArray();
			realizations = new IntToDoubleFunction() {
				@Override
				public double applyAsDouble(final int i) {
					return realizationsArray[i];
				}
			};
		}
	}
	return this;
}
 

@Override
public final DoubleStream mapToDouble(IntToDoubleFunction mapper) {
    Objects.requireNonNull(mapper);
    return new DoublePipeline.StatelessOp<Integer>(this, StreamShape.INT_VALUE,
                                                   StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        public Sink<Integer> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedInt<Double>(sink) {
                @Override
                public void accept(int t) {
                    downstream.accept(mapper.applyAsDouble(t));
                }
            };
        }
    };
}
 

@Override
public RandomVariable apply(final DoubleTernaryOperator operator, final RandomVariable argument1, final RandomVariable argument2) {
	double newTime = Math.max(time, argument1.getFiltrationTime());
	newTime = Math.max(newTime, argument2.getFiltrationTime());

	final int newSize = Math.max(Math.max(this.size(), argument1.size()), argument2.size());

	final IntToDoubleFunction argument0Operator = this.getOperator();
	final IntToDoubleFunction argument1Operator = argument1.getOperator();
	final IntToDoubleFunction argument2Operator = argument2.getOperator();
	final IntToDoubleFunction result = new IntToDoubleFunction() {
		@Override
		public double applyAsDouble(final int i) {
			return operator.applyAsDouble(argument0Operator.applyAsDouble(i), argument1Operator.applyAsDouble(i), argument2Operator.applyAsDouble(i));
		}
	};

	return new RandomVariableFromFloatArray(newTime, result, newSize);
}
 

/**
 * Create a stochastic random variable.
 *
 * @param time the filtration time, set to 0.0 if not used.
 * @param realizations A map mapping integer (path or state) to double, representing this random variable.
 * @param size The size, i.e., number of paths.
 * @param typePriority The priority of this type in construction of result types. See "operator type priority" for details.
 */
public RandomVariableFromFloatArray(final double time, final IntToDoubleFunction realizations, final int size, final int typePriority) {
	super();
	this.time = time;
	this.realizations = size == 1 ? null : new float[size];//IntStream.range(0,size).parallel().mapToDouble(realisations).toArray();
	valueIfNonStochastic = size == 1 ? realizations.applyAsDouble(0) : Double.NaN;
	if(size > 1) {
		IntStream.range(0,size).parallel().forEach(new IntConsumer() {
			@Override
			public void accept(final int i) {
				RandomVariableFromFloatArray.this.realizations[i] = (float) realizations.applyAsDouble(i);
			}
		}
				);
	}
	this.typePriority = typePriority;
}
 

@Override
public final DoubleStream mapToDouble(IntToDoubleFunction mapper) {
    Objects.requireNonNull(mapper);
    return new DoublePipeline.StatelessOp<Integer>(this, StreamShape.INT_VALUE,
                                                   StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Integer> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedInt<Double>(sink) {
                @Override
                public void accept(int t) {
                    downstream.accept(mapper.applyAsDouble(t));
                }
            };
        }
    };
}
 

@Override
public final DoubleStream mapToDouble(IntToDoubleFunction mapper) {
    Objects.requireNonNull(mapper);
    return new DoublePipeline.StatelessOp<Integer>(this, StreamShape.INT_VALUE,
                                                   StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Integer> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedInt<Double>(sink) {
                @Override
                public void accept(int t) {
                    downstream.accept(mapper.applyAsDouble(t));
                }
            };
        }
    };
}
 

@Override
public final DoubleStream mapToDouble(IntToDoubleFunction mapper) {
    Objects.requireNonNull(mapper);
    return new DoublePipeline.StatelessOp<Integer>(this, StreamShape.INT_VALUE,
                                                   StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Integer> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedInt<Double>(sink) {
                @Override
                public void accept(int t) {
                    downstream.accept(mapper.applyAsDouble(t));
                }
            };
        }
    };
}
 

/**
 * Create an input device from the supplied mapping functions.
 * @param axisToValue the function that maps an integer to a double value for the axis
 * @param buttonNumberToSwitch the function that maps an integer to whether the button is pressed
 * @param padToValue the function that maps an integer to the directional axis output
 * @return the resulting input device; never null
 */
public static InputDevice create( IntToDoubleFunction axisToValue, IntToBooleanFunction buttonNumberToSwitch, IntToIntFunction padToValue ) {
    return new InputDevice() {
        @Override
        public ContinuousRange getAxis(int axis) {
            return ()->axisToValue.applyAsDouble(axis);
        }
        @Override
        public Switch getButton(int button) {
            return ()->buttonNumberToSwitch.applyAsBoolean(button);
        }
        @Override
        public DirectionalAxis getDPad(int pad) {
            return ()->padToValue.applyAsInt(pad);
        }
    };
}
 

@Test(dataProvider = "double")
public void testSetAllDouble(String name, int size, IntToDoubleFunction generator, double[] expected) {
    double[] result = new double[size];
    Arrays.setAll(result, generator);
    assertDoubleArrayEquals(result, expected, 0.05, "setAll(double[], IntToDoubleFunction) case " + name + " failed.");

    // ensure fresh array
    result = new double[size];
    Arrays.parallelSetAll(result, generator);
    assertDoubleArrayEquals(result, expected, 0.05, "setAll(double[], IntToDoubleFunction) case " + name + " failed.");
}
 

@Test(dataProvider = "double")
public void testSetAllDouble(String name, int size, IntToDoubleFunction generator, double[] expected) {
    double[] result = new double[size];
    Arrays.setAll(result, generator);
    assertDoubleArrayEquals(result, expected, 0.05, "setAll(double[], IntToDoubleFunction) case " + name + " failed.");

    // ensure fresh array
    result = new double[size];
    Arrays.parallelSetAll(result, generator);
    assertDoubleArrayEquals(result, expected, 0.05, "setAll(double[], IntToDoubleFunction) case " + name + " failed.");
}
 

@Test(dataProvider = "double")
public void testSetAllDouble(String name, int size, IntToDoubleFunction generator, double[] expected) {
    double[] result = new double[size];
    Arrays.setAll(result, generator);
    assertDoubleArrayEquals(result, expected, 0.05, "setAll(double[], IntToDoubleFunction) case " + name + " failed.");

    // ensure fresh array
    result = new double[size];
    Arrays.parallelSetAll(result, generator);
    assertDoubleArrayEquals(result, expected, 0.05, "setAll(double[], IntToDoubleFunction) case " + name + " failed.");
}
 

private static ExampleSet createExampleSetDatetime(int columns, int rows, boolean date) {
	List<Attribute> attributes = IntStream.range(0, columns).mapToObj(i -> "att-" + i + "-" + (date && i % 2 == 1))
			.map(name -> AttributeFactory.createAttribute(name, name.endsWith("true") ? Ontology.DATE :
					Ontology.DATE_TIME))
			.collect(Collectors.toList());
	ExampleSetBuilder builder = ExampleSets.from(attributes).withBlankSize(rows);
	IntToDoubleFunction datetimeFiller = i -> rng.nextInt() * 1000001;
	IntToDoubleFunction dateFiller = i -> (rng.nextInt() * 1000000) / 1000 * 1000;
	attributes.forEach(att -> builder.withColumnFiller(att, att.getValueType() == Ontology.DATE_TIME ?
			datetimeFiller : dateFiller));
	ExampleSet build = builder.build();
	build.getAnnotations().put("bla", "blup");
	build.recalculateAllAttributeStatistics();
	return build;
}
 

@Test(dataProvider = "double")
public void testSetAllDouble(String name, int size, IntToDoubleFunction generator, double[] expected) {
    double[] result = new double[size];
    Arrays.setAll(result, generator);
    assertDoubleArrayEquals(result, expected, 0.05, "setAll(double[], IntToDoubleFunction) case " + name + " failed.");

    // ensure fresh array
    result = new double[size];
    Arrays.parallelSetAll(result, generator);
    assertDoubleArrayEquals(result, expected, 0.05, "setAll(double[], IntToDoubleFunction) case " + name + " failed.");
}