use of cern.jet.random.Normal in project micrometer by micrometer-metrics.
the class FunctionTimerSample method main.
// For Atlas: http://localhost:7101/api/v1/graph?q=name,ftimer,:eq,:dist-avg,name,timer,:eq,:dist-avg,1,:axis&s=e-5m&l=0
public static void main(String[] args) {
MeterRegistry registry = SampleConfig.myMonitoringSystem();
Timer timer = Timer.builder("timer").publishPercentiles(0.5, 0.95).register(registry);
Object placeholder = new Object();
AtomicLong totalTimeNanos = new AtomicLong(0);
AtomicLong totalCount = new AtomicLong(0);
FunctionTimer.builder("ftimer", placeholder, p -> totalCount.get(), p -> totalTimeNanos.get(), TimeUnit.NANOSECONDS).register(registry);
RandomEngine r = new MersenneTwister64(0);
Normal incomingRequests = new Normal(0, 1, r);
Normal duration = new Normal(250, 50, r);
AtomicInteger latencyForThisSecond = new AtomicInteger(duration.nextInt());
Flux.interval(Duration.ofSeconds(1)).doOnEach(d -> latencyForThisSecond.set(duration.nextInt())).subscribe();
// the potential for an "incoming request" every 10 ms
Flux.interval(Duration.ofMillis(10)).doOnEach(d -> {
if (incomingRequests.nextDouble() + 0.4 > 0) {
// pretend the request took some amount of time, such that the time is
// distributed normally with a mean of 250ms
timer.record(latencyForThisSecond.get(), TimeUnit.MILLISECONDS);
totalCount.incrementAndGet();
totalTimeNanos.addAndGet((long) TimeUtils.millisToUnit(latencyForThisSecond.get(), TimeUnit.NANOSECONDS));
}
}).blockLast();
}
use of cern.jet.random.Normal in project micrometer by micrometer-metrics.
the class LongTaskTimerSample method main.
public static void main(String[] args) {
MeterRegistry registry = SampleConfig.myMonitoringSystem();
LongTaskTimer timer = registry.more().longTaskTimer("longTaskTimer");
RandomEngine r = new MersenneTwister64(0);
Normal incomingRequests = new Normal(0, 1, r);
Normal duration = new Normal(30, 50, r);
AtomicInteger latencyForThisSecond = new AtomicInteger(duration.nextInt());
Flux.interval(Duration.ofSeconds(1)).doOnEach(d -> latencyForThisSecond.set(duration.nextInt())).subscribe();
final Map<LongTaskTimer.Sample, CountDownLatch> tasks = new ConcurrentHashMap<>();
// the potential for an "incoming request" every 10 ms
Flux.interval(Duration.ofSeconds(1)).doOnEach(d -> {
if (incomingRequests.nextDouble() + 0.4 > 0 && tasks.isEmpty()) {
int taskDur;
while ((taskDur = duration.nextInt()) < 0) ;
synchronized (tasks) {
tasks.put(timer.start(), new CountDownLatch(taskDur));
}
}
synchronized (tasks) {
for (Map.Entry<LongTaskTimer.Sample, CountDownLatch> e : tasks.entrySet()) {
e.getValue().countDown();
if (e.getValue().getCount() == 0) {
e.getKey().stop();
tasks.remove(e.getKey());
}
}
}
}).blockLast();
}
use of cern.jet.random.Normal in project micrometer by micrometer-metrics.
the class SimulatedEndpointInstrumentation method main.
public static void main(String[] args) {
MeterRegistry registry = SampleConfig.myMonitoringSystem();
Timer e1Success = Timer.builder("http.server.requests").tags("uri", "/api/bar").tags("response", "200").publishPercentiles(0.5, 0.95).register(registry);
Timer e2Success = Timer.builder("http.server.requests").tags("uri", "/api/foo").tags("response", "200").publishPercentiles(0.5, 0.95).register(registry);
Timer e1Fail = Timer.builder("http.server.requests").tags("uri", "/api/bar").tags("response", "500").publishPercentiles(0.5, 0.95).register(registry);
Timer e2Fail = Timer.builder("http.server.requests").tags("uri", "/api/foo").tags("response", "500").publishPercentiles(0.5, 0.95).register(registry);
RandomEngine r = new MersenneTwister64(0);
Normal incomingRequests = new Normal(0, 1, r);
Normal successOrFail = new Normal(0, 1, r);
Normal duration = new Normal(250, 50, r);
Normal duration2 = new Normal(250, 50, r);
AtomicInteger latencyForThisSecond = new AtomicInteger(duration.nextInt());
Flux.interval(Duration.ofSeconds(1)).doOnEach(d -> latencyForThisSecond.set(duration.nextInt())).subscribe();
AtomicInteger latencyForThisSecond2 = new AtomicInteger(duration2.nextInt());
Flux.interval(Duration.ofSeconds(1)).doOnEach(d -> latencyForThisSecond2.set(duration2.nextInt())).subscribe();
// the potential for an "incoming request" every 10 ms
Flux.interval(Duration.ofMillis(10)).doOnEach(d -> {
// are we going to receive a request for /api/foo?
if (incomingRequests.nextDouble() + 0.4 > 0) {
if (successOrFail.nextDouble() + 0.8 > 0) {
// pretend the request took some amount of time, such that the time is
// distributed normally with a mean of 250ms
e1Success.record(latencyForThisSecond.get(), TimeUnit.MILLISECONDS);
} else {
e1Fail.record(latencyForThisSecond.get(), TimeUnit.MILLISECONDS);
}
}
}).subscribe();
// the potential for an "incoming request" every 1 ms
Flux.interval(Duration.ofMillis(1)).doOnEach(d -> {
// are we going to receive a request for /api/bar?
if (incomingRequests.nextDouble() + 0.4 > 0) {
if (successOrFail.nextDouble() + 0.8 > 0) {
// pretend the request took some amount of time, such that the time is
// distributed normally with a mean of 250ms
e2Success.record(latencyForThisSecond2.get(), TimeUnit.MILLISECONDS);
} else {
e2Fail.record(latencyForThisSecond2.get(), TimeUnit.MILLISECONDS);
}
}
}).blockLast();
}
use of cern.jet.random.Normal in project processdash by dtuma.
the class LognormalConfidenceInterval method generateBootstrapSamples.
private double[] generateBootstrapSamples() {
RandomEngine u = new MersenneTwister();
Normal normal = new Normal(0, 1, u);
ChiSquare chisquare = new ChiSquare(numSamples - 1, u);
int bootstrapSize = Settings.getInt("logCI.bootstrapSize", 2000);
double[] samples = new double[bootstrapSize];
for (int i = bootstrapSize; i-- > 0; ) samples[i] = generateBootstrapSample(normal, chisquare, numSamples, logstd);
Arrays.sort(samples);
return samples;
}
use of cern.jet.random.Normal in project Gemma by PavlidisLab.
the class ComBat method plot.
/**
* Make diagnostic plots.
* FIXME: As in the original ComBat, this only graphs the first batch's statistics. In principle we can (and perhaps
* should) examine these plots for all the batches.
*
* @param filePrefix file prefix
*/
public void plot(String filePrefix) {
if (this.gammaHat == null)
throw new IllegalArgumentException("You must call 'run' first");
/*
* View the distribution of gammaHat, which we assume will have a normal distribution
*/
DoubleMatrix1D ghr = gammaHat.viewRow(0);
int NUM_HIST_BINS = 100;
Histogram gammaHatHist = new Histogram("GammaHat", NUM_HIST_BINS, ghr);
XYSeries ghplot = gammaHatHist.plot();
Normal rn = new Normal(this.gammaBar.get(0), Math.sqrt(this.t2.get(0)), new MersenneTwister());
Histogram ghtheoryT = new Histogram("Gamma", NUM_HIST_BINS, gammaHatHist.min(), gammaHatHist.max());
for (int i = 0; i < 10000; i++) {
double n = rn.nextDouble();
ghtheoryT.fill(n);
}
XYSeries ghtheory = ghtheoryT.plot();
File tmpfile;
try {
tmpfile = File.createTempFile(filePrefix + ".gammahat.histogram.", ".png");
ComBat.log.info(tmpfile);
} catch (IOException e) {
throw new RuntimeException(e);
}
try (OutputStream os = new FileOutputStream(tmpfile)) {
this.writePlot(os, ghplot, ghtheory);
/*
* View the distribution of deltaHat, which we assume has an inverse gamma distribution
*/
DoubleMatrix1D dhr = deltaHat.viewRow(0);
Histogram deltaHatHist = new Histogram("DeltaHat", NUM_HIST_BINS, dhr);
XYSeries dhplot = deltaHatHist.plot();
Gamma g = new Gamma(aPrior.get(0), bPrior.get(0), new MersenneTwister());
Histogram deltaHatT = new Histogram("Delta", NUM_HIST_BINS, deltaHatHist.min(), deltaHatHist.max());
for (int i = 0; i < 10000; i++) {
double invg = 1.0 / g.nextDouble();
deltaHatT.fill(invg);
}
XYSeries dhtheory = deltaHatT.plot();
tmpfile = File.createTempFile(filePrefix + ".deltahat.histogram.", ".png");
ComBat.log.info(tmpfile);
try (OutputStream os2 = new FileOutputStream(tmpfile)) {
this.writePlot(os2, dhplot, dhtheory);
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
Aggregations