Mercurial > octave
view libinterp/corefcn/strfns.cc @ 22407:34ce5be04942
maint: Style check C++ code in libinterp/.
* build-env.h, build-env.in.cc, builtins.h, Cell.cc, Cell.h, __contourc__.cc,
__dispatch__.cc, __dsearchn__.cc, __ilu__.cc, __lin_interpn__.cc, __luinc__.cc,
__magick_read__.cc, __pchip_deriv__.cc, __qp__.cc, balance.cc,
base-text-renderer.h, besselj.cc, bitfcns.cc, bsxfun.cc, c-file-ptr-stream.cc,
c-file-ptr-stream.h, call-stack.cc, call-stack.h, cdisplay.c, cdisplay.h,
cellfun.cc, coct-hdf5-types.c, comment-list.cc, comment-list.h, conv2.cc,
daspk.cc, dasrt.cc, dassl.cc, data.cc, data.h, debug.cc, debug.h, defaults.cc,
defaults.in.h, defun-dld.h, defun-int.h, defun.h, det.cc, dirfns.cc, dirfns.h,
display.cc, display.h, dlmread.cc, dynamic-ld.cc, dynamic-ld.h, eig.cc,
error.cc, error.h, errwarn.h, event-queue.cc, event-queue.h, fft.cc, fft2.cc,
fftn.cc, file-io.cc, file-io.h, filter.cc, find.cc, ft-text-renderer.cc,
ft-text-renderer.h, gammainc.cc, gcd.cc, getgrent.cc, getpwent.cc, givens.cc,
gl-render.cc, gl-render.h, gl2ps-print.cc, gl2ps-print.h, graphics.cc,
graphics.in.h, gripes.h, gsvd.cc, hash.cc, help.cc, help.h, hess.cc,
hex2num.cc, hook-fcn.cc, hook-fcn.h, input.cc, input.h, interpreter.cc,
interpreter.h, inv.cc, jit-ir.cc, jit-ir.h, jit-typeinfo.cc, jit-typeinfo.h,
jit-util.cc, jit-util.h, kron.cc, load-path.cc, load-path.h, load-save.cc,
load-save.h, lookup.cc, ls-ascii-helper.cc, ls-ascii-helper.h, ls-hdf5.cc,
ls-hdf5.h, ls-mat-ascii.cc, ls-mat-ascii.h, ls-mat4.cc, ls-mat4.h, ls-mat5.h,
ls-oct-binary.cc, ls-oct-binary.h, ls-oct-text.cc, ls-oct-text.h, ls-utils.cc,
ls-utils.h, lsode.cc, lu.cc, matrix_type.cc, max.cc, mex.cc, mex.h, mexproto.h,
mgorth.cc, mxarray.in.h, nproc.cc, oct-errno.h, oct-errno.in.cc, oct-fstrm.cc,
oct-fstrm.h, oct-handle.h, oct-hdf5-types.cc, oct-hdf5-types.h, oct-hdf5.h,
oct-hist.cc, oct-hist.h, oct-iostrm.cc, oct-iostrm.h, oct-lvalue.cc,
oct-lvalue.h, oct-map.h, oct-obj.h, oct-opengl.h, oct-prcstrm.cc,
oct-prcstrm.h, oct-procbuf.cc, oct-procbuf.h, oct-stdstrm.h, oct-stream.cc,
oct-stream.h, oct-strstrm.cc, oct-strstrm.h, oct.h, octave-default-image.h,
octave-link.h, octave-preserve-stream-state.h, ordschur.cc, pager.cc, pager.h,
pinv.cc, pr-output.cc, pr-output.h, procstream.cc, procstream.h, profiler.h,
psi.cc, pt-jit.cc, pt-jit.h, quad.cc, quadcc.cc, qz.cc, rand.cc, rcond.cc,
regexp.cc, schur.cc, sighandlers.cc, sighandlers.h, sparse-xdiv.cc,
sparse-xdiv.h, sparse-xpow.cc, sparse-xpow.h, sparse.cc, spparms.cc, sqrtm.cc,
str2double.cc, strfind.cc, strfns.cc, sub2ind.cc, svd.cc, sylvester.cc,
symtab.cc, symtab.h, syscalls.cc, sysdep.cc, sysdep.h, text-renderer.cc,
text-renderer.h, time.cc, toplev.cc, toplev.h, tril.cc, tsearch.cc, txt-eng.cc,
txt-eng.h, typecast.cc, urlwrite.cc, utils.cc, utils.h, variables.cc,
variables.h, workspace-element.h, xdiv.cc, xdiv.h, xnorm.cc, xnorm.h, xpow.cc,
xpow.h, zfstream.cc, zfstream.h, deprecated-config.h, __delaunayn__.cc,
__eigs__.cc, __fltk_uigetfile__.cc, __glpk__.cc, __init_fltk__.cc,
__init_gnuplot__.cc, __osmesa_print__.cc, __voronoi__.cc, amd.cc,
audiodevinfo.cc, audioread.cc, ccolamd.cc, chol.cc, colamd.cc, convhulln.cc,
dmperm.cc, fftw.cc, gzip.cc, oct-qhull.h, qr.cc, symbfact.cc, symrcm.cc,
liboctinterp-build-info.h, liboctinterp-build-info.in.cc, ov-base-diag.h,
ov-base-int.cc, ov-base-int.h, ov-base-mat.cc, ov-base-mat.h, ov-base-scalar.h,
ov-base-sparse.cc, ov-base-sparse.h, ov-base.cc, ov-base.h, ov-bool-mat.cc,
ov-bool-mat.h, ov-bool-sparse.cc, ov-bool-sparse.h, ov-bool.cc, ov-bool.h,
ov-builtin.cc, ov-builtin.h, ov-cell.cc, ov-cell.h, ov-ch-mat.cc, ov-ch-mat.h,
ov-class.cc, ov-class.h, ov-classdef.cc, ov-classdef.h, ov-colon.cc,
ov-colon.h, ov-complex.cc, ov-complex.h, ov-cs-list.h, ov-cx-diag.cc,
ov-cx-diag.h, ov-cx-mat.cc, ov-cx-mat.h, ov-cx-sparse.cc, ov-cx-sparse.h,
ov-dld-fcn.cc, ov-dld-fcn.h, ov-fcn-handle.cc, ov-fcn-handle.h,
ov-fcn-inline.cc, ov-fcn-inline.h, ov-fcn.cc, ov-fcn.h, ov-float.cc,
ov-float.h, ov-flt-complex.cc, ov-flt-complex.h, ov-flt-cx-diag.cc,
ov-flt-cx-diag.h, ov-flt-cx-mat.cc, ov-flt-cx-mat.h, ov-flt-re-diag.cc,
ov-flt-re-diag.h, ov-flt-re-mat.cc, ov-flt-re-mat.h, ov-int-traits.h,
ov-int16.cc, ov-int16.h, ov-int32.cc, ov-int32.h, ov-int64.cc, ov-int64.h,
ov-int8.cc, ov-int8.h, ov-intx.h, ov-java.cc, ov-java.h, ov-lazy-idx.cc,
ov-lazy-idx.h, ov-mex-fcn.cc, ov-mex-fcn.h, ov-null-mat.cc, ov-null-mat.h,
ov-oncleanup.cc, ov-oncleanup.h, ov-perm.cc, ov-perm.h, ov-range.cc,
ov-range.h, ov-re-diag.cc, ov-re-diag.h, ov-re-mat.cc, ov-re-mat.h,
ov-re-sparse.cc, ov-re-sparse.h, ov-scalar.cc, ov-scalar.h, ov-str-mat.cc,
ov-str-mat.h, ov-struct.cc, ov-struct.h, ov-typeinfo.cc, ov-typeinfo.h,
ov-uint16.cc, ov-uint16.h, ov-uint32.cc, ov-uint32.h, ov-uint64.cc,
ov-uint64.h, ov-uint8.cc, ov-uint8.h, ov-usr-fcn.cc, ov-usr-fcn.h, ov.h,
ovl.cc, ovl.h, octave.cc, octave.h, op-b-b.cc, op-b-bm.cc, op-b-sbm.cc,
op-bm-b.cc, op-bm-bm.cc, op-bm-sbm.cc, op-cdm-cdm.cc, op-cell.cc, op-chm.cc,
op-class.cc, op-cm-cm.cc, op-cm-cs.cc, op-cm-m.cc, op-cm-pm.cc, op-cm-s.cc,
op-cm-scm.cc, op-cm-sm.cc, op-cs-cm.cc, op-cs-cs.cc, op-cs-m.cc, op-cs-s.cc,
op-cs-scm.cc, op-cs-sm.cc, op-dm-dm.cc, op-dm-scm.cc, op-dm-sm.cc,
op-dm-template.cc, op-dms-template.cc, op-fcdm-fcdm.cc, op-fcm-fcm.cc,
op-fcm-fcs.cc, op-fcm-fm.cc, op-fcm-fs.cc, op-fcm-pm.cc, op-fcn.cc,
op-fcs-fcm.cc, op-fcs-fcs.cc, op-fcs-fm.cc, op-fcs-fs.cc, op-fdm-fdm.cc,
op-fm-fcm.cc, op-fm-fcs.cc, op-fm-fm.cc, op-fm-fs.cc, op-fm-pm.cc,
op-fs-fcm.cc, op-fs-fcs.cc, op-fs-fm.cc, op-fs-fs.cc, op-i16-i16.cc,
op-i32-i32.cc, op-i64-i64.cc, op-i8-i8.cc, op-int-concat.cc, op-int.h,
op-m-cm.cc, op-m-cs.cc, op-m-m.cc, op-m-pm.cc, op-m-s.cc, op-m-scm.cc,
op-m-sm.cc, op-pm-cm.cc, op-pm-fcm.cc, op-pm-fm.cc, op-pm-m.cc, op-pm-pm.cc,
op-pm-scm.cc, op-pm-sm.cc, op-pm-template.cc, op-range.cc, op-s-cm.cc,
op-s-cs.cc, op-s-m.cc, op-s-s.cc, op-s-scm.cc, op-s-sm.cc, op-sbm-b.cc,
op-sbm-bm.cc, op-sbm-sbm.cc, op-scm-cm.cc, op-scm-cs.cc, op-scm-m.cc,
op-scm-s.cc, op-scm-scm.cc, op-scm-sm.cc, op-sm-cm.cc, op-sm-cs.cc, op-sm-m.cc,
op-sm-s.cc, op-sm-scm.cc, op-sm-sm.cc, op-str-m.cc, op-str-s.cc, op-str-str.cc,
op-struct.cc, op-ui16-ui16.cc, op-ui32-ui32.cc, op-ui64-ui64.cc, op-ui8-ui8.cc,
ops.h, options-usage.h, lex.h, parse.h, pt-all.h, pt-arg-list.cc,
pt-arg-list.h, pt-array-list.h, pt-assign.cc, pt-assign.h, pt-binop.cc,
pt-binop.h, pt-bp.cc, pt-bp.h, pt-cbinop.cc, pt-cbinop.h, pt-cell.cc,
pt-cell.h, pt-check.cc, pt-check.h, pt-classdef.cc, pt-classdef.h, pt-cmd.cc,
pt-cmd.h, pt-colon.cc, pt-colon.h, pt-const.cc, pt-const.h, pt-decl.cc,
pt-decl.h, pt-eval.cc, pt-eval.h, pt-except.cc, pt-except.h, pt-exp.cc,
pt-exp.h, pt-fcn-handle.cc, pt-fcn-handle.h, pt-funcall.cc, pt-funcall.h,
pt-id.cc, pt-id.h, pt-idx.cc, pt-idx.h, pt-jump.cc, pt-jump.h, pt-loop.cc,
pt-loop.h, pt-mat.cc, pt-mat.h, pt-misc.cc, pt-misc.h, pt-pr-code.cc,
pt-pr-code.h, pt-select.cc, pt-select.h, pt-stmt.cc, pt-stmt.h, pt-unop.cc,
pt-unop.h, pt-walk.h, pt.cc, pt.h, token.cc, token.h, Array-jit.cc,
Array-tc.cc, version.cc, version.in.h:
Style check C++ code in libinterp/
author | Rik <rik@octave.org> |
---|---|
date | Tue, 30 Aug 2016 21:46:47 -0700 |
parents | bac0d6f07a3e |
children | 3a2b891d0b33 e9a0469dedd9 |
line wrap: on
line source
/* Copyright (C) 1994-2016 John W. Eaton This file is part of Octave. Octave is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. Octave is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with Octave; see the file COPYING. If not, see <http://www.gnu.org/licenses/>. */ #if defined (HAVE_CONFIG_H) # include "config.h" #endif #include <cctype> #include <queue> #include <sstream> #include "dMatrix.h" #include "Cell.h" #include "defun.h" #include "error.h" #include "errwarn.h" #include "ov.h" #include "ovl.h" #include "unwind-prot.h" #include "utils.h" #include "oct-string.h" DEFUN (char, args, , doc: /* -*- texinfo -*- @deftypefn {} {} char (@var{x}) @deftypefnx {} {} char (@var{x}, @dots{}) @deftypefnx {} {} char (@var{s1}, @var{s2}, @dots{}) @deftypefnx {} {} char (@var{cell_array}) Create a string array from one or more numeric matrices, character matrices, or cell arrays. Arguments are concatenated vertically. The returned values are padded with blanks as needed to make each row of the string array have the same length. Empty input strings are significant and will concatenated in the output. For numerical input, each element is converted to the corresponding ASCII character. A range error results if an input is outside the ASCII range (0-255). For cell arrays, each element is concatenated separately. Cell arrays converted through @code{char} can mostly be converted back with @code{cellstr}. For example: @example @group char ([97, 98, 99], "", @{"98", "99", 100@}, "str1", ["ha", "lf"]) @result{} ["abc " " " "98 " "99 " "d " "str1 " "half "] @end group @end example @seealso{strvcat, cellstr} @end deftypefn */) { octave_value retval; int nargin = args.length (); if (nargin == 0) retval = ""; else if (nargin == 1) retval = args(0).convert_to_str (true, true, args(0).is_dq_string () ? '"' : '\''); else { int n_elts = 0; int max_len = 0; std::queue<string_vector> args_as_strings; for (int i = 0; i < nargin; i++) { string_vector s = args(i).xstring_vector_value ("char: unable to convert some args to strings"); if (s.numel () > 0) n_elts += s.numel (); else n_elts += 1; int s_max_len = s.max_length (); if (s_max_len > max_len) max_len = s_max_len; args_as_strings.push (s); } string_vector result (n_elts); int k = 0; for (int i = 0; i < nargin; i++) { string_vector s = args_as_strings.front (); args_as_strings.pop (); int n = s.numel (); if (n > 0) { for (int j = 0; j < n; j++) { std::string t = s[j]; int t_len = t.length (); if (max_len > t_len) t += std::string (max_len - t_len, ' '); result[k++] = t; } } else result[k++] = std::string (max_len, ' '); } retval = octave_value (result, '\''); } return retval; } /* %!assert (char (), '') %!assert (char (100), "d") %!assert (char (100,100), ["d";"d"]) %!assert (char ({100,100}), ["d";"d"]) %!assert (char ([100,100]), ["dd"]) %!assert (char ({100,{100}}), ["d";"d"]) %!assert (char (100, [], 100), ["d";" ";"d"]) %!assert (char ({100, [], 100}), ["d";" ";"d"]) %!assert (char ({100,{100, {""}}}), ["d";"d";" "]) %!assert (char (["a";"be"], {"c", 100}), ["a";"be";"c";"d"]) %!assert (char ("a", "bb", "ccc"), ["a "; "bb "; "ccc"]) %!assert (char ([65, 83, 67, 73, 73]), "ASCII") %!test %! x = char ("foo", "bar", "foobar"); %! assert (x(1,:), "foo "); %! assert (x(2,:), "bar "); %! assert (x(3,:), "foobar"); */ DEFUN (strvcat, args, , doc: /* -*- texinfo -*- @deftypefn {} {} strvcat (@var{x}) @deftypefnx {} {} strvcat (@var{x}, @dots{}) @deftypefnx {} {} strvcat (@var{s1}, @var{s2}, @dots{}) @deftypefnx {} {} strvcat (@var{cell_array}) Create a character array from one or more numeric matrices, character matrices, or cell arrays. Arguments are concatenated vertically. The returned values are padded with blanks as needed to make each row of the string array have the same length. Unlike @code{char}, empty strings are removed and will not appear in the output. For numerical input, each element is converted to the corresponding ASCII character. A range error results if an input is outside the ASCII range (0-255). For cell arrays, each element is concatenated separately. Cell arrays converted through @code{strvcat} can mostly be converted back with @code{cellstr}. For example: @example @group strvcat ([97, 98, 99], "", @{"98", "99", 100@}, "str1", ["ha", "lf"]) @result{} ["abc " "98 " "99 " "d " "str1 " "half "] @end group @end example @seealso{char, strcat, cstrcat} @end deftypefn */) { int nargin = args.length (); int n_elts = 0; size_t max_len = 0; std::queue<string_vector> args_as_strings; for (int i = 0; i < nargin; i++) { string_vector s = args(i).xstring_vector_value ("strvcat: unable to convert some args to strings"); size_t n = s.numel (); // do not count empty strings in calculation of number of elements if (n > 0) { for (size_t j = 0; j < n; j++) { if (s[j].length () > 0) n_elts++; } } size_t s_max_len = s.max_length (); if (s_max_len > max_len) max_len = s_max_len; args_as_strings.push (s); } string_vector result (n_elts); octave_idx_type k = 0; for (int i = 0; i < nargin; i++) { string_vector s = args_as_strings.front (); args_as_strings.pop (); size_t n = s.numel (); if (n > 0) { for (size_t j = 0; j < n; j++) { std::string t = s[j]; if (t.length () > 0) { size_t t_len = t.length (); if (max_len > t_len) t += std::string (max_len - t_len, ' '); result[k++] = t; } } } } // Cannot use ovl. Relies on overloaded octave_value call. return octave_value (result, '\''); } /* %!assert (strvcat (""), "") %!assert (strvcat (100) == "d") %!assert (strvcat (100,100), ["d";"d"]) %!assert (strvcat ({100,100}), ["d";"d"]) %!assert (strvcat ([100,100]), ["dd"]) %!assert (strvcat ({100,{100}}), ["d";"d"]) %!assert (strvcat (100, [], 100), ["d";"d"]) %!assert (strvcat ({100, [], 100}), ["d";"d"]) %!assert (strvcat ({100,{100, {""}}}), ["d";"d"]) %!assert (strvcat (["a";"be"], {"c", 100}), ["a";"be";"c";"d"]) %!assert (strvcat ("a", "bb", "ccc"), ["a "; "bb "; "ccc"]) %!assert (strvcat (), "") */ DEFUN (ischar, args, , doc: /* -*- texinfo -*- @deftypefn {} {} ischar (@var{x}) Return true if @var{x} is a character array. @seealso{isfloat, isinteger, islogical, isnumeric, iscellstr, isa} @end deftypefn */) { if (args.length () != 1) print_usage (); return ovl (args(0).is_string ()); } /* %!assert (ischar ("a"), true) %!assert (ischar (["ab";"cd"]), true) %!assert (ischar ({"ab"}), false) %!assert (ischar (1), false) %!assert (ischar ([1, 2]), false) %!assert (ischar ([]), false) %!assert (ischar ([1, 2; 3, 4]), false) %!assert (ischar (""), true) %!assert (ischar ("test"), true) %!assert (ischar (["test"; "ing"]), true) %!assert (ischar (struct ("foo", "bar")), false) %!error ischar () %!error ischar ("test", 1) */ static octave_value do_strcmp_fun (const octave_value& arg0, const octave_value& arg1, octave_idx_type n, const char *fcn_name, bool (*array_op) (const Array<char>&, const Array<char>&, octave_idx_type), bool (*str_op) (const std::string&, const std::string&, std::string::size_type)) { octave_value retval; bool s1_string = arg0.is_string (); bool s1_cell = arg0.is_cell (); bool s2_string = arg1.is_string (); bool s2_cell = arg1.is_cell (); if (s1_string && s2_string) retval = array_op (arg0.char_array_value (), arg1.char_array_value (), n); else if ((s1_string && s2_cell) || (s1_cell && s2_string)) { octave_value str_val, cell_val; if (s1_string) { str_val = arg0; cell_val = arg1; } else { str_val = arg1; cell_val = arg0; } const Cell cell = cell_val.cell_value (); const string_vector str = str_val.string_vector_value (); octave_idx_type r = str.numel (); if (r == 0 || r == 1) { // Broadcast the string. boolNDArray output (cell_val.dims (), false); std::string s = r == 0 ? "" : str[0]; if (cell_val.is_cellstr ()) { const Array<std::string> cellstr = cell_val.cellstr_value (); for (octave_idx_type i = 0; i < cellstr.numel (); i++) output(i) = str_op (cellstr(i), s, n); } else { // FIXME: should we warn here? for (octave_idx_type i = 0; i < cell.numel (); i++) { if (cell(i).is_string ()) output(i) = str_op (cell(i).string_value (), s, n); } } retval = output; } else if (r > 1) { if (cell.numel () == 1) { // Broadcast the cell. const dim_vector dv (r, 1); boolNDArray output (dv, false); if (cell(0).is_string ()) { const std::string str2 = cell(0).string_value (); for (octave_idx_type i = 0; i < r; i++) output(i) = str_op (str[i], str2, n); } retval = output; } else { // Must match in all dimensions. boolNDArray output (cell.dims (), false); if (cell.numel () == r) { if (cell_val.is_cellstr ()) { const Array<std::string> cellstr = cell_val.cellstr_value (); for (octave_idx_type i = 0; i < cellstr.numel (); i++) output(i) = str_op (str[i], cellstr(i), n); } else { // FIXME: should we warn here? for (octave_idx_type i = 0; i < r; i++) { if (cell(i).is_string ()) output(i) = str_op (str[i], cell(i).string_value (), n); } } retval = output; } else retval = false; } } } else if (s1_cell && s2_cell) { octave_value cell1_val, cell2_val; octave_idx_type r1 = arg0.numel (), r2; if (r1 == 1) { // Make the singleton cell2. cell1_val = arg1; cell2_val = arg0; } else { cell1_val = arg0; cell2_val = arg1; } const Cell cell1 = cell1_val.cell_value (); const Cell cell2 = cell2_val.cell_value (); r1 = cell1.numel (); r2 = cell2.numel (); const dim_vector size1 = cell1.dims (); const dim_vector size2 = cell2.dims (); boolNDArray output (size1, false); if (r2 == 1) { // Broadcast cell2. if (cell2(0).is_string ()) { const std::string str2 = cell2(0).string_value (); if (cell1_val.is_cellstr ()) { const Array<std::string> cellstr = cell1_val.cellstr_value (); for (octave_idx_type i = 0; i < cellstr.numel (); i++) output(i) = str_op (cellstr(i), str2, n); } else { // FIXME: should we warn here? for (octave_idx_type i = 0; i < r1; i++) { if (cell1(i).is_string ()) { const std::string str1 = cell1(i).string_value (); output(i) = str_op (str1, str2, n); } } } } } else { if (size1 != size2) error ("%s: nonconformant cell arrays", fcn_name); if (cell1.is_cellstr () && cell2.is_cellstr ()) { const Array<std::string> cellstr1 = cell1_val.cellstr_value (); const Array<std::string> cellstr2 = cell2_val.cellstr_value (); for (octave_idx_type i = 0; i < r1; i++) output (i) = str_op (cellstr1(i), cellstr2(i), n); } else { // FIXME: should we warn here? for (octave_idx_type i = 0; i < r1; i++) { if (cell1(i).is_string () && cell2(i).is_string ()) { const std::string str1 = cell1(i).string_value (); const std::string str2 = cell2(i).string_value (); output(i) = str_op (str1, str2, n); } } } } retval = output; } else retval = false; return retval; } // These are required so that they match the same signature as strncmp // and strncmpi and can therefore be used in do_strcmp_fun. template <typename T, typename T_size_type> static bool strcmp_ignore_n (const T& s1, const T& s2, T_size_type) { return octave::string::strcmp (s1, s2); } template <typename T, typename T_size_type> static bool strcmpi_ignore_n (const T& s1, const T& s2, T_size_type) { return octave::string::strcmpi (s1, s2); } DEFUN (strcmp, args, , doc: /* -*- texinfo -*- @deftypefn {} {} strcmp (@var{s1}, @var{s2}) Return 1 if the character strings @var{s1} and @var{s2} are the same, and 0 otherwise. If either @var{s1} or @var{s2} is a cell array of strings, then an array of the same size is returned, containing the values described above for every member of the cell array. The other argument may also be a cell array of strings (of the same size or with only one element), char matrix or character string. @strong{Caution:} For compatibility with @sc{matlab}, Octave's strcmp function returns 1 if the character strings are equal, and 0 otherwise. This is just the opposite of the corresponding C library function. @seealso{strcmpi, strncmp, strncmpi} @end deftypefn */) { if (args.length () != 2) print_usage (); return ovl (do_strcmp_fun (args(0), args(1), 0, "strcmp", strcmp_ignore_n, strcmp_ignore_n)); } /* %!shared x %! x = char (zeros (0, 2)); %!assert (strcmp ("", x), false) %!assert (strcmp (x, ""), false) %!assert (strcmp (x, x), true) ## %!assert (strcmp ({""}, x), true) ## %!assert (strcmp ({x}, ""), false) ## %!assert (strcmp ({x}, x), true) ## %!assert (strcmp ("", {x}), false) ## %!assert (strcmp (x, {""}), false) ## %!assert (strcmp (x, {x}), true) ## %!assert (strcmp ({x; x}, ""), [false; false]) ## %!assert (strcmp ({x; x}, {""}), [false; false]) ## %!assert (strcmp ("", {x; x}), [false; false]) ## %!assert (strcmp ({""}, {x; x}), [false; false]) %!assert (strcmp ({"foo"}, x), false) %!assert (strcmp ({"foo"}, "foo"), true) %!assert (strcmp ({"foo"}, x), false) %!assert (strcmp (x, {"foo"}), false) %!assert (strcmp ("foo", {"foo"}), true) %!assert (strcmp (x, {"foo"}), false) %!shared y %! y = char (zeros (2, 0)); %!assert (strcmp ("", y), false) %!assert (strcmp (y, ""), false) %!assert (strcmp (y, y), true) %!assert (strcmp ({""}, y), [true; true]) %!assert (strcmp ({y}, ""), true) %!assert (strcmp ({y}, y), [true; true]) %!assert (strcmp ("", {y}), true) %!assert (strcmp (y, {""}), [true; true]) %!assert (strcmp (y, {y}), [true; true]) %!assert (strcmp ({y; y}, ""), [true; true]) %!assert (strcmp ({y; y}, {""}), [true; true]) %!assert (strcmp ("", {y; y}), [true; true]) %!assert (strcmp ({""}, {y; y}), [true; true]) %!assert (strcmp ({"foo"}, y), [false; false]) %!assert (strcmp ({"foo"}, y), [false; false]) %!assert (strcmp (y, {"foo"}), [false; false]) %!assert (strcmp (y, {"foo"}), [false; false]) %!assert (strcmp ("foobar", "foobar"), true) %!assert (strcmp ("fooba", "foobar"), false) %!error strcmp () %!error strcmp ("foo", "bar", 3) */ DEFUN (strncmp, args, , doc: /* -*- texinfo -*- @deftypefn {} {} strncmp (@var{s1}, @var{s2}, @var{n}) Return 1 if the first @var{n} characters of strings @var{s1} and @var{s2} are the same, and 0 otherwise. @example @group strncmp ("abce", "abcd", 3) @result{} 1 @end group @end example If either @var{s1} or @var{s2} is a cell array of strings, then an array of the same size is returned, containing the values described above for every member of the cell array. The other argument may also be a cell array of strings (of the same size or with only one element), char matrix or character string. @example @group strncmp ("abce", @{"abcd", "bca", "abc"@}, 3) @result{} [1, 0, 1] @end group @end example @strong{Caution:} For compatibility with @sc{matlab}, Octave's strncmp function returns 1 if the character strings are equal, and 0 otherwise. This is just the opposite of the corresponding C library function. @seealso{strncmpi, strcmp, strcmpi} @end deftypefn */) { if (args.length () != 3) print_usage (); octave_idx_type n = args(2).idx_type_value (); if (n > 0) return ovl (do_strcmp_fun (args(0), args(1), n, "strncmp", octave::string::strncmp, octave::string::strncmp)); else error ("strncmp: N must be greater than 0"); } /* %!assert (strncmp ("abce", "abc", 3), true) %!assert (strncmp (100, 100, 1), false) %!assert (strncmp ("abce", {"abcd", "bca", "abc"}, 3), logical ([1, 0, 1])) %!assert (strncmp ("abc", {"abcd", "bca", "abc"}, 4), logical ([0, 0, 0])) %!assert (strncmp ({"abcd", "bca", "abc"},"abce", 3), logical ([1, 0, 1])) %!assert (strncmp ({"abcd", "bca", "abc"},{"abcd", "bca", "abe"}, 3), logical ([1, 1, 0])) %!assert (strncmp ("abc", {"abcd", 10}, 2), logical ([1, 0])) %!error strncmp () %!error strncmp ("abc", "def") */ DEFUNX ("strcmpi", Fstrcmpi, args, , doc: /* -*- texinfo -*- @deftypefn {} {} strcmpi (@var{s1}, @var{s2}) Return 1 if the character strings @var{s1} and @var{s2} are the same, disregarding case of alphabetic characters, and 0 otherwise. If either @var{s1} or @var{s2} is a cell array of strings, then an array of the same size is returned, containing the values described above for every member of the cell array. The other argument may also be a cell array of strings (of the same size or with only one element), char matrix or character string. @strong{Caution:} For compatibility with @sc{matlab}, Octave's strcmp function returns 1 if the character strings are equal, and 0 otherwise. This is just the opposite of the corresponding C library function. @strong{Caution:} National alphabets are not supported. @seealso{strcmp, strncmp, strncmpi} @end deftypefn */) { if (args.length () != 2) print_usage (); return ovl (do_strcmp_fun (args(0), args(1), 0, "strcmpi", strcmpi_ignore_n, strcmpi_ignore_n)); } /* %!assert (strcmpi ("abc123", "ABC123"), true) */ DEFUNX ("strncmpi", Fstrncmpi, args, , doc: /* -*- texinfo -*- @deftypefn {} {} strncmpi (@var{s1}, @var{s2}, @var{n}) Return 1 if the first @var{n} character of @var{s1} and @var{s2} are the same, disregarding case of alphabetic characters, and 0 otherwise. If either @var{s1} or @var{s2} is a cell array of strings, then an array of the same size is returned, containing the values described above for every member of the cell array. The other argument may also be a cell array of strings (of the same size or with only one element), char matrix or character string. @strong{Caution:} For compatibility with @sc{matlab}, Octave's strncmpi function returns 1 if the character strings are equal, and 0 otherwise. This is just the opposite of the corresponding C library function. @strong{Caution:} National alphabets are not supported. @seealso{strncmp, strcmp, strcmpi} @end deftypefn */) { if (args.length () != 3) print_usage (); octave_idx_type n = args(2).idx_type_value (); if (n > 0) return ovl (do_strcmp_fun (args(0), args(1), n, "strncmpi", octave::string::strncmpi, octave::string::strncmpi)); else error ("strncmpi: N must be greater than 0"); } /* %!assert (strncmpi ("abc123", "ABC456", 3), true) */ DEFUN (list_in_columns, args, , doc: /* -*- texinfo -*- @deftypefn {} {} list_in_columns (@var{arg}, @var{width}, @var{prefix}) Return a string containing the elements of @var{arg} listed in columns with an overall maximum width of @var{width} and optional prefix @var{prefix}. The argument @var{arg} must be a cell array of character strings or a character array. If @var{width} is not specified or is an empty matrix, or less than or equal to zero, the width of the terminal screen is used. Newline characters are used to break the lines in the output string. For example: @c Set example in small font to prevent overfull line @smallexample @group list_in_columns (@{"abc", "def", "ghijkl", "mnop", "qrs", "tuv"@}, 20) @result{} abc mnop def qrs ghijkl tuv whos ans @result{} Variables in the current scope: Attr Name Size Bytes Class ==== ==== ==== ===== ===== ans 1x37 37 char Total is 37 elements using 37 bytes @end group @end smallexample @seealso{terminal_size} @end deftypefn */) { int nargin = args.length (); if (nargin < 1 || nargin > 3) print_usage (); string_vector s = args(0).xstring_vector_value ("list_in_columns: ARG must be a cellstr or char array"); int width = -1; if (nargin > 1 && ! args(1).is_empty ()) width = args(1).xint_value ("list_in_columns: WIDTH must be an integer"); std::string prefix; if (nargin > 2) prefix = args(2).xstring_value ("list_in_columns: PREFIX must be a string"); std::ostringstream buf; s.list_in_columns (buf, width, prefix); return ovl (buf.str ()); } /* %!test %! input = {"abc", "def", "ghijkl", "mnop", "qrs", "tuv"}; %! result = "abc mnop\ndef qrs\nghijkl tuv\n"; %! assert (list_in_columns (input, 20), result); %!test %! input = ["abc"; "def"; "ghijkl"; "mnop"; "qrs"; "tuv"]; %! result = "abc mnop \ndef qrs \nghijkl tuv \n"; %! assert (list_in_columns (input, 20), result); %!test %! input = ["abc"; "def"; "ghijkl"; "mnop"; "qrs"; "tuv"]; %! result = " abc mnop \n def qrs \n ghijkl tuv \n"; %! assert (list_in_columns (input, 20, " "), result); %!error list_in_columns () %!error list_in_columns (["abc", "def"], 20, 2) %!error list_in_columns (["abc", "def"], 20, " ", 3) %!error <list_in_columns: WIDTH must be an integer> list_in_columns (["abc", "def"], "a") */