# HG changeset patch
# User Rik <rik@octave.org>
# Date 1640650028 28800
# Node ID 83aeaba707d8cee847bd8af43663a505cc26841a
# Parent  16c5cdc7741e1f57701bd39138f1246288062d0d
doc: Use TF for output variable in documentation for isXXX functions in scripts/ directory.

* isplaying.m, isrecording.m, isequal.m, isequaln.m, iscolormap.m,
is_valid_file_id.m, isdir.m, isstr.m, isbanded.m, isdefinite.m, isdiag.m,
ishermitian.m, issymmetric.m, istril.m, istriu.m, isdeployed.m, isfolder.m,
ismac.m, ismethod.m, ispc.m, isunix.m, isaxes.m, isfigure.m, isgraphics.m,
ishandle.m, ishold.m, ispref.m, isprime.m, isletter.m, isstring.m, isstrprop.m,
is_leap_year.m:
Use TF for output variable in documentation for isXXX functions.
Change variable name in code function prototype to match documentation.

diff -r 16c5cdc7741e -r 83aeaba707d8 scripts/audio/@audioplayer/isplaying.m
--- a/scripts/audio/@audioplayer/isplaying.m	Mon Dec 27 15:51:12 2021 -0800
+++ b/scripts/audio/@audioplayer/isplaying.m	Mon Dec 27 16:07:08 2021 -0800
@@ -24,17 +24,17 @@
 ########################################################################
 
 ## -*- texinfo -*-
-## @deftypefn {} {} isplaying (@var{player})
+## @deftypefn {} {@var{tf} =} isplaying (@var{player})
 ## Return true if the audioplayer object @var{player} is currently playing back
 ## audio and false otherwise.
 ## @end deftypefn
 
-function result = isplaying (player)
+function tf = isplaying (player)
 
   if (nargin < 1)
     print_usage ();
   endif
 
-  result = __player_isplaying__ (struct (player).player);
+  tf = __player_isplaying__ (struct (player).player);
 
 endfunction
diff -r 16c5cdc7741e -r 83aeaba707d8 scripts/audio/@audiorecorder/isrecording.m
--- a/scripts/audio/@audiorecorder/isrecording.m	Mon Dec 27 15:51:12 2021 -0800
+++ b/scripts/audio/@audiorecorder/isrecording.m	Mon Dec 27 16:07:08 2021 -0800
@@ -24,17 +24,17 @@
 ########################################################################
 
 ## -*- texinfo -*-
-## @deftypefn {} {} isrecording (@var{recorder})
+## @deftypefn {} {@var{tf} =} isrecording (@var{recorder})
 ## Return true if the audiorecorder object @var{recorder} is currently
 ## recording audio and false otherwise.
 ## @end deftypefn
 
-function result = isrecording (recorder)
+function tf = isrecording (recorder)
 
   if (nargin < 1)
     print_usage ();
   endif
 
-  result = __recorder_isrecording__ (struct (recorder).recorder);
+  tf = __recorder_isrecording__ (struct (recorder).recorder);
 
 endfunction
diff -r 16c5cdc7741e -r 83aeaba707d8 scripts/general/isequal.m
--- a/scripts/general/isequal.m	Mon Dec 27 15:51:12 2021 -0800
+++ b/scripts/general/isequal.m	Mon Dec 27 16:07:08 2021 -0800
@@ -24,7 +24,7 @@
 ########################################################################
 
 ## -*- texinfo -*-
-## @deftypefn {} {} isequal (@var{x1}, @var{x2}, @dots{})
+## @deftypefn {} {@var{tf} =} isequal (@var{x1}, @var{x2}, @dots{})
 ## Return true if all of @var{x1}, @var{x2}, @dots{} are equal.
 ## @seealso{isequaln}
 ## @end deftypefn
@@ -46,7 +46,7 @@
 ##    e. cell       compare each member with isequal (recursive)
 ##    f. fcn_handle compare using overloaded "eq" operator
 
-function t = isequal (x, varargin)
+function tf = isequal (x, varargin)
 
   if (nargin < 2)
     print_usage ();
@@ -65,22 +65,22 @@
   ## All arguments must either be of the same class,
   ##  or they must be "numeric" values.
   if (two_args)
-    t = (strcmp (class (x), class (y))
-         || ((isreal (x) || iscomplex (x)) && (isreal (y) || iscomplex (y))));
+    tf = (strcmp (class (x), class (y))
+          || ((isreal (x) || iscomplex (x)) && (isreal (y) || iscomplex (y))));
   else
-    t = (all (cellfun ("isclass", varargin, class (x)))
-         || ((isreal (x) || iscomplex (x))
-             && all (cellfun ("isreal", varargin)
-                     | cellfun ("isnumeric", varargin))));
+    tf = (all (cellfun ("isclass", varargin, class (x)))
+          || ((isreal (x) || iscomplex (x))
+              && all (cellfun ("isreal", varargin)
+                      | cellfun ("isnumeric", varargin))));
   endif
 
   ## Test that everything is the same size (which also tests dimensions)
-  if (t)
-    t = size_equal (x, varargin{:});
+  if (tf)
+    tf = size_equal (x, varargin{:});
   endif
 
   ## From here on, compare any objects as if they were structures.
-  if (t && isobject (x))
+  if (tf && isobject (x))
     ## Locally suppress class-to-struct warning.  We know what we are doing.
     warning ("off", "Octave:classdef-to-struct", "local");
     x = builtin ("struct", x);
@@ -98,44 +98,44 @@
   ############################################################
   ## Check individual classes.
 
-  if (t)
+  if (tf)
     if (two_args)
 
       if (ischar (x) && ischar (y))
         ## char type.  Optimization, strcmp is ~35% faster than '==' operator.
-        t = strcmp (x, y);
+        tf = strcmp (x, y);
 
       elseif (isreal (x) || iscomplex (x))
         if (issparse (x))
           ## sparse types.
           [xi, xj, xv] = find (x);
           [yi, yj, yv] = find (y);
-          t = (length (xi) == length (yi)) && all (xi == yi) ...
+          tf = (length (xi) == length (yi)) && all (xi == yi) ...
               && all (xj == yj) && all (xv == yv);
         else
           ## general "numeric" type.  Use '==' operator.
           m = (x == y);
-          t = all (m(:));
+          tf = all (m(:));
         endif
 
       elseif (isstruct (x))
         ## struct type.  Compare # of fields, fieldnames, then field values.
 
         ## Test number of fields are equal.
-        t = (numfields (x) == numfields (y));
+        tf = (numfields (x) == numfields (y));
 
         ## Test that all the field names are equal.
-        if (t)
+        if (tf)
           s_fnm_x = sort (fieldnames (x));
-          t = all (strcmp (s_fnm_x, sort (fieldnames (y))));
+          tf = all (strcmp (s_fnm_x, sort (fieldnames (y))));
         endif
 
         ## Test that all field values are equal.  Slow because of recursion.
-        if (t)
+        if (tf)
           if (isscalar (x))
             for fldnm = s_fnm_x.'
-              t = isequal (x.(fldnm{1}), y.(fldnm{1}));
-              if (! t)
+              tf = isequal (x.(fldnm{1}), y.(fldnm{1}));
+              if (! tf)
                 break;
               endif
             endfor
@@ -143,8 +143,8 @@
             ## struct arrays have to have the contents of each field wrapped
             ## in a cell since it expands to a collection of values.
             for fldnm = s_fnm_x.'
-              t = isequal ({x.(fldnm{1})}, {y.(fldnm{1})});
-              if (! t)
+              tf = isequal ({x.(fldnm{1})}, {y.(fldnm{1})});
+              if (! tf)
                 break;
               endif
             endfor
@@ -156,20 +156,20 @@
         ## FIXME: It would be faster to use strcmp on whole cellstr arrays,
         ## but bug #51412 needs to be fixed.  Instead, time/space trade-off.
         ## Convert to char (space) for faster processing with strcmp (time).
-        t = strcmp (char (x), char (y));
+        tf = strcmp (char (x), char (y));
 
       elseif (iscell (x))
         ## cell type.  Check that each element of a cell is equal.  Slow.
         n = numel (x);
         idx = 1;
-        while (t && idx <= n)
-          t = isequal (x{idx}, y{idx});
+        while (tf && idx <= n)
+          tf = isequal (x{idx}, y{idx});
           idx += 1;
         endwhile
 
       elseif (is_function_handle (x))
         ## function type.  Use '==' operator which is overloaded.
-        t = (x == y);
+        tf = (x == y);
 
       else
         error ("isequal: Impossible to reach code.  File a bug report.");
@@ -181,8 +181,8 @@
       if (ischar (x) && all (cellfun ("isclass", varargin, "char")))
         ## char type.  Optimization, strcmp is ~35% faster than '==' operator.
         idx = 1;
-        while (t && idx <= nvarargin)
-          t = strcmp (x, varargin{idx});
+        while (tf && idx <= nvarargin)
+          tf = strcmp (x, varargin{idx});
           idx += 1;
         endwhile
 
@@ -193,11 +193,11 @@
 
           idx = 1;
           [xi, xj, xv] = find (x);
-          while (t && idx <= nvarargin)
+          while (tf && idx <= nvarargin)
             y = varargin{idx};
             [yi, yj, yv] = find (y);
-            t = (length (xi) == length (yi)) && all (xi == yi) ...
-                && all (xj == yj) && all (xv == yv);
+            tf = (length (xi) == length (yi)) && all (xi == yi) ...
+                 && all (xj == yj) && all (xv == yv);
 
             idx += 1;
           endwhile
@@ -206,10 +206,10 @@
           ## general "numeric" type.  Use '==' operator.
 
           idx = 1;
-          while (t && idx <= nvarargin)
+          while (tf && idx <= nvarargin)
             y = varargin{idx};
             m = (x == y);
-            t = all (m(:));
+            tf = all (m(:));
 
             idx += 1;
           endwhile
@@ -223,21 +223,21 @@
         fnm_x = fieldnames (x);
         n = numel (fnm_x);
         fnm_v = cellfun ("fieldnames", varargin, "uniformoutput", false);
-        t = all (n == cellfun ("numel", fnm_v));
+        tf = all (n == cellfun ("numel", fnm_v));
 
         ## Test that all the field names are equal.
-        if (t)
+        if (tf)
           fnm_x = sort (fnm_x);
           idx = 1;
-          while (t && idx <= nvarargin)
+          while (tf && idx <= nvarargin)
             ## Allow the fieldnames to be in a different order.
-            t = all (strcmp (fnm_x, sort (fnm_v{idx})));
+            tf = all (strcmp (fnm_x, sort (fnm_v{idx})));
             idx += 1;
           endwhile
         endif
 
         ## Test that all field values are equal.  Slow because of recursion.
-        if (t)
+        if (tf)
           args = cell (1, 1 + nvarargin);
           if (isscalar (x))
             for fldnm = fnm_x.'
@@ -246,9 +246,9 @@
                 args{argn+1} = varargin{argn}.(fldnm{1});
               endfor
 
-              t = isequal (args{:});
+              tf = isequal (args{:});
 
-              if (! t)
+              if (! tf)
                 break;
               endif
             endfor
@@ -261,9 +261,9 @@
                 args{argn+1} = { varargin{argn}.(fldnm{1}) };
               endfor
 
-              t = isequal (args{:});
+              tf = isequal (args{:});
 
-              if (! t)
+              if (! tf)
                 break;
               endif
             endfor
@@ -277,8 +277,8 @@
         ## Convert to char (space) for faster processing with strcmp (time).
         idx = 1;
         x = char (x);
-        while (t && idx <= nvarargin)
-          t = strcmp (x, char (varargin{idx}));
+        while (tf && idx <= nvarargin)
+          tf = strcmp (x, char (varargin{idx}));
           idx += 1;
         endwhile
 
@@ -287,18 +287,18 @@
         n = numel (x);
         args = cell (1, 1 + nvarargin);
         idx = 1;
-        while (t && idx <= n)
+        while (tf && idx <= n)
           args(1) = x{idx};
           args(2:end) = [cellindexmat(varargin, idx){:}];
 
-          t = isequal (args{:});
+          tf = isequal (args{:});
 
           idx += 1;
         endwhile
 
       elseif (is_function_handle (x))
         ## function type.  Use '==' operator which is overloaded.
-        t = all (cellfun ("eq", {x}, varargin));
+        tf = all (cellfun ("eq", {x}, varargin));
 
       else
         error ("isequal: Impossible to reach code.  File a bug report.");
@@ -308,7 +308,7 @@
     endif
   endif
 
-  t = full (t);  # Always return full logical value for Matlab compatibility.
+  tf = full (tf);  # Always return full logical value for Matlab compatibility.
 
 endfunction
 
diff -r 16c5cdc7741e -r 83aeaba707d8 scripts/general/isequaln.m
--- a/scripts/general/isequaln.m	Mon Dec 27 15:51:12 2021 -0800
+++ b/scripts/general/isequaln.m	Mon Dec 27 16:07:08 2021 -0800
@@ -24,7 +24,7 @@
 ########################################################################
 
 ## -*- texinfo -*-
-## @deftypefn {} {} isequaln (@var{x1}, @var{x2}, @dots{})
+## @deftypefn {} {@var{tf} =} isequaln (@var{x1}, @var{x2}, @dots{})
 ## Return true if all of @var{x1}, @var{x2}, @dots{} are equal under the
 ## additional assumption that NaN == NaN (no comparison of NaN placeholders
 ## in dataset).
@@ -48,7 +48,7 @@
 ##    e. cell       compare each member with isequaln (recursive)
 ##    f. fcn_handle compare using overloaded "eq" operator
 
-function t = isequaln (x, varargin)
+function tf = isequaln (x, varargin)
 
   if (nargin < 2)
     print_usage ();
@@ -67,22 +67,22 @@
   ## All arguments must either be of the same class,
   ##  or they must be "numeric" values.
   if (two_args)
-    t = (strcmp (class (x), class (y))
-         || ((isreal (x) || iscomplex (x)) && (isreal (y) || iscomplex (y))));
+    tf = (strcmp (class (x), class (y))
+          || ((isreal (x) || iscomplex (x)) && (isreal (y) || iscomplex (y))));
   else
-    t = (all (cellfun ("isclass", varargin, class (x)))
-         || ((isreal (x) || iscomplex (x))
-             && all (cellfun ("isreal", varargin)
-                     | cellfun ("isnumeric", varargin))));
+    tf = (all (cellfun ("isclass", varargin, class (x)))
+          || ((isreal (x) || iscomplex (x))
+              && all (cellfun ("isreal", varargin)
+                      | cellfun ("isnumeric", varargin))));
   endif
 
   ## Test that everything is the same size (which also tests dimensions)
-  if (t)
-    t = size_equal (x, varargin{:});
+  if (tf)
+    tf = size_equal (x, varargin{:});
   endif
 
   ## From here on, compare any objects as if they were structures.
-  if (t && isobject (x))
+  if (tf && isobject (x))
     ## Locally suppress class-to-struct warning.  We know what we are doing.
     warning ("off", "Octave:classdef-to-struct", "local");
     x = builtin ("struct", x);
@@ -100,40 +100,40 @@
   ############################################################
   ## Check individual classes.
 
-  if (t)
+  if (tf)
     if (two_args)
 
       if (ischar (x) && ischar (y))
         ## char type.  Optimization, strcmp is ~35% faster than '==' operator.
-        t = strcmp (x, y);
+        tf = strcmp (x, y);
 
       elseif (isreal (x) || iscomplex (x))
         ## general "numeric" type.  Use '==' operator.
         m = (x == y);
-        t = all (m(:));
+        tf = all (m(:));
 
-        if (! t && isfloat (x) && isfloat (y))
-          t = isnan (x(! m)) && isnan (y(! m));
+        if (! tf && isfloat (x) && isfloat (y))
+          tf = isnan (x(! m)) && isnan (y(! m));
         endif
 
       elseif (isstruct (x))
         ## struct type.  Compare # of fields, fieldnames, then field values.
 
         ## Test number of fields are equal.
-        t = (numfields (x) == numfields (y));
+        tf = (numfields (x) == numfields (y));
 
         ## Test that all the field names are equal.
-        if (t)
+        if (tf)
           s_fnm_x = sort (fieldnames (x));
-          t = all (strcmp (s_fnm_x, sort (fieldnames (y))));
+          tf = all (strcmp (s_fnm_x, sort (fieldnames (y))));
         endif
 
         ## Test that all field values are equal.  Slow because of recursion.
-        if (t)
+        if (tf)
           if (isscalar (x))
             for fldnm = s_fnm_x.'
-              t = isequaln (x.(fldnm{1}), y.(fldnm{1}));
-              if (! t)
+              tf = isequaln (x.(fldnm{1}), y.(fldnm{1}));
+              if (! tf)
                 break;
               endif
             endfor
@@ -141,8 +141,8 @@
             ## struct arrays have to have the contents of each field wrapped
             ## in a cell since it expands to a collection of values.
             for fldnm = s_fnm_x.'
-              t = isequaln ({x.(fldnm{1})}, {y.(fldnm{1})});
-              if (! t)
+              tf = isequaln ({x.(fldnm{1})}, {y.(fldnm{1})});
+              if (! tf)
                 break;
               endif
             endfor
@@ -154,20 +154,20 @@
         ## FIXME: It would be faster to use strcmp on whole cellstr arrays,
         ## but bug #51412 needs to be fixed.  Instead, time/space trade-off.
         ## Convert to char (space) for faster processing with strcmp (time).
-        t = strcmp (char (x), char (y));
+        tf = strcmp (char (x), char (y));
 
       elseif (iscell (x))
         ## cell type.  Check that each element of a cell is equal.  Slow.
         n = numel (x);
         idx = 1;
-        while (t && idx <= n)
-          t = isequaln (x{idx}, y{idx});
+        while (tf && idx <= n)
+          tf = isequaln (x{idx}, y{idx});
           idx += 1;
         endwhile
 
       elseif (is_function_handle (x))
         ## function type.  Use '==' operator which is overloaded.
-        t = (x == y);
+        tf = (x == y);
 
       else
         error ("isequaln: Impossible to reach code.  File a bug report.");
@@ -179,8 +179,8 @@
       if (ischar (x) && all (cellfun ("isclass", varargin, "char")))
         ## char type.  Optimization, strcmp is ~35% faster than '==' operator.
         idx = 1;
-        while (t && idx <= nvarargin)
-          t = strcmp (x, varargin{idx});
+        while (tf && idx <= nvarargin)
+          tf = strcmp (x, varargin{idx});
           idx += 1;
         endwhile
 
@@ -188,13 +188,13 @@
         ## general "numeric" type.  Use '==' operator.
 
         idx = 1;
-        while (t && idx <= nvarargin)
+        while (tf && idx <= nvarargin)
           y = varargin{idx};
           m = (x == y);
-          t = all (m(:));
+          tf = all (m(:));
 
-          if (! t && isfloat (x) && isfloat (y))
-            t = isnan (x(! m)) && isnan (y(! m));
+          if (! tf && isfloat (x) && isfloat (y))
+            tf = isnan (x(! m)) && isnan (y(! m));
           endif
 
           idx += 1;
@@ -207,21 +207,21 @@
         fnm_x = fieldnames (x);
         n = numel (fnm_x);
         fnm_v = cellfun ("fieldnames", varargin, "uniformoutput", false);
-        t = all (n == cellfun ("numel", fnm_v));
+        tf = all (n == cellfun ("numel", fnm_v));
 
         ## Test that all the field names are equal.
-        if (t)
+        if (tf)
           fnm_x = sort (fnm_x);
           idx = 1;
-          while (t && idx <= nvarargin)
+          while (tf && idx <= nvarargin)
             ## Allow the fieldnames to be in a different order.
-            t = all (strcmp (fnm_x, sort (fnm_v{idx})));
+            tf = all (strcmp (fnm_x, sort (fnm_v{idx})));
             idx += 1;
           endwhile
         endif
 
         ## Test that all field values are equal.  Slow because of recursion.
-        if (t)
+        if (tf)
           args = cell (1, 1 + nvarargin);
           if (isscalar (x))
             for fldnm = fnm_x.'
@@ -230,9 +230,9 @@
                 args{argn+1} = varargin{argn}.(fldnm{1});
               endfor
 
-              t = isequaln (args{:});
+              tf = isequaln (args{:});
 
-              if (! t)
+              if (! tf)
                 break;
               endif
             endfor
@@ -245,9 +245,9 @@
                 args{argn+1} = { varargin{argn}.(fldnm{1}) };
               endfor
 
-              t = isequaln (args{:});
+              tf = isequaln (args{:});
 
-              if (! t)
+              if (! tf)
                 break;
               endif
             endfor
@@ -261,8 +261,8 @@
         ## Convert to char (space) for faster processing with strcmp (time).
         idx = 1;
         x = char (x);
-        while (t && idx <= nvarargin)
-          t = strcmp (x, char (varargin{idx}));
+        while (tf && idx <= nvarargin)
+          tf = strcmp (x, char (varargin{idx}));
           idx += 1;
         endwhile
 
@@ -271,18 +271,18 @@
         n = numel (x);
         args = cell (1, 1 + nvarargin);
         idx = 1;
-        while (t && idx <= n)
+        while (tf && idx <= n)
           args(1) = x{idx};
           args(2:end) = [cellindexmat(varargin, idx){:}];
 
-          t = isequaln (args{:});
+          tf = isequaln (args{:});
 
           idx += 1;
         endwhile
 
       elseif (is_function_handle (x))
         ## function type.  Use '==' operator which is overloaded.
-        t = all (cellfun ("eq", {x}, varargin));
+        tf = all (cellfun ("eq", {x}, varargin));
 
       else
         error ("isequaln: Impossible to reach code.  File a bug report.");
@@ -292,7 +292,7 @@
     endif
   endif
 
-  t = full (t);  # Always return full logical value for Matlab compatibility.
+  tf = full (tf);  # Always return full logical value for Matlab compatibility.
 
 endfunction
 
diff -r 16c5cdc7741e -r 83aeaba707d8 scripts/image/iscolormap.m
--- a/scripts/image/iscolormap.m	Mon Dec 27 15:51:12 2021 -0800
+++ b/scripts/image/iscolormap.m	Mon Dec 27 16:07:08 2021 -0800
@@ -24,7 +24,7 @@
 ########################################################################
 
 ## -*- texinfo -*-
-## @deftypefn {} {} iscolormap (@var{cmap})
+## @deftypefn {} {@var{tf} =} iscolormap (@var{cmap})
 ## Return true if @var{cmap} is a colormap.
 ##
 ## A colormap is a real matrix, of class single or double, with 3 columns.
@@ -38,15 +38,14 @@
 ## @seealso{colormap, rgbplot}
 ## @end deftypefn
 
-function retval = iscolormap (cmap)
+function tf = iscolormap (cmap)
 
   if (nargin < 1)
     print_usage ();
   endif
 
-  retval = (isnumeric (cmap) && isreal (cmap)
-            && ndims (cmap) == 2 && columns (cmap) == 3
-            && isfloat (cmap));
+  tf = isnumeric (cmap) && isreal (cmap) && isfloat (cmap) ...
+       && ndims (cmap) == 2 && columns (cmap) == 3;
 
 endfunction
 
diff -r 16c5cdc7741e -r 83aeaba707d8 scripts/io/is_valid_file_id.m
--- a/scripts/io/is_valid_file_id.m	Mon Dec 27 15:51:12 2021 -0800
+++ b/scripts/io/is_valid_file_id.m	Mon Dec 27 16:07:08 2021 -0800
@@ -24,23 +24,23 @@
 ########################################################################
 
 ## -*- texinfo -*-
-## @deftypefn {} {} is_valid_file_id (@var{fid})
+## @deftypefn {} {@var{tf} =} is_valid_file_id (@var{fid})
 ## Return true if @var{fid} refers to an open file.
 ## @seealso{freport, fopen}
 ## @end deftypefn
 
-function retval = is_valid_file_id (fid)
+function tf = is_valid_file_id (fid)
 
   if (nargin < 1)
     print_usage ();
   endif
 
-  retval = false;
+  tf = false;
 
   try
     if (isscalar (fid))
       [file, mode, arch] = fopen (fid);
-      retval = ! isempty (file);
+      tf = ! isempty (file);
     endif
   end_try_catch
 
diff -r 16c5cdc7741e -r 83aeaba707d8 scripts/legacy/isdir.m
--- a/scripts/legacy/isdir.m	Mon Dec 27 15:51:12 2021 -0800
+++ b/scripts/legacy/isdir.m	Mon Dec 27 16:07:08 2021 -0800
@@ -24,7 +24,7 @@
 ########################################################################
 
 ## -*- texinfo -*-
-## @deftypefn {} {} isdir (@var{f})
+## @deftypefn {} {@var{tf} =} isdir (@var{f})
 ##
 ## This function is not recommended.  Use @code{isfolder} or
 ## @code{file_in_loadpath} instead.
@@ -43,7 +43,7 @@
 ## is_rooted_relative_filename}
 ## @end deftypefn
 
-function retval = isdir (f)
+function tf = isdir (f)
 
   persistent warned = false;
   if (! warned)
@@ -57,7 +57,7 @@
   endif
 
   ## Exist returns an integer but isdir should return a logical.
-  retval = (exist (f, "dir") == 7);
+  tf = (exist (f, "dir") == 7);
 
 endfunction
 
diff -r 16c5cdc7741e -r 83aeaba707d8 scripts/legacy/isstr.m
--- a/scripts/legacy/isstr.m	Mon Dec 27 15:51:12 2021 -0800
+++ b/scripts/legacy/isstr.m	Mon Dec 27 16:07:08 2021 -0800
@@ -24,7 +24,7 @@
 ########################################################################
 
 ## -*- texinfo -*-
-## @deftypefn {} {} isstr (@var{x})
+## @deftypefn {} {@var{tf} =} isstr (@var{x})
 ## This function is obsolete.  Use @code{ischar} instead.
 ## @seealso{ischar}
 ## @end deftypefn
@@ -33,7 +33,7 @@
 ## removed in some future version.  Now users are told that it should be
 ## avoided, but there is no mention of possible future removal.
 
-function retval = isstr (varargin)
+function tf = isstr (varargin)
 
   persistent warned = false;
   if (! warned)
@@ -42,6 +42,6 @@
              "isstr is obsolete; please use ischar instead");
   endif
 
-  retval = ischar (varargin{:});
+  tf = ischar (varargin{:});
 
 endfunction
diff -r 16c5cdc7741e -r 83aeaba707d8 scripts/linear-algebra/isbanded.m
--- a/scripts/linear-algebra/isbanded.m	Mon Dec 27 15:51:12 2021 -0800
+++ b/scripts/linear-algebra/isbanded.m	Mon Dec 27 16:07:08 2021 -0800
@@ -24,7 +24,7 @@
 ########################################################################
 
 ## -*- texinfo -*-
-## @deftypefn {} {} isbanded (@var{A}, @var{lower}, @var{upper})
+## @deftypefn {} {@var{tf} =} isbanded (@var{A}, @var{lower}, @var{upper})
 ## Return true if @var{A} is a matrix with entries confined between
 ## @var{lower} diagonals below the main diagonal and @var{upper} diagonals
 ## above the main diagonal.
@@ -33,7 +33,7 @@
 ## @seealso{isdiag, istril, istriu, bandwidth}
 ## @end deftypefn
 
-function retval = isbanded (A, lower, upper)
+function tf = isbanded (A, lower, upper)
 
   if (nargin != 3)
     print_usage ();
@@ -44,16 +44,16 @@
   endif
 
   if (isempty (A))
-    retval = [];
+    tf = [];
   else
-    retval = (isnumeric (A) || islogical (A)) && ndims (A) == 2;
-    if (retval)
+    tf = (isnumeric (A) || islogical (A)) && ndims (A) == 2;
+    if (tf)
       [i, j] = find (A);
       pupp = j >= i;
-      retval = all (j(pupp) - i(pupp) <= upper);
-      if (retval)
+      tf = all (j(pupp) - i(pupp) <= upper);
+      if (tf)
         plow = i >= j;
-        retval = all (i(plow) - j(plow) <= lower);
+        tf = all (i(plow) - j(plow) <= lower);
       endif
     endif
   endif
diff -r 16c5cdc7741e -r 83aeaba707d8 scripts/linear-algebra/isdefinite.m
--- a/scripts/linear-algebra/isdefinite.m	Mon Dec 27 15:51:12 2021 -0800
+++ b/scripts/linear-algebra/isdefinite.m	Mon Dec 27 16:07:08 2021 -0800
@@ -24,8 +24,8 @@
 ########################################################################
 
 ## -*- texinfo -*-
-## @deftypefn  {} {} isdefinite (@var{A})
-## @deftypefnx {} {} isdefinite (@var{A}, @var{tol})
+## @deftypefn  {} {@var{tf} =} isdefinite (@var{A})
+## @deftypefnx {} {@var{tf} =} isdefinite (@var{A}, @var{tol})
 ## Return true if @var{A} is symmetric positive definite matrix within the
 ## tolerance specified by @var{tol}.
 ##
@@ -47,14 +47,14 @@
 ## @seealso{issymmetric, ishermitian}
 ## @end deftypefn
 
-function retval = isdefinite (A, tol)
+function tf = isdefinite (A, tol)
 
   if (nargin < 1)
     print_usage ();
   endif
 
   ## Validate inputs
-  retval = false;
+  tf = false;
   if (! isnumeric (A))
     return;
   endif
@@ -76,7 +76,7 @@
   e = tol * eye (rows (A));
   [~, p] = chol (A - e);
   if (p == 0)
-    retval = true;
+    tf = true;
   endif
 
 endfunction
diff -r 16c5cdc7741e -r 83aeaba707d8 scripts/linear-algebra/isdiag.m
--- a/scripts/linear-algebra/isdiag.m	Mon Dec 27 15:51:12 2021 -0800
+++ b/scripts/linear-algebra/isdiag.m	Mon Dec 27 16:07:08 2021 -0800
@@ -24,24 +24,24 @@
 ########################################################################
 
 ## -*- texinfo -*-
-## @deftypefn {} {} isdiag (@var{A})
+## @deftypefn {} {@var{tf} =} isdiag (@var{A})
 ## Return true if @var{A} is a diagonal matrix.
 ## @seealso{isbanded, istril, istriu, diag, bandwidth}
 ## @end deftypefn
 
-function retval = isdiag (A)
+function tf = isdiag (A)
 
   if (nargin < 1)
     print_usage ();
   endif
 
   if (strfind (typeinfo (A), "diagonal matrix"))
-    retval = true;
+    tf = true;
   elseif ((isnumeric (A) || islogical (A)) && ndims (A) == 2)
     [i, j] = find (A);
-    retval = all (i == j);
+    tf = all (i == j);
   else
-    retval = false;
+    tf = false;
   endif
 
 endfunction
diff -r 16c5cdc7741e -r 83aeaba707d8 scripts/linear-algebra/ishermitian.m
--- a/scripts/linear-algebra/ishermitian.m	Mon Dec 27 15:51:12 2021 -0800
+++ b/scripts/linear-algebra/ishermitian.m	Mon Dec 27 16:07:08 2021 -0800
@@ -24,10 +24,10 @@
 ########################################################################
 
 ## -*- texinfo -*-
-## @deftypefn  {} {} ishermitian (@var{A})
-## @deftypefnx {} {} ishermitian (@var{A}, @var{tol})
-## @deftypefnx {} {} ishermitian (@var{A}, @qcode{"skew"})
-## @deftypefnx {} {} ishermitian (@var{A}, @qcode{"skew"}, @var{tol})
+## @deftypefn  {} {@var{tf} =} ishermitian (@var{A})
+## @deftypefnx {} {@var{tf} =} ishermitian (@var{A}, @var{tol})
+## @deftypefnx {} {@var{tf} =} ishermitian (@var{A}, @qcode{"skew"})
+## @deftypefnx {} {@var{tf} =} ishermitian (@var{A}, @qcode{"skew"}, @var{tol})
 ## Return true if @var{A} is a Hermitian or skew-Hermitian matrix within the
 ## tolerance specified by @var{tol}.
 ##
@@ -50,7 +50,7 @@
 ## @seealso{issymmetric, isdefinite}
 ## @end deftypefn
 
-function retval = ishermitian (A, skewopt = "nonskew", tol = 0)
+function tf = ishermitian (A, skewopt = "nonskew", tol = 0)
 
   if (nargin < 1)
     print_usage ();
@@ -67,8 +67,8 @@
   endif
 
   ## Validate inputs
-  retval = (isnumeric (A) || islogical (A)) && issquare (A);
-  if (! retval)
+  tf = (isnumeric (A) || islogical (A)) && issquare (A);
+  if (! tf)
     return;
   endif
 
@@ -84,26 +84,26 @@
   if (strcmp (skewopt, "nonskew"))
     if (tol == 0)
       ## check for exact symmetry
-      retval = full (! any ((A != A')(:)));
+      tf = full (! any ((A != A')(:)));
     else
       if (islogical (A))
         ## Hack to allow norm to work.  Choose single to minimize memory.
         A = single (A);
       endif
       norm_x = norm (A, Inf);
-      retval = norm_x == 0 || norm (A - A', Inf) / norm_x <= tol;
+      tf = norm_x == 0 || norm (A - A', Inf) / norm_x <= tol;
     endif
   else
     ## skew-Hermitian
     if (tol == 0)
-      retval = full (! any ((A != -A')(:)));
+      tf = full (! any ((A != -A')(:)));
     else
       if (islogical (A))
         ## Hack to allow norm to work.  Choose single to minimize memory.
         A = single (A);
       endif
       norm_x = norm (A, Inf);
-      retval = norm_x == 0 || norm (A + A', Inf) / norm_x <= tol;
+      tf = norm_x == 0 || norm (A + A', Inf) / norm_x <= tol;
     endif
   endif
 
diff -r 16c5cdc7741e -r 83aeaba707d8 scripts/linear-algebra/issymmetric.m
--- a/scripts/linear-algebra/issymmetric.m	Mon Dec 27 15:51:12 2021 -0800
+++ b/scripts/linear-algebra/issymmetric.m	Mon Dec 27 16:07:08 2021 -0800
@@ -24,10 +24,10 @@
 ########################################################################
 
 ## -*- texinfo -*-
-## @deftypefn  {} {} issymmetric (@var{A})
-## @deftypefnx {} {} issymmetric (@var{A}, @var{tol})
-## @deftypefnx {} {} issymmetric (@var{A}, @qcode{"skew"})
-## @deftypefnx {} {} issymmetric (@var{A}, @qcode{"skew"}, @var{tol})
+## @deftypefn  {} {@var{tf} =} issymmetric (@var{A})
+## @deftypefnx {} {@var{tf} =} issymmetric (@var{A}, @var{tol})
+## @deftypefnx {} {@var{tf} =} issymmetric (@var{A}, @qcode{"skew"})
+## @deftypefnx {} {@var{tf} =} issymmetric (@var{A}, @qcode{"skew"}, @var{tol})
 ## Return true if @var{A} is a symmetric or skew-symmetric matrix within the
 ## tolerance specified by @var{tol}.
 ##
@@ -49,7 +49,7 @@
 ## @seealso{ishermitian, isdefinite}
 ## @end deftypefn
 
-function retval = issymmetric (A, skewopt = "nonskew", tol = 0)
+function tf = issymmetric (A, skewopt = "nonskew", tol = 0)
 
   if (nargin < 1)
     print_usage ();
@@ -79,7 +79,7 @@
   endif
 
   if (! issquare (A))
-    retval = false;
+    tf = false;
     return;
   endif
 
@@ -87,26 +87,26 @@
   if (strcmp (skewopt, "nonskew"))
     if (tol == 0)
       ## check for exact symmetry
-      retval = full (! any ((A != A.')(:)));
+      tf = full (! any ((A != A.')(:)));
     else
       if (! isnumeric (A))
         ## Hack to allow norm to work.  Choose single to minimize memory.
         A = single (A);
       endif
       norm_x = norm (A, Inf);
-      retval = norm_x == 0 || norm (A - A.', Inf) / norm_x <= tol;
+      tf = norm_x == 0 || norm (A - A.', Inf) / norm_x <= tol;
     endif
   else
     ## skew symmetry
     if (tol == 0)
-      retval = full (! any ((A != -A.')(:)));
+      tf = full (! any ((A != -A.')(:)));
     else
       if (! isnumeric (A))
         ## Hack to allow norm to work.  Choose single to minimize memory.
         A = single (A);
       endif
       norm_x = norm (A, Inf);
-      retval = norm_x == 0 || norm (A + A.', Inf) / norm_x <= tol;
+      tf = norm_x == 0 || norm (A + A.', Inf) / norm_x <= tol;
     endif
   endif
 
diff -r 16c5cdc7741e -r 83aeaba707d8 scripts/linear-algebra/istril.m
--- a/scripts/linear-algebra/istril.m	Mon Dec 27 15:51:12 2021 -0800
+++ b/scripts/linear-algebra/istril.m	Mon Dec 27 16:07:08 2021 -0800
@@ -24,7 +24,7 @@
 ########################################################################
 
 ## -*- texinfo -*-
-## @deftypefn {} {} istril (@var{A})
+## @deftypefn {} {@var{tf} =} istril (@var{A})
 ## Return true if @var{A} is a lower triangular matrix.
 ##
 ## A lower triangular matrix has nonzero entries only on the main diagonal and
@@ -32,16 +32,16 @@
 ## @seealso{istriu, isbanded, isdiag, tril, bandwidth}
 ## @end deftypefn
 
-function retval = istril (A)
+function tf = istril (A)
 
   if (nargin < 1)
     print_usage ();
   endif
 
-  retval = (isnumeric (A) || islogical (A)) && ndims (A) == 2;
-  if (retval)
+  tf = (isnumeric (A) || islogical (A)) && ndims (A) == 2;
+  if (tf)
     [i, j] = find (A);
-    retval = all (i >= j);
+    tf = all (i >= j);
   endif
 
 endfunction
diff -r 16c5cdc7741e -r 83aeaba707d8 scripts/linear-algebra/istriu.m
--- a/scripts/linear-algebra/istriu.m	Mon Dec 27 15:51:12 2021 -0800
+++ b/scripts/linear-algebra/istriu.m	Mon Dec 27 16:07:08 2021 -0800
@@ -24,7 +24,7 @@
 ########################################################################
 
 ## -*- texinfo -*-
-## @deftypefn {} {} istriu (@var{A})
+## @deftypefn {} {@var{tf} =} istriu (@var{A})
 ## Return true if @var{A} is an upper triangular matrix.
 ##
 ## An upper triangular matrix has nonzero entries only on the main diagonal and
@@ -32,16 +32,16 @@
 ## @seealso{isdiag, isbanded, istril, triu, bandwidth}
 ## @end deftypefn
 
-function retval = istriu (A)
+function tf = istriu (A)
 
   if (nargin < 1)
     print_usage ();
   endif
 
-  retval = (isnumeric (A) || islogical (A)) && ndims (A) == 2;
-  if (retval)
+  tf = (isnumeric (A) || islogical (A)) && ndims (A) == 2;
+  if (tf)
     [i, j] = find (A);
-    retval = all (i <= j);
+    tf = all (i <= j);
   endif
 
 endfunction
diff -r 16c5cdc7741e -r 83aeaba707d8 scripts/miscellaneous/isdeployed.m
--- a/scripts/miscellaneous/isdeployed.m	Mon Dec 27 15:51:12 2021 -0800
+++ b/scripts/miscellaneous/isdeployed.m	Mon Dec 27 16:07:08 2021 -0800
@@ -24,7 +24,7 @@
 ########################################################################
 
 ## -*- texinfo -*-
-## @deftypefn {} {} isdeployed ()
+## @deftypefn {} {@var{tf} =} isdeployed ()
 ## Return true if the current program has been compiled and is running
 ## separately from the Octave interpreter and false if it is running in
 ## the Octave interpreter.
@@ -32,8 +32,8 @@
 ## Currently, this function always returns false in Octave.
 ## @end deftypefn
 
-function retval = isdeployed ()
-  retval = false;
+function tf = isdeployed ()
+  tf = false;
 endfunction
 
 
diff -r 16c5cdc7741e -r 83aeaba707d8 scripts/miscellaneous/isfolder.m
--- a/scripts/miscellaneous/isfolder.m	Mon Dec 27 15:51:12 2021 -0800
+++ b/scripts/miscellaneous/isfolder.m	Mon Dec 27 16:07:08 2021 -0800
@@ -33,7 +33,7 @@
 ## is_rooted_relative_filename}
 ## @end deftypefn
 
-function retval = isfolder (f)
+function tf = isfolder (f)
 
   if (nargin < 1)
     print_usage ();
@@ -44,10 +44,10 @@
   endif
 
   f = cellstr (f);
-  retval = false (size (f));
+  tf = false (size (f));
   for i = 1:numel (f)
     [info, err] = stat (f{i});
-    retval(i) = (! err && S_ISDIR (info.mode));
+    tf(i) = (! err && S_ISDIR (info.mode));
   endfor
 
 endfunction
diff -r 16c5cdc7741e -r 83aeaba707d8 scripts/miscellaneous/ismac.m
--- a/scripts/miscellaneous/ismac.m	Mon Dec 27 15:51:12 2021 -0800
+++ b/scripts/miscellaneous/ismac.m	Mon Dec 27 16:07:08 2021 -0800
@@ -24,14 +24,14 @@
 ########################################################################
 
 ## -*- texinfo -*-
-## @deftypefn {} {} ismac ()
+## @deftypefn {} {@var{tf} =} ismac ()
 ## Return true if Octave is running on a Mac OS X system and false otherwise.
 ## @seealso{isunix, ispc}
 ## @end deftypefn
 
-function retval = ismac ()
+function tf = ismac ()
 
-  retval = __octave_config_info__ ("mac");
+  tf = __octave_config_info__ ("mac");
 
 endfunction
 
diff -r 16c5cdc7741e -r 83aeaba707d8 scripts/miscellaneous/ismethod.m
--- a/scripts/miscellaneous/ismethod.m	Mon Dec 27 15:51:12 2021 -0800
+++ b/scripts/miscellaneous/ismethod.m	Mon Dec 27 16:07:08 2021 -0800
@@ -24,14 +24,14 @@
 ########################################################################
 
 ## -*- texinfo -*-
-## @deftypefn  {} {} ismethod (@var{obj}, @var{method})
-## @deftypefnx {} {} ismethod (@var{class_name}, @var{method})
+## @deftypefn  {} {@var{tf} =} ismethod (@var{obj}, @var{method})
+## @deftypefnx {} {@var{tf} =} ismethod (@var{class_name}, @var{method})
 ## Return true if the string @var{method} is a valid method of the object
 ## @var{obj} or of the class @var{clsname}.
 ## @seealso{isprop, isobject, isjava, methods}
 ## @end deftypefn
 
-function retval = ismethod (obj, method)
+function tf = ismethod (obj, method)
 
   if (nargin != 2)
     print_usage ();
@@ -47,7 +47,7 @@
 
   method_list = methods (obj);
 
-  retval = ismember (method, method_list);
+  tf = ismember (method, method_list);
 
 endfunction
 
diff -r 16c5cdc7741e -r 83aeaba707d8 scripts/miscellaneous/ispc.m
--- a/scripts/miscellaneous/ispc.m	Mon Dec 27 15:51:12 2021 -0800
+++ b/scripts/miscellaneous/ispc.m	Mon Dec 27 16:07:08 2021 -0800
@@ -24,14 +24,14 @@
 ########################################################################
 
 ## -*- texinfo -*-
-## @deftypefn {} {} ispc ()
+## @deftypefn {} {@var{tf} =} ispc ()
 ## Return true if Octave is running on a Windows system and false otherwise.
 ## @seealso{isunix, ismac}
 ## @end deftypefn
 
-function retval = ispc ()
+function tf = ispc ()
 
-  retval = __octave_config_info__ ("windows");
+  tf = __octave_config_info__ ("windows");
 
 endfunction
 
diff -r 16c5cdc7741e -r 83aeaba707d8 scripts/miscellaneous/isunix.m
--- a/scripts/miscellaneous/isunix.m	Mon Dec 27 15:51:12 2021 -0800
+++ b/scripts/miscellaneous/isunix.m	Mon Dec 27 16:07:08 2021 -0800
@@ -24,14 +24,14 @@
 ########################################################################
 
 ## -*- texinfo -*-
-## @deftypefn {} {} isunix ()
+## @deftypefn {} {@var{tf} =} isunix ()
 ## Return true if Octave is running on a Unix-like system and false otherwise.
 ## @seealso{ismac, ispc}
 ## @end deftypefn
 
-function retval = isunix ()
+function tf = isunix ()
 
-  retval = __octave_config_info__ ("unix");
+  tf = __octave_config_info__ ("unix");
 
 endfunction
 
diff -r 16c5cdc7741e -r 83aeaba707d8 scripts/plot/util/isaxes.m
--- a/scripts/plot/util/isaxes.m	Mon Dec 27 15:51:12 2021 -0800
+++ b/scripts/plot/util/isaxes.m	Mon Dec 27 16:07:08 2021 -0800
@@ -24,7 +24,7 @@
 ########################################################################
 
 ## -*- texinfo -*-
-## @deftypefn {} {} isaxes (@var{h})
+## @deftypefn {} {@var{tf} =} isaxes (@var{h})
 ## Return true if @var{h} is an axes graphics handle and false otherwise.
 ##
 ## If @var{h} is a matrix then return a logical array which is true where the
@@ -32,16 +32,16 @@
 ## @seealso{isfigure, ishghandle, isgraphics}
 ## @end deftypefn
 
-function retval = isaxes (h)
+function tf = isaxes (h)
 
   if (nargin < 1)
     print_usage ();
   endif
 
-  retval = ishghandle (h);
+  tf = ishghandle (h);
 
-  if (any (retval))
-    retval(retval) = strcmp (get (h(retval), "type"), "axes");
+  if (any (tf))
+    tf(tf) = strcmp (get (h(tf), "type"), "axes");
   endif
 
 endfunction
diff -r 16c5cdc7741e -r 83aeaba707d8 scripts/plot/util/isfigure.m
--- a/scripts/plot/util/isfigure.m	Mon Dec 27 15:51:12 2021 -0800
+++ b/scripts/plot/util/isfigure.m	Mon Dec 27 16:07:08 2021 -0800
@@ -24,7 +24,7 @@
 ########################################################################
 
 ## -*- texinfo -*-
-## @deftypefn {} {} isfigure (@var{h})
+## @deftypefn {} {@var{tf} =} isfigure (@var{h})
 ## Return true if @var{h} is a figure graphics handle and false otherwise.
 ##
 ## If @var{h} is a matrix then return a logical array which is true where the
@@ -33,16 +33,16 @@
 ## @seealso{isaxes, ishghandle, isgraphics}
 ## @end deftypefn
 
-function retval = isfigure (h)
+function tf = isfigure (h)
 
   if (nargin < 1)
     print_usage ();
   endif
 
-  retval = ishghandle (h);
+  tf = ishghandle (h);
 
-  if (any (retval))
-    retval(retval) = strcmp (get (h(retval), "type"), "figure");
+  if (any (tf))
+    tf(tf) = strcmp (get (h(tf), "type"), "figure");
   endif
 
 endfunction
diff -r 16c5cdc7741e -r 83aeaba707d8 scripts/plot/util/isgraphics.m
--- a/scripts/plot/util/isgraphics.m	Mon Dec 27 15:51:12 2021 -0800
+++ b/scripts/plot/util/isgraphics.m	Mon Dec 27 16:07:08 2021 -0800
@@ -24,8 +24,8 @@
 ########################################################################
 
 ## -*- texinfo -*-
-## @deftypefn  {} {} isgraphics (@var{h})
-## @deftypefnx {} {} isgraphics (@var{h}, @var{type})
+## @deftypefn  {} {@var{tf} =} isgraphics (@var{h})
+## @deftypefnx {} {@var{tf} =} isgraphics (@var{h}, @var{type})
 ## Return true if @var{h} is a graphics handle (of type @var{type}) and false
 ## otherwise.
 ##
@@ -34,7 +34,7 @@
 ## @seealso{ishghandle, ishandle, isaxes, isfigure}
 ## @end deftypefn
 
-function retval = isgraphics (h, type = "")
+function tf = isgraphics (h, type = "")
 
   if (nargin < 1)
     print_usage ();
@@ -45,10 +45,10 @@
   endif
 
   ## Octave has no Simulink equivalent so it is sufficient to call ishghandle.
-  retval = ishghandle (h);
+  tf = ishghandle (h);
 
-  if (nargin == 2 && any (retval))
-    retval(retval) = strcmpi (get (h(retval), "type"), type);
+  if (nargin == 2 && any (tf))
+    tf(tf) = strcmpi (get (h(tf), "type"), type);
   endif
 
 endfunction
diff -r 16c5cdc7741e -r 83aeaba707d8 scripts/plot/util/ishandle.m
--- a/scripts/plot/util/ishandle.m	Mon Dec 27 15:51:12 2021 -0800
+++ b/scripts/plot/util/ishandle.m	Mon Dec 27 16:07:08 2021 -0800
@@ -24,7 +24,7 @@
 ########################################################################
 
 ## -*- texinfo -*-
-## @deftypefn {} {} ishandle (@var{h})
+## @deftypefn {} {@var{tf} =} ishandle (@var{h})
 ## Return true if @var{h} is a handle to a graphics or Java object and false
 ## otherwise.
 ##
@@ -39,13 +39,13 @@
 ## @seealso{ishghandle, isgraphics, isjava}
 ## @end deftypefn
 
-function retval = ishandle (h)
+function tf = ishandle (h)
 
   if (nargin < 1)
     print_usage ();
   endif
 
-  retval = ishghandle (h) | isjava (h);
+  tf = ishghandle (h) | isjava (h);
 
 endfunction
 
diff -r 16c5cdc7741e -r 83aeaba707d8 scripts/plot/util/ishold.m
--- a/scripts/plot/util/ishold.m	Mon Dec 27 15:51:12 2021 -0800
+++ b/scripts/plot/util/ishold.m	Mon Dec 27 16:07:08 2021 -0800
@@ -24,9 +24,9 @@
 ########################################################################
 
 ## -*- texinfo -*-
-## @deftypefn  {} {} ishold
-## @deftypefnx {} {} ishold (@var{hax})
-## @deftypefnx {} {} ishold (@var{hfig})
+## @deftypefn  {} {@var{tf} =} ishold
+## @deftypefnx {} {@var{tf} =} ishold (@var{hax})
+## @deftypefnx {} {@var{tf} =} ishold (@var{hfig})
 ## Return true if the next plot will be added to the current plot, or
 ## false if the plot device will be cleared before drawing the next plot.
 ##
@@ -35,7 +35,7 @@
 ## @seealso{hold, newplot}
 ## @end deftypefn
 
-function retval = ishold (h)
+function tf = ishold (h)
 
   if (nargin == 0)
     fig = gcf ();
@@ -60,7 +60,7 @@
     endswitch
   endif
 
-  retval = (strcmp (get (fig, "nextplot"), "add")
+  tf = (strcmp (get (fig, "nextplot"), "add")
             && ! isempty (ax) && strcmp (get (ax, "nextplot"), "add"));
 
 endfunction
diff -r 16c5cdc7741e -r 83aeaba707d8 scripts/prefs/ispref.m
--- a/scripts/prefs/ispref.m	Mon Dec 27 15:51:12 2021 -0800
+++ b/scripts/prefs/ispref.m	Mon Dec 27 16:07:08 2021 -0800
@@ -24,9 +24,9 @@
 ########################################################################
 
 ## -*- texinfo -*-
-## @deftypefn  {} {} ispref ("@var{group}", "@var{pref}")
-## @deftypefnx {} {} ispref ("@var{group}", @{"@var{pref1}", "@var{pref2"}, @dots{}@})
-## @deftypefnx {} {} ispref ("@var{group}")
+## @deftypefn  {} {@var{tf} =} ispref ("@var{group}", "@var{pref}")
+## @deftypefnx {} {@var{tf} =} ispref ("@var{group}", @{"@var{pref1}", "@var{pref2"}, @dots{}@})
+## @deftypefnx {} {@var{tf} =} ispref ("@var{group}")
 ## Return true if the named preference @var{pref} exists in the preference
 ## group @var{group}.
 ##
@@ -39,7 +39,7 @@
 ## @seealso{getpref, addpref, setpref, rmpref}
 ## @end deftypefn
 
-function retval = ispref (group, pref = "")
+function tf = ispref (group, pref = "")
 
   if (nargin == 0)
     print_usage ();
@@ -53,16 +53,16 @@
   endif
 
   if (nargin == 1)
-    retval = isfield (loadprefs (), group);
+    tf = isfield (loadprefs (), group);
   else
     prefs = loadprefs ();
     if (isfield (prefs, group))
-      retval = isfield (prefs.(group), pref);
+      tf = isfield (prefs.(group), pref);
     else
       if (ischar (pref))
-        retval = false;
+        tf = false;
       else
-        retval = false (size (pref));
+        tf = false (size (pref));
       endif
     endif
   endif
diff -r 16c5cdc7741e -r 83aeaba707d8 scripts/specfun/isprime.m
--- a/scripts/specfun/isprime.m	Mon Dec 27 15:51:12 2021 -0800
+++ b/scripts/specfun/isprime.m	Mon Dec 27 16:07:08 2021 -0800
@@ -24,7 +24,7 @@
 ########################################################################
 
 ## -*- texinfo -*-
-## @deftypefn {} {} isprime (@var{x})
+## @deftypefn {} {@var{tf} =} isprime (@var{x})
 ## Return a logical array which is true where the elements of @var{x} are prime
 ## numbers and false where they are not.
 ##
@@ -72,7 +72,7 @@
 ## @seealso{primes, factor, gcd, lcm}
 ## @end deftypefn
 
-function t = isprime (x)
+function tf = isprime (x)
 
   if (nargin < 1)
     print_usage ();
@@ -81,12 +81,12 @@
   endif
 
   if (isempty (x))
-    t = x;
+    tf = x;
     return;
   endif
 
   if (iscomplex (x))
-    t = isgaussianprime (x);
+    tf = isgaussianprime (x);
     return;
   endif
 
@@ -101,7 +101,7 @@
   ## because of the method used by __isprimelarge__ below.
   maxp = 37;
   pr = [2 3 5 7 11 13 17 19 23 29 31 37];
-  t = lookup (pr, x, "b");  # quick search for table matches.
+  tf = lookup (pr, x, "b");  # quick search for table matches.
 
   THRESHOLD = 29e9;
   ## FIXME: THRESHOLD is the input value at which Miller-Rabin
@@ -143,7 +143,7 @@
     ## Start by dividing through by the small primes until the remaining list
     ## of entries is small (and most likely prime themselves).
     pr2 = primes (sqrt (max (m)));
-    t |= lookup (pr2, x, "b");
+    tf |= lookup (pr2, x, "b");
     for p = pr2
       m = m(rem (m, p) != 0);
       if (numel (m) < numel (pr) / 10)
@@ -160,20 +160,20 @@
 
     ## Add any remaining entries, which are truly prime, to the results.
     if ( ! isempty (m))
-      t |= lookup (sort (m), x, "b");
+      tf |= lookup (sort (m), x, "b");
     endif
   endif
 
   ## Process remaining entries (everything above THRESHOLD) with Miller-Rabin
   ii = (x(:)' > THRESHOLD);
-  t(ii) = __isprimelarge__ (x(ii));
+  tf(ii) = __isprimelarge__ (x(ii));
 
 endfunction
 
-function t = isgaussianprime (z)
+function tf = isgaussianprime (z)
 
   ## Assume prime unless proven otherwise
-  t = true (size (z));
+  tf = true (size (z));
 
   x = real (z);
   y = imag (z);
@@ -183,13 +183,13 @@
   xidx = y==0 & mod (x, 4) == 3;
   yidx = x==0 & mod (y, 4) == 3;
 
-  t(xidx) &= isprime (x(xidx));
-  t(yidx) &= isprime (y(yidx));
+  tf(xidx) &= isprime (x(xidx));
+  tf(yidx) &= isprime (y(yidx));
 
   ## Otherwise, prime if x^2 + y^2 is prime
   zidx = ! (xidx | yidx);          # Skip entries that were already evaluated
   zabs = x(zidx).^2 + y(zidx).^2;
-  t(zidx) &= isprime (zabs);
+  tf(zidx) &= isprime (zabs);
 
 endfunction
 
diff -r 16c5cdc7741e -r 83aeaba707d8 scripts/strings/isletter.m
--- a/scripts/strings/isletter.m	Mon Dec 27 15:51:12 2021 -0800
+++ b/scripts/strings/isletter.m	Mon Dec 27 16:07:08 2021 -0800
@@ -24,7 +24,7 @@
 ########################################################################
 
 ## -*- texinfo -*-
-## @deftypefn {} {} isletter (@var{s})
+## @deftypefn {} {@var{tf} =} isletter (@var{s})
 ## Return a logical array which is true where the elements of @var{s}
 ## are letters and false where they are not.
 ##
@@ -32,13 +32,13 @@
 ## @seealso{isalpha, isdigit, ispunct, isspace, iscntrl, isalnum}
 ## @end deftypefn
 
-function retval = isletter (s)
+function tf = isletter (s)
 
   if (nargin < 1)
     print_usage ();
   endif
 
-  retval = isalpha (s);
+  tf = isalpha (s);
 
 endfunction
 
diff -r 16c5cdc7741e -r 83aeaba707d8 scripts/strings/isstring.m
--- a/scripts/strings/isstring.m	Mon Dec 27 15:51:12 2021 -0800
+++ b/scripts/strings/isstring.m	Mon Dec 27 16:07:08 2021 -0800
@@ -24,7 +24,7 @@
 ########################################################################
 
 ## -*- texinfo -*-
-## @deftypefn {} {} isstring (@var{s})
+## @deftypefn {} {@var{tf} =} isstring (@var{s})
 ## Return true if @var{s} is a string array.
 ##
 ## A string array is a data type that stores strings (row vectors of
@@ -40,13 +40,13 @@
 ## @seealso{ischar, iscellstr, isfloat, isinteger, islogical, isnumeric, isa}
 ## @end deftypefn
 
-function retval = isstring (s)
+function tf = isstring (s)
 
   if (nargin < 1)
     print_usage ();
   endif
 
-  retval = false;
+  tf = false;
 
 endfunction
 
diff -r 16c5cdc7741e -r 83aeaba707d8 scripts/strings/isstrprop.m
--- a/scripts/strings/isstrprop.m	Mon Dec 27 15:51:12 2021 -0800
+++ b/scripts/strings/isstrprop.m	Mon Dec 27 16:07:08 2021 -0800
@@ -24,7 +24,7 @@
 ########################################################################
 
 ## -*- texinfo -*-
-## @deftypefn {} {} isstrprop (@var{str}, @var{prop})
+## @deftypefn {} {@var{tf} =} isstrprop (@var{str}, @var{prop})
 ## Test character string properties.
 ##
 ## For example:
@@ -91,7 +91,7 @@
 ## isspace, ispunct, iscntrl, isgraph, isprint, isascii}
 ## @end deftypefn
 
-function retval = isstrprop (str, prop)
+function tf = isstrprop (str, prop)
 
   if (nargin != 2)
     print_usage ();
@@ -99,29 +99,29 @@
 
   switch (prop)
     case "alpha"
-      retval = isalpha (str);
+      tf = isalpha (str);
     case {"alnum", "alphanum"}
-      retval = isalnum (str);
+      tf = isalnum (str);
     case "ascii"
-      retval = isascii (str);
+      tf = isascii (str);
     case "cntrl"
-      retval = iscntrl (str);
+      tf = iscntrl (str);
     case "digit"
-      retval = isdigit (str);
+      tf = isdigit (str);
     case {"graph", "graphic"}
-      retval = isgraph (str);
+      tf = isgraph (str);
     case "lower"
-      retval = islower (str);
+      tf = islower (str);
     case "print"
-      retval = isprint (str);
+      tf = isprint (str);
     case "punct"
-      retval = ispunct (str);
+      tf = ispunct (str);
     case {"space", "wspace"}
-      retval = isspace (str);
+      tf = isspace (str);
     case "upper"
-      retval = isupper (str);
+      tf = isupper (str);
     case "xdigit"
-      retval = isxdigit (str);
+      tf = isxdigit (str);
     otherwise
       error ("isstrprop: invalid string property");
   endswitch
diff -r 16c5cdc7741e -r 83aeaba707d8 scripts/time/is_leap_year.m
--- a/scripts/time/is_leap_year.m	Mon Dec 27 15:51:12 2021 -0800
+++ b/scripts/time/is_leap_year.m	Mon Dec 27 16:07:08 2021 -0800
@@ -24,8 +24,8 @@
 ########################################################################
 
 ## -*- texinfo -*-
-## @deftypefn  {} {} is_leap_year ()
-## @deftypefnx {} {} is_leap_year (@var{year})
+## @deftypefn  {} {@var{tf} =} is_leap_year ()
+## @deftypefnx {} {@var{tf} =} is_leap_year (@var{year})
 ## Return true if @var{year} is a leap year and false otherwise.
 ##
 ## If no year is specified, @code{is_leap_year} uses the current year.
@@ -41,14 +41,14 @@
 ## @seealso{weekday, eomday, calendar}
 ## @end deftypefn
 
-function retval = is_leap_year (year)
+function tf = is_leap_year (year)
 
   if (nargin == 0)
     t = clock ();
     year = t(1);
   endif
 
-  retval = (rem (year, 4) == 0 & rem (year, 100) != 0) | (rem (year, 400) == 0);
+  tf = (rem (year, 4) == 0 & rem (year, 100) != 0) | (rem (year, 400) == 0);
 
 endfunction