Я не могу сосчитать дважды мой код

Question

Сначала я хочу сказать, извините, я не программист, мне просто нужно решить этот расчет.Проблема в том, что: у меня разные параметры, один из них (D), который меняет форму (скажем, 2-100).Я хочу повторить мои вычисления (часть диаграммы) для разных (D), но я не могу добавить еще один цикл перед моим кодом.Как я могу это понять?Я показываю, там написал комментарий, цикл D запускается только один раз.D = 2.это не будет рассчитывать больше.Спасибо за помощь и ваше время.PS этот график дает мне такую ​​картинку введите описание изображения здесь

import java.awt.Color;
import java.awt.BasicStroke; 
import org.jfree.chart.ChartPanel; 
import org.jfree.chart.JFreeChart;
import org.jfree.data.xy.XYDataset; 
import org.jfree.data.xy.XYSeries; 
import org.jfree.ui.ApplicationFrame; 
import org.jfree.ui.RefineryUtilities; 
import org.jfree.chart.plot.XYPlot; 
import org.jfree.chart.ChartFactory; 
import org.jfree.chart.plot.PlotOrientation; 
import org.jfree.data.xy.XYSeriesCollection; 
import org.jfree.chart.renderer.xy.XYLineAndShapeRenderer;
public class Zmax_Ot_D_FEqOne extends ApplicationFrame {
private static final long serialVersionUID = 1L;
//Calculations
public static int A=1,A1=A+1,A2=A+2,A3=A+3,A4=A+4, 
 B=A+A,B1=B+1,B2=B+2,B3=B+3,B4=B+4
//public static int A=1,A1=2,A2=3,A3=4,A4=5, 
   B=2*A,B1=2*A1,B2=2*A2,B3=2*A3,B4=2*A4
,D=20, 
j;
//Fr=1
public static double RangeStart= 0.18, RangeEnd=0.265, RangeStep=0.005;
public static int XAxisStart=5,XAxisEnd=25, XAxisStep=5;
public static double F; 
public static double F_Starting_Value=(double)Math.round(0.009   
*1000d)/1000d;
public static double F_End_Value=((double)Math.round(1.000   
*1000d)/1000d);
public static double F_Step=((double)Math.round(0.001      *1000d)/1000d);
public static int MatrixSize=1000;
public static double [] Zclassic_A = new double [MatrixSize];
public static double [] ZFEC_A = new double [MatrixSize];
public static double [] ZFEC_A1 = new double [MatrixSize];
public static double [] ZFEC_A2 = new double [MatrixSize];
public static double [] ZFEC_A3 = new double [MatrixSize];
public static double [] ZFEC_A4 = new double [MatrixSize];
public static double [] Z_A = new double [MatrixSize];
public static double [] Z_A1 = new double [MatrixSize];
public static double [] Z_A2 = new double [MatrixSize];
public static double [] Z_A3 = new double [MatrixSize];
public static double [] Z_A4 = new double [MatrixSize];
// Factorial B и A/
public static int Facterial(int n) 
{
    int temp=1, fact=1;
    for(int i=n; i>0;i--) {
    temp=i*fact;;
    fact=temp;
    }

    return fact;
}
// PSI
public static double []Psi()
{
    double []temp = new double [MatrixSize]; 
    double [] p = new double [MatrixSize];
    //==========F=============
     for (F=((double)Math.round(F_Starting_Value*1000d)/1000d),j=0;
          F < ((double)Math.round(F_End_Value*1000d)/1000d) && 
    j<MatrixSize;
          F+=((double)Math.round(F_Step*1000d)/1000d), j++)
    {
        for (int i= A; i<= B; i++) 
        {
        temp[j]=0;
            temp [j]= Math.pow(((double)Math.round(F*1000d)/1000d), i)
                *Math.pow(1-((double)Math.round(F*1000d)/1000d),B-i)
                *((Facterial(B))/(Facterial(B-i)*Facterial(i)));
                p[j] += ((double)Math.round(temp 
    [j]*1000000000d)/1000000000d);
        }
    }
    return p;
}
 //========================================
public static double []Psi1()
{
    double []temp = new double [MatrixSize]; 
    double [] p = new double [MatrixSize];
    //==========Изменение точности=============
     for ( F=((double)Math.round(F_Starting_Value*1000d)/1000d),j=0;
             F < ((double)Math.round(F_End_Value*1000d)/1000d) && j<MatrixSize;
             F+=((double)Math.round(F_Step*1000d)/1000d), j++)
    {
        for (int i= A1; i<= B1; i++) 
        {
        temp[j]=0;
            temp [j]= Math.pow(((double)Math.round(F*1000d)/1000d), i)
                *Math.pow(1-((double)Math.round(F*1000d)/1000d),B1-i)
                *((Facterial(B1))/(Facterial(B1-i)*Facterial(i)));
                p[j] += ((double)Math.round(temp [j]*1000000000d)/1000000000d);
        }
    }
    return p;
}
//=================================================================================
public static double []Psi2()
{
    double []temp = new double [MatrixSize]; 
    double [] p = new double [MatrixSize];
    //==========Изменение точности=============
     for ( F=((double)Math.round(F_Starting_Value*1000d)/1000d),j=0;
             F < ((double)Math.round(F_End_Value*1000d)/1000d) && j<MatrixSize;
             F+=((double)Math.round(F_Step*1000d)/1000d), j++)
    {
        for (int i= A2; i<= B2; i++) 
        {
        temp[j]=0;
            temp [j]= Math.pow(((double)Math.round(F*1000d)/1000d), i)
                *Math.pow(1-((double)Math.round(F*1000d)/1000d),B2-i)
                *((Facterial(B2))/(Facterial(B2-i)*Facterial(i)));
                p[j] += ((double)Math.round(temp [j]*1000000000d)/1000000000d);
        }
    }
    return p;
}
public static double []Psi3()
{
    double []temp = new double [MatrixSize]; 
    double [] p = new double [MatrixSize];
    //==========Изменение точности=============
     for ( F=((double)Math.round(F_Starting_Value*1000d)/1000d),j=0;
             F < ((double)Math.round(F_End_Value*1000d)/1000d) && j<MatrixSize;
             F+=((double)Math.round(F_Step*1000d)/1000d), j++)
    {
        for (int i= A3; i<= B3; i++) 
        {
        temp[j]=0;
            temp [j]= Math.pow(((double)Math.round(F*1000d)/1000d), i)
                *Math.pow(1-((double)Math.round(F*1000d)/1000d),B3-i)
                *((Facterial(B3))/(Facterial(B3-i)*Facterial(i)));
                p[j] += ((double)Math.round(temp [j]*1000000000d)/1000000000d);
        }
    }
    return p;
}
//=============================================================
public static double []Psi4()
{
    double []temp = new double [MatrixSize]; 
    double [] p = new double [MatrixSize];
    //==========Изменение точности=============
     for ( F=((double)Math.round(F_Starting_Value*1000d)/1000d),j=0;
             F < ((double)Math.round(F_End_Value*1000d)/1000d) && j<MatrixSize;
             F+=((double)Math.round(F_Step*1000d)/1000d), j++)
    {
        for (int i= A4; i<= B4; i++) 
        {
        temp[j]=0;
            temp [j]= Math.pow(((double)Math.round(F*1000d)/1000d), i)
                *Math.pow(1-((double)Math.round(F*1000d)/1000d),B4-i)
                *((Facterial(B4))/(Facterial(B4-i)*Facterial(i)));
                p[j] += ((double)Math.round(temp [j]*1000000000d)/1000000000d);
        }
    }
    return p;
}
//==========End of Calculations==========================
//Charts creation===========THE QUESTION IS ABOUT THIS PART======

public Zmax_Ot_D_FEqOne( String applicationTitle, String chartTitle ) {
    super(applicationTitle);

    JFreeChart xylineChart = ChartFactory.createXYLineChart(
       chartTitle ,
       "F" ,
       "Z max ",
       createDataset() ,
       PlotOrientation.HORIZONTAL ,
       true , true , false);
    ChartPanel chartPanel = new ChartPanel( xylineChart );
    chartPanel.setPreferredSize( new java.awt.Dimension( 600, 500 ) );
    final XYPlot plot = xylineChart.getXYPlot( );

    //Line colors and width  
      XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer( );
      renderer.setSeriesPaint( 0 , Color.RED );
      renderer.setSeriesPaint( 1 , Color.GREEN );
      renderer.setSeriesPaint( 2 , Color.YELLOW );
      renderer.setSeriesPaint( 3 , Color.BLUE );
      renderer.setSeriesPaint( 4 , Color.BLACK );
      renderer.setSeriesStroke( 0 , new BasicStroke( 2.0f ) );
      renderer.setSeriesStroke( 1 , new BasicStroke( 3.0f ) );
      renderer.setSeriesStroke( 2 , new BasicStroke( 4.0f ) );
      renderer.setSeriesStroke( 3 , new BasicStroke( 5.0f ) );
      renderer.setSeriesStroke( 4 , new BasicStroke( 6.0f ) );

      plot.setRenderer( renderer ); 
      setContentPane( chartPanel ); 
}
   //==============Data input========================
private XYDataset createDataset( ) {

    final XYSeries Z= new XYSeries( "Zmax, A= "+A );
    final XYSeries Z1 = new XYSeries( "Zmax, A1= "+A1 );
    final XYSeries Z2 = new XYSeries( "Zmax, A2= "+A2 );
    final XYSeries Z3 = new XYSeries( "Zmax, A3= "+A3 );
    final XYSeries Z4 = new XYSeries( "Zmax, A4= "+A4 );

    //============= Calc===========
double [] psi=Psi();double [] psi1=Psi1();
double [] psi2=Psi2();double [] psi3=Psi3();double [] psi4=Psi4();
double temp=0.0, temp1=0.0, temp2=0.0, temp3=0.0, temp4=0.0, 
Ftemp=0.0, Ftemp1=0.0, Ftemp2=0.0, Ftemp3=0.0, Ftemp4=0.0;
//here I wnat to put and other loop for
//for(D=2;D<100;D++){
for ( F=F_Starting_Value, j=0;F<F_End_Value && j<MatrixSize;
        F+=((double)Math.round(F_Step*1000d)/1000d), j++)
      {
        //=============A==============
        Zclassic_A [j]=((double)Math.round(F*1000d)/1000d)/((D-1)*
                (1-((double)Math.round(F*1000d)/1000d))+1);
        ZFEC_A [j]=(A*psi[j])/( ((1-psi[j])*(D-1))+ B);
        Z_A[j]= ((double)Math.round(ZFEC_A[j]*1000000000d)/1000000000d)-
                ((double)Math.round(Zclassic_A[j]*1000000000d)/1000000000d);
        if (Z_A[j]>temp) 
        {
            temp=Z_A[j];    
            Ftemp=F;    
        }
        //================A1=======================
        ZFEC_A1 [j]=(A1*psi1[j])/( ((1-psi1[j])*(D-1))+ B1);
        Z_A1[j]=((double)Math.round(ZFEC_A1[j]*1000000000d)/1000000000d)
                -((double)Math.round(Zclassic_A[j]*1000000000d)/1000000000d);
        if (Z_A1[j]>temp1) 
        {
            temp1=Z_A1[j];  
            Ftemp1=F;   
        }
        //===============A2=============
        ZFEC_A2 [j]=(A2*psi2[j])/( ((1-psi2[j])*(D-1))+ B2);
        Z_A2[j]=((double)Math.round(ZFEC_A2[j]*1000000000d)/1000000000d)-
                ((double)Math.round(Zclassic_A[j]*1000000000d)/1000000000d);
        if (Z_A2[j]>temp2)
        {
            temp2=Z_A2[j];  
            Ftemp2=F;   
        }
        //===============A3=============
        ZFEC_A3 [j]=(A3*psi3[j])/( ((1-psi3[j])*(D-1))+ B3);
        Z_A3[j]=((double)Math.round(ZFEC_A3[j]*1000000000d)/1000000000d)-
                ((double)Math.round(Zclassic_A[j]*1000000000d)/1000000000d);
        if (Z_A3[j]>temp3) 
        {
            temp3=Z_A3[j];  
            Ftemp3=F;   
        }

     //===============A4=============
            ZFEC_A4 [j]=(A4*psi4[j])/( ((1-psi4[j])*(D-1))+ B4);
            Z_A4[j]=((double)Math.round(ZFEC_A4[j]*1000000000d)/1000000000d)-
                    ((double)Math.round(Zclassic_A[j]*1000000000d)/1000000000d);
            if (Z_A4[j]>temp4) 
            {
                temp4=Z_A4[j];  
                Ftemp4=F;   
            }
        }
    Z.add( ((double)Math.round(Ftemp*1000d)/1000d) , 
        ((double)Math.round(temp *100000000d)/100000000d));
    Z1.add( ((double)Math.round(Ftemp1*1000d)/1000d) , 
        ((double)Math.round(temp1 *100000000d)/100000000d));
    Z2.add( ((double)Math.round(Ftemp2*1000d)/1000d) , 
        ((double)Math.round(temp2 *100000000d)/100000000d));
    Z3.add( ((double)Math.round(Ftemp3*1000d)/1000d) , 
        ((double)Math.round(temp3 *100000000d)/100000000d));
    Z4.add( ((double)Math.round(Ftemp4*1000d)/1000d) , 
        ((double)Math.round(temp4 *100000000d)/100000000d));
    //============================================================
          //Data output 
        final XYSeriesCollection dataset = new XYSeriesCollection( );          
        dataset.addSeries( Z );  
        dataset.addSeries( Z1 );
        dataset.addSeries( Z2 );
        dataset.addSeries( Z3 );
        dataset.addSeries( Z4 );
        return dataset; 
    }
   //======================End of Chart========================
   //==========================================
   public static void main( String[ ] args )
   {
       Zmax_Ot_D_FEqOne chart = new Zmax_Ot_D_FEqOne("",
              "Max Z");
      chart.pack( );          
      RefineryUtilities.centerFrameOnScreen( chart );          
      chart.setVisible( true );
   }
}>

Answer 1

Очень простой принцип в программировании: СУХОЙ (не повторяйся).Хотя я абсолютно не знаю, что конкретно делает ваш расчет, вполне очевидно, что вы вычисляете одни и те же вещи снова и снова.Вместо того, чтобы копировать свой код и просто изменять аргумент цикла for (и один аргумент в вызове Math.pow -функции), вы можете просто написать для этого дополнительную функцию:

public static double []psi(int aParameter, int bParameter) {
    double []temp = new double [MatrixSize]; 
    double [] p = new double [MatrixSize];
    //==========Изменение точности=============
     for ( F=((double)Math.round(F_Starting_Value*1000d)/1000d),j=0;
             F < ((double)Math.round(F_End_Value*1000d)/1000d) && j<MatrixSize;
             F+=((double)Math.round(F_Step*1000d)/1000d), j++)
    {
        for (int i= aParameter; i<= bParameter; i++) 
        {
        temp[j]=0;
            temp [j]= Math.pow(((double)Math.round(F*1000d)/1000d), i)
                *Math.pow(1-((double)Math.round(F*1000d)/1000d),bParameter-i)
                *((Facterial(bParameter))/(Facterial(bParameter-i)*Facterial(i)));
                p[j] += ((double)Math.round(temp [j]*1000000000d)/1000000000d);
        }
    }
    return p;
}

КонечноВы должны выбрать более описательные имена параметров, чем aParameter и bParameter, в зависимости от того, что они представляют.

Вы можете применить тот же принцип почти ко всем другим частям вашего кода.Тем не менее, поскольку не моя задача полностью решить вашу проблему, я оставлю все остальное вам.Если у вас есть еще вопросы, просто спросите.