12497 Reputation

19 Badges

12 years, 232 days

MaplePrimes Activity

These are replies submitted by tomleslie

without error in Maple  2022.1 on Windows.

So doesn't look like a Maple version issue.

Soesn't look like an OS issue - at keast for Linux/Windows

maybe MacOS issue?

Run the attached (which does a version check) and upload hte output


`Standard Worksheet Interface, Maple 2022.1, Windows 7, May 26 2022 Build ID 1619613`



equ1 := BesselJ(sqrt(17)/2, 10*sqrt(t)*sqrt(2))/t^(1/4) + BesselY(sqrt(17)/2, 10*sqrt(t)*sqrt(2))/t^(1/4):

equ2 := BesselJ(sqrt(17)/2, 10*sqrt(t)*sqrt(2))/t^(1/4) + 5*BesselY(sqrt(17)/2, 10*sqrt(t)*sqrt(2))/t^(1/4):

equ3 := BesselJ(sqrt(17)/2, 10*sqrt(t))/t^(1/4) + 5*BesselY(sqrt(17)/2, 10*sqrt(t))/t^(1/4):

tmax   := 30:
colors := ["Red", "Violet", "Blue"]:

p1 := plot([equ1, equ2, equ3], t = 0 .. tmax, labels = [t, T[2](t)], tickmarks = [0, 0], labelfont = [TIMES, ITALIC, 12], axes = boxed, color = colors):

ymin := min(op~(1, op~(2, op~(2, [plottools:-getdata(p1)])))):
ymax := max(op~(2, op~(2, op~(2, [plottools:-getdata(p1)])))):
dy   := 2*ymax:

legend1 := typeset(C[3] = 1, ` , `, C[4] = 1, ` , `, Omega^2 = 50):
legend2 := typeset(C[3] = 1, ` , `, C[4] = 5, ` , `, Omega^2 = 50):
legend3 := typeset(C[3] = 1, ` , `, C[4] = 5, ` , `, Omega^2 = 25):

p2 := seq(textplot([tmax-2, ymax-k*dy/20, legend||k], align=left), k=1..3):

p3 := seq(plot([[tmax-2, ymax-k*dy/20], [tmax-1, ymax-k*dy/20]], color=colors[k]), k=1..3):
display(p1, p2, p3, view=[default, -ymax..ymax], size=[800, 500])



Download oddPlot.mw

'f(x,y)^2+(z-1)^2=0  still requires z=1 for the same reason as before so you are probably better to use a 2-D implicitplot and transform it to 3D, as in the attached "toy" example.

Whatever algorithm implicitplot3d() is using doesn't seem to work very well when one of the coordinates is restricted to a single value :-(

  p1:=implicitplot( x^2+y^2=9, x=-10..10, y=-10..10):
  f:=transform( (x,y)->[x,y,1]):







Download 3dplot.mw


then you can set a "default" unit for a given dimension - in the attached I have set the default unit for angular velocity to be 'rpm'. Now no conversion is necessary.

On the subject on "context menus" - they can never contain all the possibilities. They would have to be so big (or nested so deep) that they would become unusable. They are best thought of as containing only "most commonly used" stuff.


Units:-UseUnit('rpm'); with(Units[Standard])




acc1 := 9.0*Unit('gn')



arm1 := 10.0*Unit('ft')



vel1 := (acc1*arm1)^(1/2)



circ1 := 2*Pi*arm1



T1 := circ1/vel1



f1 := 1/T1



omega1 := 2*Pi*Unit('rad')*f1;




Download unitProb2.mw

@Christian Wolinski 

Assuming you have the automatic back-up on, ie the menu entry

Tools->Options->General->Auto save entry

checkbox is "checked",  then Maple will be backing up your work at the interval specified. These backups can be recovered in a susequent Maple session using

File->Restore Backup

which will produce a pop-up window where you can browse for the backup you want. (Rather amusingly, in this pop-up, one has to uses the horizontal scroll bar in order to scroll vertically!). Alternatively, you can use the


and navigate  to the backup directory, which in a standard Windows installlation is located at


A few warnings

  1. If the checkbox Tools->Options->General->Keep files is set (the default) then you will keep the backup files even after using a "Save" or "Save as" command. If this is unset, then the "Save" or "Save as" command, performs the "save" operation and deletes the backup.
  2. It is generally good practice when you open a new Maple worksheet to save it immediately with "sensible" name. Otherwise, (assuming Keep files checkbox is set), your backup directory will contain a lot of files called something like "untitled3214_MAS.bak" - which isn't exactly helpful. You can, of course, generally figure out which one you want from the datestamp/timestamp.
  3. The default interval (which you can change) between backups is 3minutes. If you have a BIG worksheet, then you may notice that Maple becomes "unresponsive" for a few seconds every 3mins. This is unavoidable. I'm pretty sure that when Maple is performing a backup, the annunciator in the bottom left corner of the Maple GUI, says "saving" - so at least you can check that Maple hasn't died on you! Increasing the back-up interval is a trade-off between how much work you risk losing, and how annoying you find the periodic non-response.

Just noticed that you want this evaluated for m=1..10 - soI need  a trivial additional execution group to my previous post. See the attached

ode := xi^2*(diff(psi[m](xi), xi, xi))+2*xi*(diff(psi[m](xi), xi))+(xi^2-m*(m+1))*psi[m](xi) = 0; Order := 8; dsolve(ode, psi[m](xi), series); ans := convert(%, polynom)

xi^2*(diff(diff(psi[m](xi), xi), xi))+2*xi*(diff(psi[m](xi), xi))+(xi^2-m*(m+1))*psi[m](xi) = 0


psi[m](xi) = _C1*xi^m*(series(1+(1/(-4*m-6))*xi^2+(1/((-8*m-20)*(-4*m-6)))*xi^4+(1/((-12*m-42)*(-8*m-20)*(-4*m-6)))*xi^6+O(xi^8),xi,8))+_C2*xi^(-m-1)*(series(1+(1/(m^2-(-m-1)^2+6*m-1))*xi^2+(1/((m^2-(-m-1)^2+10*m-11)*(m^2-(-m-1)^2+6*m-1)))*xi^4+(1/((m^2-(-m-1)^2+14*m-29)*(m^2-(-m-1)^2+10*m-11)*(m^2-(-m-1)^2+6*m-1)))*xi^6+O(xi^8),xi,8))


psi[m](xi) = _C1*xi^m*(1+xi^2/(-4*m-6)+xi^4/((-8*m-20)*(-4*m-6))+xi^6/((-12*m-42)*(-8*m-20)*(-4*m-6)))+_C2*xi^(-m-1)*(1+xi^2/(m^2-(-m-1)^2+6*m-1)+xi^4/((m^2-(-m-1)^2+10*m-11)*(m^2-(-m-1)^2+6*m-1))+xi^6/((m^2-(-m-1)^2+14*m-29)*(m^2-(-m-1)^2+10*m-11)*(m^2-(-m-1)^2+6*m-1)))


seq(eval(ans, m = j), j = 1 .. 10)

psi[1](xi) = _C1*xi*(1-(1/10)*xi^2+(1/280)*xi^4-(1/15120)*xi^6)+_C2*(1+(1/2)*xi^2-(1/8)*xi^4+(1/144)*xi^6)/xi^2, psi[2](xi) = _C1*xi^2*(1-(1/14)*xi^2+(1/504)*xi^4-(1/33264)*xi^6)+_C2*(1+(1/6)*xi^2+(1/24)*xi^4-(1/144)*xi^6)/xi^3, psi[3](xi) = _C1*xi^3*(1-(1/18)*xi^2+(1/792)*xi^4-(1/61776)*xi^6)+_C2*(1+(1/10)*xi^2+(1/120)*xi^4+(1/720)*xi^6)/xi^4, psi[4](xi) = _C1*xi^4*(1-(1/22)*xi^2+(1/1144)*xi^4-(1/102960)*xi^6)+_C2*(1+(1/14)*xi^2+(1/280)*xi^4+(1/5040)*xi^6)/xi^5, psi[5](xi) = _C1*xi^5*(1-(1/26)*xi^2+(1/1560)*xi^4-(1/159120)*xi^6)+_C2*(1+(1/18)*xi^2+(1/504)*xi^4+(1/15120)*xi^6)/xi^6, psi[6](xi) = _C1*xi^6*(1-(1/30)*xi^2+(1/2040)*xi^4-(1/232560)*xi^6)+_C2*(1+(1/22)*xi^2+(1/792)*xi^4+(1/33264)*xi^6)/xi^7, psi[7](xi) = _C1*xi^7*(1-(1/34)*xi^2+(1/2584)*xi^4-(1/325584)*xi^6)+_C2*(1+(1/26)*xi^2+(1/1144)*xi^4+(1/61776)*xi^6)/xi^8, psi[8](xi) = _C1*xi^8*(1-(1/38)*xi^2+(1/3192)*xi^4-(1/440496)*xi^6)+_C2*(1+(1/30)*xi^2+(1/1560)*xi^4+(1/102960)*xi^6)/xi^9, psi[9](xi) = _C1*xi^9*(1-(1/42)*xi^2+(1/3864)*xi^4-(1/579600)*xi^6)+_C2*(1+(1/34)*xi^2+(1/2040)*xi^4+(1/159120)*xi^6)/xi^10, psi[10](xi) = _C1*xi^10*(1-(1/46)*xi^2+(1/4600)*xi^4-(1/745200)*xi^6)+_C2*(1+(1/38)*xi^2+(1/2584)*xi^4+(1/232560)*xi^6)/xi^11



Download odeSer2.mw

This problem is (somewhat?) analogous to a Sudoku number puzzle, in that it is grid-based and there are certain constraints on what has to occur in each row and column.

There is a wonderful piece of code here (https://www.maplesoft.com/Applications/Detail.aspx?id=154483), which uses Maple's Logic:-Satisfy() command to solve "the world's hardest sudoku".

If one looks up the help for the Logic:-Satisfy() command one might get the impression that it is applicable to only rather "simple"  logical problems. However in the Application mentioned above, the author generates 17598 logical constraints to supply to the Logic:-Satisfy() command, which then solves the Sudoku puzzle in ~0.5secs.

I'm pretty sure that a similar approach, with the appropriate constraints, could be used for the OP's problem.

Do I fancy writing the necessary constraints? Not really!  I think this could turn into a rather lengthy programming exercise


but only for the labels of each point. See the attached. (Again, the plot renders better in the worksheet than it does on this site)

  theta := (2*Pi)/17:
  p1:= pointplot
       ( [ seq
           ( [cos(k*theta), sin(k*theta)],
         symbol = solidcircle,
         color = red,
         symbolsize = 10
  p2:= textplot
       ( [ seq
           ( [ cos(k*theta), sin(k*theta), cat("M", k)],
         align=["above", "right"]



Download ptplt2.mw

In the Mapleprimes toolbar to upload the actual worksheet you are running which illustrates the problem.

the first thing you can do, is to utilise the amzing featued of this site where you can upload the worksheet which is causing you problems. This is done using the big green up-arrow in the Mapleprimes toolbar

When you cut/paste from a Maple worksheet and expect people to trawl throught it deleting all the irrelevant (output) crap - you are on a loser - opload something executable which illustrates your problem


These mean two completely different things and I'm not sure what you are after.

 p(Delta*delta)  is the function p() with the argument (delta*delta)

p*(Delta*delta)is just a simple product of three terms, and the parentheses are completely superfluous

Only you know whether you have a function definition or a simple product.


uploaded a worksheet (use the big green arrow in the Mapleprimes toolbar), it is difficult to work out exactly what your problem is. Maybe the attached will help?

# The "classic" wave equation
  we1:= diff(u(x,t), t$2)= c^2*diff(u(x,t), x$2);
# The "usual" variable transformation for the
# above
  we2:= dchange
        ( solve
          ( [ eta=x-c*t, mu=x+c*t],
          {eta, mu},
  we3:=simplify( rhs(we2)-lhs(we2)=0);
# Now solve we3

diff(diff(u(x, t), t), t) = c^2*(diff(diff(u(x, t), x), x))


4*c^2*(diff(diff(u(eta, mu), eta), mu)) = 0


u(eta, mu) = _F2(eta)+_F1(mu)


# Note that one can get the same answer more or less directly

u(x, t) = _F1(c*t+x)+_F2(c*t-x)



Download tw.mw


main plot commands which provide "contours". These are





The first two of these produce contours for continuous expressions: the second two produce contours for a "grid" of discrete data. So far as I am aware, you only have data at discrete points, so you are restricted to the last two entries above. You may be able to restructure your code (slightly?) to use either of the first two, if you define a procedure whihc returns a meaningful answer for a pair of supplied variables whose ranges you provide. You (probably?) won't be able to specify the exact points which will be used in this case, since these will be determined by Maple's adaptive plotting routines.

See the attached "toy" example for usage, where I produce plots for the "same" expression using all four commands. (I haven't bothered to make these look as similar as possible by adjusting color schemes, number of contours, axes positions, etc, etc)

  f:=(x,y)-> sin(x/5*y/5);
# Produce a standard 2D contour plot of the
# above expression
  contourplot( f, -15..15, -15..15, filledregions=true);
# Produce a standard 3D contour plot of the
# above expression
  contourplot3d( f, -15..15, -15..15, filledregions=true);
# Sample the above expression on a 31 by 31 grid to a listlist
# structure and use listcontplot to generate a 2D contourplot
# of the result
  listcontplot([seq([seq( f(x,y), x=-15..15)], y=-15..15)], filledregions=true);
# Sample the above expression on a 31 by 31 grid to a listlist
# structure and use listcontplot3d to generate a 3D contourplot
# of the result
  listcontplot3d([seq([seq( f(x,y), x=-15..15)], y=-15..15)], filledregions=true);

proc (x, y) options operator, arrow; sin((1/25)*x*y) end proc








Download conPlot.mw


generate 3 lists each of which has 21 entries so plot axes will be 1..3 nd 1..21. If this isn't clear enough consider the attached "toy" example from the listcontplot help pags



  # there are 31 lists with 31 entries, so both axes
  # will run from 1 to 31.
    listcontplot([seq([seq( sin(x/5*y/5), x=-15..15)], y=-15..15)]);


  # there are 11 lists with 31 entries, so one axis
  # will be 1..11 and the other will be 1..31
    listcontplot([seq([seq( sin(x/5*y/5), x=-15..15)], y=-5..5)]);


  # there are 11 lists with 7 entries, so one axis
  # will be 1..11 and the other will be 1..71
    listcontplot([seq([seq( sin(x/5*y/5), x=-3..3)], y=-5..5)]);



Download lcp.mw


have I seen code with so many basic logical, mathematical and syntactical errors.

In the attached I attempted to list these and suggest corrections based on what I guessed to be your intention, but eventually I had to give up.

So for what it is worth

# OP's attempt at code
#     with(PDEtools):L:=2:
#     PDEtools[declare](theta(r, z), prime = r, prime = z);
#     PDEtools[declare](sigma(r, z), prime = r, prime = z);
# Problems:
# 1. Why load the PDEtools package and the use the longform
#    calling sequence PDEtools[declare]() ?
# 2. 'prime' notation can only be used for functions of one
#    variable. If I were to write g'(x,y), with respect to
#    which variable has the differentiation been performed?
# Since OP obviously does not understand clever notation, or
# how to use it, probably safest not to bother with it, in
# which case the above attempt at code becomes

# OP's next attempt at code
#      theta(r, z):=sum((p^i)*theta[i](r, z),i=0..L):  
#      sigma(r, z):=sum((p^i)*sigma[i](r, z),i=0..L);
# Problems:
# 1. *Never* use an indexed variable, and an unindexed variable
#    with the saem name. For exampl theta[i](r,z) in the above
#    defines the i-th entry in a table named theta: Is the theta
#    on the left-hand side of this assignment the same table? Or
#    maybe something "different. This confuses me, and it confuses
#    Maple
# 2. Don't use sum() when you should be using add()
# Fix the above attempt at code - note the capitalization on
# the left-hand side of the assignments to avoid the name clash
# described in (1) aabove
  Theta(r, z):= add((p^i)*theta[i](r, z), i=0..L);
  Sigma(r, z):= add((p^i)*sigma[i](r, z), i=0..L);

theta[0](r, z)+p*theta[1](r, z)+p^2*theta[2](r, z)


sigma[0](r, z)+p*sigma[1](r, z)+p^2*sigma[2](r, z)


# OP's next attempt at code
# HO1:=(1-p)*(diff(theta(r, z),r,r))+p*(((1/r)*(diff(theta(r, z),r))+Nb*((diff(theta(r, z),r))*diff(sigma(r, z),r))+Nt*(diff(theta(r, z),r)^2))):
# expand(%):
# collect(%,p):
# HO2:=(1-p)*(diff(sigma(r, z),r,r))+p*(((1/r)*(diff(sigma(r, z),r))+(Nt/Nb)*((diff(delta(r, z),r,r))+(1/r)*diff(delta(r, z),r)))):
# expand(%):
# collect(%,p):
# Problems.
# 1. All instances of 'theta(r,z) and 'sigma(r,z) in the above will
#    have to be replaced with 'Theta(r,z) and 'Sigma(r,z)' for reasons
#    described in the comments of the preceding execution group
# 2. The expand() and collect() function in the above are pointless.
#    Their output is not assigned to anything and so cannot be
#    subsequently called by anything.
# 3. OP has two equations, but even after collecting coefficients of
#    powers of 'p' later ther will be *three* dependent variables.
#    This is not going to end well, but leave it for now!
#    Where did delta(r,z) come from?
  HO1:=(1-p)*(diff(Theta(r, z),r,r))+p*(((1/r)*(diff(Theta(r, z),r))+Nb*((diff(Theta(r, z),r))*diff(Sigma(r, z),r))+Nt*(diff(Theta(r, z),r)^2)));
  HO2:=(1-p)*(diff(Sigma(r, z),r,r))+p*(((1/r)*(diff(Sigma(r, z),r))+(Nt/Nb)*((diff(delta(r, z),r,r))+(1/r)*diff(delta(r, z),r))));

(1-p)*(diff(diff(theta[0](r, z), r), r)+p*(diff(diff(theta[1](r, z), r), r))+p^2*(diff(diff(theta[2](r, z), r), r)))+p*((diff(theta[0](r, z), r)+p*(diff(theta[1](r, z), r))+p^2*(diff(theta[2](r, z), r)))/r+Nb*(diff(theta[0](r, z), r)+p*(diff(theta[1](r, z), r))+p^2*(diff(theta[2](r, z), r)))*(diff(sigma[0](r, z), r)+p*(diff(sigma[1](r, z), r))+p^2*(diff(sigma[2](r, z), r)))+Nt*(diff(theta[0](r, z), r)+p*(diff(theta[1](r, z), r))+p^2*(diff(theta[2](r, z), r)))^2)


(1-p)*(diff(diff(sigma[0](r, z), r), r)+p*(diff(diff(sigma[1](r, z), r), r))+p^2*(diff(diff(sigma[2](r, z), r), r)))+p*((diff(sigma[0](r, z), r)+p*(diff(sigma[1](r, z), r))+p^2*(diff(sigma[2](r, z), r)))/r+Nt*(diff(diff(delta(r, z), r), r)+(diff(delta(r, z), r))/r)/Nb)



# OP's next code attempt
#     for i from 0 to L+1 do equa[1][i]:=coeff(HO1,p,i)=0 end  do:
#     for i from 0 to L+1 do equa[2][i]:=coeff(HO2,p,i)=0 end  do:
# Questions
# 1. Why use two 'for' loops when one will suffice?
# 2. Why use indexed variable on the left-hand-side
#    of these assignments when there is no need. This
#    just makes "notation" even more confusing
  for i from 0 to L+1 do
  end  do;

diff(diff(theta[0](r, z), r), r) = 0


diff(diff(sigma[0](r, z), r), r) = 0


diff(diff(theta[1](r, z), r), r)-(diff(diff(theta[0](r, z), r), r))+(diff(theta[0](r, z), r))/r+Nb*(diff(theta[0](r, z), r))*(diff(sigma[0](r, z), r))+Nt*(diff(theta[0](r, z), r))^2 = 0


diff(diff(sigma[1](r, z), r), r)-(diff(diff(sigma[0](r, z), r), r))+(diff(sigma[0](r, z), r))/r+Nt*(diff(diff(delta(r, z), r), r)+(diff(delta(r, z), r))/r)/Nb = 0


diff(diff(theta[2](r, z), r), r)-(diff(diff(theta[1](r, z), r), r))+(diff(theta[1](r, z), r))/r+Nb*(diff(theta[0](r, z), r))*(diff(sigma[1](r, z), r))+Nb*(diff(theta[1](r, z), r))*(diff(sigma[0](r, z), r))+2*Nt*(diff(theta[0](r, z), r))*(diff(theta[1](r, z), r)) = 0


diff(diff(sigma[2](r, z), r), r)-(diff(diff(sigma[1](r, z), r), r))+(diff(sigma[1](r, z), r))/r = 0


-(diff(diff(theta[2](r, z), r), r))+(diff(theta[2](r, z), r))/r+Nb*(diff(theta[0](r, z), r))*(diff(sigma[2](r, z), r))+Nb*(diff(theta[1](r, z), r))*(diff(sigma[1](r, z), r))+Nb*(diff(theta[2](r, z), r))*(diff(sigma[0](r, z), r))+Nt*(2*(diff(theta[0](r, z), r))*(diff(theta[2](r, z), r))+(diff(theta[1](r, z), r))^2) = 0


-(diff(diff(sigma[2](r, z), r), r))+(diff(sigma[2](r, z), r))/r = 0


# OP's next code attempt, even more hilarious
#    con[1][0]:=theta(r,z)[0](h(z),0)=0,(D(theta(r,z)[0]))(0,0)=0:
#    con[2][0]:=sigma(r,z)[0](h(z),0)=0,(D(sigma(r,z)[0]))(0,0)=0:
#    for j from 1 to L do:
#         con[1][j]:=theta(r,z)[j](h(z),0)=0,(D(theta(r,z)[j]))(0)=0:
#         con[2][j]:=sigma(r,z)[j](h(z),0)=0,(D(sigma(r,z)[j]))(0)=0:
#    end do;
# Problems
# 1. There are no functions theta(r,z)[0] or sigma(r,z)[0], these
#    should presumably be theta[0](r,z) and sigma[0](r,z)
# 2. The correction in (1) above shows just how preposterous
#    the original definition is because then we would have
#    theta[0](r,z)(h(z), 0) - which is a "sensible" function
#    isn't it!!!
# 3. The derivative conditions above have the same inept function
#    definition. Furthermore the 'D' operator has no indication
#    of which independent variable differetniation is with respect
#    to. In the corrected code below I have assume that it is the
#    first variable
# 4. Why is the case j=0 treated separately from the others? There
#    seems to be no reason! Just run the loop from 0 to L.
# 5. Why the unnecessary indexing on the left hand side of the
#    assignements - again just to make the notation as confusing
#    as possible?
  for j from 0 to L do
      con1[j]:= theta[j](h(z),0)=0, D[1](theta[j])(0,0)=0:
      con2[j]:= sigma[j](h(z),0)=0, D[1](sigma[j])(0,0)=0:
  end do;

theta[0](h(z), 0) = 0, (D[1](theta[0]))(0, 0) = 0


sigma[0](h(z), 0) = 0, (D[1](sigma[0]))(0, 0) = 0


theta[1](h(z), 0) = 0, (D[1](theta[1]))(0, 0) = 0


sigma[1](h(z), 0) = 0, (D[1](sigma[1]))(0, 0) = 0


theta[2](h(z), 0) = 0, (D[1](theta[2]))(0, 0) = 0


sigma[2](h(z), 0) = 0, (D[1](sigma[2]))(0, 0) = 0


# This is when I lost the will to live
#       for i from 0 to L do:
#           dsolve({equa[1][i],con[1][i]},delta(r,z)[i](r)):
#           delta(r,z)[i](r):=rhs(%);
#           delta(r,z)[i](r):=evalf(%);
#           dsolve({equa[2][i],con[2][i]},sigma(r,z)[i](r)):
#           sigma(r,z)[i](r):=rhs(%);
#           sigma(r,z)[i](r):=evalf(%);
#       end do;
# There are so many errors (logical and syntactical) in the
# above that I don't even know where to start
# 1. What does this delta(r,z)[i](r) mean? A function
#    theta() which takes two variables (r,z) which returns an
#    indexable quantity 'delta(r,z)[i]' which in trurn is a function
#    function accepting the single variable r ????
# 2. Ditto for the gobbledegook sigma(r,z)[i](r).
# 3. So the OP apparently wants to solve differential equations
#    for functions whihc do not exist in the differetnial equations
# More out of idle curiosity rather than anything else. what is
# the system to be solved first time the loop executes (ie i=0)
  eval( [equa1[0], con1[0]], i=0);
# And dsolve() will Error on this because of the invalid boundary
# condition involving the unknown function h(z)
# Check the other equation
  eval( [equa2[0], con2[0]], i=0);
# dsolve() will error on this for the same reason as above

[diff(diff(theta[0](r, z), r), r) = 0, theta[0](h(z), 0) = 0, (D[1](theta[0]))(0, 0) = 0]


Error, (in dsolve) unexpected occurrence of the variables {z} in the 1st operand of theta[0](h(z),0) in the given initial conditions


[diff(diff(sigma[0](r, z), r), r) = 0, sigma[0](h(z), 0) = 0, (D[1](sigma[0]))(0, 0) = 0]




Download hpm2.mw


your latest post very carefully, I now have absolutely no idea what you are trying to achieve.

The secret to getting a sensible answer is to ask a sensible question

4 5 6 7 8 9 10 Last Page 6 of 196