Unanswered Questions

This page lists MaplePrimes questions that have not yet received an answer






no matter what e is , expect to output the same 0.733333



I have a set of nonlinear equations (transcendental) containing variables and one free parameter. I want to solve this system for variables while varying parameter's value. I have tried with fsolve and solve commands keeping fixed the parameter value, but they are not solving yet. Is there any way to solve this system for a range of parameter's value.
The systmem is like this, x,y,z are the variables and 'a' is the parameter:

Many thanks in advance.


I submit you this strange result:
for somenumerical  values of a, b, c  (a, b, c real and b > a), Maple 2018 is not able to compute the mean of
c*U where U is a Uniform random variable with support [a, b].





`Standard Worksheet Interface, Maple 2018.0, Windows 7, March 10 2018 Build ID 1298750`


z := .4070716688*RandomVariable(Uniform(0.12-0.02*0.12, 0.12+0.02*0.12));



Error, (in Statistics:-Mean) the expression does not have a taylor expansion at t = 0


z := .4070716688*RandomVariable(Uniform(a, b));
subs({a=0.12-0.02*0.12, b=0.12+0.02*0.12}, %);









Download Mean.mw

PLEASE: Maple still fails if I replace  a = 0.12 -0.02*0.12 by its value 0.1174
                                                                       and b = 0.12+0.02*0.12 by its value 0.1224

This is incomprehensible and could hide a more profound problem.

Hello everyone, i've a problem working with Maple because i have a really big system of equations and for everything that i have to do with them, for example, collect terms, coefficients, take a lot of time from me. The problem it is when, for example, i wait 30 minutes to take the coefficients from a equation and in the next command Maple might stop, then i have to close and start all over again... My question it is if have anyway to save my file in a way that if i close and re open i dont have to compile all again. Maybe this is pretty obvious but i really dont know how to do it, because if i close my work and open again, i have to compile everything again.

I have a eigenvalue problem like:

[FF1]* {w}=N^2 *[FF2] *{w}

[FF1] and [FF2] are a*b matrices (non square matrix) , {w} are vectors(eigenvectors) and the values of N are eigenvalues.

I want to obtain eigenvalues and eigenvectors by computing Moore-Penrose pseudo-inverse of [FF2] and do the procedures below :

[FF2]^-1 * [FF1] *{w} =N^2 *{w}            ,        (assume  [FF2]^-1   is Moore-Penrose pseudo-inverse of [FF2]   )

[FF2]^-1 * [FF1] = [FF3]  ,  ( [FF3] is a b*b matrix- squre matrix) 

so  [FF3] *{w}=N^2 *{w}

then I can use LinearAlgebra[Eigenvectors](FF3) to get eigenvalues and eigenvectors. 

I know that Moore-Penrose pseudo-inverse of [FF2] * [FF1] isn't equal to Identity matrix. [FF2]^-1 * [FF1] <> [ I ] . But assume it can be. ( I have a solution for this problem) . 

My biggest problem is [FF2] and [FF1] are large-scale sparse matrix and it takes hours or several days that maple can compute Moore-Penrose pseudo-inverse of [FF2]  and also LinearAlgebra[Eigenvectors](FF3). 

Main question : can I compute Moore-Penrose pseudo-inverse and LinearAlgebra[Eigenvectors]  by using Parallel Programming?  if the answer is yes , how? give me an example please.

if the answer is No , is there any way (any algorithm) to find the inverse of a large non-sqaure matrix or eigenvalues of a large matrix faster?

please introduce some books for parallel programming in maple or general.



From the attached code, you can see that I have a Matrix, A, that I am trying to output into Fortran code so that I can simply copy and paste this long matrix into fortran. The output does not look correct. Doesa anyone have an idea on how to put this matrix A into a form that can be easily copy and pasted into Fortran? You can see that I tried to do each line individually in the attatched code but I am really looking for a way to do the entire Matrix. Thanks for any help or suggestions.



I'm trying to solve an ODE system from an IVP problem, but the error occurs: "Error, (in ...) cannot evaluate the solution further left of ..., maxfun limit exceeded (see ?dsolve,maxfun for details)"

I've already tried modifying the maxfun value but this did not work. I would like some suggestion.

Thank you



 I created my own costum package and I want to edit this package: insert procedures or modules. Is there a way?

Thank you.

What's going on here? Am I missing something, or is it a bug? If it's a bug, then it's by far the deepest and most profound bug that I've ever found or seen in Maple (and I've seen thousands over the decades). And since that surprises me, my guess is that I'm missing something obvious.

Op:= (R,F)-> F(['R()'$2]):
Op(rand(1..9), [f,f]);
                     [f([7, 6]), f([2, 4])]

The expected output is [f([7,6]), f([7,6])]. The same thing happens if I replace with seq, or if I replace -> with proc.

pls help me cirrect this. i am trying to use finite element method to siolve a fluid equation. The code is give below

> pde := alpha^2*(diff(u(t, r), t))+2*(-1/2)^(1/n)*(diff(u(t, r), r))/r-(-1/2)^((1-n)/n)*(diff(u(t, r), `$`(r, 2)))*(diff(u(t, r), r))^(1/n-1)/n+2*theta/r-4*(1+e)+4*B*cos(.2) = 0; /1\ |-| \n/ /-1\ / d \ 2 |--| |--- u(t, r)| 2 / d \ \2 / \ dr / alpha |--- u(t, r)| + ----------------------- \ dt / r /1 - n\ /1 \ |-----| |- - 1| \ n / \n / /-1\ / d / d \\ / d \ |--| |--- |--- u(t, r)|| |--- u(t, r)| \2 / \ dr \ dr // \ dr / 2 theta - ---------------------------------------------------- + ------- - 4 - 4 e n r + 3.920266311 B = 0 > tmax := 0.5e-1; > rmin := 0; > rmax := 10; > N := 6; > bc1 := diff(u(t, r = rmin), r) = 1/mu; > bc2 := u(t, r = rmax) = 0; > ic1 := u(0, r) = 0; > PDE*Boundary*condition*colllection; > bcs := {u(0, r) = rhs(ic1), D[1](diff(u(t, r = rmin), r)) = rhs(bc1), (D[1](u))(t, r = rmax) = rhs(bc2)}; / / d \ 1 \ { u(0, r) = 0, D[1]|--- u(t, r = 0)| = --, D[1](u)(t, r = 10) = 0 } \ \ dr / mu / > > Collocation*method; > Typesetting[delayDotProduct](Define*a*simple*function*with*known*solution.one, can, true)*choose*either*a*trigonometric*function, othorgonal*polynomia, (Typesetting[delayDotProduct](legendre*polynomia*etc.we, want, true)*will*choose*a*simple*polynomia*which*will)*make*our*work*easier; > basis := r^i; > uhat := sum(A[i](t)*basis, i = 0 .. N-1); > Alist := indets(uhat, function(identical(t))); > Here, we*will*determine*the^2*two*unknowns*(A1, A2)*using*boundary*conditions; > duhat := diff(uhat, r); > knownAs := solve({subs(r = rmin, duhat) = rhs(bc1), subs(A[1](t) = 0, r = rmax, duhat) = rhs(bc2)}, {A[1](t), A[2](t)}); > unknownAs := `minus`(Alist, {seq(lhs(knownAs[i]), i = 1 .. nops(knownAs))}); > `and`(uhat*after*substituting*A1, A2); > uhat := subs(knownAs, uhat); > uhat := collect(uhat, Alist); > Residual*function*is*obtai*ned*after*substituting*uhat*into*the*original*pde; > residual := eval(subs(u(t, r) = uhat, pde)); > residual := collect(residual, r); > `and`(Typesetting[delayDotProduct](Now*we*choose*points*where*exact*solution*must*be*matched.since, we, true)*have*point*A[1], A[2]), we*will*only*need*N-2*points; > odes := {seq(subs(r = i*rmax/N, residual), i = 1 .. nops(unknownAs))}; > Find*ICs*of*unknown*A(t)*s; > iceqs := {seq(subs(t = 0, r = i*rmax/N, uhat) = rhs(bc2), i = 1 .. nops(unknownAs))}; > ics := solve(iceqs, subs(t = 0, unknownAs)); > > sols := dsolve(`union`(odes, ics)); Warning, computation interrupted > Approximate*solution; > uhat := subs(sols, uhat); Error, invalid input: subs received sols, which is not valid for its 1st argument > uhat := collect(uhat, r); > Plot*solution; > plot3d(uhat, r = 0 .. rmax, t = 0 .. tmax, axes = boxed, lightmodel = light4, orientation = [-120, 40], shading = zhue, transparency = .3); Warning, unable to evaluate the function to numeric values in the region; see the plotting command's help page to ensure the calling sequence is correct > >

The question is all in the title really. I am struggling to make a subsection on my macbook, using 2018 Maple software. The cmd + shift + . will only make sections, regardless of where i place my cursor.

I am trying to solve improper integrals using Maple. I need to choose at least one from attached and I am leaning towards number 26 but I am having trouble. I am new to Maple and have no idea where to even begin. Please provide the correct steps needed to get to the right answer.

Hi there:

i use Grid:-Map() to run some code on many cores. When I set


everything runs fine. When I set (note I have 28 logical cores present):


I get the "stack limit reached" message (see attached image below). I've explored setting stack limits to 'unlimited' at the OS level (ubuntu 18.04), as well as setting


However, these do not help, and I still end up with the same message.

Any ideas what could be the problem? Also, I am assuming that kernelopts settings get passed to other, spawned kernels, but even if not, I experimented with setting this directly inside the function that gets passed to Grid:-Map()






a:=sin(theta3(t))*(diff(theta3(t), t))^2*cos(theta1(t))*l1*l3*m3+sin(theta3(t))*(diff(theta3(t), t))^2*cos(theta1(t))*l1*l3*mi+sin(theta3(t))*(diff(theta3(t), t))^2*cos(theta1(t))*l1*l3*m4+l1^2*m2*(diff(theta1(t), t, t))-sin(theta3(t))*(diff(theta3(t), t))^2*cos(theta1(t))*l1*lc3*m3+sin(theta4(t))*(diff(theta4(t), t))^2*cos(theta1(t))*l1*l4*mi+sin(theta4(t))*(diff(theta4(t), t))^2*cos(theta1(t))*l1*l4*m4-sin(theta4(t))*(diff(theta4(t), t))^2*cos(theta1(t))*l1*lc4*m4+sin(theta6(t))*(diff(theta6(t), t))^2*cos(theta1(t))*h2*l1*ml+sin(theta6(t))*(diff(theta6(t), t))^2*cos(theta1(t))*h2*l1*m3+l1^2*ml*(diff(theta1(t), t, t))+l1^2*mr*(diff(theta1(t), t, t))+cos(theta2(t))*cos(theta1(t))*l1*l2*ml*(diff(theta2(t), t, t))+cos(theta2(t))*cos(theta1(t))*l1*l2*mc*(diff(theta2(t), t, t))+sin(theta5(t))*sin(theta1(t))*h2*l1*mi*(diff(theta5(t), t, t))-cos(theta3(t))*cos(theta1(t))*l1*l3*m4*(diff(theta3(t), t, t))+cos(theta5(t))*cos(theta1(t))*h2*l1*mc*(diff(theta5(t), t, t))+sin(theta6(t))*(diff(theta6(t), t))^2*cos(theta1(t))*h2*l1*mi+sin(theta6(t))*(diff(theta6(t), t))^2*cos(theta1(t))*h2*l1*m4-sin(theta5(t))*(diff(theta5(t), t))^2*cos(theta1(t))*h2*l1*mi-sin(theta5(t))*(diff(theta5(t), t))^2*cos(theta1(t))*h2*l1*m4-sin(theta5(t))*(diff(theta5(t), t))^2*cos(theta1(t))*h2*l1*m3-sin(theta5(t))*(diff(theta5(t), t))^2*cos(theta1(t))*h2*l1*mr-sin(theta5(t))*(diff(theta5(t), t))^2*cos(theta1(t))*h2*l1*mc-sin(theta2(t))*(diff(theta2(t), t))^2*cos(theta1(t))*l1*l2*m3-sin(theta2(t))*(diff(theta2(t), t))^2*cos(theta1(t))*l1*lc2*m2-sin(theta2(t))*(diff(theta2(t), t))^2*cos(theta1(t))*l1*l2*mr+sin(theta2(t))*sin(theta1(t))*l1*l2*ml*(diff(theta2(t), t, t))+cos(theta5(t))*cos(theta1(t))*h2*l1*mi*(diff(theta5(t), t, t))+l1^2*m4*(diff(theta1(t), t, t))+sin(theta5(t))*sin(theta1(t))*h2*l1*m3*(diff(theta5(t), t, t))+cos(theta3(t))*cos(theta1(t))*l1*lc3*m3*(diff(theta3(t), t, t))-sin(theta3(t))*sin(theta1(t))*l1*l3*m4*(diff(theta3(t), t, t))-cos(theta6(t))*cos(theta1(t))*h2*l1*m4*(diff(theta6(t), t, t))-sin(theta4(t))*sin(theta1(t))*l1*l4*m4*(diff(theta4(t), t, t))-sin(theta2(t))*(diff(theta2(t), t))^2*cos(theta1(t))*l1*l2*mi-sin(theta2(t))*(diff(theta2(t), t))^2*cos(theta1(t))*l1*l2*mc-sin(theta2(t))*(diff(theta2(t), t))^2*cos(theta1(t))*l1*l2*ml-sin(theta2(t))*(diff(theta2(t), t))^2*cos(theta1(t))*l1*l2*m4-sin(theta7(t))*(diff(theta7(t), t))^2*cos(theta1(t))*h3*l1*mc-cos(theta4(t))*cos(theta1(t))*l1*l4*mi*(diff(theta4(t), t, t))+cos(theta2(t))*cos(theta1(t))*l1*l2*mr*(diff(theta2(t), t, t))-cos(theta6(t))*(diff(theta6(t), t))^2*sin(theta1(t))*h2*l1*mi-cos(theta6(t))*(diff(theta6(t), t))^2*sin(theta1(t))*h2*l1*m4+cos(theta5(t))*(diff(theta5(t), t))^2*sin(theta1(t))*h2*l1*m3+cos(theta5(t))*(diff(theta5(t), t))^2*sin(theta1(t))*h2*l1*mi+cos(theta5(t))*(diff(theta5(t), t))^2*sin(theta1(t))*h2*l1*mc+cos(theta5(t))*(diff(theta5(t), t))^2*sin(theta1(t))*h2*l1*mr+cos(q2(t))*sin(theta1(t))*l1*l2*mi*(diff(theta2(t), t))*(diff(theta1(t), t))+cos(q2(t))*sin(theta1(t))*l1*l2*m4*(diff(theta2(t), t))*(diff(theta1(t), t))+cos(q2(t))*sin(theta1(t))*l1*lc2*m2*(diff(theta2(t), t))*(diff(theta1(t), t))+cos(q2(t))*sin(theta1(t))*l1*l2*m3*(diff(theta2(t), t))*(diff(theta1(t), t))+cos(q2(t))*sin(theta1(t))*l1*l2*mc*(diff(theta2(t), t))*(diff(theta1(t), t))+cos(q2(t))*sin(theta1(t))*l1*l2*ml*(diff(theta2(t), t))*(diff(theta1(t), t))+cos(q2(t))*sin(theta1(t))*l1*l2*mr*(diff(theta2(t), t))*(diff(theta1(t), t))-sin(q2(t))*cos(theta1(t))*l1*l2*mc*(diff(theta2(t), t))*(diff(theta1(t), t))-sin(q2(t))*cos(theta1(t))*l1*l2*m4*(diff(theta2(t), t))*(diff(theta1(t), t))-sin(q2(t))*cos(theta1(t))*l1*l2*mr*(diff(theta2(t), t))*(diff(theta1(t), t))-sin(q2(t))*cos(theta1(t))*l1*l2*m3*(diff(theta2(t), t))*(diff(theta1(t), t))-sin(q2(t))*cos(theta1(t))*l1*l2*mi*(diff(theta2(t), t))*(diff(theta1(t), t))-sin(q2(t))*cos(theta1(t))*l1*l2*ml*(diff(theta2(t), t))*(diff(theta1(t), t))-sin(q2(t))*cos(theta1(t))*l1*lc2*m2*(diff(theta2(t), t))*(diff(theta1(t), t))-cos(theta3(t))*(diff(theta3(t), t))^2*sin(theta1(t))*l1*l3*mi+cos(theta3(t))*(diff(theta3(t), t))^2*sin(theta1(t))*l1*lc3*m3-cos(theta4(t))*(diff(theta4(t), t))^2*sin(theta1(t))*l1*l4*m4-cos(theta4(t))*(diff(theta4(t), t))^2*sin(theta1(t))*l1*l4*mi+cos(theta4(t))*(diff(theta4(t), t))^2*sin(theta1(t))*l1*lc4*m4-cos(theta6(t))*(diff(theta6(t), t))^2*sin(theta1(t))*h2*l1*ml-cos(theta6(t))*(diff(theta6(t), t))^2*sin(theta1(t))*h2*l1*m3-cos(theta3(t))*(diff(theta3(t), t))^2*sin(theta1(t))*l1*l3*m4-cos(theta3(t))*(diff(theta3(t), t))^2*sin(theta1(t))*l1*l3*m3+l1^2*mc*(diff(theta1(t), t, t))-cos(theta4(t))*cos(theta1(t))*l1*l4*m4*(diff(theta4(t), t, t))+cos(theta5(t))*cos(theta1(t))*h2*l1*mr*(diff(theta5(t), t, t))+cos(theta2(t))*cos(theta1(t))*l1*lc2*m2*(diff(theta2(t), t, t))+cos(theta1(t))*g*l1*mr+cos(theta1(t))*g*l1*m3+cos(theta1(t))*g*l1*m2+cos(theta1(t))*g*l1*m4+cos(theta1(t))*g*l1*ml+cos(theta1(t))*g*l1*mc+m1*g*lc1*cos(theta1(t))+cos(theta1(t))*g*l1*mi+cos(theta5(t))*cos(theta1(t))*h2*l1*m3*(diff(theta5(t), t, t))-cos(theta2(t))*sin(theta1(t))*(diff(theta1(t), t))*l1*l2*m4*(diff(theta2(t), t))+cos(theta2(t))*(diff(theta2(t), t))^2*sin(theta1(t))*l1*l2*mc+sin(theta2(t))*cos(theta1(t))*(diff(theta1(t), t))*l1*l2*mc*(diff(theta2(t), t))+cos(theta7(t))*(diff(theta7(t), t))^2*sin(theta1(t))*h3*l1*mc+l1^2*m3*(diff(theta1(t), t, t))+l1^2*mi*(diff(theta1(t), t, t))+cos(theta5(t))*(diff(theta5(t), t))^2*sin(theta1(t))*h2*l1*m4-cos(theta2(t))*sin(theta1(t))*(diff(theta1(t), t))*l1*l2*m3*(diff(theta2(t), t))+cos(theta2(t))*(diff(theta2(t), t))^2*sin(theta1(t))*l1*l2*ml+sin(theta2(t))*cos(theta1(t))*(diff(theta1(t), t))*l1*l2*ml*(diff(theta2(t), t))-cos(theta2(t))*sin(theta1(t))*(diff(theta1(t), t))*l1*lc2*m2*(diff(theta2(t), t))+cos(theta2(t))*(diff(theta2(t), t))^2*sin(theta1(t))*l1*l2*mr+sin(theta2(t))*cos(theta1(t))*(diff(theta1(t), t))*l1*l2*mr*(diff(theta2(t), t))+cos(theta2(t))*(diff(theta2(t), t))^2*sin(theta1(t))*l1*l2*m4+sin(theta2(t))*cos(theta1(t))*(diff(theta1(t), t))*l1*l2*m4*(diff(theta2(t), t))+cos(theta2(t))*(diff(theta2(t), t))^2*sin(theta1(t))*l1*l2*mi+sin(theta2(t))*cos(theta1(t))*(diff(theta1(t), t))*l1*l2*mi*(diff(theta2(t), t))-cos(theta2(t))*sin(theta1(t))*(diff(theta1(t), t))*l1*l2*mr*(diff(theta2(t), t))-cos(theta2(t))*sin(theta1(t))*(diff(theta1(t), t))*l1*l2*mi*(diff(theta2(t), t))+cos(theta2(t))*(diff(theta2(t), t))^2*sin(theta1(t))*l1*l2*m3+sin(theta2(t))*cos(theta1(t))*(diff(theta1(t), t))*l1*l2*m3*(diff(theta2(t), t))-cos(theta2(t))*sin(theta1(t))*(diff(theta1(t), t))*l1*l2*mc*(diff(theta2(t), t))-cos(theta2(t))*sin(theta1(t))*(diff(theta1(t), t))*l1*l2*ml*(diff(theta2(t), t))+cos(theta2(t))*(diff(theta2(t), t))^2*sin(theta1(t))*l1*lc2*m2+sin(theta2(t))*cos(theta1(t))*(diff(theta1(t), t))*l1*lc2*m2*(diff(theta2(t), t))+sin(theta2(t))*sin(theta1(t))*l1*l2*m3*(diff(theta2(t), t, t))+cos(theta2(t))*cos(theta1(t))*l1*l2*m3*(diff(theta2(t), t, t))+cos(theta2(t))*cos(theta1(t))*l1*l2*mi*(diff(theta2(t), t, t))+cos(theta5(t))*cos(theta1(t))*h2*l1*m4*(diff(theta5(t), t, t))+sin(theta2(t))*sin(theta1(t))*l1*l2*mr*(diff(theta2(t), t, t))+m1*lc1^2*(diff(theta1(t), t, t))-sin(theta6(t))*sin(theta1(t))*h2*l1*m4*(diff(theta6(t), t, t))+sin(theta5(t))*sin(theta1(t))*h2*l1*mr*(diff(theta5(t), t, t))+sin(theta5(t))*sin(theta1(t))*h2*l1*mc*(diff(theta5(t), t, t))-cos(theta6(t))*cos(theta1(t))*h2*l1*mi*(diff(theta6(t), t, t))-sin(theta6(t))*sin(theta1(t))*h2*l1*mi*(diff(theta6(t), t, t))-cos(theta6(t))*cos(theta1(t))*h2*l1*m3*(diff(theta6(t), t, t))-sin(theta6(t))*sin(theta1(t))*h2*l1*m3*(diff(theta6(t), t, t))+sin(theta2(t))*sin(theta1(t))*l1*lc2*m2*(diff(theta2(t), t, t))+cos(theta2(t))*cos(theta1(t))*l1*l2*m4*(diff(theta2(t), t, t))+sin(theta2(t))*sin(theta1(t))*l1*l2*mc*(diff(theta2(t), t, t))+sin(theta3(t))*sin(theta1(t))*l1*lc3*m3*(diff(theta3(t), t, t))-cos(theta3(t))*cos(theta1(t))*l1*l3*mi*(diff(theta3(t), t, t))-sin(theta3(t))*sin(theta1(t))*l1*l3*mi*(diff(theta3(t), t, t))-cos(theta3(t))*cos(theta1(t))*l1*l3*m3*(diff(theta3(t), t, t))-sin(theta3(t))*sin(theta1(t))*l1*l3*m3*(diff(theta3(t), t, t))+cos(theta7(t))*cos(theta1(t))*h3*l1*mc*(diff(theta7(t), t, t))-cos(theta6(t))*cos(theta1(t))*h2*l1*ml*(diff(theta6(t), t, t))+sin(theta7(t))*sin(theta1(t))*h3*l1*mc*(diff(theta7(t), t, t))-sin(theta6(t))*sin(theta1(t))*h2*l1*ml*(diff(theta6(t), t, t))+sin(theta4(t))*sin(theta1(t))*l1*lc4*m4*(diff(theta4(t), t, t))+cos(theta4(t))*cos(theta1(t))*l1*lc4*m4*(diff(theta4(t), t, t))-sin(theta4(t))*sin(theta1(t))*l1*l4*mi*(diff(theta4(t), t, t))+sin(theta2(t))*sin(theta1(t))*l1*l2*m4*(diff(theta2(t), t, t))+sin(theta2(t))*sin(theta1(t))*l1*l2*mi*(diff(theta2(t), t, t))+sin(theta5(t))*sin(theta1(t))*h2*l1*m4*(diff(theta5(t), t, t))

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