Abbruchbedingung- Iteratives Verfahren

[Midorima]

Moin Moin Freunde der Sonne,

ich habe da so ein kleines Problem und verstehe nicht wirklich woran es liegen kann.
Es handelt sich um folgendes: Ich solle ein iteratives Verfahren anwenden und dieses solange durchlaufen lassen bis es eine gewisse Genauigkeit erreicht in dem Fall auf 1*10^-5
Das ganze habe ich in eine while Schleife verpackt.
Wie müsste die Abbruchbedingung lauten? Denn bei mir vergleicht er den alten Wert und neuen Wert und gibt danach nichts mehr aus obwohl sie nicht identisch sind.
Ich hoffe ihr könnt mir helfen und bedanke mich schonmal!

import java.text.*;

import java.util.Scanner;

 
public class jacobi1 {
	
	public static void main (String[] args){
	NMatrix();
	
		}

	 private static void NMatrix (){
		 
		 	System.out.println("Please enter gamma");
		    Scanner s = new Scanner(System.in);
		    double gamma;
		    gamma = s.nextDouble();
		    int Schritt = 0;
		  
		  
			// startwert x
		    double [] x1 = new double [9];
			for ( int a = 0 ; a<= 8 ;a++){
				x1[a]= 1;
				
			}
			
		    
			  // ausgangsmatrix A addiert mit gamma
			  
//			double [][] A = new double [][]{{4+gamma,-1,0,-1,0,0,0,0,0},
//											{-1,4+gamma,-1,0,-1,0,0,0,0},
//											{0,-1,4+gamma,0,0,-1,0,0,0},
//											{-1,0,0,4+gamma,-1,0,-1,0,0},
//											{0,-1,0,-1,4+gamma,-1,0,-1,0}, 
//											{0,0,-1,0,-1,4+gamma,0,0,-1},
//											{0,0,0,-1,0,0,4+gamma,-1,0},
//											{0,0,0,0,-1,0,-1,4+gamma,-1},
//											{0,0,0,0,0,-1,0,-1,4+gamma}};
			
			
			
			// L+U von A
			double [][] L_U = new double [][]{	{0,-1,0,-1,0,0,0,0,0},
												{-1,0,-1,0,-1,0,0,0,0},
												{0,-1,0,0,0,-1,0,0,0},
												{-1,0,0,0,-1,0,-1,0,0},
												{0,-1,0,-1,0,-1,0,-1,0},
												{0,0,-1,0,-1,0,0,0,-1},
												{0,0,0,-1,0,0,0,-1,0},
												{0,0,0,0,-1,0,-1,0,-1},
												{0,0,0,0,0,-1,0,-1,0}};		
			
			//inverse D von "aufgesplittenen" matrix A = L + U + D
			
			double [][] Dinv = new double [][]{	{1/(4+gamma),0,0,0,0,0,0,0,0},
												{0,1/(4+gamma),0,0,0,0,0,0,0},
												{0,0,1/(4+gamma),0,0,0,0,0,0},
												{0,0,0,1/(4+gamma),0,0,0,0,0},
												{0,0,0,0,1/(4+gamma),0,0,0,0},
												{0,0,0,0,0,1/(4+gamma),0,0,0},
												{0,0,0,0,0,0,1/(4+gamma),0,0},
												{0,0,0,0,0,0,0,1/(4+gamma),0},
												{0,0,0,0,0,0,0,0,1/(4+gamma)}};
			double [] loesung = new double [9];
			
			
			s.close();
			
			
			double [] ersteVektor = new double [9];
			double summe=0;
			double summe3=0;
			
			
			
			
			int iterations = 0;
			while(true){ 
				iterations++;
			
			// multiplikation ( (L+U)*x )
			for (int g=0;g<=8; g++) {
			    	for (int k=0;k<=8;k++) {
				    summe=summe+(L_U[g][k]*x1[k]);
			    	}
				ersteVektor[g]=summe;
				summe=0.0;	    
			}
			
			// initialisiere b 
			double [] b = new double [9];
			for ( int a = 0 ; a<= 8 ;a++){
				b[a]= 1;
				}
			
			// b-(L+U)*x
		double [] zweiterVektor = new double [9];
		for (int t=0; t<=8; t++) {
		    
			zweiterVektor[t]= b[t]-ersteVektor[t];
		}
		
		
			// D^-1 *(b-(L+U)*x)
		
		
		
		for (int o=0;o<=8; o++){
					    	
		    	for (int k=0;k<=8;k++) {
		    		
			    summe3=summe3+(Dinv[o][k]*zweiterVektor[k]);
		    	}
			loesung[o]=summe3;
			summe3=0.0;
			if(x1==loesung) break;
			Schritt++;
	    	x1=loesung;
		
			
		    
		
			
		

		
			
	    	for (int l = 0; l <= 8; ++l) {
	    		
	    		System.out.print(loesung[l] + "\t");
	    		
	    	}
	    	
	    	System.out.println(" ");	
	    			
				
	
			}// ende von while
		
	  System.out.print(Schritt + " Iterations");
	 
	
			
			
	 }
}}

 

[knilch]

Hi,
Wie wäre es wenn du so eine Prüfung machen würdest:

if((Math.abs(alterWert-neuerWert) < 1*10^-5) {
          // Resultat ist genug genau .
}
else {
   // Resultat ist noch nicht genug genau 
}

 

[Midorima]

Danke für die Antwort!

Habe das jetzt umständlicher gemacht und jedes einzelne string verglichen.

 

[arilou]

while( true )
ist eigentlich immer falsch. Was du möchtest ist doch
while( Zielgenauigkeit nicht erreicht ) {
// bestimme präziseres Ergebnis
}