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

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

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.math.stat.descriptive.*
  5. DescriptiveStatistics
  6. DescriptiveStatistics

Introduction

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

Prototype

public DescriptiveStatistics()

Source Link

Document

Construct a DescriptiveStatistics instance with an infinite window

Usage

From source file:playground.johannes.socialnetworks.snowball2.sim.postprocess.ConfidenceInterval.java

/**
 * @param args/*from ww w.j a v  a2 s  .c  om*/
 * @throws IOException 
 */
public static void main(String[] args) throws IOException {
    String rootDir = args[0];

    int dumpStart = Integer.parseInt(args[1]);
    int dumpEnd = Integer.parseInt(args[2]);
    ;
    int dumpStep = Integer.parseInt(args[3]);

    String constParamKey = args[4];
    int constParam = Integer.parseInt(args[5]);
    String property = args[6];
    String dumpProperty = args[7];
    String output = args[8];

    final double mean = Double.parseDouble(args[9]);
    double confProba = Double.parseDouble(args[10]);
    String mode = args[11];

    TIntObjectHashMap<TIntDoubleHashMap> table = new TIntObjectHashMap<TIntDoubleHashMap>();
    SortedSet<Integer> dumpKeys = new TreeSet<Integer>();

    for (int dumpKey = dumpStart; dumpKey <= dumpEnd; dumpKey += dumpStep) {
        TIntDoubleHashMap row = new TIntDoubleHashMap();

        BufferedReader valueReader;
        BufferedReader dumpReader;
        if (constParamKey.equalsIgnoreCase("alpha")) {
            String path = String.format("%1$s/seed.%2$s/alpha.%3$s/%4$s.txt", rootDir, dumpKey, constParam,
                    property);
            valueReader = new BufferedReader(new FileReader(path));
            System.out.println("Loading file " + path);

            path = String.format("%1$s/seed.%2$s/alpha.%3$s/%4$s.avr.txt", rootDir, dumpKey, constParam,
                    dumpProperty);
            dumpReader = new BufferedReader(new FileReader(path));
            System.out.println("Loading file " + path);
        } else if (constParamKey.equalsIgnoreCase("seed")) {
            String path = String.format("%1$s/seed.%2$s/alpha.%3$s/%4$s.txt", rootDir, constParam, dumpKey,
                    property);
            valueReader = new BufferedReader(new FileReader(path));
            System.out.println("Loading file " + path);

            path = String.format("%1$s/seed.%2$s/alpha.%3$s/%4$s.avr.txt", rootDir, constParam, dumpKey,
                    dumpProperty);
            dumpReader = new BufferedReader(new FileReader(path));
            System.out.println("Loading file " + path);
        } else
            throw new IllegalArgumentException(
                    String.format("Constant parameter %1$s unknown.", constParamKey));

        String header = valueReader.readLine();
        String keys[] = header.split("\t");
        int cols = keys.length;
        String valueLine;
        Map<String, TDoubleArrayList> matrix = new HashMap<String, TDoubleArrayList>();
        while ((valueLine = valueReader.readLine()) != null) {
            String[] tokens = valueLine.split("\t");
            for (int i = 0; i < cols; i++) {
                TDoubleArrayList list = matrix.get(keys[i]);
                if (list == null) {
                    list = new TDoubleArrayList();
                    matrix.put(keys[i], list);
                }

                list.add(Double.parseDouble(tokens[i]));
            }
        }

        String dumpLine;
        Map<String, String> dumpMapping = new HashMap<String, String>();
        while ((dumpLine = dumpReader.readLine()) != null) {
            String[] tokens = dumpLine.split("\t");
            dumpMapping.put(tokens[0], tokens[1]);
        }

        for (Entry<String, TDoubleArrayList> entry : matrix.entrySet()) {
            DescriptiveStatistics stats = new DescriptiveStatistics();

            double vals[] = entry.getValue().toNativeArray();
            for (double val : vals) {
                if (!Double.isNaN(val)) {
                    double relerr;
                    if (mode.equals("abs")) {
                        relerr = Math.abs((val - mean) / mean);
                    } else {
                        relerr = (val - mean) / mean;
                    }
                    stats.addValue(relerr);

                }
            }
            if (stats.getN() < 50) {
                System.err.println("Less than 50 samples. Ignoring dump.");
            } else {
                double conf;
                if (mode.equals("abs"))
                    conf = stats.getPercentile(confProba);
                else if (mode.equals("pos")) {
                    confProba = (100 - confProba) / 2.0;
                    conf = stats.getPercentile(100 - confProba);
                } else if (mode.equals("neg")) {
                    confProba = (100 - confProba) / 2.0;
                    conf = stats.getPercentile(confProba);
                } else {
                    throw new IllegalArgumentException(String.format("Mode %1$s unknown.", mode));
                }
                // int key = Integer.parseInt(keys[i]);
                String keyStr = entry.getKey();
                if (!dumpMapping.get(keyStr).equals("null")) {
                    int key = (int) Double.parseDouble(dumpMapping.get(keyStr));
                    row.put(key, conf);
                    dumpKeys.add(key);
                } else {
                    System.err.println("Null key");
                }
            }
        }
        table.put(dumpKey, row);
    }

    write(table, output, dumpKeys);
}

From source file:playground.johannes.socialnetworks.snowball2.sim.postprocess.PercentileTest.java

/**
 * @param args/*from   ww w .  ja  va 2s.  co  m*/
 */
public static void main(String[] args) {
    DescriptiveStatistics stats = new DescriptiveStatistics();

    for (int i = 0; i < 20; i++) {
        stats.addValue(i);
    }

    System.out.println(stats.getPercentile(10));

}

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

@Override
public void analyze(Graph g, Map<String, DescriptiveStatistics> stats) {
    try {//  ww  w .j  av  a  2 s.c o m
        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());
    }/*  w w w  .j  a  v a 2  s.  com*/

    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));
    }/* w  ww. j  ava  2  s  .  c o  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 w ww  . ja  va 2s  .c o m*/

    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());//from   ww  w . jav a 2 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);//from  ww w  . j  a va 2  s .c om
        else
            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());//w w w.j  a v  a2 s  .  c o  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);//ww w .  ja  v a 2s .c  o m
            else
                stats.addValue(values.get(v));
        }
    }

    return stats;
}