*** ./liboctave/CNDArray.cc.orig	2004-03-26 18:17:12.000000000 +0100
--- ./liboctave/CNDArray.cc	2004-03-26 20:42:05.000000000 +0100
***************
*** 683,688 ****
--- 683,874 ----
    return ::cat_ra(*this, ra_arg, dim, iidx, move);
  }
  
+ static const Complex Complex_NaN_result (octave_NaN, octave_NaN);
+ 
+ ComplexNDArray
+ ComplexNDArray::max (int dim) const
+ {
+   ArrayN<int> dummy_idx;
+   return max (dummy_idx, dim);
+ }
+ 
+ ComplexNDArray
+ ComplexNDArray::max (ArrayN<int>& idx_arg, int dim) const
+ {
+   dim_vector dv = dims ();
+   dim_vector dr = dims ();
+ 
+   if (dv.numel () == 0 || dim > dv.length () || dim < 0)
+     return ComplexNDArray ();
+   
+   dr(dim) = 1;
+ 
+   ComplexNDArray result (dr);
+   idx_arg.resize (dr);
+ 
+   int x_stride = 1;
+   int x_len = dv(dim);
+   for (int i = 0; i < dim; i++)
+     x_stride *= dv(i);
+ 
+   for (int i = 0; i < dr.numel (); i++)
+     {
+       int x_offset;
+       if (x_stride == 1)
+ 	x_offset = i * x_len;
+       else
+ 	{
+ 	  int x_offset2 = 0;
+ 	  x_offset = i;
+ 	  while (x_offset >= x_stride)
+ 	    {
+ 	      x_offset -= x_stride;
+ 	      x_offset2++;
+ 	    }
+ 	  x_offset += x_offset2 * x_stride * x_len;
+ 	}
+ 
+       int idx_j;
+ 
+       Complex tmp_max;
+ 
+       double abs_max = octave_NaN;
+ 
+       for (idx_j = 0; idx_j < x_len; idx_j++)
+ 	{
+ 	  tmp_max = elem (idx_j * x_stride + x_offset);
+ 	  
+ 	  if (! octave_is_NaN_or_NA (tmp_max))
+ 	    {
+ 	      abs_max = ::abs(tmp_max);
+ 	      break;
+ 	    }
+ 	}
+ 
+       for (int j = idx_j+1; j < x_len; j++)
+ 	{
+ 	  Complex tmp = elem (j * x_stride + x_offset);
+ 
+ 	  if (octave_is_NaN_or_NA (tmp))
+ 	    continue;
+ 
+ 	  double abs_tmp = ::abs (tmp);
+ 
+ 	  if (abs_tmp > abs_max)
+ 	    {
+ 	      idx_j = j;
+ 	      tmp_max = tmp;
+ 	      abs_max = abs_tmp;
+ 	    }
+ 	}
+ 
+       if (octave_is_NaN_or_NA (tmp_max))
+ 	{
+ 	  result.elem (i) = Complex_NaN_result;
+ 	  idx_arg.elem (i) = 0;
+ 	}
+       else
+ 	{
+ 	  result.elem (i) = tmp_max;
+ 	  idx_arg.elem (i) = idx_j;
+ 	}
+     }
+ 
+   return result;
+ }
+ 
+ ComplexNDArray
+ ComplexNDArray::min (int dim) const
+ {
+   ArrayN<int> dummy_idx;
+   return min (dummy_idx, dim);
+ }
+ 
+ ComplexNDArray
+ ComplexNDArray::min (ArrayN<int>& idx_arg, int dim) const
+ {
+   dim_vector dv = dims ();
+   dim_vector dr = dims ();
+ 
+   if (dv.numel () == 0 || dim > dv.length () || dim < 0)
+     return ComplexNDArray ();
+   
+   dr(dim) = 1;
+ 
+   ComplexNDArray result (dr);
+   idx_arg.resize (dr);
+ 
+   int x_stride = 1;
+   int x_len = dv(dim);
+   for (int i = 0; i < dim; i++)
+     x_stride *= dv(i);
+ 
+   for (int i = 0; i < dr.numel (); i++)
+     {
+       int x_offset;
+       if (x_stride == 1)
+ 	x_offset = i * x_len;
+       else
+ 	{
+ 	  int x_offset2 = 0;
+ 	  x_offset = i;
+ 	  while (x_offset >= x_stride)
+ 	    {
+ 	      x_offset -= x_stride;
+ 	      x_offset2++;
+ 	    }
+ 	  x_offset += x_offset2 * x_stride * x_len;
+ 	}
+ 
+       int idx_j;
+ 
+       Complex tmp_min;
+ 
+       double abs_min = octave_NaN;
+ 
+       for (idx_j = 0; idx_j < x_len; idx_j++)
+ 	{
+ 	  tmp_min = elem (idx_j * x_stride + x_offset);
+ 	  
+ 	  if (! octave_is_NaN_or_NA (tmp_min))
+ 	    {
+ 	      abs_min = ::abs(tmp_min);
+ 	      break;
+ 	    }
+ 	}
+ 
+       for (int j = idx_j+1; j < x_len; j++)
+ 	{
+ 	  Complex tmp = elem (j * x_stride + x_offset);
+ 
+ 	  if (octave_is_NaN_or_NA (tmp))
+ 	    continue;
+ 
+ 	  double abs_tmp = ::abs (tmp);
+ 
+ 	  if (abs_tmp < abs_min)
+ 	    {
+ 	      idx_j = j;
+ 	      tmp_min = tmp;
+ 	      abs_min = abs_tmp;
+ 	    }
+ 	}
+ 
+       if (octave_is_NaN_or_NA (tmp_min))
+ 	{
+ 	  result.elem (i) = Complex_NaN_result;
+ 	  idx_arg.elem (i) = 0;
+ 	}
+       else
+ 	{
+ 	  result.elem (i) = tmp_min;
+ 	  idx_arg.elem (i) = idx_j;
+ 	}
+     }
+ 
+   return result;
+ }
+ 
  NDArray
  ComplexNDArray::abs (void) const
  {
***************
*** 836,841 ****
--- 1022,1162 ----
    return is;
  }
  
+ // XXX FIXME XXX -- it would be nice to share code among the min/max
+ // functions below.
+ 
+ #define EMPTY_RETURN_CHECK(T) \
+   if (nel == 0)	\
+     return T (dv);
+ 
+ ComplexNDArray
+ min (Complex c, const ComplexNDArray& m)
+ {
+   dim_vector dv = m.dims ();
+   int nel = dv.numel ();
+ 
+   EMPTY_RETURN_CHECK (ComplexNDArray);
+ 
+   ComplexNDArray result (dv);
+ 
+   for (int i = 0; i < nel; i++)
+     {
+       OCTAVE_QUIT;
+       result (i) = xmin (c, m (i));
+     }
+ 
+   return result;
+ }
+ 
+ ComplexNDArray
+ min (const ComplexNDArray& m, Complex c)
+ {
+   dim_vector dv = m.dims ();
+   int nel = dv.numel ();
+ 
+   EMPTY_RETURN_CHECK (ComplexNDArray);
+ 
+   ComplexNDArray result (dv);
+ 
+   for (int i = 0; i < nel; i++)
+     {
+       OCTAVE_QUIT;
+       result (i) = xmin (c, m (i));
+     }
+ 
+   return result;
+ }
+ 
+ ComplexNDArray
+ min (const ComplexNDArray& a, const ComplexNDArray& b)
+ {
+   dim_vector dv = a.dims ();
+   int nel = dv.numel ();
+ 
+   if (dv != b.dims ())
+     {
+       (*current_liboctave_error_handler)
+ 	("two-arg min expecting args of same size");
+       return ComplexNDArray ();
+     }
+ 
+   EMPTY_RETURN_CHECK (ComplexNDArray);
+ 
+   ComplexNDArray result (dv);
+ 
+   for (int i = 0; i < nel; i++)
+     {
+       OCTAVE_QUIT;
+       result (i) = xmin (a (i), b (i));
+     }
+ 
+   return result;
+ }
+ 
+ ComplexNDArray
+ max (Complex c, const ComplexNDArray& m)
+ {
+   dim_vector dv = m.dims ();
+   int nel = dv.numel ();
+ 
+   EMPTY_RETURN_CHECK (ComplexNDArray);
+ 
+   ComplexNDArray result (dv);
+ 
+   for (int i = 0; i < nel; i++)
+     {
+       OCTAVE_QUIT;
+       result (i) = xmax (c, m (i));
+     }
+ 
+   return result;
+ }
+ 
+ ComplexNDArray
+ max (const ComplexNDArray& m, Complex c)
+ {
+   dim_vector dv = m.dims ();
+   int nel = dv.numel ();
+ 
+   EMPTY_RETURN_CHECK (ComplexNDArray);
+ 
+   ComplexNDArray result (dv);
+ 
+   for (int i = 0; i < nel; i++)
+     {
+       OCTAVE_QUIT;
+       result (i) = xmax (c, m (i));
+     }
+ 
+   return result;
+ }
+ 
+ ComplexNDArray
+ max (const ComplexNDArray& a, const ComplexNDArray& b)
+ {
+   dim_vector dv = a.dims ();
+   int nel = dv.numel ();
+ 
+   if (dv != b.dims ())
+     {
+       (*current_liboctave_error_handler)
+ 	("two-arg max expecting args of same size");
+       return ComplexNDArray ();
+     }
+ 
+   EMPTY_RETURN_CHECK (ComplexNDArray);
+ 
+   ComplexNDArray result (dv);
+ 
+   for (int i = 0; i < nel; i++)
+     {
+       OCTAVE_QUIT;
+       result (i) = xmax (a (i), b (i));
+     }
+ 
+   return result;
+ }
+ 
  NDS_CMP_OPS(ComplexNDArray, real, Complex, real)
  NDS_BOOL_OPS(ComplexNDArray, Complex, 0.0)
  
*** ./liboctave/CNDArray.h.orig	2004-03-26 18:17:23.000000000 +0100
--- ./liboctave/CNDArray.h	2004-03-26 18:26:50.000000000 +0100
***************
*** 89,94 ****
--- 89,99 ----
    ComplexNDArray sumsq (int dim = -1) const;
    int cat (const ComplexNDArray& ra_arg, int dim, int iidx, int move);
  
+   ComplexNDArray max (int dim = 0) const;
+   ComplexNDArray max (ArrayN<int>& index, int dim = 0) const;
+   ComplexNDArray min (int dim = 0) const;
+   ComplexNDArray min (ArrayN<int>& index, int dim = 0) const;
+ 
    ComplexNDArray& insert (const NDArray& a, int r, int c);
    ComplexNDArray& insert (const ComplexNDArray& a, int r, int c);
    
***************
*** 130,135 ****
--- 135,148 ----
      : MArrayN<Complex> (d, dv) { }
  };
  
+ extern ComplexNDArray min (const Complex& c, const ComplexNDArray& m);
+ extern ComplexNDArray min (const ComplexNDArray& m, const Complex& c);
+ extern ComplexNDArray min (const ComplexNDArray& a, const ComplexNDArray& b);
+ 
+ extern ComplexNDArray max (const Complex& c, const ComplexNDArray& m);
+ extern ComplexNDArray max (const ComplexNDArray& m, const Complex& c);
+ extern ComplexNDArray max (const ComplexNDArray& a, const ComplexNDArray& b);
+ 
  NDS_CMP_OP_DECLS (ComplexNDArray, Complex)
  NDS_BOOL_OP_DECLS (ComplexNDArray, Complex)
  
*** ./liboctave/dNDArray.cc.orig	2004-03-26 18:17:33.000000000 +0100
--- ./liboctave/dNDArray.cc	2004-03-26 20:39:23.000000000 +0100
***************
*** 660,670 ****
  NDArray::max (int dim) const
  {
    ArrayN<int> dummy_idx;
!   return max (dim, dummy_idx);
  }
  
  NDArray
! NDArray::max (int dim, ArrayN<int>& idx_arg) const
  {
    dim_vector dv = dims ();
    dim_vector dr = dims ();
--- 660,670 ----
  NDArray::max (int dim) const
  {
    ArrayN<int> dummy_idx;
!   return max (dummy_idx, dim);
  }
  
  NDArray
! NDArray::max (ArrayN<int>& idx_arg, int dim) const
  {
    dim_vector dv = dims ();
    dim_vector dr = dims ();
***************
*** 711,717 ****
  	    break;
  	}
  
!       for (int j = idx_j+1; j < nc; j++)
  	{
  	  double tmp = elem (j * x_stride + x_offset);
  
--- 711,717 ----
  	    break;
  	}
  
!       for (int j = idx_j+1; j < x_len; j++)
  	{
  	  double tmp = elem (j * x_stride + x_offset);
  
***************
*** 731,736 ****
--- 731,811 ----
    return result;
  }
  
+ NDArray
+ NDArray::min (int dim) const
+ {
+   ArrayN<int> dummy_idx;
+   return min (dummy_idx, dim);
+ }
+ 
+ NDArray
+ NDArray::min (ArrayN<int>& idx_arg, int dim) const
+ {
+   dim_vector dv = dims ();
+   dim_vector dr = dims ();
+ 
+   if (dv.numel () == 0 || dim > dv.length () || dim < 0)
+     return NDArray ();
+   
+   dr(dim) = 1;
+ 
+   NDArray result (dr);
+   idx_arg.resize (dr);
+ 
+   int x_stride = 1;
+   int x_len = dv(dim);
+   for (int i = 0; i < dim; i++)
+     x_stride *= dv(i);
+ 
+   for (int i = 0; i < dr.numel (); i++)
+     {
+       int x_offset;
+       if (x_stride == 1)
+ 	x_offset = i * x_len;
+       else
+ 	{
+ 	  int x_offset2 = 0;
+ 	  x_offset = i;
+ 	  while (x_offset >= x_stride)
+ 	    {
+ 	      x_offset -= x_stride;
+ 	      x_offset2++;
+ 	    }
+ 	  x_offset += x_offset2 * x_stride * x_len;
+ 	}
+ 
+       int idx_j;
+ 
+       double tmp_min = octave_NaN;
+ 
+       for (idx_j = 0; idx_j < x_len; idx_j++)
+ 	{
+ 	  tmp_min = elem (idx_j * x_stride + x_offset);
+ 	  
+ 	  if (! octave_is_NaN_or_NA (tmp_min))
+ 	    break;
+ 	}
+ 
+       for (int j = idx_j+1; j < x_len; j++)
+ 	{
+ 	  double tmp = elem (j * x_stride + x_offset);
+ 
+ 	  if (octave_is_NaN_or_NA (tmp))
+ 	    continue;
+ 	  else if (tmp < tmp_min)
+ 	    {
+ 	      idx_j = j;
+ 	      tmp_min = tmp;
+ 	    }
+ 	}
+ 
+       result.elem (i) = tmp_min;
+       idx_arg.elem (i) = octave_is_NaN_or_NA (tmp_min) ? 0 : idx_j;
+     }
+ 
+   return result;
+ }
+ 
  int
  NDArray::cat (const NDArray& ra_arg, int dim, int iidx, int move)
  {
***************
*** 851,856 ****
--- 926,1066 ----
    return is;
  }
  
+ // XXX FIXME XXX -- it would be nice to share code among the min/max
+ // functions below.
+ 
+ #define EMPTY_RETURN_CHECK(T) \
+   if (nel == 0)	\
+     return T (dv);
+ 
+ NDArray
+ min (double d, const NDArray& m)
+ {
+   dim_vector dv = m.dims ();
+   int nel = dv.numel ();
+ 
+   EMPTY_RETURN_CHECK (NDArray);
+ 
+   NDArray result (dv);
+ 
+   for (int i = 0; i < nel; i++)
+     {
+       OCTAVE_QUIT;
+       result (i) = xmin (d, m (i));
+     }
+ 
+   return result;
+ }
+ 
+ NDArray
+ min (const NDArray& m, double d)
+ {
+   dim_vector dv = m.dims ();
+   int nel = dv.numel ();
+ 
+   EMPTY_RETURN_CHECK (NDArray);
+ 
+   NDArray result (dv);
+ 
+   for (int i = 0; i < nel; i++)
+     {
+       OCTAVE_QUIT;
+       result (i) = xmin (d, m (i));
+     }
+ 
+   return result;
+ }
+ 
+ NDArray
+ min (const NDArray& a, const NDArray& b)
+ {
+   dim_vector dv = a.dims ();
+   int nel = dv.numel ();
+ 
+   if (dv != b.dims ())
+     {
+       (*current_liboctave_error_handler)
+ 	("two-arg min expecting args of same size");
+       return NDArray ();
+     }
+ 
+   EMPTY_RETURN_CHECK (NDArray);
+ 
+   NDArray result (dv);
+ 
+   for (int i = 0; i < nel; i++)
+     {
+       OCTAVE_QUIT;
+       result (i) = xmin (a (i), b (i));
+     }
+ 
+   return result;
+ }
+ 
+ NDArray
+ max (double d, const NDArray& m)
+ {
+   dim_vector dv = m.dims ();
+   int nel = dv.numel ();
+ 
+   EMPTY_RETURN_CHECK (NDArray);
+ 
+   NDArray result (dv);
+ 
+   for (int i = 0; i < nel; i++)
+     {
+       OCTAVE_QUIT;
+       result (i) = xmax (d, m (i));
+     }
+ 
+   return result;
+ }
+ 
+ NDArray
+ max (const NDArray& m, double d)
+ {
+   dim_vector dv = m.dims ();
+   int nel = dv.numel ();
+ 
+   EMPTY_RETURN_CHECK (NDArray);
+ 
+   NDArray result (dv);
+ 
+   for (int i = 0; i < nel; i++)
+     {
+       OCTAVE_QUIT;
+       result (i) = xmax (d, m (i));
+     }
+ 
+   return result;
+ }
+ 
+ NDArray
+ max (const NDArray& a, const NDArray& b)
+ {
+   dim_vector dv = a.dims ();
+   int nel = dv.numel ();
+ 
+   if (dv != b.dims ())
+     {
+       (*current_liboctave_error_handler)
+ 	("two-arg max expecting args of same size");
+       return NDArray ();
+     }
+ 
+   EMPTY_RETURN_CHECK (NDArray);
+ 
+   NDArray result (dv);
+ 
+   for (int i = 0; i < nel; i++)
+     {
+       OCTAVE_QUIT;
+       result (i) = xmax (a (i), b (i));
+     }
+ 
+   return result;
+ }
+ 
  NDS_CMP_OPS(NDArray, , double, )
  NDS_BOOL_OPS(NDArray, double, 0.0)
  
*** ./liboctave/dNDArray.h.orig	2004-03-26 18:17:38.000000000 +0100
--- ./liboctave/dNDArray.h	2004-03-26 18:26:17.000000000 +0100
***************
*** 87,93 ****
    NDArray sum (int dim = -1) const;  
    NDArray sumsq (int dim = -1) const;
    int cat (const NDArray& ra_arg, int dim, int iidx, int move);
!      
    NDArray abs (void) const;
  
    ComplexNDArray fourier (int dim = 1) const;
--- 87,98 ----
    NDArray sum (int dim = -1) const;  
    NDArray sumsq (int dim = -1) const;
    int cat (const NDArray& ra_arg, int dim, int iidx, int move);
! 
!   NDArray max (int dim = 0) const;
!   NDArray max (ArrayN<int>& index, int dim = 0) const;
!   NDArray min (int dim = 0) const;
!   NDArray min (ArrayN<int>& index, int dim = 0) const;
!   
    NDArray abs (void) const;
  
    ComplexNDArray fourier (int dim = 1) const;
***************
*** 125,130 ****
--- 130,143 ----
    NDArray (double *d, const dim_vector& dv) : MArrayN<double> (d, dv) { }
  };
  
+ extern NDArray min (double d, const NDArray& m);
+ extern NDArray min (const NDArray& m, double d);
+ extern NDArray min (const NDArray& a, const NDArray& b);
+ 
+ extern NDArray max (double d, const NDArray& m);
+ extern NDArray max (const NDArray& m, double d);
+ extern NDArray max (const NDArray& a, const NDArray& b);
+ 
  NDS_CMP_OP_DECLS (NDArray, double)
  NDS_BOOL_OP_DECLS (NDArray, double)
  
*** ./liboctave/ChangeLog.orig	2004-03-27 01:44:39.000000000 +0100
--- ./liboctave/ChangeLog	2004-03-27 01:44:43.000000000 +0100
***************
*** 1,3 ****
--- 1,14 ----
+ 2004-03-26  David Bateman <address@hidden>
+ 
+ 	* dNDArray.cc (NDArray::min, NDArray::max, min, max):
+ 	Min and Max functions for NDArrays.
+ 	* dNDArray.h (NDArray::min, NDArray::max, min, max): Decl.
+ 
+ 	* CNDArray.cc (ComplexNDArray::min, ComplexNDArray::max, min, max):
+ 	Min and Max functions for ComplexNDArrays.
+ 	* CNDArray.h (ComplexNDArray::min, ComplexNDArray::max, min, max): 
+ 	Decl.
+ 	
  2004-03-11  John W. Eaton  <address@hidden>
  
  	* so-array.cc (SND_CMP_OP, NDS_CMP_OP, NDND_CMP_OP):
*** ./src/DLD-FUNCTIONS/minmax.cc.orig	2004-03-26 18:17:53.000000000 +0100
--- ./src/DLD-FUNCTIONS/minmax.cc	2004-03-27 01:37:06.000000000 +0100
***************
*** 28,35 ****
  
  #include "lo-ieee.h"
  #include "lo-mappers.h"
! #include "dMatrix.h"
! #include "CMatrix.h"
  #include "quit.h"
  
  #include "defun-dld.h"
--- 28,35 ----
  
  #include "lo-ieee.h"
  #include "lo-mappers.h"
! #include "dNDArray.h"
! #include "CNDArray.h"
  #include "quit.h"
  
  #include "defun-dld.h"
***************
*** 37,49 ****
  #include "gripes.h"
  #include "oct-obj.h"
  
  #define MINMAX_BODY(FCN) \
   \
    octave_value_list retval;  \
   \
    int nargin = args.length (); \
   \
!   if (nargin < 1 || nargin > 2 || nargout > 2) \
      { \
        print_usage (#FCN); \
        return retval; \
--- 37,51 ----
  #include "gripes.h"
  #include "oct-obj.h"
  
+ #include "ov-cx-mat.h"
+ 
  #define MINMAX_BODY(FCN) \
   \
    octave_value_list retval;  \
   \
    int nargin = args.length (); \
   \
!   if (nargin < 1 || nargin > 3 || nargout > 2) \
      { \
        print_usage (#FCN); \
        return retval; \
***************
*** 51,59 ****
--- 53,65 ----
   \
    octave_value arg1; \
    octave_value arg2; \
+   octave_value arg3; \
   \
    switch (nargin) \
      { \
+     case 3: \
+       arg3 = args(2); \
+  \
      case 2: \
        arg2 = args(1); \
   \
***************
*** 66,162 ****
        break; \
      } \
   \
!   if (nargin == 1 && (nargout == 1 || nargout == 0)) \
      { \
        if (arg1.is_real_type ()) \
  	{ \
! 	  Matrix m = arg1.matrix_value (); \
   \
  	  if (! error_state) \
  	    { \
! 	      if (m.rows () == 1) \
! 		retval(0) = m.row_ ## FCN (); \
! 	      else \
! 		{ \
! 		  if (m.rows () == 0 || m.columns () == 0) \
! 		    retval(0) = Matrix (); \
! 		  else \
! 		    retval(0) = m.column_ ## FCN (); \
! 		} \
  	    } \
  	} \
        else if (arg1.is_complex_type ()) \
  	{ \
! 	  ComplexMatrix m = arg1.complex_matrix_value (); \
   \
  	  if (! error_state) \
  	    { \
! 	      if (m.rows () == 1) \
! 		retval(0) = m.row_ ## FCN (); \
! 	      else \
! 		{ \
! 		  if (m.rows () == 0 || m.columns () == 0) \
! 		    retval(0) = Matrix (); \
! 		  else \
! 		    retval(0) = m.column_ ## FCN (); \
! 		} \
  	    } \
  	} \
        else \
  	gripe_wrong_type_arg (#FCN, arg1); \
      } \
!   else if (nargin == 1 && nargout == 2) \
      { \
!       Array<int> index; \
   \
        if (arg1.is_real_type ()) \
  	{ \
! 	  Matrix m = arg1.matrix_value (); \
   \
  	  if (! error_state) \
  	    { \
! 	      retval.resize (2); \
!  \
! 	      if (m.rows () == 1) \
! 		retval(0) = m.row_ ## FCN (index); \
! 	      else \
! 		{ \
! 		  if (m.rows () == 0 || m.columns () == 0) \
! 		    retval(0) = Matrix (); \
! 		  else \
! 		    retval(0) = m.column_ ## FCN (index); \
! 		} \
  	    } \
  	} \
        else if (arg1.is_complex_type ()) \
  	{ \
! 	  ComplexMatrix m = arg1.complex_matrix_value (); \
   \
  	  if (! error_state) \
  	    { \
! 	      retval.resize (2); \
!  \
! 	      if (m.rows () == 1) \
! 		retval(0) = m.row_ ## FCN (index); \
! 	      else \
! 		{ \
! 		  if (m.rows () == 0 || m.columns () == 0) \
! 		    retval(0) = Matrix (); \
! 		  else \
! 		    retval(0) = m.column_ ## FCN (index); \
! 		} \
  	    } \
  	} \
        else \
  	gripe_wrong_type_arg (#FCN, arg1); \
   \
!       int len = index.length (); \
   \
        if (len > 0) \
  	{ \
  	  double nan_val = lo_ieee_nan_value (); \
   \
! 	  RowVector idx (len); \
   \
  	  for (int i = 0; i < len; i++) \
  	    { \
--- 72,182 ----
        break; \
      } \
   \
!   int dim; \
!   dim_vector dv = ((const octave_complex_matrix&) arg1) .dims (); \
!   if (error_state) \
!     { \
!       gripe_wrong_type_arg (#FCN, arg1);  \
!       return retval; \
!     } \
!  \
!   if (nargin == 3) \
!     { \
!       dim = arg3.nint_value () - 1;  \
!       if (dim < 0 || dim >= dv.length ()) \
!         { \
! 	  error ("%s: invalid dimension", #FCN); \
! 	  return retval; \
! 	} \
!     } \
!   else \
!     { \
!       dim = 0; \
!       while ((dim < dv.length ()) && (dv (dim) <= 1)) \
! 	dim++; \
!       if (dim == dv.length ()) \
! 	dim = 0; \
!     } \
!  \
!   bool single_arg = (nargin == 1) || arg2.is_empty();	\
!  \
!   if (single_arg) \
!     { \
!       dv(dim) = 1; \
!       int n_dims = dv.length (); \
!       for (int i = n_dims; i > 1; i--) \
! 	{ \
! 	  if (dv(i-1) == 1) \
! 	    n_dims--; \
! 	  else \
! 	    break; \
! 	} \
!       dv.resize (n_dims); \
!     } \
!  \
!   if (single_arg && (nargout == 1 || nargout == 0)) \
      { \
        if (arg1.is_real_type ()) \
  	{ \
! 	  NDArray m = arg1.array_value (); \
   \
  	  if (! error_state) \
  	    { \
! 	      NDArray n = m. FCN (dim); \
! 	      n.resize (dv); \
! 	      retval(0) = n; \
  	    } \
  	} \
        else if (arg1.is_complex_type ()) \
  	{ \
! 	  ComplexNDArray m = arg1.complex_array_value (); \
   \
  	  if (! error_state) \
  	    { \
! 	      ComplexNDArray n = m. FCN (dim); \
! 	      n.resize (dv); \
! 	      retval(0) = n; \
  	    } \
  	} \
        else \
  	gripe_wrong_type_arg (#FCN, arg1); \
      } \
!   else if (single_arg && nargout == 2) \
      { \
!       ArrayN<int> index; \
   \
        if (arg1.is_real_type ()) \
  	{ \
! 	  NDArray m = arg1.array_value (); \
   \
  	  if (! error_state) \
  	    { \
! 	      NDArray n = m. FCN (index, dim);	\
! 	      n.resize (dv); \
! 	      retval(0) = n; \
  	    } \
  	} \
        else if (arg1.is_complex_type ()) \
  	{ \
! 	  ComplexNDArray m = arg1.complex_array_value (); \
   \
  	  if (! error_state) \
  	    { \
! 	      ComplexNDArray n = m. FCN (index, dim);	\
! 	      n.resize (dv); \
! 	      retval(0) = n; \
  	    } \
  	} \
        else \
  	gripe_wrong_type_arg (#FCN, arg1); \
   \
!       int len = index.numel (); \
   \
        if (len > 0) \
  	{ \
  	  double nan_val = lo_ieee_nan_value (); \
   \
! 	  NDArray idx (index.dims ()); \
   \
  	  for (int i = 0; i < len; i++) \
  	    { \
***************
*** 169,177 ****
  	  retval(1) = idx; \
  	} \
        else \
! 	retval(1) = Matrix (); \
      } \
!   else if (nargin == 2) \
      { \
        int arg1_is_scalar = arg1.is_scalar_type (); \
        int arg2_is_scalar = arg2.is_scalar_type (); \
--- 189,197 ----
  	  retval(1) = idx; \
  	} \
        else \
! 	retval(1) = NDArray (); \
      } \
!   else \
      { \
        int arg1_is_scalar = arg1.is_scalar_type (); \
        int arg2_is_scalar = arg2.is_scalar_type (); \
***************
*** 184,193 ****
  	  if (arg1_is_complex || arg2_is_complex) \
  	    { \
  	      Complex c1 = arg1.complex_value (); \
! 	      ComplexMatrix m2 = arg2.complex_matrix_value (); \
  	      if (! error_state) \
  		{ \
! 		  ComplexMatrix result = FCN (c1, m2); \
  		  if (! error_state) \
  		    retval(0) = result; \
  		} \
--- 204,213 ----
  	  if (arg1_is_complex || arg2_is_complex) \
  	    { \
  	      Complex c1 = arg1.complex_value (); \
! 	      ComplexNDArray m2 = arg2.complex_array_value (); \
  	      if (! error_state) \
  		{ \
! 		  ComplexNDArray result = FCN (c1, m2); \
  		  if (! error_state) \
  		    retval(0) = result; \
  		} \
***************
*** 195,205 ****
  	  else \
  	    { \
  	      double d1 = arg1.double_value (); \
! 	      Matrix m2 = arg2.matrix_value (); \
   \
  	      if (! error_state) \
  		{ \
! 		  Matrix result = FCN (d1, m2); \
  		  if (! error_state) \
  		    retval(0) = result; \
  		} \
--- 215,225 ----
  	  else \
  	    { \
  	      double d1 = arg1.double_value (); \
! 	      NDArray m2 = arg2.array_value (); \
   \
  	      if (! error_state) \
  		{ \
! 		  NDArray result = FCN (d1, m2); \
  		  if (! error_state) \
  		    retval(0) = result; \
  		} \
***************
*** 209,232 ****
  	{ \
  	  if (arg1_is_complex || arg2_is_complex) \
  	    { \
! 	      ComplexMatrix m1 = arg1.complex_matrix_value (); \
   \
  	      if (! error_state) \
  		{ \
  		  Complex c2 = arg2.complex_value (); \
! 		  ComplexMatrix result = FCN (m1, c2); \
  		  if (! error_state) \
  		    retval(0) = result; \
  		} \
  	    } \
  	  else \
  	    { \
! 	      Matrix m1 = arg1.matrix_value (); \
   \
  	      if (! error_state) \
  		{ \
  		  double d2 = arg2.double_value (); \
! 		  Matrix result = FCN (m1, d2); \
  		  if (! error_state) \
  		    retval(0) = result; \
  		} \
--- 229,252 ----
  	{ \
  	  if (arg1_is_complex || arg2_is_complex) \
  	    { \
! 	      ComplexNDArray m1 = arg1.complex_array_value (); \
   \
  	      if (! error_state) \
  		{ \
  		  Complex c2 = arg2.complex_value (); \
! 		  ComplexNDArray result = FCN (m1, c2); \
  		  if (! error_state) \
  		    retval(0) = result; \
  		} \
  	    } \
  	  else \
  	    { \
! 	      NDArray m1 = arg1.array_value (); \
   \
  	      if (! error_state) \
  		{ \
  		  double d2 = arg2.double_value (); \
! 		  NDArray result = FCN (m1, d2); \
  		  if (! error_state) \
  		    retval(0) = result; \
  		} \
***************
*** 236,250 ****
  	{ \
  	  if (arg1_is_complex || arg2_is_complex) \
  	    { \
! 	      ComplexMatrix m1 = arg1.complex_matrix_value (); \
   \
  	      if (! error_state) \
  		{ \
! 		  ComplexMatrix m2 = arg2.complex_matrix_value (); \
   \
  		  if (! error_state) \
  		    { \
! 		      ComplexMatrix result = FCN (m1, m2); \
  		      if (! error_state) \
  			retval(0) = result; \
  		    } \
--- 256,270 ----
  	{ \
  	  if (arg1_is_complex || arg2_is_complex) \
  	    { \
! 	      ComplexNDArray m1 = arg1.complex_array_value (); \
   \
  	      if (! error_state) \
  		{ \
! 		  ComplexNDArray m2 = arg2.complex_array_value (); \
   \
  		  if (! error_state) \
  		    { \
! 		      ComplexNDArray result = FCN (m1, m2); \
  		      if (! error_state) \
  			retval(0) = result; \
  		    } \
***************
*** 252,266 ****
  	    } \
  	  else \
  	    { \
! 	      Matrix m1 = arg1.matrix_value (); \
   \
  	      if (! error_state) \
  		{ \
! 		  Matrix m2 = arg2.matrix_value (); \
   \
  		  if (! error_state) \
  		    { \
! 		      Matrix result = FCN (m1, m2); \
  		      if (! error_state) \
  			retval(0) = result; \
  		    } \
--- 272,286 ----
  	    } \
  	  else \
  	    { \
! 	      NDArray m1 = arg1.array_value (); \
   \
  	      if (! error_state) \
  		{ \
! 		  NDArray m2 = arg2.array_value (); \
   \
  		  if (! error_state) \
  		    { \
! 		      NDArray result = FCN (m1, m2); \
  		      if (! error_state) \
  			retval(0) = result; \
  		    } \
***************
*** 268,288 ****
  	    } \
  	} \
      } \
-   else \
-     panic_impossible (); \
   \
    return retval
  
  DEFUN_DLD (min, args, nargout,
    "-*- texinfo -*-\n\
! @deftypefn {Mapping Function} {} min (@var{x}, @var{y})\n\
  @deftypefnx {Mapping Function} address@hidden, @var{iw}] =} min (@var{x})\n\
  @cindex Utility Functions\n\
  For a vector argument, return the minimum value.  For a matrix\n\
  argument, return the minimum value from each column, as a row\n\
! vector.\n\
! For two matrices (or a matrix and scalar),\n\
! return the pair-wise minimum.\n\
  Thus,\n\
  \n\
  @example\n\
--- 288,305 ----
  	    } \
  	} \
      } \
   \
    return retval
  
  DEFUN_DLD (min, args, nargout,
    "-*- texinfo -*-\n\
! @deftypefn {Mapping Function} {} min (@var{x}, @var{y}, @var{dim})\n\
  @deftypefnx {Mapping Function} address@hidden, @var{iw}] =} min (@var{x})\n\
  @cindex Utility Functions\n\
  For a vector argument, return the minimum value.  For a matrix\n\
  argument, return the minimum value from each column, as a row\n\
! vector, or over the dimension @var{dim} if defined. For two matrices\n\
! (or a matrix and scalar), return the pair-wise minimum.\n\
  Thus,\n\
  \n\
  @example\n\
***************
*** 323,336 ****
  
  DEFUN_DLD (max, args, nargout,
    "-*- texinfo -*-\n\
! @deftypefn {Mapping Function} {} max (@var{x}, @var{y})\n\
  @deftypefnx {Mapping Function} address@hidden, @var{iw}] =} max (@var{x})\n\
  @cindex Utility Functions\n\
  For a vector argument, return the maximum value.  For a matrix\n\
  argument, return the maximum value from each column, as a row\n\
! vector.\n\
! For two matrices (or a matrix and scalar),\n\
! return the pair-wise maximum.\n\
  Thus,\n\
  \n\
  @example\n\
--- 340,352 ----
  
  DEFUN_DLD (max, args, nargout,
    "-*- texinfo -*-\n\
! @deftypefn {Mapping Function} {} max (@var{x}, @var{y}, @var{dim})\n\
  @deftypefnx {Mapping Function} address@hidden, @var{iw}] =} max (@var{x})\n\
  @cindex Utility Functions\n\
  For a vector argument, return the maximum value.  For a matrix\n\
  argument, return the maximum value from each column, as a row\n\
! vector, or over the dimension @var{dim} if defined. For two matrices\n\
! (or a matrix and scalar), return the pair-wise maximum.\n\
  Thus,\n\
  \n\
  @example\n\