Example usage for org.apache.commons.math.stat.regression SimpleRegression getIntercept

List of usage examples for org.apache.commons.math.stat.regression SimpleRegression getIntercept

Introduction

In this page you can find the example usage for org.apache.commons.math.stat.regression SimpleRegression getIntercept.

Prototype

public double getIntercept() 

Source Link

Document

Returns the intercept of the estimated regression line.

Usage

From source file:com.discursive.jccook.math.SimpleRegressionExample.java

public static void main(String[] args) throws MathException {

    SimpleRegression sr = new SimpleRegression();

    // Add data points       
    sr.addData(0, 0);/* ww  w . j a va 2  s . c  o  m*/
    sr.addData(1, 1.2);
    sr.addData(2, 2.6);
    sr.addData(3, 3.2);
    sr.addData(4, 4);
    sr.addData(5, 5);

    NumberFormat format = NumberFormat.getInstance();

    // Print the value of y when line intersects the y axis
    System.out.println("Intercept: " + format.format(sr.getIntercept()));

    // Print the number of data points
    System.out.println("N: " + sr.getN());

    // Print the Slope and the Slop Confidence
    System.out.println("Slope: " + format.format(sr.getSlope()));
    System.out.println("Slope Confidence: " + format.format(sr.getSlopeConfidenceInterval()));

    // Print RSquare a measure of relatedness
    System.out.println("RSquare: " + format.format(sr.getRSquare()));

    sr.addData(400, 100);
    sr.addData(300, 105);
    sr.addData(350, 70);
    sr.addData(200, 50);
    sr.addData(150, 300);
    sr.addData(50, 500);

    System.out.println("Intercept: " + format.format(sr.getIntercept()));
    System.out.println("N: " + sr.getN());
    System.out.println("Slope: " + format.format(sr.getSlope()));
    System.out.println("Slope Confidence: " + format.format(sr.getSlopeConfidenceInterval()));
    System.out.println("RSquare: " + format.format(sr.getRSquare()));

}

From source file:graticules2wld.Main.java

/**
 * @param args//from  w w w  .  ja va  2s.  c  om
 * @throws Exception
 */
public static void main(String[] args) throws Exception {

    /* parse the command line arguments */
    // create the command line parser
    CommandLineParser parser = new PosixParser();

    // create the Options
    Options options = new Options();
    options.addOption("x", "originx", true, "x component of projected coordinates of upper left pixel");
    options.addOption("y", "originy", true, "y component of projected coordinates of upper left pixel");
    options.addOption("u", "tometers", true, "multiplication factor to get source units into meters");
    options.addOption("h", "help", false, "prints this usage page");
    options.addOption("d", "debug", false, "prints debugging information to stdout");

    double originNorthing = 0;
    double originEasting = 0;

    String inputFileName = null;
    String outputFileName = null;

    try {
        // parse the command line arguments
        CommandLine line = parser.parse(options, args);

        if (line.hasOption("help"))
            printUsage(0); // print usage then exit using a non error exit status

        if (line.hasOption("debug"))
            debug = true;

        // these arguments are required
        if (!line.hasOption("originy") || !line.hasOption("originx"))
            printUsage(1);

        originNorthing = Double.parseDouble(line.getOptionValue("originy"));
        originEasting = Double.parseDouble(line.getOptionValue("originx"));

        if (line.hasOption("tometers"))
            unitsToMeters = Double.parseDouble(line.getOptionValue("tometers"));

        // two args should be left. the input csv file name and the output wld file name.
        String[] iofiles = line.getArgs();
        if (iofiles.length < 2) {
            printUsage(1);
        }

        inputFileName = iofiles[0];
        outputFileName = iofiles[1];
    } catch (ParseException exp) {
        System.err.println("Unexpected exception:" + exp.getMessage());
        System.exit(1);
    }

    // try to open the input file for reading and the output file for writing
    File graticulesCsvFile;
    BufferedReader csvReader = null;

    File wldFile;
    BufferedWriter wldWriter = null;

    try {
        graticulesCsvFile = new File(inputFileName);
        csvReader = new BufferedReader(new FileReader(graticulesCsvFile));
    } catch (IOException exp) {
        System.err.println("Could not open input file for reading: " + inputFileName);
        System.exit(1);
    }

    try {
        wldFile = new File(outputFileName);
        wldWriter = new BufferedWriter(new FileWriter(wldFile));
    } catch (IOException exp) {
        System.err.println("Could not open output file for writing: " + outputFileName);
        System.exit(1);
    }

    // list of lon graticules and lat graticules
    ArrayList<Graticule> lonGrats = new ArrayList<Graticule>();
    ArrayList<Graticule> latGrats = new ArrayList<Graticule>();

    // read the source CSV and convert its information into the two ArrayList<Graticule> data structures
    readCSV(csvReader, lonGrats, latGrats);

    // we now need to start finding the world file paramaters
    DescriptiveStatistics stats = new DescriptiveStatistics();

    // find theta and phi
    for (Graticule g : latGrats) {
        stats.addValue(g.angle());
    }

    double theta = stats.getMean(); // we use the mean of the lat angles as theta
    if (debug)
        System.out.println("theta range = " + Math.toDegrees(stats.getMax() - stats.getMin()));
    stats.clear();

    for (Graticule g : lonGrats) {
        stats.addValue(g.angle());
    }

    double phi = stats.getMean(); // ... and the mean of the lon angles for phi
    if (debug)
        System.out.println("phi range = " + Math.toDegrees(stats.getMax() - stats.getMin()));
    stats.clear();

    // print these if in debug mode
    if (debug) {
        System.out.println("theta = " + Math.toDegrees(theta) + "deg");
        System.out.println("phi = " + Math.toDegrees(phi) + "deg");
    }

    // find x and y (distance beteen pixels in map units)
    Collections.sort(latGrats);
    Collections.sort(lonGrats);
    int prevMapValue = 0; //fixme: how to stop warning about not being initilised?
    Line2D prevGratPixelSys = new Line2D.Double();

    boolean first = true;
    for (Graticule g : latGrats) {
        if (!first) {
            int deltaMapValue = Math.abs(g.realValue() - prevMapValue);
            double deltaPixelValue = (g.l.ptLineDist(prevGratPixelSys.getP1())
                    + (g.l.ptLineDist(prevGratPixelSys.getP2()))) / 2;

            double delta = deltaMapValue / deltaPixelValue;
            stats.addValue(delta);
        } else {
            first = false;
            prevMapValue = g.realValue();
            prevGratPixelSys = (Line2D) g.l.clone();
        }
    }

    double y = stats.getMean();
    if (debug)
        System.out.println("y range = " + (stats.getMax() - stats.getMin()));
    stats.clear();

    first = true;
    for (Graticule g : lonGrats) {
        if (!first) {
            int deltaMapValue = g.realValue() - prevMapValue;
            double deltaPixelValue = (g.l.ptLineDist(prevGratPixelSys.getP1())
                    + (g.l.ptLineDist(prevGratPixelSys.getP2()))) / 2;

            double delta = deltaMapValue / deltaPixelValue;
            stats.addValue(delta);
        } else {
            first = false;
            prevMapValue = g.realValue();
            prevGratPixelSys = (Line2D) g.l.clone();
        }
    }

    double x = stats.getMean();
    if (debug)
        System.out.println("x range = " + (stats.getMax() - stats.getMin()));
    stats.clear();

    if (debug) {
        System.out.println("x = " + x);
        System.out.println("y = " + y);
    }

    SimpleRegression regression = new SimpleRegression();

    // C, F are translation terms: x, y map coordinates of the center of the upper-left pixel
    for (Graticule g : latGrats) {
        // find perp dist to pixel space 0,0
        Double perpPixelDist = g.l.ptLineDist(new Point2D.Double(0, 0));

        // find the map space distance from this graticule to the center of the 0,0 pixel
        Double perpMapDist = perpPixelDist * y; // perpMapDist / perpPixelDist = y

        regression.addData(perpMapDist, g.realValue());
    }

    double F = regression.getIntercept();
    regression.clear();

    for (Graticule g : lonGrats) {
        // find perp dist to pixel space 0,0
        Double perpPixelDist = g.l.ptLineDist(new Point2D.Double(0, 0));

        // find the map space distance from this graticule to the center of the 0,0 pixel
        Double perpMapDist = perpPixelDist * x; // perpMapDist / perpPixelDist = x

        regression.addData(perpMapDist, g.realValue());
    }

    double C = regression.getIntercept();
    regression.clear();

    if (debug) {
        System.out.println("Upper Left pixel has coordinates " + C + ", " + F);
    }

    // convert to meters
    C *= unitsToMeters;
    F *= unitsToMeters;

    // C,F store the projected (in map units) coordinates of the upper left pixel.
    // originNorthing,originEasting is the offset we need to apply to 0,0 to push the offsets into our global coordinate system 
    C = originEasting + C;
    F = originNorthing + F;

    // calculate the affine transformation matrix elements
    double D = -1 * x * unitsToMeters * Math.sin(theta);
    double A = x * unitsToMeters * Math.cos(theta);
    double B = y * unitsToMeters * Math.sin(phi); // if should be negative, it'll formed by negative sin
    double E = -1 * y * unitsToMeters * Math.cos(phi);

    /*
     * Line 1: A: pixel size in the x-direction in map units/pixel
     * Line 2: D: rotation about y-axis
     * Line 3: B: rotation about x-axis
     * Line 4: E: pixel size in the y-direction in map units, almost always negative[3]
     * Line 5: C: x-coordinate of the center of the upper left pixel
     * Line 6: F: y-coordinate of the center of the upper left pixel
     */
    if (debug) {
        System.out.println("A = " + A);
        System.out.println("D = " + D);
        System.out.println("B = " + B);
        System.out.println("E = " + E);
        System.out.println("C = " + C);
        System.out.println("F = " + F);

        // write the world file
        System.out.println();
        System.out.println("World File:");
        System.out.println(A);
        System.out.println(D);
        System.out.println(B);
        System.out.println(E);
        System.out.println(C);
        System.out.println(F);
    }

    // write to the .wld file
    wldWriter.write(A + "\n");
    wldWriter.write(D + "\n");
    wldWriter.write(B + "\n");
    wldWriter.write(E + "\n");
    wldWriter.write(C + "\n");
    wldWriter.write(F + "\n");

    wldWriter.close();
}

From source file:com.griddynamics.jagger.engine.e1.scenario.DefaultWorkloadSuggestionMaker.java

private static Integer findClosestPoint(BigDecimal desiredTps, Map<Integer, Pair<Long, BigDecimal>> stats) {
    final int MAX_POINTS_FOR_REGRESSION = 10;

    SortedMap<Long, Integer> map = Maps.newTreeMap(new Comparator<Long>() {
        @Override//from ww  w .  j  ava 2s.co m
        public int compare(Long first, Long second) {
            return second.compareTo(first);
        }
    });
    for (Map.Entry<Integer, Pair<Long, BigDecimal>> entry : stats.entrySet()) {
        map.put(entry.getValue().getFirst(), entry.getKey());
    }

    if (map.size() < 2) {
        throw new IllegalArgumentException("Not enough stats to calculate point");
    }

    // <time><number of threads> - sorted by time
    Iterator<Map.Entry<Long, Integer>> iterator = map.entrySet().iterator();

    SimpleRegression regression = new SimpleRegression();
    Integer tempIndex;
    double previousValue = -1.0;
    double value;
    double measuredTps;

    log.debug("Selecting next point for balancing");
    int indx = 0;
    while (iterator.hasNext()) {

        tempIndex = iterator.next().getValue();

        if (previousValue < 0.0) {
            previousValue = tempIndex.floatValue();
        }
        value = tempIndex.floatValue();
        measuredTps = stats.get(tempIndex).getSecond().floatValue();

        regression.addData(value, measuredTps);

        log.debug(String.format("   %7.2f    %7.2f", value, measuredTps));

        indx++;
        if (indx > MAX_POINTS_FOR_REGRESSION) {
            break;
        }
    }

    double intercept = regression.getIntercept();
    double slope = regression.getSlope();

    double approxPoint;

    // if no slope => use previous number of threads
    if (Math.abs(slope) > 1e-12) {
        approxPoint = (desiredTps.doubleValue() - intercept) / slope;
    } else {
        approxPoint = previousValue;
    }

    // if approximation point is negative - ignore it
    if (approxPoint < 0) {
        approxPoint = previousValue;
    }

    log.debug(String.format("Next point   %7d    (target tps: %7.2f)", (int) Math.round(approxPoint),
            desiredTps.doubleValue()));

    return (int) Math.round(approxPoint);
}

From source file:com.netxforge.netxstudio.common.math.NativeFunctions.java

/**
 * Return a {@link GenericsTuple tuple} with a key being the slope and the
 * value being the intercept of the trendline.
 * //from   www . ja  va2s  .  co m
 */
public GenericsTuple<Double, Double> trend(double[][] dataPair) {

    SimpleRegression regression = new SimpleRegression();
    regression.addData(dataPair);
    double slope = regression.getSlope();
    double intercept = regression.getIntercept();

    return new GenericsTuple<Double, Double>(slope, intercept);
}

From source file:ch.usi.inf.lidr.merging.SSL.java

/**
 * <b>IMPORTANT:</b> {@link #setSampleDocuments(List)} must be called before running normalization.
 * //from ww  w.j a  v a 2  s  .co m
 * @see ch.usi.inf.lidr.norm.ScoreNormalization#normalize(List<ScoredEntity<T>>)
 * @see #setSampleDocuments(List)
 */
@Override
public <T> List<ScoredEntity<T>> normalize(List<ScoredEntity<T>> unnormScoredDocs) {
    if (unnormScoredDocs == null) {
        throw new NullPointerException("The list of scored documents is null.");
    }

    SimpleRegression regression = getRegression(unnormScoredDocs);
    //TODO: backup with CORI
    if (regression.getN() < 3) {
        return new ArrayList<ScoredEntity<T>>();
    }

    List<ScoredEntity<T>> normScoredDocs = new ArrayList<ScoredEntity<T>>(unnormScoredDocs.size());
    for (int i = 0; i < unnormScoredDocs.size(); i++) {
        ScoredEntity<T> normScoredDoc = new ScoredEntity<T>(unnormScoredDocs.get(i).getEntity(),
                regression.getSlope() * unnormScoredDocs.get(i).getScore() + regression.getIntercept());
        normScoredDocs.add(normScoredDoc);
    }

    return normScoredDocs;
}

From source file:msc.fall2015.stock.kmeans.hbase.mapreduce.StockDataReaderMapper.java

public void map(ImmutableBytesWritable row, Result value, Context context)
        throws InterruptedException, IOException {
    SimpleRegression regression;
    for (Map.Entry<byte[], NavigableMap<byte[], NavigableMap<Long, byte[]>>> columnFamilyMap : value.getMap()
            .entrySet()) {/*from  www  .  jav  a2  s.c o m*/
        regression = new SimpleRegression();
        int count = 1;
        for (Map.Entry<byte[], NavigableMap<Long, byte[]>> entryVersion : columnFamilyMap.getValue()
                .entrySet()) {
            for (Map.Entry<Long, byte[]> entry : entryVersion.getValue().entrySet()) {
                String rowKey = Bytes.toString(value.getRow());
                String column = Bytes.toString(entryVersion.getKey());
                byte[] val = entry.getValue();
                String valOfColumn = new String(val);
                System.out.println(
                        "RowKey : " + rowKey + " Column Key : " + column + " Column Val : " + valOfColumn);
                if (!valOfColumn.isEmpty()) {
                    String[] priceAndCap = valOfColumn.split("_");
                    if (priceAndCap.length > 1) {
                        String pr = priceAndCap[0];
                        if (pr != null && !pr.equals("null")) {
                            double price = Double.valueOf(pr);
                            if (price < 0) {
                                price = price - 2 * price;
                            }
                            System.out.println("Price : " + price + " count : " + count);
                            regression.addData(count, price);
                        }
                    }
                }
            }
            count++;
        }
        // displays intercept of regression line
        System.out.println("Intercept : " + regression.getIntercept());

        // displays slope of regression line
        System.out.println("Slope : " + regression.getSlope());

        // displays slope standard error
        System.out.println("Slope STD Error : " + regression.getSlopeStdErr());
    }
}

From source file:edu.indiana.soic.ts.crunch.CrunchDataReader.java

public PTable<String, String> extractText(PTable<ImmutableBytesWritable, Result> tableContent) {
    return tableContent.parallelDo("Read data",
            new DoFn<Pair<ImmutableBytesWritable, Result>, Pair<String, String>>() {
                @Override/*from   w w  w.ja  v  a2s .c  o m*/
                public void process(Pair<ImmutableBytesWritable, Result> row,
                        Emitter<Pair<String, String>> emitter) {
                    SimpleRegression regression;
                    NavigableMap<byte[], NavigableMap<byte[], NavigableMap<Long, byte[]>>> map = row.second()
                            .getMap();
                    System.out.println(map.size());
                    for (Map.Entry<byte[], NavigableMap<byte[], NavigableMap<Long, byte[]>>> columnFamilyMap : map
                            .entrySet()) {
                        regression = new SimpleRegression();
                        int count = 1;
                        for (Map.Entry<byte[], NavigableMap<Long, byte[]>> entryVersion : columnFamilyMap
                                .getValue().entrySet()) {
                            for (Map.Entry<Long, byte[]> entry : entryVersion.getValue().entrySet()) {
                                String rowKey = Bytes.toString(row.second().getRow());
                                String column = Bytes.toString(entryVersion.getKey());
                                byte[] val = entry.getValue();
                                String valOfColumn = new String(val);
                                System.out.println("RowKey : " + rowKey + " Column Key : " + column
                                        + " Column Val : " + valOfColumn);
                                if (!valOfColumn.isEmpty()) {
                                    String[] priceAndCap = valOfColumn.split("_");
                                    if (priceAndCap.length > 1) {
                                        String pr = priceAndCap[0];
                                        if (pr != null && !pr.equals("null")) {
                                            double price = Double.valueOf(pr);
                                            if (price < 0) {
                                                price = price - 2 * price;
                                            }
                                            System.out.println("Price : " + price + " count : " + count);
                                            regression.addData(count, price);
                                        }
                                    }
                                }
                            }
                            count++;
                        }
                        // displays intercept of regression line
                        System.out.println("Intercept : " + regression.getIntercept());

                        // displays slope of regression line
                        System.out.println("Slope : " + regression.getSlope());

                        // displays slope standard error
                        System.out.println("Slope STD Error : " + regression.getSlopeStdErr());
                        emitter.emit(new Pair<String, String>(String.valueOf(regression.getIntercept()),
                                String.valueOf(regression.getSlope())));
                    }
                }
            }, Writables.tableOf(Writables.strings(), Writables.strings()));
}

From source file:playground.boescpa.converters.vissim.tools.TripMatcher.java

@Override
public HashMap<Id<Trip>, Integer> matchTrips(HashMap<Id<Trip>, Long[]> msTrips,
        HashMap<Id<Trip>, Long[]> amTrips) {

    int matchesWithHighScores = 0;
    int matchesWithVeryHighScores = 0;
    int progressCounter = 0;
    int progressChecker = 2;

    HashMap<Id<Trip>, Integer> countsPerAnmTrip = new HashMap<>();
    for (Id<Trip> amTrip : amTrips.keySet()) {
        countsPerAnmTrip.put(amTrip, 0);
    }// w w  w  .  j  ava  2 s .  c o m
    List<Id<Trip>> amTripsKeySet = new ArrayList<>(amTrips.keySet());

    for (Id<Trip> msTrip : msTrips.keySet()) {
        progressCounter++;
        Long[] msTripZones = msTrips.get(msTrip);

        Id<Trip> bestMatchingAmTrip = null;
        int bestMatchScore = Integer.MIN_VALUE;

        // Shuffle key set:
        Collections.shuffle(amTripsKeySet);
        for (Id<Trip> amTrip : amTripsKeySet) {
            Long[] amTripZones = amTrips.get(amTrip);

            // Linear regression between the to trips:
            SimpleRegression simpleRegression = new SimpleRegression();
            for (int i = 0; i < msTripZones.length; i++) {
                boolean foundNone = true;
                for (int j = 0; j < amTripZones.length; j++) {
                    if (msTripZones[i].equals(amTripZones[j])) {
                        simpleRegression.addData(i, j);
                        foundNone = false;
                    }
                }
                if (foundNone) {
                    int yPos = -(msTripZones.length - i) - NEG_OFFSET_IF_NOT_FOUNG;
                    simpleRegression.addData(i, yPos);
                }
            }

            // Scoring:
            int matchScore = 0;

            // Criterion 1.1: Difference in length of trips not greater than 10%.
            if (((double) Math.abs(msTripZones.length - amTripZones.length))
                    / ((double) msTripZones.length) <= 0.1) {
                matchScore += TEN_PRCT_SCORE;
            }
            // Criterion 1.2: The smaller the difference in length, the better.
            matchScore -= (Math.abs(msTripZones.length - amTripZones.length) * LENGTH_SCORE);

            // Criterion 2: The closer the intercept to zero, the better.
            matchScore -= (int) (Math.abs(simpleRegression.getIntercept()) * INTERCEPT_SCORE);

            // Criterion 3: The closer the slope to one, the better.
            matchScore -= (int) (Math.abs(1 - simpleRegression.getSlope()) * SLOPE_SCORE);

            // Criterion 4: The smaller the mean square error of the regression, the better.
            matchScore -= (int) (Math.abs(simpleRegression.getMeanSquareError()) * MSE_SCORE);

            if (matchScore > bestMatchScore) {
                bestMatchScore = matchScore;
                bestMatchingAmTrip = amTrip;
            }
        }

        countsPerAnmTrip.put(bestMatchingAmTrip, (countsPerAnmTrip.get(bestMatchingAmTrip) + 1));

        if (bestMatchScore >= 0.9 * TEN_PRCT_SCORE) {
            matchesWithHighScores++;
            if (bestMatchScore >= 0.99 * TEN_PRCT_SCORE) {
                matchesWithVeryHighScores++;
            }
        }

        // log progress:
        if (progressCounter >= progressChecker) {
            log.info(progressChecker + " trips matched.");
            progressChecker *= 2;
        }
    }

    log.info("Of total " + msTrips.size() + " trips, " + matchesWithHighScores
            + " were matched with a high score above " + 0.9 * TEN_PRCT_SCORE + " points.");
    log.info("Of total " + msTrips.size() + " trips, " + matchesWithVeryHighScores
            + " were matched with a very high score above " + 0.99 * TEN_PRCT_SCORE + " points.");

    return countsPerAnmTrip;
}

From source file:uk.ac.leeds.ccg.andyt.generic.visualisation.charts.Generic_ScatterPlotAndLinearRegression.java

/**
 * @param data double[2][] where: data[0][] are the y values data[1][] are
 * the x values//w  ww . j  a  v a  2  s  .  c om
 * @return double[] result where: <ul> <li>result[0] is the y axis
 * intercept;</li> <li>result[1] is the change in y relative to x (gradient
 * or slope);</li> <li>result[2] is the rank correlation coefficient
 * (RSquare);</li> <li>result[3] is data[0].length.</li> </ul>
 */
public static double[] getSimpleRegressionParameters(double[][] data) {
    double[] result = new double[4];
    // org.apache.commons.math.stat.regression.SimpleRegression;
    SimpleRegression a_SimpleRegression = new SimpleRegression();
    //System.out.println("data.length " + data[0].length);
    for (int i = 0; i < data[0].length; i++) {
        a_SimpleRegression.addData(data[1][i], data[0][i]);
        //aSimpleRegression.addData(data[0][i], data[1][i]);
    }
    result[0] = a_SimpleRegression.getIntercept();
    result[1] = a_SimpleRegression.getSlope();
    result[2] = a_SimpleRegression.getRSquare();
    result[3] = data[0].length;
    return result;
}

From source file:uk.ac.leeds.ccg.andyt.projects.moses.process.RegressionReport.java

/**
 * data[0][] = observed  SAR/*from   w w w. j  a  va2 s  .  c o m*/
 * data[1][] = expected  CAS
 *
 * @param data
 * @return 
 */
public static double[] printSimpleRegression(double[][] data) {
    double[] result = new double[3];
    // org.apache.commons.math.stat.regression.SimpleRegression;
    SimpleRegression aSimpleRegression = new SimpleRegression();
    System.out.println("data.length " + data[0].length);
    for (int i = 0; i < data[0].length; i++) {
        // aSimpleRegression.addData( data[1][i], data[0][i] );
        aSimpleRegression.addData(data[0][i], data[1][i]);
    }
    double _Intercept = aSimpleRegression.getIntercept();
    double _Slope = aSimpleRegression.getSlope();
    double _RSquare = aSimpleRegression.getRSquare();
    System.out.println(" y = " + _Slope + " * x + " + _Intercept);
    System.out.println(" RSquare " + _RSquare);
    result[0] = _Intercept;
    result[1] = _Slope;
    result[2] = _RSquare;
    return result;
}