Maple Questions and Posts

These are Posts and Questions associated with the product, Maple

Suppose I am plotting a 2D plot and want to highlight the point where two lines intersect. I would like to display this intersection point inside the plot in black font, mark it with an arrow or some visual highlight, and clearly label it. How can I do this?

Additionally, instead of using different colours (blue, green, red) for the lines, I want to distinguish them using different line styles such as solid, dotted, and long-dashed lines. How can I make these changes?

restart

with(Optimization); with(plots); with(Student[VectorCalculus]); with(LinearAlgebra)

NULL

_local(Pi)

Pi

(1)

NULL

NULL

``

M_w := b*(((Cr*alpha*((-g*i2+a)*Cr+2*Crm+2*c-2*Pr)*b+((g*i2-a)*Cr-2*Crm-2*c+2*Pr)*alpha-(-g*i2+a)*Cr)*d+alpha*((-g*i2+a)*Cr+2*Crm+2*c-2*Pr)*b+2*g*i2-2*a)*rho0+(2*((Cr*b-1)*d+b))*(delta+Cn-Pr-1))^2*d/(8*(Cr*b*d+b-d)^2*(((Cr*alpha*b-alpha+1)*d+alpha*b)*rho0^2-2*b*d*(delta-1)))

(1/8)*b*(((Cr*alpha*((-g*i2+a)*Cr+2*Crm+2*c-2*Pr)*b+((g*i2-a)*Cr-2*Crm-2*c+2*Pr)*alpha-(-g*i2+a)*Cr)*d+alpha*((-g*i2+a)*Cr+2*Crm+2*c-2*Pr)*b+2*g*i2-2*a)*rho0+(2*(Cr*b-1)*d+2*b)*(delta+Cn-Pr-1))^2*d/((Cr*b*d+b-d)^2*(((Cr*alpha*b-alpha+1)*d+alpha*b)*rho0^2-2*b*d*(delta-1)))

(2)

``

``

``

M_D := (Cr*rho0*t*(Cr*alpha*b-alpha-1)*d^2+((alpha*((-g*i2+a)*Cr+2*Crm+2*c+3*t-2*Pr)*Cr*b+((g*i2-a)*Cr-2*Crm-2*c-2*t+2*Pr)*alpha+(g*i2-a)*Cr-2*t)*rho0+(2*(Cr*b-1))*(sigma*t+Cn-Pr+delta-1))*d+(alpha*((-g*i2+a)*Cr+2*Crm+2*c+2*t-2*Pr)*b+2*g*i2-2*a)*rho0+2*b*(sigma*t+Cn-Pr+delta-1))^2*d*b/((8*(((Cr*alpha*b-alpha+1)*rho0^2-2*b*(delta-1))*d+rho0^2*b*alpha))*((Cr*b-1)*d+b)^2)

(Cr*rho0*t*(Cr*alpha*b-alpha-1)*d^2+((alpha*((-g*i2+a)*Cr+2*Crm+2*c+3*t-2*Pr)*Cr*b+((g*i2-a)*Cr-2*Crm-2*c-2*t+2*Pr)*alpha+(g*i2-a)*Cr-2*t)*rho0+(2*Cr*b-2)*(sigma*t+Cn-Pr+delta-1))*d+(alpha*((-g*i2+a)*Cr+2*Crm+2*c+2*t-2*Pr)*b+2*g*i2-2*a)*rho0+2*b*(sigma*t+Cn-Pr+delta-1))^2*d*b/((8*((Cr*alpha*b-alpha+1)*rho0^2-2*b*(delta-1))*d+8*rho0^2*b*alpha)*((Cr*b-1)*d+b)^2)

(3)

M_S := ((t*Cr*(Cr*alpha*b-alpha-1)*d^2+(Cr*((-g*i2+a)*Cr-2*Pr+2*Crm+2*c-2*s+3*t)*alpha*b+((g*i2-a)*Cr+2*Pr-2*Crm-2*c+2*s-2*t)*alpha+(g*i2-a)*Cr-2*t)*d+((-g*i2+a)*Cr-2*Pr+2*Crm+2*c-2*s+2*t)*alpha*b+2*g*i2-2*a)*rho0-(2*(-sigma*t-Cn+Pr-delta+1))*((Cr*b-1)*d+b))^2*b*d/((8*(((Cr*alpha*b-alpha+1)*d+alpha*b)*rho0^2-2*b*d*(delta-1)))*(Cr*b*d+b-d)^2)

((t*Cr*(Cr*alpha*b-alpha-1)*d^2+(Cr*((-g*i2+a)*Cr+2*Crm+2*c-2*Pr-2*s+3*t)*alpha*b+((g*i2-a)*Cr-2*Crm-2*c+2*Pr+2*s-2*t)*alpha+(g*i2-a)*Cr-2*t)*d+((-g*i2+a)*Cr+2*Crm+2*c-2*Pr-2*s+2*t)*alpha*b+2*g*i2-2*a)*rho0-(-2*sigma*t-2*Cn+2*Pr-2*delta+2)*((Cr*b-1)*d+b))^2*b*d/((8*((Cr*alpha*b-alpha+1)*d+alpha*b)*rho0^2-16*b*d*(delta-1))*(Cr*b*d+b-d)^2)

(4)

``

``

NULL

NULL

DATA1 := [delta = .9, a = 0.1e-1, g = .25, c = 0.5e-1, rho0 = .4, Cn = .4, Crm = .1, i2 = 0.6e-1, t = 0.1e-1, alpha = .95, s = 0.1e-1, Pr = .35, upsilon = .95, b = .5, d = .3, Cr = 0.1e-1]

[delta = .9, a = 0.1e-1, g = .25, c = 0.5e-1, rho0 = .4, Cn = .4, Crm = .1, i2 = 0.6e-1, t = 0.1e-1, alpha = .95, s = 0.1e-1, Pr = .35, upsilon = .95, b = .5, d = .3, Cr = 0.1e-1]

(5)

P11 := subs(DATA1, M_w); P21 := subs(DATA1, M_D); P31 := subs(DATA1, M_S)

0.9301486586e-2

 

4.251178959*(-0.4764573140e-1+0.4030e-2*sigma)^2

 

4.251178959*(-0.4917713136e-1+0.4030e-2*sigma)^2

(6)

``

A1 := plot([P11, P21, P31], sigma = 0 .. .7, color = ["Red", "Blue", "Green"], labels = [sigma, `π__m`], labeldirections = ["horizontal", "vertical"], legend = [`#msubsup(mi("π"),mi("n"),mn("W"));`, `#msubsup(mi("π"),mi("n"),mn("D"));`, `#msubsup(mi("π"),mi("n"),mn("DS"));`], axis[2] = [color = "#600000"])

 

NULL

display(A1, pointplot([[X, Y]], symbol = circle, symbolsize = 25, color = blue))

Error, (in plots:-pointplot) points cannot be converted to floating-point values

 
 

NULL

Download Manf_profit__t_graph_changes_needed.mw

When there is a large Matrix in a worksheet, asking Maple to export the worksheet to PDF, the matrix is truncated in the PDF. Only one page of it shows.

Is there a way to tell Maple not to truncate large matrix, even if goes over many pages?

I need to export eveything in the worksheet to PDF.

Here is an example

restart;
interface(rtablesize = infinity);

A:=Array(1 .. 0);
for n from 1 to 50 do
    A,= [n];
od:

convert(convert(A,listlist),Matrix);

When I do , from menu, File->Export As and select PDF, then open the PDF, I only see half the matrix in the PDF.

Attached the PDF also.

Worksheet mode, Maple 2025.2

Is this a bug? export should export everything in worksheet.

truncate_output.pdf

truncate_output.mw

Update

Found a workaround.

First, I tried to print to pdf, istead of export to pdf. That also did not work.

Then I tried DocumentTools:-Tabulate instead, and now this worked. The PDF has the full content, not truncated.

i.e. instead of  

convert(convert(A,listlist),Matrix);

Did this:

the_table:=convert(A,listlist):
DocumentTools:-Tabulate(A,'width'=400,widthmode='pixels', etc...); #change as needed

For some reason, Matrix is truncated when exporting to PDF, but not Tabulate.

I think it is a bug for Maple to truncate the Matrix in PDF,  but workaround exist, so not critical.

Hello all,

I just need a hint how to enter "matrices" in Maple which are lists of lists and so on.

Since I gave up on "math"ematica I would like to be able to enter what is just

below (with the dimension).

Is it doable in Maple...I guess yes :)

M = {{a, {1, a, -0.5}}
, {{b, {1}}}, c + d}
Out[5]= {a, {1, a, -0.5}, {{b, {1}}}, c + d}
In[8]:= MatrixForm[M]
Out[8]//MatrixForm=
a
{1, a, -0.5}
{{b, {1}}}
c + d
In[9]:= Dimensions[M]
Out[9]= {4}

PS: Is a moderator ready to make me with a reputation of 100 in order I can enter tags.

Thank you for everything.

Regards,

JM

I am not able to find place in help which lists which changes interface(typesetting = extended); makes compared to interface(typesetting = standard);

Reason  I am asking, is that in interface(typesetting = extended); Maple adds a small annoying "dot"  between each term for multiplication, which is not there in standard.

Is there a place in documentation that mentions this as part of extended? Where to find it?

What does Error, (in dsolve/numeric/bvp) bad index into Matrix mean?
Also, I'm trying to run it, it is slow, any suggestions?

restart;
with(Student[VectorCalculus]);
with(DynamicSystems);
with(DEtools);
with(PDEtools, ReducedForm, declare, diff_table, dsubs);
NULL;
 #Digits:= trunc(evalhf(Digits)); #generally a very efficient setting

# Here we solve a 1D problem in 3 regions. In each region, we have concentration and potential (c,phi) distributions,
# We first solve the unperturbed steady-state problem and then the linearized perturbation problem (which rely on the steady state).
# Each region is defined in x = 0..1, and the regions are connected by interface conditions that 
# connect (c1(1),phi1(1)) to (c2(0),phi2(0)) and (c2(1),phi2(1)) to (c3(0),phi3(0))

Q:=10;   omega:=100;     J0:= 0.01;   # parameters
                            Q := 10

                          omega := 100

                           J0 := 0.01

# The unperturbed steady-state

c1:=1-J0/2*x: 
c3:=1-J0/2*(x-1):  
c12:= eval(c1,x=1); 
c32 := eval(c3,x=0); 
S1:=sqrt(Q^2+4*c12^2): 
S3:=sqrt(Q^2+4*c32^2):  
c21:=eval((S1-Q)/2); 
c23:=eval((S3-Q)/2);  
I0:=fsolve(Q*i0/2/J0*ln((J0*S1-Q*i0)/(J0*S3-Q*i0))=(J0-S1+S3)/2,i0);  
V:=(I0/J0+1)*ln(c32/c12)+ln((c21+Q)/(c23+Q))+(J0+2*c23-2*c21)/Q; # the potential drop across the system 
c2:=solve(y-c21+Q*I0/2/J0*ln((Q*I0-Q*J0-2*J0*y)/(Q*I0-Q*J0-2*J0*c21))=-J0/2*x,y):  
phi1:=I0/J0*ln(c1)+V: 
phi3:=I0/J0*ln(c3): 
dphi1:=diff(phi1,x); 
dphi3:=diff(phi3,x); 
phi21:=I0/J0*ln(c12)+V-0.5*ln((c21+Q)/c21); 
phi2:=(2*c21-2*c2+Q*phi21-J0*x)/Q: 
dphi2:=diff(phi2,x); 
dphi12 := eval(dphi1, x=1); 
dphi21 := eval(dphi2, x=0); 
dphi23 := eval(dphi2, x=1); 
dphi32 := eval(dphi3, x=0); 
INT1 := int(1/(2*c1), x = 0 .. 1); 
INT2 := int(1/(2*c2 + Q), x = 0 .. 1); 
INT3 := int(1/(2*c3), x = 0 .. 1); 
INT := INT1 + INT2 + INT3;
                      c12 := 0.9950000000

                       c32 := 1.005000000

                      c21 := 0.09804129000

                      c23 := 0.1000024500

                      I0 := 0.01419804328

                       V := 0.02539628566

                              0.007099021640   
                dphi1 := - --------------------
                           1 - 0.005000000000 x

                              0.007099021640        
           dphi3 := - ------------------------------
                      1.005000000 - 0.005000000000 x

                     phi21 := -2.299074561

dphi2 := (0.001000000000 LambertW(-0.2818670588 exp(-0.2818670588

   - 0.0007043224058 x)))/(1

   + LambertW(-0.2818670588 exp(-0.2818670588 - 0.0007043224058 x)

  )) - 0.001000000000


                   dphi12 := -0.007134695118

                   dphi21 := -0.001392499832

                   dphi23 := -0.001391964358

                   dphi32 := -0.007063703124

                      INT1 := 0.5012541824

                     INT2 := 0.09805801917

                      INT3 := 0.4987541511

                       INT := 1.098066353


sys1 := {
-omega*C11(x)+diff(diff(C12(x), x), x)=0,
omega*C12(x)+diff(diff(C11(x), x), x) = 0,
-omega*C21(x)+diff(diff(C22(x), x)+(c2*sigma2-C22(x)*dphi2*Q)/(2*c2+Q), x) =0,
 omega*C22(x)+diff(diff(C21(x), x)+(c2*sigma1-C21(x)*dphi2*Q)/(2*c2+Q), x) = 0,
-omega*C31(x)+diff(diff(C32(x), x), x)=0,
omega*C32(x)+diff(diff(C31(x), x), x) = 0
}:

sys2 := {
diff(FA1(x), x) = C11(x)*dphi1/c1,
diff(FA2(x), x) = C21(x)*dphi2/(c2+Q/2),
diff(FA3(x), x) = C31(x)*dphi3/c3,
diff(FB1(x), x) = C12(x)*dphi1/c1,
diff(FB2(x), x) = C22(x)*dphi2/(c2+Q/2),
diff(FB3(x), x) = C32(x)*dphi3/c3
}: 

Bc := {
C11(0) = 0, C12(0) = 0,  C31(1) = 0, C32(1) = 0,
FA1(0) = 0, FB1(0) = 0,  FA3(1) = 0, FB3(1) = 0, 

2*C11(1)/c12 = C21(0)/(c21+Q)+C21(0)/c21, 
2*C12(1)/c12 = C22(0)/(c21+Q)+C22(0)/c21,
C21(1)/(c23+Q)+C21(1)/c23 = 2*C31(0)/c32,
C22(1)/(c23+Q)+C22(1)/c23 = 2*C32(0)/c32,

D(C11)(1)+dphi12*C11(1)-sigma1/2-c12*D(FA1)(1) = D(C21)(0)+dphi21*C21(0)-(c21+Q)*sigma1/(2*c21+Q)-(c21+Q)*D(FA2)(0),
D(C12)(1)+dphi12*C12(1)-sigma2/2-c12*D(FB1)(1) = D(C22)(0)+dphi21*C22(0)-(c21+Q)*sigma2/(2*c21+Q)-(c21+Q)*D(FB2)(0),
D(C11)(1)-dphi12*C11(1)+sigma1/2+c12*D(FA1)(1) = D(C21)(0)-dphi21*C21(0)+c21*sigma1/(2*c21+Q)+c21*D(FA2)(0),
D(C12)(1)-dphi12*C12(1)+sigma2/2+c12*D(FB1)(1) = D(C22)(0)-dphi21*C22(0)+c21*sigma2/(2*c21+Q)+c21*D(FB2)(0),

D(C31)(0)+dphi32*C31(0)-sigma1/2-c32*D(FA3)(0) = D(C21)(1)+dphi23*C21(1)-(c23+Q)*sigma1/(2*c23+Q)-(c23+Q)*D(FA2)(1),
D(C32)(0)+dphi32*C32(0)-sigma2/2-c32*D(FB3)(0) = D(C22)(1)+dphi23*C22(1)-(c23+Q)*sigma2/(2*c23+Q)-(c23+Q)*D(FB2)(1),
D(C31)(0)-dphi32*C31(0)+sigma1/2+c32*D(FA3)(0) = D(C21)(1)-dphi23*C21(1)+c23*sigma1/(2*c23+Q)+c23*D(FA2)(1),
D(C32)(0)-dphi32*C32(0)+sigma2/2+c32*D(FB3)(0) = D(C22)(1)-dphi23*C22(1)+c23*sigma2/(2*c23+Q)+c23*D(FB2)(1)
}:
 
 


all_sys := sys1 union sys2 union Bc:
sol1 := dsolve(all_sys, initmesh = 100, maxmesh = 15000, numeric, method = bvp[midrich], output = listprocedure):
#(all_sys, numeric, method = bvp[midrich]);

Error, (in dsolve/numeric/bvp) bad index into Matrix

Would this be considered a bug or expected?

Everytime I see internal error in red, for me, it tells me it is a bug. But wanted to check first what others think.

restart;

interface(version);

`Standard Worksheet Interface, Maple 2025.2, Windows 10, November 11 2025 Build ID 1971053`

ode:=x^2*diff(y(x), x$2) + (cos(x)-1)*diff(y(x), x) + exp(x)*y(x) = 0;
sol:=dsolve(ode,y(x),type='series',x=0):
sol1:=eval(%, _C2=0):
sol2:=eval(%%, _C1=0):

x^2*(diff(diff(y(x), x), x))+(cos(x)-1)*(diff(y(x), x))+exp(x)*y(x) = 0

Y:= unapply(rhs(sol1), x):
eval(lhs(ode), y=Y):
MultiSeries:-asympt(%, x);

Error, (in simpl/min) non-real argument to max/min: -13/2+1/2*I*3^(1/2)

Y:= unapply(rhs(sol2), x):
eval(lhs(ode), y=Y):
MultiSeries:-asympt(%, x);

Error, (in simpl/min) non-real argument to max/min: -13/2-1/2*I*3^(1/2)

 

 

Download asympt_none_real_argument_jan_17_2026.mw

I am looking for ways to clear remember tables in a Maple session to ensure that a Maple command/procedure is executed as if it were being called for the first time. I currently use

map(forget, [anames()])

but I am not sure if that statement clears all existing remeber tables (i.e. including system remember tables)?

Are there other ways to do this? Restart is not an option since it clears almost everything.

Edit: This question is not about disabling remember tables.

I'm looking for the general solution to the attached differential equation. Maple doesn't provide it. What am I doing wrong?

restart

ode5 := diff(y(x), x) = (8*y(x)*b-32*b^2*x/y(x)-64*b^2*x^2*y(x))/(3*y(x)^2+8*b*x-16*b^2*x^2/y(x)^2)

diff(y(x), x) = (8*y(x)*b-32*b^2*x/y(x)-64*b^2*x^2*y(x))/(3*y(x)^2+8*b*x-16*b^2*x^2/y(x)^2)

(1)

simplify(ode5)

diff(y(x), x) = ((64*b^2*x^2-8*b)*y(x)^3+32*b^2*x*y(x))/(-3*y(x)^4-8*b*x*y(x)^2+16*b^2*x^2)

(2)

dsolve(ode5, y(x))

NULLNULL

Download testdgl5.mw

I was wondering which theorem the following result is based on, and what the name of the sequence used is.

restart; with(LinearAlgebra)

K := proc (i::integer, j::integer) local M; M := Matrix(5, 5); M[i, i] := 1; M[j, j] := 1; return M end proc

F := proc (r, c, g, h) options operator, arrow; Adjoint(A.K(r, c).B.K(g, h).C) end proc

d1 := 3; d2 := 5; A := Matrix(d1, d2, symbol = a); B := Matrix(d2, d2, symbol = b); C := Matrix(d2, d1, symbol = c)

d1 := 3

 

d2 := 5

 

Matrix(3, 5, {(1, 1) = a[1, 1], (1, 2) = a[1, 2], (1, 3) = a[1, 3], (1, 4) = a[1, 4], (1, 5) = a[1, 5], (2, 1) = a[2, 1], (2, 2) = a[2, 2], (2, 3) = a[2, 3], (2, 4) = a[2, 4], (2, 5) = a[2, 5], (3, 1) = a[3, 1], (3, 2) = a[3, 2], (3, 3) = a[3, 3], (3, 4) = a[3, 4], (3, 5) = a[3, 5]})

 

Matrix(5, 5, {(1, 1) = b[1, 1], (1, 2) = b[1, 2], (1, 3) = b[1, 3], (1, 4) = b[1, 4], (1, 5) = b[1, 5], (2, 1) = b[2, 1], (2, 2) = b[2, 2], (2, 3) = b[2, 3], (2, 4) = b[2, 4], (2, 5) = b[2, 5], (3, 1) = b[3, 1], (3, 2) = b[3, 2], (3, 3) = b[3, 3], (3, 4) = b[3, 4], (3, 5) = b[3, 5], (4, 1) = b[4, 1], (4, 2) = b[4, 2], (4, 3) = b[4, 3], (4, 4) = b[4, 4], (4, 5) = b[4, 5], (5, 1) = b[5, 1], (5, 2) = b[5, 2], (5, 3) = b[5, 3], (5, 4) = b[5, 4], (5, 5) = b[5, 5]})

 

Matrix(%id = 36893489807004764868)

(1)

simplify(Adjoint(A.B.C)-add([F(1, 2, 1, 2), F(1, 2, 1, 3), F(1, 2, 1, 4), F(1, 2, 1, 5), F(1, 2, 2, 3), F(1, 2, 2, 4), F(1, 2, 2, 5), F(1, 2, 3, 4), F(1, 2, 3, 5), F(1, 2, 4, 5), F(1, 3, 1, 2), F(1, 3, 1, 3), F(1, 3, 1, 4), F(1, 3, 1, 5), F(1, 3, 2, 3), F(1, 3, 2, 4), F(1, 3, 2, 5), F(1, 3, 3, 4), F(1, 3, 3, 5), F(1, 3, 4, 5), F(1, 4, 1, 2), F(1, 4, 1, 3), F(1, 4, 1, 4), F(1, 4, 1, 5), F(1, 4, 2, 3), F(1, 4, 2, 4), F(1, 4, 2, 5), F(1, 4, 3, 4), F(1, 4, 3, 5), F(1, 4, 4, 5), F(1, 5, 1, 2), F(1, 5, 1, 3), F(1, 5, 1, 4), F(1, 5, 1, 5), F(1, 5, 2, 3), F(1, 5, 2, 4), F(1, 5, 2, 5), F(1, 5, 3, 4), F(1, 5, 3, 5), F(1, 5, 4, 5), F(2, 3, 1, 2), F(2, 3, 1, 3), F(2, 3, 1, 4), F(2, 3, 1, 5), F(2, 3, 2, 3), F(2, 3, 2, 4), F(2, 3, 2, 5), F(2, 3, 3, 4), F(2, 3, 3, 5), F(2, 3, 4, 5), F(2, 4, 1, 2), F(2, 4, 1, 3), F(2, 4, 1, 4), F(2, 4, 1, 5), F(2, 4, 2, 3), F(2, 4, 2, 4), F(2, 4, 2, 5), F(2, 4, 3, 4), F(2, 4, 3, 5), F(2, 4, 4, 5), F(2, 5, 1, 2), F(2, 5, 1, 3), F(2, 5, 1, 4), F(2, 5, 1, 5), F(2, 5, 2, 3), F(2, 5, 2, 4), F(2, 5, 2, 5), F(2, 5, 3, 4), F(2, 5, 3, 5), F(2, 5, 4, 5), F(3, 4, 1, 2), F(3, 4, 1, 3), F(3, 4, 1, 4), F(3, 4, 1, 5), F(3, 4, 2, 3), F(3, 4, 2, 4), F(3, 4, 2, 5), F(3, 4, 3, 4), F(3, 4, 3, 5), F(3, 4, 4, 5), F(3, 5, 1, 2), F(3, 5, 1, 3), F(3, 5, 1, 4), F(3, 5, 1, 5), F(3, 5, 2, 3), F(3, 5, 2, 4), F(3, 5, 2, 5), F(3, 5, 3, 4), F(3, 5, 3, 5), F(3, 5, 4, 5), F(4, 5, 1, 2), F(4, 5, 1, 3), F(4, 5, 1, 4), F(4, 5, 1, 5), F(4, 5, 2, 3), F(4, 5, 2, 4), F(4, 5, 2, 5), F(4, 5, 3, 4), F(4, 5, 3, 5), F(4, 5, 4, 5)]))

Matrix(%id = 36893489807027993164)

(2)

nops([F(1, 2, 1, 2), F(1, 2, 1, 3), F(1, 2, 1, 4), F(1, 2, 1, 5), F(1, 2, 2, 3), F(1, 2, 2, 4), F(1, 2, 2, 5), F(1, 2, 3, 4), F(1, 2, 3, 5), F(1, 2, 4, 5), F(1, 3, 1, 2), F(1, 3, 1, 3), F(1, 3, 1, 4), F(1, 3, 1, 5), F(1, 3, 2, 3), F(1, 3, 2, 4), F(1, 3, 2, 5), F(1, 3, 3, 4), F(1, 3, 3, 5), F(1, 3, 4, 5), F(1, 4, 1, 2), F(1, 4, 1, 3), F(1, 4, 1, 4), F(1, 4, 1, 5), F(1, 4, 2, 3), F(1, 4, 2, 4), F(1, 4, 2, 5), F(1, 4, 3, 4), F(1, 4, 3, 5), F(1, 4, 4, 5), F(1, 5, 1, 2), F(1, 5, 1, 3), F(1, 5, 1, 4), F(1, 5, 1, 5), F(1, 5, 2, 3), F(1, 5, 2, 4), F(1, 5, 2, 5), F(1, 5, 3, 4), F(1, 5, 3, 5), F(1, 5, 4, 5), F(2, 3, 1, 2), F(2, 3, 1, 3), F(2, 3, 1, 4), F(2, 3, 1, 5), F(2, 3, 2, 3), F(2, 3, 2, 4), F(2, 3, 2, 5), F(2, 3, 3, 4), F(2, 3, 3, 5), F(2, 3, 4, 5), F(2, 4, 1, 2), F(2, 4, 1, 3), F(2, 4, 1, 4), F(2, 4, 1, 5), F(2, 4, 2, 3), F(2, 4, 2, 4), F(2, 4, 2, 5), F(2, 4, 3, 4), F(2, 4, 3, 5), F(2, 4, 4, 5), F(2, 5, 1, 2), F(2, 5, 1, 3), F(2, 5, 1, 4), F(2, 5, 1, 5), F(2, 5, 2, 3), F(2, 5, 2, 4), F(2, 5, 2, 5), F(2, 5, 3, 4), F(2, 5, 3, 5), F(2, 5, 4, 5), F(3, 4, 1, 2), F(3, 4, 1, 3), F(3, 4, 1, 4), F(3, 4, 1, 5), F(3, 4, 2, 3), F(3, 4, 2, 4), F(3, 4, 2, 5), F(3, 4, 3, 4), F(3, 4, 3, 5), F(3, 4, 4, 5), F(3, 5, 1, 2), F(3, 5, 1, 3), F(3, 5, 1, 4), F(3, 5, 1, 5), F(3, 5, 2, 3), F(3, 5, 2, 4), F(3, 5, 2, 5), F(3, 5, 3, 4), F(3, 5, 3, 5), F(3, 5, 4, 5), F(4, 5, 1, 2), F(4, 5, 1, 3), F(4, 5, 1, 4), F(4, 5, 1, 5), F(4, 5, 2, 3), F(4, 5, 2, 4), F(4, 5, 2, 5), F(4, 5, 3, 4), F(4, 5, 3, 5), F(4, 5, 4, 5)])

100

(3)
 

NULL

Download Adjoint353.mw

Given first order nonlinear ode which is hard to solve using standard methods, the smart dsolve sometimes uses a method where it linearizes the first order ode to a linear second order ode and solves that.

Then with that solution to the linear second order ode, it is able to find the solution of the first order ode (need to resolve the constants of integration to merge them into one, but this part is easy to do).

My question is, how and what method it uses to "linearizes by differentation"? I could not find this in any textbook I have, and not able to see how it does.

Here is an example where it uses this method to solving this first order ode

restart;

Typesetting:-Unsuppress('all'); #always do this.
Typesetting:-Settings(prime=x,'typesetprime'=true); #this says to use y'(x) instead of dy/dx    
Typesetting:-Suppress(y(x)); # this says to use y' and not y'(x)

ode:=diff(y(x),x) = (-y(x)^2+4*a*x)^2/y(x); 
infolevel[dsolve]:=5;
dsolve(ode,y(x), singsol=all);

Tracing says 

So it says, if I understand, that it differentiated the original given first order ode and then linearized the resulting second order ode to the above, which is    y''=-64 a^2 x^2 y - 16 a x y' which is certainly linear second order ode and now can be solved using kovacic algorithm. Now the solution to the first order ode can be obtained.

But when differentiating the first order ode, this is the result

expand(diff(ode,x))

So the question is, did Maple mean it "linearized" the above to y''=-64 a^2 x^2 y - 16 a x y' 

If so, then how? Did it use Taylor series? but if so, where it expanded about? Or did it use some other method?  One thing I noticed is that by multiplying the RHS above by y^2 it becomes

And "removing" the nonlinear terms (say expansion is around y=0, so higher order y terms are very small and can be removed) the RHS above becomes

    y'' y^2 = -16 y' a^2 x^2 + 32 a^2 x y

Which is close to Maple shows, but 32 instead of 64, and what about the y^2 on the left side?  Is this method even valid mathematically to do? Since solution that result will be correct only near y=0?

So far, trying to step in the debugger to find how, I was not able to find where it does that but will keep trying.

Any idea what Maple means by linearization to 2nd order and how it does it?

ps. only case I know about, where nonlinear first order ode can be transformed to linear second order ode is the Riccati ode using transformation y=u'/u. But this  first order ode is not Riccati.

I just installed Maple 2023 on a MacPro running macOS Sequoia 15.7.2. Update to latest .version and activation worked without a hitch.

When I try to run it from the Finder it immediately puts up a dialog saying something like "Java not found". There is a webpage by Maplesoft addressing this, but it is completely uninformative and unhelpful.

I can get Maple to run using the cli (in Terminal) opening the Maple 2023 .app file, at which point Maple (running the standard GUI) works just as one would expect. So it is not a crisis but I'd like to be able to open it through the Finder as well. The Maple .app folder appears to have all the Java stuff in it, and clearly it is somewhere.

Anyone seen and solved this before?

Thanks,

Mac Dude

Solving this ode, Maple says 

But notice, the xi and eta tangent vectors order is reversed. Maple says pattern is [0,F*G], but shows [F*G,0].

Also, when later using DEtools:-symgen with HINT option, it does not return the above result. Tried both patterns with 0 on left and 0 on right. In both cases symgen does not return what shows above. 

Why is that? Am I doing something wrong? Notice also it says   "way=HINT"  but I am not using way option. Only HINT option, Why is it saying way=HINT? it seems argument passing I  am using is wrong, but do not see why it could be wrong.  This is what help says

Worksheet below

interface(version);

`Standard Worksheet Interface, Maple 2025.2, Windows 10, November 11 2025 Build ID 1971053`

restart;

ode:=diff(y(x),x)*cos(y(x))-cos(x)*sin(y(x))^2-sin(y(x)) = 0;
infolevel[dsolve]:=5;
infolevel[symgen]:=5;

(diff(y(x), x))*cos(y(x))-cos(x)*sin(y(x))^2-sin(y(x)) = 0

5

5

dsolve(ode);

Methods for first order ODEs:

--- Trying classification methods ---

trying a quadrature

trying 1st order linear

trying Bernoulli

trying separable

trying inverse linear

trying homogeneous types:

trying Chini

differential order: 1; looking for linear symmetries

trying exact

Looking for potential symmetries

trying inverse_Riccati

trying an equivalence to an Abel ODE

differential order: 1; trying a linearization to 2nd order

--- trying a change of variables {x -> y(x), y(x) -> x}

differential order: 1; trying a linearization to 2nd order

trying 1st order ODE linearizable_by_differentiation

--- Trying Lie symmetry methods, 1st order ---

 -> Computing symmetries using: way = 3

 -> Computing symmetries using: way = 4

 -> Computing symmetries using: way = 5

trying symmetry patterns for 1st order ODEs

 -> Computing symmetries using: way = patterns

-> trying a symmetry pattern of the form [F(x)*G(y), 0]

-> trying a symmetry pattern of the form [0, F(x)*G(y)]

-> The symmetry found is [0 exp(-x)*(2*sin(y)^2+cos(y)^2-1)/cos(y)]

<- symmetry pattern of the form [0, F(x)*G(y)] successful

[exp(-x)*(2*sin(y)^2+cos(y)^2-1)/cos(y), 0]

 <- successful computation of symmetries.

y(x) = arctan(-2*exp(x)/(exp(x)*cos(x)+exp(x)*sin(x)+2*c__1), ((2*cos(x)*sin(x)*(exp(x))^2+4*c__1*sin(x)*exp(x)+4*cos(x)*c__1*exp(x)+4*c__1^2+(exp(x))^2)*(2*cos(x)*sin(x)*(exp(x))^2+4*c__1*sin(x)*exp(x)+4*cos(x)*c__1*exp(x)-3*(exp(x))^2+4*c__1^2))^(1/2)/(2*cos(x)*sin(x)*(exp(x))^2+4*c__1*sin(x)*exp(x)+4*cos(x)*c__1*exp(x)+4*c__1^2+(exp(x))^2)), y(x) = arctan(-2*exp(x)/(exp(x)*cos(x)+exp(x)*sin(x)+2*c__1), -((2*cos(x)*sin(x)*(exp(x))^2+4*c__1*sin(x)*exp(x)+4*cos(x)*c__1*exp(x)+4*c__1^2+(exp(x))^2)*(2*cos(x)*sin(x)*(exp(x))^2+4*c__1*sin(x)*exp(x)+4*cos(x)*c__1*exp(x)-3*(exp(x))^2+4*c__1^2))^(1/2)/(2*cos(x)*sin(x)*(exp(x))^2+4*c__1*sin(x)*exp(x)+4*cos(x)*c__1*exp(x)+4*c__1^2+(exp(x))^2))

infolevel[dsolve]:=0;

0

DEtools:-symgen(ode,y(x),HINT = [ 0,F(x)*G(y)]); #why this does not return the symmetries found by dsolve above?

 -> Computing symmetries using: way = HINT

DEtools:-symgen(ode,y(x),HINT = [ F(x)*G(y),0]); #why this does not return the symmetries found by dsolve above?

 -> Computing symmetries using: way = HINT

DEtools:-symgen(ode)

 -> Computing symmetries using: way = 2

 -> Computing symmetries using: way = 3

 -> Computing symmetries using: way = 4

 -> Computing symmetries using: way = abaco1

[0, exp(-x)*(-1+cos(2*y))/cos(y)]

 <- successful computation of symmetries.

[_xi = 0, _eta = exp(-x)*(-1+cos(2*y))/cos(y)]

 

 

Download symgen_confusion_jan_9_2026.mw

Has anybody seen the unit palette beeing empty? 

This is new to me. I normally use the unit entry in the favourites but this time wanted to try Maple presets.

I was searching release notes for some old Maple versions. I found so many broken links on Maple web pages. The first page is https://www.maplesoft.com/products/maple/history/ 

Scrolling down, and starting from Maple 2016 (about half way down the page), all links to the "product press release" are broken. This is the link to the right of each product.  All these links on the right, from 2016 to the end of the page are broken,

Clicking on any of these, sends the user to new broken web page, called https://www.maplesoft.com/company/publications/  titled "Maplesoft media coverage".

This page does not even work. Clicking on "Jump to year" does not open. Clicking in "first page" does nothing. Tried Edge browser on windows 10, also the page does nothing. 

Then I clicked on Maplesoft Media Releases link at top, and now it works.

But jumping to any year before  2016, all the links that show on those pages are broken. Try and see,

For example. jumping to 2015, and clicking on release called "

November 25, 2015"

Gives

This applies to each press release for each year from 2015 to 1997.

Hundreds of links are broken.

There is software which checks broken links, and it is free for windows, called Xenu's Link Sleuth. May be someone at Maplesoft can use it to find all broken links at Maplesoft web site and fix them?

It is not acceptable in this day and age to have a Major software company with a web site full of broken links.

I downloaded the Maple free trial but could not find the Migration Assistant. What to do?

1 2 3 4 5 6 7 Last Page 1 of 2238