Intersezione tra rette [JAVA]

[Ki11aTom]

Salve a tutti!
Il frammento di codice seguente

p.setY((float)(-(this.a*c/(a+this.c))/(this.b-(this.a*b)/a))); 
p.setX((float)((c-(b*(-(this.a*c/(a+this.c))/(this.b-(this.a*b)/a))))/a));

dovrebbe calcolare il punto di intersezione tra 2 rette. Il problema è che quando lo vado a stampare nel main mi dice sempre Infinity, Perchè? sapreste aiutarmi o magari dirmi se sbaglio a calcolarlo? Grazie in anticipo.

[Patrick Jane]

Se postassi tutto il codice sarebbe meglio...

[zipangulu]

Considerando il codice da te postato non si può dire molto anzi..
Per prima cosa ti suggerisco di postare tutto il codice o perlomeno tutto ciò che ne faciliti la comprensione , in secondo luogo ragioniamo cu cosa possa dare infinito:
Trattandosi di frazioni (dal tuo codice posso solo notare questo) i casi che danno infinito sono 2:
-il numeratore è infinito (dubito fortemente sia questo il caso)
-il denominatore della frazione è zero
Secondo me è proprio quest'ultimo il caso , supponendo che le variabili che compaiono nel codice siano variabili intere , quindi divisione tra interi --> risultato intero , dando un valore decimale compreso tra 0 e 1 che castato a int è arrotondato a zero , effettuando la divisione si ha n/0 = infinity

[Ki11aTom]

Questa è la classe retta e il metodo in questione è "Intersezione"

public class Retta {
    //private double m;
    //private double q;
    private float a;
    private float b;
    private float c;
    private float m;
    private float q;

    public Retta(float p1, float p2, float p3) {
        a = p1;
        b = p2;
        c = p3;
       
    }
     public Retta() {
        a=-1;
        b=1;
        c=0;
       
    }

    public float getA() {
        return a;
    }

    public float getB() {
        return b;
    }

    public float getC() {
        return c;
    }

    public void setA(float a) {
        this.a = a;
    }

    public void setB(float b) {
        this.b = b;
    }

    public void setC(float c) {
        this.c = c;
    }
    /**Retta parallela alla retta passante per il punto P ritorna la retta
     */ 
    public Retta Parallela(Punto p) {
        
        Retta r=new Retta();
        r.setA(this.a);
        r.setB(this.b);
        r.setC((-this.b*p.getY()-this.a*p.getX())); //y - y1 = m(x - x1)
        return r; 
    }
    /**Retta perpendicolare alla retta passante per il punto P ritorna la retta
     */
    public Retta Perpendicolare(Punto p) {
        Retta r=new Retta();
        r.setA(-this.a);
        r.setB(this.b);
        r.setC(-this.a*p.getX()+this.b*p.getY());
        return r;
    }
    /**Intersezione tra 2 rette viene ritornato il Punto di intersezione
     */
    public Punto Intersezione(Retta r) throws IOException {
        Punto p=new Punto();

        if((-this.a/this.b)!=(a/b)) {

           p.setY((float)(-((this.a*c)/(a+this.c))/(this.b-(this.a*b)/a)));
           p.setX((float)((c-(b*p.getY()))/a));
          
        }else {
            System.out.println("Rette parallele impossibile calcolare punto di intersezione");
        }
        
        return p;
    }
    /**Intersezione con l'asse X
     */
    public Punto IntersezioneAsseX() {
          Punto p=new Punto();
          p.setX((float)(-this.c/this.a));
          p.setY(0);
          return p;
    }
    /**Intersezione con l'asse Y
     */
    public Punto IntersezioneAsseY() {
          Punto p=new Punto();
          p.setX(0);
          p.setY((float)(-this.c/this.b));
          return p;
    }
    
}

Richiamo il metodo intersezione dal main attraverso il seguente frammento:

                    Tastiera t5=new Tastiera();
                    Retta r8=new Retta();
                    Punto p13=new Punto();
                    System.out.println("Inserisci A: ");
                    r8.setA(t5.inputFloat());
                    System.out.println("Inserisci B: ");
                    r8.setB(t5.inputFloat());
                    System.out.println("Inserisci C: ");
                    r8.setC(t5.inputFloat());
                    p13=r8.IntersezioneAsseY();
                    System.out.println(p13.getX());
                    System.out.println(p13.getY());

La classe punto ha la x e la y del punto di tipo float

Ecco il codice più completo.

[Andrea1979]

Forse hai qualche errore nelle formule...

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package html.exercise;

/**
 *
 * @author Andrea
 */

class CustomGeometricException extends Exception {
    
    public CustomGeometricException() {
        super();
    }
    
    public CustomGeometricException (String err) {
        super(err);
    }
}
class Point {
    private double x, y;
    
    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }
    
    public Point() {
        this(0,0);
    }
    
    public double getX() {
        return this.x;
    }
    
    public double getY() {
        return this.y;
    }
    
    public void setX(double x) {
        this.x = x;
    }
    
    public void setY(double y) {
        this.y = y;
    }
    
    public String toString() {
        return "( "+x+" ; "+y+" )";
    }
}

class Retta {
    double a,b,c;
    double m,q;
        
    public Retta(double a, double b, double c) {
        this.a = a;
        this.b = b;
        this.c = c;
        
        m = (b == 0 ? Double.POSITIVE_INFINITY : -a/b);
        q = (b == 0 ? Double.NaN : -c/b);
    }
    
    public double getA() {
        return this.a;
    }
    
    public double getB() {
        return this.b;
    }
    
    public double getC() {
        return this.c;
    }
    
    public Point intersezione(Retta r) throws CustomGeometricException {
        double det = a*r.getB()-b*r.getA();
        if (det == 0) {
            throw new CustomGeometricException("Rette parallele");
        }
        double int_x = -(c*r.getB()-b*r.getC())/det;
        double int_y = (c*r.getA()-a*r.getC())/det;
        return new Point(int_x, int_y);
    }
    
}

public class Esercizio01 {
    
    public static void main (String[] args) {
        Retta r1 = new Retta(1,1,-1);
        Retta r2 = new Retta(-1,1,0);
        //Retta r2 = new Retta(1,1,0); - è parallala a r1
        
        try {
            System.out.println("Intersezione r1 / r2: "+r1.intersezione(r2));
        }
        catch (CustomGeometricException e) {
            e.printStackTrace();
        }
                
    }
    
}

Con le limitazioni del caso (calcolo in virgola mobile e perdita di precisione)

[Ki11aTom]

Risolto!!! Grazie Andrea! il problema non era nella formula ma nell'accesso alla retta r che gli passavo, non facevo r.getA() ma mettevo solo a per cui a inizializzato a 0 mi ritornava infinity perchè dividevo per 0!

Grazie ancora!!