Maple 2024 Questions and Posts

These are Posts and Questions associated with the product, Maple 2024

Hello,

I'm seeking an efficient solution to a particular problem. To illustrate, I'll provide a simplified example, though in practice, I'm handling lists with millions of elements.

Let's take the list, l: [1, 2, 3, 4, 5, 6, 7, 8]. Each element in this list has a corresponding twin. For instance, 1 has twins [4, 5], and 2 has twins [9, 12] (note that 12 is not in the original list, but that's not problematic). The complete list of twins is represented as t: [[4, 5], [9, 12], [6, 8], [1, 5], [1, 4], [3, 8], [13, 14, 17], [3, 6], [2, 12], [11, 12, 15]], and the twins are made available as they are needed.

The objective is to remove all twins starting from the first element of the list. Once a twin is removed, there's no need to check for twins for that particular element. For example, consider the first element, 1; the twins [4, 5] are removed, and there's no need to find the twins for those elements. The desired outcome would be the list [1, 2, 3, 7,10].

My solution utilizes a combination of a while loop and sets. However, it's painfully slow when dealing with lists larger than a few hundred thousand elements. 

Many thanks.  

I am a new Maple user. I have a system of differential equations and I want Maple to solve the system such that if one of the solutions (dependent variable) is larger than a certain value, one of the differential equation will be described in a different way. I will describe it with an example:

restart;
with(plots);
# imagine we have two differential equations:
eqn1 := diff(T(x), x) = x + T(x)/10 + q(x)/2;
eqn2 := diff(q(x), x) = T(x)^2/10 + 3*q(x);
#The solution is given by:
sol := dsolve({eqn1, eqn2, T(0) = 0, q(0) = 0}, {T(x), q(x)}, numeric, method = mebdfi);
odeplot(sol, [x, T(x)], x = 1 .. 3);

#what I want to do is to write a conditional differential equation that depends on the solution T(x) of the system. For exmaple, if the value of T(x) is larger than 4, the solver sould use a different equation to solve the system. Say for example instead of eqn1 it will use something else like: eqn1:=diff(T(x),x)=x+T(x)^2/200+q(x)/300.

#Internally after each iteration, the solver should check the value of the solution T(x), and depending on it it will choose a different differential equation to use in the next step x.

I tried defining the differential equation as piecewise but I was not successful.

Maple gives solutions that do not satisfy the equation. Wondering what do I need to change.  

restart;
n:=3;m:=2;
eqx:=x^(n/m)=a;
maple_sol:=[PDEtools:-Solve(eqx,x)]; #also tried solve()
F:=map(X->eval(eqx,X),maple_sol);
map(X->evalb(X),F);

 

I always verified in Mathematica

Any thought what is going on and what do I need to change in my Maple code to make it give the solution x=a^(2/3) only?  

It is also possible that Mathematica is the one who is skipping the two complex solutions, but then I need to verify these in Maple, and so far I can't. Only the first solution is verified by Maple.

Even simplification with assuming a>0 do not verify these two extra solution given with complex values. I also tried RealDomain package but this also had no effect. I tired assuming real also and tried simplify with symbolic option.

Anything else I should try?

Maple 2024 on windows 10

update

As I said, I tried RealDomain but with PDEtools:-Solve. With solve it works. Is this a bug? worksheet below

35788

restart;

35788

interface(version);

`Standard Worksheet Interface, Maple 2024.0, Windows 10, March 01 2024 Build ID 1794891`

Physics:-Version();

`The "Physics Updates" version in the MapleCloud is 1701. The version installed in this computer is 1693 created 2024, March 7, 17:27 hours Pacific Time, found in the directory C:\Users\Owner\maple\toolbox\2024\Physics Updates\lib\`

restart;

35788

n:=3;m:=2;
eqx:=x^(n/m)=a;
use RealDomain in (PDEtools:-Solve(eqx,x)) end use;
F:=map(X->eval(eqx,X),[%]);
map(X->evalb(X),F);

3

2

x^(3/2) = a

x = a^(2/3), x = (1/4)*a^(2/3)*(1+I*3^(1/2))^2, x = (1/4)*a^(2/3)*(I*3^(1/2)-1)^2

[a = a, (1/16)*4^(1/2)*(a^(2/3)*(1+I*3^(1/2))^2)^(3/2) = a, (1/16)*4^(1/2)*(a^(2/3)*(I*3^(1/2)-1)^2)^(3/2) = a]

[true, false, false]

restart;

35788

n:=3;m:=2;
eqx:=x^(n/m)=a;
use RealDomain in (solve(eqx,x)) end use;
F:=map(X->eval(eqx,x=X),[%]);
map(X->evalb(X),F);

3

2

x^(3/2) = a

a^(2/3)

[a = a]

[true]

 

 

Download real_domain_solve_vs_PDEtools_Solve.mw

I have used "colour" as my spelling on optional inputs to procedures in my package.  How can I also handle the alternative spelling "color"?  
 

restart

 

coltest:=proc(c)
  if c="b" then return 1
   elif c="r" then return 2
   elif c="g" then return 3
  end if;
end proc:

 

foo:=proc(a,{colour:="b"})
local COL;
   COL:=coltest(colour);
if COL=1 then return a
  elif COL=2 then return a^2
  elif COL=3 then return a^3
  else error `wrong colour`;
end if ;
end proc:

 

foo(3,colour="r")

9

(1)

foo(2,colour="p")

Error, (in foo) wrong colour

 
 

 

Download 2024-03-21_Q_colour_or_color.mw

May be someone can come up with a way to simplify this ode solution? I used the option useInt but the solution can be written in much simpler way than Maple gives.  Below is worksheet showing Maple's 2024 solution and my hand solution.

(having trouble uploading worksheet, will try again).


 

144036

ode:=diff(y(x),x)^3=y(x)+x

(diff(y(x), x))^3 = y(x)+x

maple_sol:=dsolve(ode,useInt):
maple_sol:=Vector([maple_sol]);

Vector(3, {(1) = x-Intat(3*_a^2/(_a+1), _a = (y(x)+x)^(1/3))-_C1 = 0, (2) = x-Intat(3*_a^2/(_a+1), _a = -(1/2)*(y(x)+x)^(1/3)-((1/2)*I)*sqrt(3)*(y(x)+x)^(1/3))-_C1 = 0, (3) = x-Intat(3*_a^2/(_a+1), _a = -(1/2)*(y(x)+x)^(1/3)+((1/2)*I)*sqrt(3)*(y(x)+x)^(1/3))-_C1 = 0})

mysol1:= Intat(1/(_a^(1/3) + 1), _a = (y(x) + x))=x+_C1:
mysol2:= Intat(1/( -(-1)^(1/3)*_a^(1/3) + 1), _a = (y(x) + x))=x+_C1:
mysol3:= Intat(1/( (-1)^(2/3)*_a^(1/3) + 1), _a = (y(x) + x))=x+_C1:
mysol:=Vector([mysol1,mysol2,mysol3]);

 

Vector(3, {(1) = Intat(1/(1+_a^(1/3)), _a = y(x)+x) = x+_C1, (2) = Intat(1/(-(-1)^(1/3)*_a^(1/3)+1), _a = y(x)+x) = x+_C1, (3) = Intat(1/((-1)^(2/3)*_a^(1/3)+1), _a = y(x)+x) = x+_C1})

map(X->odetest(X,ode),mysol)

 

Vector(3, {(1) = 0, (2) = 0, (3) = 0})

 


 

Download simpler_solution.mw

I keep losing the edits I do. I post screen shot. Click submit, then find all my changes are lost. Will try one more time and give up:

This is Maple solution

This is implified version

 

Both versions are verified correct by odetest. The question is there is a way to obtain the simpler form from Maple.

 

Hi,

I need your insights on two technical questions regarding my BoxPlot:

1) How to adjust the color of the text (Title and caption)

2) How to remove only the y-axis

Thank you

S5StatBoxPlotBtest.mw

I was wondering why Maple do not give this simpler solution to this ode. It solves it as exact. But if solved as separable, the solution is much simpler.

I solved this by hand and Maple verifies my solution. You can see the separable solution is much simpler. Any tricks to make Maple gives the simpler solution?

interface(version);

`Standard Worksheet Interface, Maple 2024.0, Windows 10, March 01 2024 Build ID 1794891`

ode:=diff(y(x),x)^4+f(x)*(y(x)-a)^3*(y(x)-b)^3*(y(x)-c)^2 = 0;

(diff(y(x), x))^4+f(x)*(y(x)-a)^3*(y(x)-b)^3*(y(x)-c)^2 = 0

infolevel[dsolve]:=5;
sol:=dsolve(ode);
odetest(sol,ode);

5

Methods for first order ODEs:

-> Solving 1st order ODE of high degree, 1st attempt

trying 1st order WeierstrassP solution for high degree ODE

trying 1st order WeierstrassPPrime solution for high degree ODE

trying 1st order JacobiSN solution for high degree ODE

trying 1st order ODE linearizable_by_differentiation

trying differential order: 1; missing variables

trying simple symmetries for implicit equations

--- Trying classification methods ---

trying homogeneous types:

trying exact

<- exact successful

Intat(1/((_a-c)^(1/2)*(_a-b)^(3/4)*(_a-a)^(3/4)), _a = y(x))+Intat(-(-f(_a)*(-y(x)+c)^2*(-y(x)+b)^3*(-y(x)+a)^3)^(1/4)/((y(x)-c)^(1/2)*(y(x)-b)^(3/4)*(y(x)-a)^(3/4)), _a = x)+c__1 = 0

0

mysol:=Intat(1/( (_a-c)^(2/3)*(_a-b)*(_a-a))^(3/4),_a = y(x))=Intat( (-f(_a))^(1/4),_a=x)+_C1;
odetest(mysol,ode)

Intat(1/((_a-c)^(2/3)*(_a-b)*(_a-a))^(3/4), _a = y(x)) = Intat((-f(_a))^(1/4), _a = x)+c__1

0


 

Download why_not_this_simpler_solution.mw

Hand solution

Maple 2024

it took me hrs to find this as my solution was failing verification and I did not know why.

What logic do you think Maple used to simplify this:

expr:=sqrt(1 + sin(x))/x;
simplify(expr)

To this

How could the above be simpler than

?

Compare to Mathematica

And this is what I expected. I am now scared to use simplify in Maple as I do not know what I will get back.

Is there a way to tell Maple not to do such strange "simplification"? I am doing this in code, and the code does not know what the expression is.

To see an example of the side effect of this, here is one, where if solution to an ode is simplified first, it no longer verifies by odetest without adding extra assumptions:


 

155324

interface(version);

`Standard Worksheet Interface, Maple 2024.0, Windows 10, March 01 2024 Build ID 1794891`

restart;

155324

ode:=diff(y(x),x)=(cos(x)-2*x*y(x)^2)/(2*x^2*y(x));
sol:=dsolve([ode,y(Pi)=1/Pi]);
odetest(sol,ode);

diff(y(x), x) = (1/2)*(cos(x)-2*x*y(x)^2)/(x^2*y(x))

y(x) = (sin(x)+1)^(1/2)/x

0

odetest(simplify(sol),ode);

(1/4)*cos(x)*2^(1/2)*csgn(cos((1/2)*x)+sin((1/2)*x))^2*csgn(1, (1/2)*2^(1/2)*(cos((1/2)*x)+sin((1/2)*x)))/x

One does not expect that simplified solution no longer verfiies the ode.

Sure, I can do

          odetest(simplify(sol),ode) assuming real;

and now it gives 0. But the point is that the first one did not need assumptions.

Download simplify_with_odetest.mw

Maple 2024 on windows 10.

I am trying to tidy up cases where a proc returns multiple values. Have being trying Tabulate. I can get it to work when called after the results are returned. I would the procedure to do this but  keep acces to the name(s) assigned to the returned values.

A,B,C:= proc(...)  .....  return a, b, c    end proc. 

So basically display a tabulated of a, b, c.
 

restart

 

QQFProj := proc(q12::algebraic, q23::algebraic, q34::algebraic, q14::algebraic,{columns:=[QQFproj,Q13proj,Q24proj]},prnt::boolean:=true)
description "Projective quadruple quad formula and intermediate 13 and 24 quads. Useful for cyclic quadrilaterals";
local qqf,q13,q24, sub1,sub2,sub3, R;
#uses  DT = DocumentTools;
sub1:= (q12 + q23 + q34 + q14)^2 - 2*(q12^2 + q23^2 + q34^2 + q14^2) ;
sub2:=-4*(q12*q23*q34+q12*q23*q14+q12*q34*q14+q23*q34*q14)+8*q12*q23*q34*q14;
sub3:=64*q12*q23*q34*q14*(1-q12)*(1-q23)*(1-q34)*(1-q14);
qqf:=(sub1+sub2)^2=sub3;
q13:=((q12-q23)^2-(q34-q14)^2)/(2*(q12+q23-q34-q14-2*q12*q23+2*q34*q14));#check this
q24:=((q23-q34)^2-(q12-q14)^2)/(2*(q23+q34-q12-q14-2*q23*q34+2*q12*q14));#check this
#if prnt then
#return [columns,[qqf,q13,q24]];


if prnt then
print(cat(" ",columns[1],"    ",columns[2],"     ",columns[3])) ;
end if;
return qqf ,q13,q24


 end proc:

q12:=1/2:q23:=9/10:q34:=25/26:q41:=9/130: #Cyclic quadrilateral
 AA:=QQFProj(q12,q23,q34,q41,true);


AA[1];
AA[2];
AA[3]

" QQFproj    Q13proj     Q24proj"

 

9801/2856100 = 9801/2856100, 4/5, 16/65

 

9801/2856100 = 9801/2856100

 

4/5

 

16/65

(1)

# Can the below be built into the proc to nicely didplay the results but maintain access to the results as shown when prnt=true.

columns:=[QQFproj,Q13proj,Q24proj]:
BB:=QQFProj(q12,q23,q34,q41,false):
DocumentTools:-Tabulate([columns,[BB]],width=55):#could do with a variable width depending on length of output epression.

BB[1];
BB[2];
BB[3]

9801/2856100 = 9801/2856100

 

4/5

 

16/65

(2)

dspformat:=(BB,columns)->DocumentTools:-Tabulate([columns,[BB]],width=75);

proc (BB, columns) options operator, arrow; DocumentTools:-Tabulate([columns, [BB]], width = 75) end proc

(3)

CC:=dspformat(BB,columns):#layout not as expected

CC[1] ; #  just gives  letters from Tabulate

"T"

(4)

 


 

Download 2024-03-18_Q_Format_Returned_Results_into_a_Table..mw

I am trying to get Maple to simplify the following trigonometric expressions (for "generic" parameters) as much as possible

sineExpr(3) := (
   sin(a[2] - b[1])*sin(a[3] - b[1]))/(
   sin(b[2] - b[1])*sin(b[3] - b[1]))*sin(a[1] - b[1]) + (
   sin(a[3] - b[2])*sin(a[1] - b[2]))/(
   sin(b[3] - b[2])*sin(b[1] - b[2]))*sin(a[2] - b[2]) + (
   sin(a[1] - b[3])*sin(a[2] - b[3]))/(
   sin(b[1] - b[3])*sin(b[2] - b[3]))*sin(a[3] - b[3]);
 = 
   (('RealDomain:-sin'(a[2]-b[1])*'RealDomain:-sin'(a[3]-b[1]))/('RealDomain:-sin'(b[2]-b[1])*'RealDomain:-sin'(b[3]-b[1])))&*'RealDomain:-sin'(a[1]-b[1])+(('RealDomain:-sin'(a[3]-b[2])*'RealDomain:-sin'(a[1]-b[2]))/('RealDomain:-sin'(b[3]-b[2])*'RealDomain:-sin'(b[1]-b[2])))&*'RealDomain:-sin'(a[2]-b[2])+(('RealDomain:-sin'(a[1]-b[3])*'RealDomain:-sin'(a[2]-b[3]))/('RealDomain:-sin'(b[1]-b[3])*'RealDomain:-sin'(b[2]-b[3])))&*'RealDomain:-sin'(a[3]-b[3])


sineExpr(4) := (
   sin(a[2] - b[1])*sin(a[3] - b[1])*sin(a[4] - b[1]))/(
   sin(b[2] - b[1])*sin(b[3] - b[1])*sin(b[4] - b[1]))*
   sin(a[1] - b[1]) + (
   sin(a[3] - b[2])*sin(a[4] - b[2])*sin(a[1] - b[2]))/(
   sin(b[3] - b[2])*sin(b[4] - b[2])*sin(b[1] - b[2]))*
   sin(a[2] - b[2]) + (
   sin(a[4] - b[3])*sin(a[1] - b[3])*sin(a[2] - b[3]))/(
   sin(b[4] - b[3])*sin(b[1] - b[3])*sin(b[2] - b[3]))*
   sin(a[3] - b[3]) + (
   sin(a[1] - b[4])*sin(a[2] - b[4])*sin(a[3] - b[4]))/(
   sin(b[1] - b[4])*sin(b[2] - b[4])*sin(b[3] - b[4]))*
   sin(a[4] - b[4]);
 = 
(('RealDomain:-sin'(a[2]-b[1])*'RealDomain:-sin'(a[3]-b[1])*'RealDomain:-sin'(a[4]-b[1]))/('RealDomain:-sin'(b[2]-b[1])*'RealDomain:-sin'(b[3]-b[1])*'RealDomain:-sin'(b[4]-b[1])))&*'RealDomain:-sin'(a[1]-b[1])+(('RealDomain:-sin'(a[3]-b[2])*'RealDomain:-sin'(a[4]-b[2])*'RealDomain:-sin'(a[1]-b[2]))/('RealDomain:-sin'(b[3]-b[2])*'RealDomain:-sin'(b[4]-b[2])*'RealDomain:-sin'(b[1]-b[2])))&*'RealDomain:-sin'(a[2]-b[2])+(('RealDomain:-sin'(a[4]-b[3])*'RealDomain:-sin'(a[1]-b[3])*'RealDomain:-sin'(a[2]-b[3]))/('RealDomain:-sin'(b[4]-b[3])*'RealDomain:-sin'(b[1]-b[3])*'RealDomain:-sin'(b[2]-b[3])))&*'RealDomain:-sin'(a[3]-b[3])+(('RealDomain:-sin'(a[1]-b[4])*'RealDomain:-sin'(a[2]-b[4])*'RealDomain:-sin'(a[3]-b[4]))/('RealDomain:-sin'(b[1]-b[4])*'RealDomain:-sin'(b[2]-b[4])*'RealDomain:-sin'(b[3]-b[4])))&*'RealDomain:-sin'(a[4]-b[4])

So far, all of my attempts have failed: 
 

restart:

kernelopts('version');

Physics:-Version();

`Maple 2024.0, X86 64 WINDOWS, Mar 01 2024, Build ID 1794891`

 

`The "Physics Updates" version in the MapleCloud is 1701 and is the same as the version installed in this computer, created 2024, March 17, 17:24 hours Pacific Time.`

(1)

sineExpr := proc (m::posint) options operator, arrow; add(mul(ifelse(j <> t, (':-sin')(a[j]-b[t])/(':-sin')(b[j]-b[t]), (':-sin')(a[t]-b[t])), j = 1 .. m), t = 1 .. m) end proc

Warning, (in sineExpr) `t` is implicitly declared local

 

Warning, (in sineExpr) `j` is implicitly declared local

 

Warning, (in sineExpr) `t` is implicitly declared local

 

Warning, (in sineExpr) `j` is implicitly declared local

 

combine(simplify(normal(sineExpr(1), expanded), trig), trig);

sin(a[1]-b[1])

(2)

combine(simplify(normal(sineExpr(2), expanded), trig), trig); # which can be transformed into sin((a[1]+a[2])-(b[1]+b[2])) only in certain legacy versions!

-(1/2)*(cos(-2*b[2]+a[1]+a[2])-cos(-2*b[1]+a[1]+a[2]))/sin(b[1]-b[2])

(3)

combine(simplify(normal(sineExpr(3), expanded), trig), trig);

(1/2)*(cos(-b[1]-3*b[2]+b[3]+a[2]+a[3]+a[1])-cos(b[1]-3*b[2]-b[3]+a[2]+a[3]+a[1])-cos(-b[1]-3*b[3]+a[2]+a[3]+a[1]+b[2])+cos(b[1]-3*b[3]-b[2]+a[2]+a[3]+a[1])+cos(-3*b[1]+a[2]+a[3]+a[1]+b[2]-b[3])-cos(-3*b[1]+a[2]+a[3]+a[1]-b[2]+b[3]))/(sin(-2*b[2]+2*b[1])-sin(-2*b[3]+2*b[1])+sin(2*b[2]-2*b[3]))

(4)

CodeTools:-Usage(combine(simplify(normal(sineExpr(4), expanded), trig), trig));

memory used=244.67MiB, alloc change=0 bytes, cpu time=6.17s, real time=5.49s, gc time=1000.00ms

 

(1/2)*(sin(-2*a[3]+4*a[4]+2*a[2]-b[3]-b[4]-b[2]-b[1])-sin(4*a[2]-2*a[4]-b[3]-b[4]-b[2]-b[1]+2*a[1])+sin(-2*a[2]-b[3]-b[4]-b[2]-b[1]+4*a[4]+2*a[1])+sin(-2*a[2]+b[3]+b[4]+b[2]+b[1]-4*a[4]+2*a[1])+sin(-b[3]-b[4]-b[2]-b[1]+4*a[1]-2*a[3]+2*a[4])-sin(4*a[3]-2*a[4]+2*a[2]-b[3]-b[4]-b[2]-b[1])-sin(-4*a[3]-2*a[4]+2*a[2]+b[3]+b[4]+b[2]+b[1])+sin(-2*a[3]-4*a[4]+2*a[2]+b[3]+b[4]+b[2]+b[1])-sin(-2*a[3]+2*a[4]+4*a[2]-b[3]-b[4]-b[2]-b[1])+sin(-4*a[3]+b[3]+b[4]+b[2]+b[1]-2*a[4]+2*a[1])-sin(4*a[4]-2*a[3]-b[3]-b[4]-b[2]-b[1]+2*a[1])-sin(-2*a[2]-b[3]-b[4]-b[2]-b[1]+4*a[3]+2*a[1])-sin(-2*a[2]+b[3]+b[4]+b[2]+b[1]-4*a[3]+2*a[1])+sin(2*a[3]-2*a[4]+4*a[2]-b[3]-b[4]-b[2]-b[1])-sin(-4*a[2]-2*a[4]+b[3]+b[4]+b[2]+b[1]+2*a[1])+sin(4*a[3]-b[3]-b[4]-b[2]-b[1]-2*a[4]+2*a[1])-sin(-b[3]-b[4]-b[2]-b[1]+4*a[1]+2*a[3]-2*a[4])-sin(-b[3]-b[4]-b[2]-b[1]+4*a[1]+2*a[4]-2*a[2])+sin(-b[3]-b[4]-b[2]-b[1]+4*a[1]-2*a[4]+2*a[2])+sin(-b[3]-b[4]-b[2]-b[1]+4*a[1]+2*a[3]-2*a[2])-sin(-b[3]-b[4]-b[2]-b[1]+4*a[1]-2*a[3]+2*a[2])-sin(-4*a[4]-2*a[3]+b[3]+b[4]+b[2]+b[1]+2*a[1])+sin(4*a[2]-2*a[3]-b[3]-b[4]-b[2]-b[1]+2*a[1])+sin(-4*a[2]-2*a[3]+b[3]+b[4]+b[2]+b[1]+2*a[1]))/(cos(a[1]-a[2]-3*a[3]+3*a[4])-cos(a[1]-a[2]+3*a[3]-3*a[4])+cos(-3*a[2]-a[3]+a[4]+3*a[1])-cos(-3*a[2]+a[3]-a[4]+3*a[1])-cos(a[1]+3*a[2]-3*a[3]-a[4])+cos(a[3]-3*a[4]-a[2]+3*a[1])-cos(-a[3]-3*a[4]+a[2]+3*a[1])+cos(-3*a[3]-a[4]+a[2]+3*a[1])-cos(-3*a[3]+a[4]-a[2]+3*a[1])+cos(a[1]-3*a[2]+3*a[3]-a[4])-cos(a[1]-3*a[2]-a[3]+3*a[4])+cos(a[1]+3*a[2]-a[3]-3*a[4]))

(5)

CodeTools:-Usage(combine(simplify(normal(sineExpr(5), expanded), trig), trig)): # rather lengthy

memory used=4.23GiB, alloc change=-32.00MiB, cpu time=2.66m, real time=2.29m, gc time=29.98s

 

Can sineExpr(3), sineExpr(4), and sineExpr(5) be reduced to sin(a[1]+a[2]+a[3]-b[1]-b[2]-b[3]), sin(a[1]+a[2]+a[3]+a[4]-b[1]-b[2]-b[3]-b[4]), and sin(a[1]+a[2]+a[3]+a[4]+a[5]-b[1]-b[2]-b[3]-b[4]-b[5]) respectively by Maple itself (that is, with as little user-intervention as possible) if one is not aware of such reductions in advance?


 

Download sinIdentity.mw

Note that because zero testing is frequently considerably easier, combine always succeeds in showing that the difference between the simplest possible and the original version is zero. 

combine(sin((a[1]+a[2]+a[3])-(b[1]+b[2]+b[3]))-sineExpr(3));
 = 
                               0

combine(sin((a[1]+a[2]+a[3]+a[4])-(b[1]+b[2]+b[3]+b[4]))-sineExpr(4));
 = 
                               0

However, I wonder if Maple can thoroughly simplify them without knowing those known “simplest possible” form beforehand
I also tried some other functions like rationalize, radnormal, and `convert/trig`, yet Maple appears to have not been capable of completely simplifying even the sub-simplest case 𝑚=2. Is there any workaround? 

Of note, it can be demonstrated inductively that m∈ℕ 

 

where none of the denominators is 0. Nevertheless, as mentioned above, is it possible to transform  and  (as well as , if possible) into potentially more elegant forms (Ideally,  is rewritten into ,  is rewritten into , and  is rewritten into .) without any such a priori knowledge
In Mma, these may be done using TrigReduce directly (cf. ); unfortunately, I cannot found a Maple equivalent to such functionality. 

 I am writing help pages for a package. The inital Overview should be at the top of the listing like in other Maple help directories. 

How to I do this? Mine is listing purely alphabetically.
 

NULL

with(HelpTools)

[Database, TableOfContents, Worksheet]

(1)

currentdir()

"D:\User Account Ronan\Documents\MAPLE\Rational Trigonometry"

(2)

 

NULL

NULL

HelpTools[Database][Create]("C:/Users/Ronan/Maple/toolbox/personal/lib/RationalTrigonometry.help")

"C:/Users/Ronan/Maple/toolbox/personal/lib/RationalTrigonometry.help"

(3)

HelpTools[Database][Add]("C:/Users/Ronan/Maple/toolbox/personal/lib/RationalTrigonometry.help")

["C:\Program Files\Maple 2024\lib\maple.help", "C:\Program Files\Maple 2024\lib\maple_ja.help", "C:\Users\Ronan\maple\toolbox\CodeBuilder\lib\CodeBuilder.help", "C:\Users\Ronan\maple\toolbox\DirectSearch\lib\DirectSearch.help", "C:\Users\Ronan\maple\toolbox\OEIS\lib\OEIS.help", "C:\Users\Ronan\maple\toolbox\UTF8\lib\UTF8.help"]

(4)

HelpTools[Database][GetActive]()

["C:/Users/Ronan/Maple/toolbox/personal/lib/RationalTrigonometry.help", "C:\Program Files\Maple 2024\lib\maple.help", "C:\Program Files\Maple 2024\lib\maple_ja.help", "C:\Users\Ronan\maple\toolbox\CodeBuilder\lib\CodeBuilder.help", "C:\Users\Ronan\maple\toolbox\DirectSearch\lib\DirectSearch.help", "C:\Users\Ronan\maple\toolbox\OEIS\lib\OEIS.help", "C:\Users\Ronan\maple\toolbox\UTF8\lib\UTF8.help", "C:\Users\Ronan\maple\toolbox\personal\lib\RationalTrigonometry.help"]

(5)

NULL

makehelp("RationalTrigonometry", "Rational Trigonometry Overiew Help.mw", "C:/Users/Ronan/Maple/toolbox/personal/lib/RationalTrigonometry.help", aliases = ["RatTrig", "Rat Trig", "RT", "R T"], browser = ["Rational Trigonometry", " Overview"])

["C:/Users/Ronan/Maple/toolbox/personal/lib/RationalTrigonometry.help", "C:\Program Files\Maple 2024\lib\maple.help", "C:\Program Files\Maple 2024\lib\maple_ja.help", "C:\Users\Ronan\maple\toolbox\CodeBuilder\lib\CodeBuilder.help", "C:\Users\Ronan\maple\toolbox\DirectSearch\lib\DirectSearch.help", "C:\Users\Ronan\maple\toolbox\OEIS\lib\OEIS.help", "C:\Users\Ronan\maple\toolbox\UTF8\lib\UTF8.help", "C:\Users\Ronan\maple\toolbox\personal\lib\RationalTrigonometry.help"]

(6)

makehelp("RationalTrigonometry,Quadrance", "Help Quadrance.mw", "C:/Users/Ronan/Maple/toolbox/personal/lib/RationalTrigonometry.help", browser = ["Rational Trigonometry", "Quadrance"])

makehelp("RationalTrigonometry,Cross Law", "Help Cross Law.mw", "C:/Users/Ronan/Maple/toolbox/personal/lib/RationalTrigonometry.help", browser = ["Rational Trigonometry", "CrossLaw"])

makehelp("RationalTrigonometry,Spread", "Help Spread.mw", "C:/Users/Ronan/Maple/toolbox/personal/lib/RationalTrigonometry.help", aliases = ["RT Spread", "R T Spread"], browser = ["Rational Trigonometry", "Spread"])

makehelp("RationalTrigonometry,Spread Law", "Help Spread Law.mw", "C:/Users/Ronan/Maple/toolbox/personal/lib/RationalTrigonometry.help", aliases = ["RT Spread Law", "Spread Law Quadrea"], browser = ["Rational Trigonometry", "Spread Law"])

makehelp("RationalTrigonometry,TQF", "Help Triple Quad Formula.mw", "C:/Users/Ronan/Maple/toolbox/personal/lib/RationalTrigonometry.help", aliases = ["Triple Quad Formula", "TQF"], browser = ["Rational Trigonometry", "Triple Quad Formula"])

makehelp("RationalTrigonometry,TSF", "Help Triple Spread Formula.mw", "C:/Users/Ronan/Maple/toolbox/personal/lib/RationalTrigonometry.help", aliases = ["Triple Spread Formula", "TSF"], browser = ["Rational Trigonometry", "Triple Spread Formula"])

makehelp("RationalTrigonometry,QQF", "Help Quadruple Quad Formula.mw", "C:/Users/Ronan/Maple/toolbox/personal/lib/RationalTrigonometry.help", aliases = ["Quadruple Quad Formula", "QQF"], browser = ["Rational Trigonometry", "Quadruple Quad Formula"])

makehelp("RationalTrigonometry,QSF", "Help Quadruple Spread Formula.mw", "C:/Users/Ronan/Maple/toolbox/personal/lib/RationalTrigonometry.help", aliases = ["Quadruple Spread Formula", "QSF"], browser = ["Rational Trigonometry", "Quadruple Spread Formula"])

makehelp("RationalTrigonometry,Quadrea", "Help Quadrea Triangle.mw", "C:/Users/Ronan/Maple/toolbox/personal/lib/RationalTrigonometry.help", browser = ["Rational Trigonometry", "Quadrea"])

NULL

NULL

NULL       

NULL


 

Download Help_Edit_to_Database_2023.mw

THis ode looks complicated

ode := (2*x^(5/2) - 3*y(x)^(5/3))/(2*x^(5/2)*y(x)^(2/3)) + ((-2*x^(5/2) + 3*y(x)^(5/3))*diff(y(x), x))/(3*x^(3/2)*y(x)^(5/3)) = 0;

But is actually a simple first order linear ode:

RHS:=solve(ode,diff(y(x),x));
new_ode:=diff(y(x),x)=RHS;

Whose solution is 

But Maple gives this very complicated answer as shown below. When asking it to solve as linear ode, it now gives the much simpler solution.  

Maple complicated solutions are all verified OK. But the question is, why did it not give this simple solution?

Attached worksheet.  All on Maple 2024


 

204152

restart;

204152

interface(version);

`Standard Worksheet Interface, Maple 2024.0, Windows 10, March 01 2024 Build ID 1794891`

Physics:-Version();

`The "Physics Updates" version in the MapleCloud is 1700. The version installed in this computer is 1693 created 2024, March 7, 17:27 hours Pacific Time, found in the directory C:\Users\Owner\maple\toolbox\2024\Physics Updates\lib\`

ode := (2*x^(5/2) - 3*y(x)^(5/3))/(2*x^(5/2)*y(x)^(2/3)) + ((-2*x^(5/2) + 3*y(x)^(5/3))*diff(y(x), x))/(3*x^(3/2)*y(x)^(5/3)) = 0;

(1/2)*(2*x^(5/2)-3*y(x)^(5/3))/(x^(5/2)*y(x)^(2/3))+(1/3)*(-2*x^(5/2)+3*y(x)^(5/3))*(diff(y(x), x))/(x^(3/2)*y(x)^(5/3)) = 0

DEtools:-odeadvisor(ode);

[[_1st_order, _with_linear_symmetries], _exact, _rational]

#why such complicated solutions?
sol:=[dsolve(ode)];

[y(x) = (1/3)*2^(3/5)*3^(2/5)*(x^(5/2))^(3/5), y(x) = (1/3)*(-(1/4)*5^(1/2)-1/4-((1/4)*I)*2^(1/2)*(5-5^(1/2))^(1/2))^3*2^(3/5)*3^(2/5)*(x^(5/2))^(3/5), y(x) = (1/3)*(-(1/4)*5^(1/2)-1/4+((1/4)*I)*2^(1/2)*(5-5^(1/2))^(1/2))^3*2^(3/5)*3^(2/5)*(x^(5/2))^(3/5), y(x) = (1/3)*((1/4)*5^(1/2)-1/4-((1/4)*I)*2^(1/2)*(5+5^(1/2))^(1/2))^3*2^(3/5)*3^(2/5)*(x^(5/2))^(3/5), y(x) = (1/3)*((1/4)*5^(1/2)-1/4+((1/4)*I)*2^(1/2)*(5+5^(1/2))^(1/2))^3*2^(3/5)*3^(2/5)*(x^(5/2))^(3/5), x/y(x)^(2/3)+y(x)/x^(3/2)+c__1 = 0]

#all solution are correct
map(X->odetest(X,ode),sol);

[0, 0, 0, 0, 0, 0]

RHS:=solve(ode,diff(y(x),x));
new_ode:=diff(y(x),x)=RHS;

(3/2)*y(x)/x

diff(y(x), x) = (3/2)*y(x)/x

dsolve(new_ode);

y(x) = c__1*x^(3/2)

#force it to solve it as first order linear ode
dsolve(ode,y(x),[`linear`])

y(x) = c__1*x^(3/2)


 

Download why_missed_simple_solution_march_17_2024.mw

In Maple 2022

restart;

res := t^3 - 3*t^2*sqrt(t^2*(12*sqrt(2)*ln(t) + 9*ln(t)^2 + 8)^(1/3))*ln(t)/(12*sqrt(2)*ln(t) + 9*ln(t)^2 + 8)^(2/3) - 2*t^2*sqrt(t^2*(12*sqrt(2)*ln(t) + 9*ln(t)^2 + 8)^(1/3))*sqrt(2)/(12*sqrt(2)*ln(t) + 9*ln(t)^2 + 8)^(2/3);
plot(res,t=-5..1)

gives

The same exact code in Maple 2024 gives

Worksheet is below. 

Both on same PC. Windows 10.

Will report to Maplesoft, but thought to check also here is others have seen such problem before.

Btw, Maple 2022 plot is the correct one.


 

14900

interface(version);

`Standard Worksheet Interface, Maple 2024.0, Windows 10, March 01 2024 Build ID 1794891`

Physics:-Version();

`The "Physics Updates" version in the MapleCloud is 1700. The version installed in this computer is 1693 created 2024, March 7, 17:27 hours Pacific Time, found in the directory C:\Users\Owner\maple\toolbox\2024\Physics Updates\lib\`

restart;

14900

res := t^3 - 3*t^2*sqrt(t^2*(12*sqrt(2)*ln(t) + 9*ln(t)^2 + 8)^(1/3))*ln(t)/(12*sqrt(2)*ln(t) + 9*ln(t)^2 + 8)^(2/3) - 2*t^2*sqrt(t^2*(12*sqrt(2)*ln(t) + 9*ln(t)^2 + 8)^(1/3))*sqrt(2)/(12*sqrt(2)*ln(t) + 9*ln(t)^2 + 8)^(2/3);
plot(res,t=-5..1)

t^3-3*t^2*(t^2*(12*2^(1/2)*ln(t)+9*ln(t)^2+8)^(1/3))^(1/2)*ln(t)/(12*2^(1/2)*ln(t)+9*ln(t)^2+8)^(2/3)-2*t^2*(t^2*(12*2^(1/2)*ln(t)+9*ln(t)^2+8)^(1/3))^(1/2)*2^(1/2)/(12*2^(1/2)*ln(t)+9*ln(t)^2+8)^(2/3)

 


 

Download wrong_plot_V_2024_march_15_2024.mw

Maple's coulditbe  is useful. But unfortunately it does not return back to the user the conditions under which the proposition was found true. This could make it much more useful. It seems in way similar to Mathematica' Reduce but Reduce returns the conditions.

Is there a way to find the conditions which makes it true? 

I use coulditbe alot. I use it to verify that the result of odetest (I call it the residue) is zero or not. Maytimes, odetest does not return zero. And using simplify, or evalb or is to check if the residue is zero, all fail. But many times, coulditbe returns true, meaning the residue is zero. But I do not know under what conditions. In Mathematica's Reduce, it tells me the conditions. 

Here is one of hundreds of examples I have

restart;
ode:=(t^3+y(t)^2*sqrt(t^2+y(t)^2))-(t*y(t)*sqrt(t^2+y(t)^2))*diff(y(t),t)=0;
ic:=y(1)=1;
sol:=dsolve([ode,ic]);
the_residue:=odetest(sol,[ode,ic]);

You see, odetest says it could not verify the solution (the first entry above) but it did verify the solution against the initial conditions. 

Using simplify, evalb and is all also could not verify it

simplify(the_residue[1]);
evalb(the_residue[1]=0);
is(the_residue[1]=0);

Now coulditbe does:

_EnvTry:='hard':
coulditbe(the_residue[1]=0);

So the solution is correct, but I do not know under what conditions. Using Mathematica's Reduce I can find this:

So now back in Maple, I can do this

simplify(the_residue[1]) assuming t>exp(-2*sqrt(2)/3);

                      0

Actually in this example, just using assume t>0 also gives zero. But I am using Mathematica's result for illustration.

You might ask, why do I need to know for what values of the independent variable is the residue zero?

Because in some cases, the residue is zero only at single point! So it does not make sense to say the solution is verified to be correct only at one single point of the domain, right?

it needs to be some finite range at least. Here is an example of an ode whose solution is correct only at x=0

ode:=diff(y(x),x)=3*x*(y(x)-1)^(1/3);
ic:=y(3)=-7;
sol:=dsolve([ode,ic]);
the_residue:=odetest(sol,[ode,ic]);

And simplify, evalb, is all fail to verifiy this, but coulditbe says true

simplify(the_residue[1]);
evalb(the_residue[1]=0);
is(the_residue[1]=0);
_EnvTry:='hard':
coulditbe(the_residue[1]=0);

So now, we ask, is this solution then correct or not? It turns out to be zero but only at origin x=0

plot(abs(the_residue[1]),x=-1..1)

If I knew that residue is zero only at single point, then I would say this solution is not correct, right?

And that is why I need to know under what conditions coulditbe retruned true.

I tried infolevel[coulditbe]:=5 but nothing more was displayed on the screen.

Mathematica's Reduce confirms that when x=0 the residue is zero.

So my question is simply this: Can one obtain the conditions used by coulditbe to determine when result is true?

It will be useful if Maple could in future version return the value/range which makes it true.

 

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

 

First 38 39 40 41 Page 40 of 41