Looking for TVM contributions

[robve]

(06-15-2024 05:48 PM)robve Wrote:  I also implemented a prototype hybrid algorithm. This uses g=3 (g=2 is not as good). Here compared to Secant (with g=2) it performs well:

The number of evals is between Newton and Secant, which is to be expected. The FVerror looks alright, a bit better than Newton and a little less good than Secant. But this is preliminary. There is some room for improvement.

One nice aspect of Secant is that it does not have to deal with the problematic tiny rates where Newton goes haywire (see above and Albert's has extensively posted about this).

This updated hybrid method runs about as many npmt evaluations as Newton does, but has no issue with tiny rates and offers mostly higher accuracy (for these tests):

  tvmperfcomp-hybrid2.pdf (Size: 41.42 KB / Downloads: 7) (updated with a more robust version)

Newton takes 103 evaluations total over all tests, Secant takes 162 evaluations (though they are a bit cheaper), Hybrid takes 104 evaluations and these are cheaper than Newton.

The Hybrid method solver is pretty straightforward to compute rate i% (updated to a more robust version):

Code:

  g = 0; // no retries
  i = iguess();
  if (i == 0.0)
    i = 1e-5;
  v = i;
  w = y;
  y = npmt();
  d = b*pmt - (pv + fv)*(1.0 + n*s/(r + r/j))/r - fv;
  h = 100*y/d;
  i -= h;
  if (y == 0 || y == w || isnan(y))
    return;
  w = y;
  y = npmt();
  if (y == 0 || y == w || isnan(y))
    return;
  do {
    do {
      double t = i;
      h = (i - v)*y/(y - w);
      i -= h;
      v = t;
      if (i != 0.0) {
        rr = r; // only to compute FV error
        w = y;
        y = npmt();
      }
      if (isnan(i))
        return;
    } while (y != 0.0 && fabs(y) < fabs(w));
  } while (y != 0.0 && y != w && g-- > 0);
  if (y != 0) {
    i = v;
    r = rr;     // only to compute FV error
    s = r + 1;  // only to compute FV error
  }
  j = 0.01*i; // only to compute FV error
  printf("i%%=%.18g%%  FVerror=%.2g\n", fabs(fv - (k*pmt*r/j-pv)/s);

The Secant code is practically the same, but lacks the Newton step and instead uses i/2 for the next point, and with g=2 to repeat and retry if necessary.

EDIT: minor edit to correct testing nan(y) instead of nan(i) in the initialization, this can save one unnecessary npmt evaluation when y=nan.

- Rob