@Ratch The Java based interface came with Maple 9. And I believe the 2D-input was introduced at the same time (not earlier for sure). Then Maple 9.5, 10, 11, 12, 13, and now 14. So that amounts to 7 levels.

@Ratch The Java based interface came with Maple 9. And I believe the 2D-input was introduced at the same time (not earlier for sure). Then Maple 9.5, 10, 11, 12, 13, and now 14. So that amounts to 7 levels.

@acer By clearing the remember table of `is/internal` and also removing option remember, FAIL is the result when Digits is raised to 300, but not with Digits = 30. But the procedure still remembers!

If only the remember table is removed the answers remain true.

restart;
z:=3.1415926535897932384626433:
is(Pi<z);
                              true
lprint(op(4,eval(`is/internal`)));
table( [( Pi < 3.1415926535897932384626433 ) = true, ( 0., RealRange(Open(-3.1415926535897932384626433+Pi), infinity) ) = true ] )
forget(`is/internal`);
op(4,eval(`is/internal`));
`is/internal`:=subsop(3=NULL,eval(`is/internal`)):
Digits:=30:
is(Pi<z);
                              true
Digits:=300:
is(Pi<z);
                              FAIL
lprint(op(4,eval(`is/internal`)));
table( [( Pi < 3.1415926535897932384626433 ) = FAIL, ( 0., RealRange(Open(-3.1415926535897932384626433+Pi), infinity) ) = FAIL ] )

@acer By clearing the remember table of `is/internal` and also removing option remember, FAIL is the result when Digits is raised to 300, but not with Digits = 30. But the procedure still remembers!

If only the remember table is removed the answers remain true.

restart;
z:=3.1415926535897932384626433:
is(Pi<z);
                              true
lprint(op(4,eval(`is/internal`)));
table( [( Pi < 3.1415926535897932384626433 ) = true, ( 0., RealRange(Open(-3.1415926535897932384626433+Pi), infinity) ) = true ] )
forget(`is/internal`);
op(4,eval(`is/internal`));
`is/internal`:=subsop(3=NULL,eval(`is/internal`)):
Digits:=30:
is(Pi<z);
                              true
Digits:=300:
is(Pi<z);
                              FAIL
lprint(op(4,eval(`is/internal`)));
table( [( Pi < 3.1415926535897932384626433 ) = FAIL, ( 0., RealRange(Open(-3.1415926535897932384626433+Pi), infinity) ) = FAIL ] )

There is still an rtable inside the procedure that you want to translate.

And also convert is not recognized:

doesnotworkeither := proc(p) convert(p,string) end proc;

CodeGeneration[C](doesnotworkeither);
Warning, the function names {convert} are not recognized in the target language
double doesnotworkeither (double p)
{
  return(convert(p, string));
}

There is still an rtable inside the procedure that you want to translate.

And also convert is not recognized:

doesnotworkeither := proc(p) convert(p,string) end proc;

CodeGeneration[C](doesnotworkeither);
Warning, the function names {convert} are not recognized in the target language
double doesnotworkeither (double p)
{
  return(convert(p, string));
}

@Joe Riel My last solution doesn't cover cases like

aa:=a:
plot(aa*sin(x),x=0..b) assuming a=-2, b=7;

which clearly is not acceptable.

So I returned to the first version handling temporary assignments by actually assigning the parameters before evaluating the first argument to `assuming`.

However, for the first version to handle vectors and matrices  op(eval(res,par)) in the last line before 'end proc' replaces op(eval(res)). The eval was inserted to get procedural output (e.g. from dsolve/numeric) evaluated.

Probably more problems will turn up.

p:=subsop(3=overload,eval(`assuming`)):
`assuming`:=overload(
       [
          proc(x::uneval,par1::list({equation,set(equation),list(equation)})) option overload;
           local par,res;
           par:=ListTools:-Flatten(evalindets(par1,set,[op]));
           assign(par);
           try
            res:=eval(x);
           catch:
            error;
           finally  
            map(unassign@lhs,eval(par,2));
           end try;
           op(eval(res,par))
          end proc,
          eval(p)
        ]
):

@Joe Riel The following doesn't split mixed assumptions and temporary assignments, but does handle both classes.

restart;
p:=subsop(3=overload,eval(`assuming`)):
`assuming`:=overload(
     [
        proc(x::uneval,a::list({equation,set(equation),list(equation)}),$) option overload;
            op(eval(x,ListTools:-Flatten(evalindets([a], set, [op]))));
        end proc,
        eval(p)
      ]
):
plot(a*sin(x),x=0..b) assuming {a=-2,b=7};
param := {a=2,b=7}:
plot(a*sin(x),x=0..b) assuming param;
plot(a*sin(x),x=0..b) assuming a=-2,b=7;
plot(a*sin(x),x=0..b) assuming [a=-2],{b=Pi};
simplify(sqrt((x*y)^2)) assuming x>0,y>0;
int(exp(a*t),t=0..infinity) assuming a<0;

#Interestingly, this one works (with or without overloading), but in the result b is not replaced by 2:

int(exp(b*a*t),t=0..infinity) assuming b=2,a<0;

#This one doesn't work, because the main procedure doesn't accept sets or lists of properties.

int(exp(b*a*t),t=0..infinity) assuming {a<0,b=2};

@acer You are right. 'Using' sounds better.

And I have to get used to using the 'use' statement. I had almost forgotten its existence.

Unfortunately, with

param:={a=-2,b=7};

neither one of
use param in plot(a*sin(x),x=0..b) end use;
use op(param) in plot(a*sin(x),x=0..b) end use;

works. It is convenient to have the parameters defined as a set or list since 'eval' doesn't accept a sequence, as does subs.

@pchin Thanks to Joe Riel and pchin. The wikipedia link about reentrancy is difficult reading, by I think I got the gist of it.

@pchin Thanks to Joe Riel and pchin. The wikipedia link about reentrancy is difficult reading, by I think I got the gist of it.

@pvrbik I always use 1d-input (also known as Maple Input), so that is why.

I tried doing the whole thing with 2d-input and the result was that the input in the tex-file looked like this:

\begin{mapleinput}
\mapleinline{active}{2d}{for i to 10 do f := proc (x) options operator, arrow; x^2 end proc; f(x) end do; 1}{\[\]}
\end{mapleinput}

but nothing of that turned up in the dvi-file, only the 10 results.

@pvrbik I always use 1d-input (also known as Maple Input), so that is why.

I tried doing the whole thing with 2d-input and the result was that the input in the tex-file looked like this:

\begin{mapleinput}
\mapleinline{active}{2d}{for i to 10 do f := proc (x) options operator, arrow; x^2 end proc; f(x) end do; 1}{\[\]}
\end{mapleinput}

but nothing of that turned up in the dvi-file, only the 10 results.

test.pdf

@pvrbik 

No images. See the file test.pdf which I produced from your Maple code. It should be attached.

test.pdf

@pvrbik 

No images. See the file test.pdf which I produced from your Maple code. It should be attached.