MaplePrimes Questions

Performing a search brought some results from wamp.mapleprimes.com. 

I clicked on it and firefox gave me a warning.  Is wamp.mapleprimes.com a legitamate site???

I believe I found I bug.

The 'next' statement for loop control will not work in 2D Input but it does in Code Edit Region.

From the documentation on 'next', I copied the following code into a 2D input in a document. 

Running it results in Error, invalid expression for eval; id=54 which is a missing help page.

for i to 4 do
    for j to 4 do
       print([i, j]);
         if i = j then next i;
        end if;
   end do;
end do

However 'next' without a following integer/name works fine in both 2D Input and Code Edit Region.

So is there only a subset of Maple code that will work in 2D Input?

I have calculated an expression which depends on functions. I would now like to calculate the derivative withe respect to a function  but when I try to do so I get the error “Deriving a functional ”Error, invalid input: diff received fA(r), which is not valid for its 2nd argument. There is no help page available for this error, so maybe someone knows what I am doing wrong .

I get this is because die diff function might not be able to handel a function as an argument, but how would I do it? 

L := -r^2*((-fA(r)^4+(-2*fB(r)^2-2*fC(r)^2+2)*fA(r)^2+4*(D(fB))(r)*fA(r)*fC(r)*r-fB(r)^4+(-2*fC(r)^2+2)*fB(r)^2-4*fB(r)*fC(r)*(D(fA))(r)*r-2*r^2*(D(fA))(r)^2-1-2*r^2*(D(fB))(r)^2)/(2*g^2*r^4)+(r*(fB(r)^2+(1/2)*fC(r)^2+fA(r)^2-2*fA(r)+1)*H(r)^2+(-(D(K))(r)*r^2*fC(r)-2*K(r)*fB(r)*r)*H(r)+(1/2)*K(r)^2*fC(r)^2*r+(D(H))(r)*K(r)*r^2*fC(r)+r*((fB(r)^2+fA(r)^2)*K(r)^2+(1/2)*r^2*((D(H))(r)^2+(D(K))(r)^2)))*v^2/(r^2)^(3/2)-lambda((1/2)*(K(r)^2+H(r)^2-1)*v^2)^2)

-r^2*((1/2)*(-fA(r)^4+(-2*fB(r)^2-2*fC(r)^2+2)*fA(r)^2+4*(D(fB))(r)*fA(r)*fC(r)*r-fB(r)^4+(-2*fC(r)^2+2)*fB(r)^2-4*fB(r)*fC(r)*(D(fA))(r)*r-2*r^2*(D(fA))(r)^2-1-2*r^2*(D(fB))(r)^2)/(g^2*r^4)+(r*(fB(r)^2+(1/2)*fC(r)^2+fA(r)^2-2*fA(r)+1)*H(r)^2+(-(D(K))(r)*r^2*fC(r)-2*K(r)*fB(r)*r)*H(r)+(1/2)*K(r)^2*fC(r)^2*r+(D(H))(r)*K(r)*r^2*fC(r)+r*((fB(r)^2+fA(r)^2)*K(r)^2+(1/2)*r^2*((D(H))(r)^2+(D(K))(r)^2)))*v^2/(r^2)^(3/2)-lambda((1/2)*(K(r)^2+H(r)^2-1)*v^2)^2)

(1)

diff(L, fA(r))

Error, invalid input: diff received fA(r), which is not valid for its 2nd argument

 
 

``

Download test_funtion.mw

Hi,

Is there a way to vary C in steps of fractions of Pi ? Thanks

Q_Pi_scaling.mw

What am I missing here?  I type in a simple differential equation and I get .. unable to parse error.

For practice, I would like to calculate the left-hand limit according to the attached file. The computer does not finish. The result pi^2/6 is known from a calculation "on foot".

restart

``

limit((1-t)^2*(sum(k*t^k/(1-t^k), k = 1 .. infinity)), t = 1, left)

limit((1-t)^2*(sum(k*t^k/(1-t^k), k = 1 .. infinity)), t = 1, left)

(1)

"(->)"``

``

Download test.mwtest.mw

Hello, an interesting issue about set equivalence.

Logically, the two sets are equivalent by derivation.

The first principal case, for set A, k=0, the element values ​​are Pi/6 and 5*Pi/6, which corresponds to the case of k=0 (element value is Pi/6) and k=1 (element value is 5*Pi/6) in set B. Obviously, the k value is not one-to-one correspondence, but just a letter representing a positive integer. As for the second general case, it is the same steps I thought.

So, how to verify that the two sets are equivalent? I know Maple cannot do it in one step, but I don't know how to do it?

A := solve(sin(x) = 1/2, allsolutions = true)

(1/6)*Pi+2*Pi*_Z5, (5/6)*Pi+2*Pi*_Z5

(1)

A := `assuming`([`union`({(1/6)*Pi+2*k*Pi}, {Pi-(1/6)*Pi+2*k*Pi})], [k::integer])

{(1/6)*Pi+2*k*Pi, (5/6)*Pi+2*k*Pi}

(2)

B := `assuming`([{k*Pi+(1/6)*(-1)^k*Pi}], [k::integer])

{k*Pi+(1/6)*(-1)^k*Pi}

(3)

is(A = B)

false

(4)

restart

alpha = 'alpha'

alpha = alpha

(5)

solve(sin(x) = alpha, x, allsolutions = true)

2*Pi*_Z1+arcsin(alpha), -arcsin(alpha)+Pi+2*Pi*_Z1

(6)

A := `assuming`([`union`({arcsin(alpha)+2*k*Pi}, {Pi-arcsin(alpha)+2*k*Pi})], [k::integer])

{arcsin(alpha)+2*k*Pi, Pi-arcsin(alpha)+2*k*Pi}

(7)

B := `assuming`([{k*Pi+(-1)^k*arcsin(alpha)}], [k::integer])

{k*Pi+(-1)^k*arcsin(alpha)}

(8)

is(A = B)

false

(9)
 

NULL

Download verify_set_A_and_set_B_is_equivalent.mw

I have Maple 2024 and successfully loaded the FeynmanIntegral package with:

with(Physics); with(FeynmanIntegral);

Maple confirms that FeynmanIntegral is loaded by displaying:

[Evaluate, ExpandDimension, FromAbstractRepresentation, Parametrize, Series, SumLookup, TensorBasis, TensorReduce, ToAbstractRepresentation, epsilon, varepsilon]

However, when I attempt to evaluate a Feynman integral, Maple only displays the unevaluated expression instead of computing it:

Delta(q); %FeynmanIntegral(1/p^2*1/(p + q)^2, p);

And explicitly calling Evaluate() does not compute the result:

Evaluate(Delta(q));

  1. Using Evaluate() explicitly:

    FeynmanIntegral:-Evaluate(1 / (p^2 * (p + q)^2), p);

    Result: No evaluation, only displays the input.

  2. Assigning the integral to a variable before evaluating:

    I := FeynmanIntegral(1 / (p^2 * (p + q)^2), p); Evaluate(I);

    Result: Still does not evaluate.

  3. Using dimension= instead of d= when specifying the spacetime dimension:

    FeynmanIntegral:-Evaluate(1 / (p^2 * (p + q)^2), p, dimension = 4 - 2*epsilon);

    Result: No evaluation.

  4. Checking if FeynmanIntegral functions exist:

    showstat(FeynmanIntegral);

    Result: The package seems loaded, but it does not execute calculations.

I expect FeynmanIntegral:-Evaluate(...) to automatically compute the dimensional integral using Feynman rules and return a result.

  1. Is FeynmanIntegral:-Evaluate() broken in Maple 2024?
  2. Are there additional setup steps needed to enable full functionality?
  3. Has anyone successfully used FeynmanIntegral for automatic dimensional integration?
  4. Are there alternative Maple functions/packages for computing Feynman integrals in dimensional regularization?

Any help would be greatly appreciated!

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

First 25 26 27 28 29 30 31 Last Page 27 of 2425