on DLMF page, they show this transformation on independent variable for second order ode

https://dlmf.nist.gov/1.13#Px7

About half way down the page, under Elimination of First Derivative by Change of Independent Variable section.

I tried to verify it using Maple dchange. But the problem it looks like dchange wants the old variable to be on the left side (z in this example) and the new variable (eta in this example) to be on the right side in the transformation. But on the above web page, it is the other way around.

Here are my attempts

restart;
ode:=diff(w(z),z$2)+f(z)*diff(w(z),z)+g(z)*w(z)=0;

tranformation:=eta=int(exp(-int(f(z),z)),z);

PDEtools:-dchange({tranformation},ode,known={z},unknown={eta});
PDEtools:-dchange({tranformation},ode,{eta},known={z});
PDEtools:-dchange({tranformation},ode,{eta});

All give errors

Error, (in dchange/info) missing a list with the new variables
Error, (in dchange/info) the new variables are not contained in the rhs of the direct transformation equations
Error, (in dchange/info) the new variables are not contained in the rhs of the direct transformation equations

The problem it does not seem possible to invert the transformation shown on the webpage, so that the old variable z show on the left side and the new variable (eta) on the right side.  

Why is this restriction on dchange  Since one tells it which is the new variable and which is the old variable? May be I am not using dchange correctly in this example.

Any suggestion for a workaround to use dchange to verify the above result?

Here is my hand derivation (pdf file attached also)

Can the above be done using dchange?

Maple 2021.2 on windows 10

sol.pdf

sometimes complicated equation is generated and attempt to solve it fail, which is OK. But there is a case, where Maple generates an internal error from solve(). The problem is that it is not possible to even capture this error using try...catch... end try so the whole program crashes.

Is there a way to trap such errors, so at least it can bypass it without solving it but without terminating the whole program? 

According to help it says

The try statement provides a mechanism for executing statements in a controlled environment, where errors will not just cause the execution to halt with no warning.

Well. The above is not really true.

Download dec_16_2021.mw

Other than saving few bytes of memory, why would one use ::static for methods of Object?

I found that if I use ::static, then I have to add prefix _self:- each time an object data member is referenced anywhere, making the code very hard to read.

Imagine having to write  _self:-x + 3* _self:-x^2 + 2* _self:-y^3 and so on all the time, instead of just x+3*x^2+2*y^3. (where it is assumed here that x,y happened to be object private data members and not local variables for a proc inside the module).

But then I found if I remove  ::static now _self:- no longer needed and can still get the benefit of using the object and the code works as before, but the code is now much more readable. 

I know that by not using static, then a copy of each method is made for each new object.

I am OK with that. As I do not use that many objects any way (few at a time before GC cleans the ones I used).

But the benefit of much more readable code far outweights the little extra memory needed, and memory is cheap these days anyway. I got lots of RAM. An extra few MB's is not a big deal.

What Am I missing here? Why does all the Maple help and documenation say that one should use static for object methods then? But do not mention that by not using static:: then the code will become more readable since _self:- is not needed to be appeneded to each variable or method name.

Here is an example below to compare. 

First example uses ::static methods, and the second does not.

One can see the difference The code is more clear in the second.   Is there something else I am overlooking by not using ::static . I am still learning OOP in Maple, and could be overlooking something else. I definitly do not want to code using _self:-variable_name all the time if I have to use OOP in Maple as it makes the code hard to read. 

Notice that in both examples, and for the exported methods, I used _self as first argument. This is OK. This is meant to allow client of the object to call it using object:-method() syntax which is what I prefer instead of method(object,....). syntax.

I am talking about the execssive use of _self internal to the module/object code when having to use ::static. methods.

Download OOP.mw

Without trying it or looking down more, should these two code fragments give same output or not

# CASE 1

restart;
A   :=   2;
B   :=   x+2*y;
t^2 * ( A * B );


#CASE 2
restart;
t^2*( 2 * (x+2*y)  );

One would expect both to give same output, right? CASE 1 just uses variables and CASE 2 just uses the values of these variables. I mean the semantics of CASE 1 and 2 are the same, given that Maple replaces each variable with its value when evaluating.

But Maple does not give same result.

One way to force same result when using variables is to use t^2*(eval(A*B));

My question is why CASE 1 gives different result from CASE 2?  I would have expected same output.

Maple 2021.2 on windows 10. Worksheet.

Download why_different.mw

Why would simplify(t^2*x^2+t^2*y^2)  give  (x^2 + y^2)*t^2 but with seemingly same input except changing `+` to `-` fails now to simplify it?  simplify(t^2*x^2-t^2*y^2) gives t^2*x^2-t^2*y^2

Just trying to understand the logic behind this behavior.

In Mathematica both do simplify as can be seen below, which is what one would expect.