octave-nkf: src/strfns.cc comparison

comparison src/strfns.cc @ 10108:06e11df4592d

implement built-in strcmpi/strncmpi, reduce some code duplication

author	Jaroslav Hajek <highegg@gmail.com>
date	Thu, 14 Jan 2010 13:48:20 +0100
parents	c2923c27c877
children	cd96d29c5efa

comparison

equal deleted inserted replaced

-:fd262afea1d1
+:06e11df4592d
 %!assert (ischar (1), logical (0));
 %!error <Invalid call to ischar.*> ischar ();
 */
-DEFUN (strcmp, args, ,
+static octave_value
-"-*- texinfo -*-\n\
+do_strcmp_fun (const octave_value& arg0, const octave_value& arg1,
-@deftypefn {Built-in Function} {} strcmp (@var{s1}, @var{s2})\n\
+octave_idx_type n, const char *fcn_name,
-Return 1 if the character strings @var{s1} and @var{s2} are the same,\n\
+bool (*array_op) (const charNDArray&, const charNDArray&, octave_idx_type),
-and 0 otherwise.\n\
+bool (*str_op) (const std::string&, const std::string&, octave_idx_type))
-\n\
-If either @var{s1} or @var{s2} is a cell array of strings, then an array\n\
-of the same size is returned, containing the values described above for\n\
-every member of the cell array.  The other argument may also be a cell\n\
-array of strings (of the same size or with only one element), char matrix\n\
-or character string.\n\
-\n\
-@strong{Caution:} For compatibility with @sc{matlab}, Octave's strcmp\n\
-function returns 1 if the character strings are equal, and 0 otherwise.\n\
-This is just the opposite of the corresponding C library function.\n\
-@seealso{strcmpi, strncmp, strncmpi}\n\
-@end deftypefn")
 {
 octave_value retval;
-if (args.length () == 2)
+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))
 {
-bool s1_string = args(0).is_string ();
+octave_value str_val, cell_val;
-bool s1_cell = args(0).is_cell ();
-bool s2_string = args(1).is_string ();
+if (s1_string)
-bool s2_cell = args(1).is_cell ();
+{
+str_val = arg0;
-if (s1_string && s2_string)
+cell_val = arg1;
-	{
+}
-	  // Must match exactly in all dimensions.
+else
+{
-	  const dim_vector dv1 = args(0).dims ();
+str_val = arg1;
-	  const dim_vector dv2 = args(1).dims ();
+cell_val = arg0;
+}
-	  if (dv1.length () == dv2.length ())
-	    {
+const Cell cell = cell_val.cell_value ();
-	      for (octave_idx_type i = 0; i < dv1.length (); i++)
+const string_vector str = str_val.all_strings ();
-		{
+octave_idx_type r = str.rows ();
-		  if (dv1(i) != dv2(i))
-		    {
+if (r == 0 || r == 1)
-		      retval = false;
+{
-		      return retval;
+// Broadcast the string.
-		    }
-		}
+boolNDArray output (cell_val.dims (), false);
-	      if (dv1(0) == 0)
+std::string s = r == 0 ? std::string () : str[0];
-		retval = true;
-	      else
+if (cell_val.is_cellstr ())
-		{
+{
-		  const charNDArray s1 = args(0).char_array_value ();
+const Array<std::string> cellstr = cell_val.cellstr_value ();
-		  const charNDArray s2 = args(1).char_array_value ();
+for (octave_idx_type i = 0; i < cellstr.length (); i++)
+output(i) = str_op (cellstr(i), s, n);
-		  for (octave_idx_type i = 0; i < dv1.numel (); i++)
+}
-		    {
+else
-		      if (s1(i) != s2(i))
+{
-			{
+// FIXME: should we warn here?
-			  retval = false;
+for (octave_idx_type i = 0; i < cell.length (); i++)
-			  return retval;
-			}
-		    }
-		  retval = true;
-		}
-	    }
-	}
-else if ((s1_string && s2_cell) || (s1_cell && s2_string))
-	{
-octave_value str_val, cell_val;
-	  if (s1_string)
-	    {
-	      str_val = args (0);
-cell_val = args (1);
-	    }
-	  else
-	    {
-	      str_val = args (1);
-cell_val = args (0);
-	    }
-const Cell cell = cell_val.cell_value ();
-	  const string_vector str = str_val.all_strings ();
-	  octave_idx_type r = str.rows ();
-	  if (r == 0 || r == 1)
-	    {
-	      // Broadcast the string.
-	      boolNDArray output (cell_val.dims (), false);
-	      std::string s = r == 0 ? std::string () : str[0];
-if (cell_val.is_cellstr ())
 {
-const Array<std::string> cellstr = cell_val.cellstr_value ();
+if (cell(i).is_string ())
-for (octave_idx_type i = 0; i < cellstr.length (); i++)
+output(i) = str_op (cell(i).string_value (), s, n);
-output(i) = cellstr(i) == s;
 }
-else
+}
+retval = output;
+}
+else if (r > 1)
+{
+if (cell.length () == 1)
+{
+// Broadcast the cell.
+const dim_vector dv (r, 1);
+boolNDArray output (dv, false);
+if (cell(0).is_string ())
 {
-// FIXME: should we warn here?
+const std::string str2 = cell(0).string_value ();
-for (octave_idx_type i = 0; i < cell.length (); i++)
+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.length () == r)
+{
+if (cell_val.is_cellstr ())
 {
-if (cell(i).is_string ())
+const Array<std::string> cellstr = cell_val.cellstr_value ();
-output(i) = (cell(i).string_value () == s);
-}
-}
-	      retval = output;
-	    }
-	  else if (r > 1)
-	    {
-	      if (cell.length () == 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[i] == str2);
-		    }
-		  retval = output;
-		}
-	      else
-		{
-		  // Must match in all dimensions.
-		  boolNDArray output (cell.dims (), false);
-		  if (cell.length () == r)
-		    {
-if (cell_val.is_cellstr ())
-{
-const Array<std::string> cellstr = cell_val.cellstr_value ();
-for (octave_idx_type i = 0; i < cellstr.length (); i++)
-output(i) = str[i] == cellstr(i);
-}
-else
-{
-// FIXME: should we warn here?
-for (octave_idx_type i = 0; i < r; i++)
-{
-if (cell(i).is_string ())
-output(i) = (str[i] == cell(i).string_value ());
-}
-}
-		      retval = output;
-		    }
-		  else
-		    retval = false;
-		}
-	    }
-	}
-else if (s1_cell && s2_cell)
-	{
-octave_value cell1_val, cell2_val;
-	  octave_idx_type r1 = args(0).numel (), r2;
-	  if (r1 == 1)
-	    {
-	      // Make the singleton cell2.
-	      cell1_val = args(1);
-	      cell2_val = args(0);
-	    }
-	  else
-	    {
-	      cell1_val = args(0);
-	      cell2_val = args(1);
-	    }
-	  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.length (); i++)
-output(i) = cellstr(i) == str2;
+output(i) = str_op (str[i], cellstr(i), n);
 }
 else
 {
 // FIXME: should we warn here?
-for (octave_idx_type i = 0; i < r1; i++)
+for (octave_idx_type i = 0; i < r; i++)
 {
-if (cell1(i).is_string ())
+if (cell(i).is_string ())
-{
+output(i) = str_op (str[i], cell(i).string_value (), n);
-const std::string str1 = cell1(i).string_value ();
-output(i) = (str1 == str2);
-}
 }
 }
-		}
-	    }
+retval = output;
-	  else
+}
-	    {
+else
-	      if (size1 != size2)
+retval = false;
-		{
+}
-		  error ("strcmp: nonconformant cell arrays");
+}
-		  return retval;
+}
-		}
+else if (s1_cell && s2_cell)
+{
-if (cell1.is_cellstr () && cell2.is_cellstr ())
+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> cellstr1 = cell1_val.cellstr_value ();
+const Array<std::string> cellstr = cell1_val.cellstr_value ();
-const Array<std::string> cellstr2 = cell2_val.cellstr_value ();
+for (octave_idx_type i = 0; i < cellstr.length (); i++)
-for (octave_idx_type i = 0; i < r1; i++)
+output(i) = str_op (cellstr(i), str2, n);
-output (i) = cellstr1(i) == cellstr2(i);
 }
 else
 {
 // FIXME: should we warn here?
 for (octave_idx_type i = 0; i < r1; i++)
 {
-if (cell1(i).is_string () && cell2(i).is_string ())
+if (cell1(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);
-output(i) = (str1 == str2);
 }
 }
 }
-	    }
+}
+}
-	  retval = output;
-	}
 else
-	retval = false;
+{
+if (size1 != size2)
+{
+error ("%s: nonconformant cell arrays", fcn_name);
+return retval;
+}
+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;
+}
+// If both args are arrays, dimensions may be significant.
+static bool
+strcmp_array_op (const charNDArray& s1, const charNDArray& s2, octave_idx_type)
+{
+return (s1.dims () == s2.dims ()
+&& std::equal (s1.data (), s1.data () + s1.numel (), s2.data ()));
+}
+// Otherwise, just use strings.
+static bool
+strcmp_str_op (const std::string& s1, const std::string& s2,
+octave_idx_type)
+{
+return s1 == s2;
+}
+DEFUN (strcmp, args, ,
+"-*- texinfo -*-\n\
+@deftypefn {Built-in Function} {} strcmp (@var{s1}, @var{s2})\n\
+Return 1 if the character strings @var{s1} and @var{s2} are the same,\n\
+and 0 otherwise.\n\
+\n\
+If either @var{s1} or @var{s2} is a cell array of strings, then an array\n\
+of the same size is returned, containing the values described above for\n\
+every member of the cell array.  The other argument may also be a cell\n\
+array of strings (of the same size or with only one element), char matrix\n\
+or character string.\n\
+\n\
+@strong{Caution:} For compatibility with @sc{matlab}, Octave's strcmp\n\
+function returns 1 if the character strings are equal, and 0 otherwise.\n\
+This is just the opposite of the corresponding C library function.\n\
+@seealso{strcmpi, strncmp, strncmpi}\n\
+@end deftypefn")
+{
+octave_value retval;
+if (args.length () == 2)
+{
+retval = do_strcmp_fun (args (0), args (1), 0,
+"strcmp", strcmp_array_op, strcmp_str_op);
 }
 else
 print_usage ();
 return retval;
 %!assert (all (strcmp ({'foo'}, y) == [false; false]));
 %!assert (all (strcmp (y, {'foo'}) == [false; false]));
 %!assert (all (strcmp (y, {'foo'}) == [false; false]));
 */
+// Apparently, Matlab ignores the dims with strncmp. It also
+static bool
+strncmp_array_op (const charNDArray& s1, const charNDArray& s2, octave_idx_type n)
+{
+octave_idx_type l1 = s1.numel (), l2 = s2.numel ();
+return (n > 0 && n <= l1 && n <= l2
+&& std::equal (s1.data (), s1.data () + n, s2.data ()));
+}
+// Otherwise, just use strings. Note that we neither extract substrings (which
+// would mean a copy, at least in GCC), nor use string::compare (which is a
+// 3-way compare).
+static bool
+strncmp_str_op (const std::string& s1, const std::string& s2, octave_idx_type n)
+{
+octave_idx_type l1 = s1.length (), l2 = s2.length ();
+return (n > 0 && n <= l1 && n <= l2
+&& std::equal (s1.data (), s1.data () + n, s2.data ()));
+}
 DEFUN (strncmp, args, ,
 "-*- texinfo -*-\n\
 @deftypefn {Built-in Function} {} strncmp (@var{s1}, @var{s2}, @var{n})\n\
 Return 1 if the first @var{n} characters of strings @var{s1} and @var{s2} are the same,\n\
 and 0 otherwise.\n\
 {
 octave_value retval;
 if (args.length () == 3)
 {
-bool s1_string = args(0).is_string ();
+octave_idx_type n = args(2).idx_type_value ();
-bool s1_cell = args(0).is_cell ();
-bool s2_string = args(1).is_string ();
+if (! error_state)
-bool s2_cell = args(1).is_cell ();
+{
+if (n > 0)
-// Match only first n strings.
+{
-int n = args(2).int_value ();
+retval = do_strcmp_fun (args(0), args(1), n, "strncmp",
+strncmp_array_op, strncmp_str_op);
-if (n <= 0)
+}
-	{
+else
-	  error ("strncmp: N must be greater than 0");
+error ("strncmp: N must be greater than 0");
-	  return retval;
+}
-	}
-if (s1_string && s2_string)
-	{
-	  // The only restriction here is that each string has equal or
-	  // greater than n characters
-	  const dim_vector dv1 = args(0).dims ();
-	  const dim_vector dv2 = args(1).dims ();
-	  if (dv1.numel () >= n && dv2.numel () >= n)
-	    {
-	      // Follow Matlab in the sense that the first n characters of
-	      // the two strings (in column major order) need to be the same.
-	      charNDArray s1 = args(0).char_array_value ();
-	      charNDArray s2 = args(1).char_array_value ();
-	      for (int i = 0; i < n; i++)
-		{
-		  if (s1(i) != s2(i))
-		    {
-		      retval = false;
-		      return retval;
-		    }
-		}
-	      retval = true;
-	    }
-	  else
-	    retval = false;
-	}
-else if ((s1_string && s2_cell) || (s1_cell && s2_string))
-	{
-	  string_vector str;
-	  Cell cell;
-	  octave_idx_type r, c;
-	  if (s1_string)
-	    {
-	      str = args(0).all_strings ();
-	      r = args(0).rows ();
-	      c = args(0).columns ();
-	      cell = args(1).cell_value ();
-	    }
-	  else
-	    {
-	      str = args(1).all_strings ();
-	      r = args(1).rows ();
-	      c = args(1).columns ();
-	      cell = args(0).cell_value ();
-	    }
-	  if (r == 1)
-	    {
-	      // Broadcast the string.
-	      boolNDArray output (cell.dims (), false);
-	      if (c < n)
-		{
-		  for (octave_idx_type i = 0; i < cell.length (); i++)
-		    output(i) = false;
-		}
-	      else
-		{
-		  for (octave_idx_type i = 0; i < cell.length (); i++)
-		    {
-		      if (cell(i).is_string ())
-			{
-			  const std::string str2 = cell(i).string_value ();
-			  if (str2.length () >= n
-			      && str2.compare (0, n, str[0], 0, n) == 0)
-				output(i) = true;
-			}
-		    }
-		}
-	      retval = output;
-	    }
-	  else if (r > 1)
-	    {
-	      if (cell.length () == 1)
-		{
-		  // Broadcast the cell.
-		  const dim_vector dv (r, 1);
-		  boolNDArray output (dv, false);
-		  if (cell(0).is_string () && c >= n)
-		    {
-		      const std::string str2 = cell(0).string_value ();
-		      if (str2.length () >= n)
-			{
-			  for (octave_idx_type i = 0; i < r; i++)
-			    {
-			      if (str[i].compare (0, n, str2, 0, n) == 0)
-				output(i) = true;
-			    }
-			}
-		    }
-		  retval = output;
-		}
-	      else
-		{
-		  // Must match in all dimensions.
-		  boolNDArray output (cell.dims (), false);
-		  if (cell.numel () == r)
-		    {
-		      for (octave_idx_type i = 0; i < r; i++)
-			{
-			  if (cell(i).is_string () && c >= n)
-			    {
-			      std::string str2 = cell(i).string_value ();
-			      if (str2.length () >= n
-				  && str2.compare (0, n, str[i], 0, n) == 0)
-				output(i) = true;
-			    }
-			}
-		      retval = output;
-		    }
-		  else
-		    {
-		      error ("strncmp: the number of rows of the string matrix must match the number of elements in the cell");
-		      return retval;
-		    }
-		}
-	    }
-	}
-else if (s1_cell && s2_cell)
-	{
-	  Cell cell1;
-	  Cell cell2;
-	  octave_idx_type r1 = args(0).numel ();
-	  octave_idx_type r2;
-	  if (r1 == 1)
-	    {
-	      // Make the singleton cell2.
-	      cell1 = args(1).cell_value ();
-	      cell2 = args(0).cell_value ();
-	      r1 = cell1.length ();
-	      r2 = 1;
-	    }
-	  else
-	    {
-	      cell1 = args(0).cell_value ();
-	      cell2 = args(1).cell_value ();
-	      r2 = cell2.length ();
-	    }
-	  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 ();
-		  for (octave_idx_type i = 0; i < r1; i++)
-		    {
-		      if (cell1(i).is_string ())
-			{
-			  const std::string str1 = cell1(i).string_value ();
-			  if (str1.length () >= n && str2.length () >= n
-			      && str1.compare (0, n, str2, 0, n) == 0)
-			    output(i) = true;
-			}
-		    }
-		}
-	    }
-	  else
-	    {
-	      if (size1 != size2)
-		{
-		  error ("strncmp: nonconformant cell arrays");
-		  return retval;
-		}
-	      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 ();
-		      if (str1.length () >= n && str2.length () >= n
-			  && str1.compare (0, n, str2, 0, n) == 0)
-			output(i) = true;
-		    }
-		}
-	    }
-	  retval = output;
-	}
-else
-	retval = false;
 }
 else
 print_usage ();
 return retval;
 %!assert (all (strncmp ({"abcd", "bca", "abc"},"abce", 3) == [1, 0, 1]))
 %!assert (all (strncmp ({"abcd", "bca", "abc"},{"abcd", "bca", "abe"}, 3) == [1, 1, 0]))
 %!assert (all (strncmp("abc", {"abcd", 10}, 2) == [1, 0]))
 */
+// case-insensitive character equality functor
+struct icmp_char_eq : public std::binary_function<char, char, bool>
+{
+bool operator () (char x, char y) const
+{ return std::toupper (x) == std::toupper (y); }
+};
+// strcmpi is equivalent to strcmp in that it checks all dims.
+static bool
+strcmpi_array_op (const charNDArray& s1, const charNDArray& s2, octave_idx_type)
+{
+return (s1.dims () == s2.dims ()
+&& std::equal (s1.data (), s1.data () + s1.numel (), s2.data (),
+icmp_char_eq ()));
+}
+// Ditto for string.
+static bool
+strcmpi_str_op (const std::string& s1, const std::string& s2,
+octave_idx_type)
+{
+return (s1.size () == s2.size ()
+&& std::equal (s1.data (), s1.data () + s1.size (), s2.data (),
+icmp_char_eq ()));
+}
+DEFUN (strcmpi, args, ,
+"-*- texinfo -*-\n\
+@deftypefn {Built-in Function} {} strcmpi (@var{s1}, @var{s2})\n\
+Returns 1 if the character strings @var{s1} and @var{s2} are the same,\n\
+disregarding case of alphabetic characters, and 0 otherwise.\n\
+\n\
+If either @var{s1} or @var{s2} is a cell array of strings, then an array\n\
+of the same size is returned, containing the values described above for\n\
+every member of the cell array.  The other argument may also be a cell\n\
+array of strings (of the same size or with only one element), char matrix\n\
+or character string.\n\
+\n\
+@strong{Caution:} For compatibility with @sc{matlab}, Octave's strcmp\n\
+function returns 1 if the character strings are equal, and 0 otherwise.\n\
+This is just the opposite of the corresponding C library function.\n\
+\n\
+@strong{Caution:} National alphabets are not supported.\n\
+@seealso{strcmp, strncmp, strncmpi}\n\
+@end deftypefn")
+{
+octave_value retval;
+if (args.length () == 2)
+{
+retval = do_strcmp_fun (args (0), args (1), 0,
+"strcmpi", strcmpi_array_op, strcmpi_str_op);
+}
+else
+print_usage ();
+return retval;
+}
+/*
+%!assert (strcmpi("abc123", "ABC123"), logical(1));
+*/
+// Like strncmp.
+static bool
+strncmpi_array_op (const charNDArray& s1, const charNDArray& s2, octave_idx_type n)
+{
+octave_idx_type l1 = s1.numel (), l2 = s2.numel ();
+return (n > 0 && n <= l1 && n <= l2
+&& std::equal (s1.data (), s1.data () + n, s2.data (),
+icmp_char_eq ()));
+}
+// Ditto.
+static bool
+strncmpi_str_op (const std::string& s1, const std::string& s2, octave_idx_type n)
+{
+octave_idx_type l1 = s1.length (), l2 = s2.length ();
+return (n > 0 && n <= l1 && n <= l2
+&& std::equal (s1.data (), s1.data () + n, s2.data (),
+icmp_char_eq ()));
+}
+DEFUN (strncmpi, args, ,
+"-*- texinfo -*-\n\
+@deftypefn {Built-in Function} {} strncmp (@var{s1}, @var{s2}, @var{n})\n\
+Returns 1 if the first @var{n} character of @var{s1} and @var{s2} are the same,\n\
+disregarding case of alphabetic characters, and 0 otherwise.\n\
+\n\
+If either @var{s1} or @var{s2} is a cell array of strings, then an array\n\
+of the same size is returned, containing the values described above for\n\
+every member of the cell array.  The other argument may also be a cell\n\
+array of strings (of the same size or with only one element), char matrix\n\
+or character string.\n\
+\n\
+@strong{Caution:} For compatibility with @sc{matlab}, Octave's strncmpi\n\
+function returns 1 if the character strings are equal, and 0 otherwise.\n\
+This is just the opposite of the corresponding C library function.\n\
+\n\
+@strong{Caution:} National alphabets are not supported.\n\
+@seealso{strncmp, strcmp, strcmpi}\n\
+@end deftypefn")
+{
+octave_value retval;
+if (args.length () == 3)
+{
+octave_idx_type n = args(2).idx_type_value ();
+if (! error_state)
+{
+if (n > 0)
+{
+retval = do_strcmp_fun (args(0), args(1), n, "strncmpi",
+strncmpi_array_op, strncmpi_str_op);
+}
+else
+error ("strncmp: N must be greater than 0");
+}
+}
+else
+print_usage ();
+return retval;
+}
+/*
+%!assert (strncmpi("abc123", "ABC456", 3), logical(1));
+*/
 DEFUN (list_in_columns, args, ,
 "-*- texinfo -*-\n\
 @deftypefn {Built-in Function} {} list_in_columns (@var{arg}, @var{width})\n\
 Return a string containing the elements of @var{arg} listed in\n\

Mercurial > octave-nkf

comparison src/strfns.cc @ 10108:06e11df4592d