Tema: Saber si en mrua habrá alcance o nunca se encontraran
Ver Mensaje Individual
  #10 (permalink)  
Antiguo 19/05/2016, 04:16
eferion
 
Fecha de Ingreso: octubre-2014
Ubicación: Madrid
Mensajes: 1.212
Antigüedad: 10 años, 1 mes
Puntos: 204
Respuesta: Saber si en mrua habrá alcance o nunca se encontraran
Voy a empezar de 0 porque con las ediciones que hice al final es cierto que metí la pata.

La ecuación de la velocidad suponiendo una aceleración constante es v(t)=a0t+v0. En consecuencia, la posición dada por dicha velocidad se calcula integrando la anterior ecuación, lo que resulta en p(t)=(a0/2)*t^2+v0t+p0.

Con esta ecuación ya calculada podemos empezar a trabajar. Lo primero es calcular el momento en el que se cruzan. Como los dos objetos van a tener aceleración constante únicamente pueden cruzarse, a lo sumo, una vez y esto es así porque la posición únicamente depende del tiempo, luego existe una relación de proporcionalidad entre la posición de los dos objetos.

El caso es que ambos objetos se encontrarían cuando p1(t)=p2(t), es decir, cuando (a1/2)*t^2+v1t+p1=(a2/2)*t^2+v2t+p2. Si esta última ecuación la transformamos para trabajar con ella obtenemos dos posibles soluciones que básicamente nos van a dar el mismo resultado:
  • ((a1-a2)/2)*t^2+(v1-v2)*t-(p1-p2)=0
  • ((a2-a1)/2)*t^2+(v2-v1)*t-(p2-p1)=0

Estas ecuaciones no son más que un polinomio de grado dos (at^2+bt+c=0) y sus raices se pueden calcular mediante las ecuaciones:
  • r1 = (-b - sqrt(b^2-4ac))/2a
  • r2 = (-b + sqrt(b^2-4ac))/2a

Como hemos comentado como mucho una de estas dos raices indicará un punto de cruce, la otra o tendrá parte imaginaria o dará un valor negativo... estamos hablando de tiempo y se asume que el tiempo ha de avanzar, no retroceder.

Vale, supongamos que hemos encontrado un punto de cruce en t=r. Si no hubiese restricciones en cuanto al movimiento de los objetos esa sería nuestra solución final... sin embargo una restricción es que si un objeto alcanza velocidad 0 se detiene y ya no se mueve. Esta restricción podemos tratarla de la siguiente forma:
  • Calculamos el tiempo necesario para parar cada objeto. Al igual que sucedía con los puntos de cruce este cálculo puede arrojar 0 o 1 soluciones posibles.
  • Si el tiempo anterior es mayor que el tiempo que tardan en cruzarse descartamos el tiempo de la parada... nos interesa saber dónde se cruzan, lo que hagan despues...
  • Si resulta que ambos objetos se para antes del tiempo de cruce entonces no se van a cruzar nunca... obvio, no?
  • Si solo un objeto se para antes del cruce podemos hacer lo siguiente:
    • Calculamos el punto en el que se para el objeto
    • Calculamos el tiempo que tardará el segundo objeto en alcanzar dicha posición
    • Comprobamos si el segundo objeto se para o no antes de llegar a esta nueva posición

Y ya está... después de todo este proceso pueden pasar dos cosas:
  • Que tengamos un tiempo válido. Esto implica que ambos objetos se cruzan después de todo
  • Que tengamos un tiempo no válido. Es decir, no se cruzan.

En el caso de que se crucen basta con verificar la posición de cualquiera de los objetos en el tiempo hallado y listo.

Una forma de hacerlo con C++:

Código C++: 
Ver original
  1. #include <array>
  2. #include <iostream>
  3. #include <cmath>
  4. #include <memory>
  5.  
  6. enum ParamIndex
  7. {
  8.     Aceleracion,
  9.     Velocidad,
  10.     Posicion
  11. };
  12.  
  13. using ParamsObj = std::array<double,3>;
  14. using NullDouble = std::unique_ptr<double>;
  15.  
  16. constexpr bool SonEquivalentes(double a, double b)
  17. {
  18.   return fabs(a-b) < 1e-8;
  19. }
  20.  
  21. NullDouble CalcularTiempoParada(ParamsObj const& obj)
  22. {
  23.   NullDouble toReturn;
  24.  
  25.   auto a = obj[Aceleracion];
  26.   auto v = obj[Velocidad];
  27.  
  28.   if( !SonEquivalentes(a,0) && !SonEquivalentes(v,0) )
  29.   {
  30.     auto tiempo = -v/a;
  31.     if( tiempo > 0. )
  32.       toReturn = std::make_unique<double>(tiempo);
  33.   }
  34.  
  35.   return toReturn;
  36. }
  37.  
  38. NullDouble CalcularTiempoCruce(ParamsObj const& obj1, ParamsObj const& obj2)
  39. {
  40.   NullDouble toReturn;
  41.  
  42.   auto a = (obj1[Aceleracion]-obj2[Aceleracion])/2;
  43.   auto b =  obj1[Velocidad]  -obj2[Velocidad];
  44.   auto c =  obj1[Posicion]   -obj2[Posicion];
  45.  
  46.   if( SonEquivalentes(a,0) ) // Si no hay aceleración
  47.   {
  48.     auto tiempo = -c/b;
  49.     if( tiempo > 0 )
  50.       toReturn = std::make_unique<double>(tiempo);
  51.   }
  52.   else
  53.   {
  54.     int raiz = b*b-4*a*c;
  55.  
  56.     if( raiz > 0 )
  57.     {
  58.       auto tiempo = (-b + sqrt(raiz))/(2*a);
  59.       if( (tiempo < 0) || !std::isfinite(tiempo) )
  60.         tiempo = (-b - sqrt(raiz))/(2*a);
  61.       if( (tiempo > 0) && std::isfinite(tiempo) )
  62.         toReturn = std::make_unique<double>(tiempo);
  63.     }
  64.   }
  65.  
  66.   return toReturn;
  67. }
  68.  
  69. double CalcularPosicion(ParamsObj const& obj, double tiempo)
  70. {
  71.   auto a = obj[Aceleracion];
  72.   auto v = obj[Velocidad];
  73.   auto p = obj[Posicion];
  74.  
  75.   return ((a*pow(tiempo,2))/2)+(v*tiempo)+p;
  76. }
  77.  
  78. void Comprobar(ParamsObj const& obj1, ParamsObj const& obj2)
  79. {
  80.   std::cout << "Condiciones iniciales:\n"
  81.             << "\tObjeto 1: a=" << obj1[Aceleracion] << ", v=" << obj1[Velocidad] << ", x=" << obj1[Posicion] << "\n"
  82.             << "\tObjeto 2: a=" << obj2[Aceleracion] << ", v=" << obj2[Velocidad] << ", x=" << obj2[Posicion] << "\n"
  83.             << "\n\nResultado:\n";
  84.  
  85.   auto tiempo = CalcularTiempoCruce(obj1, obj2);
  86.   NullDouble posicion;
  87.  
  88.   if( tiempo )
  89.   {
  90.     auto t1 = CalcularTiempoParada(obj1);
  91.     auto t2 = CalcularTiempoParada(obj2);
  92.  
  93.     bool usarT1 = ( t1 && *t1 < *tiempo );
  94.     bool usarT2 = ( t2 && *t2 < *tiempo );
  95.  
  96.     // Si ambos se paran antes del cruce entonces no se cruzan
  97.     if( usarT1 && usarT2 )
  98.     {
  99.       usarT1 = usarT2 = false;
  100.       t1.reset();
  101.       t2.reset();
  102.       tiempo.reset();
  103.     }
  104.  
  105.     // Si alguno se para antes del cruce hay que reajustar las fórmulas
  106.     if( usarT1 )
  107.     {
  108.       auto pos = CalcularPosicion(obj1,*t1);
  109.       ParamsObj newObj1 = { 0, 0, pos };
  110.       tiempo = CalcularTiempoCruce(newObj1,obj2);
  111.  
  112.       if( tiempo )
  113.       {
  114.         if( !t2 || *tiempo < *t2 )
  115.           posicion = std::make_unique<double>(pos);
  116.         else
  117.           tiempo.reset();
  118.       }
  119.     }
  120.     else if( usarT2 )
  121.     {
  122.       auto pos = CalcularPosicion(obj2,*t1);
  123.       ParamsObj newObj2 = { 0, 0, pos };
  124.       tiempo = CalcularTiempoCruce(obj1,newObj2);
  125.  
  126.       if( tiempo )
  127.       {
  128.         if( !t1 || *tiempo < *t1 )
  129.           posicion = std::make_unique<double>(pos);
  130.         else
  131.           tiempo.reset();
  132.       }
  133.     }
  134.   }
  135.  
  136.   if( tiempo )
  137.   {
  138.     auto pos = (posicion)? *posicion : CalcularPosicion(obj1,*tiempo);
  139.     std::cout << "\tLos objetos se cruzan en p=" << pos
  140.               << ", en t=" << *tiempo << "\n";
  141.   }
  142.   else
  143.   {
  144.     std::cout << "\tNo se cruzan\n";
  145.   }
  146. }
  147.  
  148.  
  149. int main()
  150. {
  151.   std::cout << "EJEMPLO1: El objeto de atrás va mas rápido\n";
  152.   ParamsObj paramsObj1 = { 2 /*aceleracion*/, 2 /*velocidad*/,  5 /*posicion*/};
  153.   ParamsObj paramsObj2 = { 1 /*aceleracion*/, 3 /*velocidad*/, 10 /*posicion*/};
  154.   Comprobar(paramsObj1,paramsObj2);
  155.  
  156.   std::cout << "\nEJEMPLO2: El objeto de delante va mas rápido\n";
  157.   paramsObj1 = { 1 /*aceleracion*/, 2 /*velocidad*/,  5 /*posicion*/};
  158.   paramsObj2 = { 1 /*aceleracion*/, 3 /*velocidad*/, 10 /*posicion*/};
  159.   Comprobar(paramsObj1,paramsObj2);
  160.  
  161.   std::cout << "\nEJEMPLO3: El objeto mas adelantado frena mas rapido\n";
  162.   paramsObj1 = { -1 /*aceleracion*/, 10 /*velocidad*/, 5 /*posicion*/};
  163.   paramsObj2 = { -3 /*aceleracion*/, 10 /*velocidad*/, 7 /*posicion*/};
  164.   Comprobar(paramsObj1,paramsObj2);
  165.  
  166.   std::cout << "\nEJEMPLO4: Ambos objetos se paran antes de encontrarse\n";
  167.   paramsObj1 = { -1 /*aceleracion*/, 5 /*velocidad*/,  5 /*posicion*/};
  168.   paramsObj2 = { -2 /*aceleracion*/, 30 /*velocidad*/, 10 /*posicion*/};
  169.   Comprobar(paramsObj1,paramsObj2);
  170.  
  171.   std::cout << "\nEJEMPLO5: Un objeto se para y el otro le da caza\n";
  172.   paramsObj1 = { -1 /*aceleracion*/, 10 /*velocidad*/,  1000 /*posicion*/};
  173.   paramsObj2 = { 0 /*aceleracion*/, 2 /*velocidad*/, 0 /*posicion*/};
  174.   Comprobar(paramsObj1,paramsObj2);
  175.  
  176.   std::cout << "\nEJEMPLO6: Cada objeto va en un sentido y no se cruzan\n";
  177.   paramsObj1 = { -1 /*aceleracion*/, -1 /*velocidad*/,  -1 /*posicion*/};
  178.   paramsObj2 = { 1 /*aceleracion*/, 1 /*velocidad*/, 1 /*posicion*/};
  179.   Comprobar(paramsObj1,paramsObj2);
  180.  
  181.   std::cout << "\nEJEMPLO7: Objetos enfrentados se encuentran a mitad de camino\n";
  182.   paramsObj1 = { -1 /*aceleracion*/, -1 /*velocidad*/,  10 /*posicion*/};
  183.   paramsObj2 = { 1 /*aceleracion*/, 1 /*velocidad*/, -5 /*posicion*/};
  184.   Comprobar(paramsObj1,paramsObj2);
  185.  
  186.   std::cout << "\nEJEMPLO8: Objetos enfrentados se paran cerca pero antes de encontrarse\n";
  187.   paramsObj1 = { 1 /*aceleracion*/, -1 /*velocidad*/,  10 /*posicion*/};
  188.   paramsObj2 = { -1 /*aceleracion*/, 1 /*velocidad*/, -5 /*posicion*/};
  189.   Comprobar(paramsObj1,paramsObj2);
  190.   return EXIT_SUCCESS;
  191. }
__________________
La ayuda se paga con esfuerzo o con dinero. Si no estás dispuesto a esforzarte y quieres que te hagan los deberes pide presupuesto, al menos así ahorrarás tiempo.
Última edición por eferion; 19/05/2016 a las 04:40