H := CopyGraph(G);

The GraphTheory package implements CopyGraph which is appropriate here.

You can try e.g.

kernelopts(numcpus=2):

but I doubt that it will help avoiding a BSOD - which I have never seen due to Maple usage...

Good luck however!

That seems to be a glitch in old versions. At least since Maple 2017, I'm consistently getting

cg0 = x[0] * x[0];

which is the expected output here.

I cannot see any difference either. What do you mean when saying "expr1 is not correct"?

Did you install the last update for Maple 2020? Please see here (the link will not be valid forever).

My preferred solution for this representation:

normal(w,expanded);

I don't know if this existed already in Maple 12, but in any case, here's what I think you asked for:

ode := u(x)*diff(u(x),x)^2=a__1*u(x)^4+a__2*u(x)^3+a__3*u(x)^2+a__4*u(x)+a__5;
odeWF := VariationalCalculus:-Weierstrass(ode,x,u(x),'p');
solWF := [dsolve(odeWF,u(x))];
odetest~(solWF,odeWF);

0.*I and -0.*I are not simplified automatically because these outputs (typically of a numerical function evaluation) may contain information on branching behaviour of that function - this is hinted at under the ?fnormal description.

That worksheet is quite old, apparently it was created in the 1990s. In the meantime, some new commands have been added, e.g. plots:-plotcompare which is very helpful for visualizing basic properties of functions in the complex domain.

Some eyecatchers can be made with Fractals:-EscapeTime package. Engineers benefit from various commands in DiscreteTransforms and SignalProcessing, e.g.

Are you interested in plotting specifically, or in complex numbers generally?

First, you will need to insert a multiplication symbol between q and I in the assignment to eq1. Note that qI would be an unknown variable.

Next, apply evalc as follows:

a := evalc(Re(eq1));
b := evalc(Im(eq1));

I tend to say yes, the equation can be solved analytically - but I don't know any direct method, sorry.

What you can try in Maple is to apply the identify command to the numerical solution, at increasing values of Digits:

A := Matrix(2, 2, [[2, 1], [1, -1]]):
B := Vector[column](2, [3, 1]):
Q := Matrix(2, 2, [[3, 0], [0, 2]]):
R := Matrix(1, 1, [[3]]): 
with(LinearAlgebra):
Digits := 72:
nsol := CARE(A,B,Q,R);
idsol := identify(nsol);
exsol := allvalues(idsol);

For Digits>=54, identify is successful with one element of the solution matrix; and Digits=72 seems to be the lowest setting to obtain all of them.

I have not tried with L and condition number (see CARE option 'output'), though.

Maple is using log4j version 1.2.3; see e.g. the note under ?copyright (Apache log4j is listed in section Open Source).

Affected versions range from 2.0 to 2.14.1.

These attributes are not configurable. The code editor is really meant to be tiny. If you think it's useful to have additional configuration settings, please submit an SCR via the More menu of MaplePrimes. Thank you.

Hardware specs of your laptop should still be sufficient for Maple 2021. I suppose by "latest stable Ubuntu" you mean one of the supported versions; please see our System Requirements.

To determine whether it's really a memory issue, I would suggest running a thorough test such as MemTest86.

Good luck!

See the Contact link at the top of the page. There is no separate e-mail address.

Your expectation is not unreasonable; in fact, pdsolve is trying a factorization (albeit unsuccessfully), as can be seen from the diagnostic output. Other methods (separation ansatz) are successful, but return a very long solution which can be simplified somewhat:

restart:
eq1:=E*D(II)(x)*D[1](psi)(x,t)+E*II(x)*(D[1]@@2)(psi)(x,t)-G*A(x)*psi(x,t)+G*A(x)*D[1](v)(x,t):
eq1:=convert(eq1,diff);
eq2:=-(G*D[1](A)(x)*psi(x,t)+G*A(x)*D[1](psi)(x,t))+(G*D[1](A)(x)*v(x,t))+G*A(x)*(D[1]@@2)(v)(x,t)-m(x)/G*D[2](v)(x,t):
eq2:=convert(eq2,diff);
sys:=[eq1,eq2]:
infolevel[pdsolve]:=5:
sol:=pdsolve(sys,[psi(x,t),v(x,t)]);
length~(sol);
ot:=odetest(sol,sys);
ssol:=simplify~(sol): length~(ssol);

I've let this run over the lunch break, and saw the results afterwards.