Download colored_caption.mw

evalf(Int(Fg, [0..1, 0..2.2], epsilon=5e-10));
Error, (in evalf/int) Cannot obtain the requested accuracy

evalf(Int(Fg, [0..1, 0..2.2], epsilon=1e-9));
                           8.140784249

evalf(Int(Fg, [0..1, 0..2.2], epsilon=1e-6));

                           8.140784161

newFg := proc(x0,y0)
  if not (x0::numeric and y0::numeric) then
    return 'procname'(args);
  end if;
  if (x0>=0)and(x0<=3) and (y0<=x0+2)
   and (y0>=x0-1) and (y0>=0) and (y0 <=3) then
    return y0*(3-y0)*x0*(3-x0)*(x0+2-y0)*(y0-x0+1);
  else
    return 0;
  end if:
end proc:

evalf(Int(newFg(x,y), [x=0..1, y=0..2.2]));

                                8.140784249

evalf(Int(Int('Fg'(x,y), x=0..1), y=0..2.2, epsilon=1e-9));
  
                              8.140784249

Remove the semicolon that appears before the keyword `local`.

proc(z0, u0, F0);

I mean that semicolon.

If your code is in plaintext then you can run the standalong shell tool mint against it. It has been kept much more up-to-date than has the maplemint command, with regards to newer syntax and Maple language developments.

If you don't want to write out your procedure's source code to a text file (and if you haven't developed it as such, or if running shell scripts is awkward on your platform), and if the rather weak maplemint command cannot handle your procedure, then you can try the method in this old Post. That uses a temporary file to get access to the external mint utility.

It isn't clear to me whether you also want to obtain an explicit result, and whether you want it exact or as a float approximation.

expr:=1/(u+v)^2+4*u*v-1:

ans:=[solve({expr=0, u>0, v>0}, real, explicit)]:
ans:=simplify(combine(evalc(simplify(ans)))):

lprint(ans);

[{u = (2*cos(2/9*Pi)+5/4+3^(1/2)*sin(2/9*Pi))
      *(2*(19-6*cos(4/9*Pi)-12*3^(1/2)*sin(2/9*Pi)
      -6*cos(2/9*Pi))^(1/2)+6*cos(4/9*Pi)
      +3*3^(1/2)*sin(2/9*Pi)-3*cos(2/9*Pi)-2)^(1/2),
  v = 1/4*(2*(19-6*cos(4/9*Pi)-12*3^(1/2)*sin(2/9*Pi)
      -6*cos(2/9*Pi))^(1/2)+6*cos(4/9*Pi)
      +3*3^(1/2)*sin(2/9*Pi)-3*cos(2/9*Pi)-2)^(1/2)}]

evalf(ans);                                      
               [{u = 1.594539597, v = 0.1023339994}]

simplify(eval(expr, ans[1]));                    

                                0

It seems to me that if Digits is "high enough" then one may achieve enough numerical robustness to get reasonably close to 10 digits of accuracy with fewer terms in the nested sums. But also, using the accelerated numerical summation techniques offered by evalf(Sum(...)) computes such results quite bit quicker than does add, for these examples.

On my (fast) 64bit Linux machine, using Maple 2016.2, I can compute J(3,Pi/6) to about 9 digits in 16sec using evalf(Sum(...)) while it takes add about 54sec. For the expression a*b*(-A*J(3,Pi/6)+B*J(6,Pi/6)) it computes with evalf(Sum(...) about 7 digits in about a quarter of the time than does add. Your mileage may vary. Please double-check, as we can all make mistakes.

Download sumproc.mw

A little poking around in the code reveals an undocumented method="alternate" option, which makes Maple 2016's plots:-contourplot command utilize plots:-implicitplot internally (via the internal procedure Plot:-ContourPlot).

restart;
kernelopts(version);

   Maple 2016.2, X86 64 LINUX, Jan 13 2017, Build ID 1194701

plots:-contourplot( 1/(x^2+y^2), x=-2 .. 2, y=-2 .. 2, method="alternate" );

plots:-contourplot( 1/(x^2+y^2), x=-2 .. 2, y=-2 .. 2, method="alternate",
                    contours=[seq(i,i=0.5..4,0.5)] );

Download alternate_contourplot.mw

It would be even nicer if that internal procedure Plot:-ContourPlot could separate out additionally passed options specific to plots:-implicitplot (so that it didn't pass all of argument _rest to plots:-display, but allowed options like say gridrefine, etc, to be passed along to plots:-implicitplot). Or, for consistency with plots:-inequal it might be made to pass along with an optionsimplicit option.

evalf[5]( evalf( expression ) )

will round the result to 5 digits. But the inner call to evalf will still use the current Digits working precision (which you may want done).

Since Maple 2015 all platforms of Maple (Linux, OSX, Windows) have used BLAS and LAPACK functions from the Intel Math Kernel Library (MKL) for hardware floating-point linear algebra. That functionality can be utilized by computations other than just overt calls to LinearAlgebra commands.

The kernelopts(numcpus) setting will not affect the number of cores that may be used by those functions. But the OS enviroment variable OMP_NUM_THREADS will restrict that number of cores. As the system administrator you could set that variable in the two shell scripts maple and xmaple, both found in the bin directory of the Maple installation.

You can verify that it is functioning with the following code:

M:=LinearAlgebra:-RandomMatrix(5000,datatype=float[8]):

CodeTools:-Usage(LinearAlgebra:-Eigenvectors(M)):

The printout of that last command might look like the following on an otherwise unloaded 4-core 64bit Linux machine with that variable unset (or set to 4):

memory used=0.75GiB, alloc change=0.78GiB, cpu time=3.39m, real time=51.59s, gc time=32.00ms

The "cpu time" reported is the sum from all threads. Note that it is about 4 times greater than the "real time", which essentially means that four cores were in heavy use. The Linux utility `top` showed a load average of as high as about 3.40 while that was computing.

Now, with that environment variable set to 1 (in the maple shell script) the printout I see is like this:

memory used=0.75GiB, alloc change=0.78GiB, cpu time=68.50s, real time=68.56s, gc time=32.00ms

In that case top showed a load average no higher than about 1.05. And the "real time" matches the "cpu time" which is the sum for just the single thread.

The reason that the 4-thread case "real time" was not so very much faster than the single-thread case "real time" is that the nonsymmetric eigenvector algorithm is not so easily parallelized effectively throughout as is, say, matrix-matrix multiplication. But that's rather incidental to this illustration.

You can also check the value of a OS variable, within Maple, using the getenv command. Eg,

getenv("OMP_NUM_THREADS");

Regarding what Carl mentioned about kernelopts(numcpus=n) only working once, as an initial command. That's good news for your situation, since if you set it within a system-wide Maple initialization file then it could hold forcibly throughout your users' sessions.

for a from 1 to 20 do
  printf("%s\n",sprintf("%a",[op(numtheory:-divisors(a))])[2..-2]);
end do:

1
1, 2
1, 3
1, 2, 4
1, 5
1, 2, 3, 6
1, 7
1, 2, 4, 8
1, 3, 9
1, 2, 5, 10
1, 11
1, 2, 3, 4, 6, 12
1, 13
1, 2, 7, 14
1, 3, 5, 15
1, 2, 4, 8, 16
1, 17
1, 2, 3, 6, 9, 18
1, 19
1, 2, 4, 5, 10, 20

Or, if you don't want to reproduce it as a triangle,

seq(op(numtheory:-divisors(a)), a=1..20);

1, 1, 2, 1, 3, 1, 2, 4, 1, 5, 1, 2, 3, 6, 1, 7, 1, 2, 4, 8, 1, 3, 9, 1, 2, 5, 10, 1, 11, 1, 2, 3, 4, 6, 12, 1, 13, 1, 2, 7, 14, 1, 3, 5, 15, 1, 2, 4, 8, 16, 1, 17, 1, 2, 3, 6, 9, 18, 1, 19, 1, 2, 4, 5, 10, 20

The OP has written that, "The format of the input shouldn't matter."

But of course it can matter. Symbolic integration of expressions containing float-ing point approximations is not always a great idea. In this case alternatives include 1) floating-point numeric integration of the expression containing floats, 2) tricky, extra effort to get symbolic integration of the expression containing floats to behave better, and as mentioned 3) symbolic integration of the expression with exact rather than floating-point coefficients.

(This site doesn't render the worksheet below very nicely. Sorry.)
 

Download hypotrochoid_2.mw

Make your batch file print (whatever it thinks is) the PATH, when it runs successfully in a command shell.

Then adjust it to set PATH (for itself) explicitly to that very same thing.

[edit] If it relied on the current working directory (when functioning in cmd) then I suggest that 1) that is poor programming style, and 2) adjust the PATH anyway, but make it all fully qualified rather than relative.

Then try running it from Maple by escaping to a shell, using ssystem or system.

Below I give a procedure presubsuper which allows you to build the so-called atomic identifier (aka typeMK) for a pre-sub-superscripted name.

I also show that an unevaluated function call like, say, Iso(U,92,238) can be made to be automatically prettyprinted using that presubsuper procedure, by having its own so-called print-slash extension to the printing mechanism.

(This whole business could also be done, probably quite gracefully, using the more modern Maple object mechanism. I won't go there right now, but it would be fun to see how much physical chemistry or nuclear physics could be incorporated into static exports of such objects...).

Download presubsuper.mw

The DocumentTools package can be used to programatically generate GUI Tables that are formatted like a report.

The DocumentTools:-Tabulate command provides an easy way to do that, though with ease-of-use comes less flexibility.

The subpackage DocumentTools:-Layout (and, less so here, DocumentTools:-Components) contains lower level commands with more flexibility. (It's what Tabulate uses). The results of the Layout commands can be saved to a new worksheet, opened in a new GUI tab, or embedded within the current worksheet (which you could also subsequently copy&paste).

The sticking point is your desire for LaTeX. The GUI's File->Export as... main menu item will produce LaTeX source for "the whole worksheet", as you probably know. It's a slight drawback that it requires use of one of Maple's own .sty files (bundled with the product). But the thorny bit is that support for such LaTeX export of GUI Tables is not good.

Let's call your AND(A->B, B->C) the statement P. And let's call your A->C the statement Q. It is the case that Q follows from P.

But you seem to be under the impression that Q is the only statement that follows from P. But it isn't. It's also not the case that P follows from Q, and so they are not equivalent. So what's your rationale for thinking that Q should be, say, the obvious or useful statement that follows from P?

It happens that Q does not contain a reference to B. Is that your reason want Q, because in that way it is simpler than P? I'm going to proceed along those grounds.

with(Logic):

p := (A &implies B) &and (B &implies C):

BooleanSimplify( eval(p, B=false) &or eval(p, B=true) );

                                  C &or &not(A)

# And you ought to be able to recognize the above as being
# equivalent to A->C

BooleanSimplify( A &implies C );

                                  C &or &not(A)