function [z,v,info,xxx_newt] = newton1d(f_newt,x0_newt,Jf_newt,...
                                  E_newt,kmax_newt,dialogo_newt)
//
// Metodo di Newton monodimensionale.
//
// Approssima uno zero della funzione f_newt: R -> R con derivata prima
// (continua) Jf_newt costruendo ua successione x(k).
//
// La costruzione della successione si arresta quando:
//   (*) la funzione f_newt si annulla nel punto attuale x(k);
//   (*) il rapporto tra i valori assoluti in x(k) della funzione
//       f_newt e della derivata Jf_newt è minore di E_newt (in tal
//       caso, se la successione fosse convergente ad uno zero semplice
//       di f_newt, l'errore assoluto tra z = x(k) e tale zero sarebbe
//       circa pari a E_newt (vedi nota));
//   (*) dopo kmax_newt iterazioni (valore suggerito: kmax_newt = 20).
//
// Se dialogo_newt = "loquace", ad ogni ciclo di iterazione la procedura
// stampa il numero di iterazione, il valore attuale x(k) ed il valore
// f_newt(x(k)). Disegna infine (nella finestra grafica NFG_newt)
// due grafici della stima dell'errore assoluto.
//
// z: approssimazione finale (zero di f_newt oppure una sua
//    approssimazione);
// v: valore di f_newt in z;
// info = 0: individuato valore in cui f_newt si annulla;
//      = 1: criterio di arresto soddisfatto;
//      = 2: il valore di Jf_newt in x(k) è zero;
//      = 3: superato il numero massimo consentito di iterazioni.
// xxx_newt: matrice contenente la successione generata x(k).
//
// Se info = 2, si pone z = [] e v = [].
//
info = -1;
StimaErr = [];
k_newt = 0; // contatore iterazioni effettuate
x_newt = x0_newt;
xxx_newt = x0_newt;
v_f = f_newt(x_newt);
v_J = Jf_newt(x_newt);
if dialogo_newt == "loquace" then
   ListaFinestre_newt = winsid();
   if length(ListaFinestre_newt) ~= 0 then
         FinestraCorrente_newt = gcf(); end;
   NFG_newt = 37; // Numero della Finestra Grafica nella quale la
                  //  procedura disegna.
   clf(37);
   figure_handle_newt = scf(NFG_newt);
   figure_handle_newt.figure_name =...
         "finestra generata da newton1d.sci (37)";
   format_newt = " k = %d , x = %16.15e, f = %16.15e\n";
   printf(format_newt,k_newt,x_newt,v_f);
end;
//
// ****************** Iterazione
//
while info == -1,
   if v_f == 0 then info = 0; z = x_newt; v = 0; break; end;
   if v_J == 0 then info = 2, z = [], v = []; break; end;
   StimaErr($+1) = abs(v_f/v_J);
   if StimaErr($) < E_newt then
      info = 1; z = x_newt; v = v_f; break;
   end;
   if k_newt >= kmax_newt then
      info = 3; z = x_newt; v = v_f; break; end;
   xprev_newt = x_newt;
   x_newt = x_newt - v_f/v_J;
   xxx_newt(1,$+1) = x_newt;
   v_f = f_newt(x_newt);
   v_J = Jf_newt(x_newt);
   k_newt = k_newt+1;
   if dialogo_newt == "loquace" then
      printf(format_newt,k_newt,x_newt,v_f); end;
end;
//
// ****************** Fine iterazione
//
if dialogo_newt == "loquace" then
   select info,
     case 0 then printf("\n\n *** Trovato zero\n\n");
     case 1 then printf("\n\n *** Trovata approssimazione\n\n");
                 printf(" *** Stima errore = %6.5e\n\n", abs(v_f/v_J));
     case 2 then printf("\n\n *** Errore: derivata nulla\n\n");
     case 3 then printf("\n\n *** Superato numero max iterazioni\n\n");
   end;
   // Grafici
   StimaErr_x = StimaErr(1:$-1)';
   StimaErr_y = StimaErr(2:$)';
   subplot(121);
   plot2d("ll",StimaErr_x,StimaErr_y,style=5,frameflag=4);
   xgrid();
   xlabel("stima al passo  k");
   ylabel("stima al passo  k+1");
   xtitle("Stima errore assoluto (scale logaritmiche)");
   subplot(122);
   plot(0:length(StimaErr_x)-1,log10(StimaErr_y)./log10(StimaErr_x));
   xgrid();
   xlabel("k");
   ylabel("log10( e(k+1) ) / log10( e(k) )");
   if length(ListaFinestre_newt) ~= 0 then
         scf(FinestraCorrente_newt); end;
end;
endfunction

// Sia f_newt = f di classe C(2,[a,b]) e Z lo zero semplice di f che
// la successione x(k) sta approssimando; posto
//
//                                       f(x(k))
//          e(k) = x(k) - Z   e   F(k) = --------
//                                       f'(x(k))
//
// si ha:
//                         1     f''(t)
//          e(k) = F(k) - --- * -------- * (e(k))^2
//                         2    f'(x(k))
//
// con t tra Z e x(k), da cui (M = max |f''|, m = min |f'|):
//
//                               M
//          | e(k) - F(k) | <=  --- (e(k))^2
//                              2*m
//
// dunque, quando e(k) è piccolo, F(k) è una buona stima di e(k).
//
