nm - Questions - MaplePrimes

where is tools->options in Maple 2025?...

Asked: nm 11373 Product: Maple 2025

March 26 2025

1 2

Where is the tools->options menu in Maple 2025? I can't find it.

This is how it looks in Maple 2024:

I open new worksheet, but it is still uses math for input. I wanted to change that like I did in Maple 2024 to use Maple notation.

But do not see any options under tools in Maple 2025:

Windows 10.

bug report (Maple 2024). Adding Physics:...

Asked: nm 11373 Product: Maple 2025

March 25 2025

1 4

Does this happen in Maple 2025?

Why when adding Physics:-Setup(assumingusesAssume = true): now Maple gives internal exception which can not even be cought?

>	interface(version);

>	Physics:-Version();

>

restart;

>	ode:=diff(y(x),x) = (ln(y(x))^2+2_C1)^(1/2)y(x); sol:=y(x) = exp((-2*_C1)^(1/2))

>	odetest(sol,ode) assuming positive;

>

restart;

>	ode:=diff(y(x),x) = (ln(y(x))^2+2_C1)^(1/2)y(x); sol:=y(x) = exp((-2*_C1)^(1/2)) ;

>	Physics:-Setup(assumingusesAssume = true):

>	odetest(sol,ode) assuming positive;

Error, (in type/evalc/cx) too many levels of recursion

>

restart;

>	ode:=diff(y(x),x) = (ln(y(x))^2+2_C1)^(1/2)y(x); sol:=y(x) = exp((-2*_C1)^(1/2)) ;

>	Physics:-Setup(assumingusesAssume = false):

>	odetest(sol,ode) assuming positive;

Download ode_test_with_physics_march_25_2025.mw

how to make simplify run through same co...

Asked: nm 11373 Product: Maple 2024

March 24 2025

3 7

Update

Also, is there a way to disable the use of remember tables permanently in Maple? This causes me so much trouble and It is cause of why Maple behave differently at different times.

Help shows how to do it if one knows the name of the module or procedure. But Maple has 1000's of these. There does not seem to be a way to tell maple

forget(all)

and have set once. (may be something I can put in the ini file, to disable this feature).

At the end of help it says

"As a special case, specifying f as an empty range allows for selective clearing of remember table entries from all remember tables in the system. This requires a second argument, to indicate which entries to clear. For example, forget(..,x), which will clear all remembered entries in the system that reference x. "

But what is x in the above?? If I do forget(..) it does not work.

---- end update ------------------------------------------------------------------------------------------------------------------

Adding printlevel:=20, I see simplify generate/runs through longer code the first time. The second time calling the same exact simplify code, now it shows it runs through much shorter code.

I am assuming printlevel is behaving correctly each time.

This must be due to cache simplifies keeps somewhere, or some internal settings it updates from first time and this is what causes it to do shorter run second time.

Without doing restart, how can make force simplify to run through same code it did the first time and each time? i.e. as if it was called the very first time each time?

I tried forget, but it is not doing anything.

Here is worksheet. The code is simply this

printlevel:=0;
restart;
printlevel:=20;
simplify(3*x^3/x+sin(x^2)/4);  #long printout

simplify(3*x^3/x+sin(x^2)/4);  #short printout

printlevel:=0;
forget(simplify,forgetpermanent = true,reinitialize=true);

printlevel:=20;
simplify(3*x^3/x+sin(x^2)/4); #still same short printout

So there is something else needs to be cleared? Only way to get the long printout is to do restart. but ofcourse I can't do restart in middle of a loop.

I tried gc() also, but had no effect.

What other commands are there to do this? I do use Physics and it is on my libname.

>	printlevel:=0;

>

restart;

>	interface(version);

>	Physics:-Version();

>

libname;

$"C:\Users\Owner\maple\toolbox\2024\Physics Updates\lib", "C:\Program Files\Maple 2024\lib"$

>	printlevel:=20;

>	simplify(3*x^3/x+sin(x^2)/4);

{--> enter sin, args = x^2

{--> enter \`type/SymbolicInfinity\`, args = x^2

<-- exit \`type/SymbolicInfinity\` (now in sin) = false}

{--> enter \`sin/normal\`, args = x^2

{--> enter \`tools/sign\`, args = x^2

<-- exit \`tools/sign\` (now in \`sin/normal\`) = 1}

<-- exit \`sin/normal\` (now in sin) = sin(x^2)}

{--> enter \`trig/linear_in_Pi\`, args = x^2

{--> enter collect, args = x^2, Pi

<-- exit collect (now in \`trig/linear_in_Pi\`) = x^2}

<-- exit \`trig/linear_in_Pi\` (now in sin) = x^2}

<-- exit sin (now at top level) = sin(x^2)}

{--> enter simplify, args = 3*x^2+(1/4)*sin(x^2)

{--> enter \`simplify/do\`, args = 3*x^2+(1/4)*sin(x^2)

{--> enter \`tools/membertype\`, args = Not(Or(algebraic, list, set, relation, range)), 3*x^2+(1/4)*sin(x^2)

<-- exit \`tools/membertype\` (now in \`simplify/do\`) = false}

{--> enter \`simplify/check_constant\`, args = 3*x^2+(1/4)*sin(x^2)

<-- exit \`simplify/check_constant\` (now in \`simplify/do\`) = false}

{--> enter \`type/ratpoly\`, args = 3*x^2+(1/4)*sin(x^2), complex(numeric)

<-- exit \`type/ratpoly\` (now in \`simplify/do\`) = false}

{--> enter \`simplify/recurse\`, args = 3*x^2+(1/4)*sin(x^2)

<-- exit \`simplify/recurse\` (now in \`simplify/do\`) = 3*x^2+(1/4)*sin(x^2)}

${3*x^2+(1/4)*sin(x^2)}$

{--> enter \`simplify/check_constant\`, args = 3*x^2+(1/4)*sin(x^2)

<-- exit \`simplify/check_constant\` (now in \`simplify/do\`) = false}

{--> enter \`simplify/getkernels\`, args = 3*x^2+(1/4)*sin(x^2), false

${x^2, (1/4)*sin(x^2), 3*x^2+(1/4)*sin(x^2), sin(x^2)}$

<-- exit \`simplify/getkernels\` (now in \`simplify/do\`) = {x^2, (1/4)*sin(x^2), 3*x^2+(1/4)*sin(x^2), sin(x^2)}}

${x^2, (1/4)*sin(x^2), 3*x^2+(1/4)*sin(x^2), sin(x^2)}$

{--> enter \`simplify/getinds\`, args = {x^2, (1/4)*sin(x^2), 3*x^2+(1/4)*sin(x^2), sin(x^2)}

<-- exit \`simplify/getinds\` (now in \`simplify/do\`) = {power, trig}}

{--> enter \`simplify/sortinds\`, args = {power, trig}

<-- exit \`simplify/sortinds\` (now in \`simplify/do\`) = [trig, power]}

{--> enter \`simplify/check_constant\`, args = 3*x^2+(1/4)*sin(x^2)

<-- exit \`simplify/check_constant\` (now in \`simplify/do\`) = false}

{--> enter \`simplify/getkernels\`, args = 3*x^2+(1/4)*sin(x^2), false

${x^2, (1/4)*sin(x^2), 3*x^2+(1/4)*sin(x^2), sin(x^2)}$

<-- exit \`simplify/getkernels\` (now in \`simplify/do\`) = {x^2, (1/4)*sin(x^2), 3*x^2+(1/4)*sin(x^2), sin(x^2)}}

{--> enter \`type/ratpoly\`, args = 3*x^2+(1/4)*sin(x^2), extended_numeric

<-- exit \`type/ratpoly\` (now in \`simplify/do\`) = false}

{--> enter \`simplify/getinds\`, args = {x^2, (1/4)*sin(x^2), 3*x^2+(1/4)*sin(x^2), sin(x^2)}

<-- exit \`simplify/getinds\` (now in \`simplify/do\`) = {power, trig}}

{--> enter \`simplify/sortinds\`, args = {power, trig}

<-- exit \`simplify/sortinds\` (now in \`simplify/do\`) = [trig, power]}

{--> enter \`simplify/power_exp\`, args = 3*x^2+(1/4)*sin(x^2)

<-- exit \`simplify/power_exp\` (now in \`simplify/do\`) = 3*x^2+(1/4)*sin(x^2)}

{--> enter \`simplify/check_constant\`, args = 3*x^2+(1/4)*sin(x^2)

<-- exit \`simplify/check_constant\` (now in \`simplify/do\`) = false}

{--> enter \`simplify/do/content\`, args = 3*x^2+(1/4)*sin(x^2)

<-- exit \`simplify/do/content\` (now in \`simplify/do\`) = 3*x^2+(1/4)*sin(x^2)}

{--> enter \`simplify/recurse_on_constants\`, args = 3*x^2

<-- exit \`simplify/recurse_on_constants\` (now in \`simplify/do\`) = 3*x^2}

{--> enter \`simplify/recurse_on_constants\`, args = (1/4)*sin(x^2)

<-- exit \`simplify/recurse_on_constants\` (now in \`simplify/do\`) = (1/4)*sin(x^2)}

{--> enter \`simplify/recurse_on_constants\`, args = 3*x^2+(1/4)*sin(x^2)

<-- exit \`simplify/recurse_on_constants\` (now in \`simplify/do\`) = 3*x^2+(1/4)*sin(x^2)}

<-- exit \`simplify/do\` (now in simplify) = 3*x^2+(1/4)*sin(x^2)}

{--> enter simplify, args = 3*x^2+(1/4)*sin(x^2), size, applysimplifysize = false

{--> enter \`simplify/do\`, args = 3*x^2+(1/4)*sin(x^2), size

${3*x^2+(1/4)*sin(x^2)}$

<-- exit \`simplify/do\` (now in simplify) = 3*x^2+(1/4)*sin(x^2)}

<-- exit simplify (now in simplify) = 3*x^2+(1/4)*sin(x^2)}

<-- exit simplify (now at top level) = 3*x^2+(1/4)*sin(x^2)}

>	simplify(3*x^3/x+sin(x^2)/4);

value remembered (at top level): sin(x^2) -> sin(x^2)

{--> enter simplify, args = 3*x^2+(1/4)*sin(x^2)

value remembered (in simplify): \`simplify/do\`(3*x^2+(1/4)*sin(x^2)) -> 3*x^2+(1/4)*sin(x^2)

{--> enter simplify, args = 3*x^2+(1/4)*sin(x^2), size, applysimplifysize = false

<-- exit simplify (now in simplify) = 3*x^2+(1/4)*sin(x^2)}

<-- exit simplify (now at top level) = 3*x^2+(1/4)*sin(x^2)}

>	printlevel:=0; forget(simplify,forgetpermanent = true,reinitialize=true);

>	printlevel:=20;

>	simplify(3*x^3/x+sin(x^2)/4);

value remembered (at top level): sin(x^2) -> sin(x^2)

{--> enter simplify, args = 3*x^2+(1/4)*sin(x^2)

value remembered (in simplify): \`simplify/do\`(3*x^2+(1/4)*sin(x^2)) -> 3*x^2+(1/4)*sin(x^2)

{--> enter simplify, args = 3*x^2+(1/4)*sin(x^2), size, applysimplifysize = false

<-- exit simplify (now in simplify) = 3*x^2+(1/4)*sin(x^2)}

<-- exit simplify (now at top level) = 3*x^2+(1/4)*sin(x^2)}

Download how_to_clear_simplify_cache_march_24_2025.mw

Anyone has Maple 2025 could check if same behaviour there also?

why select(has,-a^2,x); returns 1?...

Asked: nm 11373 Product: Maple 2024

March 23 2025

2 2

I do not understand why select(has,-a^2,x); returns 1 but select(has,a^2,x); returned undefined.

Should not both return undefined, since there is no x anywhere in the expression?

I looked at help and do not see a clue so far.

Download select_question_march_23_2025.mw

Here is another variation, where I changed a^2 to a

Download select_question_v2_march_23_2025.mw

The good thing is that has(C,x) returns false in both case. So the problem is not with the has call. It is select which decided to return 1 when there is negative sign. But why?

Download select_question_v3_march_23_2025.mw

how to help dsolve find this ode solutio...

Asked: nm 11373 Product: Maple 2024

March 12 2025

2 13

This is problem from INTRODUCTORY DIFFERENTIAL EQUATIONS. Martha L. Abell, James P. Braselton. Fourth edition 2014. ElScAe. 2014 , Chapter 2. First Order Equations. Exercises 2.4, page 57, problem 39

Maple 2024.2 can't solve it. But solution is arctan(t)-t*y(t)^2 = 0 which Maple verifies correct