CHM3Lab

/*Class Spline*/
package package1;

import java.util.ArrayList;
import java.util.List;
import java.util.NavigableMap;

/**
 * Created by Alexey on 08.12.2015.
 */
public class Spline {

    private double a, b;    //начало, конец
    private int N;  //кол-во узлов отрезка
    private ArrayList<Double> nodes;    //узлы интерполяции
    private ArrayList<Double> newNodes;     //узлы учащенной сетки
    private ArrayList<Double> values;   //значения функции в узлах интерполяции
    private ArrayList<Double> newValues;    //значения функции в учащенной сетке
    private ArrayList<Double> splineCafsB;   //значения коэффициентов B кубического сплайна
    private ArrayList<Double> splineCafsC;   //значения коэффициентов C кубического сплайна
    private ArrayList<Double> splineCafsD;   //значения коэффициентов D кубического сплайна
    private ArrayList<Double> alpha;    //прогоночные коэф-ты alpha и betta
    private ArrayList<Double> betta;    //прогоночные коэф-ты alpha и betta

    /*
    * Сеттеры значений a, b, N
    * */
    public void setA(int a) {
        this.a = a;
    }

    public void setB(int b) {
        this.b = b;
    }

    public void setN(int n) {
        N = n;
    }

    /*
    * Геттеры значений a, b, N
    * */
    public double getA() {
        return a;
    }

    public double getB() {
        return b;
    }

    public double getN() {
        return N;
    }

    /*
    * Деление отрезка на N частей
    * */
    public void parcing() {
        nodes = new ArrayList<>();
        for (int i = 0; i <= N; i++) {
            double temp = (double) (a + (b - a) * i / N);
            nodes.add(temp);
        }
    }

    /*
    * Деление отрезка на N частей
    * */
    public void parcingNew(){
        newNodes = new ArrayList<>();
        for (int i = 0; i <= (10*N); i++) {
            double temp = (double) (a + (b - a) * i / (10*N));
            newNodes.add(temp);
        }
    }

    /*
    * Вычисление значений функции на учащенной сетке
    * */
    public void calcValInNewNodes(){
        newValues = new ArrayList<>();
        for(Double temp : newNodes) {
            newValues.add(func(temp));
        }
    }

    /*
    * Исходная функция
    * */
    private double func(double x){
        return Math.pow(x, 2) - 5;
    }

    /*
    * Вычисление значений в узлах интерполяции
    * */
    public void calcValuesInNodes(){
        values = new ArrayList<>();
        for(Double temp : nodes) {
            values.add(func(temp));
        }
    }

    /*
    * Вывод на экран таблицы узлов и значений функции в узлах
    * */
    public void getTable(){
        for(int i = 0; i < nodes.size(); i++) {
            System.out.printf("%-10.3f", nodes.get(i));
            System.out.printf("%-10.3f", values.get(i));
            System.out.println();
        }
        System.out.println("******************************");
    }

    /*
    * Вычисление прогоночных коэф. alpha и betta
    * */
    public void alphaAndBettaCalc(){
        alpha = new ArrayList<>();
        betta = new ArrayList<>();
        alpha.add(0, (double) 0);
        betta.add(0, (double) 0);
        for (int i = 1; i < N - 1; i++) {
            double hi = nodes.get(i) - nodes.get(i-1);
            double hi1 = nodes.get(i+1) - nodes.get(i);
            double A = hi;
            double B = hi1;
            double C = 2 * (hi + hi1);
            double D = 6 * ((values.get(i+1) - values.get(i)) / hi1 - (values.get(i) - values.get(i-1)) / hi);
            double temp = (A * alpha.get(i-1) + C);
            alpha.add(-B / temp);
            betta.add((D - A * betta.get(i-1)) / temp);
        }
    }

    /*
    * Обратный ход, нахождение решения
    * */
    private void setSplineCafsC(){
        splineCafsC = new ArrayList<>();
        init(splineCafsC);
        for (int i = N - 2; i > 0; i--){
            splineCafsC.add(alpha.get(i) * splineCafsC.get(i+1) + betta.get(i));
        }
    }

    /*
    * Заполняем B коэффициенты сплайнов
    * */
    public void setSplineCafsB(){
        splineCafsB = new ArrayList<>();
        init(splineCafsB);
        for (int i = N - 1; i > 0; i--) {
            double hi = nodes.get(i) - nodes.get(i-1);
            splineCafsB.add(hi * (2.0 * splineCafsC.get(i) + splineCafsC.get(i-1) / 6.0 + (values.get(i) - values.get(i-1)) / hi));
        }
    }

    /*
    * Заполняем D коэффициенты сплайнов
    * */
    public void setSplineCafsD(){
        splineCafsD = new ArrayList<>();
        init(splineCafsD);
        for (int i = N - 1; i > 0; i--) {
            double hi = nodes.get(i) - nodes.get(i-1);
            splineCafsD.add((splineCafsC.get(i) - splineCafsC.get(i-1)) / hi);
        }
    }

    /*
    * Вычисление интерполированной функции в точке x
    * */
    private double interpolating(double x){
        alphaAndBettaCalc();
        setSplineCafsC();
        setSplineCafsB();
        setSplineCafsD();
        int index;
        if (x <= nodes.get(0)) {
            index = 0;
        } else if (x >= nodes.get(N - 1)) {
            index = N - 1;
        }
        else {
            int i = 0;
            int j = N - 1;
            while (i + 1 < j)
            {
                int k = i + (j - i) / 2;
                if (x <= nodes.get(k))
                {
                    j = k;
                }
                else
                {
                    i = k;
                }
            }
            index = j;
        }
        double dx = x - nodes.get(index);
        return values.get(index) + (splineCafsB.get(index) + (splineCafsC.get(index) / 2.0 + splineCafsD.get(index) * dx / 6.0) * dx) * dx;
    }

    /*
    * Инициализация ArrayList-ов
    * */
    private void init(List<Double> list){
        for (int i = 0; i < N; i++) {
            list.add(0.0);
        }
    }

    /*
    * Вывод максимальной погрешности
    * */
    public double getMaxEps(){
        parcingNew();
        calcValInNewNodes();
        double maxEps = -1;
        double eps = 0;
        for (int i = 0; i < 10*N; i++) {
            eps = Math.abs(newValues.get(i) - interpolating(newNodes.get(i)));
            System.out.println(eps + "\t" + "\t" + newNodes.get(i) + "\t" + "\t" + newValues.get(i));
            if (maxEps < eps){
                maxEps = eps;
            }
        }
        return maxEps;
    }

    /*
    * Вывод таблицы погрешностей на экран
    * */
    public void getEpsTable(){

    }
}
/*Class Main*/
package package1;

public class Main {

    public static void main(String[] args) {
        Spline spline = new Spline();
        spline.setA(0);
        spline.setB(2);
        spline.setN(5);
        spline.parcing();
        spline.calcValuesInNodes();
        spline.getTable();
        System.out.println(spline.getMaxEps());
    }
}