I was expanding an expressions, and found that Maple expands trig also. Then found there is a way to turn that off. Which is great. I tested it in my worksheet and it works. But when I put the same code inside my module, I get an error.  It seems like some scoping issue which I do not understand.

Here is a MWE

restart;
expr:=(1+x)*sin(3*x+k);
forget(expand);
expand(expandoff());
expandoff(cos,sin,exp);
F:=expand(expr);
forget(expand);

which gives 

Which does what I want. But inside a proc, the code fails

foo:=proc(expr)
local F;

forget(expand);
expand(expandoff());
expandoff(cos,sin,exp);
F:=expand(expr);
forget(expand);

end proc;

And now when calling it as 

expr:=x*sin(3*x+k);
foo(expr)

What Am I doing wrong? And how to make it work? I need to prevent expand() from expanding these functions. Help says that expand has memory table, and I want to clear that before and after doing this, so it does not affect later code.

Maple 2021.1

Update

I just found out, if I add a restart before defining my function, then the error goes away

restart;
expr:=(1+x)*sin(3*x+k);
forget(expand);
expand(expandoff());
expandoff(cos,sin,exp);
F:=expand(expr);
forget(expand);

restart;  # had to add this. But why??
foo:=proc(expr)
local F;

forget(expand);
expand(expandoff());
expandoff(cos,sin,exp);
F:=expand(expr);
forget(expand);
end proc;

#
expr:=(1+x)*sin(3*x+k);
foo(expr)

#no error. now it works

I need this to work repeatedly inside a module, so I can't do restart each time ofcourse like the above.

Even if I do restart before defining the function, next time I call it, it will fail:

restart; 
foo:=proc(expr)
local F;

forget(expand);
expand(expandoff());
expandoff(cos,sin,exp);
F:=expand(expr);
forget(expand);
end proc;

#
expr:=(1+x)*sin(3*x+k);
foo(expr); #OK
foo(expr); #FAILED

Very strange. 

I can't find how to use Maple structured type, to check for say sin(x) and say sin(x)^2 without having to duplicate the code and make a structured type for each of the two cases. An example will explain.

I need to check if expression is of this form   m*sin(anything)^n*cos(anything)^r  Where in this example below, m,n,r can be integer or rational.     

The problem is that 'specfunc'(sin)^Or(integer,rational) will not match sin(x) but will only match if sin(x) is raised to an actual power different from default 1.

So I have to duplicate the check below, by writing Or('specfunc'(sin),'specfunc'(sin)^Or(integer,rational) and the same for cos(x). I am trying to avoid all this duplication, because as the structured type becomes more involved, it will hard to read and work with like this.

Is there a way to eliminate this? In Mathematica for example, this is done using the pattern   x_. where the little dot at the end there, allows for zero of more. So for the above, it will be  Sin[x_]^n_. and this will match Sin[anything] and also match Sin[anything]^2 

I know it is possible to use patmatch in Maple to do this, but is it possible without using pathmatch and just using structured types? as I am trying to do everything without having to use patmatch now.

restart;
my_type:=''`*`'( { Or('specfunc'(sin),'specfunc'(sin)^Or(integer,rational)),
                   Or('specfunc'(cos),'specfunc'(cos)^Or(integer,rational)),
                   Or(integer,rational)})';
type(3*sin(x)^2*cos(x)^3,my_type);
type(sin(x)^2*99*cos(x),my_type);
type(sin(x)*cos(x),my_type);
type(cos(x)*sin(x)^(1/2),my_type);

gives

btw, the help page for structured type mentiones zero or more occurances of but do not know how to do this for the above example

Ok, I think I am starting to get the hang of this. So in Maple, structured types is like a pattern in Mathematica. To find some subexpression one needs to first define a structured type which match that subexpression, and then use  select(type,.....).  

This works well so far (but it is not as easy as setting up a pattern).

But one small problem is that select() starts looking at the operands of the expression to look for a match.

So if the whole expression itself matches the structured type, it will not detect the whole expression, since select goes over each operand, missing that the whole thing actually matches the type.

May be an example helps shows what I mean. I want to find if an expression has cos(anything)*sin(anything) so I made a structured type for this 

mytype_3 :=  ''`*`'( {'specfunc'(cos),'specfunc'(sin)})';

btw, I do not know if I should use `&*` or '`*`' but that is a side point, I'll try to find this out.   

Now I want to use the above to check if expression has the same "structured type", or "pattern". The expression is expr:=cos(x)*sin(x); clearly it matches it. But since select looks at the operands, it will only see cos(x) by itself, and then sin(x) by itself and hence not find the structured type. 

restart;
mytype_3 :=  ''`*`'( {'specfunc'(cos),'specfunc'(sin)})';
expr:=cos(x)*sin(x);
type(expr,mytype_3);  # true
select(type, expr, mytype_3); # does not work, does not find it.

Since I am doing this in code, and I do not know what the expression is, I think I have to now do the following 

restart;
mytype_3 :=  ''`*`'( {'specfunc'(cos),'specfunc'(sin)})';
expr:=cos(x)*sin(x);
if type(expr,mytype_3) then
   print("The whole expression is a match! nothing to do. no need to use select");
else
   select(type, expr, mytype_3);
fi;

Which is OK. I can do this, But it will be nice if there was a way to have select (or another function like it) starts at the top level before looking at the operands?  

How do others handle such cases? does the above sound like an OK solution to this?

I am learning how to use select with my own types defined, to find parts of expression. This is instead of using patmach.

For example, given   3+x^2*sin(x) and then I want to find any POLYNIMAL*sin function, if present. So I did the following

restart;
expr_1:=3+x^2*sin(x):
mytype_1 := `&*`( polynom(And(algebraic, satisfies(u -> not has(u, I))),x),specfunc('sin')):
select( z->type(z,mytype_1),expr_1);

Which works. Maple returned 

The problem is that if I change the order of multiplication, and also at same time change the polynomial by adding one more term, it no longer works!

I have no idea why. It seems Maple rememebrs something.  Here is a screen shot, followed by plain text code.

code

restart;
expr_1:=3+(1+x)*sin(x):
mytype_1 := `&*`( polynom(And(algebraic, satisfies(u -> not has(u, I))),x),specfunc('sin')):
select( z->type(z,mytype_1),expr_1);
expr_1:=3+sin(x)*(1+x):
select( z->type(z,mytype_1),expr_1);

#change polynomial but keep same order, it works
expr_2:=3+(1+x+x^2)*sin(x):
select( z->type(z,mytype_1),expr_2);

#change order BUT keep same polynomial, it works
expr_3:=3+sin(x)*(1+x+x^2):
select(z->type(z, mytype_1),expr_3);

#keep same order as above, but change polynomial, now it does not works
expr_4:=3+sin(x)*(1+x+x^2+x^4):
select(z->type(z, mytype_1),expr_4);

#keep same order as first one  but change polynomial, it does not work
expr_5:=3+(1+x+x^2+x^4)*sin(x):
select(z->type(z, mytype_1),expr_5);

#keep same order as first one but change polynomial back to what it was, now it works
expr_6:=3+(1+x)*sin(x):
select(z->type(z, mytype_1),expr_6);

What Am I doing wrong?

Maple 2021.1

I need to check if an expression is polynomial in x but with coefficients that are either symbolic, or do not include the complex numebr I.

The problem is that maple considers integers and reals complex also.   

type(1,complex) gives true. so I can't use

restart;
type(1+2*x,polynom(Not(complex),x))

Since this gives false. 

I could instead list all the types to be accepted using Or, like this

restart;
type(1+2*x,polynom(Or(float,realcons,rational,integer),x))

But I might overlook something if I have to enumerate every type accepted. It is easier to just exclude complex numbers. 

What is the correct way to tell Maple to check if expression is polynomial in x where coefficients do not have the complex I in them? It it ok if the coefficient are any other numeric value, or a known Maple constant, or a parameter (symbol). I just want to exclude complex numbers.

I know I could do this

restart;
the_poly:=1+2*x;
if not has(the_poly,I) then
   type(the_poly,polynom(anything,x))
else
   print("not allowed");
fi;

But I wanted to learn how to make a type which excludes complex numbers.

Maple 2021.1