Mercurial > octave-nkf

changeset 4964:269c3d6c0569

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[project @ 2004-09-04 01:16:28 by jwe]
author jwe
date Sat, 04 Sep 2004 01:16:28 +0000
parents 573d23f9c9cf
children c0d8e8afa82f
files liboctave/ChangeLog liboctave/boolNDArray.cc liboctave/boolNDArray.h liboctave/mk-ops.awk liboctave/mx-ops liboctave/oct-inttypes.h scripts/ChangeLog scripts/general/repmat.m src/ChangeLog src/OPERATORS/op-b-b.cc src/OPERATORS/op-b-bm.cc src/OPERATORS/op-bm-b.cc src/OPERATORS/op-bm-bm.cc src/OPERATORS/op-i16-i16.cc src/OPERATORS/op-i32-i32.cc src/OPERATORS/op-i64-i64.cc src/OPERATORS/op-i8-i8.cc src/OPERATORS/op-int.h src/OPERATORS/op-ui16-ui16.cc src/OPERATORS/op-ui32-ui32.cc src/OPERATORS/op-ui64-ui64.cc src/OPERATORS/op-ui8-ui8.cc src/ov-bool.cc src/ov-intx.h
diffstat 24 files changed, 891 insertions(+), 59 deletions(-) [+]
line wrap: on
line diff
--- a/liboctave/ChangeLog	Fri Sep 03 15:43:30 2004 +0000
+++ b/liboctave/ChangeLog	Sat Sep 04 01:16:28 2004 +0000
@@ -1,5 +1,20 @@
+2004-09-03  David Bateman  <dbateman@free.fr>
+
+	* boolNDArray.cc (boolNDArray::concat, boolNDArray::insert):
+	New functions for boolean matrix concatenation.
+	* boolNDArray.h: Provide decls.
+
 2004-09-03  John W. Eaton  <jwe@octave.org>
 
+	* oct-inttpes.h (OCTAVE_INT_CMP_OP): Convert operarands to double
+	to avoid signed/unsigned int comparison problems.
+
+	* mx-ops: Generate CMP and BOOL ops for mixed integer types and
+	for mixed integer and double types.
+
+	* mk-ops.awk: Output BIN_OP_DECLS, CMP_OP_DECLS, and BOOL_OP_DECLS
+	separately, and only if needed.
+
 	* oct-inttypes.h (octave_fit_to_range): Use constructor instead of
 	static_cast for type conversion.
 
--- a/liboctave/boolNDArray.cc	Fri Sep 03 15:43:30 2004 +0000
+++ b/liboctave/boolNDArray.cc	Sat Sep 04 01:16:28 2004 +0000
@@ -61,6 +61,31 @@
   MX_ND_ANY_ALL_REDUCTION (MX_ND_ANY_EVAL (MX_ND_ANY_EXPR), false);
 }
 
+boolNDArray
+concat (const boolNDArray& ra, const boolNDArray& rb, const Array<int>& ra_idx)
+{
+  boolNDArray retval (ra);
+  if (rb.numel () > 0)
+    retval.insert (rb, ra_idx);
+  return retval;
+}
+
+boolNDArray&
+boolNDArray::insert (const boolNDArray& a, int r, int c)
+{
+  Array<bool>::insert (a, r, c);
+  return *this;
+}
+
+boolNDArray&
+boolNDArray::insert (const boolNDArray& a, const Array<int>& ra_idx)
+{
+  Array<bool>::insert (a, ra_idx);
+  return *this;
+}
+
+
+
 boolMatrix
 boolNDArray::matrix_value (void) const
 {
--- a/liboctave/boolNDArray.h	Fri Sep 03 15:43:30 2004 +0000
+++ b/liboctave/boolNDArray.h	Sat Sep 04 01:16:28 2004 +0000
@@ -70,6 +70,12 @@
   boolNDArray all (int dim = -1) const;
   boolNDArray any (int dim = -1) const;
 
+  friend boolNDArray concat (const boolNDArray& ra, const boolNDArray& rb, 
+			     const Array<int>& ra_idx);
+
+  boolNDArray& insert (const boolNDArray& a, int r, int c);
+  boolNDArray& insert (const boolNDArray& a, const Array<int>& ra_idx);
+
   boolMatrix matrix_value (void) const;
 
   boolNDArray squeeze (void) const { return ArrayN<bool>::squeeze (); }
--- a/liboctave/mk-ops.awk	Fri Sep 03 15:43:30 2004 +0000
+++ b/liboctave/mk-ops.awk	Sat Sep 04 01:16:28 2004 +0000
@@ -137,8 +137,18 @@
 
           printf ("#include \"mx-op-defs.h\"\n") >> h_file;
 
-          printf ("%s%s_OP_DECLS (%s, %s, %s)\n", lhs_class,
-		  rhs_class, result_type, lhs_type, rhs_type) >> h_file
+          if (bin_ops)
+            printf ("%s%s_BIN_OP_DECLS (%s, %s, %s)\n", lhs_class,
+		    rhs_class, result_type, lhs_type, rhs_type) >> h_file
+
+          if (cmp_ops)
+            printf ("%s%s_CMP_OP_DECLS (%s, %s)\n", lhs_class,
+		    rhs_class, lhs_type, rhs_type) >> h_file
+
+          if (bool_ops)
+            printf ("%s%s_BOOL_OP_DECLS (%s, %s)\n", lhs_class,
+		    rhs_class, lhs_type, rhs_type) >> h_file
+
 
           print "#endif" >> h_file;
 
--- a/liboctave/mx-ops	Fri Sep 03 15:43:30 2004 +0000
+++ b/liboctave/mx-ops	Sat Sep 04 01:16:28 2004 +0000
@@ -9,6 +9,7 @@
 #   DM: diagonal matrix
 #   ND: N-d array
 #
+x NONE NONE NONE NO
 b bool S NONE NO
 bm boolMatrix ND boolMatrix.h YES
 bnda boolNDArray ND boolNDArray.h YES
@@ -26,12 +27,16 @@
 ui16 octave_uint16 S oct-inttypes.h YES
 i32 octave_int32 S oct-inttypes.h YES
 ui32 octave_uint32 S oct-inttypes.h YES
+i64 octave_int64 S oct-inttypes.h YES
+ui64 octave_uint64 S oct-inttypes.h YES
 i8nda int8NDArray ND int8NDArray.h YES
 ui8nda uint8NDArray ND uint8NDArray.h YES
 i16nda int16NDArray ND int16NDArray.h YES
 ui16nda uint16NDArray ND uint16NDArray.h YES
 i32nda int32NDArray ND int32NDArray.h YES
 ui32nda uint32NDArray ND uint32NDArray.h YES
+i64nda int64NDArray ND int64NDArray.h YES
+ui64nda uint64NDArray ND uint64NDArray.h YES
 # ops
 # result_t lhs_t rhs_t op-type lhs_conv rhs_conv zero_val headers ...
 #
@@ -71,6 +76,7 @@
 m dm s B
 m m dm B 0.0
 m s dm B
+#
 i8nda s i8nda BCL NONE NONE 0 boolMatrix.h boolNDArray.h
 i8nda i8nda s BCL NONE NONE 0 boolMatrix.h boolNDArray.h
 ui8nda s ui8nda BCL NONE NONE 0 boolMatrix.h boolNDArray.h
@@ -83,3 +89,233 @@
 i32nda i32nda s BCL NONE NONE 0 boolMatrix.h boolNDArray.h
 ui32nda s ui32nda BCL NONE NONE 0 boolMatrix.h boolNDArray.h
 ui32nda ui32nda s BCL NONE NONE 0 boolMatrix.h boolNDArray.h
+i64nda s i64nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+i64nda i64nda s CL NONE NONE 0 boolMatrix.h boolNDArray.h
+ui64nda s ui64nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+ui64nda ui64nda s CL NONE NONE 0 boolMatrix.h boolNDArray.h
+#
+x nda i8 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i8 nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x nda ui8 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui8 nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x nda i16 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i16 nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x nda ui16 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui16 nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x nda i32 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i32 nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x nda ui32 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui32 nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x nda i64 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i64 nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x nda ui64 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui64 nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+#
+x nda i8nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i8nda nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x nda ui8nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui8nda nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x nda i16nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i16nda nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x nda ui16nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui16nda nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x nda i32nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i32nda nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x nda ui32nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui32nda nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x nda i64nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i64nda nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x nda ui64nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui64nda nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+#
+x i8nda ui8 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i8nda i16 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i8nda ui16 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i8nda i32 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i8nda ui32 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i8nda i64 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i8nda ui64 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+#
+x i16nda i8 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i16nda ui8 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i16nda ui16 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i16nda i32 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i16nda ui32 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i16nda i64 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i16nda ui64 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+#
+x i32nda i8 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i32nda ui8 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i32nda i16 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i32nda ui16 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i32nda ui32 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i32nda i64 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i32nda ui64 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+#
+x i64nda i8 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i64nda ui8 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i64nda i16 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i64nda ui16 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i64nda i32 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i64nda ui32 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i64nda ui64 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+#
+x ui8nda i8 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui8nda i16 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui8nda ui16 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui8nda i32 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui8nda ui32 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui8nda i64 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui8nda ui64 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+#
+x ui16nda i8 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui16nda ui8 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui16nda i16 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui16nda i32 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui16nda ui32 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui16nda i64 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui16nda ui64 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+#
+x ui32nda i8 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui32nda ui8 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui32nda i16 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui32nda ui16 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui32nda i32 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui32nda i64 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui32nda ui64 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+#
+x ui64nda i8 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui64nda ui8 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui64nda i16 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui64nda ui16 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui64nda i32 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui64nda ui32 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui64nda i64 CL NONE NONE 0 boolMatrix.h boolNDArray.h
+#
+x i8 ui8nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i8 i16nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i8 ui16nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i8 i32nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i8 ui32nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i8 i64nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i8 ui64nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+#
+x i16 i8nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i16 ui8nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i16 ui16nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i16 i32nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i16 ui32nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i16 i64nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i16 ui64nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+#
+x i32 i8nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i32 ui8nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i32 i16nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i32 ui16nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i32 ui32nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i32 i64nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i32 ui64nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+#
+x i64 i8nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i64 ui8nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i64 i16nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i64 ui16nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i64 i32nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i64 ui32nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i64 ui64nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+#
+x ui8 i8nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui8 i16nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui8 ui16nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui8 i32nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui8 ui32nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui8 i64nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui8 ui64nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+#
+x ui16 i8nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui16 ui8nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui16 i16nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui16 i32nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui16 ui32nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui16 i64nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui16 ui64nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+#
+x ui32 i8nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui32 ui8nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui32 i16nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui32 ui16nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui32 i32nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui32 i64nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui32 ui64nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+#
+x ui64 i8nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui64 ui8nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui64 i16nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui64 ui16nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui64 i32nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui64 ui32nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui64 i64nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+#
+x i8nda ui8nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i8nda i16nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i8nda ui16nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i8nda i32nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i8nda ui32nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i8nda i64nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i8nda ui64nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+#
+x i16nda i8nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i16nda ui8nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i16nda ui16nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i16nda i32nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i16nda ui32nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i16nda i64nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i16nda ui64nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+#
+x i32nda i8nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i32nda ui8nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i32nda i16nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i32nda ui16nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i32nda ui32nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i32nda i64nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i32nda ui64nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+#
+x i64nda i8nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i64nda ui8nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i64nda i16nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i64nda ui16nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i64nda i32nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i64nda ui32nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x i64nda ui64nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+#
+x ui8nda i8nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui8nda i16nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui8nda ui16nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui8nda i32nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui8nda ui32nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui8nda i64nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui8nda ui64nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+#
+x ui16nda i8nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui16nda ui8nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui16nda i16nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui16nda i32nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui16nda ui32nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui16nda i64nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui16nda ui64nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+#
+x ui32nda i8nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui32nda ui8nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui32nda i16nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui32nda ui16nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui32nda i32nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui32nda i64nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui32nda ui64nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+#
+x ui64nda i8nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui64nda ui8nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui64nda i16nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui64nda ui16nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui64nda i32nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui64nda ui32nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
+x ui64nda i64nda CL NONE NONE 0 boolMatrix.h boolNDArray.h
--- a/liboctave/oct-inttypes.h	Fri Sep 03 15:43:30 2004 +0000
+++ b/liboctave/oct-inttypes.h	Sat Sep 04 01:16:28 2004 +0000
@@ -504,13 +504,18 @@
     return a;
 }
 
+// XXX FIXME XXX -- need partial specializations for int64 and uint64
+// types.
+
 #define OCTAVE_INT_CMP_OP(OP) \
  \
   template <class T1, class T2> \
   bool \
   operator OP (const octave_int<T1>& x, const octave_int<T2>& y) \
   { \
-    return x.value () OP y.value (); \
+    double tx = static_cast<double> (x.value ()); \
+    double ty = static_cast<double> (y.value ()); \
+    return tx OP ty; \
   }
 
 OCTAVE_INT_CMP_OP (<)
--- a/scripts/ChangeLog	Fri Sep 03 15:43:30 2004 +0000
+++ b/scripts/ChangeLog	Sat Sep 04 01:16:28 2004 +0000
@@ -1,3 +1,7 @@
+2004-09-03  David Bateman  <dbateman@free.fr>
+
+	* general/repmat.m: Fix to allow logical classes.
+
 2004-08-31  John W. Eaton  <jwe@octave.org>
 
 	* general/isa.m: New function, from Octave-forge.
--- a/scripts/general/repmat.m	Fri Sep 03 15:43:30 2004 +0000
+++ b/scripts/general/repmat.m	Sat Sep 04 01:16:28 2004 +0000
@@ -55,7 +55,16 @@
     if (isstr (a))
       x = setstr (toascii (a) * ones (idx));
     else
-      x = a * ones(idx, class(a));
+      if (strcmp (class (a), "double"))
+	## This is faster with octave for double/Complex
+	x = a * ones(idx, class(a));
+      else
+	cidx = cell (1, length (idx));
+	for i=1:length(idx)
+	  cidx{i} = ones (1,idx(i));
+	endfor
+	x = a (cidx{:});
+      endif
     endif
   elseif (ndims (a) == 2 && length (idx) < 3)
     if (isstr (a))
--- a/src/ChangeLog	Fri Sep 03 15:43:30 2004 +0000
+++ b/src/ChangeLog	Sat Sep 04 01:16:28 2004 +0000
@@ -1,5 +1,52 @@
 2004-09-03  John W. Eaton  <jwe@octave.org>
 
+	* OPERATORS/op-b-bm.cc (DEFCONV): Define bool scalar to bool
+	matrix conversion.
+	(install_b_bm_ops): Install it.
+	Install conversion for assignment of bool matrix to indexed bool.
+	* OPERATORS/op-b-b.cc (install_b_b_ops): Install conversion for
+	assignment of bool to indexed bool.
+
+2004-09-03  David Bateman  <dbateman@free.fr>
+
+	* OPERATORS/op-b-b.cc, OPERATORS/op-b-bm.cc, OPERATORS/op-bm-b.cc,
+	OPERATORS/op-bm-bm.cc: Modify concatenation between boolean types
+	so that it returns a boolean.
+
+	* ov-bool.cc (octave_bool::do_index_op): Return boolean matrix.
+
+	* ov-intx.h (do_index_op (const octave_value_list&, int)):
+	New function for indexed subsref of int types.
+
+2004-09-03  John W. Eaton  <jwe@octave.org>
+
+	* OPERATORS/op-int.h (OCTAVE_SM_INT_OPS): Define int by double
+	mixed comparison and bool ops.
+	(OCTAVE_INSTALL_SM_INT_OPS): Install them.
+	(OCTAVE_MS_INT_OPS): Define double by int mixed comparison and
+	bool ops.
+	(OCTAVE_INSTALL_MS_INT_OPS): Install them
+
+	* OPERATORS/op-i8-i8.cc, OPERATORS/op-i16-i16.cc,
+	OPERATORS/op-i32-i32.cc, OPERATORS/op-i64-i64.cc,
+	OPERATORS/op-ui8-ui8.cc, OPERATORS/op-ui16-ui16.cc,
+	OPERATORS/op-ui32-ui32.cc, OPERATORS/op-ui64-ui64.cc:
+	Define and install various mixed-type operators.
+
+	* OPERATORS/op-int.h (OCTAVE_MM_INT_OPS): Also define mixed int
+	and double matrix comparison and bool ops.
+	(OCTAVE_INSTALL_MM_INT_OPS): Install them.
+	(OCTAVE_SS_INT_BOOL_OPS, OCTAVE_SM_INT_BOOL_OPS,
+	OCTAVE_MS_INT_BOOL_OPS, OCTAVE_MM_INT_BOOL_OPS):
+	Define logical AND and OR ops.
+	(OCTAVE_INSTALL_SS_INT_BOOL_OPS, OCTAVE_INSTALL_SM_INT_BOOL_OPS,
+	OCTAVE_INSTALL_MS_INT_BOOL_OPS, OCTAVE_INSTALL_MM_INT_BOOL_OPS):
+	Install them.
+	(OCTAVE_MM_INT_CMP_OPS, OCTAVE_MM_INT_BOOL_OPS): Accept prefix arg.
+	(OCTAVE_MM_CONV): New macro.
+	(OCTAVE_MM_INT_OPS): Use it to define complex matrix conversion.
+	(OCTAVE_MIXED_INT_CMP_OPS, OCTAVE_MIXED_INT_BOOL_OPS): New macros.
+
 	* OPERATORS/op-int.h (OCTAVE_MS_INT_OPS): Don't define indexed int
 	matrix = complex scalar assignment ops.
 	(OCTAVE_MS_INT_OPS): Don't define indexed int matrix = complex
--- a/src/OPERATORS/op-b-b.cc	Fri Sep 03 15:43:30 2004 +0000
+++ b/src/OPERATORS/op-b-b.cc	Sat Sep 04 01:16:28 2004 +0000
@@ -32,6 +32,7 @@
 #include "oct-obj.h"
 #include "ov.h"
 #include "ov-bool.h"
+#include "ov-bool-mat.h"
 #include "ov-scalar.h"
 #include "ov-re-mat.h"
 #include "ov-typeinfo.h"
@@ -54,7 +55,7 @@
 DEFBINOP_OP (el_and, bool, bool, &&)
 DEFBINOP_OP (el_or, bool, bool, ||)
 
-DEFNDCATOP_FN (b_b, bool, bool, array, array, concat)
+DEFNDCATOP_FN (b_b, bool, bool, bool_array, bool_array, concat)
 DEFNDCATOP_FN (b_s, bool, scalar, array, array, concat)
 DEFNDCATOP_FN (s_b, scalar, bool, array, array, concat)
 
@@ -73,6 +74,8 @@
   INSTALL_CATOP (octave_bool, octave_bool, b_b);
   INSTALL_CATOP (octave_bool, octave_scalar, b_s);
   INSTALL_CATOP (octave_scalar, octave_bool, s_b);
+
+  INSTALL_ASSIGNCONV (octave_bool, octave_bool, octave_bool_matrix);
 }
 
 /*
--- a/src/OPERATORS/op-b-bm.cc	Fri Sep 03 15:43:30 2004 +0000
+++ b/src/OPERATORS/op-b-bm.cc	Sat Sep 04 01:16:28 2004 +0000
@@ -45,10 +45,17 @@
 DEFNDBINOP_FN (el_and, bool, bool_matrix, bool, bool_array, mx_el_and)
 DEFNDBINOP_FN (el_or, bool, bool_matrix, bool, bool_array, mx_el_or)
 
-DEFNDCATOP_FN (b_bm, bool, bool_matrix, array, array, concat)
+DEFNDCATOP_FN (b_bm, bool, bool_matrix, bool_array, bool_array, concat)
 DEFNDCATOP_FN (b_m, bool, matrix, array, array, concat)
 DEFNDCATOP_FN (s_bm, scalar, bool_matrix, array, array, concat)
 
+DEFCONV (bool_matrix_conv, bool, bool_matrix)
+{
+  CAST_CONV_ARG (const octave_bool&);
+
+  return new octave_bool_matrix (v.bool_matrix_value ());
+}
+
 void
 install_b_bm_ops (void)
 {
@@ -58,6 +65,10 @@
   INSTALL_CATOP (octave_bool, octave_bool_matrix, b_bm);
   INSTALL_CATOP (octave_bool, octave_matrix, b_m);
   INSTALL_CATOP (octave_scalar, octave_bool_matrix, s_bm);
+
+  INSTALL_ASSIGNCONV (octave_bool, octave_bool_matrix, octave_bool_matrix);
+
+  INSTALL_WIDENOP (octave_bool, octave_bool_matrix, bool_matrix_conv);
 }
 
 /*
--- a/src/OPERATORS/op-bm-b.cc	Fri Sep 03 15:43:30 2004 +0000
+++ b/src/OPERATORS/op-bm-b.cc	Sat Sep 04 01:16:28 2004 +0000
@@ -45,7 +45,7 @@
 DEFNDBINOP_FN (el_and, bool_matrix, bool, bool_array, bool, mx_el_and)
 DEFNDBINOP_FN (el_or, bool_matrix, bool, bool_array, bool, mx_el_or)
 
-DEFNDCATOP_FN (bm_b, bool_matrix, bool, array, array, concat)
+DEFNDCATOP_FN (bm_b, bool_matrix, bool, bool_array, bool_array, concat)
 DEFNDCATOP_FN (bm_s, bool_matrix, scalar, array, array, concat)
 DEFNDCATOP_FN (m_b, matrix, bool, array, array, concat)
 
--- a/src/OPERATORS/op-bm-bm.cc	Fri Sep 03 15:43:30 2004 +0000
+++ b/src/OPERATORS/op-bm-bm.cc	Sat Sep 04 01:16:28 2004 +0000
@@ -66,7 +66,7 @@
 DEFNDBINOP_FN (el_or,  bool_matrix, bool_matrix, bool_array, bool_array,
 	       mx_el_or)
 
-DEFNDCATOP_FN (bm_bm, bool_matrix, bool_matrix, array, array, concat)
+DEFNDCATOP_FN (bm_bm, bool_matrix, bool_matrix, bool_array, bool_array, concat)
 DEFNDCATOP_FN (bm_m, bool_matrix, matrix, array, array, concat)
 DEFNDCATOP_FN (m_bm, matrix, bool_matrix, array, array, concat)
 
--- a/src/OPERATORS/op-i16-i16.cc	Fri Sep 03 15:43:30 2004 +0000
+++ b/src/OPERATORS/op-i16-i16.cc	Sat Sep 04 01:16:28 2004 +0000
@@ -28,6 +28,39 @@
 #include <config.h>
 #endif
 
+#include "mx-i16nda-i8.h"
+#include "mx-i16nda-ui8.h"
+#include "mx-i16nda-ui16.h"
+#include "mx-i16nda-i32.h"
+#include "mx-i16nda-ui32.h"
+#include "mx-i16nda-i64.h"
+#include "mx-i16nda-ui64.h"
+
+#include "mx-i16nda-i8nda.h"
+#include "mx-i16nda-ui8nda.h"
+#include "mx-i16nda-ui16nda.h"
+#include "mx-i16nda-i32nda.h"
+#include "mx-i16nda-ui32nda.h"
+#include "mx-i16nda-i64nda.h"
+#include "mx-i16nda-ui64nda.h"
+
+#include "mx-i16-i8nda.h"
+#include "mx-i16-ui8nda.h"
+#include "mx-i16-ui16nda.h"
+#include "mx-i16-i32nda.h"
+#include "mx-i16-ui32nda.h"
+#include "mx-i16-i64nda.h"
+#include "mx-i16-ui64nda.h"
+
+#include "mx-i16nda-s.h"
+#include "mx-s-i16nda.h"
+
+#include "mx-i16nda-nda.h"
+#include "mx-nda-i16nda.h"
+
+#include "mx-i16-nda.h"
+#include "mx-nda-i16.h"
+
 #include "gripes.h"
 #include "oct-obj.h"
 #include "ov.h"
@@ -68,6 +101,14 @@
 OCTAVE_MM_INT_ASSIGN_OPS (mmi64, int16_, int64_, int64_)
 OCTAVE_MM_INT_ASSIGN_OPS (mmui64, int16_, uint64_, uint64_)
 
+OCTAVE_MIXED_INT_CMP_OPS (int16, int8)
+OCTAVE_MIXED_INT_CMP_OPS (int16, uint8)
+OCTAVE_MIXED_INT_CMP_OPS (int16, uint16)
+OCTAVE_MIXED_INT_CMP_OPS (int16, int32)
+OCTAVE_MIXED_INT_CMP_OPS (int16, uint32)
+OCTAVE_MIXED_INT_CMP_OPS (int16, int64)
+OCTAVE_MIXED_INT_CMP_OPS (int16, uint64)
+
 void
 install_i16_i16_ops (void)
 {
@@ -96,6 +137,14 @@
   OCTAVE_INSTALL_SM_INT_ASSIGNCONV (int16, uint32);
   OCTAVE_INSTALL_SM_INT_ASSIGNCONV (int16, int64);
   OCTAVE_INSTALL_SM_INT_ASSIGNCONV (int16, uint64);
+
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (int16, int8);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (int16, uint8);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (int16, uint16);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (int16, int32);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (int16, uint32);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (int16, int64);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (int16, uint64);
 }
 
 /*
--- a/src/OPERATORS/op-i32-i32.cc	Fri Sep 03 15:43:30 2004 +0000
+++ b/src/OPERATORS/op-i32-i32.cc	Sat Sep 04 01:16:28 2004 +0000
@@ -28,6 +28,39 @@
 #include <config.h>
 #endif
 
+#include "mx-i32nda-i8.h"
+#include "mx-i32nda-ui8.h"
+#include "mx-i32nda-i16.h"
+#include "mx-i32nda-ui16.h"
+#include "mx-i32nda-ui32.h"
+#include "mx-i32nda-i64.h"
+#include "mx-i32nda-ui64.h"
+
+#include "mx-i32nda-i8nda.h"
+#include "mx-i32nda-ui8nda.h"
+#include "mx-i32nda-i16nda.h"
+#include "mx-i32nda-ui16nda.h"
+#include "mx-i32nda-ui32nda.h"
+#include "mx-i32nda-i64nda.h"
+#include "mx-i32nda-ui64nda.h"
+
+#include "mx-i32-i8nda.h"
+#include "mx-i32-ui8nda.h"
+#include "mx-i32-i16nda.h"
+#include "mx-i32-ui16nda.h"
+#include "mx-i32-ui32nda.h"
+#include "mx-i32-i64nda.h"
+#include "mx-i32-ui64nda.h"
+
+#include "mx-i32nda-s.h"
+#include "mx-s-i32nda.h"
+
+#include "mx-i32nda-nda.h"
+#include "mx-nda-i32nda.h"
+
+#include "mx-i32-nda.h"
+#include "mx-nda-i32.h"
+
 #include "gripes.h"
 #include "oct-obj.h"
 #include "ov.h"
@@ -68,6 +101,14 @@
 OCTAVE_MM_INT_ASSIGN_OPS (mmi64, int32_, int64_, int64_)
 OCTAVE_MM_INT_ASSIGN_OPS (mmui64, int32_, uint64_, uint64_)
 
+OCTAVE_MIXED_INT_CMP_OPS (int32, int8)
+OCTAVE_MIXED_INT_CMP_OPS (int32, uint8)
+OCTAVE_MIXED_INT_CMP_OPS (int32, int16)
+OCTAVE_MIXED_INT_CMP_OPS (int32, uint16)
+OCTAVE_MIXED_INT_CMP_OPS (int32, uint32)
+OCTAVE_MIXED_INT_CMP_OPS (int32, int64)
+OCTAVE_MIXED_INT_CMP_OPS (int32, uint64)
+
 void
 install_i32_i32_ops (void)
 {
@@ -96,6 +137,14 @@
   OCTAVE_INSTALL_SM_INT_ASSIGNCONV (int32, uint32);
   OCTAVE_INSTALL_SM_INT_ASSIGNCONV (int32, int64);
   OCTAVE_INSTALL_SM_INT_ASSIGNCONV (int32, uint64);
+
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (int32, int8);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (int32, uint8);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (int32, int16);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (int32, uint16);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (int32, uint32);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (int32, int64);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (int32, uint64);
 }
 
 /*
--- a/src/OPERATORS/op-i64-i64.cc	Fri Sep 03 15:43:30 2004 +0000
+++ b/src/OPERATORS/op-i64-i64.cc	Sat Sep 04 01:16:28 2004 +0000
@@ -28,6 +28,39 @@
 #include <config.h>
 #endif
 
+#include "mx-i64nda-i8.h"
+#include "mx-i64nda-ui8.h"
+#include "mx-i64nda-i16.h"
+#include "mx-i64nda-ui16.h"
+#include "mx-i64nda-i32.h"
+#include "mx-i64nda-ui32.h"
+#include "mx-i64nda-ui64.h"
+
+#include "mx-i64nda-i8nda.h"
+#include "mx-i64nda-ui8nda.h"
+#include "mx-i64nda-i16nda.h"
+#include "mx-i64nda-ui16nda.h"
+#include "mx-i64nda-i32nda.h"
+#include "mx-i64nda-ui32nda.h"
+#include "mx-i64nda-ui64nda.h"
+
+#include "mx-i64-i8nda.h"
+#include "mx-i64-ui8nda.h"
+#include "mx-i64-i16nda.h"
+#include "mx-i64-ui16nda.h"
+#include "mx-i64-i32nda.h"
+#include "mx-i64-ui32nda.h"
+#include "mx-i64-ui64nda.h"
+
+#include "mx-i64nda-s.h"
+#include "mx-s-i64nda.h"
+
+#include "mx-i64nda-nda.h"
+#include "mx-nda-i64nda.h"
+
+#include "mx-i64-nda.h"
+#include "mx-nda-i64.h"
+
 #include "gripes.h"
 #include "oct-obj.h"
 #include "ov.h"
@@ -64,8 +97,8 @@
 OCTAVE_MS_INT_ASSIGN_OPS (mc, int64_, complex_, )
 
 OCTAVE_M_INT_UNOPS (int64)
-OCTAVE_MM_INT_CMP_OPS (int64, int64)
-OCTAVE_MM_INT_BOOL_OPS (int64, int64)
+OCTAVE_MM_INT_CMP_OPS (mm, int64_, int64_)
+OCTAVE_MM_INT_BOOL_OPS (mm, int64_, int64_)
 OCTAVE_MM_INT_ASSIGN_OPS (mm, int64_, int64_, int64_)
 OCTAVE_MM_INT_ASSIGN_OPS (mmx, int64_, , )
 OCTAVE_MM_INT_ASSIGN_OPS (mmc, int64_, complex_, )
@@ -86,6 +119,14 @@
 OCTAVE_MM_INT_ASSIGN_OPS (mmui32, int64_, uint32_, uint32_)
 OCTAVE_MM_INT_ASSIGN_OPS (mmui64, int64_, uint64_, uint64_)
 
+OCTAVE_MIXED_INT_CMP_OPS (int64, int8)
+OCTAVE_MIXED_INT_CMP_OPS (int64, uint8)
+OCTAVE_MIXED_INT_CMP_OPS (int64, int16)
+OCTAVE_MIXED_INT_CMP_OPS (int64, uint16)
+OCTAVE_MIXED_INT_CMP_OPS (int64, int32)
+OCTAVE_MIXED_INT_CMP_OPS (int64, uint32)
+OCTAVE_MIXED_INT_CMP_OPS (int64, uint64)
+
 void
 install_i64_i64_ops (void)
 {
@@ -103,8 +144,8 @@
   OCTAVE_INSTALL_MS_INT_ASSIGN_OPS (mc, int64_, complex_);
 
   OCTAVE_INSTALL_M_INT_UNOPS (int64);
-  OCTAVE_INSTALL_MM_INT_CMP_OPS (int64, int64);
-  OCTAVE_INSTALL_MM_INT_BOOL_OPS (int64, int64);
+  OCTAVE_INSTALL_MM_INT_CMP_OPS (mm, int64_, int64_);
+  OCTAVE_INSTALL_MM_INT_BOOL_OPS (mm, int64_, int64_);
   OCTAVE_INSTALL_MM_INT_ASSIGN_OPS (mm, int64_, int64_);
   OCTAVE_INSTALL_MM_INT_ASSIGN_OPS (mmx, int64_, );
   OCTAVE_INSTALL_MM_INT_ASSIGN_OPS (mmc, int64_, complex_);
@@ -132,6 +173,14 @@
   OCTAVE_INSTALL_SM_INT_ASSIGNCONV (int64, int32);
   OCTAVE_INSTALL_SM_INT_ASSIGNCONV (int64, uint32);
   OCTAVE_INSTALL_SM_INT_ASSIGNCONV (int64, uint64);
+
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (int64, int8);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (int64, uint8);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (int64, int16);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (int64, uint16);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (int64, int32);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (int64, uint32);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (int64, uint64);
 }
 
 /*
--- a/src/OPERATORS/op-i8-i8.cc	Fri Sep 03 15:43:30 2004 +0000
+++ b/src/OPERATORS/op-i8-i8.cc	Sat Sep 04 01:16:28 2004 +0000
@@ -28,6 +28,39 @@
 #include <config.h>
 #endif
 
+#include "mx-i8nda-ui8.h"
+#include "mx-i8nda-i16.h"
+#include "mx-i8nda-ui16.h"
+#include "mx-i8nda-i32.h"
+#include "mx-i8nda-ui32.h"
+#include "mx-i8nda-i64.h"
+#include "mx-i8nda-ui64.h"
+
+#include "mx-i8nda-ui8nda.h"
+#include "mx-i8nda-i16nda.h"
+#include "mx-i8nda-ui16nda.h"
+#include "mx-i8nda-i32nda.h"
+#include "mx-i8nda-ui32nda.h"
+#include "mx-i8nda-i64nda.h"
+#include "mx-i8nda-ui64nda.h"
+
+#include "mx-i8-ui8nda.h"
+#include "mx-i8-i16nda.h"
+#include "mx-i8-ui16nda.h"
+#include "mx-i8-i32nda.h"
+#include "mx-i8-ui32nda.h"
+#include "mx-i8-i64nda.h"
+#include "mx-i8-ui64nda.h"
+
+#include "mx-i8nda-s.h"
+#include "mx-s-i8nda.h"
+
+#include "mx-i8nda-nda.h"
+#include "mx-nda-i8nda.h"
+
+#include "mx-i8-nda.h"
+#include "mx-nda-i8.h"
+
 #include "gripes.h"
 #include "oct-obj.h"
 #include "ov.h"
@@ -68,6 +101,14 @@
 OCTAVE_MM_INT_ASSIGN_OPS (mmi64, int8_, int64_, int64_)
 OCTAVE_MM_INT_ASSIGN_OPS (mmui64, int8_, uint64_, uint64_)
 
+OCTAVE_MIXED_INT_CMP_OPS (int8, uint8)
+OCTAVE_MIXED_INT_CMP_OPS (int8, int16)
+OCTAVE_MIXED_INT_CMP_OPS (int8, uint16)
+OCTAVE_MIXED_INT_CMP_OPS (int8, int32)
+OCTAVE_MIXED_INT_CMP_OPS (int8, uint32)
+OCTAVE_MIXED_INT_CMP_OPS (int8, int64)
+OCTAVE_MIXED_INT_CMP_OPS (int8, uint64)
+
 void
 install_i8_i8_ops (void)
 {
@@ -96,6 +137,14 @@
   OCTAVE_INSTALL_SM_INT_ASSIGNCONV (int8, uint32);
   OCTAVE_INSTALL_SM_INT_ASSIGNCONV (int8, int64);
   OCTAVE_INSTALL_SM_INT_ASSIGNCONV (int8, uint64);
+
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (int8, uint8);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (int8, int16);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (int8, uint16);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (int8, int32);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (int8, uint32);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (int8, int64);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (int8, uint64);
 }
 
 /*
--- a/src/OPERATORS/op-int.h	Fri Sep 03 15:43:30 2004 +0000
+++ b/src/OPERATORS/op-int.h	Sat Sep 04 01:16:28 2004 +0000
@@ -99,8 +99,19 @@
   } \
 
 #define OCTAVE_SS_INT_BOOL_OPS(PFX, T1, T2) \
-  /* DEFBINOP_OP (PFX ## _el_and, T1 ## scalar, T2 ## scalar, &&) */ \
-  /* DEFBINOP_OP (PFX ## _el_or, T1 ## scalar, T2 ## scalar, ||) */
+  DEFBINOP (PFX ## _el_and, T2, T2) \
+  { \
+    CAST_BINOP_ARGS (const octave_ ## T1 ## scalar&, const octave_ ## T2 ## scalar&); \
+ \
+    return v1.T1 ## scalar_value () != 0 && v2.T2 ## scalar_value () != 0; \
+  } \
+ \
+  DEFBINOP (PFX ## _el_or, T1, T2) \
+  { \
+    CAST_BINOP_ARGS (const octave_ ## T1 ## scalar&, const octave_ ## T2 ## scalar&); \
+ \
+    return v1.T1 ## scalar_value () != 0 || v2.T2 ## scalar_value () != 0; \
+  }
 
 #define OCTAVE_SS_INT_CMP_OPS(PFX, T1, T2) \
   DEFBINOP_OP (PFX ## _lt, T1 ## scalar, T2 ## scalar, <) \
@@ -199,8 +210,8 @@
   DEFNDBINOP_FN (PFX ## _ne, TS ## scalar, TM ## matrix, TS ## scalar, TM ## array, mx_el_ne)
 
 #define OCTAVE_SM_INT_BOOL_OPS(PFX, TS, TM) \
-  /* DEFNDBINOP_FN (PFX ## _el_and, TS ## scalar, TYPE ## matrix, TS ## scalar, TYPE ## array, mx_el_and) */ \
-  /* DEFNDBINOP_FN (PFX ## _el_or,  TS ## scalar, TYPE ## matrix, TS ## scalar, TYPE ## array, mx_el_or) */
+  DEFNDBINOP_FN (PFX ## _el_and, TS ## scalar, TM ## matrix, TS ## scalar, TM ## array, mx_el_and) \
+  DEFNDBINOP_FN (PFX ## _el_or,  TS ## scalar, TM ## matrix, TS ## scalar, TM ## array, mx_el_or)
 
 #define OCTAVE_SM_POW_OPS(T1, T2) \
   octave_value \
@@ -229,8 +240,10 @@
   OCTAVE_SM_INT_ARITH_OPS (xm, , TYPE ## _) \
   OCTAVE_SM_INT_CMP_OPS (sm, TYPE ## _, TYPE ## _) \
   OCTAVE_SM_INT_CMP_OPS (xm, , TYPE ## _) \
+  OCTAVE_SM_INT_CMP_OPS (smx, TYPE ## _, ) \
   OCTAVE_SM_INT_BOOL_OPS (sm, TYPE ## _, TYPE ## _) \
   OCTAVE_SM_INT_BOOL_OPS (xm, , TYPE ## _) \
+  OCTAVE_SM_INT_BOOL_OPS (smx, TYPE ## _, ) \
   OCTAVE_SM_CONV (TYPE ## _, TYPE ## _) \
   OCTAVE_SM_CONV (TYPE ## _, complex_)
 
@@ -295,12 +308,11 @@
   DEFNDBINOP_FN (PFX ## _eq, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, mx_el_eq) \
   DEFNDBINOP_FN (PFX ## _ge, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, mx_el_ge) \
   DEFNDBINOP_FN (PFX ## _gt, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, mx_el_gt) \
-  DEFNDBINOP_FN (PFX ## _ne, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, mx_el_ne) \
+  DEFNDBINOP_FN (PFX ## _ne, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, mx_el_ne)
 
 #define OCTAVE_MS_INT_BOOL_OPS(PFX, TM, TS) \
-  /* DEFNDBINOP_FN (PFX ## _el_and, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, mx_el_and) */ \
-  /* DEFNDBINOP_FN (PFX ## _el_or, TM ## matrix, TS ## scalar, TM
-     ## array, TS ## scalar, mx_el_or) */
+  DEFNDBINOP_FN (PFX ## _el_and, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, mx_el_and) \
+  DEFNDBINOP_FN (PFX ## _el_or, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, mx_el_or)
 
 #define OCTAVE_MS_INT_ASSIGN_OPS(PFX, TM, TS, TE) \
   DEFNDASSIGNOP_FN (PFX ## _assign, TM ## matrix, TS ## scalar, TE ## array, assign)
@@ -323,8 +335,10 @@
   OCTAVE_MS_INT_ARITH_OPS (mx, TYPE ## _, ) \
   OCTAVE_MS_INT_CMP_OPS (ms, TYPE ## _, TYPE ## _) \
   OCTAVE_MS_INT_CMP_OPS (mx, TYPE ## _, ) \
+  OCTAVE_MS_INT_CMP_OPS (mxs, , TYPE ## _) \
   OCTAVE_MS_INT_BOOL_OPS (ms, TYPE ## _, TYPE ## _) \
   OCTAVE_MS_INT_BOOL_OPS (mx, TYPE ## _, ) \
+  OCTAVE_MS_INT_BOOL_OPS (mxs, , TYPE ## _) \
   OCTAVE_MS_INT_ASSIGN_OPS (ms, TYPE ## _, TYPE ## _, TYPE ## _) \
   OCTAVE_MS_INT_ASSIGN_OPS (mx, TYPE ## _, , )
 
@@ -380,17 +394,17 @@
   /* return octave_value (quotient (v2.array_value (), v1.array_value ())); */ \
   /* } */
 
-#define OCTAVE_MM_INT_CMP_OPS(T1, T2) \
-  DEFNDBINOP_FN (mm_lt, T1 ## _matrix, T2 ## _matrix, T1 ## _array, T2 ## _array, mx_el_lt) \
-  DEFNDBINOP_FN (mm_le, T1 ## _matrix, T2 ## _matrix, T1 ## _array, T2 ## _array, mx_el_le) \
-  DEFNDBINOP_FN (mm_eq, T1 ## _matrix, T2 ## _matrix, T1 ## _array, T2 ## _array, mx_el_eq) \
-  DEFNDBINOP_FN (mm_ge, T1 ## _matrix, T2 ## _matrix, T1 ## _array, T2 ## _array, mx_el_ge) \
-  DEFNDBINOP_FN (mm_gt, T1 ## _matrix, T2 ## _matrix, T1 ## _array, T2 ## _array, mx_el_gt) \
-  DEFNDBINOP_FN (mm_ne, T1 ## _matrix, T2 ## _matrix, T1 ## _array, T2 ## _array, mx_el_ne)
+#define OCTAVE_MM_INT_CMP_OPS(PFX, T1, T2) \
+  DEFNDBINOP_FN (PFX ## _lt, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, mx_el_lt) \
+  DEFNDBINOP_FN (PFX ## _le, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, mx_el_le) \
+  DEFNDBINOP_FN (PFX ## _eq, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, mx_el_eq) \
+  DEFNDBINOP_FN (PFX ## _ge, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, mx_el_ge) \
+  DEFNDBINOP_FN (PFX ## _gt, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, mx_el_gt) \
+  DEFNDBINOP_FN (PFX ## _ne, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, mx_el_ne)
 
-#define OCTAVE_MM_INT_BOOL_OPS(T1, T2) \
-  DEFNDBINOP_FN (mm_el_and, T1 ## _matrix, T2 ## _matrix, T1 ## _array, T2 ## _array, mx_el_and) \
-  DEFNDBINOP_FN (mm_el_or,  T1 ## _matrix, T2 ## _matrix, T1 ## _array, T2 ## _array, mx_el_or)
+#define OCTAVE_MM_INT_BOOL_OPS(PFX, T1, T2) \
+  DEFNDBINOP_FN (PFX ## _el_and, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, mx_el_and) \
+  DEFNDBINOP_FN (PFX ## _el_or,  T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, mx_el_or)
 
 #define OCTAVE_MM_INT_ASSIGN_OPS(PFX, TLHS, TRHS, TE) \
   DEFNDASSIGNOP_FN (PFX ## _assign, TLHS ## matrix, TRHS ## matrix, TE ## array, assign)
@@ -415,14 +429,25 @@
     return octave_value (result); \
   }
 
+#define OCTAVE_MM_CONV(T1, T2) \
+  DEFCONV (T1 ## m_ ## T2 ## m_conv, T1 ## matrix, T2 ## matrix) \
+  { \
+    CAST_CONV_ARG (const octave_ ## T1 ## matrix&); \
+ \
+    return new octave_ ## T2 ## matrix (v.T2 ## array_value ()); \
+  }
+
 #define OCTAVE_MM_INT_OPS(TYPE) \
   OCTAVE_M_INT_UNOPS (TYPE) \
   OCTAVE_MM_POW_OPS (TYPE, TYPE) \
   OCTAVE_MM_INT_ARITH_OPS (TYPE, TYPE) \
-  OCTAVE_MM_INT_CMP_OPS (TYPE, TYPE) \
-  OCTAVE_MM_INT_BOOL_OPS (TYPE, TYPE) \
+  OCTAVE_MM_INT_CMP_OPS (mm, TYPE ## _, TYPE ## _) \
+  OCTAVE_MM_INT_CMP_OPS (mmx, TYPE ## _, ) \
+  OCTAVE_MM_INT_BOOL_OPS (mm, TYPE ## _, TYPE ## _) \
+  OCTAVE_MM_INT_BOOL_OPS (mmx, TYPE ## _, ) \
   OCTAVE_MM_INT_ASSIGN_OPS (mm, TYPE ## _, TYPE ## _, TYPE ## _) \
-  OCTAVE_MM_INT_ASSIGN_OPS (mmx, TYPE ## _, , )
+  OCTAVE_MM_INT_ASSIGN_OPS (mmx, TYPE ## _, , ) \
+  OCTAVE_MM_CONV(TYPE ## _, complex_)
 
 #define OCTAVE_MM_INT_OPS2(T1, T2) \
   OCTAVE_MM_INT_ARITH_OPS (mm, T1, T2) \
@@ -476,8 +501,8 @@
   INSTALL_BINOP (op_ne, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _ne);
 
 #define OCTAVE_INSTALL_SS_INT_BOOL_OPS(PFX, T1, T2) \
-  /* INSTALL_BINOP (op_el_and, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _el_and); */ \
-  /* INSTALL_BINOP (op_el_or, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _el_or); */
+  INSTALL_BINOP (op_el_and, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _el_and); \
+  INSTALL_BINOP (op_el_or, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _el_or);
 
 #define OCTAVE_INSTALL_SS_INT_OPS(TYPE) \
   OCTAVE_INSTALL_S_INT_UNOPS (TYPE) \
@@ -520,18 +545,20 @@
   INSTALL_BINOP (op_ne, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _ne);
 
 #define OCTAVE_INSTALL_SM_INT_BOOL_OPS(PFX, T1, T2) \
-  /* INSTALL_BINOP (op_el_and, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_and); */ \
-  /* INSTALL_BINOP (op_el_or, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_or); */
+  INSTALL_BINOP (op_el_and, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_and); \
+  INSTALL_BINOP (op_el_or, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_or);
 
 #define OCTAVE_INSTALL_SM_INT_OPS(TYPE) \
   OCTAVE_INSTALL_SM_INT_ARITH_OPS (sm, TYPE ## _, TYPE ## _) \
   OCTAVE_INSTALL_SM_INT_ARITH_OPS (xm, , TYPE ## _) \
   OCTAVE_INSTALL_SM_INT_CMP_OPS (sm, TYPE ## _, TYPE ## _) \
   OCTAVE_INSTALL_SM_INT_CMP_OPS (xm, , TYPE ## _) \
+  OCTAVE_INSTALL_SM_INT_CMP_OPS (smx, TYPE ## _, ) \
   OCTAVE_INSTALL_SM_INT_BOOL_OPS (sm, TYPE ## _, TYPE ## _) \
   OCTAVE_INSTALL_SM_INT_BOOL_OPS (xm, , TYPE ## _) \
-  INSTALL_WIDENOP (octave_ ## TYPE ## _scalar, octave_ ## TYPE ## _matrix, TYPE ## _matrix_conv) \
-  INSTALL_WIDENOP (octave_ ## TYPE ## _scalar, octave_complex_matrix, complex_matrix_conv) \
+  OCTAVE_INSTALL_SM_INT_BOOL_OPS (smx, TYPE ## _, ) \
+  INSTALL_WIDENOP (octave_ ## TYPE ## _scalar, octave_ ## TYPE ## _matrix, TYPE ## _s_ ## TYPE ## _m_conv) \
+  INSTALL_WIDENOP (octave_ ## TYPE ## _scalar, octave_complex_matrix, TYPE ## _s_complex_m_conv) \
   INSTALL_ASSIGNCONV (octave_ ## TYPE ## _scalar, octave_ ## TYPE ## _matrix, octave_ ## TYPE ## _matrix) \
   INSTALL_ASSIGNCONV (octave_ ## TYPE ## _scalar, octave_matrix, octave_ ## TYPE ## _matrix) \
   INSTALL_ASSIGNCONV (octave_ ## TYPE ## _scalar, octave_complex_matrix, octave_complex_matrix)
@@ -563,8 +590,8 @@
   INSTALL_BINOP (op_ne, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _ne);
 
 #define OCTAVE_INSTALL_MS_INT_BOOL_OPS(PFX, T1, T2) \
-  /* INSTALL_BINOP (op_el_and, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_and); */ \
-  /* INSTALL_BINOP (op_el_or, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_or); */
+  INSTALL_BINOP (op_el_and, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_and); \
+  INSTALL_BINOP (op_el_or, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_or);
 
 #define OCTAVE_INSTALL_MS_INT_ASSIGN_OPS(PFX, TLHS, TRHS) \
   INSTALL_ASSIGNOP (op_asn_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## scalar, PFX ## _assign)
@@ -574,8 +601,10 @@
   OCTAVE_INSTALL_MS_INT_ARITH_OPS (mx, TYPE ## _, ) \
   OCTAVE_INSTALL_MS_INT_CMP_OPS (ms, TYPE ## _, TYPE ## _) \
   OCTAVE_INSTALL_MS_INT_CMP_OPS (mx, TYPE ## _, ) \
+  OCTAVE_INSTALL_MS_INT_CMP_OPS (mxs, , TYPE ## _) \
   OCTAVE_INSTALL_MS_INT_BOOL_OPS (ms, TYPE ## _, TYPE ## _) \
   OCTAVE_INSTALL_MS_INT_BOOL_OPS (mx, TYPE ## _, ) \
+  OCTAVE_INSTALL_MS_INT_BOOL_OPS (mxs, , TYPE ## _) \
   OCTAVE_INSTALL_MS_INT_ASSIGN_OPS (ms, TYPE ## _, TYPE ## _) \
   OCTAVE_INSTALL_MS_INT_ASSIGN_OPS (mx, TYPE ## _, ) \
   INSTALL_ASSIGNCONV (octave_ ## TYPE ## _matrix, octave_complex_scalar, octave_complex_matrix)
@@ -606,17 +635,17 @@
   INSTALL_BINOP (op_el_pow, octave_ ## T1 ## _matrix, octave_ ## T2 ## _matrix, mm_el_pow); \
   /* INSTALL_BINOP (op_el_ldiv, octave_ ## T1 ## _matrix, octave_ ## T2 ## _matrix, mm_el_ldiv); */
 
-#define OCTAVE_INSTALL_MM_INT_CMP_OPS(T1, T2) \
-  INSTALL_BINOP (op_lt, octave_ ## T1 ## _matrix, octave_ ## T2 ## _matrix, mm_lt); \
-  INSTALL_BINOP (op_le, octave_ ## T1 ## _matrix, octave_ ## T2 ## _matrix, mm_le); \
-  INSTALL_BINOP (op_eq, octave_ ## T1 ## _matrix, octave_ ## T2 ## _matrix, mm_eq); \
-  INSTALL_BINOP (op_ge, octave_ ## T1 ## _matrix, octave_ ## T2 ## _matrix, mm_ge); \
-  INSTALL_BINOP (op_gt, octave_ ## T1 ## _matrix, octave_ ## T2 ## _matrix, mm_gt); \
-  INSTALL_BINOP (op_ne, octave_ ## T1 ## _matrix, octave_ ## T2 ## _matrix, mm_ne);
+#define OCTAVE_INSTALL_MM_INT_CMP_OPS(PFX, T1, T2) \
+  INSTALL_BINOP (op_lt, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _lt); \
+  INSTALL_BINOP (op_le, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _le); \
+  INSTALL_BINOP (op_eq, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _eq); \
+  INSTALL_BINOP (op_ge, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _ge); \
+  INSTALL_BINOP (op_gt, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _gt); \
+  INSTALL_BINOP (op_ne, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _ne);
 
-#define OCTAVE_INSTALL_MM_INT_BOOL_OPS(T1, T2) \
-  INSTALL_BINOP (op_el_and, octave_ ## T1 ## _matrix, octave_ ## T2 ## _matrix, mm_el_and); \
-  INSTALL_BINOP (op_el_or, octave_ ## T1 ## _matrix, octave_ ## T2 ## _matrix, mm_el_or);
+#define OCTAVE_INSTALL_MM_INT_BOOL_OPS(PFX, T1, T2) \
+  INSTALL_BINOP (op_el_and, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_and); \
+  INSTALL_BINOP (op_el_or, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_or);
 
 #define OCTAVE_INSTALL_MM_INT_ASSIGN_OPS(PFX, TLHS, TRHS) \
   INSTALL_ASSIGNOP (op_asn_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## matrix, PFX ## _assign)
@@ -624,11 +653,13 @@
 #define OCTAVE_INSTALL_MM_INT_OPS(TYPE) \
   OCTAVE_INSTALL_M_INT_UNOPS (TYPE) \
   OCTAVE_INSTALL_MM_INT_ARITH_OPS (TYPE, TYPE) \
-  OCTAVE_INSTALL_MM_INT_CMP_OPS (TYPE, TYPE) \
-  OCTAVE_INSTALL_MM_INT_BOOL_OPS (TYPE, TYPE) \
+  OCTAVE_INSTALL_MM_INT_CMP_OPS (mm, TYPE ## _, TYPE ## _) \
+  OCTAVE_INSTALL_MM_INT_CMP_OPS (mmx, TYPE ## _, ) \
+  OCTAVE_INSTALL_MM_INT_BOOL_OPS (mm, TYPE ## _, TYPE ## _) \
+  OCTAVE_INSTALL_MM_INT_BOOL_OPS (mmx, TYPE ## _, ) \
   OCTAVE_INSTALL_MM_INT_ASSIGN_OPS (mm, TYPE ## _, TYPE ## _) \
   OCTAVE_INSTALL_MM_INT_ASSIGN_OPS (mmx, TYPE ## _, ) \
-  INSTALL_WIDENOP (octave_ ## TYPE ## _matrix, octave_complex_matrix, complex_matrix_conv) \
+  INSTALL_WIDENOP (octave_ ## TYPE ## _matrix, octave_complex_matrix, TYPE ## _m_complex_m_conv) \
   INSTALL_ASSIGNCONV (octave_ ## TYPE ## _matrix, octave_complex_matrix, octave_complex_matrix)
 
 #define OCTAVE_INSTALL_MM_INT_OPS2(T1, T2) \
@@ -661,6 +692,18 @@
   INSTALL_ASSIGNCONV (octave_ ## TLHS ## _scalar, octave_ ## TRHS ## _scalar, octave_ ## TLHS ## _matrix) \
   INSTALL_ASSIGNCONV (octave_ ## TLHS ## _scalar, octave_ ## TRHS ## _matrix, octave_ ## TLHS ## _matrix)
 
+#define OCTAVE_MIXED_INT_CMP_OPS(T1, T2) \
+  OCTAVE_SS_INT_CMP_OPS (T1 ## _ ## T2 ## _ss, T1 ## _, T2 ## _) \
+  OCTAVE_SM_INT_CMP_OPS (T1 ## _ ## T2 ## _sm, T1 ## _, T2 ## _) \
+  OCTAVE_MS_INT_CMP_OPS (T1 ## _ ## T2 ## _ms, T1 ## _, T2 ## _) \
+  OCTAVE_MM_INT_CMP_OPS (T1 ## _ ## T2 ## _mm, T1 ## _, T2 ## _)
+
+#define OCTAVE_INSTALL_MIXED_INT_CMP_OPS(T1, T2) \
+  OCTAVE_INSTALL_SS_INT_CMP_OPS (T1 ## _ ## T2 ## _ss, T1 ## _, T2 ## _) \
+  OCTAVE_INSTALL_SM_INT_CMP_OPS (T1 ## _ ## T2 ## _sm, T1 ## _, T2 ## _) \
+  OCTAVE_INSTALL_MS_INT_CMP_OPS (T1 ## _ ## T2 ## _ms, T1 ## _, T2 ## _) \
+  OCTAVE_INSTALL_MM_INT_CMP_OPS (T1 ## _ ## T2 ## _mm, T1 ## _, T2 ## _)
+
 /*
 ;;; Local Variables: ***
 ;;; mode: C++ ***
--- a/src/OPERATORS/op-ui16-ui16.cc	Fri Sep 03 15:43:30 2004 +0000
+++ b/src/OPERATORS/op-ui16-ui16.cc	Sat Sep 04 01:16:28 2004 +0000
@@ -28,6 +28,39 @@
 #include <config.h>
 #endif
 
+#include "mx-ui16nda-i8.h"
+#include "mx-ui16nda-ui8.h"
+#include "mx-ui16nda-i16.h"
+#include "mx-ui16nda-i32.h"
+#include "mx-ui16nda-ui32.h"
+#include "mx-ui16nda-i64.h"
+#include "mx-ui16nda-ui64.h"
+
+#include "mx-ui16nda-i8nda.h"
+#include "mx-ui16nda-ui8nda.h"
+#include "mx-ui16nda-i16nda.h"
+#include "mx-ui16nda-i32nda.h"
+#include "mx-ui16nda-ui32nda.h"
+#include "mx-ui16nda-i64nda.h"
+#include "mx-ui16nda-ui64nda.h"
+
+#include "mx-ui16-i8nda.h"
+#include "mx-ui16-ui8nda.h"
+#include "mx-ui16-i16nda.h"
+#include "mx-ui16-i32nda.h"
+#include "mx-ui16-ui32nda.h"
+#include "mx-ui16-i64nda.h"
+#include "mx-ui16-ui64nda.h"
+
+#include "mx-ui16nda-s.h"
+#include "mx-s-ui16nda.h"
+
+#include "mx-ui16nda-nda.h"
+#include "mx-nda-ui16nda.h"
+
+#include "mx-ui16-nda.h"
+#include "mx-nda-ui16.h"
+
 #include "gripes.h"
 #include "oct-obj.h"
 #include "ov.h"
@@ -68,6 +101,14 @@
 OCTAVE_MM_INT_ASSIGN_OPS (mmi64, uint16_, int64_, int64_)
 OCTAVE_MM_INT_ASSIGN_OPS (mmui64, uint16_, uint64_, uint64_)
 
+OCTAVE_MIXED_INT_CMP_OPS (uint16, int8)
+OCTAVE_MIXED_INT_CMP_OPS (uint16, uint8)
+OCTAVE_MIXED_INT_CMP_OPS (uint16, int16)
+OCTAVE_MIXED_INT_CMP_OPS (uint16, int32)
+OCTAVE_MIXED_INT_CMP_OPS (uint16, uint32)
+OCTAVE_MIXED_INT_CMP_OPS (uint16, int64)
+OCTAVE_MIXED_INT_CMP_OPS (uint16, uint64)
+
 void
 install_ui16_ui16_ops (void)
 {
@@ -96,6 +137,14 @@
   OCTAVE_INSTALL_SM_INT_ASSIGNCONV (uint16, uint32);
   OCTAVE_INSTALL_SM_INT_ASSIGNCONV (uint16, int64);
   OCTAVE_INSTALL_SM_INT_ASSIGNCONV (uint16, uint64);
+
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (uint16, int8);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (uint16, uint8);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (uint16, int16);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (uint16, int32);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (uint16, uint32);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (uint16, int64);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (uint16, uint64);
 }
 
 /*
--- a/src/OPERATORS/op-ui32-ui32.cc	Fri Sep 03 15:43:30 2004 +0000
+++ b/src/OPERATORS/op-ui32-ui32.cc	Sat Sep 04 01:16:28 2004 +0000
@@ -28,6 +28,39 @@
 #include <config.h>
 #endif
 
+#include "mx-ui32nda-i8.h"
+#include "mx-ui32nda-ui8.h"
+#include "mx-ui32nda-i16.h"
+#include "mx-ui32nda-ui16.h"
+#include "mx-ui32nda-i32.h"
+#include "mx-ui32nda-i64.h"
+#include "mx-ui32nda-ui64.h"
+
+#include "mx-ui32nda-i8nda.h"
+#include "mx-ui32nda-ui8nda.h"
+#include "mx-ui32nda-i16nda.h"
+#include "mx-ui32nda-ui16nda.h"
+#include "mx-ui32nda-i32nda.h"
+#include "mx-ui32nda-i64nda.h"
+#include "mx-ui32nda-ui64nda.h"
+
+#include "mx-ui32-i8nda.h"
+#include "mx-ui32-ui8nda.h"
+#include "mx-ui32-i16nda.h"
+#include "mx-ui32-ui16nda.h"
+#include "mx-ui32-i32nda.h"
+#include "mx-ui32-i64nda.h"
+#include "mx-ui32-ui64nda.h"
+
+#include "mx-ui32nda-s.h"
+#include "mx-s-ui32nda.h"
+
+#include "mx-ui32nda-nda.h"
+#include "mx-nda-ui32nda.h"
+
+#include "mx-ui32-nda.h"
+#include "mx-nda-ui32.h"
+
 #include "gripes.h"
 #include "oct-obj.h"
 #include "ov.h"
@@ -68,6 +101,13 @@
 OCTAVE_MM_INT_ASSIGN_OPS (mmi64, uint32_, int64_, int64_)
 OCTAVE_MM_INT_ASSIGN_OPS (mmui64, uint32_, uint64_, uint64_)
 
+OCTAVE_MIXED_INT_CMP_OPS (uint32, int8)
+OCTAVE_MIXED_INT_CMP_OPS (uint32, uint8)
+OCTAVE_MIXED_INT_CMP_OPS (uint32, int16)
+OCTAVE_MIXED_INT_CMP_OPS (uint32, uint16)
+OCTAVE_MIXED_INT_CMP_OPS (uint32, int32)
+OCTAVE_MIXED_INT_CMP_OPS (uint32, int64)
+OCTAVE_MIXED_INT_CMP_OPS (uint32, uint64)
 void
 install_ui32_ui32_ops (void)
 {
@@ -96,6 +136,14 @@
   OCTAVE_INSTALL_SM_INT_ASSIGNCONV (uint32, int32);
   OCTAVE_INSTALL_SM_INT_ASSIGNCONV (uint32, int64);
   OCTAVE_INSTALL_SM_INT_ASSIGNCONV (uint32, uint64);
+
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (uint32, int8);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (uint32, uint8);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (uint32, int16);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (uint32, uint16);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (uint32, int32);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (uint32, int64);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (uint32, uint64);
 }
 
 /*
--- a/src/OPERATORS/op-ui64-ui64.cc	Fri Sep 03 15:43:30 2004 +0000
+++ b/src/OPERATORS/op-ui64-ui64.cc	Sat Sep 04 01:16:28 2004 +0000
@@ -28,6 +28,39 @@
 #include <config.h>
 #endif
 
+#include "mx-ui64nda-i8.h"
+#include "mx-ui64nda-ui8.h"
+#include "mx-ui64nda-i16.h"
+#include "mx-ui64nda-ui16.h"
+#include "mx-ui64nda-i32.h"
+#include "mx-ui64nda-ui32.h"
+#include "mx-ui64nda-i64.h"
+
+#include "mx-ui64nda-i8nda.h"
+#include "mx-ui64nda-ui8nda.h"
+#include "mx-ui64nda-i16nda.h"
+#include "mx-ui64nda-ui16nda.h"
+#include "mx-ui64nda-i32nda.h"
+#include "mx-ui64nda-ui32nda.h"
+#include "mx-ui64nda-i64nda.h"
+
+#include "mx-ui64-i8nda.h"
+#include "mx-ui64-ui8nda.h"
+#include "mx-ui64-i16nda.h"
+#include "mx-ui64-ui16nda.h"
+#include "mx-ui64-i32nda.h"
+#include "mx-ui64-ui32nda.h"
+#include "mx-ui64-i64nda.h"
+
+#include "mx-ui64nda-s.h"
+#include "mx-s-ui64nda.h"
+
+#include "mx-ui64nda-nda.h"
+#include "mx-nda-ui64nda.h"
+
+#include "mx-ui64-nda.h"
+#include "mx-nda-ui64.h"
+
 #include "gripes.h"
 #include "oct-obj.h"
 #include "ov.h"
@@ -64,8 +97,8 @@
 OCTAVE_MS_INT_ASSIGN_OPS (mc, uint64_, complex_, )
 
 OCTAVE_M_INT_UNOPS (uint64)
-OCTAVE_MM_INT_CMP_OPS (uint64, uint64)
-OCTAVE_MM_INT_BOOL_OPS (uint64, uint64)
+OCTAVE_MM_INT_CMP_OPS (mm, uint64_, uint64_)
+OCTAVE_MM_INT_BOOL_OPS (mm, uint64_, uint64_)
 OCTAVE_MM_INT_ASSIGN_OPS (mm, uint64_, uint64_, uint64_)
 OCTAVE_MM_INT_ASSIGN_OPS (mmx, uint64_, , )
 OCTAVE_MM_INT_ASSIGN_OPS (mmc, uint64_, complex_, )
@@ -86,6 +119,14 @@
 OCTAVE_MM_INT_ASSIGN_OPS (mmui32, uint64_, uint32_, uint32_)
 OCTAVE_MM_INT_ASSIGN_OPS (mmi64, uint64_, int64_, int64_)
 
+OCTAVE_MIXED_INT_CMP_OPS (uint64, int8)
+OCTAVE_MIXED_INT_CMP_OPS (uint64, uint8)
+OCTAVE_MIXED_INT_CMP_OPS (uint64, int16)
+OCTAVE_MIXED_INT_CMP_OPS (uint64, uint16)
+OCTAVE_MIXED_INT_CMP_OPS (uint64, int32)
+OCTAVE_MIXED_INT_CMP_OPS (uint64, uint32)
+OCTAVE_MIXED_INT_CMP_OPS (uint64, int64)
+
 void
 install_ui64_ui64_ops (void)
 {
@@ -103,8 +144,8 @@
   OCTAVE_INSTALL_MS_INT_ASSIGN_OPS (mc, uint64_, complex_);
 
   OCTAVE_INSTALL_M_INT_UNOPS (uint64);
-  OCTAVE_INSTALL_MM_INT_CMP_OPS (uint64, uint64);
-  OCTAVE_INSTALL_MM_INT_BOOL_OPS (uint64, uint64);
+  OCTAVE_INSTALL_MM_INT_CMP_OPS (mm, uint64_, uint64_);
+  OCTAVE_INSTALL_MM_INT_BOOL_OPS (mm, uint64_, uint64_);
   OCTAVE_INSTALL_MM_INT_ASSIGN_OPS (mm, uint64_, uint64_);
   OCTAVE_INSTALL_MM_INT_ASSIGN_OPS (mmx, uint64_, );
   OCTAVE_INSTALL_MM_INT_ASSIGN_OPS (mmc, uint64_, complex_);
@@ -132,6 +173,14 @@
   OCTAVE_INSTALL_SM_INT_ASSIGNCONV (uint64, int32);
   OCTAVE_INSTALL_SM_INT_ASSIGNCONV (uint64, uint32);
   OCTAVE_INSTALL_SM_INT_ASSIGNCONV (uint64, int64);
+
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (uint64, int8);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (uint64, uint8);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (uint64, int16);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (uint64, uint16);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (uint64, int32);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (uint64, uint32);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (uint64, int64);
 }
 
 /*
--- a/src/OPERATORS/op-ui8-ui8.cc	Fri Sep 03 15:43:30 2004 +0000
+++ b/src/OPERATORS/op-ui8-ui8.cc	Sat Sep 04 01:16:28 2004 +0000
@@ -28,6 +28,39 @@
 #include <config.h>
 #endif
 
+#include "mx-ui8nda-i8.h"
+#include "mx-ui8nda-i16.h"
+#include "mx-ui8nda-ui16.h"
+#include "mx-ui8nda-i32.h"
+#include "mx-ui8nda-ui32.h"
+#include "mx-ui8nda-i64.h"
+#include "mx-ui8nda-ui64.h"
+
+#include "mx-ui8nda-i8nda.h"
+#include "mx-ui8nda-i16nda.h"
+#include "mx-ui8nda-ui16nda.h"
+#include "mx-ui8nda-i32nda.h"
+#include "mx-ui8nda-ui32nda.h"
+#include "mx-ui8nda-i64nda.h"
+#include "mx-ui8nda-ui64nda.h"
+
+#include "mx-ui8-i8nda.h"
+#include "mx-ui8-i16nda.h"
+#include "mx-ui8-ui16nda.h"
+#include "mx-ui8-i32nda.h"
+#include "mx-ui8-ui32nda.h"
+#include "mx-ui8-i64nda.h"
+#include "mx-ui8-ui64nda.h"
+
+#include "mx-ui8nda-s.h"
+#include "mx-s-ui8nda.h"
+
+#include "mx-ui8nda-nda.h"
+#include "mx-nda-ui8nda.h"
+
+#include "mx-ui8-nda.h"
+#include "mx-nda-ui8.h"
+
 #include "gripes.h"
 #include "oct-obj.h"
 #include "ov.h"
@@ -68,6 +101,14 @@
 OCTAVE_MM_INT_ASSIGN_OPS (mmi64, uint8_, int64_, int64_)
 OCTAVE_MM_INT_ASSIGN_OPS (mmui64, uint8_, uint64_, uint64_)
 
+OCTAVE_MIXED_INT_CMP_OPS (uint8, int8)
+OCTAVE_MIXED_INT_CMP_OPS (uint8, int16)
+OCTAVE_MIXED_INT_CMP_OPS (uint8, uint16)
+OCTAVE_MIXED_INT_CMP_OPS (uint8, int32)
+OCTAVE_MIXED_INT_CMP_OPS (uint8, uint32)
+OCTAVE_MIXED_INT_CMP_OPS (uint8, int64)
+OCTAVE_MIXED_INT_CMP_OPS (uint8, uint64)
+
 void
 install_ui8_ui8_ops (void)
 {
@@ -96,6 +137,14 @@
   OCTAVE_INSTALL_SM_INT_ASSIGNCONV (uint8, uint32);
   OCTAVE_INSTALL_SM_INT_ASSIGNCONV (uint8, int64);
   OCTAVE_INSTALL_SM_INT_ASSIGNCONV (uint8, uint64);
+
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (uint8, int8);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (uint8, int16);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (uint8, uint16);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (uint8, int32);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (uint8, uint32);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (uint8, int64);
+  OCTAVE_INSTALL_MIXED_INT_CMP_OPS (uint8, uint64);
 }
 
 /*
--- a/src/ov-bool.cc	Fri Sep 03 15:43:30 2004 +0000
+++ b/src/ov-bool.cc	Sat Sep 04 01:16:28 2004 +0000
@@ -36,6 +36,7 @@
 #include "oct-obj.h"
 #include "ops.h"
 #include "ov-bool.h"
+#include "ov-bool-mat.h"
 #include "ov-base.h"
 #include "ov-base-scalar.h"
 #include "ov-base-scalar.cc"
@@ -97,7 +98,7 @@
       // 1x1 matrix back to a scalar value.  Need a better solution
       // to this problem.
 
-      octave_value tmp (new octave_matrix (matrix_value ()));
+      octave_value tmp (new octave_bool_matrix (bool_matrix_value ()));
 
       retval = tmp.do_index_op (idx, resize_ok);
     }
--- a/src/ov-intx.h	Fri Sep 03 15:43:30 2004 +0000
+++ b/src/ov-intx.h	Sat Sep 04 01:16:28 2004 +0000
@@ -118,6 +118,32 @@
   empty_clone (void) const
     { return new OCTAVE_VALUE_INT_SCALAR_T (); }
 
+  octave_value do_index_op (const octave_value_list& idx, int resize_ok)
+  {
+    octave_value retval;
+
+    if (idx.valid_scalar_indices ())
+      retval = scalar;
+    else
+      {
+	// XXX FIXME XXX -- this doesn't solve the problem of
+	//
+	//   a = 1; a([1,1], [1,1], [1,1])
+	//
+	// and similar constructions.  Hmm...
+
+	// XXX FIXME XXX -- using this constructor avoids narrowing the
+	// 1x1 matrix back to a scalar value.  Need a better solution
+	// to this problem.
+
+	octave_value tmp (new OCTAVE_VALUE_INT_MATRIX_T (
+			     OCTAVE_VALUE_INT_NDARRAY_EXTRACTOR_FUNCTION ())); 
+	retval = tmp.do_index_op (idx, resize_ok);
+      }
+
+    return retval;
+  }
+
   OCTAVE_INT_T
   OCTAVE_VALUE_INT_SCALAR_EXTRACTOR_FUNCTION (void) const
     { return scalar; }