Java Resources

Pearson correlation coefficient

teddy — Thu, 22 Apr 2010 07:50:48 +0000

In statistics, the Pearson product-moment correlation coefficient (sometimes referred to as the PMCC, and typically denoted by r) is a measure of the correlation (linear dependence) between two variables X and Y, giving a value between +1 and −1 inclusive.

    /**
     *   calculate Pearson product-moment correlation coefficient
     * @param point1     first point
     * @param point2     second point
     * @return     Pearson correlation coefficient
     */
    public static double getPMCC(double[] point1, double[] point2) {
        double suma = 0;
        double sumb = 0;
        double sumaSq = 0;
        double sumbSq = 0;
        double pSum = 0;
        int n = point1.length;
        for (int i = 0; i < point1.length; i++) {
            suma = suma + point1[i];
            sumb = sumb + point2[i];
            sumaSq = sumaSq + point1[i] * point1[i];
            sumbSq = sumbSq + point2[i] * point1[i];
            pSum = pSum + point1[i] * point2[i];
        }
        double numerator = pSum - suma * sumb / n;
        double denominator = Math.sqrt((sumaSq - suma * suma / n) * (sumbSq - sumb * sumb / n));
        return numerator / denominator;
    }

Normalization

teddy — Thu, 22 Apr 2010 07:39:22 +0000

Normalization is any process that makes something more normal.

    /**
     * @param point1 first point
     * @param point2 second point
     * @return the  normalization Euclidean distance of two points
     */
    public static double getNormalizeDistance(double[] point1, double[] point2) {
        return 1 / (getDistance(point1, point2) + 1);
    }

Euclidean distance

teddy — Tue, 20 Apr 2010 06:12:14 +0000

In mathematics, the Euclidean distance or Euclidean metric is the “ordinary” distance between two points that one would measure with a ruler, and is given by the Pythagorean formula.

    /**
     * @param point1   first point
     * @param point2   second point
     * @return  the  Euclidean distance of two points
     */
    public static double getDistance(double[] point1, double[] point2) {
        double distance = 0;
        for (int i = 0; i < point1.length; i++) {
            distance = distance + Math.pow((point1[i] - point2[i]), 2);
        }
        return Math.sqrt(distance);
    }

Gaussian distribution

teddy — Fri, 09 Apr 2010 06:02:05 +0000

The normal distribution or Gaussian distribution is a continuous probability distribution that often gives a good description of data that cluster around the mean.

    /**
     *   The aim of this static method is to implememnt the function of Gaussian distribution
     *   N（μ，σ2)
     * @param x   variable
     * @param mean   mathematic expectation
     * @param stdDev Variance
     * @return
     */
    public static double normalDens(double x, double mean, double stdDev) {
         double diff = x - mean;
         return (1 / ( Math.sqrt(2 * Math.PI) * stdDev))
                 * Math.exp(-(diff * diff / (2 * stdDev * stdDev)));
     }

Gaussian elimination

teddy — Tue, 30 Mar 2010 12:47:23 +0000

In linear algebra, Gaussian elimination is an algorithm for solving systems of linear equations, finding the rank of a matrix, and calculating the inverse of an invertible square matrix.

Gauss-Jordan Elimination is a variant of Gaussian Elimination.

package org.javaresources.math.matrix;
/**
 * Created by IntelliJ IDEA.
 * User: glen
 * Date: 2010-3-29
 * Time: 20:10:28
 *
 */
public class MatrixUtil {
    /**
     *   Ax=b
     * @param a A  matrix
     * @param b b  vector
     */
    public static void gaussJordan(double a[][], double b[]){
        int i, j, k, m;
        double temp;
        int numRows = a.length;
        int numCols = a[0].length;
        int index[][] = new int[numRows][2];
        partialPivot(a, b, index);
        for (i = 0; i < numRows; ++i) {
            temp = a[i][i];
            for (j = 0; j < numCols; ++j) {
                a[i][j] /= temp;
            }
            b[i] /= temp;
            a[i][i] = 1.0 / temp;
            for (k = 0; k < numRows; ++k) {
                if (k != i) {
                    temp = a[k][i];
                    for (j = 0; j < numCols; ++j) {
                        a[k][j] -= temp * a[i][j];
                    }
                    b[k] -= temp * b[i];
                    a[k][i] = -temp * a[i][i];
                }
            }
        }
        for (j = numCols - 1; j >= 0; --j) {
            k = index[j][0];
            m = index[j][1];
            if (k != m) {
                for (i = 0; i < numRows; ++i) {
                    temp = a[i][m];
                    a[i][m] = a[i][k];
                    a[i][k] = temp;
                }
            }
        }
        return;
    }
    /**
     *
     * @param mt  matrix
     * @param v     vector
     * @param index
     */
    private static void partialPivot(
            double mt[][], double v[], int index[][]) {
        double temp;
        double tempRow[];
        int i, j, m;
        int numRows = mt.length;
        int numCols = mt[0].length;
        double scale[] = new double[numRows];
        for (i = 0; i < numRows; ++i) {
            index[i][0] = i;
            index[i][1] = i;
            for (j = 0; j < numCols; ++j) {
                scale[i] = Math.max(scale[i], Math.abs(mt[i][j]));
            }
        }
        for (j = 0; j < numCols - 1; ++j) {
            m = j;
            for (i = j + 1; i < numRows; ++i) {
                if (Math.abs(mt[i][j]) / scale[i] >
                        Math.abs(mt[m][j]) / scale[m]) {
                    m = i;
                }
            }
            if (m != j) {
                index[j][0] = j;
                index[j][1] = m;
                tempRow = mt[j];
                mt[j] = mt[m];
                mt[m] = tempRow;
                temp = v[j];
                v[j] = v[m];
                v[m] = temp;
                temp = scale[j];
                scale[j] = scale[m];
                scale[m] = temp;
            }
        }
    }

    /**
     *    Inverse matrix
     * @param a
     */
    public static void invertMatrix(double a[][]) {
        int i, j, k, m;
        double temp;

        int numRows = a.length;
        int numCols = a[0].length;
        int index[][] = new int[numRows][2];
        partialPivot(a, new double[numRows], index);
        for (i = 0; i < numRows; ++i) {
            temp = a[i][i];
            for (j = 0; j < numCols; ++j) {
                a[i][j] /= temp;
            }
            a[i][i] = 1.0 / temp;
            for (k = 0; k < numRows; ++k) {
                if (k != i) {
                    temp = a[k][i];
                    for (j = 0; j < numCols; ++j) {
                        a[k][j] -= temp * a[i][j];
                    }
                    a[k][i] = -temp * a[i][i];
                }
            }
        }
        for (j = numCols - 1; j >= 0; --j) {
            k = index[j][0];
            m = index[j][1];
            if (k != m) {
                for (i = 0; i < numRows; ++i) {
                    temp = a[i][m];
                    a[i][m] = a[i][k];
                    a[i][k] = temp;
                }
            }
        }
    }
}

Mysql + JSP Example

teddy — Sun, 28 Mar 2010 14:00:27 +0000

Java Database Connectivity (JDBC) is an API that lets you access any tabular data sources from a Java application.
This example shows a JSP that queries a UserInfo table using JDBC.







<%@ page language="java" import="java.sql.*, java.io.*" %>
<%
    Connection con = null;
    try{
        Class.forName("com.mysql.jdbc.Driver");
        con = DriverManager.getConnection("jdbc:mysql://localhost/blog?user=root&password=123456");
        Statement statement = con.createStatement();
        ResultSet rs = statement.executeQuery("SELECT * FROM userinfo");

%>


<%
        while ( rs.next() ) {
            out.println("
\n


");
            out.println("


");
        }
        rs.close();
    } catch (IOException io) {
        out.println(io.getMessage());
    } catch (SQLException sql) {
        out.println(sql.getMessage());
    } catch (Exception e) {
        out.println(e.getMessage());
    } finally {
        try {
            if ( con != null ) {
                con.close();
            }
        } catch (SQLException sql) {
            out.println(sql.getMessage());
        }
    }
%>


Name
password
" + rs.getString("username") + " " + rs.getString("password") + "

Name	password
" + rs.getString("username") + "	" + rs.getString("password") + "

Mysql Connection

admin — Sun, 28 Mar 2010 03:49:42 +0000

public static Connection getConnection() throws Exception {
String driver = "com.mysql.jdbc.Driver";
String url = "jdbc:mysql://localhost/ev?";
String username = "root";
String password = "0532";
Class.forName(driver); // load Oracle driver
return DriverManager.getConnection(url, username, password);
}