tomleslie

13876 Reputation

20 Badges

15 years, 182 days

MaplePrimes Activity


These are replies submitted by tomleslie

@Earl I can't read these files becuase your links don't work. If I could read them I might be able to come up with a fix

@acer 

What was "special" about the files where it failed? Maybe if I could look at these then some modification might be possible

The strings with(plots) or with(plottools) do not exist in this file as plaintext - just dump it into a halfway decent editor to check.

On the other hand if you load this worksheet in Maple2016, convert to 1D input, then save.

The strings with(plots) and with(plottools) now appear as plaintext so the approach I suggested will work

I think my fundamental mistake was to only test my original script on 1D input Maple files - it didn't really occur to me that the format of 'mw' files would change so much depending on 1d vs 2d input - I would have expected this just to be a simple 'switch' somewhere near the start of the file - not significant changes in the 'boody' of the file

The worksheet

Classical_Mechanics_5.5_bead_sliding_down_wire_at_constant_velocity.mw

does not *seem* to use with(VariationalCalculus) - hence it will not be found. It is possible that in defining the user library called by libname() you may have "included" the VariationalCalculus() package. This will not be detected. It would be theoretically possible to find the argument of the libname() command, then apply ReadFile() to this file, checking for anything which might refer to the 'VariationalCalculus'. However it occurs to me that there are a host of ways in which any given worksheet *might* read/load another file which in turn loads the VariationaCalculus() package. Or you might load a file, which loads another file, whihc loads another file.......etc, etc..........which loads the VariationalCalculus package. This could get seriously ugly to detect in general. Mainly because one would actually have to 'execute' worksheets to just to determine what is being loaded

On the issue of 2D input: so far as I can tell, in Maple 2016, if the statement with(VariationalCalculus) occurs in the original Maple worksheet, then it will appear as plaintext in the resulting .mw file and can therefore be found using the approach I have already described.

However I accept that in Maple 2018, the level of encoding applied to .mw files appears to have increased, and the target string may not occur in the output file (other than in some coded form). Hence my suggestion (or grep, and other OS tools such as perl) will not work,because it seems impossible to work out what to search for.

@basha 666 

  1. Your code does not contain the first PDE of the system - probably a simple oversight
  2. There is a typo in the first equation of your code diff(u(x,y,t),t)+u(x,y,t)*diff(u(x,y,t),x)+v(x,y,t)*diff(u(x,y,t),y)=diff(u(x,y,t),y$2)+gr*h(x,y,t)+gr*c(x,y,t)-m*u(x,y,t) should(?) be  diff(u(x,y,t),t)+u(x,y,t)*diff(u(x,y,t),x)+v(x,y,t)*diff(v(x,y,t),y)=diff(u(x,y,t),y$2)+gr*h(x,y,t)+gr*c(x,y,t)-m*u(x,y,t)
  3. You have 14 initial/boundary conditions: examining the equations, I think you only need 13
  4. Maple's built-in numeric pde solvers only allow 2 (or fewer) independent variables, usually interpreted as one spatial variable and one temporal variable. You have three independent variables, two spatial, one temporal. Hence no built-in Maple routine can handle this problem. You would seem to have two (maybe three) choices
    1. Possibly some kind of spatial symmetry consideration would allow you to reduce the number of spatial variables - for example, if the probalem exhibits radial symmetry
    2. Possibly the form of the temporal variation is known - for example it is an exponential decay
    3. It is possible to write code to numerically solve systems of pdes in three variables, but this is going to be a very lengthy exercise

 

If you have four dependent functions, you are going to need four equations

I'm running 64-bit win7. In Maple 2017, the sequence File-Export As, does not result in a sub-menu (such as you show) but a fresh pop-up window, one of whose options is pdf. See attached screen grab.

I'm not sure why there would be a difference in export formats resulting from an OS difference

In addition, if I just enter ?pdf at the Maple prompt, I get the help page (emphasis added)

PDF (.pdf) File Format
PDF file format

Description
Notes
Description
• PDF (Portable Document Format) is a document file format.
• PDF is the native file format of Adobe Acrobat and widely used for exchanging multi-page formatted documents in a platform-independent fashion.
Maple documents can be translated to PDF using the Export as PDF menu option.
• Additionally the Context Panel can be used to export Maple plot graphics to this format.
Notes
• Content-Type: application/pdf
See Also
Exporting documents to PDF
Formats

What happens when you query the Maple help for pdf?

@Amna Raja 

because if I just evaluate the pde with the given solution (and do some "simplification"), then it appears that the solution is valid. See the attached (slightly extended version of my previous code)

  restart;
  assume(r::real, a::real, b::real, upsilon::real, sigma::real, x::real, y::real, t > 0);
  assume(sigma > 0);
  assume(-b^2-r+2 > 0);
  evalc(Im(b*y+r*t));
#
# define equation
#
  pde:=I*(diff(V(x,y,t), t))+diff(V(x,y,t), x, x)+diff(V(x,y,t), y, y)+sigma*abs(V(x,y,t)^2)*V(x,y,t) = 0;
#
# "Supplied solution"
#
  sol:=V(x, y, t) = -2*exp(I*(sqrt(-b^2-r+2)*x+b*y+r*t))*sqrt(1/sigma)*sech(-t*(-2*sqrt(-b^2-r+2)-2*b)-x-y);
#
# Test this solution in the pde with pdetest()
#
  evalc( simplify( pdetest( sol, pde) ));
#
# Just evaluate the pde with the supplied solution
#
  evalc( simplify( eval(pde, sol)));

0

 

I*(diff(V(x, y, t), t))+diff(diff(V(x, y, t), x), x)+diff(diff(V(x, y, t), y), y)+sigma*abs(V(x, y, t))^2*V(x, y, t) = 0

 

V(x, y, t) = -2*exp(I*((-b^2-r+2)^(1/2)*x+b*y+r*t))*sech(-t*(-2*(-b^2-r+2)^(1/2)-2*b)-x-y)/sigma^(1/2)

 

-64*exp(2*t*(-b^2-r+2)^(1/2)+2*t*b+x+y)*cos((-b^2-r+2)^(1/2)*x+b*y+r*t)*(-exp(4*t*(-b^2-r+2)^(1/2)+4*t*b+2*x+2*y)*(exp(2*t*(-b^2-r+2)^(1/2)+2*t*b-x-y)+exp(-2*t*(-b^2-r+2)^(1/2)-2*t*b+x+y))^2+exp(8*t*((-b^2-r+2)^(1/2)+b))+2*exp(4*t*(-b^2-r+2)^(1/2)+4*t*b+2*x+2*y)+exp(4*x+4*y))/(sigma^(1/2)*(exp(4*t*((-b^2-r+2)^(1/2)+b))+exp(2*x+2*y))^3*(exp(2*t*(-b^2-r+2)^(1/2)+2*t*b-x-y)+exp(-2*t*(-b^2-r+2)^(1/2)-2*t*b+x+y))^2)-(64*I)*exp(2*t*(-b^2-r+2)^(1/2)+2*t*b+x+y)*sin((-b^2-r+2)^(1/2)*x+b*y+r*t)*(-exp(4*t*(-b^2-r+2)^(1/2)+4*t*b+2*x+2*y)*(exp(2*t*(-b^2-r+2)^(1/2)+2*t*b-x-y)+exp(-2*t*(-b^2-r+2)^(1/2)-2*t*b+x+y))^2+exp(8*t*((-b^2-r+2)^(1/2)+b))+2*exp(4*t*(-b^2-r+2)^(1/2)+4*t*b+2*x+2*y)+exp(4*x+4*y))/(sigma^(1/2)*(exp(4*t*((-b^2-r+2)^(1/2)+b))+exp(2*x+2*y))^3*(exp(2*t*(-b^2-r+2)^(1/2)+2*t*b-x-y)+exp(-2*t*(-b^2-r+2)^(1/2)-2*t*b+x+y))^2)

 

0 = 0

(1)

 


 

Download pdtest2.mw

Why does intersection() require rationals, when IsOnObject() doesn't?

Cos both IsOnObject() commands here return 'true'

restart;
with(geom3d):
line(l1, [point(p1, [15, 6, 3.4]), vector([-4, 12, .3])]):
line(l2, [point(p2, [-17, 54, 3.2]), vector([6, -6, .2])]):
IsOnObject( point(p3, [7, 30, 4]), l1);
IsOnObject( point(p3, [7, 30, 4]), l2);

 

so what else do you want to know?

When you sya you want to find "skin friction", is this some function of the dependent/independet variables in the code?

Calculates the real roots in as "simple" a fashion as possible - which means it may run in Maple 12. I only keep the most recent five versions of Maple on this machine so I can't test in Maple 12
 

restart; S3 := -(1/2*I)*(-(2*I)*exp(I*Pi*k*tau/T)*Pi*k-exp(I*Pi*k*tau/T)*T+I*exp(I*Pi*k*tau/T)*Pi*k*tau+(4*I)*Pi*k-(2*I)*exp(-I*Pi*k*tau/T)*Pi*k+exp(-I*Pi*k*tau/T)*T+I*exp(-I*Pi*k*tau/T)*Pi*k*tau)*sin(2*Pi*k*x/T)/(Pi^2*k^2)

-((1/2)*I)*(-(2*I)*exp(I*Pi*k*tau/T)*Pi*k-exp(I*Pi*k*tau/T)*T+I*exp(I*Pi*k*tau/T)*Pi*k*tau+(4*I)*Pi*k-(2*I)*exp(-I*Pi*k*tau/T)*Pi*k+exp(-I*Pi*k*tau/T)*T+I*exp(-I*Pi*k*tau/T)*Pi*k*tau)*sin(2*Pi*k*x/T)/(Pi^2*k^2)

(1)

"(->)"(-2*cos(Pi*k*tau/T)*Pi*k-sin(Pi*k*tau/T)*T+cos(Pi*k*tau/T)*Pi*k*tau+2*Pi*k)*sin(2*Pi*k*x/T)/(Pi^2*k^2)

S3 = ((-I)*(1/2))*((I*Pi*k*tau-(2*I)*Pi*k)*(exp(I*Pi*k*tau/T)+exp(-I*Pi*k*tau/T))-T*(exp(I*Pi*k*tau/T)-exp(-I*Pi*k*tau/T))+(4*I)*Pi*k)*sin(2*Pi*k*x/T)/(Pi^2*k^2)

-((1/2)*I)*(-(2*I)*exp(I*Pi*k*tau/T)*Pi*k-exp(I*Pi*k*tau/T)*T+I*exp(I*Pi*k*tau/T)*Pi*k*tau+(4*I)*Pi*k-(2*I)*exp(-I*Pi*k*tau/T)*Pi*k+exp(-I*Pi*k*tau/T)*T+I*exp(-I*Pi*k*tau/T)*Pi*k*tau)*sin(2*Pi*k*x/T)/(Pi^2*k^2) = -((1/2)*I)*((I*Pi*k*tau-(2*I)*Pi*k)*(exp(I*Pi*k*tau/T)+exp(-I*Pi*k*tau/T))-T*(exp(I*Pi*k*tau/T)-exp(-I*Pi*k*tau/T))+(4*I)*Pi*k)*sin(2*Pi*k*x/T)/(Pi^2*k^2)

(2)

"(->)"true"(->)"true

convert(S3, trig) = (-2*cos(Pi*k*tau/T)*Pi*k-sin(Pi*k*tau/T)*T+cos(Pi*k*tau/T)*Pi*k*tau+2*Pi*k)*sin(2*Pi*k*x/T)/(Pi^2*k^2)

-((1/2)*I)*(-(2*I)*(cos(Pi*k*tau/T)+I*sin(Pi*k*tau/T))*Pi*k-(cos(Pi*k*tau/T)+I*sin(Pi*k*tau/T))*T+I*(cos(Pi*k*tau/T)+I*sin(Pi*k*tau/T))*Pi*k*tau+(4*I)*Pi*k-(2*I)*(cos(Pi*k*tau/T)-I*sin(Pi*k*tau/T))*Pi*k+(cos(Pi*k*tau/T)-I*sin(Pi*k*tau/T))*T+I*(cos(Pi*k*tau/T)-I*sin(Pi*k*tau/T))*Pi*k*tau)*sin(2*Pi*k*x/T)/(Pi^2*k^2) = (-2*cos(Pi*k*tau/T)*Pi*k-sin(Pi*k*tau/T)*T+cos(Pi*k*tau/T)*Pi*k*tau+2*Pi*k)*sin(2*Pi*k*x/T)/(Pi^2*k^2)

(3)

"(->)"true"(->)"true``

 

Set the following for the Fourier coeffs:``

Ck := simplify(convert(S3, trig)/sin(2*Pi*k*x/T), size)

(Pi*k*(tau-2)*cos(Pi*k*tau/T)-sin(Pi*k*tau/T)*T+2*Pi*k)/(Pi^2*k^2)

(4)

 

NULL

T := N*tau; m := 10; a[0] := 0; N := 2; tau := 2; T; Ck

(-4*sin((1/2)*Pi*k)+2*Pi*k)/(Pi^2*k^2)

(5)

Plot the results:````

plots[display](plot(a[0]+sum(Ck*sin(2*Pi*k*x/T), k = 1 .. 5), x = -2 .. 2, numpoints = 400, axis[1] = [mode = linear], axis[2] = [mode = linear]), plot(a[0]+sum(Ck*sin(2*Pi*k*x/T), k = 1 .. 10), x = -2 .. 2, color = "LimeGreen"), plot(a[0]+sum(Ck*sin(2*Pi*k*x/T), k = 1 .. 20), x = -2 .. 2, color = "Blue"), plot(a[0]+sum(Ck*sin(2*Pi*k*x/T), k = 1 .. 50), x = -2 .. 2, color = "Orange"))

 

 

plots[display](plot(diff(a[0]+sum(Ck*sin(2*Pi*k*x/T), k = 1 .. 5), x), x = -1 .. 1, numpoints = 400, axis[1] = [mode = linear], axis[2] = [mode = linear]), plot(diff(a[0]+sum(Ck*sin(2*Pi*k*x/T), k = 1 .. 10), x), x = -1 .. 1, color = "LimeGreen"), plot(diff(a[0]+sum(Ck*sin(2*Pi*k*x/T), k = 1 .. 20), x), x = -1 .. 1, color = "Blue"))

 

 

NULL

``

#
# Set number of terms to be used in the summation
# and the number of roots to be determined (in the
# case of real roots. I tested this up to 100000
# terms in the sum and 100 roots (for the case of
# real roots): this took about 120secs on my machine,
# with a memory usage of 2MiB. With the supplied values
# below, calculation took about 13secs on my machine
# and still used only 2MiB
#
# Write the sequentisl root-finding process as a
# procedure just to facilitate resource reporting
#
# Rewrite the code in as simple terms as possible,
# delete the resource monitoring and don't use
# Array() (which may not have been implemented)
# so that it has a chance of executing in Maple 12
#
  with(RootFinding):
  nTerms:=10000:
  nRoots:=100:
  rts:=[0]:
  f:= unapply
      ( diff
        ( a[0] + Sum
                 ( Ck*sin(2*Pi*k*x/T),
                   k = 1 .. nTerms
                 ),
          x
        ),
        x
      );
  for i from 2 to nRoots do
      rts:= [rts[], NextZero(f, rts[i-1])];
  od:
  rts;
  rts[1..floor(sqrt(nRoots))];

proc (x) options operator, arrow; Sum((1/2)*(-4*sin((1/2)*Pi*k)+2*Pi*k)*cos((1/2)*Pi*k*x)/(Pi*k), k = 1 .. 10000) end proc

 

[0, 0.1999700038e-3, 0.4000199997e-3, 0.5999100115e-3, 0.8000399994e-3, 0.9998500192e-3, 0.1200059999e-2, 0.1399790026e-2, 0.1600079999e-2, 0.1799730034e-2, 0.2000099998e-2, 0.2199670042e-2, 0.2400119998e-2, 0.2599610049e-2, 0.2800139998e-2, 0.2999550057e-2, 0.3200159998e-2, 0.3399490064e-2, 0.3600179998e-2, 0.3799430071e-2, 0.4000199999e-2, 0.4199370078e-2, 0.4400219999e-2, 0.4599310085e-2, 0.4800240000e-2, 0.4999250092e-2, 0.5200260000e-2, 0.5399190099e-2, 0.5600280001e-2, 0.5799130106e-2, 0.6000300002e-2, 0.6199070112e-2, 0.6400320003e-2, 0.6599010118e-2, 0.6800340005e-2, 0.6998950124e-2, 0.7200360006e-2, 0.7398890130e-2, 0.7600380008e-2, 0.7798830136e-2, 0.8000400010e-2, 0.8198770141e-2, 0.8400420012e-2, 0.8598710146e-2, 0.8800440015e-2, 0.8998650151e-2, 0.9200460017e-2, 0.9398590155e-2, 0.9600480020e-2, 0.9798530160e-2, 0.1000050002e-1, 0.1019847016e-1, 0.1040052002e-1, 0.1059841016e-1, 0.1080054003e-1, 0.1099835017e-1, 0.1120056003e-1, 0.1139829017e-1, 0.1160058004e-1, 0.1179823017e-1, 0.1200060004e-1, 0.1219817017e-1, 0.1240062005e-1, 0.1259811018e-1, 0.1280064005e-1, 0.1299805018e-1, 0.1320066006e-1, 0.1339799018e-1, 0.1360068006e-1, 0.1379793018e-1, 0.1400070007e-1, 0.1419787018e-1, 0.1440072008e-1, 0.1459781018e-1, 0.1480074008e-1, 0.1499775018e-1, 0.1520076009e-1, 0.1539769018e-1, 0.1560078010e-1, 0.1579763018e-1, 0.1600080011e-1, 0.1619757018e-1, 0.1640082012e-1, 0.1659751017e-1, 0.1680084013e-1, 0.1699745017e-1, 0.1720086014e-1, 0.1739739017e-1, 0.1760088015e-1, 0.1779733016e-1, 0.1800090016e-1, 0.1819727016e-1, 0.1840092017e-1, 0.1859721016e-1, 0.1880094019e-1, 0.1899715015e-1, 0.1920096020e-1, 0.1939709014e-1, 0.1960098021e-1, 0.1979703014e-1]

 

[0, 0.1999700038e-3, 0.4000199997e-3, 0.5999100115e-3, 0.8000399994e-3, 0.9998500192e-3, 0.1200059999e-2, 0.1399790026e-2, 0.1600079999e-2, 0.1799730034e-2]

(6)

 

 

NULL


 

Download getRoots2.mw

@Vaishnavi 

I have just tried the original worksheet (getSols.mw) in Maple 2017.3 and it produces the same answer as reported in my earlier post.

In order to use the second worksheet (getSols2.mw), you will need to download/install the DirectSearch() add-on package from the Maple Application Centre

If neither of the above solves your problem, then

  1. execute the worksheet which shows the problem
  2. save the worksheet (with all the output, error messages, etc)
  3. upload this worksheet here using the big green up-arrow in the toolbar

Your original question says that you want to

plot it in the box -1<=x,y,z<=1

In a fieldplot3d() command, you cannot define plot ranges as inequalities, you have to set the plot ranges as in x=-1..1, y=-1..1, z=-1..1. You can set up expressions for the end points of these ranges, as in x=expr1..expr2, y=expr3..expr4, z=expr5..expr6, provided that all of the 'exprn' can be evaluated to numeric quantities.

So for example if you know (or can calculate) that -xlim1<=x<=xlim2, then just set the correspondng range in the fieldplot3d() command to x=-xlim1..xlim2, and similarly for other coordinates.

whihc is available from as a free download from the Maple Applications Centre, I obtained a 'better' solution than the above (ie lower residuals), see attached

A := 2500

2500

(1)

alpha := 4

4

(2)

beta := 0.2e-1

0.2e-1

(3)

c := 5

5

(4)

x[w] := 10

10

(5)

x[1] := 8

8

(6)

delta := 5

5

(7)

t[d] := .5

.5

(8)

a := 20

20

(9)

b := 25

25

(10)

theta := .5

.5

(11)

m := theta*(1-exp(-.5*xi))

.5-.5*exp(-.5*xi)

(12)

TC(t[1], t[2], xi) := (A+alpha*((1/2)*a*t[d]^2+(1/3)*a*t[d]^3)+beta*((1/6)*a*t[d]^3+(1/8)*a*t[d]^4)+t[d]*(a/(theta-m)+b*(t[d]-1/(theta-m))/(theta-m)-exp((theta-m)*(t[1]-t[d]))*(a/(theta-m)+b*(t[1]-1/(theta-m))/(theta-m)))-a*(-6*beta*b-(6*(theta-m))*(-a*beta+alpha*b)+6*(theta-m)^2*(a*beta*t[1]+alpha*b*t[d])+3*b*beta*(theta-m)^2*(-t[1]^2+t[d]^2)+6*a*alpha*(theta-m)^2+2*b*beta*(theta-m)^3*(t[1]^3-t[d]^3)+3*a*beta*(theta-m)^3*(t[1]^2-t[d]^2)+3*b*alpha*(theta-m)^3*(t[1]^2-t[d]^2)+6*a*alpha*(theta-m)^3*(t[1]-t[d])+6*exp((theta-m)*(t[1]-t[d]))*((6*(theta-m))*(-a*beta+alpha*b)-6*b*beta*(theta-m)*(t[1]-t[d])-6*((theta-m)^2*(-b*beta*t[1]*t[d]+a*beta*t[d]+alpha*b*t[1]+a*alpha)+beta*b)))/(6*(theta-m)^4)+x[1]*(2*a*t[2]*delta^2+2*b*t[1]*t[2].(delta^2)+b*t[2]*delta-2*a*delta*ln(delta*t[2]+1)-2*b*ln(delta*t[2]+1)-2*b*t[1]*delta*ln(delta*t[2]+1)-2*b*t[2]*delta*ln(delta*t[2]+1)+2*b*t[2]*delta)/(2*delta^2)+x[w]*(2*a*t[2]*delta^2+b*t[2]^2*delta^2+2*b*t[1]*t[2].(delta^2)+2*a*delta*t[2]+2*b*t[2]*delta*ln(1/(delta*t[2]+1))+2*b*ln(1/(delta*t[2]+1))+2*a*delta*ln(1/(delta*t[2]+1))+2*b*t[1]*delta*ln(1/(delta*t[2]+1)))/(2*delta^3)+c*(a*t[d]+(1/2)*b*t[d]^3+a/(theta-m)+b*(t[d]-1/(theta-m))/(theta-m)-exp((theta-m)*(t[1]-t[d]))*(a/(theta-m)+b*(t[1]-1/(theta-m))/(theta-m))-a*ln(1/(delta*t[2]+1))/delta-b*(1+delta*(t[1]+t[2]))*ln(delta*t[2]+1)/delta^2-b*t[2]/delta))/(t[1]+t[2])

(2571.157291+220.0000000/exp(-.5*xi)+275.0000000*(.5-2.000000000/exp(-.5*xi))/exp(-.5*xi)-5.5*exp(.5*exp(-.5*xi)*(t[1]-.5))*(40.00000000/exp(-.5*xi)+50.00000000*(t[1]-2.000000000/exp(-.5*xi))/exp(-.5*xi))-53.33333333*(-3.00-298.800*exp(-.5*xi)+1.50*(exp(-.5*xi))^2*(.40*t[1]+50.0)+.3750*(exp(-.5*xi))^2*(-t[1]^2+.25)+120.00*(exp(-.5*xi))^2+.12500*(exp(-.5*xi))^3*(t[1]^3-.125)+37.65000*(exp(-.5*xi))^3*(t[1]^2-.25)+60.000*(exp(-.5*xi))^3*(t[1]-.5)+6*exp(.5*exp(-.5*xi)*(t[1]-.5))*(298.800*exp(-.5*xi)-1.500*exp(-.5*xi)*(t[1]-.5)-1.50*(exp(-.5*xi))^2*(99.750*t[1]+80.200)-3.00))/(exp(-.5*xi))^4+243*t[2]+250*t[1]*t[2]-40*ln(5*t[2]+1)-40*t[1]*ln(5*t[2]+1)-40*t[2]*ln(5*t[2]+1)+25*t[2]^2+10*t[2]*ln(1/(5*t[2]+1))-10*ln(1/(5*t[2]+1))+10*t[1]*ln(1/(5*t[2]+1))-5*(1+5*t[1]+5*t[2])*ln(5*t[2]+1))/(t[1]+t[2])

(13)

``

``

eq1 := diff(TC(t[1], t[2], xi), t[1]) = 0

-(2571.157291+220.0000000/exp(-.5*xi)+275.0000000*(.5-2.000000000/exp(-.5*xi))/exp(-.5*xi)-5.5*exp(.5*exp(-.5*xi)*(t[1]-.5))*(40.00000000/exp(-.5*xi)+50.00000000*(t[1]-2.000000000/exp(-.5*xi))/exp(-.5*xi))-53.33333333*(-3.00-298.800*exp(-.5*xi)+1.50*(exp(-.5*xi))^2*(.40*t[1]+50.0)+.3750*(exp(-.5*xi))^2*(-t[1]^2+.25)+120.00*(exp(-.5*xi))^2+.12500*(exp(-.5*xi))^3*(t[1]^3-.125)+37.65000*(exp(-.5*xi))^3*(t[1]^2-.25)+60.000*(exp(-.5*xi))^3*(t[1]-.5)+6*exp(.5*exp(-.5*xi)*(t[1]-.5))*(298.800*exp(-.5*xi)-1.500*exp(-.5*xi)*(t[1]-.5)-1.50*(exp(-.5*xi))^2*(99.750*t[1]+80.200)-3.00))/(exp(-.5*xi))^4+243*t[2]+250*t[1]*t[2]-40*ln(5*t[2]+1)-40*t[1]*ln(5*t[2]+1)-40*t[2]*ln(5*t[2]+1)+25*t[2]^2+10*t[2]*ln(1/(5*t[2]+1))-10*ln(1/(5*t[2]+1))+10*t[1]*ln(1/(5*t[2]+1))-5*(1+5*t[1]+5*t[2])*ln(5*t[2]+1))/(t[1]+t[2])^2+(-2.75*exp(-.5*xi)*exp(.5*exp(-.5*xi)*(t[1]-.5))*(40.00000000/exp(-.5*xi)+50.00000000*(t[1]-2.000000000/exp(-.5*xi))/exp(-.5*xi))-275.0000000*exp(.5*exp(-.5*xi)*(t[1]-.5))/exp(-.5*xi)-53.33333333*(.6000*(exp(-.5*xi))^2-.7500*(exp(-.5*xi))^2*t[1]+.37500*(exp(-.5*xi))^3*t[1]^2+75.30000*(exp(-.5*xi))^3*t[1]+60.000*(exp(-.5*xi))^3+3.0*exp(-.5*xi)*exp(.5*exp(-.5*xi)*(t[1]-.5))*(298.800*exp(-.5*xi)-1.500*exp(-.5*xi)*(t[1]-.5)-1.50*(exp(-.5*xi))^2*(99.750*t[1]+80.200)-3.00)+6*exp(.5*exp(-.5*xi)*(t[1]-.5))*(-1.500*exp(-.5*xi)-149.62500*(exp(-.5*xi))^2))/(exp(-.5*xi))^4+250*t[2]-65*ln(5*t[2]+1)+10*ln(1/(5*t[2]+1)))/(t[1]+t[2]) = 0

(14)

eq2 := diff(TC(t[1], t[2], xi), t[2]) = 0

-(2571.157291+220.0000000/exp(-.5*xi)+275.0000000*(.5-2.000000000/exp(-.5*xi))/exp(-.5*xi)-5.5*exp(.5*exp(-.5*xi)*(t[1]-.5))*(40.00000000/exp(-.5*xi)+50.00000000*(t[1]-2.000000000/exp(-.5*xi))/exp(-.5*xi))-53.33333333*(-3.00-298.800*exp(-.5*xi)+1.50*(exp(-.5*xi))^2*(.40*t[1]+50.0)+.3750*(exp(-.5*xi))^2*(-t[1]^2+.25)+120.00*(exp(-.5*xi))^2+.12500*(exp(-.5*xi))^3*(t[1]^3-.125)+37.65000*(exp(-.5*xi))^3*(t[1]^2-.25)+60.000*(exp(-.5*xi))^3*(t[1]-.5)+6*exp(.5*exp(-.5*xi)*(t[1]-.5))*(298.800*exp(-.5*xi)-1.500*exp(-.5*xi)*(t[1]-.5)-1.50*(exp(-.5*xi))^2*(99.750*t[1]+80.200)-3.00))/(exp(-.5*xi))^4+243*t[2]+250*t[1]*t[2]-40*ln(5*t[2]+1)-40*t[1]*ln(5*t[2]+1)-40*t[2]*ln(5*t[2]+1)+25*t[2]^2+10*t[2]*ln(1/(5*t[2]+1))-10*ln(1/(5*t[2]+1))+10*t[1]*ln(1/(5*t[2]+1))-5*(1+5*t[1]+5*t[2])*ln(5*t[2]+1))/(t[1]+t[2])^2+(243+250*t[1]-150/(5*t[2]+1)-250*t[1]/(5*t[2]+1)-65*ln(5*t[2]+1)-250*t[2]/(5*t[2]+1)+50*t[2]+10*ln(1/(5*t[2]+1))-25*(1+5*t[1]+5*t[2])/(5*t[2]+1))/(t[1]+t[2]) = 0

(15)

eq3 := diff(TC(t[1], t[2], xi), xi) = 0

(110.0000000/exp(-.5*xi)+137.5000000*(.5-2.000000000/exp(-.5*xi))/exp(-.5*xi)-275.0000000/(exp(-.5*xi))^2+1.375*exp(-.5*xi)*(t[1]-.5)*exp(.5*exp(-.5*xi)*(t[1]-.5))*(40.00000000/exp(-.5*xi)+50.00000000*(t[1]-2.000000000/exp(-.5*xi))/exp(-.5*xi))-5.5*exp(.5*exp(-.5*xi)*(t[1]-.5))*(20.00000000/exp(-.5*xi)+25.00000000*(t[1]-2.000000000/exp(-.5*xi))/exp(-.5*xi)-50.00000000/(exp(-.5*xi))^2)-106.6666667*(-3.00-298.800*exp(-.5*xi)+1.50*(exp(-.5*xi))^2*(.40*t[1]+50.0)+.3750*(exp(-.5*xi))^2*(-t[1]^2+.25)+120.00*(exp(-.5*xi))^2+.12500*(exp(-.5*xi))^3*(t[1]^3-.125)+37.65000*(exp(-.5*xi))^3*(t[1]^2-.25)+60.000*(exp(-.5*xi))^3*(t[1]-.5)+6*exp(.5*exp(-.5*xi)*(t[1]-.5))*(298.800*exp(-.5*xi)-1.500*exp(-.5*xi)*(t[1]-.5)-1.50*(exp(-.5*xi))^2*(99.750*t[1]+80.200)-3.00))/(exp(-.5*xi))^4-53.33333333*(149.4000*exp(-.5*xi)-1.500*(exp(-.5*xi))^2*(.40*t[1]+50.0)-.37500*(exp(-.5*xi))^2*(-t[1]^2+.25)-120.000*(exp(-.5*xi))^2-.187500*(exp(-.5*xi))^3*(t[1]^3-.125)-56.475000*(exp(-.5*xi))^3*(t[1]^2-.25)-90.0000*(exp(-.5*xi))^3*(t[1]-.5)-1.50*exp(-.5*xi)*(t[1]-.5)*exp(.5*exp(-.5*xi)*(t[1]-.5))*(298.800*exp(-.5*xi)-1.500*exp(-.5*xi)*(t[1]-.5)-1.50*(exp(-.5*xi))^2*(99.750*t[1]+80.200)-3.00)+6*exp(.5*exp(-.5*xi)*(t[1]-.5))*(-149.4000*exp(-.5*xi)+.7500*exp(-.5*xi)*(t[1]-.5)+1.500*(exp(-.5*xi))^2*(99.750*t[1]+80.200)))/(exp(-.5*xi))^4)/(t[1]+t[2]) = 0

(16)

``       

fsolve({eq1, eq2, eq3}, {xi, t[1], t[2]})

{xi = 8.906818845, t[1] = -64.35385212, t[2] = -.1999803845}

(17)

eval({eq1, eq2, eq3}, {xi = 8.906818845, t[1] = -64.35385212, t[2] = -.1999803845})

{0.8e-2 = 0, .1549094703 = 0, 3.074 = 0}

(18)

with(DirectSearch), SolveEquations([eq1, eq2, eq3], evaluationlimit = 100000)

[BoundedObjective, CompromiseProgramming, DataFit, ExponentialWeightedSum, GlobalOptima, GlobalSearch, Minimax, ModifiedTchebycheff, Search, SolveEquations, WeightedProduct, WeightedSum], [HFloat(2.1416610048351058e-13), Vector[column](%id = 18446744074377177078), [xi = HFloat(-450.74729702345076), t[1] = HFloat(-74651.7387772571), t[2] = HFloat(0.10000130796574878)], 14053]

(19)

Download getSols2.mw

Maple 12 was obsolete 10 years ago.

If you wan to convert the perfectly functional code which I provided, so that it works in Maple 12, then I suggest you find all instances of

CodeTools:-Usage( someCode )

and just get rid of the time/resource monitoring by replacing with above with

someCode;

How hard can that be? If you find it difficult ask a find a random 10-year-old and ask him/her to explain it to you

Now rather obviously, since the existence of CodeTools:-Usage() in the section generating real roots prevented its execution, various required arguments for the RootFinding:-Analytic() command have not been generated - so it will fail. How difficult is that to understand?

When you say

I looked at the output of your posting & the smallest REAL root was 0.0001999700039 which corresponds to 10000 terms in the series.  I do not see any output for 100000 terms.

Try reading the comments section in my code which says

#
# Set number of terms to be used in the summation
# and the number of roots to be determined (in the
# case of real roots. I tested this up to 100000
# terms in the sum and 100 roots (for the case of
# real roots): this took about 120secs on my machine,
# with a memory usage of 2MiB. With the supplied values
# below, calculation took about 13secs on my machine
# and still used only 2MiB

#
# Write the sequentisl root-finding process as a
# procedure just to facilitate resource reporting
#
  nTerms:=10000:
  nRoots:=100:

Now please highlight in the above which word you don't understand: if you want to use 100000 terms in the summation, then just change the value of nTerms to 100000. Again if this is to difficult for you, just find the nearest 10-year-old and ask for an explanation.

Please note if you do set nTerms=100000, then the computation of real roots will be fine - but I wouldn't run the computation for complex roots unless you have a *lot* of time

First 97 98 99 100 101 102 103 Last Page 99 of 207