--- a/liboctave/CColVector.cc
+++ b/liboctave/CColVector.cc
@@ -270,50 +270,6 @@
   return *this;
 }
 
-ComplexColumnVector&
-ComplexColumnVector::operator += (const ComplexColumnVector& a)
-{
-  int len = length ();
-
-  int a_len = a.length ();
-
-  if (len != a_len)
-    {
-      gripe_nonconformant ("operator +=", len, a_len);
-      return *this;
-    }
-
-  if (len == 0)
-    return *this;
-
-  Complex *d = fortran_vec (); // Ensures only one reference to my privates!
-
-  add2 (d, a.data (), len);
-  return *this;
-}
-
-ComplexColumnVector&
-ComplexColumnVector::operator -= (const ComplexColumnVector& a)
-{
-  int len = length ();
-
-  int a_len = a.length ();
-
-  if (len != a_len)
-    {
-      gripe_nonconformant ("operator -=", len, a_len);
-      return *this;
-    }
-
-  if (len == 0)
-    return *this;
-
-  Complex *d = fortran_vec (); // Ensures only one reference to my privates!
-
-  subtract2 (d, a.data (), len);
-  return *this;
-}
-
 // column vector by scalar -> column vector operations
 
 ComplexColumnVector

--- a/liboctave/CColVector.h
+++ b/liboctave/CColVector.h
@@ -81,9 +81,6 @@
   ComplexColumnVector& operator += (const ColumnVector& a);
   ComplexColumnVector& operator -= (const ColumnVector& a);
 
-  ComplexColumnVector& operator += (const ComplexColumnVector& a);
-  ComplexColumnVector& operator -= (const ComplexColumnVector& a);
-
   // column vector by scalar -> column vector operations
 
   friend ComplexColumnVector operator + (const ComplexColumnVector& a,
@@ -190,6 +187,8 @@
   ComplexColumnVector (Complex *d, int l) : MArray<Complex> (d, l) { }
 };
 
+MARRAY_FORWARD_DEFS (MArray, ComplexColumnVector, Complex)
+
 #endif
 
 /*

--- a/liboctave/CMatrix.h
+++ b/liboctave/CMatrix.h
@@ -271,6 +271,8 @@
 MM_CMP_OP_DECLS (ComplexMatrix, ComplexMatrix)
 MM_BOOL_OP_DECLS (ComplexMatrix, ComplexMatrix)
 
+MARRAY_FORWARD_DEFS (MArray2, ComplexMatrix, Complex)
+
 #endif
 
 /*

--- a/liboctave/CRowVector.cc
+++ b/liboctave/CRowVector.cc
@@ -270,50 +270,6 @@
   return *this;
 }
 
-ComplexRowVector&
-ComplexRowVector::operator += (const ComplexRowVector& a)
-{
-  int len = length ();
-
-  int a_len = a.length ();
-
-  if (len != a_len)
-    {
-      gripe_nonconformant ("operator +=", len, a_len);
-      return *this;
-    }
-
-  if (len == 0)
-    return *this;
-
-  Complex *d = fortran_vec (); // Ensures only one reference to my privates!
-
-  add2 (d, a.data (), len);
-  return *this;
-}
-
-ComplexRowVector&
-ComplexRowVector::operator -= (const ComplexRowVector& a)
-{
-  int len = length ();
-
-  int a_len = a.length ();
-
-  if (len != a_len)
-    {
-      gripe_nonconformant ("operator -=", len, a_len);
-      return *this;
-    }
-
-  if (len == 0)
-    return *this;
-
-  Complex *d = fortran_vec (); // Ensures only one reference to my privates!
-
-  subtract2 (d, a.data (), len);
-  return *this;
-}
-
 // row vector by scalar -> row vector operations
 
 ComplexRowVector

--- a/liboctave/CRowVector.h
+++ b/liboctave/CRowVector.h
@@ -80,9 +80,6 @@
   ComplexRowVector& operator += (const RowVector& a);
   ComplexRowVector& operator -= (const RowVector& a);
 
-  ComplexRowVector& operator += (const ComplexRowVector& a);
-  ComplexRowVector& operator -= (const ComplexRowVector& a);
-
   // row vector by scalar -> row vector operations
 
   friend ComplexRowVector operator + (const ComplexRowVector& a, double s);
@@ -167,6 +164,8 @@
 
 ComplexRowVector linspace (const Complex& x1, const Complex& x2, int n);
 
+MARRAY_FORWARD_DEFS (MArray, ComplexRowVector, Complex)
+
 #endif
 
 /*

--- a/liboctave/ChangeLog
+++ b/liboctave/ChangeLog
@@ -1,3 +1,8 @@
+2000-02-04  John W. Eaton  <jwe@bevo.che.wisc.edu>
+
+	* dColVector.h, dRowVector.h, CColVector.h, CRowVector.h:
+	Use MARRAY_FORWARD_DEFS here.
+
 2000-02-03  John W. Eaton  <jwe@bevo.che.wisc.edu>
 
 	* dMatrix.cc (Matrix::ifourier): Cast divisor to double.

--- a/liboctave/MArray-defs.h
+++ b/liboctave/MArray-defs.h
@@ -49,3 +49,193 @@
     } \
   while (0)
 
+// A macro that can be used to declare and instantiate OP= operators.
+#define MARRAY_OP_ASSIGN_DECL(A_T, E_T, OP, PFX, LTGT, RHS_T) \
+  PFX A_T<E_T>& \
+  operator OP LTGT (A_T<E_T>&, const RHS_T&)
+
+// All the OP= operators that we care about.
+#define MARRAY_OP_ASSIGN_DECLS(A_T, E_T, PFX, LTGT, RHS_T) \
+  MARRAY_OP_ASSIGN_DECL (A_T, E_T, +=, PFX, LTGT, RHS_T); \
+  MARRAY_OP_ASSIGN_DECL (A_T, E_T, -=, PFX, LTGT, RHS_T);
+
+// Generate forward declarations for OP= operators.
+#define MARRAY_OP_ASSIGN_FWD_DECLS(A_T) \
+  MARRAY_OP_ASSIGN_DECLS (A_T, T, template <typename T>, , T) \
+  MARRAY_OP_ASSIGN_DECLS (A_T, T, template <typename T>, , A_T<T>) \
+
+// Generate friend declarations for the OP= operators.
+#define MARRAY_OP_ASSIGN_FRIENDS(A_T) \
+  MARRAY_OP_ASSIGN_DECLS (A_T, T, friend, <>, T) \
+  MARRAY_OP_ASSIGN_DECLS (A_T, T, friend, <>, A_T<T>)
+
+// Instantiate the OP= operators.
+#define MARRAY_OP_ASSIGN_DEFS(A_T, E_T) \
+  MARRAY_OP_ASSIGN_DECLS (A_T, E_T, template, , T) \
+  MARRAY_OP_ASSIGN_DECLS (A_T, E_T, template, , A_T<E_T>)
+
+// A function that can be used to forward OP= operations from derived
+// classes back to us.
+#define MARRAY_OP_ASSIGN_FWD_FCN(R, F, T, C_X, X_T, C_Y, Y_T) \
+  inline R \
+  F (X_T& x, const Y_T& y) \
+  { \
+    return R (F (C_X (x), C_Y (y))); \
+  }
+
+// All the OP= operators that we care about forwarding.
+#define MARRAY_OP_ASSIGN_FWD_DEFS(R, T, C_X, X_T, C_Y, Y_T) \
+  MARRAY_OP_ASSIGN_FWD_FCN (R, operator +=, T, C_X, X_T, C_Y, Y_T) \
+  MARRAY_OP_ASSIGN_FWD_FCN (R, operator -=, T, C_X, X_T, C_Y, Y_T)
+
+// A macro that can be used to declare and instantiate unary operators.
+#define MARRAY_UNOP(A_T, E_T, F, PFX, LTGT) \
+  PFX A_T<E_T> \
+  F LTGT (const A_T<E_T>&)
+
+// All the unary operators that we care about.
+#define MARRAY_UNOP_DECLS(A_T, E_T, PFX, LTGT) \
+  MARRAY_UNOP (A_T, E_T, operator +, PFX, LTGT); \
+  MARRAY_UNOP (A_T, E_T, operator -, PFX, LTGT);
+
+// Generate forward declarations for unary operators.
+#define MARRAY_UNOP_FWD_DECLS(A_T) \
+  MARRAY_UNOP_DECLS (A_T, T, template <typename T>, )
+
+// Generate friend declarations for the unary operators.
+#define MARRAY_UNOP_FRIENDS(A_T) \
+  MARRAY_UNOP_DECLS (A_T, T, friend, <>)
+
+// Instantiate the unary operators.
+#define MARRAY_UNOP_DEFS(A_T, E_T) \
+  MARRAY_UNOP_DECLS (A_T, E_T, template, )
+
+// A function that can be used to forward unary operations from derived
+// classes back to us.
+#define MARRAY_UNOP_FWD_FCN(R, F, T, C_X, X_T) \
+  inline R \
+  F (const X_T& x) \
+  { \
+    return R (F (C_X (x))); \
+  }
+
+// All the unary operators that we care about forwarding.
+#define MARRAY_UNOP_FWD_DEFS(R, T, C_X, X_T) \
+  MARRAY_UNOP_FWD_FCN (R, operator +, T, C_X, X_T) \
+  MARRAY_UNOP_FWD_FCN (R, operator -, T, C_X, X_T)
+
+// A macro that can be used to declare and instantiate binary operators.
+#define MARRAY_BINOP_DECL(A_T, E_T, F, PFX, LTGT, X_T, Y_T) \
+  PFX A_T<E_T> \
+  F LTGT (const X_T&, const Y_T&)
+
+// All the binary operators that we care about.  We have two
+// sets of macros since the MArray OP MArray operations use functions
+// (product and quotient) instead of operators (*, /).
+#define MARRAY_BINOP_DECLS(A_T, E_T, PFX, LTGT, X_T, Y_T) \
+  MARRAY_BINOP_DECL (A_T, E_T, operator +, PFX, LTGT, X_T, Y_T); \
+  MARRAY_BINOP_DECL (A_T, E_T, operator -, PFX, LTGT, X_T, Y_T); \
+  MARRAY_BINOP_DECL (A_T, E_T, operator *, PFX, LTGT, X_T, Y_T); \
+  MARRAY_BINOP_DECL (A_T, E_T, operator /, PFX, LTGT, X_T, Y_T);
+
+#define MARRAY_AA_BINOP_DECLS(A_T, E_T, PFX, LTGT) \
+  MARRAY_BINOP_DECL (A_T, E_T, operator +, PFX, LTGT, A_T<E_T>, A_T<E_T>); \
+  MARRAY_BINOP_DECL (A_T, E_T, operator -, PFX, LTGT, A_T<E_T>, A_T<E_T>); \
+  MARRAY_BINOP_DECL (A_T, E_T, quotient,   PFX, LTGT, A_T<E_T>, A_T<E_T>); \
+  MARRAY_BINOP_DECL (A_T, E_T, product,    PFX, LTGT, A_T<E_T>, A_T<E_T>);
+
+// Generate forward declarations for binary operators.
+#define MARRAY_BINOP_FWD_DECLS(A_T) \
+  MARRAY_BINOP_DECLS (A_T, T, template <typename T>, , A_T<T>, T) \
+  MARRAY_BINOP_DECLS (A_T, T, template <typename T>, , T, A_T<T>) \
+  MARRAY_AA_BINOP_DECLS (A_T, T, template <typename T>, )
+
+// Generate friend declarations for the binary operators.
+#define MARRAY_BINOP_FRIENDS(A_T) \
+  MARRAY_BINOP_DECLS (A_T, T, friend, <>, A_T<T>, T) \
+  MARRAY_BINOP_DECLS (A_T, T, friend, <>, T, A_T<T>) \
+  MARRAY_AA_BINOP_DECLS (A_T, T, friend, <>)
+
+// Instantiate the binary operators.
+#define MARRAY_BINOP_DEFS(A_T, E_T) \
+  MARRAY_BINOP_DECLS (A_T, E_T, template, , A_T<E_T>, E_T) \
+  MARRAY_BINOP_DECLS (A_T, E_T, template, , E_T, A_T<E_T>) \
+  MARRAY_AA_BINOP_DECLS (A_T, E_T, template, )
+
+// A function that can be used to forward binary operations from derived
+// classes back to us.
+#define MARRAY_BINOP_FWD_FCN(R, F, T, C_X, X_T, C_Y, Y_T) \
+  inline R \
+  F (const X_T& x, const Y_T& y) \
+  { \
+    return R (F (C_X (x), C_Y (y))); \
+  }
+
+// The binary operators that we care about forwarding.  We have two
+// sets of macros since the MArray OP MArray operations use functions
+// (product and quotient) instead of operators (*, /).
+#define MARRAY_BINOP_FWD_DEFS(R, T, C_X, X_T, C_Y, Y_T) \
+  MARRAY_BINOP_FWD_FCN (R, operator +, T, C_X, X_T, C_Y, Y_T) \
+  MARRAY_BINOP_FWD_FCN (R, operator -, T, C_X, X_T, C_Y, Y_T) \
+  MARRAY_BINOP_FWD_FCN (R, operator *, T, C_X, X_T, C_Y, Y_T) \
+  MARRAY_BINOP_FWD_FCN (R, operator /, T, C_X, X_T, C_Y, Y_T)
+
+#define MARRAY_AA_BINOP_FWD_DEFS(R, T, C_X, X_T, C_Y, Y_T) \
+  MARRAY_BINOP_FWD_FCN (R, operator +, T, C_X, X_T, C_Y, Y_T) \
+  MARRAY_BINOP_FWD_FCN (R, operator -, T, C_X, X_T, C_Y, Y_T) \
+  MARRAY_BINOP_FWD_FCN (R, product,    T, C_X, X_T, C_Y, Y_T) \
+  MARRAY_BINOP_FWD_FCN (R, quotient,   T, C_X, X_T, C_Y, Y_T)
+
+// Forward declarations for the MArray operators.
+#define MARRAY_OPS_FORWARD_DECLS(A_T) \
+  template <class T> \
+  class A_T; \
+ \
+  MARRAY_OP_ASSIGN_FWD_DECLS (A_T) \
+  MARRAY_UNOP_FWD_DECLS (A_T) \
+  MARRAY_BINOP_FWD_DECLS (A_T)
+
+// Friend declarations for the MArray operators.
+#define MARRAY_OPS_FRIEND_DECLS(A_T) \
+  MARRAY_OP_ASSIGN_FRIENDS (A_T) \
+  MARRAY_UNOP_FRIENDS (A_T) \
+  MARRAY_BINOP_FRIENDS (A_T)
+
+// The following macros are for external use.
+
+// Instantiate all the MArray friends for MArray element type T.
+#define INSTANTIATE_MARRAY_FRIENDS(T) \
+  MARRAY_OP_ASSIGN_DEFS (MArray, T) \
+  MARRAY_UNOP_DEFS (MArray, T) \
+  MARRAY_BINOP_DEFS (MArray, T)
+
+// Instantiate all the MArray friends for MArray element type T.
+#define INSTANTIATE_MARRAY2_FRIENDS(T) \
+  MARRAY_OP_ASSIGN_DEFS (MArray2, T) \
+  MARRAY_UNOP_DEFS (MArray2, T) \
+  MARRAY_BINOP_DEFS (MArray2, T)
+
+// Define all the MArray forwarding functions for return type R and
+// MArray element type T
+#define MARRAY_FORWARD_DEFS(B, R, T) \
+  MARRAY_OP_ASSIGN_FWD_DEFS \
+    (R, T, dynamic_cast<B<T>&>, R, , T) \
+ \
+  MARRAY_OP_ASSIGN_FWD_DEFS \
+    (R, T, \
+     dynamic_cast<B<T>&>, R, dynamic_cast<const B<T>&>, R) \
+ \
+  MARRAY_UNOP_FWD_DEFS \
+    (R, T, dynamic_cast<const B<T>&>, R) \
+ \
+  MARRAY_BINOP_FWD_DEFS \
+    (R, T, dynamic_cast<const B<T>&>, R, , T) \
+ \
+  MARRAY_BINOP_FWD_DEFS \
+    (R, T, , T, dynamic_cast<const B<T>&>, R) \
+ \
+  MARRAY_AA_BINOP_FWD_DEFS \
+    (R, T, dynamic_cast<const B<T>&>, R, dynamic_cast<const B<T>&>, R)
+
+// Now we have all the definitions we need.
+

--- a/liboctave/MArray.cc
+++ b/liboctave/MArray.cc
@@ -170,6 +170,13 @@
   return result;
 }
 
+template <class T>
+MArray<T>
+operator + (const MArray<T>& a)
+{
+  return a;
+}
+
 /*
 ;;; Local Variables: ***
 ;;; mode: C++ ***

--- a/liboctave/MArray.h
+++ b/liboctave/MArray.h
@@ -30,72 +30,13 @@
 
 #include "Array.h"
 
-#if defined (LTGT)
-#undef LTGT
-#endif
-
-#if !defined (CXX_NEW_FRIEND_TEMPLATE_DECL)
-#define LTGT
-#else
-
-#define LTGT <>
-
-template <class T> 
-class MArray;
+// One dimensional array with math ops.
 
-template <typename T> MArray<T>& 
-operator += (MArray<T>& a, const T& s);
-
-template <typename T> MArray<T>& 
-operator -= (MArray<T>& a, const T& s);
-
-template <typename T> MArray<T>& 
-operator += (MArray<T>& a, const MArray<T>& b);
-
-template <typename T> MArray<T>& 
-operator -= (MArray<T>& a, const MArray<T>& b);
-
-template <typename T> MArray<T> 
-operator + (const MArray<T>& a, const T& s);
-
-template <typename T> MArray<T> 
-operator - (const MArray<T>& a, const T& s);
+// But first, some preprocessor abuse...
 
-template <typename T> MArray<T> 
-operator * (const MArray<T>& a, const T& s);
-
-template <typename T> MArray<T> 
-operator / (const MArray<T>& a, const T& s);
-
-template <typename T> MArray<T> 
-operator + (const T& s, const MArray<T>& a);
-
-template <typename T> MArray<T> 
-operator - (const T& s, const MArray<T>& a);
-
-template <typename T> MArray<T> 
-operator * (const T& s, const MArray<T>& a);
-
-template <typename T> MArray<T> 
-operator / (const T& s, const MArray<T>& a);
+#include "MArray-defs.h"
 
-template <typename T> MArray<T> 
-operator + (const MArray<T>& a, const MArray<T>& b);
-
-template <typename T> MArray<T> 
-operator - (const MArray<T>& a, const MArray<T>& b);
-
-template <class T> MArray<T> 
-product (const MArray<T>& a, const MArray<T>& b);
-
-template <typename T> MArray<T> 
-quotient (const MArray<T>& a, const MArray<T>& b);
-
-template <typename T> MArray<T> 
-operator - (const MArray<T>& a);
-#endif
-
-// One dimensional array with math ops.
+MARRAY_OPS_FORWARD_DECLS (MArray)
 
 template <class T>
 class MArray : public Array<T>
@@ -119,32 +60,17 @@
       Array<T>::operator = (a);
       return *this;
     }
+
+  // Currently, the OPS functions don't need to be friends, but that
+  // may change.
+
+  MARRAY_OPS_FRIEND_DECLS (MArray)
 };
 
-#undef LTGT
-
+// XXX FIXME XXX -- there must be a better place for this...
 extern void
 gripe_nonconformant (const char *op, int op1_len, int op2_len);
 
-#define INSTANTIATE_MARRAY_FRIENDS(T) \
-  template MArray<T>& operator += (MArray<T>& a, const T& s); \
-  template MArray<T>& operator -= (MArray<T>& a, const T& s); \
-  template MArray<T>& operator += (MArray<T>& a, const MArray<T>& b); \
-  template MArray<T>& operator -= (MArray<T>& a, const MArray<T>& b); \
-  template MArray<T> operator + (const MArray<T>& a, const T& s); \
-  template MArray<T> operator - (const MArray<T>& a, const T& s); \
-  template MArray<T> operator * (const MArray<T>& a, const T& s); \
-  template MArray<T> operator / (const MArray<T>& a, const T& s); \
-  template MArray<T> operator + (const T& s, const MArray<T>& a); \
-  template MArray<T> operator - (const T& s, const MArray<T>& a); \
-  template MArray<T> operator * (const T& s, const MArray<T>& a); \
-  template MArray<T> operator / (const T& s, const MArray<T>& a); \
-  template MArray<T> operator + (const MArray<T>& a, const MArray<T>& b); \
-  template MArray<T> operator - (const MArray<T>& a, const MArray<T>& b); \
-  template MArray<T> product (const MArray<T>& a, const MArray<T>& b); \
-  template MArray<T> quotient (const MArray<T>& a, const MArray<T>& b); \
-  template MArray<T> operator - (const MArray<T>& a);
-
 #endif
 
 /*

--- a/liboctave/MArray2.h
+++ b/liboctave/MArray2.h
@@ -30,72 +30,13 @@
 
 #include "Array2.h"
 
-#if defined (LTGT)
-#undef LTGT
-#endif
-
-#if !defined (CXX_NEW_FRIEND_TEMPLATE_DECL)
-#define LTGT
-#else
-
-#define LTGT <>
-
-template <class T>
-class MArray2;
+// Two dimensional array with math ops.
 
-template <typename T> MArray2<T>& 
-operator += (MArray2<T>& a, const T& s);
-
-template <typename T> MArray2<T>& 
-operator -= (MArray2<T>& a, const T& s);
-
-template <typename T> MArray2<T>& 
-operator += (MArray2<T>& a, const MArray2<T>& b);
-
-template <typename T> MArray2<T>& 
-operator -= (MArray2<T>& a, const MArray2<T>& b);
-
-template <typename T> MArray2<T> 
-operator + (const MArray2<T>& a, const T& s);
-
-template <typename T> MArray2<T> 
-operator - (const MArray2<T>& a, const T& s);
+// But first, some preprocessor abuse...
 
-template <typename T> MArray2<T> 
-operator * (const MArray2<T>& a, const T& s);
-
-template <typename T> MArray2<T> 
-operator / (const MArray2<T>& a, const T& s);
-
-template <typename T> MArray2<T> 
-operator + (const T& s, const MArray2<T>& a);
-
-template <typename T> MArray2<T> 
-operator - (const T& s, const MArray2<T>& a);
-
-template <typename T> MArray2<T> 
-operator * (const T& s, const MArray2<T>& a);
-
-template <typename T> MArray2<T> 
-operator / (const T& s, const MArray2<T>& a);
+#include "MArray-defs.h"
 
-template <typename T> MArray2<T> 
-operator + (const MArray2<T>& a, const MArray2<T>& b);
-
-template <typename T> MArray2<T> 
-operator - (const MArray2<T>& a, const MArray2<T>& b);
-
-template <typename T> MArray2<T> 
-product (const MArray2<T>& a, const MArray2<T>& b);
-
-template <typename T> MArray2<T> 
-quotient (const MArray2<T>& a, const MArray2<T>& b);
-
-template <typename T> MArray2<T> 
-operator - (const MArray2<T>& a);
-#endif
-
-// Two dimensional array with math ops.
+MARRAY_OPS_FORWARD_DECLS (MArray2)
 
 template <class T>
 class MArray2 : public Array2<T>
@@ -127,33 +68,17 @@
   }
 
   MArray2<T> transpose (void) const { return Array2<T>::transpose (); }
-};
 
-#undef LTGT
+  // Currently, the OPS functions don't need to be friends, but that
+  // may change.
+
+  MARRAY_OPS_FRIEND_DECLS (MArray2)
+};
 
 extern void
 gripe_nonconformant (const char *op, int op1_nr, int op1_nc,
 		     int op2_nr, int op2_nc);
 
-#define INSTANTIATE_MARRAY2_FRIENDS(T) \
-  template MArray2<T>& operator += (MArray2<T>& a, const T& s); \
-  template MArray2<T>& operator -= (MArray2<T>& a, const T& s); \
-  template MArray2<T>& operator += (MArray2<T>& a, const MArray2<T>& b); \
-  template MArray2<T>& operator -= (MArray2<T>& a, const MArray2<T>& b); \
-  template MArray2<T> operator + (const MArray2<T>& a, const T& s); \
-  template MArray2<T> operator - (const MArray2<T>& a, const T& s); \
-  template MArray2<T> operator * (const MArray2<T>& a, const T& s); \
-  template MArray2<T> operator / (const MArray2<T>& a, const T& s); \
-  template MArray2<T> operator + (const T& s, const MArray2<T>& a); \
-  template MArray2<T> operator - (const T& s, const MArray2<T>& a); \
-  template MArray2<T> operator * (const T& s, const MArray2<T>& a); \
-  template MArray2<T> operator / (const T& s, const MArray2<T>& a); \
-  template MArray2<T> operator + (const MArray2<T>& a, const MArray2<T>& b); \
-  template MArray2<T> operator - (const MArray2<T>& a, const MArray2<T>& b); \
-  template MArray2<T> product (const MArray2<T>& a, const MArray2<T>& b); \
-  template MArray2<T> quotient (const MArray2<T>& a, const MArray2<T>& b); \
-  template MArray2<T> operator - (const MArray2<T>& a);
-
 #endif
 
 /*

--- a/liboctave/dColVector.h
+++ b/liboctave/dColVector.h
@@ -100,6 +100,8 @@
   ColumnVector (double *d, int l) : MArray<double> (d, l) { }
 };
 
+MARRAY_FORWARD_DEFS (MArray, ColumnVector, double)
+
 #endif
 
 /*

--- a/liboctave/dMatrix.cc
+++ b/liboctave/dMatrix.cc
@@ -1462,8 +1462,8 @@
   int minus_one_j = -1;
   for (int j = 7; j >= 0; j--)
     {
-      npp = (m * npp) + (m * padec[j]);
-      dpp = (m * dpp) + (m * (minus_one_j * padec[j]));
+      npp = m * npp + padec[j] * m;
+      dpp = m * dpp + (minus_one_j * padec[j]) * m;
       minus_one_j *= -1;
     }
   

--- a/liboctave/dMatrix.h
+++ b/liboctave/dMatrix.h
@@ -248,6 +248,8 @@
 MM_CMP_OP_DECLS (Matrix, Matrix)
 MM_BOOL_OP_DECLS (Matrix, Matrix)
 
+MARRAY_FORWARD_DEFS (MArray2, Matrix, double)
+
 #endif
 
 /*

--- a/liboctave/dRowVector.h
+++ b/liboctave/dRowVector.h
@@ -106,6 +106,8 @@
 
 RowVector linspace (double x1, double x2, int n);
 
+MARRAY_FORWARD_DEFS (MArray, RowVector, double)
+
 #endif
 
 /*