Examples with EmpiricalDistribution de.hpi.bpt.scylla.model.configuration.distribution.EmpiricalDistribution used on opensource projects

Example 1 with EmpiricalDistribution

use of de.hpi.bpt.scylla.model.configuration.distribution.EmpiricalDistribution in project scylla by bptlab.

the class DataDistributionWrapper method getSample.

/*public void setMin(double min) {
		this.min = min;
	}
	
	public void setMax(double max) {
		this.max = max;
	}*/
public Object getSample() throws ScyllaRuntimeException, ScyllaValidationException {
    if (desmojDistribution == null) {
        throw new ScyllaRuntimeException("desmojDistribution is not set.");
    }
    double value;
    /*do{
			value = desmojDistribution.sample().doubleValue();
		} while(min > value || value > max);*/
    // generate data in the given range with the given distribution, project it
    // value = min + (max-min) * ((desmojDistribution.sample().doubleValue() - Double.MAX_VALUE)/(Double.MAX_VALUE - Double.MAX_VALUE));
    value = desmojDistribution.sample().doubleValue();
    if (type == DataDistributionType.LONG) {
        return Math.round(value);
    } else // handle STRING samples
    if (type == DataDistributionType.STRING) {
        if (!(distribution instanceof EmpiricalStringDistribution)) {
            throw new ScyllaValidationException("Distribution is not an empirical string distribution, but the distribution type is String.");
        }
        EmpiricalStringDistribution es = (EmpiricalStringDistribution) distribution;
        return es.getNames().get(value);
    } else // handle BOOLEAN samples
    if (type == DataDistributionType.BOOLEAN) {
        if (!(distribution instanceof EmpiricalDistribution)) {
            throw new ScyllaValidationException("Distribution is not an empirical distribution, but the distribution type is Boolean.");
        }
        EmpiricalDistribution es = (EmpiricalDistribution) distribution;
        if (es.getEntries().size() != 2 || !es.getEntries().containsKey(1.0) || !es.getEntries().containsKey(0.0)) {
            throw new ScyllaValidationException("Distribution does not match the requirements for Boolean distribution type.");
        }
        return (value == 1.0);
    } else // handle default DOUBLE samples
    {
        return value;
    }
}

Example 2 with EmpiricalDistribution

use of de.hpi.bpt.scylla.model.configuration.distribution.EmpiricalDistribution in project scylla by bptlab.

the class SimulationUtils method getDistribution.

public static NumericalDist<?> getDistribution(Distribution dist, SimulationModel model, String name, Integer nodeId, boolean showInReport, boolean showInTrace) throws InstantiationException {
    if (dist instanceof BinomialDistribution) {
        BinomialDistribution binDist = (BinomialDistribution) dist;
        double probability = binDist.getProbability();
        int amount = binDist.getAmount();
        return new DiscreteDistBinomial(model, name, probability, amount, showInReport, showInTrace);
    } else if (dist instanceof ConstantDistribution) {
        ConstantDistribution conDist = (ConstantDistribution) dist;
        double constantValue = conDist.getConstantValue();
        return new DiscreteDistConstant<Number>(model, name, constantValue, showInReport, showInTrace);
    } else if (dist instanceof EmpiricalDistribution) {
        EmpiricalDistribution empDist = (EmpiricalDistribution) dist;
        Map<Double, Double> entries = empDist.getEntries();
        DiscreteDistEmpirical<Double> cde = new DiscreteDistEmpirical<Double>(model, name, showInReport, showInTrace);
        for (Double value : entries.keySet()) {
            Double frequency = entries.get(value);
            cde.addEntry(value, frequency);
        }
        return cde;
    } else if (dist instanceof EmpiricalStringDistribution) {
        EmpiricalStringDistribution empDist = (EmpiricalStringDistribution) dist;
        Map<Double, Double> entries = empDist.getEntries();
        DiscreteDistEmpirical<Double> cde = new DiscreteDistEmpirical<Double>(model, name, showInReport, showInTrace);
        for (Double value : entries.keySet()) {
            Double frequency = entries.get(value);
            cde.addEntry(value, frequency);
        }
        return cde;
    } else if (dist instanceof ErlangDistribution) {
        ErlangDistribution erlDist = (ErlangDistribution) dist;
        double mean = erlDist.getMean();
        long order = erlDist.getOrder();
        return new ContDistErlang(model, name, order, mean, showInReport, showInTrace);
    } else if (dist instanceof ExponentialDistribution) {
        ExponentialDistribution expDist = (ExponentialDistribution) dist;
        double mean = expDist.getMean();
        return new ContDistExponential(model, name, mean, showInReport, showInTrace);
    } else if (dist instanceof TriangularDistribution) {
        TriangularDistribution triDist = (TriangularDistribution) dist;
        double lower = triDist.getLower();
        double upper = triDist.getUpper();
        double peak = triDist.getPeak();
        return new ContDistTriangular(model, name, lower, upper, peak, showInReport, showInTrace);
    } else if (dist instanceof NormalDistribution) {
        NormalDistribution norDist = (NormalDistribution) dist;
        double mean = norDist.getMean();
        double standardDeviation = norDist.getStandardDeviation();
        return new ContDistNormal(model, name, mean, standardDeviation, showInReport, showInTrace);
    } else if (dist instanceof PoissonDistribution) {
        PoissonDistribution poiDist = (PoissonDistribution) dist;
        double mean = poiDist.getMean();
        return new DiscreteDistPoisson(model, name, mean, showInReport, showInTrace);
    } else if (dist instanceof UniformDistribution) {
        UniformDistribution uniDist = (UniformDistribution) dist;
        double lower = uniDist.getLower();
        double upper = uniDist.getUpper();
        return new ContDistUniform(model, name, lower, upper, showInReport, showInTrace);
    } else {
        throw new InstantiationException("Distribution of node " + nodeId + " not supported.");
    }
}

Example 3 with EmpiricalDistribution

use of de.hpi.bpt.scylla.model.configuration.distribution.EmpiricalDistribution in project scylla by bptlab.

the class SimulationConfigurationParser method getDistribution.

public static Distribution getDistribution(Element element, Namespace simNamespace, String fieldType) throws ScyllaValidationException {
    Distribution distribution;
    if (element.getChild("arbitraryFiniteProbabilityDistribution", simNamespace) != null && fieldType.equals("string")) {
        Element el = element.getChild("arbitraryFiniteProbabilityDistribution", simNamespace);
        // changed name here but now in the whole project
        EmpiricalStringDistribution dist = new EmpiricalStringDistribution();
        List<Element> entries = el.getChildren("entry", simNamespace);
        if (entries.isEmpty()) {
            throw new ScyllaValidationException("You have to specify pairs of a vaule and a frequency for arbitraryFiniteProbabilityDistribution at " + getTaskOfDistribution(element) + ". Check spelling!");
        }
        double sum = 0;
        try {
            for (Element entry : entries) {
                // normalize frequency to 1.0
                sum += Double.valueOf(entry.getAttributeValue("frequency"));
            }
            for (Element entry : entries) {
                dist.addEntry(entry.getAttributeValue("value"), Double.valueOf(entry.getAttributeValue("frequency")) / sum);
            }
        } catch (NullPointerException e) {
            throw new ScyllaValidationException("You have to specify pairs of a vaule and a frequency for arbitraryFiniteProbabilityDistribution at " + getTaskOfDistribution(element) + ". Check spelling!");
        }
        distribution = dist;
    } else if (element.getChild("arbitraryFiniteProbabilityDistribution", simNamespace) != null) {
        Element el = element.getChild("arbitraryFiniteProbabilityDistribution", simNamespace);
        // changed name here but now in the whole project
        EmpiricalDistribution dist = new EmpiricalDistribution();
        List<Element> entries = el.getChildren("entry", simNamespace);
        if (entries.isEmpty()) {
            throw new ScyllaValidationException("You have to specify pairs of a vaule and a frequency for arbitraryFiniteProbabilityDistribution at " + getTaskOfDistribution(element) + ". Check spelling!");
        }
        double sum = 0;
        try {
            for (Element entry : entries) {
                // normalize frequency to 1.0
                sum += Double.valueOf(entry.getAttributeValue("frequency"));
            }
            for (Element entry : entries) {
                dist.addEntry(Double.valueOf(entry.getAttributeValue("value")), Double.valueOf(entry.getAttributeValue("frequency")) / sum);
            }
        } catch (NullPointerException e) {
            throw new ScyllaValidationException("You have to specify pairs of a vaule and a frequency for arbitraryFiniteProbabilityDistribution at " + getTaskOfDistribution(element) + ". Check spelling!");
        }
        distribution = dist;
    } else if (element.getChild("binomialDistribution", simNamespace) != null) {
        Element el = element.getChild("binomialDistribution", simNamespace);
        try {
            double probability = Double.valueOf(el.getChildText("probability", simNamespace));
            int amount = Integer.valueOf(el.getChildText("amount", simNamespace));
            distribution = new BinomialDistribution(probability, amount);
        } catch (NullPointerException e) {
            throw new ScyllaValidationException("You have to specify a probability and an amount for binomialDistribution at " + getTaskOfDistribution(element) + ". Check spelling!");
        }
    } else if (element.getChild("constantDistribution", simNamespace) != null) {
        Element el = element.getChild("constantDistribution", simNamespace);
        try {
            double constantValue = Double.valueOf(el.getChildText("constantValue", simNamespace));
            distribution = new ConstantDistribution(constantValue);
        } catch (NullPointerException e) {
            throw new ScyllaValidationException("You have to specify a constantValue for constantDistribution at " + getTaskOfDistribution(element) + ". Check spelling!");
        }
    } else if (element.getChild("erlangDistribution", simNamespace) != null) {
        Element el = element.getChild("erlangDistribution", simNamespace);
        try {
            long order = Long.valueOf(el.getChildText("order", simNamespace));
            double mean = Double.valueOf(el.getChildText("mean", simNamespace));
            distribution = new ErlangDistribution(order, mean);
        } catch (NullPointerException e) {
            throw new ScyllaValidationException("You have to specify a order and a mean for erlangDistribution at " + getTaskOfDistribution(element) + ". Check spelling!");
        }
    } else if (element.getChild("exponentialDistribution", simNamespace) != null) {
        Element el = element.getChild("exponentialDistribution", simNamespace);
        try {
            double mean = Double.valueOf(el.getChildText("mean", simNamespace));
            distribution = new ExponentialDistribution(mean);
        } catch (NullPointerException e) {
            throw new ScyllaValidationException("You have to specify a mean for exponentialDistribution at " + getTaskOfDistribution(element) + ". Check spelling!");
        }
    } else if (element.getChild("triangularDistribution", simNamespace) != null) {
        Element el = element.getChild("triangularDistribution", simNamespace);
        try {
            double lower = Double.valueOf(el.getChildText("lower", simNamespace));
            double upper = Double.valueOf(el.getChildText("upper", simNamespace));
            double peak = Double.valueOf(el.getChildText("peak", simNamespace));
            distribution = new TriangularDistribution(lower, upper, peak);
        } catch (NullPointerException e) {
            throw new ScyllaValidationException("You have to specify a lower, a upper and a peak for triangularDistribution at" + getTaskOfDistribution(element) + ". Check spelling!");
        }
    } else if (element.getChild("normalDistribution", simNamespace) != null) {
        Element el = element.getChild("normalDistribution", simNamespace);
        try {
            double mean = Double.valueOf(el.getChildText("mean", simNamespace));
            double standardDeviation = Double.valueOf(el.getChildText("standardDeviation", simNamespace));
            distribution = new NormalDistribution(mean, standardDeviation);
        } catch (NullPointerException e) {
            throw new ScyllaValidationException("You have to specify a mean and a standardDeviation for normalDistribution at " + getTaskOfDistribution(element) + ". Check spelling!");
        }
    } else if (element.getChild("poissonDistribution", simNamespace) != null) {
        Element el = element.getChild("poissonDistribution", simNamespace);
        try {
            double mean = Double.valueOf(el.getChildText("mean", simNamespace));
            distribution = new PoissonDistribution(mean);
        } catch (NullPointerException e) {
            throw new ScyllaValidationException("You have to specify a mean for poissonDistribution at " + getTaskOfDistribution(element) + ". Check spelling!");
        }
    } else if (element.getChild("uniformDistribution", simNamespace) != null) {
        Element el = element.getChild("uniformDistribution", simNamespace);
        try {
            double lower = Double.valueOf(el.getChildText("lower", simNamespace));
            double upper = Double.valueOf(el.getChildText("upper", simNamespace));
            distribution = new UniformDistribution(lower, upper);
        } catch (NullPointerException e) {
            throw new ScyllaValidationException("You have to specify a lower and an upper for uniformDistribution at " + getTaskOfDistribution(element) + ". Check spelling!");
        }
    } else {
        throw new ScyllaValidationException("Distribution definition at " + getTaskOfDistribution(element) + " not found or not supported. Check spelling!");
    }
    return distribution;
}