## 2453 Reputation

14 years, 69 days

## a similar experience...

Yes, this thread reports a similar experience and some possible workaround.

## stepwise solution...

If you mean the steps used by Maple, the detail of information that you could get is varied, possibly huge, depending on your needs. This is one example of what can be observed:

```> kernelopts(opaquemodules=false):
> infolevel[IntegrationTools]:=3:
> trace(IntegrationTools:-Definite:-Integrators:-LookUp):
>
> int(exp(-xi^2*b^2)*cos(xi^2*a*t)*cos(xi*x), xi = 0 .. infinity) assuming positive;
Definite Integration:   Integrating expression on xi=0..infinity
Definite Integration:   Using the integrators [distribution, piecewise, series, o, polynomial, ln, lookup, cook, ratpoly, elliptic, elliptictrig, meijergspecial, improper, asymptotic, ftoc, ftocms, meijerg, contour]
{--> enter Main, args = exp(-xi^2*b^2)*cos(xi^2*a*t)*cos(xi*x), xi, 0, infinity
, opts, [false, FAIL]
look := Table
look := Algebraic
look := IntegralTransform
IntegralTransform LookUp Integrator:   Integral might be a fouriercos transform with expr=cos(xi^2*a*t)*exp(-xi^2*b^2) and s=x.
2   2
1/2            b~  x~
answer := 1/2 Pi    exp(- -----------------)
2   2     4
4 (a~  t~  + b~ )
2
a~ t~        a~ t~ x~         /    2   2     4 1/4
cos(-1/2 arctan(-----) + -----------------)  /  (a~  t~  + b~ )
2          2   2     4   /
b~      4 (a~  t~  + b~ )
LookUp Integrator:   the specified integral found with the IntegralTransform look up method.
<-- exit Main (now in IntegrationTools:-Definite:-Main) = [true, 1/2*Pi^(1/2)/(
a^2*t^2+b^4)^(1/4)*exp(-1/4*b^2*x^2/(a^2*t^2+b^4))*cos(-1/2*arctan(a*t/b^2)+1/4
*a*t*x^2/(a^2*t^2+b^4))]}
Definite Integration:   Method lookup succeeded.
Definite Integration:   Finished sucessfully.

2  2                                       2
1/2           b  x                        a t        a t x
Pi    exp(- --------------) cos(-1/2 arctan(---) + --------------)
2  2    4                    2         2  2    4
4 (a  t  + b )                  b      4 (a  t  + b )
1/2 ------------------------------------------------------------------
2  2    4 1/4
(a  t  + b )

```

## No keyboard shortcut to execute...

No, the Standard GUI does not have a keyboard shortcut to execute the entire worksheet. The design of this GUI emphasizes the usage of the mouse.

## post-processor...

I think that you are asking for a post-processor facility as \$Post in Mathematica, see here. I am not aware of something like that in Maple.

## The meaning of function...

There are two different meanings of the word function here. In mathematical sense, x-y may be a function (value) by e.g. (x,y)->x-y. But in Maple's computational sense, `x-y` is not a function, but an expression of type `+`:

```> type(f(x,y),function);
true
> type(x-y,function);
false
> whattype(x-y);
+
```

What currently is not available in stock Maple is an extension/overload of diff that admits as second argument an expression of type `+`. But a wrapper of diff for this purpose could easly be written.

Besides 2-D language quirks, the help page ?names warns about using names that start with an underscore:

Names that start with an underscore (with the exception of _Env) are used as global variable names by Maple and are effectively reserved for use by library code. Do not use a symbol beginning with an underscore.

## convert the black arrow to command...

A rather simple method that works for converting Documents with these arrow 2-D objects into the underlying 1-D constructs/commands is the export to a Maple Input .mpl file. It has diverse limitations/bugs though, so that it might not be very useful for a user not knowing enough the 1-D language. A complementary method is selecting the Document and pasting into a text editor.

## the origin of the out of memory error...

Several internal routines of the package DifferentialAlgebra make external calls to a compiled C library. So, missing additional information, my primary candidate for the origin of this out of memory error is the external library. Another clue comes from the memory figures that you have given. The actual code would be needed for further investigation.

## frontend default...

The origin of the error is that frontend does not freezes products by default, a third argument is used for this purpose, see ?frontend > Parameters. So, you may try something like:

```> frontend(coeff, [k, U[x]*U[x, x]],[{},{}]);
0
```

## evaluate using method = _d01amc...

I get quickly:

```> evalindets(HE,specfunc(anything,Int),x->int(op(x),method = _d01amc));
[-0.004579906646    -0.2072734459    -0.007934121876]
[                                                   ]
[ -0.2072734459     -11.86633928      -4.760461971  ]
[                                                   ]
[-0.007934121876    -4.760461971      -8.453773359  ]
```

## help associated with a package...

I think that, as implemented, the only association of help pages with packages is through the choice of their indexing data, as shown here.

## Extending the integration database...

One thing that might be easier and you could try is the (poorly documented) extension mechanism for indefinite integration, as used in this toy example, where the integral for g(u) is added to the system:

```
> int(g(u),u=0..1);
1
/
|
|   g(u) du
|
/
0
> restart:
> `int/g`:=proc(x)
> op(1,x)^2:
> end proc:
> int(g(u),u);
2
u
> int(g(u),u=0..1);
1

```

## ambiguous bug...

Certainly, this behavior arises in the conversion to rational form of the "equation" part only here:

```> showstat(solve,73..76):
solve := proc(eqs::{`and`, `not`, `or`, algebraic, relation(algebraic), {list, set}({`and`, `not`, `or`, algebraic, relation(algebraic)})}, vars::{algebraic, {list, set}(algebraic), {list, set}(equation)} := NULL, {[AllSolutions, allsolutions]::truefalse := FAIL, [ConditionalSolutions, conditionalsolutions]::truefalse := FAIL, [DropMultiplicity, dropmultiplicity]::truefalse := FAIL, [Explicit, explicit]::{posint, truefalse} := FAIL, [MaxSols, maxsols]::{posint, pos_infinity} := FAIL, [SolveOverReals, solveoverreals, real]::truefalse := FAIL, [SymbolicSolutions, symbolicsolutions, symbolic]::truefalse := true, [TryHard, tryhard]::truefalse := FAIL, [UseAssumptions, useassumptions]::truefalse := false, domain::name := ':-default', parameters::{list, set} := {}, parametric::{truefalse, identical(lazy,proviso,full)} := false, split::truefalse := false}, \$)
local d, i, pw, qq, r, rt, s, sol, t, tmp, RO, T2, TT, XX, XX0, YY, YY0, Args, exArgs, newr, nosp, r_conds, r_eqs, teqns, tvars, backsubs, discarded, lmaxsols, oldmaxsols, Solutions_are_sets, Variables_in_list, TrigRO;
global `solve/split`, _X, identity, _SolutionsMayBeLost, `solve/SubsRootOfPower`, _MaxSols;
...
73     if hastype(Args[1],'float') then
74       exArgs := Args[1];
75       exArgs := subsindets(exArgs,`^`,z -> op(1,z)^convert(op(2,z),':-rational'));
76       exArgs := convert(exArgs,':-rational',':-exact');
...
```

Which appears in the code of solve since Maple 10. Now ?solve > Parameters states for "variables" (set/list of) names, not functions. In this sense, it could be said that functions are not admissible. And this piece of code makes sense only in this context. However, the type check allows functions...

So, there is a bug (or more than one), but its nature is ambiguous.

## an option using alias...

An option using an alias for the polar form:

```> alias(j=polar(1,2*Pi/3)):
> eq:=(evalc=(x->x))~([j,j^2]);
1/2                     1/2    2
eq := [- 1/2 + 1/2 I 3    = j, - 1/2 - 1/2 I 3    = j ]
> s:=[solve(z^3=lambda^3, z)];
1/2                          1/2
s := [lambda, (- 1/2 + 1/2 I 3   ) lambda, (- 1/2 - 1/2 I 3   ) lambda]
> subs(eq,s);
2
[lambda, j lambda, j  lambda]
```

## The reverse...

So, see ?CodeGeneration,Fortran .

 5 6 7 8 9 10 11 Last Page 7 of 29
﻿