Mercurial > hg > octave-terminal

changeset 15580:673889d49256

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
maint: merge in Juan Pablo's changes
author Jordi Gutiérrez Hermoso <jordigh@octave.org>
date Fri, 02 Nov 2012 15:19:05 -0400
parents 5fb80374c881 (diff) cef958fbae2d (current diff)
children 5649e84ea3ce
files
diffstat 1 files changed, 90 insertions(+), 87 deletions(-) [+]
line wrap: on
line diff
--- a/scripts/general/quadgk.m
+++ b/scripts/general/quadgk.m
@@ -149,7 +149,8 @@
           trace = varargin{2};
         endif
         if (nargin > 5)
-          error ("quadgk: can not pass additional arguments to user function");
+          error ("Octave:Invalid-fun-call",
+                  "quadgk: can not pass additional arguments to user function");
         endif
       else
         idx = 1;
@@ -170,14 +171,17 @@
             elseif (strcmpi (str, "trace"))
               trace = varargin{idx++};
             else
-              error ("quadgk: unknown property %s", str);
+              error ("Octave:invalid-input-arg",
+                                            "quadgk: unknown property %s", str);
             endif
           else
-            error ("quadgk: expecting property to be a string");
+            error ("Octave:invalid-input-arg",
+                                   "quadgk: expecting property to be a string");
           endif
         endwhile
         if (idx != nargin - 2)
-          error ("quadgk: expecting properties in pairs");
+          error ("Octave:Invalid-fun-call",
+                                       "quadgk: expecting properties in pairs");
         endif
       endif
     endif
@@ -297,99 +301,99 @@
     endwhile
     subs = [subs(1:end-1), subs(2:end)];
 
-    warn_state = warning ("query", "Octave:divide-by-zero");
+    # Set divide-by-zero warning off locally
+    warning ("off", "Octave:divide-by-zero", "local");
+
+    warn_msg   = "Octave:quadgk:warning-termination";
+
+    ## Singularity will cause divide by zero warnings
+    warning ("off", "Octave:divide-by-zero");
 
-    unwind_protect
-      ## Singularity will cause divide by zero warnings
-      warning ("off", "Octave:divide-by-zero");
+    ## Initial evaluation of the integrand on the subintervals
+    [q_subs, q_errs] = __quadgk_eval__ (f, subs);
+    q0 = sum (q_subs);
+    err0 = sum (q_errs);
+
+    if (isa (a, "single") || isa (b, "single") || isa (waypoints, "single"))
+      myeps = eps ("single");
+    else
+      myeps = eps;
+    endif
 
-      ## Initial evaluation of the integrand on the subintervals
-      [q_subs, q_errs] = __quadgk_eval__ (f, subs);
-      q0 = sum (q_subs);
-      err0 = sum (q_errs);
+    first = true;
+    while (true)
+      ## Check for subintervals that are too small. Test must be
+      ## performed in untransformed subintervals. What is a good
+      ## value for this test. Shampine suggests 100*eps
+      if (any (abs (diff (trans (subs), [], 2) / h0) < 100 * myeps))
+        q = q0;
+        err = err0;
+        break;
+      endif
 
-      if (isa (a, "single") || isa (b, "single") || isa (waypoints, "single"))
-        myeps = eps ("single");
-      else
-        myeps = eps;
+      ## Quit if any evaluations are not finite (Inf or NaN)
+      if (any (! isfinite (q_subs)))
+        warning (warn_msg, "quadgk: non finite integrand encountered");
+        q = q0;
+        err = err0;
+        break;
+      endif
+
+      tol = max (abstol, reltol .* abs (q0));
+
+      ## If the global error estimate is meet exit
+      if (err0 < tol)
+        q = q0;
+        err = err0;
+        break;
       endif
 
-      first = true;
-      while (true)
-        ## Check for subintervals that are too small. Test must be
-        ## performed in untransformed subintervals. What is a good
-        ## value for this test. Shampine suggests 100*eps
-        if (any (abs (diff (trans (subs), [], 2) / h0) < 100 * myeps))
-          q = q0;
-          err = err0;
-          break;
-        endif
+      ## Accept the subintervals that meet the convergence criteria
+      idx = find (abs (q_errs) < tol .* abs (diff (subs, [], 2)) ./ h);
+      if (first)
+        q = sum (q_subs (idx));
+        err = sum (q_errs(idx));
+        first = false;
+      else
+        q0 = q + sum (q_subs);
+        err0 = err + sum (q_errs);
+        q += sum (q_subs (idx));
+        err += sum (q_errs(idx));
+      endif
+      subs(idx,:) = [];
 
-        ## Quit if any evaluations are not finite (Inf or NaN)
-        if (any (! isfinite (q_subs)))
-          warning ("quadgk: non finite integrand encountered");
-          q = q0;
-          err = err0;
-          break;
-        endif
+      ## If no remaining subintervals exit
+      if (rows (subs) == 0)
+        break;
+      endif
 
-        tol = max (abstol, reltol .* abs (q0));
-
-        ## If the global error estimate is meet exit
-        if (err0 < tol)
-          q = q0;
-          err = err0;
-          break;
-        endif
+      if (trace)
+        disp ([rows(subs), err, q0]);
+      endif
 
-        ## Accept the subintervals that meet the convergence criteria
-        idx = find (abs (q_errs) < tol .* abs (diff (subs, [], 2)) ./ h);
-        if (first)
-          q = sum (q_subs (idx));
-          err = sum (q_errs(idx));
-          first = false;
-        else
-          q0 = q + sum (q_subs);
-          err0 = err + sum (q_errs);
-          q += sum (q_subs (idx));
-          err += sum (q_errs(idx));
-        endif
-        subs(idx,:) = [];
-
-        ## If no remaining subintervals exit
-        if (rows (subs) == 0)
-          break;
-        endif
-
-        if (trace)
-          disp ([rows(subs), err, q0]);
-        endif
+      ## Split remaining subintervals in two
+      mid = (subs(:,2) + subs(:,1)) ./ 2;
+      subs = [subs(:,1), mid; mid, subs(:,2)];
 
-        ## Split remaining subintervals in two
-        mid = (subs(:,2) + subs(:,1)) ./ 2;
-        subs = [subs(:,1), mid; mid, subs(:,2)];
-
-        ## If the maximum subinterval count is met accept remaining
-        ## subinterval and exit
-        if (rows (subs) > maxint)
-          warning ("quadgk: maximum interval count (%d) met", maxint);
-          q += sum (q_subs);
-          err += sum (q_errs);
-          break;
-        endif
+      ## If the maximum subinterval count is met accept remaining
+      ## subinterval and exit
+      if (rows (subs) > maxint)
+        warning (warn_msg,
+                 "quadgk: maximum interval count (%d) met", maxint);
+        q += sum (q_subs);
+        err += sum (q_errs);
+        break;
+      endif
 
-        ## Evaluation of the integrand on the remaining subintervals
-        [q_subs, q_errs] = __quadgk_eval__ (f, subs);
-      endwhile
+      ## Evaluation of the integrand on the remaining subintervals
+      [q_subs, q_errs] = __quadgk_eval__ (f, subs);
+    endwhile
 
-      if (err > max (abstol, reltol * abs (q)))
-        warning ("quadgk: Error tolerance not met. Estimated error %g", err);
-      endif
-    unwind_protect_cleanup
-      if (strcmp (warn_state.state, "on"))
-        warning ("on", "Octave:divide-by-zero");
-      endif
-    end_unwind_protect
+    if (err > max (abstol, reltol * abs (q)))
+      warning (warn_msg,
+               "quadgk: Error tolerance not met. Estimated error %g", err);
+    endif
+
   endif
 endfunction
 
@@ -460,4 +464,3 @@
 %error (quadgk (@sin))
 %error (quadgk (@sin, -pi))
 %error (quadgk (@sin, -pi, pi, "DummyArg"))
-