With the values for some variables set as in special below, then is it not clear that there are infinitely many solutions for the remaning variables, if r22 is taken between -1 and 1?
 

Download polysys2.mw

First, a few comments:

A few years (Maple major releases) ago the style of Help pages was changed so that Execution Group Boundaries were hidden from view in most Help pages Examples. The default setting for non-Help Documents and Worksheets is that Execution Group Boundaries are shown, however. That's the reason you see the mismatch between what appears in the Help page and what happens when you type the example into a fresh Document or Worksheet.

As Samir mentions, you can toggle the setting yourself, obtaining the non-default display that matches the current/modern Help pages.

nb. If, from the Help browser, you open the help page as a Document in the main Maple window then it retains its setting w.r.t. display/hiding of Markers like Execution Group Boundaries. So with default settings for File->New Documents/Worksheets (that show such Markers) you'll also see a mismatch between a fresh New Document and a Help page opened as Document.

Now, a suggestion:

I notice that your attachment is a Document, rather than a Worksheet. The more common unit for input/output in a Document is the Document-Block (which wraps around some Execution-Group) rather than the bare Execution-Group. An Execution-Group contained in a Document-Block does not get its Execution Group Boundaries shown. And so it seems to me that a Document-Block would provide an alternative, natural mechanism to get the effect you seem to want (of a Document's style) in your Document.

nb. The main menubar's View->Markers checkbox controls whether Document-Block boundaries are shown. Note that -- when shown -- those appear in a thin column to the left and outside of the actual sheet, whereas boundaries of bare Execution Groups are shown as black brackets within the actual sheet.

Here's an attachment where I have left the View->Show/Hide Contents...->Markers->Execution Group Boundaries toggled on. 

Download displayDocBlock.mw

You can apply the commands lhs and rhs to a range such as 1490.90920124091 .. 1497.18170785000 in order to extract the end-points.

expr := 1490.90920124091 .. 1497.18170785000:

lhs(expr);
                   1490.90920124091

rhs(expr);
                   1497.18170785000

I can reproduce the problem in Maple 17.02 on a 64bit OS X host as well as on a 64bit Linux host.

The problem seems (at least in part) to be in the `combine/ln` procedure, but I have not really dug down into that.

restart; kernelopts(printbytes=false):                                                         

kernelopts(version);

            Maple 17.02, APPLE UNIVERSAL OSX, Sep 5 2013, Build ID 872941

`combine/ln`:=u->u: # extraordinary measure

ans:=CodeTools:-Usage( int(3628800/(y*(1/2+y)^11)
                           -3628800/(y*(39/2+y)^11), y=39/2..infinity) ):
  memory used=13.75MiB, alloc change=32.00MiB,
  cpu time=218.00ms, real time=321.00ms

lprint(ans);                                                                                   

 87385605194015325709926400/3919454781758919*ln(2)-7431782400*ln(3)
 -7431782400*ln(13)-53097887349433051488808628851346857/
 282200744286642168000000000+7431782400*ln(5)

And now, after restart,

restart;
ans:=87385605194015325709926400/3919454781758919*ln(2)-7431782400*ln(3)
 -7431782400*ln(13)-53097887349433051488808628851346857/
  282200744286642168000000000+7431782400*ln(5):

combine(ans);
memory used=49975.3MB, alloc=2666.1MB, time=189.08
memory used=51387.2MB, alloc=4078.1MB, time=189.75
memory used=52093.2MB, alloc=4784.1MB, time=189.77
memory used=52097.7MB, alloc=4784.1MB, time=189.84
memory used=52099.3MB, alloc=4785.4MB, time=189.85
Interrupted

Another workaround for the given example is to force the ftocms method of the int command.

restart; kernelopts(printbytes=false):

ans:=CodeTools:-Usage( int(3628800/(y*(1/2+y)^11)-3628800/(y*(39/2+y)^11),
                           y=39/2..infinity, method=ftocms) ):
memory used=15.56MiB, alloc change=24.00MiB, cpu time=210.00ms, real time=314.00ms

lprint(ans);
 -53097887349433051488808628851346857/282200744286642168000000000
 +7431782400*ln(40)-29128535064671775175475200/
 3919454781758919*ln(39)-91750400/3919454781758919*ln(78)

oldans:=87385605194015325709926400/3919454781758919*ln(2)-7431782400*ln(3)
  -7431782400*ln(13)-53097887349433051488808628851346857/
  282200744286642168000000000+7431782400*ln(5):

simplify(ans - oldans);

                                     0

Here is a simpler instance of trouble within `combine/ln` . In Maple 

restart;                                                        
kernelopts(version);

        Maple 17.02, APPLE UNIVERSAL OSX, Sep 5 2013, Build ID 872941

expr:=87385605194015325709926400/3919454781758919*ln(2)-ln(3):

combine(expr);
memory used=195798.0MB, alloc=2666.1MB, time=25.01
memory used=198455.8MB, alloc=5324.0MB, time=26.77
memory used=201156.1MB, alloc=8024.2MB, time=29.39
Interrupted

Now, you wouldn't want `combine/ln` to never do anything, as in my crudest workaround at top.

I might be able to figure out how to patch your Maple 17.02 `combine/ln` (say as a "hotfix" with ToInert/FromInert to avoid copyright issues). If I do I'll let you know. (It might be related to the elif d = 1 then clause shown around line 92 under showstat(`combine/ln`) in your version. A preliminary attempt shows your example succeeding after that... but it'd require more examination. Such a change would, I suspect, return the shorter, simpler example above unchanged by combine.)

That link you gave indicates that within Matlab you can issue a command of the form

maple( ' ... ' )

and have the statement enclosed in single right-quotes be dispatched to the Maple symbolic engine. Is that correct?

If that is the case then (as I mentioned to you on stackexchange) you could use the Maple command zip to obtain a Matrix of equations from two given Matrix exp1 and exp2.  Did you try,

maple('zip(`=`,exp1,exp2)')

where the symbol `=`  is enclosed in single left-quotes?

Each of the commands evala , rationalize , and radnormal succeed in getting that form in Maple 17.02.

Using the avoid option of fsolve seems to be another way to get two distinct solutions.

Using 64bit Maple 2017.2 for Linux this worked for me at default Digits=10, without having to restrict the ranges narrower than the given 0<=beta,delta<=1 .

Download bivar.mw

An earlier post of yours was marked as Product: Maple 18 , which would explain why you are not always getting the same results from other members here, using just the simplify command.

If that guess is true then please mark all your Mapleprimes Questions as Maple 18 for the Product.

In the attached worksheet I show how you can get simpler results using Maple 18.02.

Download simp18.mw

Use time[real]() instead of time() to compare wall-clock timing.

(...and make sure that your machine is not otherwise loaded.)

You could also wrap the call with CodeTools:-Usage . Note the "cpu time" shows the addition from all threads (concurrent or otherwise), which is why you need to compare real-time instead. Eg,

restart;
N:=1000000: with(Threads): CodeTools:-Usage( Seq(sqrt(i),i=1. .. N) ):
memory used=1.21GiB, alloc change=302.20MiB, cpu time=11.41s, real time=2.99s, gc time=3.23s

restart;
N:=1000000: CodeTools:-Usage( seq(sqrt(i),i=1. .. N) ):
memory used=1.21GiB, alloc change=247.64MiB, cpu time=9.14s, real time=6.47s, gc time=4.34s

To emulate the general effect of Matlab's parfor you could look at Threads:-Seq (if the statements are thread-safe) or Grid:-Seq.

Since the syntax for parfor is like a that of a do-loop you might have to use a procedure in the Seq call, if you're trying to get the effect of multiple statements.

One can compare also with:

restart;
solve({x^3+x*a+2 > 0}, x, parametric);

{            3
{ [[RootOf(_Z  + _Z a + 2, index = real[3]) < x],
              3
    [RootOf(_Z  + _Z a + 2, index = real[1]) < x,
                  3
     x < RootOf(_Z  + _Z a + 2, index = real[2])]] , a < -3

    [[1 < x], [-2 < x, x < 1]] , a = -3
               3
    [[RootOf(_Z  + _Z a + 2, index = real[1]) < x]] , -3 < a

restart; solve({x^3+x*a+2 > 0, a>-3}, x);

                             1/3              1/3
                           %1        a      %1        a
                      {x < ----- - -----}, {----- - ----- < x}
                             3       1/3      3       1/3
                                   %1               %1

                                              3      1/2
                            %1 := -27 + 3 (3 a  + 81)

restart; solve({x^3+x*a+2 > 0, a<-3}, x);

                             1/3              1/3
                           %1        a      %1        a
                      {x < ----- - -----}, {----- - ----- < x}
                             3       1/3      3       1/3
                                   %1               %1

                                              3      1/2
                            %1 := -27 + 3 (3 a  + 81)

So you originally called `define_external` with typed declarations for each of the arguments, instead of that `MAPLE` keyword argument? And then you edited the resulting generated C file?

You could try the same thing but in that preliminary call to `define_external` wrap REF(...) around the type for the `a3` parameter. Then compare with what you got before, and edit. (The auto-generated C code would declare both an ALGEB and a FLOAT64 variable associated with `a3` I think.)

I've done exactly the thing you want myself in the past, but I won't be able to look at the old files I had until Monday.

In such a scenario you would end up making the following call from Maple like,

  mult( 2., 3., 'mult1' );

using single-right (unevaluation) quotes.

I created this worksheet in Maple 16.02. Hopefully I have properly understood your goals.

Download m16_listcont.mw

You could try using the inert Sum command rather than the active (lowercase) sum command.

Otherwise calling f(x) will return the symbolic summation result of x*cos(x).

Download Sum_vs_sum.mw

The Expression palette only has the active form sum (which displays with a black typeset Sigma as a visual cue). But you can get the inert form Sum in 2D Input (which displays with a gray typeset Sigma) by using command-completion after typing just the letters of "Sum" in 2D Input mode. Then choose the template from the drop-menu that appears.

You wrote that you want "3 decimals".

Do you mean that you want 3 digits in total, or do you mean that you want 3 digits to the right of the decimal point?

I'm going to guess that you want 3 digits to the right of the decimal place, throughout. In that case you can issue this statement, after the call to the Import command.

BTE := map(u->parse(sprintf("%.3f",u)),
           Matrix(BTE, datatype = anything)):