My code

… was written in C++11 and can be compiled with G++, Clang++, Visual C++. You can download it, too. Or just jump to my GitHub repository.

       
#include <iostream>
       
#include <cmath>
       
 
       
// a simple 2D vector

       
struct Vector
       
{
       
  // create new vector
       
  Vector(double x_, double y_) : x(x_), y(y_) {}
       
  double x, y;
       
 
       
  // compute length
       
  double getLength() const
       
  {
       
    return sqrt(x*x + y*y);
       
  }
       
  // dot product
       
  double dot(const Vector& other) const
       
  {
       
    return x * other.x + y * other.y;
       
  }
       
};
       
// use a Vector for 2D points, too

       
typedef Vector Point;
       
 
       
int main()
       
{
       
  // count reflections
       
  unsigned int steps = 0;
       
 
       
  // initial ray
       
  Point from(0.0, 10.1);
       
  Point to  (1.4, -9.6);
       
 
       
  while (true)
       
  {
       
    // exit ellipse when x is between -0.01 and +0.01 on the upper side of the ellipse
       
    if (to.x >= -0.01 && to.x <= 0.01 && to.y > 10 - 0.1) // vertical radius is 10, subtract a bit because of curving
       
      break;
       
 
       
    // find inward pointing vector of the ellipse at intersection point
       
    Vector normal(-4 * to.x, -to.y);
       
    // normalize vector length
       
    double length = normal.getLength();
       
    normal.x /= length;
       
    normal.y /= length;
       
 
       
    // current direction of the ray
       
    Vector direction(to.x - from.x, to.y - from.y);
       
    // degenerated case ? ray will exit after only one bounce
       
    if (direction.x == 0)
       
    {
       
      steps++; // same as steps = 1 in this case
       
      break;
       
    }
       
 
       
    // reflect ray at intersection considering the normal
       
    // a short explanation can be found here: http://paulbourke.net/geometry/reflected/
       
    Vector reflect(0, 0);
       
    reflect.x = direction.x - 2 * direction.dot(normal) * normal.x;
       
    reflect.y = direction.y - 2 * direction.dot(normal) * normal.y;
       
 
       
    // slope of the reflected ray
       
    double slope = reflect.y / reflect.x;
       
 
       
    // previous endpoint becomes the start point of the next iteration
       
    from.x = to.x;
       
    from.y = to.y;
       
 
       
    // find next intersection
       
    // I derived that strange formula in the initial comment section
       
    to.x = (4*from.x - slope*slope*from.x + 2*slope*from.y) / (-4 - slope*slope);
       
    to.y = slope * (to.x - from.x) + from.y;
       
 
       
    // count iterations
       
    steps++;
       
  }
       
 
       
  // display result
       
  std::cout << steps << std::endl;
       
  return 0;
       
}

This solution contains 13 empty lines, 20 comments and 2 preprocessor commands.