Projeção Linear em Java

/// <summary>
    /// Finds the Gradient using the Least Squares Method
    /// </summary>
    /// <returns>The y intercept of a trendline of best fit through the data X and Y</returns>
    public decimal LeastSquaresGradient()
    {

        //The DataSetsMatch method ensures that X and Y 
        //(both List<decimal> in this situation) have the same number of elements
        if (!DataSetsMatch())
        {
            throw new ArgumentException("X and Y must contain the same number of elements");
        }

        //These variables are used store the variances of each point from its associated mean
        List<decimal> varX = new List<decimal>();
        List<decimal> varY = new List<decimal>();

        foreach (decimal x in X)
        {
            varX.Add(x - AverageX());
        }
        foreach (decimal y in Y)
        {
            varY.Add(y - AverageY());
        }

        decimal topLine = 0;
        decimal bottomLine = 0;

        for (int i = 0; i < X.Count; i++)
        {
            topLine += (varX[i] * varY[i]);
            bottomLine += (varX[i] * varX[i]);
        }

        if (bottomLine != 0)
        {
            return topLine / bottomLine;
        }
        else
        {
            return 0;
        }
    }

    /// <summary>
    /// Finds the Y Intercept using the Least Squares Method
    /// </summary>
    /// <returns>The y intercept of a trendline of best fit through the data X and Y</returns>
    public decimal LeastSquaresYIntercept()
    {
        return AverageY() - (LeastSquaresGradient() * AverageX());
    }



    /// <summary>
    /// Averages the Y.
    /// </summary>
    /// <returns>The average of the List Y</returns>
    public decimal AverageX()
    {
        decimal temp = 0;
        foreach (decimal t in X)
        {
            temp += t;
        }

        if (X.Count == 0)
        {
            return 0;
        }
        return temp / X.Count;
    }

    /// <summary>
    /// Averages the Y.
    /// </summary>
    /// <returns>The average of the List Y</returns>
    public decimal AverageY()
    {
        decimal temp = 0;
        foreach (decimal t in Y)
        {
            temp += t;
        }

        if (Y.Count == 0)
        {
            return 0;
        }

        return temp / Y.Count;
    }

public List<BigDecimal> xarray = new ArrayList<BigDecimal>();
	public List<BigDecimal> yarray = new ArrayList<BigDecimal>();
	
	public void teste() {
		
		xarray.add(new BigDecimal(-9));
		yarray.add(new BigDecimal(13.7));

		System.out.println(leastSquaresGradient()); // 0

		xarray.add(new BigDecimal(-10));
		yarray.add(new BigDecimal(14.52));
		System.out.println(leastSquaresGradient()); // -0.[telefone removido]

		xarray.add(new BigDecimal(-9));
		yarray.add(new BigDecimal(14.41));
		System.out.println(leastSquaresGradient()); // -0.[telefone removido]

		xarray.add(new BigDecimal(-4));
		yarray.add(new BigDecimal(13.67));
		System.out.println(leastSquaresGradient()); // -0.[telefone removido]

		xarray.add(new BigDecimal(-5));
		yarray.add(new BigDecimal(14.29));
		System.out.println(leastSquaresGradient()); // -0.[telefone removido]
		
		
		
	}
	
	
	/**
	 * Cálculo Gradient 
	 * @return
	 */
	
	public BigDecimal leastSquaresGradient() {

		// Variáveis utilizadas para guardar as variancias de cada ponto de sua
		// média
		List<BigDecimal> varX = new ArrayList<BigDecimal>();
		List<BigDecimal> varY = new ArrayList<BigDecimal>();

		for (BigDecimal x : xarray) {
			varX.add(x.subtract(averageX()));
		}
		for (BigDecimal y : yarray) {
			varY.add(y.subtract(averageY()));
		}

		BigDecimal topLine = BigDecimal.ZERO;
		BigDecimal bottomLine = BigDecimal.ZERO;

		for (int i = 0; i < xarray.size(); i++) {
			topLine = topLine.add(varX.get(i).multiply(varY.get(i)));
			bottomLine = bottomLine.add(varX.get(i).multiply(varX.get(i)));
		}

		if (bottomLine.compareTo(BigDecimal.ZERO)!=0) {
			return topLine.divide(bottomLine,10,RoundingMode.FLOOR);
		} else {
			return BigDecimal.ZERO;
		}
	}
	
	/**
	 * Intercept Y
	 * @return
	 */
	
	public BigDecimal leastSquaresYIntercept() {
		return averageY().subtract(leastSquaresGradient().multiply(averageX()));
	}

	/**
	 * Média de X
	 * 
	 * @return média do array xarray
	 */
	public BigDecimal averageX() {
		BigDecimal temp = BigDecimal.ZERO;
		for (BigDecimal t : xarray) {
			temp = temp.add(t);
		}

		if (xarray.size() == 0) {
			return BigDecimal.ZERO;
		}
		return temp.divide(BigDecimal.valueOf(xarray.size()),10,RoundingMode.FLOOR);
	}

	/**
	 * Média de Y
	 * 
	 * @return média do array yarray
	 */

	public BigDecimal averageY() {

		BigDecimal temp = BigDecimal.ZERO;
		for (BigDecimal t : yarray) {
			temp = temp.add(t);
		}

		if (yarray.size() == 0) {
			return BigDecimal.ZERO;
		}
		return temp.divide(BigDecimal.valueOf(yarray.size()),10,RoundingMode.FLOOR);
	}

* Se a estatística for VERDADEIRO, PROJ.LIN devolve a estatística de regressão adicional, de forma a que a matriz devolvida seja {mn,mn-1,...,m1,b;sen,sen-1,...,se1,seb;r2,sey;F,df;ssreg,ssresid}.

* Se a estatística for FALSO ou omitida, PROJ.LIN devolve apenas os coeficientes m e a constante b."[/i]   <---  ou seja, o índice = 1 é o valor m e 2 é a intercessão