龙贝格算法的java实现

• *可以将步骤合一实现，在求Tn的后面，每增加一个Tn 就可以增加一个Sn每增加一个Sn就可以增加一个Rn，由于前面两项后面产生一项，可以对每一个序列进行一个flag标记，初始标记为0当标记大于1
  的时候，每增加一个前面的序列值，后面就会增加一个，依次类推，写成一个在不超过精度的最简算法，节省空间，一步达成，这里分开写

最后给出代码优化的思路，

**

引用注明来源，请勿抄袭！！！

package 龙贝格算法;

import java.util.ArrayList;
import java.util.Scanner;


public class Rebom {
    //math.e x
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入Tn的长度");
        int n = scanner.nextInt();

        double[] orgin = {0,1};
        double[] Tn = new double[n];
        double[] Sn = new double[n-1];
        double[] Cn = new double[n-2];
        double[] Rn = new double[n-3];




        ComplexTrapezoids(orgin, Tn);
        Sn=Sn(Tn);
        Cn= Cn(Sn);
        Rn = Rn(Cn);

        System.out.println("Tn序列");
        for (int i = 0; i < Tn.length; i++) {
            System.out.println(Tn[i]);


        } System.out.println("Sn序列");
        for (int i = 0; i < Sn.length; i++) {
            System.out.println(Sn[i]);


        } System.out.println("Cn序列");
        for (int i = 0; i < Cn.length; i++) {
            System.out.println(Cn[i]);


        } System.out.println("Rn序列");
        for (int i = 0; i < Rn.length; i++) {
            System.out.println(Rn[i]);


        }
        System.out.println("4/（1+x*x）在 0 -1 上的积分最终是"+Rn[Rn.length-1]);

    }

    
    public  static  void ComplexTrapezoids(double[]orgin,double []Tn) {
        Tn[0]=(Fun(orgin[0])+Fun(orgin[1]))*(orgin[1]-orgin[0])/2;
        ArrayList arrayList = MiddleInsertDot(orgin);
        for (int i = 1; i   MiddleInsertDot(double [] doubles) {
        double [] value =new double [doubles.length*2-1];
        double []returnvalue = new double[doubles.length-1];

        //新产生的值被保存了

        for (int i = 0; i < doubles.length-1; i++) {
            returnvalue[i]=(doubles[i]+doubles[i+1])/2;
        }
//

        for (int i = 0; i < doubles.length; i++) {
            value[i*2]=doubles[i];




        }
        for (int i = 1; i < doubles.length; i++) {
            value[i*2-1]=returnvalue[i-1];
        }


        ArrayList arrayList = new ArrayList<>();
        arrayList.add(returnvalue);
        arrayList.add(value);

        return arrayList;

    }



    // 返回函数值

    

    public static  double Fun(double x) {
        double y=0;
        y=4/(1+x*x);//需要修改的函数部分实现任意函数积分
        return y;
    }

    public static double[] Sn(double [] Tn ){
        double [] Sn=new double[Tn.length-1];
        for (int i = 0; i < Sn.length; i++) {
            Sn[i] =(4*Tn[i+1]-Tn[i])/3;


        }
        return Sn;
    }
    public static double[] Cn(double [] Sn ){
        double [] Cn=new double[Sn.length-1];
        for (int i = 0; i < Sn.length-1; i++) {
            Cn[i] =(4*4*Sn[i+1]-Sn[i])/15;


        }
        return Cn;
    }
    public static double[]Rn(double [] Cn ){
        double [] Rn=new double[Cn.length-1];
        for (int i = 0; i < Cn.length-1; i++) {
            Rn[i] =(4*4*4*Cn[i+1]-Cn[i])/63;


        }
        return Cn;
    }

}

import java.util.Scanner;


public class IteratorCode3 {
    public static void main(String[] args) {
        int n;
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输出首项数组队列长度");
        n =scanner.nextInt();
        int S1[] = new int[n];
        int S2[] = new int[n-1];
        int S3[] = new int[n-2];
        int S4[] = new int[n-3];
        IteratorCode33(S1,S2,S3);

        for (int i = 0; i < S3.length; i++) {
            System.out.println(S3[i]);
        }


    }

    public static  void IteratorCode33(int[] S1,int [] S2 ,int [] S3) {
        int i1=0;
        int i2=0;
        int i3=0;


       loop: for (; i1 < S1.length; i1++) {
            S1[i1]=i1;

              loop1:  for (; i2 < S2.length; i2++) {
                    if (i1 - i2 == 1) {
                        S2[i2] = (S1[i1] + S1[i1 - 1]);
                        for (;i3 
参考该算法
 这样可以使得龙贝格算法的迭代顺序唯一且有效，在求出有效的精度之后就停止，不会产生多于的序列值，