Example usage for org.apache.commons.math.stat.descriptive DescriptiveStatistics addValue

List of usage examples for org.apache.commons.math.stat.descriptive DescriptiveStatistics addValue

Introduction

In this page you can find the example usage for org.apache.commons.math.stat.descriptive DescriptiveStatistics addValue.

Prototype

public void addValue(double v) 

Source Link

Document

Adds the value to the dataset.

Usage

From source file:playground.johannes.socialnetworks.survey.ivt2009.analysis.deprecated.DistanceSocioAttribute.java

@Override
public void analyze(Graph g, Map<String, DescriptiveStatistics> stats) {
    try {/*from   w w w.  j a v a 2s .com*/
        SocialGraph graph = (SocialGraph) g;
        Distance dist = new ObservedDistance();
        AcceptanceProbability acc = new AcceptanceProbability();
        Degree degree = new ObservedDegree();

        Discretizer discretizer = new LinearDiscretizer(1.0);
        /*
         * male
         */
        Set<SocialVertex> vertices = new HashSet<SocialVertex>();
        for (SocialVertex vertex : graph.getVertices()) {
            if ("m".equalsIgnoreCase(vertex.getPerson().getPerson().getSex()))
                vertices.add(vertex);
        }

        DescriptiveStatistics ds = new DescriptiveStatistics();
        ds.addValue(ResponseRate.responseRate((Set) vertices));
        stats.put("alpha_male", ds);

        Distribution distr = dist.distribution(vertices);
        Distribution.writeHistogram(distr.absoluteDistributionLog2(1000), getOutputDirectory() + "/d_male_txt");
        ds = new DescriptiveStatistics();
        ds.addValue(distr.mean());
        stats.put("d_mean_male", ds);

        DescriptiveStatistics dStats = acc.distribution(vertices, choiceSet);
        TDoubleDoubleHashMap hist = Histogram.createHistogram(dStats, new LinearDiscretizer(1000.0), false);
        TXTWriter.writeMap(hist, "d", "p", getOutputDirectory() + "/p_acc_male.txt");
        //         Distribution.writeHistogram(dStats.absoluteDistributionLog2(1000), getOutputDirectory()+"/p_acc_male.txt");

        DescriptiveStatistics kDistr = degree.statistics(vertices);
        stats.put("k_male", kDistr);
        Distribution.writeHistogram(Histogram.createHistogram(kDistr, new LinearDiscretizer(1.0), false),
                getOutputDirectory() + "/k_male.txt");

        System.out.println("Male: " + kDistr.getValues().length);
        /*
         * female
         */
        vertices = new HashSet<SocialVertex>();
        for (SocialVertex vertex : graph.getVertices()) {
            if ("f".equalsIgnoreCase(vertex.getPerson().getPerson().getSex()))
                vertices.add(vertex);
        }

        ds = new DescriptiveStatistics();
        ds.addValue(ResponseRate.responseRate((Set) vertices));
        stats.put("alpha_female", ds);

        distr = dist.distribution(vertices);
        Distribution.writeHistogram(distr.absoluteDistributionLog2(1000),
                getOutputDirectory() + "/d_female_txt");
        ds = new DescriptiveStatistics();
        ds.addValue(distr.mean());
        stats.put("d_femean_male", ds);

        dStats = acc.distribution(vertices, choiceSet);
        hist = Histogram.createHistogram(dStats, new LinearDiscretizer(1000.0), false);
        TXTWriter.writeMap(hist, "d", "p", getOutputDirectory() + "/p_acc_female.txt");
        //         Distribution.writeHistogram(acc.distribution(vertices, choiceSet).absoluteDistributionLog2(1000), getOutputDirectory()+"/p_acc_female.txt");

        kDistr = degree.statistics(vertices);
        stats.put("k_female", kDistr);
        Distribution.writeHistogram(Histogram.createHistogram(kDistr, new LinearDiscretizer(1.0), false),
                getOutputDirectory() + "/k_female.txt");

        System.out.println("Female: " + kDistr.getValues().length);
        /*
         * edu
         */
        //         Education edu = new Education();
        //         edu.socioMatrix(graph);
        //         for(String att : edu.getAttributes()) {
        //            vertices = new HashSet<SocialVertex>();
        //            for (SocialVertex vertex : graph.getVertices()) {
        //               if (att.equalsIgnoreCase(vertex.getPerson().getEducation()))
        //                  vertices.add(vertex);
        //            }
        //
        //            stats.put("alpha_edu"+att, ResponseRate.responseRate((Set) vertices));
        //            
        //            distr = dist.distribution(vertices);
        //            Distribution.writeHistogram(distr.absoluteDistributionLog2(1000), getOutputDirectory() + "/d_edu"+att+".txt");
        //            stats.put("d_mean_edu"+att, distr.mean());
        //         
        //            dStats = acc.distribution(vertices, choiceSet);
        //            hist = Histogram.createHistogram(dStats, new LinearDiscretizer(1000.0), false);
        //            TXTWriter.writeMap(hist, "d", "p", getOutputDirectory()+"/p_acc_edu"+att+".txt");
        ////            Distribution.writeHistogram(acc.distribution(vertices, choiceSet).absoluteDistributionLog2(1000), getOutputDirectory()+"/p_acc_edu"+att+".txt");
        //            
        //            kDistr = degree.distribution(vertices);
        //            stats.put("k_mean_edu"+att, kDistr.getMean());
        //            Distribution.writeHistogram(Histogram.createHistogram(kDistr, new LinearDiscretizer(1.0), false), getOutputDirectory() + "/k_edu"+att+".txt");
        //
        //            System.out.println("Edu"+att+": " + kDistr.getValues().length);
        //         }
        /*
         * income
         */
        Map<Integer, Set<SocialVertex>> incomes = new HashMap<Integer, Set<SocialVertex>>();
        for (SocialVertex vertex : graph.getVertices()) {
            Set<SocialVertex> set = incomes.get(vertex.getPerson().getIncome());
            if (set == null) {
                set = new HashSet<SocialVertex>();
                incomes.put(vertex.getPerson().getIncome(), set);
            }
            set.add(vertex);
        }

        for (Entry<Integer, Set<SocialVertex>> entry : incomes.entrySet()) {
            vertices = entry.getValue();
            distr = dist.distribution(vertices);
            String att = String.valueOf(entry.getKey());

            Distribution.writeHistogram(distr.absoluteDistributionLog2(1000),
                    getOutputDirectory() + "/d_income" + att + ".txt");
            ds = new DescriptiveStatistics();
            ds.addValue(distr.mean());
            stats.put("d_mean_income" + att, ds);

            dStats = acc.distribution(vertices, choiceSet);
            hist = Histogram.createHistogram(dStats, new LinearDiscretizer(1000.0), false);
            TXTWriter.writeMap(hist, "d", "p", getOutputDirectory() + "/p_acc_income" + att + ".txt");
            //            Distribution.writeHistogram(acc.distribution(vertices, choiceSet).absoluteDistributionLog2(1000), getOutputDirectory()+"/p_acc_income"+att+".txt");

            kDistr = degree.statistics(vertices);
            stats.put("k_income" + att, kDistr);
            Distribution.writeHistogram(Histogram.createHistogram(kDistr, discretizer, false),
                    getOutputDirectory() + "/k_income" + att + ".txt");

            System.out.println("Income" + att + ": " + kDistr.getValues().length);
        }
        /*
         * civil status
         */
        Map<String, Set<SocialVertex>> civilstatus = new HashMap<String, Set<SocialVertex>>();
        for (SocialVertex vertex : graph.getVertices()) {
            Set<SocialVertex> set = civilstatus.get(vertex.getPerson().getCiviStatus());
            if (set == null) {
                set = new HashSet<SocialVertex>();
                civilstatus.put(vertex.getPerson().getCiviStatus(), set);
            }
            set.add(vertex);
        }

        for (Entry<String, Set<SocialVertex>> entry : civilstatus.entrySet()) {
            vertices = entry.getValue();
            distr = dist.distribution(vertices);
            String att = entry.getKey();

            Distribution.writeHistogram(distr.absoluteDistributionLog2(1000),
                    getOutputDirectory() + "/d_cstatus" + att + ".txt");
            ds = new DescriptiveStatistics();
            ds.addValue(distr.mean());
            stats.put("d_mean_cstatus" + att, ds);

            dStats = acc.distribution(vertices, choiceSet);
            hist = Histogram.createHistogram(dStats, new LinearDiscretizer(1000.0), false);
            TXTWriter.writeMap(hist, "d", "p", getOutputDirectory() + "/p_acc_cstatus" + att + ".txt");
            //            Distribution.writeHistogram(acc.distribution(vertices, choiceSet).absoluteDistributionLog2(1000), getOutputDirectory()+"/p_acc_cstatus"+att+".txt");

            kDistr = degree.statistics(vertices);
            stats.put("k_cstatus" + att, kDistr);
            Distribution.writeHistogram(Histogram.createHistogram(kDistr, discretizer, false),
                    getOutputDirectory() + "/k_cstatus" + att + ".txt");

            System.out.println("CivStatus" + att + ": " + kDistr.getValues().length);
        }
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

From source file:playground.johannes.socialnetworks.survey.ivt2009.analysis.Frequency.java

public DescriptiveStatistics statistics(Set<SocialEdge> edges) {
    DescriptiveStatistics stats = new DescriptiveStatistics();

    for (SocialEdge edge : edges) {
        stats.addValue(edge.getFrequency());
    }/*from   w  w w  . java2s  . co m*/

    return stats;
}

From source file:playground.johannes.socialnetworks.survey.ivt2009.analysis.SeedConnectionTask.java

@Override
public void analyze(Graph graph, Map<String, DescriptiveStatistics> stats) {
    Set<SampledVertex> seedSet = (Set<SampledVertex>) SnowballPartitions
            .createSampledPartition((Set<? extends SampledVertex>) graph.getVertices(), 0);
    List<SampledVertex> seeds = new ArrayList<SampledVertex>(seedSet);

    AdjacencyMatrix<SampledVertex> y = new AdjacencyMatrix<SampledVertex>(graph);

    int[] seedIndices = new int[seeds.size()];
    for (int i = 0; i < seeds.size(); i++) {
        seedIndices[i] = y.getIndex(seeds.get(i));
    }//from  w  w  w.java 2 s. co m

    int[][] connects = new int[seeds.size()][seeds.size()];
    int[][] directs = new int[seeds.size()][seeds.size()];
    Set<TIntArrayList> paths = new HashSet<TIntArrayList>();

    Dijkstra dijkstra = new Dijkstra(y);

    int[] ids = new int[seeds.size()];

    for (int i = 0; i < seeds.size(); i++) {
        int i_idx = y.getIndex(seeds.get(i));
        ids[i] = i_idx;
        for (int j = i + 1; j < seeds.size(); j++) {
            int j_idx = y.getIndex(seeds.get(j));
            dijkstra.run(i_idx, j_idx);
            TIntArrayList path = dijkstra.getPath(i_idx, j_idx);
            if (path != null) {
                connects[i][j] = path.size();
                connects[j][i] = path.size();

                path.insert(0, i_idx);
                paths.add(path);

                boolean indirect = false;
                for (int k = 1; k < path.size() - 1; k++) {
                    SampledVertex v = y.getVertex(path.get(k));
                    if (v.getSeed() != seeds.get(i) && v.getSeed() != seeds.get(j)) {
                        indirect = true;
                        break;
                    }
                }
                if (!indirect) {
                    directs[i][j] = 1;
                    directs[j][i] = 1;
                }
            } else {
                connects[i][j] = -1;
                connects[j][i] = -1;
            }
        }
    }

    int nPaths = 0;
    int nDirectPaths = 0;
    int total = 0;
    int totalDirect = 0;
    for (int i = 0; i < connects.length; i++) {
        for (int j = i + 1; j < connects.length; j++) {
            if (connects[i][j] > 0) {
                total += connects[i][j];
                nPaths++;

                if (directs[i][j] > 0) {
                    totalDirect += connects[i][j];
                    nDirectPaths++;
                }
            }
        }
    }

    try {
        dumpPaths(paths, y);
    } catch (IOException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }

    DescriptiveStatistics ds = new DescriptiveStatistics();
    ds.addValue(new Double(nPaths));
    stats.put(NUM_CONNECTS, ds);

    ds = new DescriptiveStatistics();
    ds.addValue(nDirectPaths);
    stats.put("n_directPath", ds);

    ds = new DescriptiveStatistics();
    ds.addValue(total / (double) nPaths);
    stats.put("apl", ds);

    ds = new DescriptiveStatistics();
    ds.addValue(totalDirect / (double) nDirectPaths);
    stats.put("apl_d", ds);

    if (getOutputDirectory() != null) {
        try {
            BufferedWriter writer = new BufferedWriter(
                    new FileWriter(String.format("%1$s/seedconnects.txt", getOutputDirectory())));

            for (int i = 0; i < connects.length; i++) {
                writer.write("\t&");
                SampledVertex v = y.getVertex(ids[i]);
                SampledVertexDecorator<SocialVertex> vertex = (SampledVertexDecorator<SocialVertex>) v;
                writer.write(String.valueOf(vertex.getDelegate().getPerson().getId().toString()));
            }
            writer.write("\\\\");
            writer.newLine();
            for (int i = 0; i < connects.length; i++) {
                SampledVertex v = y.getVertex(ids[i]);
                SampledVertexDecorator<SocialVertex> vertex = (SampledVertexDecorator<SocialVertex>) v;
                writer.write(String.valueOf(vertex.getDelegate().getPerson().getId().toString()));
                for (int j = 0; j < connects.length; j++) {
                    writer.write("\t&");
                    if (connects[i][j] < 0)
                        writer.write("-");
                    else {
                        if (directs[i][j] > 0) {
                            writer.write("\\bf{");
                            writer.write(String.valueOf(connects[i][j]));
                            writer.write("}");
                        } else {
                            writer.write(String.valueOf(connects[i][j]));
                        }
                    }

                }
                writer.write("\\\\");
                writer.newLine();
            }
            writer.close();

            TDoubleArrayList xVals = new TDoubleArrayList();
            TDoubleArrayList yVals = new TDoubleArrayList();
            TDoubleArrayList xVals2 = new TDoubleArrayList();
            TDoubleArrayList yVals2 = new TDoubleArrayList();
            for (int i = 0; i < connects.length; i++) {
                SampledVertex v = y.getVertex(ids[i]);
                int k = v.getNeighbours().size();
                int count = 0;
                int length = 0;
                for (int j = 0; j < connects.length; j++) {
                    if (connects[i][j] > 0) {
                        count++;
                        length += connects[i][j];
                    }
                }
                xVals.add(k);
                yVals.add(count);

                if (length > 0) {
                    xVals2.add(k);
                    yVals2.add(length / (double) count);
                }

            }

            TDoubleDoubleHashMap map = Correlations.mean(xVals.toNativeArray(), yVals.toNativeArray());
            TXTWriter.writeMap(map, "k", "connects",
                    String.format("%1$s/connects_k.txt", getOutputDirectory()));

            map = Correlations.mean(xVals2.toNativeArray(), yVals2.toNativeArray());
            TXTWriter.writeMap(map, "k", "closeness",
                    String.format("%1$s/closeness_k.txt", getOutputDirectory()));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

From source file:playground.johannes.socialnetworks.survey.ivt2009.graph.io.GraphBuilder.java

private void loadSociogramData(Collection<VertexRecord> records, SQLDumpReader sqlData) {
    logger.info("Loading sociogram data...");
    Map<String, VertexRecord> map = sqlData.getFullAlterKeyMappping(records);

    TObjectIntHashMap<Vertex> rawDegrees = new TObjectIntHashMap<Vertex>();
    for (Vertex v : proj.getVertices()) {
        rawDegrees.put(v, v.getNeighbours().size());
    }/*from  www .ja va  2 s.  c  om*/

    int edgecnt = 0;
    int doublecnt = 0;
    int egoEdge = 0;

    Set<Vertex> notOkVertices = new HashSet<Vertex>();
    Set<Vertex> okVertices = new HashSet<Vertex>();
    DescriptiveStatistics notOkStats = new DescriptiveStatistics();
    DescriptiveStatistics okStats = new DescriptiveStatistics();

    DescriptiveStatistics numDistr = new DescriptiveStatistics();
    DescriptiveStatistics numDistrNoZero = new DescriptiveStatistics();
    DescriptiveStatistics sizeDistr = new DescriptiveStatistics();

    TDoubleArrayList sizeValues = new TDoubleArrayList();
    TDoubleArrayList kSizeValues = new TDoubleArrayList();
    TDoubleArrayList numValues = new TDoubleArrayList();
    TDoubleArrayList numValues2 = new TDoubleArrayList();
    TDoubleArrayList kNumValues = new TDoubleArrayList();

    for (VertexRecord record : records) {
        if (record.isEgo) {
            List<Set<String>> cliques = sqlData.getCliques(record);
            numDistr.addValue(cliques.size());

            Vertex v = idMap.get(record.id);
            numValues.add(cliques.size());
            kNumValues.add(v.getNeighbours().size());

            if (!cliques.isEmpty())
                numDistrNoZero.addValue(cliques.size());

            for (Set<String> clique : cliques) {
                sizeDistr.addValue(clique.size());
                sizeValues.add(clique.size());
                kSizeValues.add(rawDegrees.get(projMap.get(v)));
                numValues2.add(cliques.size());
                List<SocialSparseVertex> vertices = new ArrayList<SocialSparseVertex>(clique.size());
                for (String alter : clique) {
                    VertexRecord r = map.get(record.egoSQLId + alter);
                    if (r != null) {
                        SocialSparseVertex vertex = idMap.get(r.id);
                        if (vertex != null) {
                            vertices.add(vertex);
                        } else {
                            logger.warn("Vertex not found.");
                        }
                    } else {
                        logger.warn("Record not found.");
                    }
                }

                for (int i = 0; i < vertices.size(); i++) {
                    for (int j = i + 1; j < vertices.size(); j++) {
                        SampledVertexDecorator<SocialSparseVertex> vProj1 = projMap.get(vertices.get(i));
                        SampledVertexDecorator<SocialSparseVertex> vProj2 = projMap.get(vertices.get(j));
                        if (!vProj1.isSampled() && !vProj2.isSampled()) {

                            if (Math.random() < 0.62) {
                                SocialSparseEdge socialEdge = builder.addEdge(graph, vertices.get(i),
                                        vertices.get(j));
                                if (socialEdge != null) {
                                    projBuilder.addEdge(proj, vProj1, vProj2, socialEdge);
                                    edgecnt++;

                                    if (vProj1.isSampled() || vProj2.isSampled()) {
                                        egoEdge++;
                                        if (vProj1.isSampled())
                                            notOkVertices.add(vProj1);
                                        else
                                            notOkVertices.add(vProj2);
                                    }

                                } else {
                                    doublecnt++;
                                    if (vProj1.isSampled())
                                        okVertices.add(vProj1);
                                    else if (vProj2.isSampled())
                                        okVertices.add(vProj2);
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    for (Vertex v : okVertices)
        okStats.addValue(rawDegrees.get(v));

    for (Vertex v : notOkVertices)
        notOkStats.addValue(rawDegrees.get(v));
    try {

        TDoubleDoubleHashMap hist = Histogram.createHistogram(okStats, new LinearDiscretizer(1), false);
        TXTWriter.writeMap(hist, "k", "n",
                "/Users/jillenberger/Work/socialnets/data/ivt2009/11-2011/augmented/k_ok.txt");

        TDoubleDoubleHashMap hist2 = Histogram.createHistogram(notOkStats, new LinearDiscretizer(1), false);
        TXTWriter.writeMap(hist2, "k", "n",
                "/Users/jillenberger/Work/socialnets/data/ivt2009/11-2011/augmented/k_notok.txt");

        TDoubleDoubleHashMap ratio = new TDoubleDoubleHashMap();
        double[] keys = hist.keys();
        for (double k : keys) {
            double val1 = hist2.get(k);
            double val2 = hist.get(k);

            ratio.put(k, val1 / (val2 + val1));
        }
        TXTWriter.writeMap(ratio, "k", "p",
                "/Users/jillenberger/Work/socialnets/data/ivt2009/11-2011/augmented/k_ratio.txt");

        logger.info("Mean num of cliques: " + numDistrNoZero.getMean());
        logger.info("Mean size: " + sizeDistr.getMean());
        logger.info("Median num of cliques: " + StatUtils.percentile(numDistrNoZero.getValues(), 50));
        logger.info("Median size: " + StatUtils.percentile(sizeDistr.getValues(), 50));

        TDoubleDoubleHashMap histNum = Histogram.createHistogram(numDistrNoZero,
                FixedSampleSizeDiscretizer.create(numDistrNoZero.getValues(), 2, 20), true);
        Histogram.normalize(histNum);
        TXTWriter.writeMap(histNum, "num", "freq",
                "/Users/jillenberger/Work/socialnets/data/ivt2009/11-2011/augmented/numCliques.txt");

        TDoubleDoubleHashMap histSize = Histogram.createHistogram(sizeDistr,
                FixedSampleSizeDiscretizer.create(sizeDistr.getValues(), 2, 20), true);
        Histogram.normalize(histSize);
        TXTWriter.writeMap(histSize, "size", "freq",
                "/Users/jillenberger/Work/socialnets/data/ivt2009/11-2011/augmented/numPersons.txt");

        Discretizer discretizer = FixedSampleSizeDiscretizer.create(kSizeValues.toNativeArray(), 20, 20);
        TDoubleArrayList valuesX = new TDoubleArrayList();
        for (int i = 0; i < kSizeValues.size(); i++) {
            valuesX.add(discretizer.discretize(kSizeValues.get(i)));
        }

        Correlations.writeToFile(Correlations.mean(valuesX.toNativeArray(), sizeValues.toNativeArray()),
                "/Users/jillenberger/Work/socialnets/data/ivt2009/11-2011/augmented/size_k.txt", "k", "size");

        discretizer = FixedSampleSizeDiscretizer.create(kNumValues.toNativeArray(), 20, 20);
        valuesX = new TDoubleArrayList();
        for (int i = 0; i < kNumValues.size(); i++) {
            valuesX.add(discretizer.discretize(kNumValues.get(i)));
        }

        Correlations.writeToFile(Correlations.mean(valuesX.toNativeArray(), numValues.toNativeArray()),
                "/Users/jillenberger/Work/socialnets/data/ivt2009/11-2011/augmented/num_k.txt", "k", "n");

        Correlations.writeToFile(Correlations.mean(numValues2.toNativeArray(), sizeValues.toNativeArray()),
                "/Users/jillenberger/Work/socialnets/data/ivt2009/11-2011/augmented/size_num.txt", "num",
                "size");
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    logger.info(String.format("Inserted %1$s edges, %2$s edges already present.", edgecnt, doublecnt));
    logger.info(String.format("Inserted %1$s edges between at least one ego.", egoEdge));
}

From source file:playground.johannes.statistics.GraphStatistics.java

public static DescriptiveStatistics getDegreeStatistics(Graph g) {
    DescriptiveStatistics stats = new DescriptiveStatistics();
    Set<Vertex> vertices = g.getVertices();
    for (Vertex v : vertices) {
        stats.addValue(v.degree());
    }/* w w w  . j a  va2 s  .  co  m*/
    return stats;
}

From source file:playground.johannes.statistics.GraphStatistics.java

public static DescriptiveStatistics getClusteringStatistics(Graph g) {
    DescriptiveStatistics stats = new DescriptiveStatistics();
    Map<Vertex, Double> values = edu.uci.ics.jung.statistics.GraphStatistics.clusteringCoefficients(g);
    for (Vertex v : values.keySet()) {
        if (v.degree() == 1)
            stats.addValue(0.0);
        else/*from   w  w w  . ja  va2 s  . c  o  m*/
            stats.addValue(values.get(v));
    }

    return stats;
}

From source file:playground.johannes.statistics.SampledGraphStatistics.java

public static DescriptiveStatistics getDegreeStatistics(SampledGraph g) {
    DescriptiveStatistics stats = new DescriptiveStatistics();
    Set<SampledVertex> vertices = g.getVertices();
    for (SampledVertex v : vertices) {
        if (!v.isAnonymous())
            stats.addValue(v.degree());
    }/*from   ww w .  j av  a2  s  . co m*/
    return stats;
}

From source file:playground.johannes.statistics.SampledGraphStatistics.java

public static DescriptiveStatistics getClusteringStatistics(SampledGraph g) {
    DescriptiveStatistics stats = new DescriptiveStatistics();
    Map<SampledVertex, Double> values = GraphStatistics.clusteringCoefficients(g);
    for (SampledVertex v : values.keySet()) {
        if (!v.isAnonymous()) {
            if (v.degree() == 1)
                stats.addValue(0.0);
            else/*from w  w w .  j a va 2 s .c o m*/
                stats.addValue(values.get(v));
        }
    }

    return stats;
}

From source file:playground.johannes.studies.coopsim.SweepMerge1D.java

/**
 * @param args/*w w w  .  j av  a 2s  .  c o m*/
 * @throws IOException
 */
public static void main(String[] args) throws IOException {
    File root = new File("/Volumes/cluster.math.tu-berlin.de/net/ils2/jillenberger/leisure/runs/run272/");
    //      String property = "score_join_culture";
    String property = "d_trip_culture";
    int valIdx = 1;
    //      String parameterKey = "beta_join";
    //      String parameterKey = "performing";
    String parameterKey = "alterProba_culture";

    int dumps = 1;

    File analysis = new File(String.format("%1$s/analysis/", root.getAbsolutePath()));
    analysis.mkdirs();

    TDoubleDoubleHashMap values = new TDoubleDoubleHashMap();

    File tasks = new File(String.format("%1$s/tasks/", root.getAbsolutePath()));
    for (File file : tasks.listFiles()) {
        if (file.isDirectory()) {
            if (!file.getName().equals("analysis")) {
                File output = new File(String.format("%1$s/output/", file.getAbsolutePath()));
                String[] dirs = output.list();
                if (dirs.length > 0) {

                    Arrays.sort(dirs, new Comparator<String>() {
                        @Override
                        public int compare(String o1, String o2) {
                            return Double.compare(Double.parseDouble(o1), Double.parseDouble(o2));
                        }
                    });
                    /*
                     * get parameter value
                     */
                    Config config = new Config();
                    ConfigReader creader = new ConfigReader(config);
                    creader.readFile(String.format("%1$s/config.xml", file.getAbsolutePath()));
                    double paramValue = Double.parseDouble(config.findParam("socialnets", parameterKey));
                    //               double paramValue = Double.parseDouble(config.findParam("planCalcScore", parameterKey));

                    int start = dirs.length - dumps;
                    start = Math.max(0, start);
                    if (dirs.length < dumps) {
                        logger.warn(String.format("Less than %1$s samples.", dumps));
                    }
                    DescriptiveStatistics stat = new DescriptiveStatistics();
                    for (int i = start; i < dirs.length; i++) {
                        //               for(int i = 12; i < 13; i++) {
                        File statsFile = new File(
                                String.format("%1$s/%2$s/statistics.txt", output.getAbsolutePath(), dirs[i]));
                        if (statsFile.exists()) {
                            /*
                             * get property value
                             */
                            BufferedReader reader = new BufferedReader(new FileReader(statsFile));
                            String line = reader.readLine();

                            while ((line = reader.readLine()) != null) {
                                String[] tokens = line.split("\t");
                                String key = tokens[0];
                                double val = Double.parseDouble(tokens[valIdx]);

                                if (key.equals(property)) {
                                    stat.addValue(val);
                                    break;
                                }
                            }
                        }

                    }
                    values.put(paramValue, stat.getMean());
                } else {
                    logger.warn("No samples.");
                }
            }
        }
    }

    TXTWriter.writeMap(values, parameterKey, property,
            String.format("%1$s/%2$s.txt", analysis.getAbsolutePath(), property));
}

From source file:playground.johannes.studies.coopsim.SweepMerge2D.java

/**
 * @param args//from w  w  w. ja  v a  2  s.com
 * @throws IOException
 */
public static void main(String[] args) throws IOException {
    File root = new File("/Volumes/cluster.math.tu-berlin.de/net/ils2/jillenberger/leisure/runs/run205/");
    String property = "d_trip_home";
    int valIdx = 1;
    String parameterKey1 = "traveling";
    String parameterKey2 = "performing";

    File analysis = new File(String.format("%1$s/analysis/", root.getAbsolutePath()));
    analysis.mkdirs();

    KeyMatrix<Double> matrix = new KeyMatrix<Double>();

    File tasks = new File(String.format("%1$s/tasks/", root.getAbsolutePath()));
    for (File file : tasks.listFiles()) {
        if (file.isDirectory()) {
            if (!file.getName().equals("analysis")) {
                File output = new File(String.format("%1$s/output/", file.getAbsolutePath()));
                String[] dirs = output.list();
                if (dirs.length > 0) {

                    Arrays.sort(dirs, new Comparator<String>() {
                        @Override
                        public int compare(String o1, String o2) {
                            return Double.compare(Double.parseDouble(o1), Double.parseDouble(o2));
                        }
                    });
                    /*
                     * get parameter value
                     */
                    Config config = new Config();
                    ConfigReader creader = new ConfigReader(config);
                    creader.readFile(String.format("%1$s/config.xml", file.getAbsolutePath()));
                    double paramValue1 = Double.parseDouble(config.findParam("planCalcScore", parameterKey1));
                    double paramValue2 = Double.parseDouble(config.findParam("planCalcScore", parameterKey2));

                    int start = dirs.length - 10;
                    start = Math.max(0, start);
                    if (dirs.length < 10) {
                        logger.warn("Less than 10 samples.");
                    }
                    DescriptiveStatistics stat = new DescriptiveStatistics();
                    for (int i = start; i < dirs.length; i++) {
                        File statsFile = new File(
                                String.format("%1$s/%2$s/statistics.txt", output.getAbsolutePath(), dirs[i]));
                        if (statsFile.exists()) {
                            /*
                             * get property value
                             */
                            BufferedReader reader = new BufferedReader(new FileReader(statsFile));
                            String line = reader.readLine();

                            while ((line = reader.readLine()) != null) {
                                String[] tokens = line.split("\t");
                                String key = tokens[0];
                                double val = Double.parseDouble(tokens[valIdx]);

                                if (key.equals(property)) {
                                    stat.addValue(val);
                                    break;
                                }
                            }
                        }

                    }
                    matrix.putValue(stat.getMean(), Math.abs(paramValue1), Math.abs(paramValue2));
                } else {
                    logger.warn("No samples.");
                }
            }
        }
    }

    matrix.write(String.format("%1$s/%2$s.matrix.txt", analysis.getAbsolutePath(), property));
}