Application: gvSIG desktop » gvSIG tools: ToolBox

<project name="SEXTANTE_LIB" default="generate-without-source" basedir=".">

    <description>

        SEXTANTE_LIB

    </description>

    <property name="version.number" value="0.7"/>

  <target name="generate-without-source"

    description="generate the distribution without the source file">

       <tstamp>

         <format property="TODAY" pattern="yyyy-MM-dd HH:mm:ss" />

       </tstamp>

    <manifest file="MANIFEST.MF">

        <attribute name="Implementation-Version"

            value="${version.number}"/>

        <attribute name="Built-Date" value="${TODAY}"/>

   </manifest>

    <jar jarfile="../dist/libMath.jar" manifest="MANIFEST.MF">

        <fileset dir="bin">

            <include name="**"/>

        </fileset>

    </jar>

    <copy todir="../dist">

  	  <fileset dir="lib" includes="**"/>

    </copy>

  </target>

</project>

Manifest-Version: 1.0

Ant-Version: Apache Ant 1.7.0

Created-By: 16.3-b01 (Sun Microsystems Inc.)

Implementation-Version: 0.7

Built-Date: 2011-12-14 14:01:08

package es.unex.sextante.math.regression;

import java.util.ArrayList;

import Jama.Matrix;

/**

 * A class for performing multiple regressions

 * 

 * @author volaya

 * 

 */

public class MultipleRegression {

   private class MaxValues {

      public int    iMax;

      public double dRMax;

   }

   private final ArrayList m_Y = new ArrayList();

   private final ArrayList m_X[];

   private final double    m_dDCoeff[];

   private final double    m_dRCoeff[];

   private final int       m_iOrder[];

   public MultipleRegression(final int iVariables) {

      m_X = new ArrayList[iVariables];

      for (int i = 0; i < m_X.length; i++) {

         m_X[i] = new ArrayList();

      }

      m_dRCoeff = new double[iVariables + 1];

      m_dDCoeff = new double[iVariables + 1];

      m_iOrder = new int[iVariables + 1];

   }

   public void addValue(final double dX[],

                        final double dY) {

      if (dX.length == m_X.length) {

         m_Y.add(new Double(dY));

         for (int i = 0; i < dX.length; i++) {

            m_X[i].add(new Double(dX[i]));

         }

      }

   }

   public boolean calculate() {

      if ((m_Y.size() > m_iOrder.length - 1) && (m_iOrder.length > 0)) {

         getRegression();

         getCorrelation();

         return true;

      }

      return false;

   }

   private boolean eliminate(final double[] X,

                             final double[] Y) {

      final Regression regression = new Regression();

      if (regression.calculate(X, Y)) {

         for (int i = 0; i < Y.length; i++) {

            Y[i] -= regression.getConstant() + regression.getCoeff() * X[i];

         }

         return true;

      }

      return false;

   }

   public double getCoeff(int iVariable) {

      if ((++iVariable > 0) && (iVariable < m_dDCoeff.length)) {

         return (m_dRCoeff[iVariable]);

      }

      return 0.0;

   }

   public double getConstant() {

      if (m_dRCoeff.length > 1) {

         return (m_dRCoeff[0]);

      }

      return (0.0);

   }

   boolean getCorrelation() {

      int i, k, nVariables, nValues;

      double Values[][], r2_sum;

      final MaxValues maxValues = new MaxValues();

      nVariables = m_iOrder.length;

      nValues = m_Y.size();

      if ((nValues >= nVariables) && (nVariables > 1)) {

         Values = new double[nVariables][nValues];

         for (k = 0; k < nValues; k++) {

            Values[0][k] = ((Double) m_Y.get(k)).doubleValue();

         }

         for (i = 1; i < nVariables; i++) {

            for (k = 0; k < nValues; k++) {

               Values[i][k] = ((Double) m_X[i - 1].get(k)).doubleValue();

            }

         }

         m_iOrder[0] = -1;

         m_dDCoeff[0] = -1;

         for (i = 0, r2_sum = 0.0; i < nVariables - 1; i++) {

            getCorrelation(Values, Values[0], maxValues);

            r2_sum += (1.0 - r2_sum) * maxValues.dRMax;

            m_iOrder[maxValues.iMax] = i;

            m_dDCoeff[maxValues.iMax] = r2_sum;

         }

         return true;

      }

      return false;

   }

   boolean getCorrelation(final double[][] X,

                          final double[] Y,

                          final MaxValues maxValues) {

      int i, n;

      double XMax[];

      final Regression regression = new Regression();

      for (i = 1, n = 0, maxValues.iMax = -1, maxValues.dRMax = 0.0; i < X.length; i++) {

         if ((X[i] != null) && regression.calculate(X[i], Y)) {

            n++;

            if ((maxValues.iMax < 0) || (maxValues.dRMax < regression.getR2())) {

               maxValues.iMax = i;

               maxValues.dRMax = regression.getR2();

            }

         }

      }

      if (n > 1) {

         XMax = X[maxValues.iMax];

         X[maxValues.iMax] = null;

         for (i = 0; i < X.length; i++) {

            if (X[i] != null) {

               eliminate(XMax, X[i]);

            }

         }

         eliminate(XMax, Y);

      }

      return (maxValues.iMax >= 1);

   }

   public int getOrder(int iVariable) {

      if ((++iVariable > 0) && (iVariable < m_iOrder.length)) {

         return (m_iOrder[iVariable]);

      }

      return -1;

   }

   public int getOrdered(final int iOrder) {

      for (int i = 0; i < m_iOrder.length; i++) {

         if (iOrder == m_iOrder[i]) {

            return i - 1;

         }

      }

      return -1;

   }

   public double getR2(int iVariable) {

      if ((++iVariable > 0) && (iVariable < m_dDCoeff.length)) {

         return (m_dDCoeff[iVariable]);

      }

      return 0.0;

   }

   public double getR2Change(final int iVariable) {

      final int iOrder = getOrder(iVariable);

      if (iOrder > 0) {

         return (getR2(iVariable) - getR2(getOrdered(iOrder - 1)));

      }

      if (iOrder == 0) {

         return (getR2(iVariable));

      }

      return (0.0);

   }

   private boolean getRegression() {

      int i, j, k, nVariables, nValues;

      double sum, B[], P[][], X[][], Y[];

      nVariables = m_iOrder.length;

      nValues = m_Y.size();

      B = new double[nVariables];

      P = new double[nVariables][nVariables];

      Y = new double[nValues];

      X = new double[nVariables][nValues];

      for (k = 0; k < nValues; k++) {

         Y[k] = ((Double) m_Y.get(k)).doubleValue();

         X[0][k] = 1.0;

      }

      for (i = 1; i < nVariables; i++) {

         for (k = 0; k < nValues; k++) {

            X[i][k] = ((Double) m_X[i - 1].get(k)).doubleValue();

         }

      }

      for (i = 0; i < nVariables; i++) {

         for (k = 0, sum = 0.0; k < nValues; k++) {

            sum += X[i][k] * Y[k];

         }

         B[i] = sum;

         for (j = 0; j < nVariables; j++) {

            for (k = 0, sum = 0.0; k < nValues; k++) {

               sum += X[i][k] * X[j][k];

            }

            P[i][j] = sum;

         }

      }

      final Matrix m = new Matrix(P);

      Matrix inverse;

      try {

         inverse = m.inverse();

      }

      catch (final Exception e) {

         return false;

      }

      for (i = 0; i < nVariables; i++) {

         for (j = 0, sum = 0.0; j < nVariables; j++) {

            sum += inverse.get(i, j) * B[j];

         }

         m_dRCoeff[i] = sum;

      }

      return true;

   }

}

package es.unex.sextante.math.regression;

import java.text.DecimalFormat;

import java.util.ArrayList;

import Jama.Matrix;

import Jama.QRDecomposition;

/*import es.unex.sextante.libMath.Jama.Matrix;

import es.unex.sextante.libMath.Jama.QRDecomposition;*/

/**

 * Least squares fitting

 * 

 * @author volaya

 * 

 */

public class LeastSquaresFit {

   private final ArrayList m_X     = new ArrayList();

   private final ArrayList m_Y     = new ArrayList();

   private double[]        m_dCoeffs;

   private String          m_sExpression;

   private double          m_dYMin = Double.MAX_VALUE;

   private double          m_dXMax = Double.NEGATIVE_INFINITY;

   private double          m_dXMin = Double.MAX_VALUE;

   private double          m_dYMax = Double.NEGATIVE_INFINITY;

   public void addValue(final double dX,

                        final double dY) {

      setMinMaxX(dX);

      setMinMaxY(dY);

      m_X.add(new Double(dX));

      m_Y.add(new Double(dY));

   }

   public boolean calculate(final int iOrder) {

      double dX, dY;

      final int nk = iOrder + 1;

      final double[][] alpha = new double[nk][nk];

      final double[] beta = new double[nk];

      double term = 0;

      m_dCoeffs = new double[nk];

      final int iNumPoints = m_X.size();

      for (int k = 0; k < nk; k++) {

         for (int j = k; j < nk; j++) {

            term = 0.0;

            alpha[k][j] = 0.0;

            for (int i = 0; i < iNumPoints; i++) {

               double prod1 = 1.0;

               dX = ((Double) m_X.get(i)).doubleValue();

               if (k > 0) {

                  for (int m = 0; m < k; m++) {

                     prod1 *= dX;

                  }

               }

               double prod2 = 1.0;

               if (j > 0) {

                  for (int m = 0; m < j; m++) {

                     prod2 *= dX;

                  }

               }

               term = (prod1 * prod2);

               alpha[k][j] += term;

            }

            alpha[j][k] = alpha[k][j];

         }

         for (int i = 0; i < iNumPoints; i++) {

            dX = ((Double) m_X.get(i)).doubleValue();

            dY = ((Double) m_Y.get(i)).doubleValue();

            double prod1 = 1.0;

            if (k > 0) {

               for (int m = 0; m < k; m++) {

                  prod1 *= dX;

               }

            }

            term = (dY * prod1);

            beta[k] += term;

         }

      }

      final Matrix alpha_matrix = new Matrix(alpha);

      final QRDecomposition alpha_QRD = new QRDecomposition(alpha_matrix);

      final Matrix beta_matrix = new Matrix(beta, nk);

      Matrix param_matrix;

      try {

         param_matrix = alpha_QRD.solve(beta_matrix);

      }

      catch (final Exception e) {

         return false;

      }

      final DecimalFormat df = new DecimalFormat("####.#####");

      final StringBuffer sb = new StringBuffer("");

      for (int k = 0; k < nk; k++) {

         m_dCoeffs[k] = param_matrix.get(k, 0);

         if (k != 0) {

            sb.append(" + " + df.format(m_dCoeffs[k]) + "x^" + Integer.toString(k));

         }

         else {

            sb.append(df.format(m_dCoeffs[k]));

         }

      }

      m_sExpression = sb.toString();

      return true;

   }

   public String getExpression() {

      return m_sExpression;

   }

   public int getNumPoints() {

      return m_X.size();

   }

   public void getPoints(final double[] x,

                         final double[] y) {

      int i;

      for (i = 0; i < m_X.size(); i++) {

         x[i] = ((Double) m_X.get(i)).doubleValue();

         y[i] = ((Double) m_Y.get(i)).doubleValue();

      }

   }

   public double getXMax() {

      return m_dXMax;

   }

   public double getXMin() {

      return m_dXMin;

   }

   public double getY(final double x) {

      int i;

      double dRet = 0;

      for (i = 0; i < m_dCoeffs.length; i++) {

         dRet += m_dCoeffs[i] * Math.pow(x, i);

      }

      return dRet;

   }

   public double getYMax() {

      return m_dYMax;

   }

   public double getYMin() {

      return m_dYMin;

   }

   private void setMinMaxX(final double x) {

      if (x > m_dXMax) {

         m_dXMax = x;

      }

      if (x < m_dXMin) {

         m_dXMin = x;

      }

   }

   private void setMinMaxY(final double y) {

      if (y > m_dYMax) {

         m_dYMax = y;

      }

      if (y < m_dYMin) {

         m_dYMin = y;

      }

   }

}

/*******************************************************************************

Regression.java

Copyright (C) Victor Olaya

Adapted from SAGA, System for Automated Geographical Analysis.

Copyrights (c) 2002-2005 by Olaf Conrad

Portions (c) 2002 by Andre Ringeler

Portions (c) 2005 by Victor Olaya

This program is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation; either version 2 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program; if not, write to the Free Software

Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *******************************************************************************/

package es.unex.sextante.math.regression;

import java.text.DecimalFormat;

import java.util.ArrayList;

/**

 * Simple regression class

 *

 * @author volaya

 *

 */

public class Regression {

   public static final int     REGRESSION_Best_Fit = 0;

   public static final int     REGRESSION_Linear   = 1;              // Y = a + b * X

   public static final int     REGRESSION_Rez_X    = 2;              // Y = a + b / X

   public static final int     REGRESSION_Rez_Y    = 3;              // Y = a / (b - X)

   public static final int     REGRESSION_Pow      = 4;              // Y = a * X^b

   public static final int     REGRESSION_Exp      = 5;              // Y = a * e^(b * X)

   public static final int     REGRESSION_Log      = 6;              // Y = a + b * ln(X)

   private static final double ALMOST_ZERO         = 0.0001;

   private final ArrayList           m_X                 = new ArrayList();

   private final ArrayList           m_Y                 = new ArrayList();

   private double              m_dR;

   private double              m_dCoeff;

   private double              m_dConst;

   private double              m_dXMin, m_dXMax, m_dYMin, m_dYMax;

   private double              m_dXMean, m_dYMean;

   private double              m_dXVar, m_dYVar;

   private int                 m_iType;

   public Regression() {

   }

   private double _X_Transform(double x) {

      switch (m_iType) {

         default:

            return (x);

         case REGRESSION_Rez_X:

            if (x == 0.0) {

               x = ALMOST_ZERO;

            }

            return (1.0 / x);

         case REGRESSION_Pow:

         case REGRESSION_Log:

            if (x <= 0.0) {

               x = ALMOST_ZERO;

            }

            return (Math.log(x));

      }

   }

   private double _Y_Transform(double y) {

      switch (m_iType) {

         default:

            return (y);

         case REGRESSION_Rez_Y:

            if (y == 0.0) {

               y = ALMOST_ZERO;

            }

            return (1.0 / y);

         case REGRESSION_Pow:

         case REGRESSION_Exp:

            if (y <= 0.0) {

               y = ALMOST_ZERO;

            }

            return (Math.log(y));

      }

   }

   public void addValue(final double dX,

                        final double dY) {

      m_X.add(new Double(dX));

      m_Y.add(new Double(dY));

   }

   public boolean calculate() {

      return calculateLinear();

   }

   public boolean calculate(final double[] x,

                            final double[] y) {

      if (x.length == y.length) {

         m_X.clear();

         m_Y.clear();

         for (int i = 0; i < y.length; i++) {

            this.addValue(x[i], y[i]);

         }

         return calculate();

      }

      else {

         return false;

      }

   }

   public boolean calculate(final int iRegressionType) {

      double d;

      if (iRegressionType == REGRESSION_Best_Fit) {

         m_iType = getBestFitType();

      }

      else {

         m_iType = iRegressionType;

      }

      if (calculateLinear()) {

         switch (m_iType) {

            case REGRESSION_Linear:

            default:

               break;

            case REGRESSION_Rez_X:

               m_dXVar = 1.0 / m_dXVar;

               break;

            case REGRESSION_Rez_Y:

               d = m_dConst;

               m_dConst = 1.0 / m_dCoeff;

               m_dCoeff = d * m_dCoeff;

               m_dYVar = 1.0 / m_dYVar;

               break;

            case REGRESSION_Pow:

               m_dConst = Math.exp(m_dConst);

               m_dXVar = Math.exp(m_dXVar);

               m_dYVar = Math.exp(m_dYVar);

               break;

            case REGRESSION_Exp:

               m_dConst = Math.exp(m_dConst);

               m_dYVar = Math.exp(m_dYVar);

               break;

            case REGRESSION_Log:

               m_dXVar = Math.exp(m_dXVar);

               break;

         }

         if (m_iType != REGRESSION_Linear) {

            calculateMinMaxMean();

         }

         return true;

      }

      return false;

   }

   private boolean calculateLinear() {

      int i;

      double x, y, s_xx, s_xy, s_x, s_y, s_dx2, s_dy2, s_dxdy;

      if (m_X.size() > 1) {

         m_dXMean = m_dXMin = m_dXMax = _X_Transform(((Double) m_X.get(0)).doubleValue());

         m_dYMean = m_dYMin = m_dYMax = _Y_Transform(((Double) m_Y.get(0)).doubleValue());

         for (i = 1; i < m_X.size(); i++) {

            m_dXMean += (x = _X_Transform(((Double) m_X.get(i)).doubleValue()));

            m_dYMean += (y = _Y_Transform(((Double) m_Y.get(i)).doubleValue()));

            setMinMaxX(x);

            setMinMaxY(y);

         }

         m_dXMean /= m_X.size();

         m_dYMean /= m_X.size();

         if (m_dXMin < m_dXMax && m_dYMin < m_dYMax) {

            s_x = s_y = s_xx = s_xy = s_dx2 = s_dy2 = s_dxdy = 0.0;

            for (i = 0; i < m_X.size(); i++) {

               x = _X_Transform(((Double) m_X.get(i)).doubleValue());

               y = _Y_Transform(((Double) m_Y.get(i)).doubleValue());

               s_x += x;

               s_y += y;

               s_xx += x * x;

               s_xy += x * y;

               x -= m_dXMean;

               y -= m_dYMean;

               s_dx2 += x * x;

               s_dy2 += y * y;

               s_dxdy += x * y;

            }

            m_dXVar = s_dx2 / m_X.size();

            m_dYVar = s_dy2 / m_X.size();

            m_dCoeff = s_dxdy / s_dx2;

            if (m_X.size() * s_xx - s_x * s_x != 0) {

               m_dConst = (s_xx * s_y - s_x * s_xy) / (m_X.size() * s_xx - s_x * s_x);

            }

            else {

               m_dConst = 0;

            }

            m_dR = s_dxdy / Math.sqrt(s_dx2 * s_dy2);

            return true;

         }

      }

      return false;

   }

   private void calculateMinMaxMean() {

      int i;

      double x, y;

      if (m_X.size() > 1) {

         m_dXMean = m_dXMin = m_dXMax = _X_Transform(((Double) m_X.get(0)).doubleValue());

         m_dYMean = m_dYMin = m_dYMax = _Y_Transform(((Double) m_Y.get(0)).doubleValue());

         for (i = 1; i < m_X.size(); i++) {

            m_dXMean += (x = ((Double) m_X.get(i)).doubleValue());

            m_dYMean += (y = ((Double) m_Y.get(i)).doubleValue());

            setMinMaxX(x);

            setMinMaxY(y);

         }

         m_dXMean /= m_X.size();

         m_dYMean /= m_X.size();

      }

   }

   private int getBestFitType() {

      int i;

      int iType = 1;

      final int iTypes = 6;

      double m_dBestR = 0;

      m_dR = 0;

      for (i = 1; i < iTypes + 1; i++) {

         calculate(i);

         if (m_dR > m_dBestR) {

            iType = i;

            m_dBestR = m_dR;

         }

      }

      return iType;

   }

   public double getCoeff() {

      return m_dCoeff;

   }

   public double getConstant() {

      return m_dConst;

   }

   public String getExpression() {

      final DecimalFormat df = new DecimalFormat("####.####");

      switch (m_iType) {

         case REGRESSION_Linear:

            return " y = " + df.format(m_dConst) + " + " + df.format(m_dCoeff) + "x";

         case REGRESSION_Rez_X:

            return " y = " + df.format(m_dConst) + " + " + df.format(m_dCoeff) + "/x";

         case REGRESSION_Rez_Y:

            return " y = " + df.format(m_dConst) + " / (" + df.format(m_dCoeff) + "- x)";

         case REGRESSION_Pow:

            return " y = " + df.format(m_dConst) + "x^" + df.format(m_dCoeff);

         case REGRESSION_Exp:

            return " y = " + df.format(m_dConst) + " � e^(" + df.format(m_dCoeff) + "x)";

         case REGRESSION_Log:

            return " y = " + df.format(m_dConst) + " + " + df.format(m_dCoeff) + " � ln(x)";

      }

      return "";

   }

   public double getR() {

      return m_dR;

   }

   public double getR2() {

      return m_dR * m_dR;

   }

   public void getRestrictedSample(final double[] x,

                                   final double[] y,

                                   final int nPoints) {

      int i;

      int iIndex;

      for (i = 0; i < nPoints; i++) {

         iIndex = (int) (Math.random() * m_X.size());

         x[i] = ((Double) m_X.get(iIndex)).doubleValue();

         y[i] = ((Double) m_Y.get(iIndex)).doubleValue();

      }

   }

   public double getX(double y) {

      if (m_X.size() > 0.0) {

         switch (m_iType) {

            case REGRESSION_Linear: // Y = a + b * X -> X = (Y - a) / b

               if (m_dCoeff != 0.0) {

                  return ((m_dConst * y) / m_dCoeff);

               }

            case REGRESSION_Rez_X: // Y = a + b / X -> X = b / (Y - a)

               if ((y = y - m_dConst) != 0.0) {

                  return (m_dCoeff / y);

               }

            case REGRESSION_Rez_Y: // Y = a / (b - X) -> X = b - a / Y

               if (y != 0.0) {

                  return (m_dCoeff - m_dConst / y);

               }

            case REGRESSION_Pow: // Y = a * X^b -> X = (Y / a)^(1 / b)

               if (m_dConst != 0.0 && m_dCoeff != 0.0) {

                  return (Math.pow(y / m_dConst, 1.0 / m_dCoeff));

               }

            case REGRESSION_Exp: // Y = a * e^(b * X) -> X = ln(Y / a) / b

               if (m_dConst != 0.0 && (y = y / m_dConst) > 0.0 && m_dCoeff != 0.0) {

                  return (Math.log(y) / m_dCoeff);

               }

            case REGRESSION_Log: // Y = a + b * ln(X) -> X = e^((Y - a) / b)

               if (m_dCoeff != 0.0) {

                  return (Math.exp((y - m_dConst) / m_dCoeff));

               }

         }

      }

      return (Double.NEGATIVE_INFINITY );

   }

   public double getXMax() {

      return m_dXMax;

   }

   public double getXMin() {

      return m_dXMin;

   }

   public double getXVar() {

      return m_dXVar;

   }

   public double getY(double x) {

      if (m_X.size() > 0.0) {

         switch (m_iType) {

            case REGRESSION_Linear: // Y = a + b * X

               return (m_dConst + m_dCoeff * x);

            case REGRESSION_Rez_X: // Y = a + b / X

               if (x != 0.0) {

                  return (m_dConst + m_dCoeff / x);

               }

            case REGRESSION_Rez_Y: // Y = a / (b - X)

               if ((x = m_dCoeff - x) != 0.0) {

                  return (m_dConst / x);

               }

            case REGRESSION_Pow: // Y = a * X^b

               return (m_dConst * Math.pow(x, m_dCoeff));

            case REGRESSION_Exp: // Y = a e^(b * X)

               return (m_dConst * Math.exp(m_dCoeff * x));

            case REGRESSION_Log: // Y = a + b * ln(X)

               if (x > 0.0) {

                  return (m_dConst + m_dCoeff * Math.log(x));

               }

         }

      }

      return (Double.NEGATIVE_INFINITY );

   }

   public double getYMax() {

      return m_dYMax;

   }

   public double getYMin() {

      return m_dYMin;

   }

   public double getYVar() {

      return m_dYVar;

   }

   private void setMinMaxX(final double x) {

      if (x > m_dXMax) {

         m_dXMax = x;

      }

      if (x < m_dXMin) {

         m_dXMin = x;

      }

   }

   private void setMinMaxY(final double y) {

      if (y > m_dYMax) {

         m_dYMax = y;

      }

      if (y < m_dYMin) {

         m_dYMin = y;

      }

   }

}

package es.unex.sextante.math.simpleStats;

/**

 * A class to calculate some basic statistics

 * 

 * @author volaya

 * 

 */

public class SimpleStats {

   //private final ArrayList m_Values;

   private double m_dSum;

   private double m_dRMS;

   private double m_dMean;

   private double m_dVariance;

   private double m_dMax, m_dMin;

   private double m_dStdDev;

   //private boolean   m_bCalculated;

   private int    m_iCount;

   private double m_dM2;

   public SimpleStats() {

      //m_Values = new ArrayList();

      //m_bCalculated = false;

      m_iCount = 0;

      m_dMax = Double.NEGATIVE_INFINITY;

      m_dMin = Double.MAX_VALUE;

      m_dSum = 0;

      m_dRMS = 0;

      m_dM2 = 0;

   }

   /**

    * adds a new value to the list of values

    * 

    * @param dValue

    *                the value

    */

   public void addValue(final double dValue) {

      m_iCount++;

      final double dDelta = dValue - m_dMean;

      m_dMean = m_dMean + dDelta / m_iCount;

      m_dM2 = m_dM2 + dDelta * (dValue - m_dMean);

      m_dVariance = m_dM2 / (m_iCount - 1);

      m_dSum += dValue;

      m_dRMS += dValue * dValue;

      m_dMax = Math.max(m_dMax, dValue);

      m_dMin = Math.min(m_dMin, dValue);

      m_dStdDev = Math.sqrt(m_dVariance);

      m_dRMS = Math.sqrt(m_dRMS / m_iCount);

   }

   /**

    * Returns the coefficient of variation

    * 

    * @return the coefficient of variation

    */

   public double getCoeffOfVar() {

      return m_dVariance / m_dMean;

   }

   /**

    * Return the number of values added

    * 

    * @return the number of values added

    */

   public int getCount() {

      return m_iCount;

   }

   /**

    * Returns the maximum value

    * 

    * @return the maximum value

    */

   public double getMax() {

      return m_dMax;

   }

   /**

    * Returns the mean value

    * 

    * @return the mean value

    */

   public double getMean() {

      return m_dMean;

   }

   /**

    * Returns the minimum value

    * 

    * @return the minimum value

    */

   public double getMin() {

      return m_dMin;

   }

   /**

    * Returns the Root Mean Squared

    * 

    * @return the Root Mean Squared

    */

   public double getRMS() {

      return m_dRMS;

   }

   /**

    * Returns the standard deviation

    * 

    * @return the standard deviation

    */

   public double getStdDev() {

      return m_dStdDev;

   }

   /**

    * Returns the sum of all values

    * 

    * @return the sum of all values

    */

   public double getSum() {

      return m_dSum;

   }

   /**

    * Returns the variance

    * 

    * @return the variance

    */

   public double getVariance() {

      return m_dVariance;

   }

}

/*************************************************************

 *

 * A reduced version of Michael Thomas Flanagan's Stat Class

 * with PDFs and CDFs

 *

 * http://www.ee.ucl.ac.uk/~mflanaga/java/Stat.html

 *

 **************************************************************/

package es.unex.sextante.math.pdf;

/**

 * Statistical functions with PDFs and CDFs. Based on Michael Thomas Flanagan's Stat Class

 *

 * @author volaya

 *

 */

public class PDF {

   // GAMMA FUNCTIONS

   // Lanczos Gamma Function approximation - N (number of coefficients -1)

   private static int         lgfN     = 6;

   // Lanczos Gamma Function approximation - Coefficients

   private static double[]    lgfCoeff = { 1.000000000190015, 76.18009172947146, -86.50532032941677, 24.01409824083091,

            -1.231739572450155, 0.1208650973866179E-2, -0.5395239384953E-5 };

   // Lanczos Gamma Function approximation - small gamma

   private static double      lgfGamma = 5.0;

   // Maximum number of iterations allowed in Incomplete Gamma Function

   // calculations

   private static int         igfiter  = 1000;

   // Tolerance used in terminating series in Incomplete Gamma Function

   // calculations

   private static double      igfeps   = 1e-8;

   public static final double FPMIN    = 1e-300;

   // BETA DISTRIBUTIONS AND FUNCTIONS

   // beta distribution cdf

   public static double betaCDF(final double alpha,

                                final double beta,

                                final double limit) {

      return betaCDF(0.0D, 1.0D, alpha, beta, limit);

   }

   // beta distribution pdf

   public static double betaCDF(final double min,

                                final double max,

                                final double alpha,

                                final double beta,

                                final double limit) {

      if (alpha <= 0.0D) {

         throw new IllegalArgumentException("The shape parameter, alpha, " + alpha + "must be greater than zero");

      }

      if (beta <= 0.0D) {

         throw new IllegalArgumentException("The shape parameter, beta, " + beta + "must be greater than zero");

      }

      if (limit < min) {

         throw new IllegalArgumentException("limit, " + limit + ", must be greater than or equal to the minimum value, " + min);

      }

      if (limit > max) {

         throw new IllegalArgumentException("limit, " + limit + ", must be less than or equal to the maximum value, " + max);

      }

      return PDF.regularisedBetaFunction(alpha, beta, (limit - min) / (max - min));

   }

   // Beta function

   public static double betaFunction(final double z,

                                     final double w) {

      return Math.exp(logGamma(z) + logGamma(w) - logGamma(z + w));

   }

   // beta distribution pdf

   public static double betaPDF(final double alpha,

                                final double beta,

                                final double x) {

      return betaPDF(0.0D, 1.0D, alpha, beta, x);

   }

   // beta distribution pdf

   public static double betaPDF(final double min,

                                final double max,

                                final double alpha,

                                final double beta,

                                final double x) {

      if (alpha <= 0.0D) {

         throw new IllegalArgumentException("The shape parameter, alpha, " + alpha + "must be greater than zero");

      }

      if (beta <= 0.0D) {

         throw new IllegalArgumentException("The shape parameter, beta, " + beta + "must be greater than zero");

      }

      if (x < min) {

         throw new IllegalArgumentException("x, " + x + ", must be greater than or equal to the minimum value, " + min);

      }

      if (x > max) {

         throw new IllegalArgumentException("x, " + x + ", must be less than or equal to the maximum value, " + max);

      }

      final double pdf = Math.pow(x - min, alpha - 1) * Math.pow(max - x, beta - 1) / Math.pow(max - min, alpha + beta - 1);

      return pdf / PDF.betaFunction(alpha, beta);

   }

   // Returns a binomial mass probabilty function

   public static double binomial(final double p,

                                 final int n,

                                 final int k) {

      if (k < 0 || n < 0) {

         throw new IllegalArgumentException("\nn and k must be greater than or equal to zero");

      }

      if (k > n) {

         throw new IllegalArgumentException("\nk is greater than n");

      }

      return Math.floor(0.5D + Math.exp(PDF.logFactorial(n) - PDF.logFactorial(k) - PDF.logFactorial(n - k))) * Math.pow(p, k)

             * Math.pow(1.0D - p, n - k);

   }

   // Returns the binomial cumulative probabilty

   public static double binomialCDF(final double p,

                                    final int n,

                                    final int k) {