Example usage for org.apache.commons.math.distribution CauchyDistributionImpl CauchyDistributionImpl

List of usage examples for org.apache.commons.math.distribution CauchyDistributionImpl CauchyDistributionImpl

Introduction

In this page you can find the example usage for org.apache.commons.math.distribution CauchyDistributionImpl CauchyDistributionImpl.

Prototype

public CauchyDistributionImpl(double median, double s) 

Source Link

Document

Create a cauchy distribution using the given median and scale.

Usage

From source file:edu.utexas.cs.tactex.servercustomers.factoredcustomer.ProbabilityDistribution.java

ProbabilityDistribution(FactoredCustomerService service, Element xml) {
    if (null == randomSeedRepo)
        randomSeedRepo = (RandomSeedRepo) SpringApplicationContext.getBean("randomSeedRepo");

    type = Enum.valueOf(DistType.class, xml.getAttribute("distribution"));
    switch (type) {
    case POINTMASS:
    case DEGENERATE:
        param1 = Double.parseDouble(xml.getAttribute("value"));
        sampler = new DegenerateSampler(param1);
        break;//from   www .  j  a  va2 s  .c o  m
    case UNIFORM:
        param1 = Double.parseDouble(xml.getAttribute("low"));
        param2 = Double.parseDouble(xml.getAttribute("high"));
        sampler = new UniformSampler(param1, param2);
        break;
    case INTERVAL:
        param1 = Double.parseDouble(xml.getAttribute("mean"));
        param2 = Double.parseDouble(xml.getAttribute("stdDev"));
        param3 = Double.parseDouble(xml.getAttribute("low"));
        param4 = Double.parseDouble(xml.getAttribute("high"));
        sampler = new IntervalSampler(param1, param2, param3, param4);
        break;
    case NORMAL:
    case GAUSSIAN:
        param1 = Double.parseDouble(xml.getAttribute("mean"));
        param2 = Double.parseDouble(xml.getAttribute("stdDev"));
        sampler = new ContinuousSampler(new NormalDistributionImpl(param1, param2));
        break;
    case STDNORMAL:
        param1 = 0;
        param2 = 1;
        sampler = new ContinuousSampler(new NormalDistributionImpl(param1, param2));
        break;
    case LOGNORMAL:
        param1 = Double.parseDouble(xml.getAttribute("expMean"));
        param2 = Double.parseDouble(xml.getAttribute("expStdDev"));
        sampler = new LogNormalSampler(param1, param2);
        break;
    case CAUCHY:
        param1 = Double.parseDouble(xml.getAttribute("median"));
        param2 = Double.parseDouble(xml.getAttribute("scale"));
        sampler = new ContinuousSampler(new CauchyDistributionImpl(param1, param2));
        break;
    case BETA:
        param1 = Double.parseDouble(xml.getAttribute("alpha"));
        param2 = Double.parseDouble(xml.getAttribute("beta"));
        sampler = new ContinuousSampler(new BetaDistributionImpl(param1, param2));
        break;
    case BINOMIAL:
        param1 = Double.parseDouble(xml.getAttribute("trials"));
        param2 = Double.parseDouble(xml.getAttribute("success"));
        sampler = new DiscreteSampler(new BinomialDistributionImpl((int) param1, param2));
        break;
    case POISSON:
        param1 = Double.parseDouble(xml.getAttribute("lambda"));
        sampler = new DiscreteSampler(new PoissonDistributionImpl(param1));
        break;
    case CHISQUARED:
        param1 = Double.parseDouble(xml.getAttribute("dof"));
        sampler = new ContinuousSampler(new ChiSquaredDistributionImpl(param1));
        break;
    case EXPONENTIAL:
        param1 = Double.parseDouble(xml.getAttribute("mean"));
        sampler = new ContinuousSampler(new ExponentialDistributionImpl(param1));
        break;
    case GAMMA:
        param1 = Double.parseDouble(xml.getAttribute("alpha"));
        param2 = Double.parseDouble(xml.getAttribute("beta"));
        sampler = new ContinuousSampler(new GammaDistributionImpl(param1, param2));
        break;
    case WEIBULL:
        param1 = Double.parseDouble(xml.getAttribute("alpha"));
        param2 = Double.parseDouble(xml.getAttribute("beta"));
        sampler = new ContinuousSampler(new WeibullDistributionImpl(param1, param2));
        break;
    case STUDENT:
        param1 = Double.parseDouble(xml.getAttribute("dof"));
        sampler = new ContinuousSampler(new TDistributionImpl(param1));
        break;
    case SNEDECOR:
        param1 = Double.parseDouble(xml.getAttribute("d1"));
        param2 = Double.parseDouble(xml.getAttribute("d2"));
        sampler = new ContinuousSampler(new FDistributionImpl(param1, param2));
        break;
    default:
        throw new Error("Invalid probability distribution type!");
    }
    sampler.reseedRandomGenerator(service.getRandomSeedRepo()
            .getRandomSeed("factoredcustomer.ProbabilityDistribution", SeedIdGenerator.getId(), "Sampler")
            .getValue());
}

From source file:es.udc.gii.common.eaf.plugin.parameter.jade.JADEFAdaptiveParameter.java

@Override
public double get(EvolutionaryAlgorithm algorithm) {

    //Lehmer mean:
    double meanl_f;
    double sum_f_i, sum_f_i_2;
    List<Individual> individuals;
    int f_individuals;
    double f_ind, f_i;

    //Hay que "chequear" que los individuos sean del tipo JADE:

    sum_f_i = 0.0;/*from   ww w .ja v a 2 s.c om*/
    sum_f_i_2 = 0.0;

    if (algorithm.getGenerations() > this.alg_generation) {

        //Calculamos mu;
        individuals = algorithm.getPopulation().getIndividuals();

        meanl_f = 0.0;
        f_individuals = 0;
        for (Individual i : individuals) {

            if (i instanceof JADEIndividual) {

                f_ind = ((JADEIndividual) i).getF();
                if (f_ind != -Double.MAX_VALUE) {
                    sum_f_i += f_ind;
                    sum_f_i_2 += f_ind * f_ind;
                    f_individuals++;
                }
            } else {
                throw new ConfigurationException(
                        "JADECRAdaptiveParameter requires individuals of type JADEIndividual");
            }

        }

        if (f_individuals > 0) {
            meanl_f = sum_f_i_2 / sum_f_i;
            this.mu_f = (1.0 - this.c) * this.mu_f + this.c * meanl_f;
        }

        this.mu_f = (this.mu_f > 1.0 ? 1.0 : (this.mu_f < 0.0 ? 0.0 : this.mu_f));

        this.alg_generation++;
    }

    CauchyDistribution d = new CauchyDistributionImpl(this.mu_f, this.std_f);
    f_i = 0.0;
    try {
        do {
            double r = EAFRandom.nextDouble();
            f_i = d.inverseCumulativeProbability(r);
        } while (f_i < 1.0e-8);
        f_i = (f_i > 1.0 ? 1.0 : (f_i < 0.0 ? 0.0 : f_i));
    } catch (MathException ex) {
        Logger.getLogger(JADEFAdaptiveParameter.class.getName()).log(Level.SEVERE, null, ex);
    }

    return f_i;
}

From source file:geogebra.kernel.statistics.AlgoDistribution.java

CauchyDistribution getCauchyDistribution(double param, double param2) {
    if (cauchy == null)
        cauchy = new CauchyDistributionImpl(param, param2);
    else {//from ww  w.java  2 s.c om
        cauchy.setMedian(param);
        cauchy.setScale(param2);
    }
    return cauchy;
}

From source file:geogebra.common.kernel.statistics.AlgoDistribution.java

/**
 * @param param//w w w  .ja va  2 s .  co  m
 *            median
 * @param param2
 *            scale
 * @return cauchy distribution
 */
protected CauchyDistribution getCauchyDistribution(double param, double param2) {
    if (cauchy == null || cauchy.getMedian() != param || cauchy.getScale() != param2)
        cauchy = new CauchyDistributionImpl(param, param2);

    return cauchy;
}

From source file:org.renjin.Distributions.java

public static double dcauchy(final double x, final double location, final double scale, boolean log) {
    return d(new CauchyDistributionImpl(location, scale), x, log);
}

From source file:org.renjin.Distributions.java

public static double pcauchy(final double q, final double location, final double scale, boolean lowerTail,
        boolean logP) {
    return p(new CauchyDistributionImpl(location, scale), q, lowerTail, logP);
}

From source file:org.renjin.Distributions.java

public static double qcauchy(final double p, final double location, final double scale, boolean lowerTail,
        boolean logP) {
    return q(new CauchyDistributionImpl(location, scale), p, lowerTail, logP);
}

From source file:org.renjin.primitives.random.Distributions.java

public static double dcauchy(@Recycle double x, @Recycle double location, @Recycle double scale, boolean log) {
    return d(new CauchyDistributionImpl(location, scale), x, log);
}

From source file:org.renjin.primitives.random.Distributions.java

public static double pcauchy(@Recycle double q, @Recycle double location, @Recycle double scale,
        boolean lowerTail, boolean logP) {
    return p(new CauchyDistributionImpl(location, scale), q, lowerTail, logP);
}

From source file:org.renjin.primitives.random.Distributions.java

public static double qcauchy(@Recycle double p, @Recycle double location, @Recycle double scale,
        boolean lowerTail, boolean logP) {
    return q(new CauchyDistributionImpl(location, scale), p, lowerTail, logP);
}