Vector optimizations

[suarezvictor]

I propose a way of otimizing some code on Simulation.cs
Currently, there's this code at line 326

                                    // bool done = true
                                    LinqExpr done = code.ReDeclInit("done", true);
                                    foreach (Expression i in S.Unknowns)
                                    {
                                        LinqExpr v = code[i];
                                        LinqExpr dv = code[NewtonIteration.Delta(i)];

                                        // done &= (|dv| < |v|*epsilon)
                                        code.Add(LinqExpr.AndAssign(done, LinqExpr.LessThan(Abs(dv), MultiplyAdd(Abs(v), LinqExpr.Constant(1e-4), LinqExpr.Constant(1e-6)))));
                                        // v += dv
                                        code.Add(LinqExpr.AddAssign(v, dv));
                                    }

the problem is that gnereated code is complex to optimze, see results of that:

                        bool flag25 = true && fabs(num405) * 10000.0 < fabs(num129) + 1E-06;
                        num129 += num405;
                        bool flag26 = flag25 && fabs(num421) * 10000.0 < fabs(num127) + 1E-06;
                        num127 += num421;
                        bool flag27 = flag26 && fabs(num474) * 10000.0 < fabs(num125) + 1E-06;
                        num125 += num474;

It also unfortunately seems to generate a lot of branches

I think it would be better to incorporate in generated code an explicit for instruction (instead of generating a list of instructions), so the compiler can apply some loop optimizations.
Code generated should be similar to that (produces same function):

double tmp_v[Unknowns_size] = { code[0], code[1], ...};
double tmp_dv[Unknowns_size] = { code[NewtonIteration.Delta(0)], code[NewtonIteration.Delta(1)], ...};
double tmp_max=0;
for(int i = 0; i < Unknowns_size; ++i)
{
  double d = fabs(tmp_dv[i]) - fabs(tmp_v[i])*1e-4;
  tmp_max = fmax(tmp_max, d));
  tmp_v[i] += tmp_dv[i];
}
done = (tmp_max < 1e-6);

This way the compiler can unroll the loop, apply vectorization and the like optimizations. A preordering of the array would also be useful.