moze byc?

package funkcje_sklejane;


import java.util.ArrayList;


class Punkt {

    double x, y;

    Punkt(double x, double y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public String toString() {
        return "(" + x + "," + y + ")";
    }

}
public class Funkcje_sklejane {

    public static void main(String[] args) {

        //mój przyklad
        Punkt punkt1 = new Punkt(-4, 444);
        Punkt punkt2 = new Punkt(-2, 32);
        Punkt punkt3 = new Punkt(0, 4);
        Punkt punkt4 = new Punkt(2, 0);
        Punkt punkt5 = new Punkt(4, 92);

        Punkt pochodna1 = new Punkt(-4, -404);
        Punkt pochodna2 = new Punkt(4, 124);

        interpolacja nowa_interpolacja = new interpolacja();
         nowa_interpolacja.ustawN(5);
         nowa_interpolacja.ustawX(1);
         nowa_interpolacja.punkty.add(punkt1);
         nowa_interpolacja.punkty.add(punkt2);
         nowa_interpolacja.punkty.add(punkt3);
         nowa_interpolacja.punkty.add(punkt4);
         nowa_interpolacja.punkty.add(punkt5);
         nowa_interpolacja.pochodne.add(pochodna1);
         nowa_interpolacja.pochodne.add(pochodna2);

         nowa_interpolacja.inicjalizacja();
         nowa_interpolacja.WyświetlTaby();
         nowa_interpolacja.Eliminacja_Gaussa();


        for (int i = 0; i <  nowa_interpolacja.pobierzWektor().length; i++)
            System.out.println( nowa_interpolacja.pobierzWektor(i));

            System.out.println();
            System.out.println("mój wynik wynosi: " +  nowa_interpolacja.Wyniki());
    }

}



class interpolacja {

    private double[] wektory;
    private double[][] tablica;
    private int n;
    private double x;
    private double[][] Alfy;
    private double[][] różnice;
    private double[] wolne;

    private static final double E = 1e-10;
    private int pomocnicza = 0;

    ArrayList<Punkt> punkty = new ArrayList<>();
    ArrayList<Punkt> pochodne = new ArrayList<>();

   //



    double[] pobierzWektor() {
        return wektory;
    }

    double pobierzWektor(int i) {
        return wektory[i];
    }

     void ustawN(int n) {
        this.n = n;
    }


    void ustawX(double x) {
        this.x = x;
    }

    void inicjalizacja() {
        tablica = new double[n + 2][2 + n];
        Alfy = new double[n - 1][n - 1];
        różnice = new double[2][3 + n - 2];
        wolne= new double[n + 2];
        wektory = new double[n + 2];
        WypełnienieTablic();
    }



    private void Wypełnianie_Alf() {
        for (int i = 0; i < Alfy.length; i++) {
            for (int j = 0; j < Alfy.length; j++) {
                if (j <= i) {
                    Alfy[i][j] = Math.pow(punkty.get(i).x - punkty.get(j).x, 3);
                } else {
                    Alfy[i][j] = 0;
                }

            }
        }

    }

    private void wypełnienie_różnice() {
        for (int i = 0; i < różnice.length; i++) {
            for (int j = 0; j < różnice[i].length; j++) {
                if (j < 3) {
                    różnice[i][j] = (j + 1) * Math.pow(pochodne.get(i).x, j);
                } else {
                    różnice[i][j] = 0;
                }
            }
        }

    }

    private void WypełnienieRóżnic() {
        for (int i = 0; i < różnice.length; i++) {
            for (int j = 3; j < różnice[i].length; j++) {
                if (i == 1) {
                    różnice[i][j] = 3 * Math.pow(pochodne.get(1).x - punkty.get(j - 2).x, 2);
                }
            }
        }

    }

    private void wypelnianieTablic() {
        int pomocnicza;
        for (int i = 0; i < tablica.length; i++) {
            if (i < n) {
                tablica[i][0] = 1;
            } else {
                tablica[i][0] = 0;
            }
        }

        for (int i = 0; i < n; i++) {
            for (int j = 1; j <= 3; j++) {
                tablica[i][j] = Math.pow(punkty.get(i).x, j);
            }

        }

        for (int i = 1; i <= Alfy.length; i++) {

            pomocnicza = 0;
            for (int j = n-1; j < tablica.length; j++) {
                tablica[i][j] = Alfy[i - 1][pomocnicza];
                pomocnicza++;
            }

        }

        for (int i = n; i < tablica.length; i++) {
            System.arraycopy(różnice[i - n], 0, tablica[i], 1, tablica.length - 1);

        }
    }

    private void wypełnianieWolnych() {
        for (int i = 0; i < wolne.length; i++) {

            if (i < n) {
                wolne[i] = punkty.get(i).y;
            } else {
                wolne[i] = pochodne.get(pomocnicza).y;
                pomocnicza++;
            }
        }

    }

    private void WypełnienieTablic() {

        Wypełnianie_Alf();
        wypełnienie_różnice();
        WypełnienieRóżnic();
        wypelnianieTablic();
        wypełnianieWolnych();
    }

        private void WyswietlTablice() {
        for (double[] TablicaA : tablica) {
            for (double TablicA : TablicaA) {
                System.out.print(TablicA + " ");
            }
            System.out.println();
        }

    }

    private void WyswietlWolne() {
        System.out.println();
        for (double Wolne : wolne) {
            System.out.print(Wolne + " ");
        }

    }
    void WyświetlTaby() {
        WyswietlTablice();
        WyswietlWolne();
    }
       void Eliminacja_Gaussa() {
        int N = wolne.length;

        for (int a = 0; a < N; a++) {

            int maximum = a;
            for (int i = a + 1; i < N; i++) {
                if (Math.abs(tablica[i][a]) > Math.abs(tablica[maximum][a])) {
                    maximum = i;
                }
            }
            double[] temp = tablica[a];
            tablica[a] = tablica[maximum];
            tablica[maximum] = temp;
            double t = wolne[a];
            wolne[a] = wolne[maximum];
            wolne[maximum] = t;

            if (Math.abs(tablica[a][a]) <= E) {
                throw new RuntimeException("Tablica jednowymiarowa");
            }

            for (int i = a + 1; i < N; i++) {
                double alpha = tablica[i][a] / tablica[a][a];
                wolne[i] = wolne[i]- (alpha * wolne[a]);
                for (int j = a; j < N; j++) {
                    tablica[i][j] = tablica[i][j]- (alpha * tablica[a][j]);
                }
            }
        }

        for (int i = N - 1; i >= 0; i--) {
            double suma = 0.0;
            for (int j = i + 1; j < N; j++) {
                suma =suma + (tablica[i][j] * wektory[j]);
            }
            wektory[i] = (wolne[i] - suma) / tablica[i][i];
        }

    }

    double Wyniki() {
        double wynik = 0;
        int pomocnicza = 0;

        for (int i = 0; i < 4; i++) {
            wynik = wynik + wektory[i] * Math.pow(x, i);
        }

        for (int i = 1; i <= n -1; i++) {
            if (x >= punkty.get(i).x) {
                wynik = wynik + wektory[4 + pomocnicza] * Math.pow(x - punkty.get(i).x, 3);
            }
            pomocnicza++;
        }

        return wynik;
    }
 }