Vector y Recta.

Para empezar usaremos la clase Punto que vimos en las prácticas anteriores. Basca con arrastrarla a la carpeta src de nuestro proyecto y ya estará importada ;)

Ésta será la primera práctica donde usemos las excepciones.Aquí teneis el esquema:

La clase vector representa el vector que iría desde el origen de cordenadas (el punto (0,0) ) hasta el punto (o coordenadas del mismo) que le demos. 

En el caso de la recta, podemos darle o bien dos puntos, o bien un punto y un vector.

Nota: Para los que no lo sepan, un vector es "una flecha" que posee módulo (longitud), dirección (sobre que recta está) y sentido (dirección a la que apunta). Para más información aquí teneis el link a la wiki.

Aquí os dejo el test para probar las clases ;)

public class TestRectas {
 public static void main(String[] args) {  
                // Calcular el área del triángulo definido por sus tres vértices
  Punto p1 = new Punto(0,0);    
  Punto p2 = new Punto(4,0);
  Punto p3 = new Punto(2,3);
  // Se calcula la distancia entre p1 y p2
  double base = p1.distancia(p2);
  // Se calcula la recta que pasa por p1 y p2
  Recta r1 = new Recta(p1,p2);
  // se calcula la distancia entre p3 y r1
  double altura = r1.distanciaDesde(p3);
  // El area es base*altura/2
  double area = base*altura/2;
  System.out.printf("Puntos %s %s %s\n",p1,p2,p3);
  System.out.println("Área = "+area);
  }
 }

Y aquí tenéis las soluciones a las clases ;)

Aquí la clase Recta:

public class Recta {
 private Vector director;
 private Punto origen;
 
 public Recta(Vector v, Punto p) {
  director = v;
  origen = p;
 }
 public Recta(Punto p1, Punto p2) {

  Vector v = new Vector(p1, p2);
  director = v;
  origen = p1;
 }
 public Vector vector() {return director;}
 public Punto origen() {return origen;}
 
  public boolean pasaPor(Punto p) {
  Vector v = new Vector(origen, p);
  return director.paralelos(v);
 }
 public boolean paralelaA(Recta r) {
  return director.paralelos(r.vector());
 }
 public Recta paralelaPor(Punto p) {
  Recta r = new Recta(director, p);
  return r;
 }
 public Recta perpendicularPor(Punto p) {
  Recta r;
  Vector v = director.ortogonal();
  r = new Recta(v, p);
  return r;
 }
 public Punto interseccionCon(Recta r) {
  double d, d1, d2, x0, y0;
  Punto p;
  if (this.paralelaA(r)) {
   throw new RuntimeException("Rectas paralelas");
   }
  d = director.componenteX() * r.vector().componenteY() - 
                    director.componenteY() * r.vector().componenteX();
  if (d==0) {
   throw new RuntimeException("Rectas paralelas 
                    o coincidentes");
   }
  d1 = director.componenteX() * origen.y() - 
                    director.componenteY() * origen.x();
  d2 = r.vector().componenteX() * r.origen().y() - 
                    r.vector().componenteY() * r.origen().x();
  
  x0 = (d1 * r.vector().componenteX() - 
                    director.componenteX() * d2)/d;
  y0 = -(director.componenteY() * d2 - 
                    r.vector().componenteY() * d1)/d;
  
  p = new Punto(x0, y0);
  return p;
 }
 public double distanciaDesde(Punto p) {
  Recta perp = this.perpendicularPor(p);
  Punto comun = this.interseccionCon(perp);
  return p.distancia(comun);
 }
 
 public String toString() {
  return "R("+director + ", " + origen + ")";
 }
}

Y aquí la clase Vector.

public class Vector {
 private Punto extremo;
 
 public Vector(double x0, double y0) {
  extremo = new Punto(x0, y0);
 }
 public Vector(Punto pto) {
  extremo = pto;
 }
 public Vector(Punto inicio, Punto fin) {
  double x0, y0;
  x0 = fin.x() - inicio.x();
  y0 = fin.y() - inicio.y();
  extremo = new Punto(x0, y0);
 }

 public double componenteX() {
  return extremo.x();
 }
 public double componenteY() {
  return extremo.y();
 }
 public double modulo() {
  double sum = extremo.x()*extremo.x() + extremo.y()*extremo.y();
  return Math.sqrt(sum);
 }
 public Vector ortogonal() {
  double x,y;
  Vector ort;
  x = extremo.x();
  y = extremo.y();
  ort = new Vector(-y, x);
  return ort;
 }
 public boolean paralelos(Vector v) {
  double xExt, yExt, xV, yV;
  xExt = extremo.x();
  yExt = extremo.y();
  xV = v.componenteX();
  yV = v.componenteY();
  
  return (xExt*yV == yExt*xV);
 }
 public Punto extremoDesde(Punto pto) {
  double x0, y0, x, y;
  Punto p;
  x0 = extremo.x();
  y0 = extremo.y();
  x = x0 + pto.x();
  y = y0 + pto.y();
  p = new Punto(x,y);
  return p;
 }

 public String toString() {
  return "V("+extremo.x()+","+extremo.y()+")"; 
 }
}