Examples with DoubleArrayList cern.colt.list.DoubleArrayList used on opensource projects

Example 66 with DoubleArrayList

use of cern.colt.list.DoubleArrayList in project tetrad by cmu-phil.

the class TestMeasurementSimulator method testPixelError.

/**
 * Turn on pixel digitalization error, turn off all other sources of error,
 * simulate 1 dish of data with 1000 samples per dish and look to see
 * whether in the aggregated data the standard deviations for Gene2:t1,
 * Gene3:t1 and Gene1:t2 are 0.3.
 */
public void testPixelError() {
    setDefaultParameters();
    // The following parameters are set to non-default values for
    // this test.
    this.simulator.setDishDishVariability(0.0001);
    this.simulator.setNumSamplesPerDish(1000);
    this.simulator.setSampleSampleVariability(0.0001);
    this.simulator.setChipChipVariability(0.0001);
    this.simulator.setPixelDigitalization(0.3);
    this.simulator.setStepsGenerated(2);
    this.simulator.setNumCellsPerDish(100);
    // Simulate the data.
    this.simulator.simulate(this.history);
    double[][][] measuredData = this.simulator.getMeasuredData();
    // Do the test.
    DoubleArrayList doubleArrayList = new DoubleArrayList(measuredData[1][0]);
    double sum = Descriptive.sum(doubleArrayList);
    double sumOfSquares = Descriptive.sumOfSquares(doubleArrayList);
    double gene2time1sd = Descriptive.standardDeviation(Descriptive.variance(measuredData[1][0].length, sum, sumOfSquares));
    DoubleArrayList doubleArrayList1 = new DoubleArrayList(measuredData[2][0]);
    double sum1 = Descriptive.sum(doubleArrayList1);
    double sumOfSquares1 = Descriptive.sumOfSquares(doubleArrayList1);
    double gene3time1sd = Descriptive.standardDeviation(Descriptive.variance(measuredData[2][0].length, sum1, sumOfSquares1));
    DoubleArrayList doubleArrayList2 = new DoubleArrayList(measuredData[1][1]);
    double sum2 = Descriptive.sum(doubleArrayList2);
    double sumOfSquares2 = Descriptive.sumOfSquares(doubleArrayList2);
    double gene1time2sd = Descriptive.standardDeviation(Descriptive.variance(measuredData[1][1].length, sum2, sumOfSquares2));
    assertEquals(0.3, gene2time1sd, 0.1);
    assertEquals(0.3, gene3time1sd, 0.1);
    assertEquals(0.3, gene1time2sd, 0.1);
}

Example 67 with DoubleArrayList

use of cern.colt.list.DoubleArrayList in project tetrad by cmu-phil.

the class LingamPattern method getScore.

// =============================PRIVATE METHODS=========================//
private Score getScore(Graph dag, TetradMatrix data, List<Node> variables) {
    // System.out.println("Scoring DAG: " + dag);
    Regression regression = new RegressionDataset(data, variables);
    List<Node> nodes = dag.getNodes();
    double score = 0.0;
    double[] pValues = new double[nodes.size()];
    TetradMatrix residuals = new TetradMatrix(data.rows(), data.columns());
    for (int i = 0; i < nodes.size(); i++) {
        Node _target = nodes.get(i);
        List<Node> _regressors = dag.getParents(_target);
        Node target = getVariable(variables, _target.getName());
        List<Node> regressors = new ArrayList<>();
        for (Node _regressor : _regressors) {
            Node variable = getVariable(variables, _regressor.getName());
            regressors.add(variable);
        }
        RegressionResult result = regression.regress(target, regressors);
        TetradVector residualsColumn = result.getResiduals();
        // residuals.viewColumn(i).assign(residualsColumn);
        residuals.assignColumn(i, residualsColumn);
        DoubleArrayList residualsArray = new DoubleArrayList(residualsColumn.toArray());
        double mean = Descriptive.mean(residualsArray);
        double std = Descriptive.standardDeviation(Descriptive.variance(residualsArray.size(), Descriptive.sum(residualsArray), Descriptive.sumOfSquares(residualsArray)));
        for (int i2 = 0; i2 < residualsArray.size(); i2++) {
            residualsArray.set(i2, (residualsArray.get(i2) - mean) / std);
            residualsArray.set(i2, Math.abs(residualsArray.get(i2)));
        }
        double _mean = Descriptive.mean(residualsArray);
        double diff = _mean - Math.sqrt(2.0 / Math.PI);
        score += diff * diff;
    }
    for (int j = 0; j < residuals.columns(); j++) {
        double[] x = residuals.getColumn(j).toArray();
        double p = new AndersonDarlingTest(x).getP();
        pValues[j] = p;
    }
    return new Score(score, pValues);
}

Example 68 with DoubleArrayList

use of cern.colt.list.DoubleArrayList in project tetrad by cmu-phil.

the class Lofs method andersonDarlingPASquareStarB.

private double andersonDarlingPASquareStarB(Node node, List<Node> parents) {
    List<Double> _residuals = new ArrayList<>();
    Node _target = node;
    List<Node> _regressors = parents;
    Node target = getVariable(variables, _target.getName());
    List<Node> regressors = new ArrayList<>();
    for (Node _regressor : _regressors) {
        Node variable = getVariable(variables, _regressor.getName());
        regressors.add(variable);
    }
    double sum = 0.0;
    DATASET: for (int m = 0; m < dataSets.size(); m++) {
        RegressionResult result = regressions.get(m).regress(target, regressors);
        TetradVector residualsSingleDataset = result.getResiduals();
        for (int h = 0; h < residualsSingleDataset.size(); h++) {
            if (Double.isNaN(residualsSingleDataset.get(h))) {
                continue DATASET;
            }
        }
        DoubleArrayList _residualsSingleDataset = new DoubleArrayList(residualsSingleDataset.toArray());
        double mean = Descriptive.mean(_residualsSingleDataset);
        double std = Descriptive.standardDeviation(Descriptive.variance(_residualsSingleDataset.size(), Descriptive.sum(_residualsSingleDataset), Descriptive.sumOfSquares(_residualsSingleDataset)));
        // of the individual columns. http://en.wikipedia.org/wiki/Mixture_distribution#Finite_and_countable_mixtures
        for (int i2 = 0; i2 < _residualsSingleDataset.size(); i2++) {
            // _residualsSingleDataset.set(i2, (_residualsSingleDataset.get(i2)) / std);
            if (isMeanCenterResiduals()) {
                _residualsSingleDataset.set(i2, (_residualsSingleDataset.get(i2) - mean));
            }
        }
        double[] _f = new double[_residuals.size()];
        for (int k = 0; k < _residuals.size(); k++) {
            _f[k] = _residuals.get(k);
        }
        sum += new AndersonDarlingTest(_f).getASquaredStar();
    }
    return sum / dataSets.size();
}

Example 69 with DoubleArrayList

use of cern.colt.list.DoubleArrayList in project tetrad by cmu-phil.

the class Lofs method residual.

private double[] residual(Node node, List<Node> parents) {
    List<Double> _residuals = new ArrayList<>();
    Node _target = node;
    List<Node> _regressors = parents;
    Node target = getVariable(variables, _target.getName());
    List<Node> regressors = new ArrayList<>();
    for (Node _regressor : _regressors) {
        Node variable = getVariable(variables, _regressor.getName());
        regressors.add(variable);
    }
    DATASET: for (int m = 0; m < dataSets.size(); m++) {
        RegressionResult result = regressions.get(m).regress(target, regressors);
        TetradVector residualsSingleDataset = result.getResiduals();
        for (int h = 0; h < residualsSingleDataset.size(); h++) {
            if (Double.isNaN(residualsSingleDataset.get(h))) {
                continue DATASET;
            }
        }
        DoubleArrayList _residualsSingleDataset = new DoubleArrayList(residualsSingleDataset.toArray());
        double mean = Descriptive.mean(_residualsSingleDataset);
        for (int i2 = 0; i2 < _residualsSingleDataset.size(); i2++) {
            // _residualsSingleDataset.set(i2, (_residualsSingleDataset.get(i2) - mean) / std);
            _residualsSingleDataset.set(i2, (_residualsSingleDataset.get(i2) - mean));
        // _residualsSingleDataset.set(i2, (_residualsSingleDataset.get(i2)));
        }
        for (int k = 0; k < _residualsSingleDataset.size(); k++) {
            _residuals.add(_residualsSingleDataset.get(k));
        }
    }
    double[] _f = new double[_residuals.size()];
    for (int k = 0; k < _residuals.size(); k++) {
        _f[k] = _residuals.get(k);
    }
    return _f;
}

Example 70 with DoubleArrayList

use of cern.colt.list.DoubleArrayList in project tetrad by cmu-phil.

the class Lofs method localScoreB.

private double localScoreB(Node node, List<Node> parents) {
    double score = 0.0;
    double maxScore = Double.NEGATIVE_INFINITY;
    Node _target = node;
    List<Node> _regressors = parents;
    Node target = getVariable(variables, _target.getName());
    List<Node> regressors = new ArrayList<>();
    for (Node _regressor : _regressors) {
        Node variable = getVariable(variables, _regressor.getName());
        regressors.add(variable);
    }
    DATASET: for (int m = 0; m < dataSets.size(); m++) {
        RegressionResult result = regressions.get(m).regress(target, regressors);
        TetradVector residualsSingleDataset = result.getResiduals();
        DoubleArrayList _residualsSingleDataset = new DoubleArrayList(residualsSingleDataset.toArray());
        for (int h = 0; h < residualsSingleDataset.size(); h++) {
            if (Double.isNaN(residualsSingleDataset.get(h))) {
                continue DATASET;
            }
        }
        double mean = Descriptive.mean(_residualsSingleDataset);
        double std = Descriptive.standardDeviation(Descriptive.variance(_residualsSingleDataset.size(), Descriptive.sum(_residualsSingleDataset), Descriptive.sumOfSquares(_residualsSingleDataset)));
        for (int i2 = 0; i2 < _residualsSingleDataset.size(); i2++) {
            _residualsSingleDataset.set(i2, (_residualsSingleDataset.get(i2) - mean) / std);
        }
        double[] _f = new double[_residualsSingleDataset.size()];
        for (int k = 0; k < _residualsSingleDataset.size(); k++) {
            _f[k] = _residualsSingleDataset.get(k);
        }
        DoubleArrayList f = new DoubleArrayList(_f);
        for (int k = 0; k < f.size(); k++) {
            f.set(k, Math.abs(f.get(k)));
        }
        double _mean = Descriptive.mean(f);
        double diff = _mean - Math.sqrt(2.0 / Math.PI);
        score += diff * diff;
        if (score > maxScore) {
            maxScore = score;
        }
    }
    double avg = score / dataSets.size();
    return avg;
}