Example usage for org.apache.commons.math3.distribution LogNormalDistribution sample

List of usage examples for org.apache.commons.math3.distribution LogNormalDistribution sample

Introduction

In this page you can find the example usage for org.apache.commons.math3.distribution LogNormalDistribution sample.

Prototype

@Override
public double sample() 

Source Link

Usage

From source file:controller.DistributionController.java

public static void logNormal(double mean, double stand, double size, double extra) {
    numerosGerados.clear();//from www .j a v a2s  . c  om
    double mu = Math.log(mean * mean / Math.sqrt(mean * mean + stand * stand));
    double sigma = Math.sqrt(Math.log((mean * mean + stand * stand) / (mean * mean)));
    LogNormalDistribution lg = new LogNormalDistribution(mu, sigma);
    Double n;
    for (int i = 0; i < size; i++) {
        n = extra + lg.sample();
        numerosGerados.add(n);
    }
}

From source file:com.gordoni.opal.ScenarioSet.java

public ScenarioSet(Config config, HistReturns hist, String cwd, Map<String, Object> params,
        String param_filename) throws ExecutionException, IOException, InterruptedException {
    this.config = config;
    this.cwd = cwd;

    // Override default scenario based on scenario file.
    boolean param_filename_is_default = (param_filename == null);
    if (param_filename_is_default)
        param_filename = config.prefix + "-scenario.txt";

    File f = new File(cwd + '/' + param_filename);
    if (!f.exists()) {
        if (!param_filename_is_default)
            throw new FileNotFoundException(param_filename);
    } else {/*from   ww  w . j  av  a  2 s. c  o m*/
        BufferedReader reader = new BufferedReader(new FileReader(f));
        StringBuilder stringBuilder = new StringBuilder();
        String line;
        while ((line = reader.readLine()) != null) {
            stringBuilder.append(line);
            stringBuilder.append(System.getProperty("line.separator"));
        }
        Map<String, Object> fParams = new HashMap<String, Object>();
        config.load_params(fParams, stringBuilder.toString());
        config.applyParams(fParams);
    }

    // Override default scenario based on command line arguments.
    if (params != null)
        config.applyParams(params);

    generate_stats = new VitalStats(this, config, hist, config.generate_time_periods);
    generate_stats.compute_stats(config.generate_life_table, 1); // Compute here so we can access death.length.
    validate_stats = new VitalStats(this, config, hist, config.validate_time_periods);
    validate_stats.compute_stats(config.validate_life_table, 1);
    generate_annuity_stats = new AnnuityStats(this, config, hist, generate_stats, config.generate_time_periods,
            config.annuity_table);
    validate_annuity_stats = new AnnuityStats(this, config, hist, validate_stats, config.validate_time_periods,
            config.annuity_table);

    System.out.println("Parameters:");
    config.dumpParams();
    System.out.println();

    boolean do_compare = !config.skip_compare;

    Scenario compare_scenario = null;
    if (do_compare) {
        assert (config.tax_rate_div == null);
        assert (!config.ef.equals("none"));
        List<String> asset_classes = new ArrayList<String>(Arrays.asList("stocks", "bonds"));
        compare_scenario = new Scenario(this, config, hist, false, !config.skip_validate, asset_classes,
                asset_classes, config.ret_equity_premium, 1, 1, 1, null, null);
    }

    Scenario scenario = new Scenario(this, config, hist, config.compute_risk_premium, !config.skip_validate,
            config.asset_classes, config.asset_class_names, config.ret_equity_premium, 1, 1, 1,
            config.start_ria, config.start_nia);
    scenario.report_returns();

    if (config.compute_risk_premium)
        return;

    Scenario[] error_scenario = new Scenario[config.error_count];
    if (config.error_count > 0) {
        List<String> asset_classes = new ArrayList<String>(Arrays.asList("stocks", "bonds"));
        Scenario risk_premium_scenario = new Scenario(this, config, hist, true, false, asset_classes,
                asset_classes, config.ret_equity_premium, 1, 1, 1, config.start_ria, config.start_nia);
        List<double[]> rp_returns = Utils.zipDoubleArray(risk_premium_scenario.returns_generate.original_data);
        double n = rp_returns.get(0).length;
        double sample_erp_am = Utils.mean(rp_returns.get(0));
        double sample_erp_sd = Utils.standard_deviation(rp_returns.get(0));

        JDKRandomGenerator random = new JDKRandomGenerator();
        random.setSeed(0);
        ChiSquaredDistribution chi_squared = new ChiSquaredDistribution(random, n - 1);
        LogNormalDistribution gamma_distribution = null;
        if (config.gamma_vol > 0)
            gamma_distribution = new LogNormalDistribution(random, 0, config.gamma_vol);
        LogNormalDistribution q_distribution = null;
        if (config.q_vol > 0)
            q_distribution = new LogNormalDistribution(random, 0, config.q_vol);
        for (int i = 0; i < error_scenario.length; i++) {
            double erp;
            double equity_vol_adjust;
            if (config.equity_premium_vol) {
                double population_erp_am = sample_erp_am;
                equity_vol_adjust = Math.sqrt((n - 1) / chi_squared.sample());
                double population_erp_sd = sample_erp_sd * equity_vol_adjust;
                double erp_am = population_erp_am;
                double erp_sd = population_erp_sd / Math.sqrt(n);
                erp = erp_am + erp_sd * random.nextGaussian();
            } else {
                erp = sample_erp_am;
                equity_vol_adjust = 1;
            }
            double gamma_adjust = ((config.gamma_vol > 0) ? gamma_distribution.sample() : 1);
            double q_adjust = ((config.q_vol > 0) ? q_distribution.sample() : 1);
            error_scenario[i] = new Scenario(this, config, hist, false, false, config.asset_classes,
                    config.asset_class_names, erp, equity_vol_adjust, gamma_adjust, q_adjust, config.start_ria,
                    config.start_nia);
        }
    }

    if (do_compare)
        compare_scenario.run_mvo("compare"); // Helps determine max_stocks based on risk tolerance.
    scenario.run_mvo("scenario");
    for (int i = 0; i < error_scenario.length; i++)
        error_scenario[i].run_mvo("error");

    executor = Executors.newFixedThreadPool(config.workers);
    try {
        if (do_compare)
            compare_scenario.run_compare();

        scenario.run_main();

        if (error_scenario.length > 0) {
            long start = System.currentTimeMillis();

            for (int i = 0; i < error_scenario.length; i++) {
                if (config.trace || config.trace_error)
                    System.out.println("error scenario " + (i + 1));
                generate_stats.compute_stats(config.generate_life_table, error_scenario[i].q_adjust);
                error_scenario[i].run_error();
            }
            generate_stats.compute_stats(config.generate_life_table, 1); // Reset to default.

            dump_error(scenario, error_scenario, "0.68", 0.68);
            dump_error(scenario, error_scenario, "0.95", 0.95);

            double elapsed = (System.currentTimeMillis() - start) / 1000.0;
            System.out.println("Error done: " + f1f.format(elapsed) + " seconds");
            System.out.println();
        }
    } catch (Exception | AssertionError e) {
        executor.shutdownNow();
        throw e;
    }
    executor.shutdown();
}