This puzzling to me. First will show the code, then explain the problem

restart;
ode:=diff(diff(y(x),x),x)+8*diff(y(x),x)+25*y(x) = 1;
sol:=dsolve(ode);
sol:= y(x)= _C2*exp(-4*x)*sin(3*x)+ _C1*exp(-4*x)*cos(3*x) + 1/25;
sol:= y(x)= _C2*exp(-4*x)*sin(3*x)+ _C1*exp(-4*x)*cos(3*x) + 1/25;
sol:= y(x)= _C2*exp(-4*x)*sin(3*x)+ _C1*exp(-4*x)*cos(3*x) + 1/25;

restart;

sol:= y(x)= _C2*exp(-4*x)*sin(3*x)+ _C1*exp(-4*x)*cos(3*x) + 1/25;

I was trying to changing the constant of integrations, to make them show at front, where it is better. But Maple refused to do so. Here is the output:

Why restart is needed to make Maple keep the output same as input? is it possible to rewrite it without having to do restart?

Download why_restart_needed.mw

I noticed that something changed with the output of translating abs() to latex. I am not sure when this happened.

Current version use \mid ...\mid  instead of the original \left| .... \right|

The problem with \mid is that the spacing no longer symmetric. It generate too much space on one side of | compared to the other side, and makes the output not pretty any more.

Is it possible to revert this back to the original way it was done? Please see example

restart;
Latex(ln(abs(1+x))=x)

                     \ln \! \left({\mid 1+x \mid}\right) = x

latex(ln(abs(1+x))=x)

                   \ln  \left(  \left| 1+x \right|  \right) =x

The second example gives better looking Latex where the space is symmetric. Here is the output

\documentclass{book}
\usepackage{amsmath}
\begin{document}          
\[
\ln \! \left({\mid 1+x \mid}\right) = x
\]

\[
\ln \! \left(  \left| 1+x \right|  \right) =x
\]
\end{document}

The second output is much better since \left|...\right| automatically sets the spacing the same between them and the math on each side.  (same if \lvert and \rvert were used)

I just noticed this first time looking at current output. I do not think this is how it used to be, else I would probably seen it before.

I am using Maple 2020.2 and Physics 890 (latest).

If not possible to change back to \left| ... right| . may be a new configuration parameter could be added to alow a user to choose which one?

Window 10.

This ode

ode:=diff(y(x),x)=sqrt(1-y(x)^2)

has general solution y(x) = sin(x + _C1) but it also has solution y=-1 and y=+1. Since these extra solutions can't be obtained from the general solution by specific value of the constant of integration, they are singular solution.

But I am not able to get Maple to show these:

restart;
ode:=diff(y(x),x)=sqrt(1-y(x)^2);    
dsolve(ode);
dsolve(ode,'singsol'='all',[separable]);
dsolve(ode,[separable]);

We can check that y=1.,y=-1 are solutions

odetest(y(x)=1,ode);
odetest(y(x)=-1,ode);

0
0

Only after I used this, was Maple able to gives these solutions

dsolve(ode,'Lie');
dsolve(ode,'Lie',singsol=all);

So only when using `Lie` symmetry methods and also using singsol=all it worked.

Most people will not think of using this specialized option.

Why Maple did not give these singular solutions using the standard dsolve(ode,singsol=all) command?

Should it not have done so? Now it makes it more confusing as to which option to use to obtain the singular solution, as one might have to keep trying different options.

What do others think? 

Maple 2020.2

I know it is not hard to write such a function, but can be tricky for all options. For 1D and uniform grid, it is straight forward to code it. The formula is here  https://en.wikipedia.org/wiki/Trapezoidal_rule#Uniform_grid

I was looking to see if Maple has this build-in. This is the equivalent of Matlab's trapz

I know about Student:-Calculus1:-ApproximateInt with option trapezoid. But this is not exactly the same. Matlab's trapz can accept just a list of numbers directly (the y values), or a a matrix of numbers (2D function), and applies trapezoidal rule. The default is unit spacing.

It is a simplified version of Student:-Calculus1:-ApproximateInt in a way, but I found trapz easier to use, if one has list of numbers generated before, (i.e. function values) and want to applies trapezoidal rule on it as is. It is more more convenient that way.

Here is an example from Matlab's help. Given

Y = [1 4 9 16 25];
Q = trapz(Y)

it gives 42.

One does not need to define f(x) or x=from..to  as in the case with Maple's ApproximateInt.

Matlab's trapz also supports Matrix as input not just 1D list of numbers.

Does Maple have something similar?

Maple mint checks for errors in one file only at a time. But not across mutliple files for correctness of calls between them. (As is done in statically complied langauges, where the compiler has access to all files and can do this).

One has to run the code to find such errors. For example, given

restart;
interface(warnlevel=4);
kernelopts('assertlevel'=2);

foo:=proc(n::integer,m::string,$)
 print("in foo, n=",n, "m = ",m );
end proc;

boo:=proc()
#How to make Maple check this call is wrong using mint? 
#before running the code? It has wrong type, and also
#missing one argument.

 foo(0.1);   
end proc;

Doing 

maplemint(boo)
maplemint(foo)

shows no errors. 

In a large program, with many calls between many procs in different packages, it will be nice if one can detect such errors before running the program if possible, than having to run the program, making sure all possible paths are taken each time.

Such an error could be hidden in the code for  sometime without one noticing it (For example, if one changes the API to a proc, but not change each call to the changed proc in order to update the call to the new API), and the code path for the now wrong call is not invoked in the current test since testing does not do 100% coverage all the time.

Is there any option in mint I might overlooked to do this?  if not, how hard would it be for Maple to add such a feature? i.e. give mint, either a set of files, or .mla library, and have it check all calls between all functions, for correctness.