计算方法(数值分析)实验：离散数据插值，离散数据拟合 拉格朗日插值法 牛顿插值法 java实现

实验目的：加深对拉格朗日插值，牛顿插值原理的理解，掌握拉格朗日插值，牛顿插值算法，加深对离散数据点拟合算法的理解，掌握法方程构建的并用程序实现。

实验要求：用程序实现课件上的拉格朗日插值和牛顿插值的两个例子。

package com.code;

import com.Service.CalculService;


public class main {
    public static void main(String[] args) {
        //CalculService.LageLangRi();
        CalculService.Newton();

    }


}

package com.Service;

import com.dao.FuncDao;

import java.util.Scanner;

public class CalculService {
    public static void LageLangRi(){
        double[] para;
        double[] fx;
        double x;
        double result = 0;
        int n;
        Scanner s = new Scanner(System.in);
        System.out.print("请输入这是几次插值：");
        n = s.nextInt();
        n += 1;
        para = new double[n];
        fx = new double[n];
        System.out.print("请依次输入x的值：");
        for (int i = 0; i < n; i++) {
            para[i] = s.nextDouble();
        }
        System.out.print("请依次输入fx的值：");
        for (int i = 0; i < n; i++) {
            fx[i] = s.nextDouble();
        }
        while (true){
            System.out.print("请输入要求的近似值x：");
            x = s.nextDouble();
            result = FuncDao.getL(x, para, fx);
            System.out.println("所求结果为：" + result);
        }
    }

    public static void Newton(){
        double[] x;
        double[] fx;
        double resultN;
        double resultL;
        double para;
        int n;
        Scanner s = new Scanner(System.in);
        System.out.print("请输入参数的个数：");
        n = s.nextInt();
        x = new double[n];
        fx = new double[n];

        System.out.print("请依次输入x的值：");
        for (int i = 0; i < n; i++) {
            x[i] = s.nextDouble();
        }

        System.out.print("请依次输入fx的值：");
        for (int i = 0; i < n; i++) {
            fx[i] = s.nextDouble();
        }

        System.out.print("请输入要求的近似值x：");
        para = s.nextDouble();


        resultN = FuncDao.getN(para,x,fx);
        resultL = FuncDao.getL(para,x,fx);

        System.out.println("拉格朗日插值法求得近似结果为：" + resultL);
        System.out.println("牛顿插值法求得近似结果为：" + resultN);

    }
}

package com.dao;


public class FuncDao {
    /**
     *
     * @param x 传入的x的值
     * @param x 数组，存放点的横坐标
     * @param fx  数组，存放点的纵坐标
     * @return
     */
    public static double getL(double para, double[] x, double[] fx){
        double result = 0;
        double oneResult = 1;
        for (int i = 0; i < x.length; i++) {
            for (int j = 0; j < x.length; j++) {
                if (i != j){
                    oneResult *= (para - x[j]) / (x[i] - x[j]);
                }
            }
            result += fx[i] * oneResult;
            oneResult = 1;
        }
        return result;
    }

    /**
     *
     * @param para 传入的x的值
     * @param x 数组，存放点的横坐标
     * @param fx  数组，存放点的纵坐标
     * @return
     */
    public static double getN(double para, double[] x, double[] fx){
        int n = x.length;
        double[] chaShang = new double[n];
        double[] chaShangAll = new double[n];
        double temp = 1;
        double result = 0;
        for (int i = 0; i < n; i++) {
            chaShang[i] = fx[i];
        }
        chaShangAll[0] = fx[0];
        for (int i = n-1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                chaShang[j] = chaShang[j+1] - chaShang[j];
                chaShang[j] /= x[n - i + j] - x[j];
            }
            //将所用的到的差商存在在chaShangAll数组
            chaShangAll[n - i] = chaShang[0];
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < i; j++) {
                temp *= para - x[j];
            }
            result += temp * chaShangAll[i];
            temp = 1;
        }
        return result;
    }

}