Ich stelle nachfolgend mal eine Funktion vor, von der ich der Meinung bin, dass man eine solche Konstruktion nicht ohne Schwierigkeiten in AWL umsetzen kann. Hierbei handelt es sich um ein Iterationsverfahren nach Newton und diese ist in der hier vorgestellten Art der Ausführung als universell anwendbare C-Funktion in andere herkömmliche C-Projekte einsetzbar. Die notwendigen Funktionen zur Aproximation werden als Funktionspointer - (*nf) - mit der notwendigen Parametern übergeben.

Code:
extd newton (extd start, extd step, extd (*nf)(extd, void *), extd convg,
              extd *max, extd *min, long maxLoops, void *pb, long *msg, long ID)
{
   extd     x0, x1, y1, x2, y2, maxi, mini;
   long     n;
   str255   s;

   inc_fn_stack ("newton");
   maxi = (max != NULL) ? *max : 0.0;
   mini = (min != NULL) ? *min : 0.0;

   if (DebugNewton)
   {
      strcpy  (s, "Newton Start: ");
      strcat  (s, newtonID (ID));
      sprintf (s,
         "\tx1&#58; %6.2f\tdx&#58; %6.2f\te&#58; %6.2f\thi&#58; %6.2f\tlo&#58; %6.2f\tn<%ld\n",
          &#40;float&#41; start, &#40;float&#41; step, &#40;float&#41; convg, &#40;float&#41; maxi,
          &#40;float&#41; mini, maxLoops&#41;;
      printf &#40;s&#41;;
   &#125;

   x1 = start;
   x2 = start + step;
   y2 = &#40;*nf&#41; &#40;x1, pb&#41;;

   if &#40;DebugNewton&#41;
   &#123;
      strcpy  &#40;s, "Newton&#58; f&#40;1&#41;&#58; "&#41;;
      strcat  &#40;s,  newtonID &#40;ID&#41;&#41;;
      sprintf &#40;s, " y2 = f&#40;x1&#41;&#58; x1 = %6.2f y2 = %6.2f\n",
              &#40;float&#41; x1, &#40;float&#41; y2&#41;;
      printf  &#40;s&#41;;
   &#125;

   for &#40;n = 0; n < maxLoops; n++&#41;
   &#123;
      y1 = y2;
      y2 = &#40;*nf&#41; &#40;x2, pb&#41;;  /* returns the difference by function call */

      if &#40;DebugNewton&#41;
      &#123;
         strcpy  &#40;s, "Newton&#58; f&#40;2&#41;&#58; "&#41;;
         strcat  &#40;s, newtonID &#40;ID&#41;&#41;;
         sprintf &#40;s, " y2 = f&#40;x2&#41;&#58; x1 = %6.2f y2 = %6.2f\n",
                 &#40;float&#41; x2, &#40;float&#41; y2&#41;;
         printf  &#40;s&#41;;
      &#125;

      if &#40;fABS&#40;y2&#41; < convg&#41;
      &#123;
         if &#40;min != NULL&#41;
            if &#40;x2 < *min&#41;
            &#123;
               *msg = msgLo;
               dec_fn_stack &#40;&#41;;
               return *min;
            &#125;

         if &#40;max != NULL&#41;
            if &#40;x2 > *max&#41;
            &#123;
               *msg = msgHi;
               dec_fn_stack &#40;&#41;;
               return *max;
            &#125;

         *msg = noErr;
         dec_fn_stack &#40;&#41;;
         return x2;
      &#125;

      if &#40;fABS&#40;y2 - y1&#41; < d_ZDP&#41;
      &#123;
         *msg = msgZDP;
         dec_fn_stack &#40;&#41;;
         return x2;
      &#125;

      x0 = x1 - y1 * &#40;x2 - x1&#41; / &#40;y2 - y1&#41;;

      if &#40;min != NULL&#41;
         x0 = fMAX &#40;x0, *min&#41;;
      if &#40;max != NULL&#41;
         x0 = fMIN &#40;x0, *max&#41;;

      x1 = x2;
      x2 = x0;
   &#125;

   *msg = msgMaxLoop;

   dec_fn_stack &#40;&#41;;
   return 0;
&#125;
Ich stelle dies mal als Start zur Diskussion in das Forum und würde gerne eure Meinung über die Machbarkeit hören.

Gruß Barnee