MaplePrimes Questions

Hi
i write my code for calculate this type of function but the result is so different from mine i  will post here i hope someone tell me where is problem

i have this

i want this

Download EX1.mw

Hello!
I am wondering if there is any way i can produce a cayley graph of a fixed radius for a finitely presented infinite group? That is if i take a FinPresInfGrp such as Z² is there any way i could create the cayley graph for the first 5 steps away from e?

I have tried increasing  _EnvMaxCosetsToddCoxeter however i imagine that this is a bit pointless!

Any help would be very much appriciated :)

Is there a way to reassign the arcsecant function "arcsec()" as "asec()" so that "arcsec" can be assigned to the arcsecond unit "Unit(arcsec)"?

Ideally, I would like all of the inverse trigonometric functions to use the shorter notation "asec()" instead of "arcsec()".  I usually do this as aliases, i.e. "alias(asin = arcsin) : alias(asec = arcsec) :" but this won't allow reusing "arcsec" for a unit instead.

Example error for Maple 2023:

alias(asec = arcsec) :
AddUnit(astronomical_unit, context = astronomy, default = true, prefix = SI, conversion = 149597870700*m) : # https://en.wikipedia.org/wiki/astronomical_unit
AddUnit(second, context = angle, spelling = arcsecond, plural = arcseconds, symbol = arcsec, prefix = SI_negative) :

AddUnit(parsec, context = astronomy, default = true, prefix = SI, conversion = AU/tan(arcsec)) ; # https://en.wikipedia.org/wiki/Parsec#Calculating_the_value_of_a_parsec

"Pi/648000" has to be used instead of "arcsec" here when defining the parsec since "arcsec" is already reserved for the arcsecant function, even with "alias(asec = arcsec) ;".

Correction: it looks like the parsec was redefined by the IAU in 2012 as exactly "648000*AU/Pi" without any tangents (or sines) in the definition (so the angle subtended by 1 AU at 1 PC is actually 0.999999999992" not 1").  Both "astronomical_unit" and "parsec" have the wrong values in Maple 2023 which need to be corrected manually.  But the conflict between arcseconds and arcsecants remains the same.

https://iau.org/static/resolutions/IAU2015_English.pdf

https://iopscience.iop.org/article/10.3847/0004-6256/152/2/41

I am reading the documentation on the `Units[Simple]` package.

There is a section that says

"In the Simple Units environment, in contrast to the Standard and Natural environments, unassigned variables are not automatically assumed to represent unit-free quantities. For example, 5m+x is a valid expression if x is unassigned, because x may represent a length. On the other hand (5m+x)(6s+x) is an invalid expression because the first factor implies that x represents a length and the second factor implies that x is a duration."

The way I understood this paragraph is that in Units:-Simple an unassigned variable is not assumed to represent a unit-free quantity, but in Units:-Standard it is assumed to represent a unit-free quantity.

Consider the expression 5m+x. This expression works in Units:-Simple but not in Units:-Standard.

Units:-Simple adds a quantity 5m to a quantity without units. But why can one add a quantity with units to a quantity without units?

Units:-Standard tries to add a quantity 5m to a quantity that is assumed to have units. What units are assumed?

Next, consider (5m+x)(6s+x).

This fails in both packages, as can be seen below (actually, for some reason, the embed below is not showing the expressions typed in for Units:-Standard, but can be seen if you download the worksheet I imagine).

restart

with(Units:-Simple)

5*Unit('m')+x

5*Units:-Unit(m)+x

(1)

(5*Unit('m')+x)*(6*Unit('s')+x)

Error, (in Units:-Simple:-*) the following expressions imply incompatible dimensions: {5*Units:-Unit(m)+x, 6*Units:-Unit(s)+x}

 

restart

with(Units:-Standard)

(5*Unit('m')+x)*(6*Unit('s')+x)

Error, (in Units:-Standard:-+) the units `m` and `1` have incompatible dimensions

 

5*Unit('m')+x

Error, (in Units:-Standard:-+) the units `m` and `1` have incompatible dimensions

 

NULL

So my question is, what exactly is the difference between considering unassigned variables to be unit-free vs not unit-free?

Download Units_Simple_vs_Standard.mw

I am looking for commands that extract from a product the value and the unit.
For example:
How to get 1.65 and m/s^2 from

g_moon := 1.635000000*Unit(('m')/'s'^2)

I was probably looking in the wrong place in Maples unit documentation.
I am not interested in lowlevel commands like op(g_moon)[1]. Something more self-explaining like GetUnit.

I just saw that Maple 2024 no longer supports importing Quandl data.

If this is a feature that I will like to use, it is possible to keep both Maple 2023 and Maple 2024 installed at the same time on Microsoft Windows 11 without conflicts?  Or should I just not upgrade to Maple 2024?  I currently have a perpetual license for Maple 2023 and am on the 15-day trial for Maple 2024.

Hi
i did calculation part by part of adomian laplace method but if we can make a loop for it is gonna be so great and take back a lot of time

restart

with(inttrans)

pde := diff(u(x, t), t)+u(x, t)*(diff(u(x, t), x)) = t^2*x+x

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

(1)

eq := laplace(pde, t, s)

s*laplace(u(x, t), t, s)-u(x, 0)+laplace(u(x, t)*(diff(u(x, t), x)), t, s) = x*(s^2+2)/s^3

(2)

eq2 := subs({u(x, 0) = 0}, eq)

s*laplace(u(x, t), t, s)+laplace(u(x, t)*(diff(u(x, t), x)), t, s) = x*(s^2+2)/s^3

(3)

NULL

lap := s^alpha*laplace(u(x, t), t, s) = x*(s^2+2)/s^3-laplace(u(x, t)*(diff(u(x, t), x)), t, s)

s^alpha*laplace(u(x, t), t, s) = x*(s^2+2)/s^3-laplace(u(x, t)*(diff(u(x, t), x)), t, s)

(4)

lap1 := lap/s^alpha

laplace(u(x, t), t, s) = (x*(s^2+2)/s^3-laplace(u(x, t)*(diff(u(x, t), x)), t, s))/s^alpha

(5)

NULL

lap2 := invlaplace(lap1, s, t)

u(x, t) = -invlaplace(s^(-alpha)*laplace(u(x, t)*(diff(u(x, t), x)), t, s), s, t)+x*(invlaplace(s^(-1-alpha), s, t)+2*invlaplace(s^(-3-alpha), s, t))

(6)

NULL

lap3 := u(x, t) = t^alpha*x/GAMMA(alpha+1)+2*x*t^(alpha+2)/GAMMA(alpha+3)-invlaplace(laplace(u(x, t)*(diff(u(x, t), x)), t, s)/s^alpha, s, t)

u(x, t) = t^alpha*x/GAMMA(1+alpha)+2*x*t^(alpha+2)/GAMMA(3+alpha)-invlaplace(laplace(u(x, t)*(diff(u(x, t), x)), t, s)/s^alpha, s, t)

(7)

NULL

NULL

NULL

NULL

``

(8)

u[1](x, t) = -invlaplace(laplace(u[0](x, t)*(diff(u[0](x, t), x)), t, s)/s^alpha, s, t)

u[1](x, t) = -invlaplace(laplace(u[0](x, t)*(diff(u[0](x, t), x)), t, s)/s^alpha, s, t)

(9)

"u[0](x,t):=(t^alpha x)/(GAMMA(1+alpha))+(2 x t^(alpha+2))/(GAMMA(3+alpha))"

proc (x, t) options operator, arrow, function_assign; t^alpha*x/GAMMA(1+alpha)+2*x*t^(alpha+2)/GAMMA(3+alpha) end proc

(10)

n := N

N

(11)

k := K

K

(12)

f := proc (u) options operator, arrow; u*(diff(u, x)) end proc

proc (u) options operator, arrow; u*(diff(u, x)) end proc

(13)

for j from 0 to 3 do A[j] := subs(lambda = 0, (diff(f(seq(sum(lambda^i*u[i](x, t), i = 0 .. 20), m = 1 .. 2)), [`$`(lambda, j)]))/factorial(j)) end do

(t^alpha*x/GAMMA(1+alpha)+2*x*t^(alpha+2)/GAMMA(3+alpha))*(t^alpha/GAMMA(1+alpha)+2*t^(alpha+2)/GAMMA(3+alpha))

 

u[1](x, t)*(t^alpha/GAMMA(1+alpha)+2*t^(alpha+2)/GAMMA(3+alpha))+(t^alpha*x/GAMMA(1+alpha)+2*x*t^(alpha+2)/GAMMA(3+alpha))*(diff(u[1](x, t), x))

 

u[2](x, t)*(t^alpha/GAMMA(1+alpha)+2*t^(alpha+2)/GAMMA(3+alpha))+u[1](x, t)*(diff(u[1](x, t), x))+(t^alpha*x/GAMMA(1+alpha)+2*x*t^(alpha+2)/GAMMA(3+alpha))*(diff(u[2](x, t), x))

 

u[3](x, t)*(t^alpha/GAMMA(1+alpha)+2*t^(alpha+2)/GAMMA(3+alpha))+u[2](x, t)*(diff(u[1](x, t), x))+u[1](x, t)*(diff(u[2](x, t), x))+(t^alpha*x/GAMMA(1+alpha)+2*x*t^(alpha+2)/GAMMA(3+alpha))*(diff(u[3](x, t), x))

(14)

S1 := u[1](x, t) = -invlaplace((t^alpha*x/GAMMA(1+alpha)+2*x*t^(alpha+2)/GAMMA(3+alpha))*(t^alpha/GAMMA(1+alpha)+2*t^(alpha+2)/GAMMA(3+alpha))/s^alpha, s, t)

u[1](x, t) = -x*(t^alpha)^2*invlaplace(s^(-alpha), s, t)*(1/GAMMA(1+alpha)^2+4*t^2/(GAMMA(3+alpha)*GAMMA(1+alpha))+4*t^4/GAMMA(3+alpha)^2)

(15)

NULL

NULL

u[1](x, t) = x*GAMMA(2*alpha+1)*t^(3*alpha)/(GAMMA(1+alpha)^2*GAMMA(3*alpha+1))-4*x*GAMMA(2*alpha+3)*t^(3*alpha+2)/(GAMMA(1+alpha)*GAMMA(3+alpha)*GAMMA(3*alpha+3))-4*`xΓ`(2*alpha+5)/(GAMMA(3+alpha)^2*GAMMA(3*alpha+3))

u[1](x, t) = x*GAMMA(2*alpha+1)*t^(3*alpha)/(GAMMA(1+alpha)^2*GAMMA(3*alpha+1))-4*x*GAMMA(2*alpha+3)*t^(3*alpha+2)/(GAMMA(1+alpha)*GAMMA(3+alpha)*GAMMA(3*alpha+3))-4*`xΓ`(2*alpha+5)/(GAMMA(3+alpha)^2*GAMMA(3*alpha+3))

(16)

NULL

u[2](x, t) = -invlaplace(laplace(u[1](x, t)*(diff(u(x, t), x)), t, s)/s^alpha, s, t)

NULL

NULL


for get definition use this pdf for fractional derivation

[Copyrighted material removed by moderator - see https://doi.org/10.4236/am.2018.94032]

Download solving_example_1.mw

I just installed the 15-day trial for the new Maple 2024.  It looks like Maple 2024 has the same problem as Maple 2023 in that it will not maintain a connection to MapleCloud.  I can sign in to MapleCloud no problem but as soon as I close the window, it forgets my password and I have to log back in each time I want to access MapleCloud.  Is there a way for Maple 2023 or Maple 2024 to remember my Maplesoft password so I do not have to log back in every time I want to access MapleCloud?

Dear all,

I am trying to minimize this polynomial function G on [0,1]x[0,1]:

Maple 2022 seems unable to find the (approximate) minimum. Even adding _EnvExplicit:=true, as suggested here on a previous post, does not fix the issue.

Any suggestion?

Thanks, Nicola

restart:

_EnvExplicit:=true:

G := (x, y) -> ((-1)*38.87*y^4 + 39.7800000000000*y^3 + (-1)*6.76000000000000*y^2 + 10.4000000000000*y - 3.90000000000000)*x^4 + (39.78*y^4 + (-1)*40.4600000000000*y^3 + 6.80000000000000*y^2 + (-1)*10.2000000000000*y + 3.40000000000000)*x^3 + ((-1)*6.76*y^4 + 6.80000000000000*y^3 + (-1)*1.12000000000000*y^2 + 1.60000000000000*y - 0.400000000000000)*x^2 + (10.4*y^4 + (-1)*10.2000000000000*y^3 + 1.60000000000000*y^2 + (-1)*2.00000000000000*y)*x + 1. + (-1)*3.9*y^4 + (-1)*0.4*y^2 + 3.4*y^3

proc (x, y) options operator, arrow; (-38.87*y^4+39.7800000000000*y^3-6.76000000000000*y^2+10.4000000000000*y-3.90000000000000)*x^4+(39.78*y^4-40.4600000000000*y^3+6.80000000000000*y^2-10.2000000000000*y+3.40000000000000)*x^3+(-6.76*y^4+6.80000000000000*y^3-1.12000000000000*y^2+1.60000000000000*y-.400000000000000)*x^2+(10.4*y^4-10.2000000000000*y^3+1.60000000000000*y^2-2.00000000000000*y)*x+1.-3.9*y^4-.4*y^2+3.4*y^3 end proc

(1)

minimize(G(x,y),x=0..1,y=0..1)

 

NULL

Download Untitled.mw

I would like to calculate the following quantity: 

 

Where F is the SU(2) field strength tensor given by:

The gauge field V (in my code A) is defined as

 

where rj is the unit vector in spherical coordinates.

I tried to calculate it with maple, however, the result is not correct. I should get a scalar function, but my result still contains dependencies on x,y,z. And I really don't know why. I have defined the gauge field in (11) and the field strength tensor in (14). I could imagine that SumOverRepeatedIndices() in (16) does not work as I think (For each a = (1,2,3) I would like a summation over mu and nu). Greek letters are my spacetime indices and lowercase letters are my space indices. Do I perhaps have to use SU(2) indices instead of the space indices? But how exactly does a SU(2) index differ from a space index?    

restart

with(Physics)

__________________________________________________________________

(1)

with(Vectors)NULL

Setup(spacetimeindices = greek, spaceindices = lowercaselatin, su2indices = uppercaselatin, signature = `+++-`, coordinates = spherical)

[coordinatesystems = {X}, signature = `+ + + -`, spaceindices = lowercaselatin, spacetimeindices = greek, su2indices = uppercaselatin]

(2)

Setup(realobjects = {g, diff(x, x), diff(y(x), x), diff(z(x), x), f__A(X[1])})

[realobjects = {g, phi, r, rho, theta, x, `x'`, y, `y'`, z, `z'`, f__A(r)}]

(3)

"x'(r,theta,phi)  :=  r * sin(theta) * cos(phi)"

proc (r, theta, phi) options operator, arrow, function_assign; Physics:-`*`(r, sin(theta), cos(phi)) end proc

(4)

"y'(r,theta,phi) := r * sin(theta) * sin(phi)"

proc (r, theta, phi) options operator, arrow, function_assign; Physics:-`*`(r, sin(theta), sin(phi)) end proc

(5)

"z'(r,theta,phi)  := r * cos(theta)"

proc (r, theta, phi) options operator, arrow, function_assign; Physics:-`*`(r, cos(theta)) end proc

(6)

 

This ist my unit vector:

Define(R[a] = [(diff(x, x))/r, (diff(y(x), x))/r, (diff(z(x), x))/r]) 

{Physics:-Dgamma[mu], Physics:-Psigma[mu], R[a], Physics:-d_[mu], Physics:-g_[mu, nu], Physics:-gamma_[a, b], Physics:-LeviCivita[alpha, beta, mu, nu], Physics:-SpaceTimeVector[mu](X)}

(7)

R[definition]

R[a] = [`x'`/r, `y'`/r, `z'`/r]

(8)

Parse:-ConvertTo1D, "first argument to _Inert_ASSIGN must be assignable"

r^2

(9)

"Define(A[mu,~a] =(1-`f__A`(X[1]) )/(g*X[1])*LeviCivita[a, mu,j,4]* R[j] )  "

{A[mu, `~a`], Physics:-Dgamma[mu], F[mu, nu, a], Physics:-Psigma[mu], R[a], Physics:-d_[mu], Physics:-g_[mu, nu], Physics:-gamma_[a, b], Physics:-LeviCivita[alpha, beta, mu, nu], Physics:-SpaceTimeVector[mu](X)}

(10)

A[definition]

A[mu, `~a`] = (1-f__A(r))*Physics:-LeviCivita[4, a, j, mu]*R[j]/(g*r)

(11)

A[]

A[mu, a] = Matrix(%id = 36893489989479580364)

(12)

Define(F[mu, nu, a] = d_[nu](A[mu, a])-d_[mu](A[nu, a])+LeviCivita[a, b, c, 4]*A[mu, `~b`]*A[nu, `~c`])

{A[i, `~a`], Physics:-Dgamma[mu], F[mu, nu, a], Physics:-Psigma[mu], R[a], Physics:-d_[mu], Physics:-g_[mu, nu], Physics:-gamma_[a, b], Physics:-LeviCivita[alpha, beta, mu, nu], Physics:-SpaceTimeVector[mu](X)}

(13)

F[definition]

F[mu, nu, a] = -Physics:-d_[nu](A[a, mu], [X])+Physics:-d_[mu](A[a, nu], [X])-Physics:-LeviCivita[4, a, b, c]*A[mu, `~b`]*A[nu, `~c`]

(14)

simplify(F[])

F[mu, nu, a] = _rtable[36893489989585113204]

(15)

"-1/(4)Simplify(SumOverRepeatedIndices(F[mu,nu,a]*F[~mu,~nu,a])); "

-(1/4)*((2*(-1+f__A(r))*`z'`*r*g-(diff(f__A(r), r))*`z'`*r^2*g-(-1+f__A(r))^2*`z'`*`x'`)^2+4*(-1+f__A(r))^4*`y'`^2*`z'`^2+((diff(f__A(r), r))*`x'`*r^2*g+2*(1-f__A(r))*`x'`*r*g+(1-f__A(r))*(-1+f__A(r))*`z'`^2)^2+((diff(f__A(r), r))*`y'`*r^2*g+2*(1-f__A(r))*`y'`*r*g+(-1+f__A(r))^2*`y'`*`x'`)^2+(2*(-1+f__A(r))*`x'`*r*g-(diff(f__A(r), r))*`x'`*r^2*g-(-1+f__A(r))*(1-f__A(r))*`y'`^2)^2+(-2*(-1+f__A(r))*`z'`*r*g+(diff(f__A(r), r))*`z'`*r^2*g+(-1+f__A(r))^2*`z'`*`x'`)^2+(-(diff(f__A(r), r))*`x'`*r^2*g-2*(1-f__A(r))*`x'`*r*g-(1-f__A(r))*(-1+f__A(r))*`z'`^2)^2+2*(-1+f__A(r))^4*`x'`^4+2*(-1+f__A(r))^4*`y'`^2*`x'`^2+2*(-1+f__A(r))^4*`z'`^2*`x'`^2+(-(diff(f__A(r), r))*`y'`*r^2*g-2*(1-f__A(r))*`y'`*r*g-(-1+f__A(r))^2*`y'`*`x'`)^2+(-2*(-1+f__A(r))*`x'`*r*g+(diff(f__A(r), r))*`x'`*r^2*g+(-1+f__A(r))*(1-f__A(r))*`y'`^2)^2)/(r^8*g^4)

(16)

L__FST := simplify(-(1/4)*((2*(-1+f__A(r))*`z'`*r*g-(diff(f__A(r), r))*`z'`*r^2*g-(-1+f__A(r))^2*`z'`*`x'`)^2+4*(-1+f__A(r))^4*`y'`^2*`z'`^2+((diff(f__A(r), r))*`x'`*r^2*g+2*(1-f__A(r))*`x'`*r*g+(1-f__A(r))*(-1+f__A(r))*`z'`^2)^2+((diff(f__A(r), r))*`y'`*r^2*g+2*(1-f__A(r))*`y'`*r*g+(-1+f__A(r))^2*`y'`*`x'`)^2+(2*(-1+f__A(r))*`x'`*r*g-(diff(f__A(r), r))*`x'`*r^2*g-(-1+f__A(r))*(1-f__A(r))*`y'`^2)^2+(-2*(-1+f__A(r))*`z'`*r*g+(diff(f__A(r), r))*`z'`*r^2*g+(-1+f__A(r))^2*`z'`*`x'`)^2+(-(diff(f__A(r), r))*`x'`*r^2*g-2*(1-f__A(r))*`x'`*r*g-(1-f__A(r))*(-1+f__A(r))*`z'`^2)^2+2*(-1+f__A(r))^4*`x'`^4+2*(-1+f__A(r))^4*`y'`^2*`x'`^2+2*(-1+f__A(r))^4*`z'`^2*`x'`^2+(-(diff(f__A(r), r))*`y'`*r^2*g-2*(1-f__A(r))*`y'`*r*g-(-1+f__A(r))^2*`y'`*`x'`)^2+(-2*(-1+f__A(r))*`x'`*r*g+(diff(f__A(r), r))*`x'`*r^2*g+(-1+f__A(r))*(1-f__A(r))*`y'`^2)^2)/(r^8*g^4))

(-g^2*r^4*(`x'`^2+(1/2)*`y'`^2+(1/2)*`z'`^2)*(diff(f__A(r), r))^2+4*g^2*r^3*(`x'`^2+(1/2)*`y'`^2+(1/2)*`z'`^2)*(-1+f__A(r))*(diff(f__A(r), r))-4*((1/8)*(`x'`^2+`y'`^2+`z'`^2)^2*f__A(r)^2-(1/4)*(`x'`^2+`y'`^2+`z'`^2)^2*f__A(r)+(1/8)*`x'`^4+(g^2*r^2+(1/4)*`y'`^2+(1/4)*`z'`^2)*`x'`^2+(1/2)*(g^2*r^2+(1/4)*`y'`^2+(1/4)*`z'`^2)*(`y'`^2+`z'`^2))*(-1+f__A(r))^2)/(r^8*g^4)

(17)

 

Download SU(2)-field-strength-tensor_.mw

Hi

i use other code for equation too when i use allvalues(Root(...)) it is more near but question is this why not satisfy the ode equation this is my equation this parameter are find for this ODe why not satisfy otherwise my equestions must be wrong!

restart

with(PDEtools)

undeclare(prime)

`There is no more prime differentiation variable; all derivatives will be displayed as indexed functions`

(1)

with(DEtools)

``

with(LinearAlgebra)

with(sumtools)

eq0 := 2*beta*g[1]^3*r[0]^3+2*p^2*sigma*g[1]*r[0]^3 = 0

eq1 := 6*beta*g[1]^3*r[0]^2*r[1]+3*p^2*sigma*g[1]*r[0]^2*r[1]+6*beta*f[0]*g[1]^2*r[0]^2 = 0

eq2 := 6*beta*g[1]^3*r[0]^2*r[2]+6*beta*g[1]^3*r[0]*r[1]^2+2*p^2*sigma*g[1]*r[0]^2*r[2]+p^2*sigma*g[1]*r[0]*r[1]^2+12*beta*f[0]*g[1]^2*r[0]*r[1]+6*beta*f[1]*g[1]^2*r[0]^2+6*beta*f[0]^2*g[1]*r[0]-k^2*sigma*g[1]*r[0]-2*w*g[1]*r[0] = 0

eq3 := 12*beta*g[1]^3*r[0]*r[1]*r[2]+2*beta*g[1]^3*r[1]^3+2*p^2*sigma*g[1]*r[0]*r[1]*r[2]+12*beta*f[0]*g[1]^2*r[0]*r[2]+6*beta*f[0]*g[1]^2*r[1]^2+12*beta*f[1]*g[1]^2*r[0]*r[1]+p^2*sigma*f[1]*r[0]*r[1]+6*beta*f[0]^2*g[1]*r[1]+12*beta*f[0]*f[1]*g[1]*r[0]-k^2*sigma*g[1]*r[1]+2*beta*f[0]^3-k^2*sigma*f[0]-2*w*g[1]*r[1]-2*w*f[0] = 0

eq4 := 6*beta*g[1]^3*r[0]*r[2]^2+6*beta*g[1]^3*r[1]^2*r[2]+2*p^2*sigma*g[1]*r[0]*r[2]^2+p^2*sigma*g[1]*r[1]^2*r[2]+12*beta*f[0]*g[1]^2*r[1]*r[2]+12*beta*f[1]*g[1]^2*r[0]*r[2]+6*beta*f[1]*g[1]^2*r[1]^2+2*p^2*sigma*f[1]*r[0]*r[2]+p^2*sigma*f[1]*r[1]^2+6*beta*f[0]^2*g[1]*r[2]+12*beta*f[0]*f[1]*g[1]*r[1]+6*beta*f[1]^2*g[1]*r[0]-k^2*sigma*g[1]*r[2]+6*beta*f[0]^2*f[1]-k^2*sigma*f[1]-2*w*g[1]*r[2]-2*w*f[1] = 0

eq5 := 6*beta*g[1]^3*r[1]*r[2]^2+3*p^2*sigma*g[1]*r[1]*r[2]^2+6*beta*f[0]*g[1]^2*r[2]^2+12*beta*f[1]*g[1]^2*r[1]*r[2]+3*p^2*sigma*f[1]*r[1]*r[2]+12*beta*f[0]*f[1]*g[1]*r[2]+6*beta*f[1]^2*g[1]*r[1]+6*beta*f[0]*f[1]^2 = 0

eq6 := 2*beta*g[1]^3*r[2]^3+2*p^2*sigma*g[1]*r[2]^3+6*beta*f[1]*g[1]^2*r[2]^2+2*p^2*sigma*f[1]*r[2]^2+6*beta*f[1]^2*g[1]*r[2]+2*beta*f[1]^3 = 0

NULL

NULL

COEFFS := solve({eq0, eq1, eq2, eq3, eq4, eq5, eq6}, {p, f[0], f[1], g[1]}, explicit)

NULL

ode := 2*beta*U(xi)^3+(-k^2*sigma-2*w)*U(xi)+(diff(diff(U(xi), xi), xi))*p^2*sigma = 0

2*beta*U(xi)^3+(-k^2*sigma-2*w)*U(xi)+(diff(diff(U(xi), xi), xi))*p^2*sigma = 0

(2)

P := f[0]+sum(f[i]*R(xi)^i, i = 1 .. 1)+sum(g[i]*((diff(R(xi), xi))/R(xi))^i, i = 1 .. 1)

f[0]+f[1]*R(xi)+g[1]*(diff(R(xi), xi))/R(xi)

(3)

case1 := {p = -sqrt(2)*sqrt(sigma*(4*r[0]*r[2]-r[1]^2)*(k^2*sigma+2*w))/(sigma*(4*r[0]*r[2]-r[1]^2)), f[0] = -(k^2*sigma+2*w)*r[1]/sqrt(-2*beta*(4*r[0]*r[2]-r[1]^2)*(k^2*sigma+2*w)), f[1] = -(2*(k^2*sigma+2*w))*r[2]/sqrt(-2*beta*(4*r[0]*r[2]-r[1]^2)*(k^2*sigma+2*w)), g[1] = -sqrt(-2*beta*(4*r[0]*r[2]-r[1]^2)*(k^2*sigma+2*w))/(beta*(4*r[0]*r[2]-r[1]^2))}

{p = -2^(1/2)*(sigma*(4*r[0]*r[2]-r[1]^2)*(k^2*sigma+2*w))^(1/2)/(sigma*(4*r[0]*r[2]-r[1]^2)), f[0] = -(k^2*sigma+2*w)*r[1]/(-2*beta*(4*r[0]*r[2]-r[1]^2)*(k^2*sigma+2*w))^(1/2), f[1] = -2*(k^2*sigma+2*w)*r[2]/(-2*beta*(4*r[0]*r[2]-r[1]^2)*(k^2*sigma+2*w))^(1/2), g[1] = -(-2*beta*(4*r[0]*r[2]-r[1]^2)*(k^2*sigma+2*w))^(1/2)/(beta*(4*r[0]*r[2]-r[1]^2))}

(4)

NULL

``

(5)

K := diff(R(xi), xi) = r[0]+r[1]*R(xi)+r[2]*R(xi)^2

diff(R(xi), xi) = r[0]+r[1]*R(xi)+r[2]*R(xi)^2

(6)

S1 := subs(K, P)

f[0]+f[1]*R(xi)+g[1]*(r[0]+r[1]*R(xi)+r[2]*R(xi)^2)/R(xi)

(7)

NULL

C1 := subs(case1, S1)

-(k^2*sigma+2*w)*r[1]/(-2*beta*(4*r[0]*r[2]-r[1]^2)*(k^2*sigma+2*w))^(1/2)-2*(k^2*sigma+2*w)*r[2]*R(xi)/(-2*beta*(4*r[0]*r[2]-r[1]^2)*(k^2*sigma+2*w))^(1/2)-(-2*beta*(4*r[0]*r[2]-r[1]^2)*(k^2*sigma+2*w))^(1/2)*(r[0]+r[1]*R(xi)+r[2]*R(xi)^2)/(beta*(4*r[0]*r[2]-r[1]^2)*R(xi))

(8)

f := U(xi) = C1

U(xi) = -(k^2*sigma+2*w)*r[1]/(-2*beta*(4*r[0]*r[2]-r[1]^2)*(k^2*sigma+2*w))^(1/2)-2*(k^2*sigma+2*w)*r[2]*R(xi)/(-2*beta*(4*r[0]*r[2]-r[1]^2)*(k^2*sigma+2*w))^(1/2)-(-2*beta*(4*r[0]*r[2]-r[1]^2)*(k^2*sigma+2*w))^(1/2)*(r[0]+r[1]*R(xi)+r[2]*R(xi)^2)/(beta*(4*r[0]*r[2]-r[1]^2)*R(xi))

(9)

NULL

SO := subs(case1, ode)

2*beta*U(xi)^3+(-k^2*sigma-2*w)*U(xi)+2*(diff(diff(U(xi), xi), xi))*(k^2*sigma+2*w)/(4*r[0]*r[2]-r[1]^2) = 0

(10)

NULL

odetest(f, SO)


same_equation_different_parameter.mw

display([plottools[arc]([op(coordinates(Omega))], r, t .. t + Pi/2, color = red, t4), plottools[arc]([op(coordinates(Omega))], r, t + Pi .. t + (3*Pi)/2, color = coral, t4), plottools[arc]([op(coordinates(Omega))], r, t - Pi/2 .. t, color = cyan, t4), plottools[arc]([op(coordinates(Omega))], r, t + Pi/2 .. t + Pi, color = green, t4)],
draw([Cir(color = blue, t4), cir(color = grey, t4), sT(color = black, t4), XXp(color = black, l3), YYp(color = black, l3), L1(color = black, l3), L2(color = black, l3), N1(color = blue, symbol = solidcircle, symbolsize = 15), N2(color = blue, symbol = solidcircle, symbolsize = 15), N3(color = blue, symbol = solidcircle, symbolsize = 15), M1(color = blue, symbol = solidcircle, symbolsize = 15)]), axes = none, view = [-30 .. 10, -10 .. 10], size = [800, 800])::
plots:-animate(Proc, [t], t = 0 .. 2*Pi, frames = 30).;

why the instruction concerning the arcs is not resected ? Thank you.

I liked the recent question from user goebeld and especially the answer from Rouben Rostamian.
I admit, I didn’t even realize that Maple had VariationalCalculus procedures.
But what if the red and green  points are on the surface x1^4 + x2^4 + x3^4 -1 = 0
Points coordinates (-0.759835685700000, -0.759835685700000, 0.759835685700000) and
 (0.759835685700000, 0.759835685700000, -0.759835685700000).

Where will the shortest distance between these points on a given surface be? Taking into account symmetry, of course.

I have a thirder order ODE with non polynomial coefficients and I naively thought to try dsolve for fun to see what happens and Maple returned DESol with a second order differential equation and an arbitrary coefficient. I know Maple outputs DESol when it cannot find a solution similar to RootOf but the arbitrary constant is what is throwing me off. 

I am unsure how to interpret this, if a particular solution is found I could reduce the order and see how I could get with the second order ODE but maple doesn't produce a particular solution when I run that command. 

DESol_Question.mw

What is the problem with the integral below when I use a variable n?

with(Units:-Simple)

V__1 := Unit('m'^3) = Units:-Unit(m^3)NULL

V__2 := 2*Unit('m'^3) = 2*Units:-Unit(m^3)NULL

int(1/V, V = V__1 .. V__2)

ln(2)

(1)

`assuming`([int(n/V, V = n*Unit('m'^3) .. m*Unit('m'^3))], [n > 0, m > 0])

-ln(n)*n+ln(m)*n

(2)

NULL

Download Units_Int.mw

First 88 89 90 91 92 93 94 Last Page 90 of 2427