I believe I have found the source of the problem. Maple 11 does try to combine the two RealRanges, but fails because signum(0.) returns as a float (0.) and not an integer (0).

The code for RealRange_union looks for overlapping, or adjacent, intervals. It does this by looking at the signum of the difference of the endpoints of the ranges. In most cases, signum returns 1 or -1 (integers), but signum(0.) returns 0. (floating point).

Here is the source for RealRange_union, with some comments added:

showstat( RealRange_union );

RealRange_union := proc()
local i, j, r, r1, r2, t1, t2, lo, hi, si;
   1   if nargs < 2 or not has([args],RealRange) then
   2     return args
       elif 2 < nargs then

for more than 2 ranges, work pairwise (recursion)

   3     for i to nargs do
   4       for j from i+1 to nargs do
   5         r := traperror(procname(args[i],args[j]));
   6         if r <> lasterror and nops([r]) = 1 then
   7           return procname(op(subsop(i = r,j = NULL,[args])))
             end if
           end do
         end do;
   8     return args
       else

extract endpoints of range 1

   9     r1 := traperror(RealRange_ends(args[1]));
  10     if r1 = lasterror then
  11       return args
         end if;

extract endpoints of range 2

  12     r2 := traperror(RealRange_ends(args[2]));
  13     if r2 = lasterror then
  14       return args
         end if;
  15     if type(r1[1],Open(algebraic)) then
  16       t1 := op(1,r1[1])
         else
  17       t1 := r1[1]
         end if;

check order of left endpoints of each range

  18     if type(r2[1],Open(algebraic)) then
  19       t2 := op(1,r2[1])
         else
  20       t2 := r2[1]
         end if;
  21     if has(t1,infinity) and has(t2,infinity) then
  22       si := 1
         else
  23       si := signum(t2-t1)
         end if;
  24     if not type(si,integer) then
  25       return args
         end if;
  26     if si = -1 or si = 0 and type(r1[1],Open(algebraic)) then

reverse order of the ranges

  27       t1 := r1;
  28       r1 := r2;
  29       r2 := t1
         end if;

At this time it is known that the left endpoint of range 1 <= right endpoint of range 2.

Now, look for overlap by comparing the right endpoint of range 1 and the left endpoint of range 2.

  30     if type(r1[2],Open(algebraic)) then
  31       t1 := op(1,r1[2])
         else
  32       t1 := r1[2]
         end if;
  33     if type(r2[1],Open(algebraic)) then
  34       t2 := op(1,r2[1])
         else
  35       t2 := r2[1]
         end if;
  36     si := signum(t2-t1);

Reduction is NOT possible when:
i) t2>t1 or
ii) both ranges are open @ t1=t2
In all other cases, simply return args unchanged

  37     if not type(si,integer) then
  38       return args
         end if;
  39     if si = 1 or si = 0 and type(r1[2],Open(algebraic)) and type(r2[1],Open(algebraic)) then
  40       return args
         end if;

Finally, begin construction of the merged range. The left endpoint is easy (because of original ordering of the ranges).

  41     lo := r1[1];

The right endpoint takes more effort. (But, isn't there a better way to do this?)

  42     if type(r2[2],Open(algebraic)) then
  43       t2 := op(1,r2[2])
         else
  44       t2 := r2[2]
         end if;
  45     if has(t1,infinity) and has(t2,infinity) then
  46       si := 1
         else
  47       si := signum(t2-t1)
         end if;
  48     if not type(si,integer) then
  49       return args
         end if;
  50     if si = 1 or si = 0 and type(r1[2],Open(algebraic)) then
  51       hi := r2[2]
         else
  52       hi := r1[2]
         end if;

Final processing to handle infinity, then return the single combined range

  53     if has(lo,infinity) then
  54       lo := -infinity
         end if;
  55     if has(hi,infinity) then
  56       hi := infinity
         end if;
  57     RealRange(lo,hi)
       end if
end proc

This procedure appears to be needlessly complicated, and is certainly quite old. (This code is exactly the same as the code found in Maple 10.)

I do not completely understand the rationale for using signum and not (simple) inequalities, but I trust there is (or was) a reason for this. Maybe something with the handling of infinity or symbolic arguments?

My suggestion for fixing this routine is to replace the use of

if not type(si,integer) then

in lines 24, 37, and 48 with

if not type(convert(si,rational),integer) then

While I do not have the time to completely rewrite this procedure, I can see that it would benefit from

• replacement of traperror/lasterror to try ... catch ... end try (lines 9-11 and 12-14)
• use of multiple assignments to interchange two quantities (lines 27-29)
• and typematch and patmatch

Of course, a full solution to this problem will involve a comprehensive look at RealRange_intersect and all of the related routines. I hope this diagnosis of the problem is helpful to someone who can implement a complete solution.

Doug

---------------------------------------------------------------------
Douglas B. Meade
Math, USC, Columbia, SC 29208  E-mail: mailto:meade@math.sc.edu       
Phone:  (803) 777-6183         URL:    http://www.math.sc.edu/~meade/