Save output before first simulation run.

If the first simulation fails, it would be nice to see the mechanism that
caused the failure. 
There is a new method saveEverything that saves the HTML, Chemkin, and restart.
This is now called at the start as well as once per iteration.
Check for a few possible mistakes in input files.

This method can be expanded to include other common (or uncommon) mistakes.
For now, it catches reaction systems that cause extrapolation of Chebyshev
polynomials outside of the PDep range. Helps avoid issue #67
Add a _repr_png_ method to Molecule for use in iPython qtconsole

If Greg and Noel can do it, so can we ;-)
http://baoilleach.blogspot.com/2012/03/molecular-eye-candy-for-ipython.html
Display pictures of species inline if running IPython QTConsole --pylab

See http://ipython.org/ipython-doc/rel-0.11/interactive/qtconsole.html#inline
If you aren't running in this mode then calls to rmgpy.display.display do nothing.
Tweak (and fix) the Atom.__str__ method.

It was missing a '
(And this doesn't need list loops)
Allow lookup of element by atomic number to accept LONG integers.

With the latest OpenBabel build, the SWIG bindings are such that
OBAtom.getAtomicNum() now returns a `long` rather than an `int`.
This caused problems when using OpenBabel to create RMG molecules.
Makefile target decython to de-cythonize as much as possible for debugging.

`make decython` should remove as much of the cythonized files as possible,
as if you had done `make clean; make minimal` so that you can debug in 
pure python mode without having to rebuild all the minimal requirements again.

Currently doesn't leave a working RMG-Py, but nor does `make minimal`!
Use log and sort from extern math.h instead of math module in cythonized code.

This means we don't have to rely on 'math' having been accidentally 
imported into the global namespace via a "from __ import *"
(which I'm about to remove).  It may also be slightly faster, who knows.
I assume it does the same thing as before.
Fix bug in measure/reaction.pyx (using 'rxn' where the variable is called 'reaction')

Not sure how this used to compile, but cython balks at it now.
Change imports in measure/reaction.pyx

Rather than import * from rmgpy.kinetics (which redefines 
Quantity, and a bunch of other stuff like 'math' etc. at runtime)
we just import the Classes that we need: Arrhenius, PDepArrhenius, Chebyshev.
No doubt more will have to be added in the future, but at least this works.
(I think "import *" is a bit risky - you never know what you're getting,
which makes debugging harder). 
Fixes to measure/reaction.pyx so `make minimal` works.

Various import statements were causing problems.
The `make decython` target also works now, to help debug in pure python mode.
Closes #72.
Check input file for missing bath gas when running with PDep.

Closes #37
Replaced os.link with shutil.copy2 for use in Windows
Merge remote-tracking branch 'sean/master'
New method Molecule.deleteHydrogens()

This is a bit like makeHydrogensImplicit, except that it doesn't increment the
implicitHydrogens counter on the neighboring atoms, so there is no getting them back!
This is useful for some situations where you have a shallow copy of a molecule and you want
to consider it without the hydrogens, but do not want to edit attributes of the atoms
that are shared with the original molecule.
More detailed error message when failing to draw molecules.
molecule_draw doesn't increment implicitHydrogens counts when searching for backbone.

Previously it would do a makeHydrogensImplicit() call on a shallow copy of the molecule.
This would not delete the hydrogens from that molecule, but WOULD increment the
implicitHydrogens counts on the atoms in it, leading to escalating H populations!
Be careful with shallow copies of dicts of dicts! (eg. bonds matrices)

When you do a shallow copy of a dictionary of dictionaries, the inner dictionaries
have not been copied - they are the original ones. This is important when you have:
    bonds1[atom1][atom2] = bond
then
    bonds2 = bonds.copy()
is NOT a safe copy to manipulate without messing up bonds1.
It is NOT a 2-D array, but a dictionary of mutable dictionaries.
You need to copy it at least one level deep (see the diff)
drawMolecule() can now cope with either implicit or explicit Hydrogens.

It doesn't need to change. It deletes the hydrogens that it's not going to draw
from the lists and dicts that it has copied, leaving the originals alone, and
it keeps track independently of how many times it has done this for each heavy
atom.
Merge branch 'drawing'

This fixes a bunch of stuff in molecule drawing, especially for
explicit/implicit hydrogens.