Numerical Analysis - hw#2

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.*;

public class hw {
  static ArrayList<Double> r = new ArrayList<Double>();
    public static void main(String[] args) throws IOException {
        prepare();
    }

    public static double error (double[] a,ArrayList<Double> dataX, ArrayList<Double> dataY){
        int m = a.length-1;
        int n = dataX.size();
        double sum = 0;
        for (int i=0; i<n; i++){
            double delta = dataY.get(i) - p(a,dataX.get(i));
            sum += Math.pow(delta,2);
        }
        sum =sum/(n+m-1);
        return sum;
    }

    public static double p(double[] a, double x){
        int n =a.length;
        double sum =0;
        double xe = 1;
        for(int i=0; i<n; i++){
            sum += a[i]*xe;
            xe *= x;
        }
        return sum;
    }

    public static double[] elimination(double[][] A, double[] b) {
        int n = A.length;
        for (int k = 0; k < n; k++) {
            for (int i = k + 1; i < n; i++) {
                double ch = A[i][k] / A[k][k];
                for (int j = k; j < n; j++)
                    A[i][j] -= ch * A[k][j];
                b[i] -= ch * b[k];
            }
        }

        double[] x = new double[n];
        for (int i = n - 1; i >= 0; i--) {
            double sum = 0;
            for (int j = i + 1; j < n; j++) {
                sum += A[i][j] * x[j];
            }
            x[i] = (b[i] - sum) / A[i][i];
        }
        return x;
    }

    public static void prepare() throws IOException {
        FileReader file = new FileReader("Data.txt");
        FileWriter fileRead = new FileWriter("result.txt");
        FileWriter fileFunc = new FileWriter("bestFun.txt");
        Scanner in = new Scanner(file);
        String f = in.nextLine();
        ArrayList<Double> x = new ArrayList<Double>();
        ArrayList<Double> y = new ArrayList<Double>();
        while (in.hasNext()) {
            x.add(in.nextDouble());
            y.add(in.nextDouble());
        }

        double[] xn = new double[x.size()];
        double[] yn = new double[y.size()];
        for (int i = 0; i < x.size(); i++) {
            xn[i] = x.get(i);
            yn[i] = y.get(i);
        }

    for (double s = 0.72; s < 12.1339; s += 0.05){
      System.out.println(lagrangeFormula(s, xn, yn));
    }
        for (double s = 0.72; s < 12.1339; s += 0.0001){
            double result =dividedDifference(s, xn, yn);
            r.add(result);
            System.out.println(s+" "+result);
            fileRead.write(s+" "+result+"\r\n");
            fileRead.flush();
        }

        int m=1;
        double[] a =leastSquare(x, y ,m);
        double minErr =error(a,x,y);
        m++;
        do{
            double[] curA =leastSquare(x,y,m);
            double curErr =error(curA, x, y);
            System.out.println("degree: "+ (m-1) + ", error: " + curErr);
            if(minErr > 2* curErr || minErr>0.1){
                minErr =curErr;
                a =curA;
                m++;
            }
            else
                break;
        }while(m<50);

        System.out.print("best function\n");
        fileFunc.write("best function\r\n");
        fileFuncOut.flush();
        for (int i = a.length-1; i>=0; i--) {
            System.out.printf("x^%s: %.15f\n",i,a[i]);
            fileFunc.write(String.format("x^%s: %.15f\r\n",i,a[i]));
            fileFunc.flush();
        }

    }

    public static double lagrangeFormula(double x, double[] xnext, double[] ynext) {
        int n = xnext.length;
        double[] xntern = new double[n];
        for (int i = 0; i <= n - 1; i++) {
            double upper = 1;
            double lower = 1;
            // upper
            for (int j = 0; j <= n - 1; j++) {
                if (i != j)
                    upper *= (x - xnext[j]);
            }
            // lower
            for (int j = 0; j <= n - 1; j++) {
                if (i != j)
                    lower *= (xnext[i] - xnext[j]);
            }
            xntern[i] = ynext[i] * upper / lower;
        }

        double sum = 0;
        for (int i = 0; i <= n - 1; i++)
            sum += xntern[i];

        return sum;
    }

    public static double dividedDifference(double x, double[] xnext, double[] ynext) {
        int n = xnext.length;
        double m[][] = new double[n][n];

        for (int i = 0; i < n; i++)
            m[i][0] = ynext[i];

        for (int j = 1; j < n; j++) {
            for (int i = 0; i < n - j; i++)
                m[i][j] = (m[i + 1][j - 1] - m[i][j - 1]) / (xnext[i + j] - xnext[i]);
        }

        double sum = 0;
        for (int i = n - 1; i > 0; i--) {
            sum = sum + m[0][i];
            sum = sum * (x - xnext[i - 1]);
        }
        sum += m[0][0];

        return sum;

    }

    public static double[] leastSquare(ArrayList<Double> dataX, ArrayList<Double> dataY, int m) {

        ArrayList<Double> x = new ArrayList<Double>();
        ArrayList<Double> y = new ArrayList<Double>();
        for (int i = 0; i < 2*m + 1; i++){
            x.add(0.0);
        }

        for (int i = 0; i < m + 1; i++){
            y.add(0.0);
        }


        for (int i = 0; i < dataX.size(); i++) {
            double xe = 1.0;
            double ye = dataY.get(i);
            double curX = dataX.get(i);
            double temp;
            temp = x.get(0);
            x.set(0, temp + xe);
            temp = y.get(0);
            y.set(0, temp + ye);

            for (int j = 1; j < m*2+1; j++) {
                xe *= curX;
                ye *= curX;
                if(j < m+1){
                    temp = y.get(j);
                    y.set(j, temp + ye);
                }
                temp = x.get(j);
                x.set(j, temp + xe);
            }
        }

        double[][] matrix =new double[m+1][m+1];
        double[] constant  =new double[m+1];
        for (int i = 0; i < m+1; i++) {
            for (int j = i; j < i+m+1; j++){
                matrix[i][j-i] = x.get(j);
            }
            constant[i] = y.get(i);
        }
        double[] a = elimination(matrix, constant);
        return a;
    }

}