2 Ausgaben, aber nur 1 gewollt.

[OhMannoMann]

Hey,
ich hab folgendes Programm geschrieben, welches den abstand eines punktes r zu einer geraden pq ausrechnen soll.

//Samantha Vordermeier GOB1B

public class Dist
{
	public static void main(String... args)
	{
	
		double xp = Double.parseDouble(args[0]);
		double yp = Double.parseDouble(args[1]);
		double xq = Double.parseDouble(args[2]);
		double yq = Double.parseDouble(args[3]);
		double xr = Double.parseDouble(args[4]);
		double yr = Double.parseDouble(args[5]);
		double m;
		double t1;
		double t2;
		double xl;
		double yl;
		double Dist;
		
			if (xq - xp == 0)
					{
					Dist = Math.abs(xp - xr);
					System.out.println(Dist);
					}
			

			m = (yq - yp) / (xq - xp);	
			
			if(m == 0)
					{
					Dist = yr - yp;
					System.out.println(Dist);
					}
                  
			else if(m != 0)
					{
					t1 = yp - ((yq-yp) / (xq-xp)) * xp;
					m = (yq - yp) / (xq -xp);
					xl = (yr + xr/m - t1) / (m + 1/m);
					yl = m * xl + t1;
					Dist = Math.sqrt((xl-xr) * (xl-xr) + (yl-yr) * (yl-yr));
					System.out.println(Dist);
					}
		
		
	}
}

Sollte soweit eigentlich stimmen, allerdins bekomm ich den Abstand in einer Zeile ausgespuckt, und darunter immer NaN.

imacrakt2 Sam$ java Dist 1 11 1 4 6 9
5.0
NaN

Woher kommt die zweite ausgabe und wie krieg ich die weg?

Schon mal Dangge.....Sam

 

[Fu3L]

NaN bedeutet Not a Number. Du wirst wahrscheinlich die Wurzel aus einer negativen Zahl gezogen haben...

Edit: Wenn du die Zweite Ausgabe weghaben willst, musst du wohl die ifs und elses und else ifs so schreiben müssen, dass immer nur eine Bedingung erfüllt ist...

 

[OhMannoMann]

Hey,
wenn ich zwei quadriete zahlen addiere kanns ned negativ werden....
ich hab ja schließlich ((xl-xr) * (xl-xr) + (yl-yr) * (yl-yr)) in der wurzel stehen, und das ist immer positiv.

 

[Fu3L]

Hey,
wenn ich zwei quadriete zahlen addiere kanns ned negativ werden....
ich hab ja schließlich ((xl-xr) * (xl-xr) + (yl-yr) * (yl-yr)) in der wurzel stehen, und das ist immer positiv.

Das stimmt... (Als nicht-hobby-mathematiker is sowas echt schwer zu lesen)

Da weiß ich auch grad nicht weiter... Lass dir am besten nach jedem Rechnschritt die Werte mit System.out.println() ausgeben, dann findest du vllt die Stelle an ders dir das NaN reinhaut...

 

[OhMannoMann]

Tja, das hab ich leider alles schon probiert...
lustiger weise haut es mir das nan auch nur bei den (und denen ähnlichen) koordinaten raus, und nicht bei allen....

 

[Fu3L]

Ich glaub ich weiß worans liegt, habs mal in mein Eclipse gepackt:
Das:

t1 = yp - ((yq-yp) / (xq-xp)) * xp;
               System.out.println(t1);

spuckt mir Infinity aus. Also hast du durch 0 geteilt. Und wenn du mit Infinity weiterrechnsest erhälst du irgendwann NaN...

Edit: Die nächste Zeile spuckt -Infinity aus und die beiden danach dann NaN...

 

[Legion]

ah dreck, da war einer schneller, aber ich habs evtl genauer...

ich hab mal für dich die drecksarbeit gemacht.

public class Dist 
{ 
   public static void main(String... args) 
   { 
    
      double xp = Double.parseDouble(args[0]); 
      double yp = Double.parseDouble(args[1]); 
      double xq = Double.parseDouble(args[2]); 
      double yq = Double.parseDouble(args[3]); 
      double xr = Double.parseDouble(args[4]); 
      double yr = Double.parseDouble(args[5]); 
      double m; 
      double t1; 
      double t2; 
      double xl; 
      double yl; 
      double Dist; 
       
         if (xq - xp == 0) 
               { 
               Dist = Math.abs(xp - xr); 
               System.out.println(Dist); 
               } 
          

         m = (yq - yp) / (xq - xp);    
          
         if(m == 0) 
               { 
               Dist = yr - yp; 
               System.out.println(Dist); 
               } 
                  
         else if(m != 0) 
               { 
               t1 = yp - ((yq-yp) / (xq-xp)) * xp; 
               m = (yq - yp) / (xq -xp);                    // <--- m = NaN
               xl = (yr + xr/m - t1) / (m + 1/m); 
               yl = m * xl + t1; 
               Dist = Math.sqrt((xl-xr) * (xl-xr) + (yl-yr) * (yl-yr)); 
               System.out.println(Dist);                   // <--- Hier spuckt er NaN aus
               } 
       
       
   } 
}

ich hab dir oben die fehlerhaften stellen markiert. woran das liegt? ganz einfach:
m = (yq - yp) / (xq -xp); xp und xq sind jeweils 1 also kommt da 0 raus. durch 0 teilt man nicht.
mit ein paar System.outs hättest du das sicher auch gefunden...

 

[kowa]

Mit ein wenig Kopfrechnen gehts auch^^
Da braucht man kein eclipse für.

 

[OhMannoMann]

Hey,
erst mal Danke für die Mühe, hab mittlerweile den fehler selber gefunden.
das mit der Division durch 0 habe ich ja eigentlich mit if (xq - xp == 0) ausgeschlossen.
allerdings hätte ich das m nur weiter oben definieren müssen und alles in eine if schleife. jetzt gehts.

also sieht jetzt so aus und funzt

public class Dist 
{ 
   public static void main(String... args) 
   { 
    
      double xp = Double.parseDouble(args[0]); 
      double yp = Double.parseDouble(args[1]); 
      double xq = Double.parseDouble(args[2]); 
      double yq = Double.parseDouble(args[3]); 
      double xr = Double.parseDouble(args[4]); 
      double yr = Double.parseDouble(args[5]); 
      double m; 
      double t1; 
      double xl; 
      double yl; 
      double Dist; 


        m = (yq - yp) / (xq - xp);  

         if (xq - xp == 0) 
               { 
               Dist = Math.abs(xp - xr); 
               System.out.println(Dist); 
               } 
          
          
         else if(m == 0) 
               { 
               Dist = yr - yp; 
               System.out.println(Dist); 
               } 
                  
         else if(m != 0) 
               { 
               t1 = yp - ((yq-yp) / (xq-xp)) * xp; 
               m = (yq - yp) / (xq -xp);                    // <--- m = NaN 
               xl = (yr + xr/m - t1) / (m + 1/m); 
               yl = m * xl + t1; 
               Dist = Math.sqrt((xl-xr) * (xl-xr) + (yl-yr) * (yl-yr)); 
               System.out.println(Dist);                   // <--- Hier spuckt er NaN aus 
               } 
        
        
   } 
}

 

[Landei]

Ein wenig "Stilistik":
- Variablen immer klein schreiben (außer static final, aber das sind ja auch i.d.R. Konstanten), also nicht Dist
- der letzte Test else if(m != 0) ist überflüssig, else reicht
- Variablen erst definieren, wenn du sie brauchts, das vermeidet versehentlich Zugriffe auf nicht initialisierte Variablen. Wir machen hier schließlich kein Pascal :-D
- Versuche dich bei der Klammerung an einen Standard zu halten (der von Sun ist am verbreitetsten und nicht so übel), sonst kriegt man Augenkrebs
- In deinem Mini-Beispiel hier ist es zwar egal, aber du solltest Berechnung und Ausgabe in der Regel voneinander trennen. Hättest du eine Funktion, die dir dist ausrechnet statt ausgibt, könntest du sie einfach wiederverwenden.
- Es ist ein netter Zug, den Nutzer darauf hinzuweisen, wieviel Argumente das Programm erwartet

Ich weiß, das ist viel Nörgelei auf einmal, aber um so früher man sich daran gewöhnt, umso besser.

Über Geschmack läßt sich bekanntlich streiten, aber ich würde es in etwa so schreiben:

public class Dist {

    public static double distance(double xp, double yp, double xq, double yq, double xr, double yr) {
        if (xq - xp == 0) {
            return Math.abs(xp - xr);
        } else if (yq - yp == 0) {
            return yr - yp;
        } else {
            double t1 = yp - ((yq - yp) / (xq - xp)) * xp;
            double m = (yq - yp) / (xq - xp);
            double xl = (yr + xr / m - t1) / (m + 1 / m);
            double yl = m * xl + t1;
            return Math.sqrt((xl - xr) * (xl - xr) + (yl - yr) * (yl - yr));
        }
    }

    public static void main(String... args) {
        if (args.length != 6) {
            System.out.println("usage: java Dist <xp> <yp> <xq> <yq> <xr> <yr>");
        } else {
            System.out.println(distance(
                    Double.parseDouble(args[0]),
                    Double.parseDouble(args[1]),
                    Double.parseDouble(args[2]),
                    Double.parseDouble(args[3]),
                    Double.parseDouble(args[4]),
                    Double.parseDouble(args[5])));
        }
    }
}

 

[OhMannoMann]

danke, Stil ist mir auch wichtig