Modified the initial inequality multiplier

I'm playing with how we choose the initial inequality multiplier.
Before, we set

z = (<e,e> / <h(x),e>) e.

This insured that mu_est started out at 1.  Really, this made it easy to
see if mu was small and we achieved convergence with respect to the
inequality constraint.  At the same time, I'm not sure if this deals
with scalings properly.  As an alternative, this check-in modifies this
procedure so that we now set

z = ( || h(x) || / || inv(L(h(x))) e || ) inv(L(h(x))) e

This insures that || z || = || h(x) || and that
mu_est = || h(x) ||  / || inv(L(h(x))) e ||.  More importantly, we now
have that h(x) o z = mu_est e on the first iteration, which I believe
means we're on the central path.  In any case, I'm still trying to get a
handle on the performance to see how well this works in practice.
Allowed a more permissive value of alpha0

Recall, alpha0 is the base line-search parameter.  Generally, we want it
to be positive, but there's also a section of the code that sets these
values everytime we set the trust-region.  Basically, we try to keep the
line-search parameters in sync with the trust-region and vice versa so
that it's easier to switch between algorithms.  In any case, when we get
a bad Hessian, it's possible that we set delta to 0.  This happens
because dx=0 and then we set delta to ||dx||/2.  This means that we set
alpha0 to zero, which then causes an issue with the restart mechanisms
since alpha0 previously needed to be positive.  This issue has now been
fixed.
Updated SR1 algorithm and added safeguards

I modified the SR1 algorithm to use a numerically more stable
computation.  Basically, we should do the inner products last and we
were previously doing them first.  In addition, I added a safeguard to
the algorithm that had some divide by zero problems.  Basically, in SR1,
we eventually have to divide by <si,yi-Bisi>.  There are a couple of
things that can go wrong here.  First, si could be zero, but we caught
that previously since si=xi-xim1=dx and we have a stopping critieria
that looks for small dx.  Second, si could be orthogonal to yi-Bisi.  In
order to combat this, we now use the scheme suggested by Nocedal and
Wright where we require

        <si,yi-Bisi> > epsilon ||si|| ||yi-Bisi||

where epsilon is equal to the square root of machine precision.
Finally, we could have yi-Bisi=0.  Generally, for unconstrained
problems, this doesn't come up.  Basically, if the problem is quadratic
with m variables, then SR1 gives a perfect approximation after m
interations.  This mean that after m iterations, we have that yi-Bisi=0.
Now, for unconstrained problems, we exit the optimization by then, so
there's no problem.  However, for inequality constrained problems, we
have to wait until we drive down mu to something small.  This means that
we don't necessessarily exit after m iterations, which means that
yi-Bisi can become small.  In order to combat this, I implemented a new
procedure that requires

        | s'(y-Bs) | > epsilson max_i | si'(yi-Bsi) |

Essentially, we want to guarantee that the new information we're adding
about the Hessian is relavant when compared to the information already
in the SR1 operator.
Updated unit tests to reflect algorithmic changes

I updated the unit tests to reflect the changes made to both the
initial choice of inequality multiplier as well as SR1 algorithm.  For
the most part, the problems because more robust and the iteration count
went down.  This was especially pronounced for Newton-CG with a
backtracking line-search.  I did have some issues with the predictor
corrector algorithm, which I'm not happy about.  Honestly, it seems a
bit flakey right now, so I need to spend some time figuring out why the
algorithm performs in the way it does.  By flakey, for a particular
value of gamma, it may or may not converge and it took way too much
tweaking to get something that performed well.
Merge branch 'feature/initial_ineq_dual' into develop
Added iter and name as arguments to serialize

I modified the API so that the serialize routine in Serialization now
provides access to the name of the variable, as a string, and the
current iteration.  The reason for this change is that it can be
difficult to figure out an appropriate file name in case we need to
write a restart file to a binary file and then only include that file
information in the json file.  Especially for big problems, writing to
external binary files is essential.  But, yes, previously we just gave
the serialize routine a vector and it was never clear, at least to me,
as to where to write this information.
Added example that demonstrates restarts to file

I added a new example that demonstrates how to write restart files to
file.  Specifically, how to write the variables to file and not directly
to json, which is a common use case for large scale optimization
problems.  Basically, this demonstrates the functionality added earlier
in this tree.

In the process of doing this, I uncovered a few different bugs.  First,
it turns that that mu_typ was not being written out the restart
packages.  This has now been fixed.  Next, there was a more subtle
problem with the StateManipulator being called at the
EndOfOptimizationIteration iteration.  Basically, this is the best place
to write the restart file.  However, this is also the location where the
stopping conditions were modified.  Since the user's state manipulator
is always called first, the restart file was being written with the
wrong stopping condition.  If we recall, the state manipulators that
implement the inequality and equality constraints adjust the stopping
conditions here.  In order to fix this, I needed to add another location
for the state manipulator called AfterCheckStop.  This is a better place
to adjust the stopping conditions.  Then, EndOfOptimizationIteration
becomes a safe place to write the restart files.  Now, added to our
enumerated types requires changes to the MATLAB/Octave and Python
interfaces, so those were modified as well.  Finally, there were some
minor bugs in rosenbrock_advanced_api, which became exposed when dealing
with our new example.  These have also been fixed.
Updated documentation with the new restart API

I updated the documentation with the new restart API.  This included
making some small modifications in our simple constrained advanced API
example, so that we could include some sample code in the manual.
Merge branch 'feature/serialize_to_file' into develop
Changed the reporting of ||dx|| during LS algos

I modified the meaning of ||dx|| during a line-search algorithm.
Before, I was trying to process the step so that ||dx|| was the size of
the raw step, not scaled by alpha.  The problem with this was that after
a rejected line-search step, I was misreporting what the norm was
because I wasn't scaling it properly before we hit the state
manipulator.  Now, I could have fixed this, but in some sense this
probably wasn't the way to go from the start.  When working on a
problem, I find it much easier to tune the step size if I know what the
size of || alpha dx || is, rather than ||dx||.  In the latter case, I
just end up multiplying things anyone.  It also simplifies our code.
Updated documentation of multipliers

I updated the documentation with respect to the multipliers.  Most
significantly, I forgot to document the change in how we compute the
initial inequality multiplier.  I also took this time to better document
how we choose the initial equality  multiplier.