MaplePrimes Questions

this function i have is so long and my parameter are twenty they are two much when i make a change in explore i the change is so slow and i can't see some of this parameter how act to figure when i change becuase the placement of parameters i want some of parameter being in right  and some of them being in right  and figure be in the middle for see them together can we do something like that?

figure.mw

How do we simplify the arguments of the exponential in (1)? Further how to express (1) into hyperbolic/trig functions? 
 

restart

with(LinearAlgebra)

Bans := -8*delta2*delta4*delta1*(delta3^2+delta4^2)*exp((-(2*I)*y*a*(delta3^2+delta4^2)*delta1^3+((2*I)*y*delta3^3*a+(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+((2*I)*y*delta4^2*a-I*t)*delta3+delta4^2*(x+y+t)^2*(B2+B1+B3+B4))*delta1^2-(2*I)*(y*delta2^2*a-(1/2)*t)*(delta3^2+delta4^2)*delta1+(2*(I*y*delta3^3*a+(1/2)*(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+(-I*t*(1/2)+I*y*delta4^2*a)*delta3+(1/2)*delta4^2*(x+y+t)^2*(B2+B1+B3+B4)))*delta2^2)/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1)))-8*delta2*delta3*delta4*(delta1^2+delta2^2)*exp(((2*I)*y*a*(delta3^2+delta4^2)*delta1^3+(-(2*I)*y*delta3^3*a+(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+(-(2*I)*y*delta4^2*a+I*t)*delta3+delta4^2*(x+y+t)^2*(B2+B1+B3+B4))*delta1^2+(2*I)*(y*delta2^2*a-(1/2)*t)*(delta3^2+delta4^2)*delta1-(2*(I*y*delta3^3*a-(1/2)*(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+(-I*t*(1/2)+I*y*delta4^2*a)*delta3-(1/2)*delta4^2*(x+y+t)^2*(B2+B1+B3+B4)))*delta2^2)/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1)))+(delta2^2-2*delta4*delta2+delta4^2+(delta3-delta1)^2)*((delta3+I*delta4)*delta2^2+(I*delta3^2+I*delta4^2)*delta2+delta1*(delta4^2+I*delta4*delta1+delta3*(delta3+delta1)))*exp((-2*y*a*(delta3^2+delta4^2)*delta2^3+(-2*y*delta4^3*a+2*(x+y+t)^2*(B1+B3)*delta4^2+(-2*a*delta3^2*y-t)*delta4+2*delta3^2*(x+y+t)^2*(B1+B3))*delta2^2-(2*(delta3^2+delta4^2))*(y*a*delta1^2+(1/2)*t)*delta2+2*delta1^2*(-y*delta4^3*a+(x+y+t)^2*(B1+B3)*delta4^2+(-(1/2)*t-y*a*delta3^2)*delta4+delta3^2*(x+y+t)^2*(B1+B3)))/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1)))+(delta2^2+2*delta4*delta2+delta4^2+(delta3-delta1)^2)*((delta3+I*delta4)*delta2^2+(-I*delta3^2-I*delta4^2)*delta2+delta1*(delta4^2+I*delta4*delta1+delta3*(delta3+delta1)))*exp((2*y*a*(delta3^2+delta4^2)*delta2^3+(-2*y*delta4^3*a+2*(x+y+t)^2*(B2+B3)*delta4^2+(-2*a*delta3^2*y-t)*delta4+2*delta3^2*(x+y+t)^2*(B2+B3))*delta2^2+(2*(delta3^2+delta4^2))*(y*a*delta1^2+(1/2)*t)*delta2+2*delta1^2*(-y*delta4^3*a+(x+y+t)^2*(B2+B3)*delta4^2+(-(1/2)*t-y*a*delta3^2)*delta4+delta3^2*(x+y+t)^2*(B2+B3)))/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1)))-(delta2^2+2*delta4*delta2+delta4^2+(delta3-delta1)^2)*((I*delta4-delta3)*delta2^2+(-I*delta3^2-I*delta4^2)*delta2+delta1*(-delta4^2+I*delta4*delta1-delta3*(delta3+delta1)))*exp((-2*y*a*(delta3^2+delta4^2)*delta2^3+(2*y*delta4^3*a+2*(x+y+t)^2*(B1+B4)*delta4^2+(2*a*delta3^2*y+t)*delta4+2*delta3^2*(x+y+t)^2*(B1+B4))*delta2^2-(2*(delta3^2+delta4^2))*(y*a*delta1^2+(1/2)*t)*delta2+(2*(y*delta4^3*a+(x+y+t)^2*(B1+B4)*delta4^2+(y*a*delta3^2+(1/2)*t)*delta4+delta3^2*(x+y+t)^2*(B1+B4)))*delta1^2)/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1)))-(delta2^2-2*delta4*delta2+delta4^2+(delta3-delta1)^2)*((I*delta4-delta3)*delta2^2+(I*delta3^2+I*delta4^2)*delta2+delta1*(-delta4^2+I*delta4*delta1-delta3*(delta3+delta1)))*exp((2*y*a*(delta3^2+delta4^2)*delta2^3+(2*y*delta4^3*a+2*(x+y+t)^2*(B2+B4)*delta4^2+(2*a*delta3^2*y+t)*delta4+2*delta3^2*(x+y+t)^2*(B2+B4))*delta2^2+(2*(delta3^2+delta4^2))*(y*a*delta1^2+(1/2)*t)*delta2+(2*(y*delta4^3*a+(x+y+t)^2*(B2+B4)*delta4^2+(y*a*delta3^2+(1/2)*t)*delta4+delta3^2*(x+y+t)^2*(B2+B4)))*delta1^2)/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1)))

-8*delta2*delta4*delta1*(delta3^2+delta4^2)*exp((-(2*I)*y*a*(delta3^2+delta4^2)*delta1^3+((2*I)*y*delta3^3*a+(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+((2*I)*y*delta4^2*a-I*t)*delta3+delta4^2*(x+y+t)^2*(B2+B1+B3+B4))*delta1^2-(2*I)*(y*delta2^2*a-(1/2)*t)*(delta3^2+delta4^2)*delta1+2*(I*y*delta3^3*a+(1/2)*(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+(-((1/2)*I)*t+I*y*delta4^2*a)*delta3+(1/2)*delta4^2*(x+y+t)^2*(B2+B1+B3+B4))*delta2^2)/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1)))-8*delta2*delta3*delta4*(delta1^2+delta2^2)*exp(((2*I)*y*a*(delta3^2+delta4^2)*delta1^3+(-(2*I)*y*delta3^3*a+(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+(-(2*I)*y*delta4^2*a+I*t)*delta3+delta4^2*(x+y+t)^2*(B2+B1+B3+B4))*delta1^2+(2*I)*(y*delta2^2*a-(1/2)*t)*(delta3^2+delta4^2)*delta1-2*(I*y*delta3^3*a-(1/2)*(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+(-((1/2)*I)*t+I*y*delta4^2*a)*delta3-(1/2)*delta4^2*(x+y+t)^2*(B2+B1+B3+B4))*delta2^2)/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1)))+(delta2^2-2*delta4*delta2+delta4^2+(delta3-delta1)^2)*((delta3+I*delta4)*delta2^2+(I*delta3^2+I*delta4^2)*delta2+delta1*(delta4^2+I*delta4*delta1+delta3*(delta3+delta1)))*exp((-2*y*a*(delta3^2+delta4^2)*delta2^3+(-2*y*delta4^3*a+2*(x+y+t)^2*(B1+B3)*delta4^2+(-2*a*delta3^2*y-t)*delta4+2*delta3^2*(x+y+t)^2*(B1+B3))*delta2^2-2*(delta3^2+delta4^2)*(y*a*delta1^2+(1/2)*t)*delta2+2*delta1^2*(-y*delta4^3*a+(x+y+t)^2*(B1+B3)*delta4^2+(-(1/2)*t-y*a*delta3^2)*delta4+delta3^2*(x+y+t)^2*(B1+B3)))/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1)))+(delta2^2+2*delta4*delta2+delta4^2+(delta3-delta1)^2)*((delta3+I*delta4)*delta2^2+(-I*delta3^2-I*delta4^2)*delta2+delta1*(delta4^2+I*delta4*delta1+delta3*(delta3+delta1)))*exp((2*y*a*(delta3^2+delta4^2)*delta2^3+(-2*y*delta4^3*a+2*(x+y+t)^2*(B2+B3)*delta4^2+(-2*a*delta3^2*y-t)*delta4+2*delta3^2*(x+y+t)^2*(B2+B3))*delta2^2+2*(delta3^2+delta4^2)*(y*a*delta1^2+(1/2)*t)*delta2+2*delta1^2*(-y*delta4^3*a+(x+y+t)^2*(B2+B3)*delta4^2+(-(1/2)*t-y*a*delta3^2)*delta4+delta3^2*(x+y+t)^2*(B2+B3)))/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1)))-(delta2^2+2*delta4*delta2+delta4^2+(delta3-delta1)^2)*((I*delta4-delta3)*delta2^2+(-I*delta3^2-I*delta4^2)*delta2+delta1*(-delta4^2+I*delta4*delta1-delta3*(delta3+delta1)))*exp((-2*y*a*(delta3^2+delta4^2)*delta2^3+(2*y*delta4^3*a+2*(x+y+t)^2*(B1+B4)*delta4^2+(2*a*delta3^2*y+t)*delta4+2*delta3^2*(x+y+t)^2*(B1+B4))*delta2^2-2*(delta3^2+delta4^2)*(y*a*delta1^2+(1/2)*t)*delta2+2*(y*delta4^3*a+(x+y+t)^2*(B1+B4)*delta4^2+(y*a*delta3^2+(1/2)*t)*delta4+delta3^2*(x+y+t)^2*(B1+B4))*delta1^2)/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1)))-(delta2^2-2*delta4*delta2+delta4^2+(delta3-delta1)^2)*((I*delta4-delta3)*delta2^2+(I*delta3^2+I*delta4^2)*delta2+delta1*(-delta4^2+I*delta4*delta1-delta3*(delta3+delta1)))*exp((2*y*a*(delta3^2+delta4^2)*delta2^3+(2*y*delta4^3*a+2*(x+y+t)^2*(B2+B4)*delta4^2+(2*a*delta3^2*y+t)*delta4+2*delta3^2*(x+y+t)^2*(B2+B4))*delta2^2+2*(delta3^2+delta4^2)*(y*a*delta1^2+(1/2)*t)*delta2+2*(y*delta4^3*a+(x+y+t)^2*(B2+B4)*delta4^2+(y*a*delta3^2+(1/2)*t)*delta4+delta3^2*(x+y+t)^2*(B2+B4))*delta1^2)/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1)))

(1)

argexp1 := simplify((-(2*I)*y*a*(delta3^2+delta4^2)*delta1^3+((2*I)*y*delta3^3*a+(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+((2*I)*y*delta4^2*a-I*t)*delta3+delta4^2*(x+y+t)^2*(B2+B1+B3+B4))*delta1^2-(2*I)*(y*delta2^2*a-(1/2)*t)*(delta3^2+delta4^2)*delta1+(2*(I*y*delta3^3*a+(1/2)*(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+(-I*t*(1/2)+I*y*delta4^2*a)*delta3+(1/2)*delta4^2*(x+y+t)^2*(B2+B1+B3+B4)))*delta2^2)/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1)), size)

(-(2*I)*y*a*(delta3^2+delta4^2)*delta1^3+((2*I)*y*delta3^3*a+(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+((2*I)*y*delta4^2*a-I*t)*delta3+delta4^2*(x+y+t)^2*(B2+B1+B3+B4))*delta1^2-(2*I)*(y*delta2^2*a-(1/2)*t)*(delta3^2+delta4^2)*delta1+2*(y*delta3^3*a*I+(1/2)*(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+(-((1/2)*I)*t+y*delta4^2*a*I)*delta3+(1/2)*delta4^2*(x+y+t)^2*(B2+B1+B3+B4))*delta2^2)/((delta1+delta2*I)*(delta4*I-delta3)*(delta3+delta4*I)*(delta2*I-delta1))

(2)

 

argexp2 := ((2*I)*y*a*(delta3^2+delta4^2)*delta1^3+(-(2*I)*y*delta3^3*a+(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+(-(2*I)*y*delta4^2*a+I*t)*delta3+delta4^2*(x+y+t)^2*(B2+B1+B3+B4))*delta1^2+(2*I)*(y*delta2^2*a-(1/2)*t)*(delta3^2+delta4^2)*delta1-(2*(I*y*delta3^3*a-(1/2)*(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+(-I*t*(1/2)+I*y*delta4^2*a)*delta3-(1/2)*delta4^2*(x+y+t)^2*(B2+B1+B3+B4)))*delta2^2)/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1))

((2*I)*y*a*(delta3^2+delta4^2)*delta1^3+(-(2*I)*y*delta3^3*a+(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+(-(2*I)*y*delta4^2*a+t*I)*delta3+delta4^2*(x+y+t)^2*(B2+B1+B3+B4))*delta1^2+(2*I)*(y*delta2^2*a-(1/2)*t)*(delta3^2+delta4^2)*delta1-2*(y*delta3^3*a*I-(1/2)*(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+(-((1/2)*I)*t+y*delta4^2*a*I)*delta3-(1/2)*delta4^2*(x+y+t)^2*(B2+B1+B3+B4))*delta2^2)/((delta1+delta2*I)*(delta4*I-delta3)*(delta3+delta4*I)*(delta2*I-delta1))

(3)

simplify(argexp1+argexp2)

2*(x+y+t)^2*(B2+B1+B3+B4)

(4)

terms := op(Bans)

-8*delta2*delta4*delta1*(delta3^2+delta4^2)*exp((-(2*I)*y*a*(delta3^2+delta4^2)*delta1^3+((2*I)*y*delta3^3*a+(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+((2*I)*y*delta4^2*a-I*t)*delta3+delta4^2*(x+y+t)^2*(B2+B1+B3+B4))*delta1^2-(2*I)*(y*delta2^2*a-(1/2)*t)*(delta3^2+delta4^2)*delta1+2*(I*y*delta3^3*a+(1/2)*(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+(-((1/2)*I)*t+I*y*delta4^2*a)*delta3+(1/2)*delta4^2*(x+y+t)^2*(B2+B1+B3+B4))*delta2^2)/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1))), -8*delta2*delta3*delta4*(delta1^2+delta2^2)*exp(((2*I)*y*a*(delta3^2+delta4^2)*delta1^3+(-(2*I)*y*delta3^3*a+(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+(-(2*I)*y*delta4^2*a+I*t)*delta3+delta4^2*(x+y+t)^2*(B2+B1+B3+B4))*delta1^2+(2*I)*(y*delta2^2*a-(1/2)*t)*(delta3^2+delta4^2)*delta1-2*(I*y*delta3^3*a-(1/2)*(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+(-((1/2)*I)*t+I*y*delta4^2*a)*delta3-(1/2)*delta4^2*(x+y+t)^2*(B2+B1+B3+B4))*delta2^2)/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1))), (delta2^2-2*delta4*delta2+delta4^2+(delta3-delta1)^2)*((delta3+I*delta4)*delta2^2+(I*delta3^2+I*delta4^2)*delta2+delta1*(delta4^2+I*delta4*delta1+delta3*(delta3+delta1)))*exp((-2*y*a*(delta3^2+delta4^2)*delta2^3+(-2*y*delta4^3*a+2*(x+y+t)^2*(B1+B3)*delta4^2+(-2*a*delta3^2*y-t)*delta4+2*delta3^2*(x+y+t)^2*(B1+B3))*delta2^2-2*(delta3^2+delta4^2)*(y*a*delta1^2+(1/2)*t)*delta2+2*delta1^2*(-y*delta4^3*a+(x+y+t)^2*(B1+B3)*delta4^2+(-(1/2)*t-y*a*delta3^2)*delta4+delta3^2*(x+y+t)^2*(B1+B3)))/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1))), (delta2^2+2*delta4*delta2+delta4^2+(delta3-delta1)^2)*((delta3+I*delta4)*delta2^2+(-I*delta3^2-I*delta4^2)*delta2+delta1*(delta4^2+I*delta4*delta1+delta3*(delta3+delta1)))*exp((2*y*a*(delta3^2+delta4^2)*delta2^3+(-2*y*delta4^3*a+2*(x+y+t)^2*(B2+B3)*delta4^2+(-2*a*delta3^2*y-t)*delta4+2*delta3^2*(x+y+t)^2*(B2+B3))*delta2^2+2*(delta3^2+delta4^2)*(y*a*delta1^2+(1/2)*t)*delta2+2*delta1^2*(-y*delta4^3*a+(x+y+t)^2*(B2+B3)*delta4^2+(-(1/2)*t-y*a*delta3^2)*delta4+delta3^2*(x+y+t)^2*(B2+B3)))/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1))), -(delta2^2+2*delta4*delta2+delta4^2+(delta3-delta1)^2)*((I*delta4-delta3)*delta2^2+(-I*delta3^2-I*delta4^2)*delta2+delta1*(-delta4^2+I*delta4*delta1-delta3*(delta3+delta1)))*exp((-2*y*a*(delta3^2+delta4^2)*delta2^3+(2*y*delta4^3*a+2*(x+y+t)^2*(B1+B4)*delta4^2+(2*a*delta3^2*y+t)*delta4+2*delta3^2*(x+y+t)^2*(B1+B4))*delta2^2-2*(delta3^2+delta4^2)*(y*a*delta1^2+(1/2)*t)*delta2+2*(y*delta4^3*a+(x+y+t)^2*(B1+B4)*delta4^2+(y*a*delta3^2+(1/2)*t)*delta4+delta3^2*(x+y+t)^2*(B1+B4))*delta1^2)/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1))), -(delta2^2-2*delta4*delta2+delta4^2+(delta3-delta1)^2)*((I*delta4-delta3)*delta2^2+(I*delta3^2+I*delta4^2)*delta2+delta1*(-delta4^2+I*delta4*delta1-delta3*(delta3+delta1)))*exp((2*y*a*(delta3^2+delta4^2)*delta2^3+(2*y*delta4^3*a+2*(x+y+t)^2*(B2+B4)*delta4^2+(2*a*delta3^2*y+t)*delta4+2*delta3^2*(x+y+t)^2*(B2+B4))*delta2^2+2*(delta3^2+delta4^2)*(y*a*delta1^2+(1/2)*t)*delta2+2*(y*delta4^3*a+(x+y+t)^2*(B2+B4)*delta4^2+(y*a*delta3^2+(1/2)*t)*delta4+delta3^2*(x+y+t)^2*(B2+B4))*delta1^2)/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1)))

(5)

NULL


 

Download argument.mw

Hi everyone,

I'm trying to compute the cohomology group of some Lie algebras using the LieAlgebra package, but it appears that the Cohomology command doesn't provide the correct basis for the higher dimensional cohomology group, instead repeating up to the correct dimension only one element.

For example, with the following Lie algebra

L1:=_DG([["LieAlgebra", Alg1, [6]], [[[1, 3, 2], 1], [[1, 2, 3], -1], [[4, 6, 5], 1], [[4, 5, 6], -1]]])
DGSetup(L1)

the command

C := RelativeChains([])

does provide the correct k-forms on Alg1, but then

H := Cohomology(C)
provides
[[theta4,theta1],[theta1 &w theta4, theta1 &w theta4, theta1 &w theta4],[theta1 &w theta2 &w theta3,theta1 &w theta2 &w theta3,theta1 &w theta2 &w theta3,theta1 &w theta2 &w theta3], [theta1 &w theta2 &w theta3 &w theta4,theta1 &w theta2 &w theta3 &w theta4,theta1 &w theta2 &w theta3 &w theta4],[theta1 &w theta2 &w theta3 &w theta4 &w theta5 &w theta6, theta1 &w theta2 &w theta3 &w theta4 &w theta5 &w theta6], [theta1 &w theta2 &w theta3 &w theta4 &w theta5 &w theta6]

A similar thing does happen for the examples provided in the online help (e.g. example 1 from https://de.maplesoft.com/support/help/Maple/view.aspx?path=DifferentialGeometry/LieAlgebras/Cohomology). Is the command broken?

Any help is really appreciated.

when i use change maple to latex most of that equation when i want to change the place of term are change how i can fix that for example in (R) if watch in exponential the x is first term but after changing to latex are change which i have to change by hand how i can fix this issue?

restart

with(PDEtools)

with(LinearAlgebra)

NULL

with(SolveTools)

_local(gamma)

Warning, A new binding for the name `gamma` has been created. The global instance of this name is still accessible using the :- prefix, :-`gamma`.  See ?protect for details.

 

undeclare(prime)

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

(1)

NULL

declare(u(x, y, z, t))

u(x, y, z, t)*`will now be displayed as`*u

(2)

declare(f(x, y, z, t))

f(x, y, z, t)*`will now be displayed as`*f

(3)

NULL

W := Lambda = k[i]*(t*w[i]+y*l[i]+z*r[i]+x)+eta[i]

Lambda = k[i]*(t*w[i]+y*l[i]+z*r[i]+x)+eta[i]

(4)

latex(W)

\Lambda = k_{i} \left(w_{i} t +y l_{i}+r_{i} z +x \right)+\eta_{i}

 

Lambda[1] := k[i]*(t*w[i]+y*l[i]+z*r[i]+x)+eta[i]

k[i]*(t*w[i]+y*l[i]+z*r[i]+x)+eta[i]

(5)

Q := f = 1+exp(Lambda[1])

f = 1+exp(k[i]*(t*w[i]+y*l[i]+z*r[i]+x)+eta[i])

(6)

Q1 := subs(W, Q)

f = 1+exp(k[i]*(t*w[i]+y*l[i]+z*r[i]+x)+eta[i])

(7)

latex(Q1)

f =
1+{\mathrm e}^{k_{i} \left(w_{i} t +y l_{i}+r_{i} z +x \right)+\eta_{i}}

 

eq15 := w[i] = (-1+sqrt(-4*beta*mu*l[i]-4*delta*mu*r[i]-4*mu*k[i]^2-4*alpha*mu+1))/(2*mu)

w[i] = (1/2)*(-1+(-4*beta*mu*l[i]-4*delta*mu*r[i]-4*mu*k[i]^2-4*alpha*mu+1)^(1/2))/mu

(8)

latex(eq15)

w_{i} =
\frac{-1+\sqrt{-4 \beta  \mu  l_{i}-4 \delta  \mu  r_{i}-4 \mu  k_{i}^{2}-4 \alpha  \mu +1}}{2 \mu}

 

R := f(x, y, z, t) = 1+exp(k[i]*(x+l[i]*y+r[i]*z+(-1+sqrt(-4*beta*mu*l[i]-4*delta*mu*r[i]-4*mu*k[i]^2-4*alpha*mu+1))*t/(2*mu))+eta[i])

f(x, y, z, t) = 1+exp(k[i]*((1/2)*(-1+(-4*beta*mu*l[i]-4*delta*mu*r[i]-4*mu*k[i]^2-4*alpha*mu+1)^(1/2))*t/mu+y*l[i]+r[i]*z+x)+eta[i])

(9)

latex(R)

f =
1+{\mathrm e}^{k_{i} \left(\frac{\left(-1+\sqrt{-4 \beta  \mu  l_{i}-4 \delta  \mu  r_{i}-4 \mu  k_{i}^{2}-4 \alpha  \mu +1}\right) t}{2 \mu}+y l_{i}+r_{i} z +x \right)+\eta_{i}}

 
 

NULL

Download latex.mw

For the following task I only get the numerical solution 2.356... :
sum(n=1 to oo)[arctan(2/n^2)]
The known "closed" result is 3*pi/4.

Dear team,

Here below you can see a simple program containing 3 loops. The problem is  that even for low iterations the execution time seems endless. I kept this program running for over 10 minutes to no avail.   Could you help me? 

Here you are the technical details of my HP laptopper

 

Hi everyone,

I am trying to visualize the integral of x3 over the interval x=−1 to x=1. I tried using:

with(plots):
display(
   plot(x^3, x = -1 .. 1, color = black, thickness = 2),
   shadebetween(x^3, 0, x = -1 .. 1, color = cyan)
);

This works, but I wondered if there’s a better or more elegant way to visualize definite integrals. For example:

  • Can I add transparency to the shaded region?
  • Is there a built-in function that directly plots definite integrals with shading?
  • Any tips for improving the aesthetics of such plots?

Thanks in advance for any help!

Download εμβαδόν_χωρίου.mw

Windows 10. From normal command line window:

"C:\Program Files\Maple 2024\bin.X86_64_WINDOWS\mint.exe" foo.mpl

Gives this

The file foo.mpl is

export module ODE() 
    option object; 
    export ode::`=`;
end module;

Notice the funny looking characters in the output.

Why does it happen?

restart

with(PDEtools)

undeclare(prime, quiet); declare(u(x, y, z, t), quiet); declare(f(x, y, z, t), quiet)

``

(1)

thetai := k[i]*(t*w[i]+y*l[i]+z*r[i]+x)

eqw := w[i] = (-1+sqrt(-4*beta*mu*l[i]-4*delta*mu*r[i]-4*mu*k[i]^2-4*alpha*mu+1))/(2*mu)

Bij := proc (i, j) options operator, arrow; -24*mu/(sqrt(1+(-4*beta*l[j]-4*delta*r[j]-4*alpha)*mu)*sqrt(1+(-4*beta*l[i]-4*delta*r[i]-4*alpha)*mu)-1+((2*r[i]+2*r[j])*delta+(2*l[i]+2*l[j])*beta+4*alpha)*mu) end proc

NULL

theta1 := normal(eval(eval(thetai, eqw), i = 1)); theta2 := normal(eval(eval(thetai, eqw), i = 2))

eqf := f(x, y, z, t) = theta1*theta2+Bij(1, 2)

eqfcomplex := collect(evalc(eval(eval(eqf, l[2] = conjugate(l[1])), l[1] = a+I*b)), t)

eq17 := u(x, y, z, t) = 2*(diff(diff(f(x, y, z, t), x), x))/f(x, y, z, t)-2*(diff(f(x, y, z, t), x))^2/f(x, y, z, t)^2; equ := simplify(eval(eq17, eqfcomplex))

So we want to find a substitution that removes the time dependence from u. One way is to find the maximum and see how it moves. Here, the first solution gives what we want.

ans := solve({diff(rhs(equ), x), diff(rhs(equ), y), diff(rhs(equ), z)}, {x, y, z}, explicit)

 

NULL

Download hfz.mw

Hi! An basic and interesting issue.

First, why I run worksheet again and again, I will get different output (even seems understandable)? I guess maybe the memory is not renewed?

Second, how to obtain the periodic solution without adding ```k*Pi``` manually?

`assuming`([solve(sqrt(2)*sin(2*x-(1/6)*Pi) = 1)], [`in`(x, real)])

5/24

(1)

x := solve(sqrt(2)*sin(2*x-(1/6)*Pi) = 1)+k*Pi

5/24+k*Pi

(2)
 

NULL

Download periodic_solution_of_a_simply_Sine_function.mw

i need the result for (eqt33) but i can reach the result there is any  other way for finding? i need to plot 3D of that function but without have the function how i can do explore on it

w1.mw

Is this a bug in mint?

Given this foo.mpl

foo:=proc()
    local x:=2,y:=3;       
        
    if MmaTranslator[Mma][LeafCount](x)<MmaTranslator[Mma][LeafCount](y)  then        
        0;
    else
       1;
    fi;  

end proc;   

It says

Procedure foo() on lines 2 to 11
  These names were used as global names but were not declared:  LeafCount, Mma

But if I rewrite the above using :- instead:

foo:=proc()
    local x:=2,y:=3;       
        
    if MmaTranslator:-Mma:-LeafCount(x)<MmaTranslator:-Mma:-LeafCount(y)  then        
        0;
    else
       1;
    fi;  

end proc;  

Now mint is happy and no message are given.

Is not  MmaTranslator:-Mma:-LeafCount(x)  the same as MmaTranslator[Mma][LeafCount](x) ?

Maple itself is happy with both. So why is mint complaining?

I am finding many problems with mint. Will post more problems found when I have more time.

Is mint still actively  maintained by Maplesoft? 

Hi Guys,

I encountered this rather unexpected behavior of Maple 18 when using the "read" function as shown below, where Maple fails to reduce the answer to 0, especially for (5). I'm curious if there's any deeper reason for this, and if there's a better or more standard solution than mine, that is, to use "parse( convert( expr, string ) )" as in (6)?

Thanks a lot!

``

restart;

 

assume(x>0);

 

f := x^2;

x^2

(1)

 

save f, "read_test.m";

 

restart;

 

f;

f

(2)

 

read "read_test.m";

 

f;

x^2

(3)

 

f - x^2;

-x^2+x^2

(4)

 

assume(x>0);

 

f - x^2;

x^2-x^2

(5)

 

f1 := parse( convert( f, string ) );

x^2

(6)

 

f1;

x^2

(7)

 

f1 - x^2;

0

(8)

 

NULL

Download test1.mw

Hi,

I am creating a multiple-choice questionnaire (MCQ) on functions, but the display of logarithmic functions is automatically converted to natural logarithms. How can I keep the logarithms displayed in base a without conversion? Thank you for your help.

S5_QCM_Expo_Log.mw

I found system remember tables mentioned under Details in ?CacheOption.

What exactly are they? Anything special about them?

The ProgrammingGuide does not given more details. It only mentions that there are "procedures that cannot use option system remember tables". For what reason a procedure cannot use them?

2 3 4 5 6 7 8 Last Page 4 of 2402