Looking for TVM contributions

[robve]

(06-18-2024 11:54 PM)Albert Chan Wrote:  Here is rate search method comparison, Secant vs. Newton.

I'm no longer just comparing Secant vs. Newton, because we know Secant takes more steps. I'm comparing Hybrid to Newton.

I'm doing these important things:

- optionally allow one or more retries after overshooting, this is parameter g. When g=0 we stop. When g=1 we allow one retry to run iterations again after overshooting from the current I%.

- if the final iteration when we stop y=npmt() is nonzero, then we should pick the previous i%, not the last that overshot.

- I'm measuring FVerror to check the TVM model's accuracy with the i% solved, not the i% rate places because some final digits simply don't matter, it's not anomalous.

- I count npmt() evaluations, not steps, because Secant requires two initial i% which we count as 2 evaluations.

- for termination test I use for the Secant, Newton and Hybrid implementations:

Code:

    } while (y != 0.0 && fabs(y) < fabs(w))
  } while (y != 0.0 && y != w && g-- > 0);

My improved Newton implementation:

Code:

  i = iguess();
  if (i == 0.0)
    i = 1e-5;
  g = 1; // pick g=0 or g=1 (see PDF)
  do {
    do {
      w = y;
      y = npmt();
      if (y == 0)
        break;
      d = b*pmt - (pv + fv)*(1.0 + n*s/(r + r/j))/r - fv;
      h = 100*y/d;
      rr = r; // only to compute FV error later
      v = i;
      i -= h;
      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; // pick previous i% after overshooting
    r = rr; // only to compute FV error
    s = r + 1; // only to compute FV error
  }
  j = 0.01*i;
  printf("%.2g\n", fabs(fv - (k*pmt*r/j-pv)/s);

As you can see, it iterates until a root was found or when overshooting. When overshooting and g=1 then we continue iterating again until a root or overshooting. After overshooting we pick the previous i% which is closer to the root.

The results Newton with g=0 and g=1 versus Hybrid with g=0. Hybrid easily beats Newton:

  tvmperfcomp-newton-hybrid.pdf (Size: 34.65 KB / Downloads: 4)

I'm curious what your implementation does differently. Or if I'm doing something wrong. Perhaps the difference is that our convergence tests aren't the same? But from the first test in your list, it looks to me that it has the same number of evaluations: 1 initial npmt and 4 steps npmt = 5 evals. These evals are all nptm + derivative, so more expensive than the Hybrid method that only uses the derivative once after the initial guess.

PS. As I had mentioned before, Newton's derivate expression has subtle evaluation errors that get worse as we get closer to the root. Newton requires both npmt and derivative to be very precise (like having both a fat line to evaluate f(i%) and a sloppy slope to evaluate f'(i%)). Secant just takes the slope of two npmt points. Secant only uses npmt. In other words, it's less risky as we get closer to the root. The Newton convergence slows down anyway, no longer quadratic or better.

- Rob