Maple Questions and Posts

These are Posts and Questions associated with the product, Maple

Is it possible overlay one column graph on top of another ? And if, how do I do it?

Regards

I have here a function  
                           "sin(x)/x"

and suppose sin(x)/x = 0 
Can I now use MapleAI to retrieve the correct command for this in Maple..could I?

The intersection points with the x-axis are positive and negative multiples of Pi
I have put these in an ordered list, but Maple gives this:
For x domain = -20...20 
X := {x = Pi}, {x = 2*Pi}, {x = 3*Pi}, {x = 4*Pi}, {x = 5*Pi}, {x = 6*Pi}, {x = -6*Pi}, {x = -5*Pi}, {x = -4*Pi}, {x = -3*Pi}, {x = -2*Pi}, {x = -Pi};

 
X := sort(eval~(x, [X]));
 X := [, -6 Pi, -5 Pi, -4 Pi, -3 Pi, -2 Pi, -Pi, 2 Pi, 3 Pi, 4 Pi, 5 Pi, 6 Pi]


A strange ranking that Maple comes up with ? 

with(NaturalLanguage);
        [Explain, GetCommand, GetMath, Query, RawQuery]



GetCommand("give for Maple solve command all options?");
            "solve(equations, variables, options);"

Explain("give for Maple solve command all options?");

"Maple is a symbolic and numeric computing environment. Its 

   "solve" command is used to find solutions (roots) of a given 

   equation or a system of equations.
  

  There are a number of options (or "parameters") which can be 

   specified in this command to alter its behavior:

  

  1. `Allsolutions`: This option makes Maple to generate all 

   possible solutions of an equation.

  

  2. `Real`: This option only provides the real solutions. If 

   equations do not have real solutions, it will return an 

   empty set.

  

  3. `Positive`: It only includes positive solutions in the 

   output.

  

  4. `explicit`: If specified, Maple attempts to isolate roots 

   and provide an explicit solution for each variable.

  

  5. `assume = real`: This option restrict the solutions to 

   only real numbers.

  

  6. `parametric`: This option allows Maple to write the 

   solutions in a parametric form. 

  

  7. `avoid ={x = a}`: This option makes solve exclude the 

   possibility `x = a` as a solution.

  

  8. `MaxDegree = d`: This option allows you to limit the 

   degree of the polynomial equations to be considered.

  

  9. `maxdepth = d`: This sets a limit on recursive depth to 

   which the computation should go to seek a solution.

  

  10. `multiplicities`: This option reports multiplicity of the 

   roots.

  

  11. `solutions = vars`: This option tells Maple to look for 

   solutions for specific variables.

  

  12. `numeric`: This option makes solve find a numeric 

   solution to the equation.

  

  13. `symbolic`: This option makes solve find a symbolic 

   solution to the equation.

  

  14. `simplify`: This option simplifies the solutions returned 

   by solve.

  

  15. `sqrt`: This option allows square roots in the output.

  

  It is important to note that not all options are suited for 

   use with all types of equations. Also, the "solve" command 

   in Maple can be occasionally limited by the complexity of 

   the equation, and may sometimes fail to find solutions that 

   more specialized software or methods can find."



 

 

I am trying to solve the following set of equations, I am able to find solutions for a simplified case (b=0) using the command solve but cannot seem to solve it for general b.

Is there a better way to attempt to find a solution?
solve.mw

restart

eqn := [(2*((q*r*a3^2-(1/2)*b^2*a3^2-(1/2)*r^2*a3^2-(1/2)*a2^2)*b^4*cos(theta)^4+(2*((q*r-(1/4)*b^2-(1/4)*r^2)*(b^2+r^2)*a4^2*sin(theta)^2-(1/2)*r^4*a3^2+q*r^3*a3^2+(1/2)*(1/2-b^2*a3^2+(1/2)*a1^2-a2^2)*r^2-(1/2)*q*(a1^2+1)*r+(1/4)*b^2*(a1^2+1)))*b^2*cos(theta)^2+2*r*(q^2*sin(theta)^4*b^2*r*a4^2-2*a4*((1/8)*a4*r^5-(1/4)*q*a4*r^4+(1/4)*b^2*a4*r^3-(1/2)*q*b*a1*r^2+b*((1/8)*b^3*a4+q^2*a1)*r+(1/4)*q*b^3*(a4*b-2*a1))*sin(theta)^2-(1/4)*r^5*a3^2+(1/2)*q*r^4*a3^2+(1/4)*(-a3^2*b^2+a1^2-a2^2+1)*r^3+q*(-a1^2-1/2)*r^2+((1/4)*b^2*(a1^2+1)+q^2*a1^2)*r-(1/2)*q*b^2*a1^2)))/((r^2+b^2*cos(theta)^2)*(-b^2+2*q*r-r^2)), (2*((q*r*s3^2-(1/2)*b^2*s3^2-(1/2)*r^2*s3^2-(1/2)*s2^2)*b^4*cos(theta)^4+(2*((q*r-(1/4)*b^2-(1/4)*r^2)*(b^2+r^2)*s4^2*sin(theta)^2-(1/2)*r^4*s3^2+q*r^3*s3^2+(1/2)*(1/2-b^2*s3^2+(1/2)*s1^2-s2^2)*r^2-(1/2)*q*(s1^2+1)*r+(1/4)*b^2*(s1^2+1)))*b^2*cos(theta)^2+2*r*(q^2*sin(theta)^4*b^2*r*s4^2-2*s4*((1/8)*r^5*s4-(1/4)*q*r^4*s4+(1/4)*b^2*r^3*s4-(1/2)*q*b*r^2*s1+b*((1/8)*b^3*s4+q^2*s1)*r+(1/4)*q*b^3*(b*s4-2*s1))*sin(theta)^2-(1/4)*r^5*s3^2+(1/2)*q*r^4*s3^2+(1/4)*(-b^2*s3^2+s1^2-s2^2+1)*r^3+q*(-s1^2-1/2)*r^2+((1/4)*b^2*(s1^2+1)+q^2*s1^2)*r-(1/2)*q*b^2*s1^2)))/((r^2+b^2*cos(theta)^2)*(-b^2+2*q*r-r^2)), (2*((1/2)*s2*sqrt(b^4*cos(theta)^4+8*q*sin(theta)^2*b^2*r+2*b^2*cos(theta)^2*r^2+r^4)+(q*r-(1/2)*b^2-(1/2)*r^2)*(b*sin(theta)^2*s4+s1)))/(-b^2+2*q*r-r^2), (2*((1/2)*a2*sqrt(b^4*cos(theta)^4+8*q*sin(theta)^2*b^2*r+2*b^2*cos(theta)^2*r^2+r^4)+(q*r-(1/2)*b^2-(1/2)*r^2)*(b*sin(theta)^2*a4+a1)))/(-b^2+2*q*r-r^2), (sqrt(b^4*cos(theta)^4+8*q*sin(theta)^2*b^2*r+2*b^2*cos(theta)^2*r^2+r^4)*n2+(2*(1+sin(theta)^2*b*n4+n1))*(q*r-(1/2)*b^2-(1/2)*r^2))/(-b^2+2*q*r-r^2), (2*(b^4*(q*s3*r*a3-(1/2)*s3*b^2*a3-(1/2)*s3*r^2*a3-(1/2)*a2*s2)*cos(theta)^4+(2*((q*r-(1/4)*b^2-(1/4)*r^2)*(b^2+r^2)*s4*a4*sin(theta)^2-(1/2)*s3*r^4*a3+q*s3*r^3*a3+(1/2)*(-s3*b^2*a3+(1/2)*a1*s1-a2*s2)*r^2-(1/2)*q*r*a1*s1+(1/4)*b^2*a1*s1))*b^2*cos(theta)^2+(2*(q^2*s4*sin(theta)^4*b^2*r*a4+(-(1/4)*s4*r^5*a4+(1/2)*q*s4*r^4*a4-(1/2)*s4*b^2*r^3*a4+(1/2)*q*b*(a1*s4+a4*s1)*r^2-b*((1/4)*s4*b^3*a4+q^2*(a1*s4+a4*s1))*r-(1/2)*q*b^3*(a4*b*s4-a1*s4-a4*s1))*sin(theta)^2-(1/4)*s3*r^5*a3+(1/2)*q*s3*r^4*a3+(1/4)*(-a3*b^2*s3+a1*s1-a2*s2)*r^3-q*r^2*a1*s1+a1*s1*(q^2+(1/4)*b^2)*r-(1/2)*q*b^2*a1*s1))*r))/((r^2+b^2*cos(theta)^2)*(-b^2+2*q*r-r^2)), (2*((1/2)*a2*sqrt(b^4*cos(theta)^4+8*q*sin(theta)^2*b^2*r+2*b^2*cos(theta)^2*r^2+r^4)+(q*r-(1/2)*b^2-(1/2)*r^2)*(b*sin(theta)^2*a4+a1)))/(-b^2+2*q*r-r^2), (2*(b^4*(q*n3*r*a3-(1/2)*n3*b^2*a3-(1/2)*n3*r^2*a3-(1/2)*a2*n2)*cos(theta)^4+(2*((q*r-(1/4)*b^2-(1/4)*r^2)*(b^2+r^2)*n4*a4*sin(theta)^2-(1/2)*n3*r^4*a3+q*n3*r^3*a3+(1/2)*(-n3*b^2*a3+(1/2)*a1*n1-a2*n2)*r^2-(1/2)*q*r*a1*n1+(1/4)*b^2*a1*n1))*b^2*cos(theta)^2+(2*(q^2*n4*sin(theta)^4*b^2*r*a4+(-(1/4)*n4*r^5*a4+(1/2)*q*n4*r^4*a4-(1/2)*n4*b^2*r^3*a4+(1/2)*q*b*(a1*n4+a4*n1)*r^2-b*((1/4)*n4*b^3*a4+q^2*(a1*n4+a4*n1))*r-(1/2)*q*b^3*(a4*b*n4-a1*n4-a4*n1))*sin(theta)^2-(1/4)*n3*r^5*a3+(1/2)*q*n3*r^4*a3+(1/4)*(-a3*b^2*n3+a1*n1-a2*n2)*r^3-q*r^2*a1*n1+a1*n1*(q^2+(1/4)*b^2)*r-(1/2)*q*b^2*a1*n1))*r))/((r^2+b^2*cos(theta)^2)*(-b^2+2*q*r-r^2)), (2*(b^4*(q*s3*r*n3-(1/2)*s3*b^2*n3-(1/2)*s3*r^2*n3-(1/2)*n2*s2)*cos(theta)^4+(2*((q*r-(1/4)*b^2-(1/4)*r^2)*(b^2+r^2)*s4*n4*sin(theta)^2-(1/2)*s3*r^4*n3+q*s3*r^3*n3+(1/2)*(-s3*b^2*n3+(1/2)*n1*s1-n2*s2)*r^2-(1/2)*q*r*n1*s1+(1/4)*b^2*n1*s1))*b^2*cos(theta)^2+(2*(q^2*s4*sin(theta)^4*b^2*r*n4+(-(1/4)*s4*r^5*n4+(1/2)*q*s4*r^4*n4-(1/2)*s4*b^2*r^3*n4+(1/2)*q*b*(n1*s4+n4*s1)*r^2-b*((1/4)*s4*b^3*n4+q^2*(n1*s4+n4*s1))*r-(1/2)*q*b^3*(b*n4*s4-n1*s4-n4*s1))*sin(theta)^2-(1/4)*s3*r^5*n3+(1/2)*q*s3*r^4*n3+(1/4)*(-b^2*n3*s3+n1*s1-n2*s2)*r^3-q*r^2*n1*s1+n1*s1*(q^2+(1/4)*b^2)*r-(1/2)*q*b^2*n1*s1))*r))/((r^2+b^2*cos(theta)^2)*(-b^2+2*q*r-r^2)), (2*((q*r*n3^2-(1/2)*b^2*n3^2-(1/2)*r^2*n3^2-(1/2)*n2^2)*b^4*cos(theta)^4+(2*((q*r-(1/4)*b^2-(1/4)*r^2)*(b^2+r^2)*n4^2*sin(theta)^2-(1/2)*r^4*n3^2+q*r^3*n3^2+(1/2)*(-b^2*n3^2+(1/2)*n1^2-n2^2)*r^2-(1/2)*q*r*n1^2+(1/4)*b^2*n1^2))*b^2*cos(theta)^2+2*r*(q^2*sin(theta)^4*b^2*r*n4^2-2*n4*((1/8)*n4*r^5-(1/4)*q*n4*r^4+(1/4)*n4*b^2*r^3-(1/2)*q*b*r^2*n1+b*((1/8)*n4*b^3+q^2*n1)*r+(1/4)*q*b^3*(b*n4-2*n1))*sin(theta)^2-(1/4)*r^5*n3^2+(1/2)*q*r^4*n3^2+(1/4)*(-b^2*n3^2+n1^2-n2^2)*r^3-q*r^2*n1^2+n1^2*(q^2+(1/4)*b^2)*r-(1/2)*q*b^2*n1^2)))/((r^2+b^2*cos(theta)^2)*(-b^2+2*q*r-r^2)), -(32*(((1/8)*(b*(-a2*a4+s2*s4)*(q-r)*sin(theta)^2+q*(a1*a2-s1*s2))*(q*r-(1/2)*b^2-(1/2)*r^2)*b^6*cos(theta)^6-(1/4)*b^4*((q*b^2-(3/2)*q*r^2+(3/2)*r^3)*(q*r-(1/2)*b^2-(1/2)*r^2)*(-a2*a4+s2*s4)*b*sin(theta)^2+(a1*a2-s1*s2)*q*(q*b^2*r+(1/2)*q*r^3-(1/2)*b^4-(3/4)*b^2*r^2))*cos(theta)^4+(b*(-a3*a4+s3*s4)*sin(theta)^2-s3*s1+a3*a1)*r*q*(q*r-(1/2)*b^2-(1/2)*r^2)^2*b^4*sin(theta)*cos(theta)^3+(1/8)*(7*(((1/14)*(3*(-a2*a4+s2*s4))*r^3-13*q*(-a2*a4+s2*s4)*r^2*(1/14)+(q^2+3*b^2*(1/14))*(-a2*a4+s2*s4)*r-(1/2)*q*b*(b*(-a2*a4+s2*s4)+(1/7)*a2*a1-(1/7)*s1*s2))*b*sin(theta)^2-(1/7)*r*(a1*a2-s1*s2)*(q-(1/2)*r)*q))*r^4*b^2*cos(theta)^2+(b*(-a3*a4+s3*s4)*sin(theta)^2-s3*s1+a3*a1)*r^3*q*(q*r-(1/2)*b^2-(1/2)*r^2)^2*b^2*sin(theta)*cos(theta)+(1/4)*(((1/4)*(-a2*a4+s2*s4)*r^5-7*q*(-a2*a4+s2*s4)*r^4*(1/4)+(1/2)*(5*(q^2+(1/10)*b^2))*(-a2*a4+s2*s4)*r^3-7*q*b^2*(-a2*a4+s2*s4)*r^2*(1/4)+q^2*b^2*(-a2*a4+s2*s4)*r-(1/2)*q*(b*(-a2*a4+s2*s4)+a2*a1-s1*s2)*b^3)*b*sin(theta)^2+r*(a1*a2-s1*s2)*(q*b^2+(1/2)*q*r^2-(3/4)*b^2*r-(1/4)*r^3)*q)*r^4)*sqrt(b^4*cos(theta)^4+8*q*sin(theta)^2*b^2*r+2*b^2*cos(theta)^2*r^2+r^4)-(1/32)*q*b^10*(a2-s2)*(a2+s2)*cos(theta)^10+(1/8)*b^8*((2*((1/8)*(-a4^2+s4^2)*r^4+5*q*(a4^2-s4^2)*r^3*(1/8)+(s4-a4)*(s4+a4)*(q^2+(1/4)*b^2)*r^2-3*q*b^2*(s4-a4)*(s4+a4)*r*(1/4)+(1/8)*((-a4^2+s4^2)*b^2-a2^2+s2^2)*b^2))*r*sin(theta)^2+(1/4)*(-a3^2+s3^2)*r^5+(a3^2-s3^2)*q*r^4+((1/2)*b^2+q^2)*(s3-a3)*(s3+a3)*r^3-((-a3^2+s3^2)*b^2+7*a2^2*(1/4)-7*s2^2*(1/4))*q*r^2+(1/4)*b^4*(-a3^2+s3^2)*r+q*b^2*(a2-s2)*(a2+s2))*cos(theta)^8+(1/2)*r*q*(q*r-(1/2)*b^2-(1/2)*r^2)*b^8*sin(theta)*(-a2*a3+s2*s3)*cos(theta)^7+(1/8)*((s4-a4)*(s4+a4)*(q*r-(1/2)*b^2)^2*q*b^2*sin(theta)^4+((-a4^2+s4^2)*r^7+25*q*(a4^2-s4^2)*r^6*(1/4)+(15*(s4-a4))*(s4+a4)*(q^2+2*b^2*(1/15))*r^5-33*q*b*((-a4^2+s4^2)*b+2*s1*s4*(1/33)-2*a1*a4*(1/33))*r^4*(1/4)+((-a4^2+s4^2)*b^4+((12*(-a4^2+s4^2))*q^2-a2^2+s2^2)*b^2+2*q^2*(-a1*a4+s1*s4)*b)*r^3-(2*((1/8)*(7*(-a4^2+s4^2))*b^3+(1/2)*(-a1*a4+s1*s4)*b^2+q^2*(-a1*a4+s1*s4)))*q*b*r^2+2*q^2*b^3*(-a1*a4+s1*s4)*r-(1/2)*q*b^5*(-a1*a4+s1*s4))*sin(theta)^2+(-a3^2+s3^2)*r^7+(6*(a3^2-s3^2))*q*r^6+(12*(q^2+(1/6)*b^2))*(s3-a3)*(s3+a3)*r^5-(8*((-a3^2+s3^2)*b^2+(1/32)*a1^2+11*a2^2*(1/16)-(1/32)*s1^2-11*s2^2*(1/16)))*q*r^4+(b^4*(-a3^2+s3^2)+8*q^2*(-a3^2+s3^2)*b^2+q^2*(a1^2-s1^2))*r^3-(2*b^4*(-a3^2+s3^2)+((1/2)*a1^2-2*a2^2-(1/2)*s1^2+2*s2^2)*b^2+q^2*(a1^2-s1^2))*q*r^2+q^2*b^2*(a1-s1)*(a1+s1)*r-(1/4)*q*b^4*(a1^2+4*a2^2-s1^2-4*s2^2))*b^6*cos(theta)^6-r*q*(q*r-(1/2)*b^2-(1/2)*r^2)*(b^2-(1/2)*r^2)*b^6*sin(theta)*(-a2*a3+s2*s3)*cos(theta)^5+r*b^4*((s4-a4)*(s4+a4)*(q*b^2*r+(17/8)*q*r^3-(1/4)*b^4)*q^2*b^2*sin(theta)^4+((1/16)*(3*(-a4^2+s4^2))*r^8+39*q*(a4^2-s4^2)*r^7*(1/32)+(1/8)*(19*(s4-a4))*(s4+a4)*(q^2+3*b^2*(1/19))*r^6-45*q*b*((-a4^2+s4^2)*b+2*s1*s4*(1/45)-2*a1*a4*(1/45))*r^5*(1/32)-(1/4)*((1/4)*(3*(a4^2-s4^2))*b^2+(-a4^2+s4^2)*q^2+3*a2^2*(1/4)-3*s2^2*(1/4))*b^2*r^4+((1/32)*(3*(-a4^2+s4^2))*b^3+(1/8)*(a1*a4-s1*s4)*b^2+q^2*(-a3^2+s3^2)*b-9*q^2*(-a1*a4+s1*s4)*(1/4))*q*b*r^3-(1/8)*(19*((-a4^2+s4^2)*b^2+(1/19)*(10*(a1*a4-s1*s4))*b+4*a2^2*(1/19)-4*s2^2*(1/19)))*q^2*b^2*r^2-(2*((1/64)*(9*(a4^2-s4^2))*b^3+(1/32)*(-a1*a4+s1*s4)*b^2+q^2*(-a1*a4+s1*s4)))*q*b^3*r+(1/2)*q^2*b^5*(-a1*a4+s1*s4))*sin(theta)^2+(1/16)*(3*(-a3^2+s3^2))*r^8+5*q*(a3^2-s3^2)*r^7*(1/4)+(1/4)*(11*(q^2+3*b^2*(1/22)))*(s3-a3)*(s3+a3)*r^6-(1/2)*(3*((-a3^2+s3^2)*b^2+(1/48)*a1^2+13*a2^2*(1/24)-(1/48)*s1^2-13*s2^2*(1/24)))*q*r^5+(q^2+3*b^2*(1/16))*(s3-a3)*(s3+a3)*b^2*r^4-(1/8)*(9*((1/9)*((1/2)*a1^2-4*a2^2-(1/2)*s1^2+4*s2^2)*b^2+q^2*(a1^2-s1^2)))*q*r^3-((-a3^2+s3^2)*b^2-5*a1^2*(1/8)+5*s1^2*(1/8))*q^2*b^2*r^2-q*b^2*((1/4)*(a3^2-s3^2)*b^4+(1/8)*((1/4)*a1^2+a2^2-(1/4)*s1^2-s2^2)*b^2+q^2*(a1^2-s1^2))*r+(1/4)*q^2*b^4*(a1-s1)*(a1+s1))*cos(theta)^4-(2*(b^2+(1/4)*r^2))*r^3*q*(q*r-(1/2)*b^2-(1/2)*r^2)*b^4*sin(theta)*(-a2*a3+s2*s3)*cos(theta)^3+(q^4*b^4*r^2*(s4-a4)*(s4+a4)*sin(theta)^6-(2*(7*q*(a4^2-s4^2)*r^5*(1/16)+3*b*(-a1*a4+s1*s4)*r^4*(1/8)+q*b^2*(s4-a4)*(s4+a4)*r^3+q^2*(-a1*a4+s1*s4)*b*r^2+(1/2)*q*b^4*(s4-a4)*(s4+a4)*r+(1/8)*b^6*(a4^2-s4^2)))*q^2*b^2*sin(theta)^4+((1/8)*(-a4^2+s4^2)*r^10+23*q*(a4^2-s4^2)*r^9*(1/32)+(1/8)*(11*(s4-a4))*(s4+a4)*(q^2+2*b^2*(1/11))*r^8-(1/32)*(15*((-a4^2+s4^2)*b-2*s1*s4*(1/15)+2*a1*a4*(1/15)))*q*b*r^7-(1/2)*((1/4)*(a4^2-s4^2)*b^3+((-a4^2+s4^2)*q^2+(1/4)*a2^2-(1/4)*s2^2)*b+3*q^2*(-a1*a4+s1*s4)*(1/2))*b*r^6+(2*((1/64)*(23*(-a4^2+s4^2))*b^3+(1/16)*(-a1*a4+s1*s4)*b^2+q^2*(-a3^2+s3^2)*b+9*q^2*(-a1*a4+s1*s4)*(1/8)))*q*b*r^5-(1/8)*(5*((-a4^2+s4^2)*b^2+3*a1^2*(1/5)+8*a2^2*(1/5)-3*s1^2*(1/5)-8*s2^2*(1/5)))*q^2*b^2*r^4+4*q*((1/128)*(15*(-a4^2+s4^2))*b^3+(1/64)*(-a1*a4+s1*s4)*b^2+q^2*(-a1*a4+s1*s4))*b^3*r^3-((a4^2-s4^2)*b^4+(1/2)*(3*(-a1*a4+s1*s4))*b^3+q^2*(a1^2-s1^2))*q^2*b^2*r^2+2*q^3*b^5*(-a1*a4+s1*s4)*r-(1/2)*q^2*b^7*(-a1*a4+s1*s4))*sin(theta)^2+(1/8)*(-a3^2+s3^2)*r^10+3*q*(a3^2-s3^2)*r^9*(1/4)+(1/2)*(3*(q^2+(1/6)*b^2))*(s3-a3)*(s3+a3)*r^8-(1/2)*((-a3^2+s3^2)*b^2-(1/16)*a1^2+9*a2^2*(1/16)+(1/16)*s1^2-9*s2^2*(1/16))*q*r^7+((1/8)*b^4*(-a3^2+s3^2)+(a3^2-s3^2)*q^2*b^2+3*q^2*(-a1^2+s1^2)*(1/8))*r^6+9*q*(2*b^4*(-a3^2+s3^2)*(1/3)+(1/3)*((1/6)*a1^2+2*a2^2-(1/6)*s1^2-2*s2^2)*b^2+q^2*(a1^2-s1^2))*r^5*(1/8)+(2*(a3^2-s3^2))*q^2*b^4*r^4+2*q*((1/4)*b^4*(-a3^2+s3^2)+(1/16)*((1/4)*a1^2+a2^2-(1/4)*s1^2-s2^2)*b^2+q^2*(a1^2-s1^2))*b^2*r^3-3*q^2*b^4*(a1-s1)*(a1+s1)*r^2*(1/4)+q^3*b^4*(a1-s1)*(a1+s1)*r-(1/4)*q^2*b^6*(a1-s1)*(a1+s1))*r*b^2*cos(theta)^2-(b^2+(1/2)*r^2)*r^5*q*(q*r-(1/2)*b^2-(1/2)*r^2)*b^2*sin(theta)*(-a2*a3+s2*s3)*cos(theta)-r^3*(q^4*b^4*r^2*(s4-a4)*(s4+a4)*sin(theta)^6-2*r*(7*q*(-a4^2+s4^2)*r^4*(1/16)+(1/2)*q*b^2*(s4-a4)*(s4+a4)*r^2+(-a1*a4+s1*s4)*((1/2)*b^2+q^2)*b*r+(1/2)*q*b^4*(s4-a4)*(s4+a4))*q^2*b^2*sin(theta)^4+((1/32)*(a4^2-s4^2)*r^10+(1/8)*q*(-a4^2+s4^2)*r^9-(1/8)*(s4-a4)*(s4+a4)*((1/2)*b^2+q^2)*r^8-(1/32)*(3*((-a4^2+s4^2)*b+2*s1*s4*(1/3)-2*a1*a4*(1/3)))*q*b*r^7+(1/8)*(7*((1/28)*(a4^2-s4^2)*b^3+((-a4^2+s4^2)*q^2+(1/28)*a2^2-(1/28)*s2^2)*b+2*q^2*(-a1*a4+s1*s4)*(1/7)))*b*r^6-((1/16)*(7*(-a4^2+s4^2))*b^3+(1/8)*(-a1*a4+s1*s4)*b^2+q^2*(-a3^2+s3^2)*b+(1/4)*q^2*(-a1*a4+s1*s4))*q*b*r^5+(1/8)*(9*((-a4^2+s4^2)*b^2+(1/9)*(2*(a1*a4-s1*s4))*b+4*a2^2*(1/9)-4*s2^2*(1/9)))*q^2*b^2*r^4+(2*((1/64)*(7*(a4^2-s4^2))*b^3+(1/32)*(a1*a4-s1*s4)*b^2+q^2*(-a1*a4+s1*s4)))*q*b^3*r^3-q^2*b^2*((1/2)*(a4^2-s4^2)*b^4+(1/2)*(a1^2-s1^2)*b^2+q^2*(a1^2-s1^2))*r^2+2*q^3*b^5*(-a1*a4+s1*s4)*r+(1/4)*q^2*b^7*((-a4^2+s4^2)*b-2*s1*s4+2*a1*a4))*sin(theta)^2+(1/32)*(a3^2-s3^2)*r^10+(1/8)*q*(-a3^2+s3^2)*r^9-(1/8)*((1/2)*b^2+q^2)*(s3-a3)*(s3+a3)*r^8-(1/8)*((-a3^2+s3^2)*b^2+(1/4)*a1^2+(1/4)*a2^2-(1/4)*s1^2-(1/4)*s2^2)*q*r^7+((1/32)*(a3^2-s3^2)*b^4+q^2*(-a3^2+s3^2)*b^2+(1/8)*q^2*(a1^2-s1^2))*r^6-(1/8)*(4*b^4*(-a3^2+s3^2)+((1/2)*a1^2+3*a2^2-(1/2)*s1^2-3*s2^2)*b^2+q^2*(a1^2-s1^2))*q*r^5+q^2*((-a3^2+s3^2)*b^2+(1/8)*s1^2-(1/8)*a1^2)*b^2*r^4+((1/4)*(a3^2-s3^2)*b^4+(1/8)*(-a2^2+s2^2+(1/4)*s1^2-(1/4)*a1^2)*b^2+q^2*(a1^2-s1^2))*q*b^2*r^3+q^3*b^4*(a1-s1)*(a1+s1)*r-(1/4)*q^2*b^6*(a1-s1)*(a1+s1))))/(sqrt(b^4*cos(theta)^4+8*q*sin(theta)^2*b^2*r+2*b^2*cos(theta)^2*r^2+r^4)*(r^2+b^2*cos(theta)^2)^3*(-b^2+2*q*r-r^2)^2)]

solve(eqn, {a1, a2, a3, a4, n1, n2, n3, n4, s1, s2, s3, s4})

``

NULL


 

Download solve.mw

 

Maple does not have full_simplify() command like with Mathematica.

So I figured why not make one? 

Here is a basic implementation. All what it does is blindly tries different simplifications methods I know about and learned from this forum then at the end sorts the result by leaf count and returns to the user the one with smallest leaf count.

I tried it on few inputs.

Advantage of full_simplify() is that user does not have to keep trying themselves. One disadvantage is that this can take longer time. timelimit can be added to this to make it not hang.

Can you see and make more improvement to this function?

May be we all together can make a better full_simplify() in Maple to use. Feel free to edit and change.

#version 1.0  
#increment version number each time when making changes.

full_simplify:=proc(e::anything)
   local result::list;
   local f:=proc(a,b)
      RETURN(MmaTranslator:-Mma:-LeafCount(a)<MmaTranslator:-Mma:-LeafCount(b))
   end proc;

   #add more methods as needed

   result:=[simplify(e),
            simplify(e,size),
            simplify(combine(e)),
            simplify(combine(e),size),
            radnormal(evala( combine(e) )),
            simplify(evala( combine(e) )),
            evala(radnormal( combine(e) )),
            simplify(radnormal( combine(e) )),
            evala(factor(e)),
            simplify(e,ln),
            simplify(e,power),
            simplify(e,RootOf),
            simplify(e,sqrt),
            simplify(e,trig),
            simplify(convert(e,trig)),
            simplify(convert(e,exp)),
            combine(e)
   ];   
   RETURN( sort(result,f)[1]);   

end proc:

worksheet below

 


 

204648

#version 1.0  
#increment version number each time when making changes.

full_simplify:=proc(e::anything)
   local result::list;
   local f:=proc(a,b)
      RETURN(MmaTranslator:-Mma:-LeafCount(a)<MmaTranslator:-Mma:-LeafCount(b))
   end proc;

   #add more methods as needed

   result:=[simplify(e),
            simplify(e,size),
            simplify(combine(e)),
            simplify(combine(e),size),
            radnormal(evala( combine(e) )),
            simplify(evala( combine(e) )),
            evala(radnormal( combine(e) )),
            simplify(radnormal( combine(e) )),
            evala(factor(e)),
            simplify(e,ln),
            simplify(e,power),
            simplify(e,RootOf),
            simplify(e,sqrt),
            simplify(e,trig),
            simplify(convert(e,trig)),
            simplify(convert(e,exp)),
            combine(e)
   ];   
   RETURN( sort(result,f)[1]);   

end proc:

#test cases
T:=[(-192*cos(t)^6 + 288*cos(t)^4 - 912*cos(t)^3 - 108*cos(t)^2 + 684*cos(t) - 54)/(4608*cos(t)^9 - 10368*cos(t)^7 + 6208*cos(t)^6 + 7776*cos(t)^5 - 9312*cos(t)^4 - 2440*cos(t)^3 + 3492*cos(t)^2 + 372*cos(t) - 1169),
(10*(5+sqrt(41)))/(sqrt(70+10*sqrt(41))*sqrt(130+10*sqrt(41))),
((6-4*sqrt(2))*ln(3-2*sqrt(2))+(3-2*sqrt(2))*ln(17-12*sqrt(2))+32-24*sqrt(2))/(48*sqrt(2)-72)*(ln(sqrt(2)+1)+sqrt(2))/3,
(1/2)*exp((1/2)*x)*(cosh((1/2)*x)-cosh((3/2)*x)+sinh((1/2)*x)+sinh((3/2)*x))
];

[(-192*cos(t)^6+288*cos(t)^4-912*cos(t)^3-108*cos(t)^2+684*cos(t)-54)/(4608*cos(t)^9-10368*cos(t)^7+6208*cos(t)^6+7776*cos(t)^5-9312*cos(t)^4-2440*cos(t)^3+3492*cos(t)^2+372*cos(t)-1169), 10*(5+41^(1/2))/((70+10*41^(1/2))^(1/2)*(130+10*41^(1/2))^(1/2)), (1/3)*((6-4*2^(1/2))*ln(3-2*2^(1/2))+(3-2*2^(1/2))*ln(17-12*2^(1/2))+32-24*2^(1/2))*(ln(1+2^(1/2))+2^(1/2))/(48*2^(1/2)-72), (1/2)*exp((1/2)*x)*(cosh((1/2)*x)-cosh((3/2)*x)+sinh((1/2)*x)+sinh((3/2)*x))]

full_simplify~(T)

[-6*(10+cos(6*t)+38*cos(3*t))/(-975+18*cos(9*t)-70*cos(3*t)+194*cos(6*t)), (1/2)*2^(1/2), (1/9)*(ln(1+2^(1/2))+2^(1/2))^2, (1/2)*exp(x)-(1/2)*exp(-x)]

 


 

Download full_simplify.mw

I just installed Maple 2024.0 and I discovered a problem in that the "Manage Style Sets" under the "Format" menu DOESN'T WORK!!! Type the following to understand how this feature works and see if you have the same problem:

>?workshhet,documenting,styles

Follow the instructions.  They are pretty simple.  Find a worksheet that has the styles you like and open it up and then save this Style Set in Maple 2024.0.  Then close it.  Open a new worksheet.  Go to "Format" and then click on "Managing Style Sets" and then click on the Style Set file name you saved previously and you will find that it does not set the style set you saved previously.  

 

Another problem you will find is that it doesn't save your Style Set file where it is supposed to save it.  It needs to be saved in a Maple 2024.0 created folder known as "data" and then in a folder under "data" called "stylesets".  I had to manually go find my Style Set file and copy and paste it there.  

Please check this out and see if I am wrong.  I use the "Format" "Manage Style Sets" option a lot when I download files from this blog and ".mw"  have fonts size 12 and they default to the nearly impossible to read font!  After I have applied the "Manage Style Sets" I can see what I have! But for some reason in Maple 2024.0 this feature was not tested or something has changed in Maple 2024.0 to break this feature!

AllGraphs is a new function in Maple 2024. Good things!

However, it seems that most of its functionalities are already provided by NonIsomorphicGraphs, and its speed even lags behind that of NonIsomorphicGraphs 

 

I'm curious about what truly sets this function apart from existing ones. It generates isomorphic graphs if nonisomorphic=falseBut I donot know what its application is. Supporting directed graphs is a new thing, but its speed is not well.

iterator := GraphTheory[AllGraphs](vertices = 6, edges =6..7, connected, nonisomorphic)
s:=[seq(p, p = iterator)]:
nops(s)

Note that this function is suitable for generating non-isomorphic connected graphs with 6 vertices and either 6 or 7 edges. It doesn't hold an advantage in terms of speed, andNonIsomorphicGraphs also provides an iteration option.

Hello,

I have plotted psi [1] and psi [2] by using contourplot, but I want to show streamline or Flow nets on curves psi[1] and psi[2].

please help me obtain updated graphs like the attached figure.

Thanks

streamline.mw

Here is a "toy" instance. 
As the title suggests, I would like to simplify the following boolean combinations: (Note that the  should be taken into account.) 

formula__0 := 
 convert(And(
   Non(`xor`(Or(0 >- 0, y ** 3=x), 
     And(((y*x - 0^0)^2 + (y*y - x*x)^2)*(y^2 + x^2) > 
       0, 0 <- (y**3 - x)*(y - x**3)**3, 
      `implies`(y + x*2 >= y ** 3*2 + x**3, 
       Or(y + x < y*y*y + x*x*x)), Not((y**3 - x)*(y - x**3) = 0), 
      0 >= 0), y <> x*x*x))), 'boolean_function'):

Regretfully, the built-in command simplify is unable to simplify : 

simplify(formula__0, assume = real); # only rudimentary simplifications 
 = 



The library function SMTLIB:-Simplify seems to simplify it, but the result is incorrect

(SMTLIB:-Simplify(formula__0) assuming real); # check {y = 1, x = 0} 
 = 
                    /   /   / 3           3\\\
                 And\Not\And\y  = x, y = x ///

The only procedure I can find that is capable of rewriting it appears to be RealDomain:-solve

RealDomain:-solve(formula__0, 'allsolutions'); # see below 
 = 
Warning, solutions may have been lost
    /            3\    /     3       \    /     3        \   
   { x = x, y = x  }, { x = y , y = y }, { y = x , x < -1 }, 
    \             /    \             /    \              /   

      /     3              \    /     3        \   
     { y = x , 0 < x, x < 1 }, { x = y , y < -1 }, 
      \                    /    \              /   

      /     3              \ 
     { x = y , 0 < y, y < 1 }
      \                    / 


Nevertheless, this is more or less overkill, since a complete solution set is somewhat unnecessary, and in practice, an simplified and compact but presumably unsolved form is more applicable to further manipulations. (For example, the simplest form of And(y*y + x*x > 0^0): (over ℝ²) should at least be x2y2>1, yet  simply returns sort(convert(Or,function,map2(`?()`,And,RealDomain[solve](And(y*y+x*x>0^0),[x,y]))),[x,y]), which is definitely unsuitable here.) (A more real example can be found in the Ex3 of this compressed file.)

I believe that this is a common problem; curiously, I cannot find any related questions in this forum. So, are such simplifications (similar to SLFQ) available in Maple? 

I have a repetative set of parameter names used in procedures in a package. I settled on making all optional inputs in the format {name::type:=something}. Originally I wanted to use non capitalised names for the optional inputs. But the names clash with Maple commands. I have all sorts of quicky abbreviations like prnt etc. These are both messy and tacky. For many of my choices I would seem to have to use capitalised naming to give a meaningful name. The problem here is these names are used in other Maple packages. So sooner or later there is going to be a clash.

Is there a way a of handling this? Like can I defiine package parameter names? Or should I just stick with my abbreviations?

I read somewhere about this problem in the help years ago. I think Basis was the example used in different packages GroebinerBasis and Polynomial package and using PackageName:-Basis to avoid the clash with both loaded. But that is more a command level handling.

restart

 

illegal:=proc(x,y,{Point:=[symbol=solidcircle,colour=purple]},{Line:=[colour=green,thickness=2]},{Colour:="Blue"},{Scale:=5},{Print:="y"})

print("1 Point= ",Point);  #I currently use points
print("2 Line= ",Line);   #                 linetype
print("3 Colour=  ",Colour); #              clr     this has nothing to do with plotting colour
print("4 Scale= ",Scale);   #               scl   
print("5 Print= ",Print);   #               prnt
Scale*x/y
end proc

 

proc (x, y, { Colour := "Blue", Line := [colour = green, thickness = 2], Point := [symbol = solidcircle, colour = purple], Print := "y", Scale := 5 }) print("1 Point= ", Point); print("2 Line= ", Line); print("3 Colour=  ", Colour); print("4 Scale= ", Scale); print("5 Print= ", Print); Scale*x/y end proc

(1)

illegal(3,7)

"1 Point= ", [symbol = solidcircle, colour = purple]

 

"2 Line= ", [colour = green, thickness = 2]

 

"3 Colour=  ", "Blue"

 

"4 Scale= ", 5

 

"5 Print= ", "y"

 

15/7

(2)

illegal(3,7,line=[linestyle=dash,colour=black,thickness=4])

"1 Point= ", [symbol = solidcircle, colour = purple]

 

"2 Line= ", [colour = green, thickness = 2]

 

"3 Colour=  ", "Blue"

 

"4 Scale= ", 5

 

"5 Print= ", "y"

 

15/7

(3)
 

 

Download 2024-03-09_Illegal_or_Not.mw

Want to make a rectangular graph (in the sense of Graph Theory) of 4 copies of the path A-B-C-D i.e. four rows of this path. Once the rectangular or matrix like graph is made its ediges are to be weighted as the matrix position of vertex stating from (1,1) at the upper left vertex i.e. "A". Help please.

Hi everyone! :)

I'm new to Maple, so please forgive me if the solution is obvious, but I could not find any fitting articles for my problem.

I have a transfer function and need to find the poles. Later, I want to calculate the constants to meet my filter requirements. For now, I'm focusing on getting a symbolic solution and evaluating the poles.

Here's my setup:


Here is the File NoiseFilter.mw

 

 

When I use the "evalf" function, it gives me a large sum, but I would like to get one complex numerical result.

I appreciate any help! :)

I would expect I could do

A := DataSeries([2, 3, 4], datatype = float)
B := DataSeries([1, 3, 19], datatype = float)
min~(A, B)

but the last command gives me 

Error, (in DataSeries:-min) invalid boolean expression: 2.

How do I find the element-wise min (i.e. DataSeries([1,3,4], datatype=float)) of two DataSeries?

One may easily spot that the symbols “” and “” are missing here and here

These two PDF files were printed officially, so I think they can be considered examples of best practice for the export functionality. Does this mean that this functionality is still defective in the most recent release?

Where does one find the python module "maple" used to access open maple as in https://www.maplesoft.com/support/help/maple/view.aspx?path=OpenMaple%2fPython%2fAPI ?

For t not equal to nT,   

dS/dt = delta- mu*S+ omega*V; 

 dV/dt = -(omega+mu)*V

For t=nT, 

 S(nT+)=(1-gamma) S(nT);

V(nT+)=V(nT)+ gamma* S(nT),

with the initial conditions  S(0+)=s0

V(0+)=v0

    how to plot the graph with this system of equations,impulsive points and initial conditions  

5 6 7 8 9 10 11 Last Page 7 of 2125