Moved physical constants to new rmgpy.constants module.

This gives users the option of importing the constants separately from
the Quantity functionality. The constants have also been made into
module-level variables instead of attributes of an otherwise-needless
class. The same globals() trick allows the defined module-level constants
to be accessible from both Python and Cython contexts; when cimported,
the C version of the constants will be made available to Cython modules.
Updated import statements to find new rmgpy.constants module.

Many of the imports of the rmgpy.quantity module only asked for one or
the other of the Quantity class or the constants object, so there seems
to be at least a small amount of sense in decoupling them. Still, many
other imports wanted both anyway, so this may just be a cosmetic change.
Improved classes for representing physical quantities.

There are now separate classes for representing scalar and higher-order
quantities, aptly named ScalarQuantity and ArrayQuantity, respectively.
For the most part, you don't need to use these directly, though; instead,
use the Quantity() function, which returns either a ScalarQuantity or
ArrayQuantity object based on the input value, units, and uncertainty.

The value attribute of both ScalarQuantity and ArrayQuantity has been
changed to a property that returns the value of the quantity in the
given units. Previously it had stored the value in the SI equivalent to
facilitate speedy computations, which worked but was rather awkward to
explain to people. What was the value attribute is now called value_si
to emphasize that it stores the value in the SI equivalent. This is
still available directly for speedy computations.

I've also revamped the unit tests accordingly.
Now using ScalarQuantity, ArrayQuantity, and value_si throughout codebase.

I've tested some of the changes using the unit tests that were previously
working, and almost all of them still pass. There are a few exceptions
that I'm ignoring for now because I think they will be addressed as part
of future commits anyway.
Moved rmgpy.constants unit tests to rmgpy package.

The motivation here is to have the unit tests live in modules alongside
the modules they test. This makes them more visible when editing the
codebase, which encourages developers to keep them up to date. We can
also use nose to automatically search and run the unit tests, perhaps as
a post-commit hook to further prevent the tests from becoming stale.
Added functions for validation of various unit types.

One thing that's been missing from our handling of physical quantities
has been the enforcing of unit types. For example, there is nothing
currently stopping someone from storing a moment of inertia in units of
cm^-1, which would lead to crazy rotational and torsional partition
functions, etc. This commit provides the UnitType class, a functor
(a function with associated metadata) for creating ScalarQuantity or
ArrayQuantity objects of a unit type. Several module-level instances of
UnitType are also defined, e.g. Inertia for moments of inertia.

The UnitType objects also give us the opportunity to handle unusual
units, e.g. frequencies in units of cm^-1 or K instead of s^-1, etc.
Note that RateCoefficient is currently implemented as a special case, as
these can have different units depending on the reaction order.

Also note that all energies, enthalpies, free energies, entropies, heat
capacities, concentrations, fluxes, and rate coefficients are treated as
intensive. This means that you must use mol or molecule for these. All
other unit types are extensive. A special case is added for mass to
convert e.g. g/mol to amu.

There are a large number of unit tests to ensure that the unit types
are acting as intended, as there are several edge cases.
Updated documentation for new physical quantity modules.

The documentation has been split into multiple files and placed into a
subfolder.
Use MathJax instead of PNG files in generated Sphinx documentation.

MathJax has at least three advantages: (1) no LaTeX installation
required to compile the HTML documentation, (2) documentation builds
much faster, and (3) generated equations scale nicely in the browser.
The only catch is that you need an internet connection to be able to see
the equations in the generated HTML, which shouldn't be a problem.
Added rmgpy.statmech subpackage for statistical mechanics functionality.

The rmgpy.statmech subpackage will contain a suite of modules providing
a variety of statistical mechanics classes and functions. This will
eventually replace the rmgpy.statmech and rmgpy._statmech modules,
enabling faster partial rebuilds and better organization.
Added rmgpy.statmech.schrodinger module for solving the Schrodinger equation.

This module contains Cython-optimized functions that use the solution to
the Schrodinger equation -- in the form of functions that return the
energy levels and degeneracies of the solution -- to compute various
thermodynamic and statistical mechanical properties. The sum and density
of states are computed using the Beyer-Swinehart-Stein-Rabinovitch
algorithm.
Added Mode class to new rmgpy.statmech.mode module.

The Mode class is a base class for all representations of molecular
degrees of freedom. It provides a place to collect common attributes and
methods. For example, the quantum attribute is used to indicate whether
we wish to use the classical or quantum mechanical model for this degree
of freedom.
Added LinearRotor class to new rmgpy.statmech.rotation module.

The LinearRotor class represents a rigid rotor for a linear molecule, i.e.
a rotor with a single moment of inertia (or rotational constant). Methods
are available for computing thermodynamic and statistical mechanical
properties of the rotor using either classical or quantum approaches.
The classical results are much faster to evaluate and nearly always
accurate except at temperatures well below room temperature.

The LinearRotor class inherits from a new Rotation base class, which
itself inherits from the Mode class and adds an attribute for the
symmetry number of the rotational degree of freedom.
Added NonlinearRotor class to rmgpy.statmech.rotation module.

Nonlinear rotors have multiple (usually three) moments of inertia that
are used to compute the thermodynamic and statistical mechanical
contributions from the rotor. As with the linear rotors, the classical
nonlinear rotor is almost always a reasonable choice (except at very low
temperatures). For nonlinear rotors the quantum mechanics solution is not
straightforward, and has not been implemented at this time; you will get
a NotImplementedError if you try to use it.
Added KRotor class to rmgpy.statmech.rotation module.

The KRotor class represents a one-dimensional rigid rotor, and is useful
for working with the K-rotor in certain situations. For example, some
pressure dependence calculations are performed with an active K-rotor
for randomizing the molecular energies, while others leave the K-rotor
adiabatic.
Added SphericalTopRotor class to rmgpy.statmech.rotation module.

The SphericalTopRotor class represents a three-dimensional rigid rotor
with a single rotational constant. This occurs in molecules such as
methane with a high degree of symmetry. The NonlinearRotor class is an
approximate generalization for nonspherical rotors.
Added HarmonicOscillator class to rmgpy.statmech.vibration module.

The HarmonicOscillator class represents one or more internal molecular
vibrational modes as a set of one-dimensional harmonic oscillators.
Methods for computing thermodynamic and statistical mechanical
properties are provided. Unlike the rigid rotor classes, the harmonic
oscillator uses the quantum mechanical solution by default; the
classical solution is also available, but is generally only accurate at
very high temperatures.
Added HinderedRotor class to rmgpy.statmech.torsion module.

The HinderedRotor class represents a one-dimensional hindered rotor,
described by a reduced moment of inertia and an angle-dependent potential
function. There are two options for representing the potential: a simple
cosine expression and a more general Fourier series.

Either the classical or quantum mechanical solutions can be used for either
potential, except that the sum and density of states cannot be expressed
classically for the Fourier series potential. A semiclassical correction
to the partition function is also available, although currently not used
by default.
Added IdealGasTranslation class to rmgpy.statmech.translation module.

This class represents the translational degrees of freedom of an ideal
gas in three-dimensional space. The only parameter is the mass of the
gas molecules, as the volume is replaced by RT/P according to the ideal
gas law. Translational energy levels, as determined from a 3D
particle-in-a-box model, are very small compared to RT except at
temperatures approaching absolute zero, so only the classical limit
results have been implemented. (Like the NonlinearRotor class, a
NotImplementedError will be raised if you attempt to use the quantum
solution.)
Added Conformer class to rmgpy.statmech.conformer module.

The Conformer class represents an individual conformation on a potential
energy surface. Each configuration is defined by a set of molecular
degrees of freedom (translation, rotation, vibration, and/or torsion),
an electronic spin multiplicity, and a number of optical isomers. The
class provides convenience methods for evaluating the thermodynamic and
statistical mechanical properties of the configuration from these
parameters.

In general, each conformer corresponds to a unique geometry (positions
of each atom). Storing that geometry makes it possible to extract some
statistical mechanical parameters (e.g. total mass and moments of
inertia) directly. Several methods for doing so have been provided.

Note that, also the ground-state energy E0 is stored as an attribute on
the Conformer object, it is not currently used to evaluate the
thermodynamic of statistical mechanical properties. This is because we
prefer to work with relative rather than absolute energies so as to not
care about the chosen zero of energy.
Import content of submodules when importing rmgpy.statmech package.

This automatically places the content of each of the various submodules
into the rmgpy.statmech symbol table, which is the preferred method of
accessing the classes and functions of the rmgpy.statmech subpackage.