Mercurial > octave
changeset 30558:83aeaba707d8
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.
line wrap: on
line diff
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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