[PATCH] Add an operator<(Complex, Complex) to oct-sort.cc for non-g++ compilers.

[John W. Eaton]

On 29-Nov-2007, Jason Riedy wrote:

| The standard rightly does not define ordering operators, but g++'s
| libstdc++ provides them.  Other compilers (e.g. icc) do not, and
| oct-sort.cc refuses to compile.  The included operator is never
| actually *used* in Octave; src/DLD-FUNCTIONS/sort.cc defines
| comparison functions for Complex sorts.

I don't see why this would be needed since the Complex versions of
these templates should not be instantiated except in
src/DLD-FUNCTIONS/sort.cc, which does provide a definition of
operator< for Complex values.  However, looking at that file, I
noticed that some of the functions there should probably pass
arguments by const reference instead of value, so I checked the
following changes.  Does that help?  If not, precisely what is the
error message you see from icc?

jwe


src/ChangeLog:

2007-11-30  John W. Eaton  <address@hidden>

        * DLD-FUNCTIONS/sort.cc (ascending_compare, descending_compare,
        operator < (const Complex&, const Complex&)):
        Pass args by const reference, not value.


Index: src/DLD-FUNCTIONS/sort.cc
===================================================================
RCS file: /cvs/octave/src/DLD-FUNCTIONS/sort.cc,v
retrieving revision 1.39
diff -u -u -w -r1.39 sort.cc
--- src/DLD-FUNCTIONS/sort.cc   25 Oct 2007 05:50:56 -0000      1.39
+++ src/DLD-FUNCTIONS/sort.cc   30 Nov 2007 17:54:37 -0000
@@ -67,14 +67,14 @@
 
 template <class T>
 bool 
-ascending_compare (vec_index<T> *a, vec_index<T> *b)
+ascending_compare (const vec_index<T> *a, const vec_index<T> *b)
 {
   return (a->vec < b->vec);
 }
 
 template <class T>
 bool 
-descending_compare (vec_index<T> *a, vec_index<T> *b)
+descending_compare (const vec_index<T> *a, const vec_index<T> *b)
 {
   return (a->vec > b->vec);
 }
@@ -442,32 +442,28 @@
 
 template <>
 bool
-ascending_compare (uint64_t a, 
-                  uint64_t b)
+ascending_compare (uint64_t a, uint64_t b)
 {
   return (a < b);
 }
 
 template <>
 bool
-ascending_compare (vec_index<uint64_t> *a, 
-                  vec_index<uint64_t> *b)
+ascending_compare (const vec_index<uint64_t> *a, const vec_index<uint64_t> *b)
 {
   return (a->vec < b->vec);
 }
 
 template <>
 bool
-descending_compare (uint64_t a, 
-                   uint64_t b)
+descending_compare (uint64_t a, uint64_t b)
 {
   return (a > b);
 }
 
 template <>
 bool
-descending_compare (vec_index<uint64_t> *a, 
-                   vec_index<uint64_t> *b)
+descending_compare (const vec_index<uint64_t> *a, const vec_index<uint64_t> *b)
 {
   return (a->vec > b->vec);
 }
@@ -800,37 +796,37 @@
 
 template <>
 bool
-ascending_compare (Complex a, Complex b)
+ascending_compare (const Complex& a, const Complex& b)
 {
-  return (xisnan (b) || (xabs (a) < xabs (b)) || ((xabs (a) == xabs (b))
-             && (arg (a) < arg (b))));
+  return (xisnan (b) || (xabs (a) < xabs (b))
+         || ((xabs (a) == xabs (b)) && (arg (a) < arg (b))));
 }
 
-bool
-operator < (const Complex a, const Complex b)
+static inline bool
+operator < (const Complex& a, const Complex& b)
 {
-  return (xisnan (b) || (xabs (a) < xabs (b)) || ((xabs (a) == xabs (b))
-             && (arg (a) < arg (b))));
+  return (xisnan (b) || (xabs (a) < xabs (b))
+         || ((xabs (a) == xabs (b)) && (arg (a) < arg (b))));
 }
 
 template <>
 bool
-descending_compare (Complex a, Complex b)
+descending_compare (const Complex& a, const Complex& b)
 {
-  return (xisnan (a) || (xabs (a) > xabs (b)) || ((xabs (a) == xabs (b))
-             && (arg (a) > arg (b))));
+  return (xisnan (a) || (xabs (a) > xabs (b))
+         || ((xabs (a) == xabs (b)) && (arg (a) > arg (b))));
 }
 
 bool
-operator > (const Complex a, const Complex b)
+operator > (const Complex& a, const Complex& b)
 {
-  return (xisnan (a) || (xabs (a) > xabs (b)) || ((xabs (a) == xabs (b))
-             && (arg (a) > arg (b))));
+  return (xisnan (a) || (xabs (a) > xabs (b))
+         || ((xabs (a) == xabs (b)) && (arg (a) > arg (b))));
 }
 
 template <>
 bool
-ascending_compare (vec_index<Complex> *a, vec_index<Complex> *b)
+ascending_compare (const vec_index<Complex> *a, const vec_index<Complex> *b)
 {
   return (xisnan (b->vec)
          || (xabs (a->vec) < xabs (b->vec))
@@ -840,7 +836,7 @@
 
 template <>
 bool
-descending_compare (vec_index<Complex> *a, vec_index<Complex> *b)
+descending_compare (const vec_index<Complex> *a, const vec_index<Complex> *b)
 {
   return (xisnan (a->vec)
          || (xabs (a->vec) > xabs (b->vec))