public DoubleMapAction(DoubleUnaryOperator mapper) { super(s -> s.map(requireNonNull(mapper)), DoubleStream.class, MAP_TO_SAME); }
static ISeq<Vec<double[]>> frontMax( final double r, final int count, final Random random ) { return random.doubles(count) .map(a -> a*PI*0.5) .mapToObj(a -> Vec.of(r*sin(a), r*cos(a))) .collect(ISeq.toISeq()); }
@Override public DoubleStream build(boolean parallel) { return previous().build(parallel).map(mapper); } }
static ISeq<Vec<double[]>> frontMin( final double r, final int count, final Random random ) { return random.doubles(count) .map(a -> a*PI*0.5 + PI) .mapToObj(a -> Vec.of(r*sin(a), r*cos(a))) .collect(ISeq.toISeq()); }
@Override public DoubleStream map(DoubleUnaryOperator mapper) { return wrap(stream().map(mapper)); }
IgniteBiTuple<Double, Long> meanTuple = dataset.compute( data -> { double sum = Arrays.stream(data.getLabels()).map(this::externalLabelToInternal).sum(); return new IgniteBiTuple<>(sum, (long)data.getLabels().length); },
/** * Find the sum of a window of values * If all values are missing/null/NaN, the return value will be 0.0 */ public static double sum(double[] values) { if (values.length == 0) { return 0.0; } return Arrays.stream(values).map(value -> { if (Double.isNaN(value) == false) { return value; } return 0.0; }).sum(); }
@Deprecated //moved to cyclops.companion.Functions public static Function<? super ReactiveSeq<Double>, ? extends ReactiveSeq<Double>> mapDoubles(DoubleUnaryOperator b){ return a->a.doubles(i->i,s->s.map(b)); } /*
public static Function<? super ReactiveSeq<Double>, ? extends ReactiveSeq<Double>> mapDoubles(DoubleUnaryOperator b){ return a->a.doubles(i->i,s->s.map(b)); } /*
@Test public void doubles(){ assertThat(ReactiveSeq.range(1, 1000).doubles(i->i.doubleValue(),s->s.map(i->i*2).filter(i->i<500)) .size(),equalTo(249)); } @Test
/** * Scale double [ ]. * * @param a the a * @param b the b * @return the double [ ] */ public static double[] scale(double[] a, double b) { return Arrays.stream(a).map(v -> v * b).toArray(); }
/** * L 2 double. * * @return the double */ public double l2() { return Math.sqrt(Arrays.stream(getData()).map(x -> x * x).sum()); }
/** * Is zero boolean. * * @param stream the stream * @param zeroTol the zero tol * @return the boolean */ public boolean isZero(@Nonnull final DoubleStream stream, double zeroTol) { final double[] array = stream.toArray(); if (array.length == 0) return false; return Arrays.stream(array).map(x -> Math.abs(x)).sum() < zeroTol; }
@Nonnull @Override public State<K> map(@Nonnull final DoubleUnaryOperator mapper) { return new State(layer, target, Arrays.stream(getDelta()).map(x -> mapper.applyAsDouble(x)).toArray()); }
/** * Map evalInputDelta. * * @param mapper the mapper * @return the evalInputDelta */ @Nonnull public DoubleBuffer<K> map(@Nonnull final DoubleUnaryOperator mapper) { return new DoubleBuffer<K>(this.layer, this.target, Arrays.stream(this.getDelta()).map(x -> mapper.applyAsDouble(x)).toArray()); }
private double calculateVarianceOfUniformDistribution(final double[] samples) { final double xSum = stream(samples).sum(); final double xPow2Sum = stream(samples).map(d -> pow(d, 2)).sum(); final double n = xSum; final double expectedValue = (n / samples.length); final double variance = (1.0 / n) * (xPow2Sum - (1.0 / n) * pow(xSum, 2)); return abs(variance - expectedValue); }
private static double[] autocovariance(double[] samples) { final int length = samples.length; double[] demeanPaddedWithZeros = calculatePaddedDemean(samples); Complex[] ifft = fftCrossCorrelationWithSelf(demeanPaddedWithZeros); double[] realParts = getRealPartsAndTruncate(ifft, length); double[] realPartsDivN = Arrays.stream(realParts).map(x -> x / length).toArray(); return realPartsDivN; }
@Override public LocalDateDoubleTimeSeries mapValues(DoubleUnaryOperator mapper) { ArgChecker.notNull(mapper, "mapper"); return createUnsafe(dates, DoubleStream.of(values).map(mapper).toArray()); }
@Override public LocalDateDoubleTimeSeries mapValues(DoubleUnaryOperator mapper) { DoubleStream values = DoubleStream.of(points).map(d -> isValidPoint(d) ? applyMapper(mapper, d) : d); return new DenseLocalDateDoubleTimeSeries(startDate, values.toArray(), dateCalculation, true); }