Advanced Search

Maple Questions and Posts

These are Posts and Questions associated with the product, Maple
View all posts
Maple Questions and Posts Feed

Incorrect evaluation of standard Bessel integral ...

Asked by: markweitzman 110
integration bessel
17 hours ago
2  5

The maple worksheet shows an incorrect evaluation of the integral in (1) which is a standard integral representation of a Bessel function.  Equations (2)-(5) along with the graph show the incorrectness of the evaluation.  What is going on?

Bessel.mw

Odegenerator plots ...

Asked by: janhardo 430
ode explore differential-equations
Yesterday at 8:03 AM
0  10

Found this old procedure code and revived it
Trying to include an Exploreplot as well
a0,a1,a2,b1,b2 are coeifficents in a ode to construct 
How about odetype when constructing a ode is this correct in code?


> 

restart;

Odegenerator := proc(V, x, y, df, const_values)
    local input_args, xi, F, result, a0, a1, a2, b0, b1, sol, Fsol, rows, numrows, eq, count, odeplot_cmd, ode_type, row_number, values;
    with(plots);
    with(DEtools);
    with(PDEtools);

    if nargs = 1 and V = "help" then
        printf("Use this procedure as follows:\n");
        printf("Define an ODE template:\n");
        printf("Odegenerator(V, x, y, df, const_values)\n");
        printf("V: A set of values for iteration over constants (if df > 0)\n");
        printf("x: The independent variable\n");
        printf("y: The function\n");
        printf("df: The row number in the DataFrame or 0 for manual input\n");
        printf("const_values: A list of values for the constants (used if df = 0)\n");
        return;
    end if;

    if nargs < 4 or nargs > 5 then
        error "Incorrect number of arguments. Expected: V, x, y, df, [const_values (optional)]";
    end if;

    # Determine the ODE type using odeadvisor for the global eq_template
    ode_type := odeadvisor(eq_template);

    # Display the ODE and its type
    print(eq_template, ode_type);

    rows := [];
    count := 0;
    ###################### BOF manuele invoer ###################
    if df = 0 then
    # If df = 0, use const_values for substitution
    if nargs < 5 or not type(const_values, list) then
        error "When df = 0, a list of constant values must be provided as the fifth argument.";
    end if;

    # Assign constant values
    if nops(const_values) <> 5 then
        error "The list of constant values must contain exactly 5 elements.";
    end if;

    # Find the corresponding row number by unique identification
    count := 1;
    for a0 in V do
        for a1 in V do
            for a2 in V do
                for b0 in V do
                    for b1 in V do
                        if [a0, a1, a2, b0, b1] = const_values then
                            row_number := sprintf("%d", count);  # Convert to string
                        end if;
                        count := count + 1;
                    end do;
                end do;
            end do;
        end do;
    end do;

    if not assigned(row_number) then
        row_number := "Unique (outside iterative rows)";  # Mark as unique
    end if;

    # Substitute the given values
    eq := subs({'a__0' = const_values[1], 'a__1' = const_values[2], 'a__2' = const_values[3], 'b__0' = const_values[4], 'b__1' = const_values[5]}, eq_template);

    # Solve the equation
    sol := dsolve(eq, y(x));
    if type(sol, `=`) then
        Fsol := rhs(sol);
    else
        Fsol := "No explicit solution";
    end if;

    # Display the solution and its row number
    odeplot_cmd := DEplot(eq, y(x), x = 0 .. 2, y = -10 .. 10, [[y(0) = 1]]);
    print(plots:-display(odeplot_cmd, size = [550, 550]));

    printf("The found function is:\n");
    print(Fsol);
    printf("The corresponding row number is: %s\n", row_number);

    # -- Start of Additional Functionality --
    # Optionally display the simplified ODE
    printf("The simplified ODE using the given coefficients is:\n");
    print(eq, ode_type);
    # -- End of Additional Functionality --

    return Fsol;
     ################# EOF manuele berekening ##################
     ############## BOF iterative berekening##############
    else
        # Iterative approach for DataFrame generation
        for a0 in V do
            for a1 in V do
                for a2 in V do
                    for b0 in V do
                        for b1 in V do
                            xi := x;
                            F := y;

                            # Substitute constant values into the ODE
                            eq := subs({'a__0' = a0, 'a__1' = a1, 'a__2' = a2, 'b__0' = b0, 'b__1' = b1}, eq_template);

                            sol := dsolve(eq, F(xi));
                            if type(sol, `=`) then
                                Fsol := rhs(sol);
                            else
                                Fsol := "No explicit solution";
                            end if;

                            rows := [op(rows), [a0, a1, a2, b0, b1, Fsol]];
                        end do;
                    end do;
                end do;
            end do;
        end do;

        numrows := nops(rows);
        result := DataFrame(Matrix(numrows, 6, rows), columns = ['a__0', 'a__1', 'a__2', 'b__0', 'b__1', y(x)]);

        interface(rtablesize = numrows + 10);

        if df > 0 and df <= numrows then
            a0 := result[df, 'a__0'];
            a1 := result[df, 'a__1'];
            a2 := result[df, 'a__2'];
            b0 := result[df, 'b__0'];
            b1 := result[df, 'b__1'];

            eq := subs({'a__0' = a0, 'a__1' = a1, 'a__2' = a2, 'b__0' = b0, 'b__1' = b1}, eq_template);

            # Display the additional parameters
            print(eq, ode_type, [df], [a0, a1, a2, b0, b1]);

            # Retrieve the solution
            Fsol := result[df, y(x)];

            # Display the solution in DEplot
            odeplot_cmd := DEplot(eq, y(x), x = 0 .. 2, y = -10 .. 10, [[y(0) = 1]]);
            print(plots:-display(odeplot_cmd, size = [550, 550]));

            printf("The found function for row number %d is:\n", df);
            print(Fsol);

        else
            printf("The specified row (%d) is out of bounds for the DataFrame.\n", df);
        end if;

        return result;
     ########## EOF iteratief bwrekening ########################
    end if;

end proc:
> 


# Test cases
V := {0, 1};
eq_template := diff(y(t), t) = 'a__0'*sin(t) + 'a__1'*y(t) + 'a__2'*y(t)^2 + 'b__0'*exp(-t);



 

{0, 1}

  

diff(y(t), t) = a__0*sin(t)+a__1*y(t)+a__2*y(t)^2+b__0*exp(-t)

 (1)

 

 

> 

# Iterative test
result := Odegenerator(V, t, y, 25);

diff(y(t), t) = a__0*sin(t)+a__1*y(t)+a__2*y(t)^2+b__0*exp(-t), [_Riccati]

  

diff(y(t), t) = sin(t)+y(t), [_Riccati], [25], [1, 1, 0, 0, 0]

  

 

The found function for row number 25 is:

  

-(1/2)*cos(t)-(1/2)*sin(t)+c__1*exp(t)

  

module DataFrame () description "two-dimensional rich data container"; local columns, rows, data, binder; option object(BaseDataObject); end module

 (2)

 

> 

# Manual input test
Odegenerator(V, t, y, 0, [1, 1, 0, 0, 0]); #0 after y is rownumber = 0 and [1, 1, 0, 0, 0] are coeifficents

diff(y(t), t) = a__0*sin(t)+a__1*y(t)+a__2*y(t)^2+b__0*exp(-t), [_Riccati]

  

 

The found function is:

  

-(1/2)*cos(t)-(1/2)*sin(t)+c__1*exp(t)

  

The corresponding row number is: 25
The simplified ODE using the given coefficients is:

  

diff(y(t), t) = sin(t)+y(t), [_Riccati]

  

-(1/2)*cos(t)-(1/2)*sin(t)+c__1*exp(t)

 (3)
 

 

> 

 


Download ODEGENERATORFUNCTIE_opgepakt-uitgebreid_naar_Mprimes_14-1-2025.mw

Open dialogue stops working. Unable to select file...

Asked by: nm 10411
windows gui dialogue
January 12 2025
3  2

This is a very serious problem. Maple 2024.2 on windows 10.

I noticed, may be starting 2-3 weeks now, that sometimes when I do File->Open , and the Open dialogue opens, I am not able to use the mouse to select the .mw file I want to open. 

Can not even close the dialogue by clicking X. Even clickiing on cancel does nothing.  Basically the mouse seems not doing anything.

Only way is to type using the keyboard the file name. Eveything else does not work.

Not only that, the mouse is trapped in the dialogue.

I can't even get it out of Maple to go to another application. AT first, I had to do CTRL-ALT-DEL to get out and use the task manager to kill Maple. Then later I found if I type the file name I can get out.

Here is a movie.  

I do not understand what is causing this. This only happens in Maple for me. Neven seen anything like this before.

Any suggestions what to look for?

I just remembered. 2-3 weeks ago, I closed the left panel. As you see above.

I just tried now, and expanded it again, and guess what, the mouse seems to be working now!

Can someone conform this?  Here is a movie with the panel expanded again:

You see, the mouse now works and can select files.

When I minimize the left panel, the mouse sometimes stops working in file dialogue.

Here is another movie showing this problem much more clearly.

When closing the left panel, the open file dialogue stops working (mouse not working), and when expanding it again, it starts to work!

This can not be a feature right? it must be a bug in the Java interface?

why my pdetest not satisfy?...

Asked by: salim-barzani 185
pde differential-equations pdetest
January 10 2025
0  11

every thing is correct but i dont know why my PDE is not be zero, i did by another way is satidy but i change whole equation by sabstitutiin then i did ode test is satisfy by putting case in equation and solution with condition but when i want to use pdetest  test in pde is not satisfy ?

> 

restart
> 

_local(gamma)
> 

with(PDEtools)
> 

NULL
> 

undeclare(prime)

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

 (1)
> 

declare(Omega(x, t)); declare(U(xi)); declare(V(xi)); declare(Theta(x, t))

Omega(x, t)*`will now be displayed as`*Omega

  

U(xi)*`will now be displayed as`*U

  

V(xi)*`will now be displayed as`*V

  

Theta(x, t)*`will now be displayed as`*Theta

 (2)
> 

xi := -t*tau+x

-t*tau+x

 (3)
> 

NULL
> 

NULL
> 

lambda := -tau/c; epsilon := -tau/c; delta := (2*c^2-gamma*tau)/(gamma-2*tau)

-tau/c

  

-tau/c

  

(2*c^2-gamma*tau)/(gamma-2*tau)

 (4)
> 

NULL
> 

case1 := [c = RootOf(-gamma^3*tau+2*_Z^2+2*gamma*tau-4*tau^2)/gamma, A[0] = 0, A[1] = RootOf(_Z^2*gamma+2*tau), B[1] = 0]

[c = RootOf(-gamma^3*tau+2*_Z^2+2*gamma*tau-4*tau^2)/gamma, A[0] = 0, A[1] = RootOf(_Z^2*gamma+2*tau), B[1] = 0]

 (5)
> 

K := Omega(x, t) = RootOf(_Z^2*gamma+2*tau)*tanh(xi)*exp(I*gamma*(delta*t+x))

Omega(x, t) = -RootOf(_Z^2*gamma+2*tau)*tanh(t*tau-x)*exp(I*gamma*((2*c^2-gamma*tau)*t/(gamma-2*tau)+x))

 (6)
> 

NULL
> 

pde1 := I*(diff(Omega(x, t), `$`(t, 2))-c^2*(diff(Omega(x, t), `$`(x, 2))))+diff(U(-t*tau+x)^2*Omega(x, t), t)-lambda*c*(diff(U(-t*tau+x)^2*Omega(x, t), x))+(1/2)*(diff(Omega(x, t), `$`(x, 2), t))-(1/2)*epsilon*c*(diff(Omega(x, t), `$`(x, 3))) = 0

I*(diff(diff(Omega(x, t), t), t)-c^2*(diff(diff(Omega(x, t), x), x)))-2*U(-t*tau+x)*Omega(x, t)*(D(U))(-t*tau+x)*tau+U(-t*tau+x)^2*(diff(Omega(x, t), t))+tau*(2*U(-t*tau+x)*Omega(x, t)*(D(U))(-t*tau+x)+U(-t*tau+x)^2*(diff(Omega(x, t), x)))+(1/2)*(diff(diff(diff(Omega(x, t), t), x), x))+(1/2)*tau*(diff(diff(diff(Omega(x, t), x), x), x)) = 0

 (7)
> 

NULL
> 

subs(case1, pde1)

I*(diff(diff(Omega(x, t), t), t)-RootOf(-gamma^3*tau+2*_Z^2+2*gamma*tau-4*tau^2)^2*(diff(diff(Omega(x, t), x), x))/gamma^2)-2*U(-t*tau+x)*Omega(x, t)*(D(U))(-t*tau+x)*tau+U(-t*tau+x)^2*(diff(Omega(x, t), t))+tau*(2*U(-t*tau+x)*Omega(x, t)*(D(U))(-t*tau+x)+U(-t*tau+x)^2*(diff(Omega(x, t), x)))+(1/2)*(diff(diff(diff(Omega(x, t), t), x), x))+(1/2)*tau*(diff(diff(diff(Omega(x, t), x), x), x)) = 0

 (8)
> 

T := simplify(I*(diff(diff(Omega(x, t), t), t)-RootOf(-gamma^3*tau+2*_Z^2+2*gamma*tau-4*tau^2)^2*(diff(diff(Omega(x, t), x), x))/gamma^2)-2*U(-t*tau+x)*Omega(x, t)*(D(U))(-t*tau+x)*tau+U(-t*tau+x)^2*(diff(Omega(x, t), t))+tau*(2*U(-t*tau+x)*Omega(x, t)*(D(U))(-t*tau+x)+U(-t*tau+x)^2*(diff(Omega(x, t), x)))+(1/2)*(diff(diff(diff(Omega(x, t), t), x), x))+(1/2)*tau*(diff(diff(diff(Omega(x, t), x), x), x)) = 0)

(1/2)*(2*gamma^2*(tau*(diff(Omega(x, t), x))+diff(Omega(x, t), t))*U(-t*tau+x)^2+(diff(diff(diff(Omega(x, t), t), x), x))*gamma^2+tau*(diff(diff(diff(Omega(x, t), x), x), x))*gamma^2-(4*I)*((1/4)*gamma^3+tau-(1/2)*gamma)*tau*(diff(diff(Omega(x, t), x), x))+(2*I)*(diff(diff(Omega(x, t), t), t))*gamma^2)/gamma^2 = 0

 (9)
> 

pdetest(K, T)

-(1/2)*2^(1/2)*(-tau/gamma)^(1/2)*(-32*gamma^4*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+16*gamma^5*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-8*gamma^6*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+32*gamma^5*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-32*gamma^4*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+16*gamma^4*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-96*gamma^3*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+192*gamma^2*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-128*tau^4*gamma*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+16*gamma^4*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-96*gamma^3*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+192*gamma^2*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-128*tau^4*gamma*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+16*gamma^5*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-8*gamma^6*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(4*I)*U(-t*tau+x)^2*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(4*I)*U(-t*tau+x)^2*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(8*I)*U(-t*tau+x)^2*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(12*I)*gamma^5*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(4*I)*U(-t*tau+x)^2*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))-(4*I)*U(-t*tau+x)^2*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(8*I)*U(-t*tau+x)^2*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(12*I)*gamma^5*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(4*I)*U(-t*tau+x)^2*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(4*I)*U(-t*tau+x)^2*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(8*I)*U(-t*tau+x)^2*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(12*I)*gamma^5*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(4*I)*U(-t*tau+x)^2*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(4*I)*U(-t*tau+x)^2*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(8*I)*U(-t*tau+x)^2*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(12*I)*gamma^5*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(32*I)*gamma^3*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(32*I)*gamma^3*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-64*gamma^4*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+64*gamma^3*tau^2*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+I*tau*gamma^7*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-64*gamma^4*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+64*gamma^3*tau^2*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+I*tau*gamma^7*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(192*I)*tau^3*gamma*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(8*I)*c^4*gamma^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(2*I)*c^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(4*I)*tau^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(8*I)*c^4*gamma^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(2*I)*c^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-I*tau*gamma^7*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(4*I)*tau^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(16*I)*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(6*I)*tau*gamma^5*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(20*I)*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(40*I)*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(48*I)*gamma^2*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(16*I)*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(6*I)*tau*gamma^5*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(20*I)*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(40*I)*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(48*I)*gamma^2*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(16*I)*gamma^3*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(96*I)*gamma^2*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(192*I)*tau^3*gamma*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(16*I)*gamma^3*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(96*I)*gamma^2*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-I*tau*gamma^7*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(4*I)*tau^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(8*I)*c^4*gamma^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))-(2*I)*c^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))-(4*I)*tau^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(8*I)*c^4*gamma^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(2*I)*tau*gamma^5*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(12*I)*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(24*I)*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(16*I)*gamma^2*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(2*I)*tau*gamma^5*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(12*I)*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))-(24*I)*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(16*I)*gamma^2*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(2*I)*c^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+32*gamma^5*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(128*I)*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(128*I)*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(8*I)*tau*c^2*U(-t*tau+x)^2*gamma^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(8*I)*tau*c^2*U(-t*tau+x)^2*gamma^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(8*I)*tau*c^2*U(-t*tau+x)^2*gamma^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(8*I)*tau*c^2*U(-t*tau+x)^2*gamma^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau)))/(gamma^2*(gamma-2*tau)^2*(exp(2*t*tau)+exp(2*x))^3)

 (10)
> 

simplify(-(1/2)*2^(1/2)*(-tau/gamma)^(1/2)*((8*I)*tau*c^2*U(-t*tau+x)^2*gamma^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(8*I)*tau*c^2*U(-t*tau+x)^2*gamma^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(8*I)*tau*c^2*U(-t*tau+x)^2*gamma^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))-(8*I)*tau*c^2*U(-t*tau+x)^2*gamma^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(128*I)*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+32*gamma^5*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+192*gamma^2*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-128*tau^4*gamma*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+16*gamma^5*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-8*gamma^6*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+32*gamma^5*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-32*gamma^4*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+16*gamma^4*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-96*gamma^3*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+192*gamma^2*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-128*tau^4*gamma*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+16*gamma^4*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-96*gamma^3*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(128*I)*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-32*gamma^4*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+16*gamma^5*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-8*gamma^6*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(32*I)*gamma^3*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(4*I)*U(-t*tau+x)^2*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(4*I)*U(-t*tau+x)^2*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(8*I)*U(-t*tau+x)^2*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(12*I)*gamma^5*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(4*I)*U(-t*tau+x)^2*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(8*I)*U(-t*tau+x)^2*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(12*I)*gamma^5*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(4*I)*U(-t*tau+x)^2*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(32*I)*gamma^3*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(4*I)*U(-t*tau+x)^2*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(8*I)*U(-t*tau+x)^2*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(12*I)*gamma^5*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(4*I)*U(-t*tau+x)^2*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))-(4*I)*U(-t*tau+x)^2*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(4*I)*U(-t*tau+x)^2*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(8*I)*U(-t*tau+x)^2*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(12*I)*gamma^5*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(8*I)*c^4*gamma^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(2*I)*c^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(4*I)*tau^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-I*tau*gamma^7*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(16*I)*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(20*I)*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(48*I)*gamma^2*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(6*I)*tau*gamma^5*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(40*I)*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(16*I)*gamma^3*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(192*I)*tau^3*gamma*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(96*I)*gamma^2*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-I*tau*gamma^7*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(8*I)*c^4*gamma^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))-(2*I)*c^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))-(4*I)*tau^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))-(12*I)*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(16*I)*gamma^2*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(2*I)*tau*gamma^5*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))-(24*I)*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))-64*gamma^4*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+64*gamma^3*tau^2*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-64*gamma^4*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+64*gamma^3*tau^2*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(8*I)*c^4*gamma^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(2*I)*tau*gamma^5*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(24*I)*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(12*I)*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(16*I)*gamma^2*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(2*I)*c^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(48*I)*gamma^2*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(96*I)*gamma^2*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(16*I)*gamma^3*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(4*I)*tau^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(2*I)*c^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(4*I)*tau^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(6*I)*tau*gamma^5*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(40*I)*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(16*I)*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(20*I)*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+I*tau*gamma^7*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+I*tau*gamma^7*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(192*I)*tau^3*gamma*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(8*I)*c^4*gamma^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau)))/(gamma^2*(gamma-2*tau)^2*(exp(2*tau*t)+exp(2*x))^3))

-(-tau/gamma)^(1/2)*((I*gamma^3*(-(1/2)*gamma+tau)*(c-tau)*(c+tau)*U(-t*tau+x)^2-((1/8)*I)*tau*gamma^7+(((1/4)*I)*c^2+((1/2)*I)*tau^2-tau)*gamma^6+(4*tau^2+(-((3/2)*I)*c^2-(3/4)*I)*tau+2*c^2)*gamma^5+(-4*tau^3+((5/2)*I)*tau^2+(-8*c^2+2)*tau+I*(c^2+2)*c^2)*gamma^4-4*(((5/4)*I)*tau^2+(-2*c^2+3)*tau+I*c^2-(1/2)*I)*tau*gamma^3+6*(I*tau^2-2*I+4*tau)*tau^2*gamma^2+((24*I)*tau^3-16*tau^4)*gamma-(16*I)*tau^4)*exp((I*(t*tau-x)*gamma^2+2*((I*x-t)*tau-I*c^2*t-2*x)*gamma+4*t*tau^2+8*x*tau)/(-gamma+2*tau))+(-I*gamma^3*(-(1/2)*gamma+tau)*(c-tau)*(c+tau)*U(-t*tau+x)^2+((1/8)*I)*tau*gamma^7+(-((1/4)*I)*c^2-((1/2)*I)*tau^2-tau)*gamma^6+(4*tau^2+(((3/2)*I)*c^2+(3/4)*I)*tau+2*c^2)*gamma^5+(-4*tau^3-((5/2)*I)*tau^2+(-8*c^2+2)*tau-I*(c^2+2)*c^2)*gamma^4+4*(((5/4)*I)*tau^2+tau*(2*c^2-3)+I*c^2-(1/2)*I)*tau*gamma^3-6*(I*tau^2-2*I-4*tau)*tau^2*gamma^2+(-(24*I)*tau^3-16*tau^4)*gamma+(16*I)*tau^4)*exp((I*(t*tau-x)*gamma^2+2*((I*x-2*t)*tau-I*c^2*t-x)*gamma+8*t*tau^2+4*x*tau)/(-gamma+2*tau))+I*gamma^2*(exp((I*(t*tau-x)*gamma^2+2*(-I*c^2*t+I*x*tau-3*x)*gamma+12*x*tau)/(-gamma+2*tau))-exp((I*(t*tau-x)*gamma^2+2*((I*x-3*t)*tau-I*c^2*t)*gamma+12*t*tau^2)/(-gamma+2*tau)))*(gamma*(-(1/2)*gamma+tau)*(c-tau)*(c+tau)*U(-t*tau+x)^2-(1/8)*tau*gamma^5+((1/4)*c^2+(1/2)*tau^2)*gamma^4+tau*(-(3/2)*c^2+1/4)*gamma^3+(c^4-(3/2)*tau^2)*gamma^2+3*tau^3*gamma-2*tau^4))*2^(1/2)/(gamma^2*(exp(2*t*tau)+exp(2*x))^3*(-(1/2)*gamma+tau)^2)

 (11)
 

 

Download pdetest.mw

How to rewrite nonlinear equations in terms of oth...

Asked by: MaPal93 175
solve parameters nonlinear
January 07 2025
0  0

I have a system of 4 nonlinear equations in 4 lambda variables. I cannot obtain a solution using solve():

4_nonlinear_equations.mw

I can sometimes simplify similar systems by rescaling equations to reduce parameters. With only 3 parameters (sigma_v, sigma_d, sigma_d3) in this case, complexity arises from the interactions of the 4 lambdas in the 4 equations. Upon examining the equations (highlighted in yellow), I suspect hidden symmetries. Is it possible to solve the system by rewriting the equations in terms of each other to find an equivalent system? I am exploring if a smarter and simpler reformulation could lead to a solution. Thank you.

How make a system of equation by using special fa...

Asked by: salim-barzani 185
ode parameters differential-equations
January 06 2025
0  4

i want to factoring the (m+G'/G) in my long equation but i use some trick but still i can't get the exactly system and still G will remain in my system what should i factoring for remove this G(xi) from my system is all about factoring , my system of equation are wrong contain G(xi) How i can remove it by taking a factoring or any other technique,

not parameter is arbitrary except V and sigma''

> 

restart
> 

with(PDEtools)
> 

with(LinearAlgebra)
> 

with(Physics)
> 

with(SolveTools)
> 

undeclare(prime)

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

 (1)
> 

_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.

  
> 

declare(Omega(x, t)); declare(U(xi)); declare(u(x, y, z, t)); declare(Q(xi)); declare(V(xi))

Omega(x, t)*`will now be displayed as`*Omega

  

U(xi)*`will now be displayed as`*U

  

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

  

Q(xi)*`will now be displayed as`*Q

  

V(xi)*`will now be displayed as`*V

 (2)
> 

NULL
> 

ode := (-V*a[2]+a[1])*(diff(diff(U(xi), xi), xi))+U(xi)*(((-gamma+sigma)*k+b)*U(xi)^2-a[1]*k^2+(w*a[2]-alpha)*k-w) = 0

(-V*a[2]+a[1])*(diff(diff(U(xi), xi), xi))+U(xi)*(((-gamma+sigma)*k+b)*U(xi)^2-a[1]*k^2+(w*a[2]-alpha)*k-w) = 0

 (3)
> 

F := sum(e[i]*(m+(diff(G(xi), xi))/G(xi))^i, i = -1 .. 1)

e[-1]/(m+(diff(G(xi), xi))/G(xi))+e[0]+e[1]*(m+(diff(G(xi), xi))/G(xi))

 (4)
> 

D1 := diff(F, xi)

-e[-1]*((diff(diff(G(xi), xi), xi))/G(xi)-(diff(G(xi), xi))^2/G(xi)^2)/(m+(diff(G(xi), xi))/G(xi))^2+e[1]*((diff(diff(G(xi), xi), xi))/G(xi)-(diff(G(xi), xi))^2/G(xi)^2)

 (5)
> 

NULL
> 

S := diff(G(xi), `$`(xi, 2)) = -(2*m*mu+lambda)*(diff(G(xi), xi))-mu

diff(diff(G(xi), xi), xi) = -(2*m*mu+lambda)*(diff(G(xi), xi))-mu

 (6)
> 

E1 := subs(S, D1)

-e[-1]*((-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)/G(xi)-(diff(G(xi), xi))^2/G(xi)^2)/(m+(diff(G(xi), xi))/G(xi))^2+e[1]*((-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)/G(xi)-(diff(G(xi), xi))^2/G(xi)^2)

 (7)
> 

D2 := diff(E1, xi)

2*e[-1]*((-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)/G(xi)-(diff(G(xi), xi))^2/G(xi)^2)*((diff(diff(G(xi), xi), xi))/G(xi)-(diff(G(xi), xi))^2/G(xi)^2)/(m+(diff(G(xi), xi))/G(xi))^3-e[-1]*(-(2*m*mu+lambda)*(diff(diff(G(xi), xi), xi))/G(xi)-(-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)*(diff(G(xi), xi))/G(xi)^2-2*(diff(G(xi), xi))*(diff(diff(G(xi), xi), xi))/G(xi)^2+2*(diff(G(xi), xi))^3/G(xi)^3)/(m+(diff(G(xi), xi))/G(xi))^2+e[1]*(-(2*m*mu+lambda)*(diff(diff(G(xi), xi), xi))/G(xi)-(-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)*(diff(G(xi), xi))/G(xi)^2-2*(diff(G(xi), xi))*(diff(diff(G(xi), xi), xi))/G(xi)^2+2*(diff(G(xi), xi))^3/G(xi)^3)

 (8)
> 

E2 := subs(S, D2)

2*e[-1]*((-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)/G(xi)-(diff(G(xi), xi))^2/G(xi)^2)^2/(m+(diff(G(xi), xi))/G(xi))^3-e[-1]*(-(2*m*mu+lambda)*(-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)/G(xi)-3*(-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)*(diff(G(xi), xi))/G(xi)^2+2*(diff(G(xi), xi))^3/G(xi)^3)/(m+(diff(G(xi), xi))/G(xi))^2+e[1]*(-(2*m*mu+lambda)*(-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)/G(xi)-3*(-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)*(diff(G(xi), xi))/G(xi)^2+2*(diff(G(xi), xi))^3/G(xi)^3)

 (9)
> 

D3 := diff(E2, xi)

-6*e[-1]*((-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)/G(xi)-(diff(G(xi), xi))^2/G(xi)^2)^2*((diff(diff(G(xi), xi), xi))/G(xi)-(diff(G(xi), xi))^2/G(xi)^2)/(m+(diff(G(xi), xi))/G(xi))^4+4*e[-1]*((-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)/G(xi)-(diff(G(xi), xi))^2/G(xi)^2)*(-(2*m*mu+lambda)*(diff(diff(G(xi), xi), xi))/G(xi)-(-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)*(diff(G(xi), xi))/G(xi)^2-2*(diff(G(xi), xi))*(diff(diff(G(xi), xi), xi))/G(xi)^2+2*(diff(G(xi), xi))^3/G(xi)^3)/(m+(diff(G(xi), xi))/G(xi))^3+2*e[-1]*(-(2*m*mu+lambda)*(-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)/G(xi)-3*(-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)*(diff(G(xi), xi))/G(xi)^2+2*(diff(G(xi), xi))^3/G(xi)^3)*((diff(diff(G(xi), xi), xi))/G(xi)-(diff(G(xi), xi))^2/G(xi)^2)/(m+(diff(G(xi), xi))/G(xi))^3-e[-1]*((2*m*mu+lambda)^2*(diff(diff(G(xi), xi), xi))/G(xi)+(2*m*mu+lambda)*(-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)*(diff(G(xi), xi))/G(xi)^2+3*(2*m*mu+lambda)*(diff(diff(G(xi), xi), xi))*(diff(G(xi), xi))/G(xi)^2+6*(-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)*(diff(G(xi), xi))^2/G(xi)^3-3*(-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)*(diff(diff(G(xi), xi), xi))/G(xi)^2+6*(diff(G(xi), xi))^2*(diff(diff(G(xi), xi), xi))/G(xi)^3-6*(diff(G(xi), xi))^4/G(xi)^4)/(m+(diff(G(xi), xi))/G(xi))^2+e[1]*((2*m*mu+lambda)^2*(diff(diff(G(xi), xi), xi))/G(xi)+(2*m*mu+lambda)*(-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)*(diff(G(xi), xi))/G(xi)^2+3*(2*m*mu+lambda)*(diff(diff(G(xi), xi), xi))*(diff(G(xi), xi))/G(xi)^2+6*(-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)*(diff(G(xi), xi))^2/G(xi)^3-3*(-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)*(diff(diff(G(xi), xi), xi))/G(xi)^2+6*(diff(G(xi), xi))^2*(diff(diff(G(xi), xi), xi))/G(xi)^3-6*(diff(G(xi), xi))^4/G(xi)^4)

 (10)
> 

E3 := subs(S, D3)

-6*e[-1]*((-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)/G(xi)-(diff(G(xi), xi))^2/G(xi)^2)^3/(m+(diff(G(xi), xi))/G(xi))^4+6*e[-1]*((-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)/G(xi)-(diff(G(xi), xi))^2/G(xi)^2)*(-(2*m*mu+lambda)*(-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)/G(xi)-3*(-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)*(diff(G(xi), xi))/G(xi)^2+2*(diff(G(xi), xi))^3/G(xi)^3)/(m+(diff(G(xi), xi))/G(xi))^3-e[-1]*((2*m*mu+lambda)^2*(-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)/G(xi)+4*(2*m*mu+lambda)*(-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)*(diff(G(xi), xi))/G(xi)^2+12*(-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)*(diff(G(xi), xi))^2/G(xi)^3-3*(-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)^2/G(xi)^2-6*(diff(G(xi), xi))^4/G(xi)^4)/(m+(diff(G(xi), xi))/G(xi))^2+e[1]*((2*m*mu+lambda)^2*(-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)/G(xi)+4*(2*m*mu+lambda)*(-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)*(diff(G(xi), xi))/G(xi)^2+12*(-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)*(diff(G(xi), xi))^2/G(xi)^3-3*(-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)^2/G(xi)^2-6*(diff(G(xi), xi))^4/G(xi)^4)

 (11)
> 

NULL
> 

NULL
> 

K := U(xi) = F
> 

K1 := diff(U(xi), xi) = E1
> 

K2 := diff(U(xi), `$`(xi, 2)) = E2
> 

K3 := diff(U(xi), `$`(xi, 3)) = E3
> 

NULL
> 

L := eval(ode, {K, K1, K2, K3})

(-V*a[2]+a[1])*(2*e[-1]*((-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)/G(xi)-(diff(G(xi), xi))^2/G(xi)^2)^2/(m+(diff(G(xi), xi))/G(xi))^3-e[-1]*(-(2*m*mu+lambda)*(-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)/G(xi)-3*(-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)*(diff(G(xi), xi))/G(xi)^2+2*(diff(G(xi), xi))^3/G(xi)^3)/(m+(diff(G(xi), xi))/G(xi))^2+e[1]*(-(2*m*mu+lambda)*(-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)/G(xi)-3*(-(2*m*mu+lambda)*(diff(G(xi), xi))-mu)*(diff(G(xi), xi))/G(xi)^2+2*(diff(G(xi), xi))^3/G(xi)^3))+(e[-1]/(m+(diff(G(xi), xi))/G(xi))+e[0]+e[1]*(m+(diff(G(xi), xi))/G(xi)))*(((-gamma+sigma)*k+b)*(e[-1]/(m+(diff(G(xi), xi))/G(xi))+e[0]+e[1]*(m+(diff(G(xi), xi))/G(xi)))^2-a[1]*k^2+(w*a[2]-alpha)*k-w) = 0

 (12)
> 

NULL
> 

# rewritting rule

RR := isolate(m+diff(G(xi), xi)/(G(xi))=Phi, diff(G(xi), xi)/G(xi));

(diff(G(xi), xi))/G(xi) = Phi-m

 (13)
> 

# Apply RR and collect wrt Phi

subs(RR, L):
normal(%):
PhiN := collect(numer(lhs(%)), phi):
PhiD := denom(lhs(%%));

Phi^3*G(xi)^4

 (14)
> 



with(LargeExpressions):

LLE := collect(PhiN, Phi, Veil[phi] ):
LLE / PhiD = 0;

(Phi^6*phi[1]+3*Phi^5*phi[2]-Phi^4*phi[3]-Phi^3*phi[4]-Phi^2*phi[5]+Phi*phi[6]-phi[7])/(Phi^3*G(xi)^4) = 0

 (15)
> 

# phi[i] coefficients


phis := [ seq( phi[i] = simplify(Unveil[phi](phi[i]), size), i=1..LastUsed[phi] ) ]:

print~( phis ):

phi[1] = G(xi)^4*e[1]^3*((-gamma+sigma)*k+b)

  

phi[2] = e[1]^2*G(xi)^4*e[0]*((-gamma+sigma)*k+b)

  

phi[3] = -3*e[1]*G(xi)^4*(-(1/3)*a[1]*k^2+(-e[-1]*(gamma-sigma)*e[1]+(-gamma+sigma)*e[0]^2+(1/3)*w*a[2]-(1/3)*alpha)*k+b*e[-1]*e[1]+b*e[0]^2-(1/3)*w)

  

phi[4] = (2*e[1]*(V*a[2]-a[1])*(diff(G(xi), xi))^3+3*e[1]*G(xi)*(2*m*mu+lambda)*(V*a[2]-a[1])*(diff(G(xi), xi))^2+e[1]*(V*a[2]-a[1])*G(xi)*((2*m*mu+lambda)^2*G(xi)+3*mu)*(diff(G(xi), xi))+G(xi)^2*(-(6*e[-1]*((-gamma+sigma)*k+b)*e[1]-a[1]*k^2+k*w*a[2]+((-gamma+sigma)*k+b)*e[0]^2-k*alpha-w)*e[0]*G(xi)+e[1]*mu*(2*m*mu+lambda)*(V*a[2]-a[1])))*G(xi)

  

phi[5] = -3*e[-1]*G(xi)^4*(-(1/3)*a[1]*k^2+(-e[-1]*(gamma-sigma)*e[1]+(-gamma+sigma)*e[0]^2+(1/3)*w*a[2]-(1/3)*alpha)*k+b*e[-1]*e[1]+b*e[0]^2-(1/3)*w)

  

phi[6] = 4*((1/2)*(V*a[2]-a[1])*(diff(G(xi), xi))^3+(3/2)*(V*a[2]-a[1])*(m*mu+(1/2)*lambda)*G(xi)*(diff(G(xi), xi))^2+(V*a[2]-a[1])*((m*mu+(1/2)*lambda)^2*G(xi)+(3/4)*mu)*G(xi)*(diff(G(xi), xi))+(1/2)*((3/2)*e[0]*((-gamma+sigma)*k+b)*e[-1]*G(xi)+(V*a[2]-a[1])*(m*mu+(1/2)*lambda)*mu)*G(xi)^2)*e[-1]*G(xi)

  

phi[7] = 8*e[-1]*((1/4)*(V*a[2]-a[1])*(diff(G(xi), xi))^4+(V*a[2]-a[1])*(m*mu+(1/2)*lambda)*G(xi)*(diff(G(xi), xi))^3+(V*a[2]-a[1])*((m*mu+(1/2)*lambda)^2*G(xi)+(1/2)*mu)*G(xi)*(diff(G(xi), xi))^2+(V*a[2]-a[1])*(m*mu+(1/2)*lambda)*mu*G(xi)^2*(diff(G(xi), xi))+(1/4)*(-(1/2)*((-gamma+sigma)*k+b)*e[-1]^2*G(xi)^2+mu^2*(V*a[2]-a[1]))*G(xi)^2)

 (16)
> 

# WATCHOUT: you have 9 coefficients and so its desirable to have the same number of unknowns

unknowns := indets(rhs~(phis), {e[-1],e[0],e[1],'identical'(mu),'identical'(lambda),'identical'(a[1]),'identical'(alpha)});

COEFFS := solve(rhs~(phis), unknowns)

{alpha, lambda, mu, a[1], e[-1], e[0], e[1]}

  

{alpha = alpha, lambda = lambda, mu = mu, a[1] = a[1], e[-1] = 0, e[0] = 0, e[1] = 0}, {alpha = alpha, lambda = lambda, mu = mu, a[1] = -(gamma*k*e[0]^2-k*sigma*e[0]^2-b*e[0]^2-k*w*a[2]+alpha*k+w)/k^2, e[-1] = 0, e[0] = e[0], e[1] = 0}, {alpha = (1/2)*(-G(xi)^4*gamma*k^3*e[-1]^2+G(xi)^4*k^3*sigma*e[-1]^2-4*G(xi)^2*(diff(G(xi), xi))*V*k^2*m*mu^2*a[2]+4*G(xi)*(diff(G(xi), xi))^3*V*k^2*m*mu*a[2]+G(xi)^4*b*k^2*e[-1]^2+4*G(xi)^2*(diff(G(xi), xi))*k*m*mu^2*w*a[2]-4*G(xi)*(diff(G(xi), xi))^3*k*m*mu*w*a[2]-2*G(xi)^2*V*k^2*mu^2*a[2]+2*G(xi)*(diff(G(xi), xi))^2*V*k^2*mu*a[2]-2*G(xi)*(diff(G(xi), xi))*RootOf(4*m^2*mu^2*(diff(G(xi), xi))*G(xi)^2+2*m*mu^2*G(xi)^2+6*m*mu*(diff(G(xi), xi))^2*G(xi)+3*mu*(diff(G(xi), xi))*G(xi)+2*(diff(G(xi), xi))^3+(4*m*mu*(diff(G(xi), xi))*G(xi)+mu*G(xi)+3*(diff(G(xi), xi))^2)*_Z+(diff(G(xi), xi))*_Z^2)*V*k^2*mu*a[2]+2*(diff(G(xi), xi))^4*V*k^2*a[2]+2*(diff(G(xi), xi))^3*RootOf(4*m^2*mu^2*(diff(G(xi), xi))*G(xi)^2+2*m*mu^2*G(xi)^2+6*m*mu*(diff(G(xi), xi))^2*G(xi)+3*mu*(diff(G(xi), xi))*G(xi)+2*(diff(G(xi), xi))^3+(4*m*mu*(diff(G(xi), xi))*G(xi)+mu*G(xi)+3*(diff(G(xi), xi))^2)*_Z+(diff(G(xi), xi))*_Z^2)*V*k^2*a[2]-4*G(xi)^2*(diff(G(xi), xi))*m*mu^2*w+2*G(xi)^2*k*mu^2*w*a[2]+4*G(xi)*(diff(G(xi), xi))^3*m*mu*w-2*G(xi)*(diff(G(xi), xi))^2*k*mu*w*a[2]+2*G(xi)*(diff(G(xi), xi))*RootOf(4*m^2*mu^2*(diff(G(xi), xi))*G(xi)^2+2*m*mu^2*G(xi)^2+6*m*mu*(diff(G(xi), xi))^2*G(xi)+3*mu*(diff(G(xi), xi))*G(xi)+2*(diff(G(xi), xi))^3+(4*m*mu*(diff(G(xi), xi))*G(xi)+mu*G(xi)+3*(diff(G(xi), xi))^2)*_Z+(diff(G(xi), xi))*_Z^2)*k*mu*w*a[2]-2*(diff(G(xi), xi))^4*k*w*a[2]-2*(diff(G(xi), xi))^3*RootOf(4*m^2*mu^2*(diff(G(xi), xi))*G(xi)^2+2*m*mu^2*G(xi)^2+6*m*mu*(diff(G(xi), xi))^2*G(xi)+3*mu*(diff(G(xi), xi))*G(xi)+2*(diff(G(xi), xi))^3+(4*m*mu*(diff(G(xi), xi))*G(xi)+mu*G(xi)+3*(diff(G(xi), xi))^2)*_Z+(diff(G(xi), xi))*_Z^2)*k*w*a[2]-2*G(xi)^2*mu^2*w+2*G(xi)*(diff(G(xi), xi))^2*mu*w-2*G(xi)*(diff(G(xi), xi))*RootOf(4*m^2*mu^2*(diff(G(xi), xi))*G(xi)^2+2*m*mu^2*G(xi)^2+6*m*mu*(diff(G(xi), xi))^2*G(xi)+3*mu*(diff(G(xi), xi))*G(xi)+2*(diff(G(xi), xi))^3+(4*m*mu*(diff(G(xi), xi))*G(xi)+mu*G(xi)+3*(diff(G(xi), xi))^2)*_Z+(diff(G(xi), xi))*_Z^2)*mu*w+2*(diff(G(xi), xi))^4*w+2*(diff(G(xi), xi))^3*RootOf(4*m^2*mu^2*(diff(G(xi), xi))*G(xi)^2+2*m*mu^2*G(xi)^2+6*m*mu*(diff(G(xi), xi))^2*G(xi)+3*mu*(diff(G(xi), xi))*G(xi)+2*(diff(G(xi), xi))^3+(4*m*mu*(diff(G(xi), xi))*G(xi)+mu*G(xi)+3*(diff(G(xi), xi))^2)*_Z+(diff(G(xi), xi))*_Z^2)*w)/((2*m*mu^2*(diff(G(xi), xi))*G(xi)^2-2*m*mu*(diff(G(xi), xi))^3*G(xi)+mu*(diff(G(xi), xi))*G(xi)*RootOf(4*m^2*mu^2*(diff(G(xi), xi))*G(xi)^2+2*m*mu^2*G(xi)^2+6*m*mu*(diff(G(xi), xi))^2*G(xi)+3*mu*(diff(G(xi), xi))*G(xi)+2*(diff(G(xi), xi))^3+(4*m*mu*(diff(G(xi), xi))*G(xi)+mu*G(xi)+3*(diff(G(xi), xi))^2)*_Z+(diff(G(xi), xi))*_Z^2)-(diff(G(xi), xi))^3*RootOf(4*m^2*mu^2*(diff(G(xi), xi))*G(xi)^2+2*m*mu^2*G(xi)^2+6*m*mu*(diff(G(xi), xi))^2*G(xi)+3*mu*(diff(G(xi), xi))*G(xi)+2*(diff(G(xi), xi))^3+(4*m*mu*(diff(G(xi), xi))*G(xi)+mu*G(xi)+3*(diff(G(xi), xi))^2)*_Z+(diff(G(xi), xi))*_Z^2)+mu^2*G(xi)^2-mu*(diff(G(xi), xi))^2*G(xi)-(diff(G(xi), xi))^4)*k), lambda = RootOf(4*m^2*mu^2*(diff(G(xi), xi))*G(xi)^2+2*m*mu^2*G(xi)^2+6*m*mu*(diff(G(xi), xi))^2*G(xi)+3*mu*(diff(G(xi), xi))*G(xi)+2*(diff(G(xi), xi))^3+(4*m*mu*(diff(G(xi), xi))*G(xi)+mu*G(xi)+3*(diff(G(xi), xi))^2)*_Z+(diff(G(xi), xi))*_Z^2)/G(xi), mu = mu, a[1] = -(1/2)*(-G(xi)^4*gamma*k*e[-1]^2+G(xi)^4*k*sigma*e[-1]^2-4*G(xi)^2*(diff(G(xi), xi))*V*m*mu^2*a[2]+4*G(xi)*(diff(G(xi), xi))^3*V*m*mu*a[2]+G(xi)^4*b*e[-1]^2-2*G(xi)^2*V*mu^2*a[2]+2*G(xi)*(diff(G(xi), xi))^2*V*mu*a[2]-2*mu*G(xi)*(diff(G(xi), xi))*V*RootOf(4*m^2*mu^2*(diff(G(xi), xi))*G(xi)^2+2*m*mu^2*G(xi)^2+6*m*mu*(diff(G(xi), xi))^2*G(xi)+3*mu*(diff(G(xi), xi))*G(xi)+2*(diff(G(xi), xi))^3+(4*m*mu*(diff(G(xi), xi))*G(xi)+mu*G(xi)+3*(diff(G(xi), xi))^2)*_Z+(diff(G(xi), xi))*_Z^2)*a[2]+2*(diff(G(xi), xi))^4*V*a[2]+2*(diff(G(xi), xi))^3*V*RootOf(4*m^2*mu^2*(diff(G(xi), xi))*G(xi)^2+2*m*mu^2*G(xi)^2+6*m*mu*(diff(G(xi), xi))^2*G(xi)+3*mu*(diff(G(xi), xi))*G(xi)+2*(diff(G(xi), xi))^3+(4*m*mu*(diff(G(xi), xi))*G(xi)+mu*G(xi)+3*(diff(G(xi), xi))^2)*_Z+(diff(G(xi), xi))*_Z^2)*a[2])/(2*m*mu^2*(diff(G(xi), xi))*G(xi)^2-2*m*mu*(diff(G(xi), xi))^3*G(xi)+mu*(diff(G(xi), xi))*G(xi)*RootOf(4*m^2*mu^2*(diff(G(xi), xi))*G(xi)^2+2*m*mu^2*G(xi)^2+6*m*mu*(diff(G(xi), xi))^2*G(xi)+3*mu*(diff(G(xi), xi))*G(xi)+2*(diff(G(xi), xi))^3+(4*m*mu*(diff(G(xi), xi))*G(xi)+mu*G(xi)+3*(diff(G(xi), xi))^2)*_Z+(diff(G(xi), xi))*_Z^2)-(diff(G(xi), xi))^3*RootOf(4*m^2*mu^2*(diff(G(xi), xi))*G(xi)^2+2*m*mu^2*G(xi)^2+6*m*mu*(diff(G(xi), xi))^2*G(xi)+3*mu*(diff(G(xi), xi))*G(xi)+2*(diff(G(xi), xi))^3+(4*m*mu*(diff(G(xi), xi))*G(xi)+mu*G(xi)+3*(diff(G(xi), xi))^2)*_Z+(diff(G(xi), xi))*_Z^2)+mu^2*G(xi)^2-mu*(diff(G(xi), xi))^2*G(xi)-(diff(G(xi), xi))^4), e[-1] = e[-1], e[0] = 0, e[1] = 0}

 (17)
> 

case1 := COEFFS[2]

{alpha = alpha, lambda = lambda, mu = mu, a[1] = -(gamma*k*e[0]^2-k*sigma*e[0]^2-b*e[0]^2-k*w*a[2]+alpha*k+w)/k^2, e[-1] = 0, e[0] = e[0], e[1] = 0}

 (18)
> 

NULL
> 

F1 := subs(case1, F)

e[0]

 (19)
> 

F2 := subs(case1, ode)

(-a[2]*V-(gamma*k*e[0]^2-k*sigma*e[0]^2-b*e[0]^2-k*w*a[2]+alpha*k+w)/k^2)*(diff(diff(U(xi), xi), xi))+U(xi)*(((-gamma+sigma)*k+b)*U(xi)^2+k*e[0]^2*gamma-k*e[0]^2*sigma-b*e[0]^2-k*w*a[2]+k*alpha+(w*a[2]-alpha)*k) = 0

 (20)
> 

W := U(xi) = F1

U(xi) = e[0]

 (21)
> 

NULL
> 

E := diff(G(xi), xi) = -(-2*m*mu-lambda)*exp(-(2*m*mu+lambda)*xi)*c__1/(2*m*mu+lambda)-mu/(2*m*mu+lambda)

diff(G(xi), xi) = -(-2*m*mu-lambda)*exp(-(2*m*mu+lambda)*xi)*c__1/(2*m*mu+lambda)-mu/(2*m*mu+lambda)

 (22)
> 

W1 := subs(E, W)

U(xi) = e[0]

 (23)
> 

W2 := subs(case1, W1)

U(xi) = e[0]

 (24)
> 

W3 := rhs(U(xi) = e[0])

e[0]

 (25)
> 

W4 := convert(W3, trig)

e[0]

 (26)
> 

W5 := W4

e[0]

 (27)
> 

odetest(W2, F2)

0

 (28)

Download G-factoring.mw

bug report. convert(..,y_x) converts non equation ...

Asked by: nm 10411
differential-equations convert
January 05 2025
1  0

I found that convert(ode,y_x) converts the input ode, when it is NOT an equation, to an equation.  

sometimes and sometimes not.

For example,  convert(diff(y(t),t)+y(t)-t,y_x)  gives diff(t(y), y) = 1/(t(y) - y) 

Notice the input is not an equation. Maple adds = and makes an equation in the output. 

This can cause no problem if it works like this in all cases. But if the input has piecewise, then Maple no longer does the same and keep the output as not an equation.

I found this by accident, as my code was doing lhs() on the result of convert, and that always worked, except when I used an ode with piecewise.

This behaviour is not consistent. Maple should either always convert output to equation for all input or not convert. It should not do it for some input and not the other.

Actually, the best behaviour is for the software to reject the input in first place if it is not an equation.

Worksheet below.

> 

interface(version);

`Standard Worksheet Interface, Maple 2024.2, Windows 10, October 29 2024 Build ID 1872373`

> 

Physics:-Version();

`The "Physics Updates" version in the MapleCloud is 1841 and is the same as the version installed in this computer, created 2025, January 3, 8:59 hours Pacific Time.`

> 

libname;

"C:\Users\Owner\maple\toolbox\2024\Physics Updates\lib", "C:\Program Files\Maple 2024\lib"

> 

#this works even when there is no equation in input, but the result is equation
ode:=diff(y(t),t)+y(t)-t;
convert(ode,y_x,y(t))

diff(y(t), t)+y(t)-t

diff(t(y), y) = 1/(t(y)-y)

> 

ode:=diff(y(t),t)+y(t)-t=0; #this gives same result as above.
convert(ode,y_x,y(t))

diff(y(t), t)+y(t)-t = 0

diff(t(y), y) = 1/(t(y)-y)

> 

#but now if the input is not equation, the output is not equation. Why
#did it not do the same as above??
ode:=diff(y(t),t)+y(t)-piecewise(0<=t and t<=1,2,t>1,0);
convert(ode,y_x,y(t))

ode := diff(y(t), t)+y(t)-piecewise(0 <= t and t <= 1, 2, 1 < t, 0)

1/(diff(t(y), y))+y-piecewise(0 <= t(y) and t(y) <= 1, 2, 1 < t(y), 0)

 

 

Download strange_behaviour_of_convert_yx_jan_5_20225.mw

system of 1-D PDEs numerically...

Asked by: mayzal 25
pde numeric pdsolve
January 05 2025
1  8

I’m trying to solve a stiff system 1-D PDEs numerically in Maple but I’m getting the following error:

“Error, (in pdsolve/numeric/match_PDEs_BCs) cannot handle systems with multiple PDE describing the time dependence of the same dependent variable, or having no time dependence”

I included a picture of the PDEs and their BCs in the attached maple file. For easy reading, the attached file includes highlighted sections for parameters and variables. You can skip those to PDEs, BCs and ICs sections at the end of the document to reach the error I’m facing.

For reference, I used another software to solve the system and I was able to get the results in few seconds, so I think it is solvable. However, personally I prefer to use Maple so any inputs, insights, workarounds that I could use to handle the system in Maple would be of great help to me. Thank you.

question.mw

`System error, `, "bad id"...

Asked by: jasser 70
programming recursion
January 02 2025
1  4

Hello

I programmed a sequence a(n). Up to a(42) Maple had no problem to calculate the term, but when calculating a(43), after a while appears the message

`System error, `, "bad id"

What does that mean and what can I do?
Thank you.

How to find greek symbols in 2D Math...

Asked by: C_R 2952
gui greek 2d-output
January 02 2025
2  4

Using edit -> Find/Replace (or crtl-f) it is possible to earch for text composed of alpha numeric-characters. Maple finds all occurences in input an output.

For greek letters this works only for 1D Math input. Is there a way to find/search for greek symbols displayed on the GUI in 2D Math input and output like lambda in the below

?

split screen in maple...

Asked by: Christopher2222 5860
windows gui user-interface
December 30 2024
1  6

This is probaby more of a software request and I think it would be useful. 

You can obviously open two worksheets of maple and tile them vertically to give the effect of a split screen but then all the icons of each worksheet reduce the visible on screen real estate in which you can work.

It should work similar to how Excel does it when you split cells.  It would work nicely in situations where you have a diagram or picture you are referring to during the creation of your worksheet. 

Anyways just a request, I'm sure some people would find that functionality welcome. 

Bug report: Error, (in dsolve) invalid subscript s...

Asked by: nm 10411
ode dsolve differential-equations
December 27 2024
0  2

I do not remember if I reported this before or not. Can't find it. Just in case, I am posting this.

If someone find it is duplicate, feel free to delete this. But this is in latest Maple 2024.2. May be this can be fixed in time by Maple 2025 version.

> 

restart;
> 

interface(version);

`Standard Worksheet Interface, Maple 2024.2, Windows 10, October 29 2024 Build ID 1872373`

> 

Physics:-Version();

`The "Physics Updates" version in the MapleCloud is 1840 and is the same as the version installed in this computer, created 2024, December 2, 10:11 hours Pacific Time.`

> 

libname;

"C:\Users\Owner\maple\toolbox\2024\Physics Updates\lib", "C:\Program Files\Maple 2024\lib"

> 

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

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

> 

DEtools:-odeadvisor(ode);

[_rational]

> 

dsolve(ode,y(x));

Error, (in dsolve) invalid subscript selector

> 

restart;
> 

infolevel[dsolve]:=5;

5

> 

ode := diff(y(x),x)/y(x)-(3*(4*x^2+y(x)^2+1))/(2*x*(4*x^2+y(x)^2-2-2*x))=0:
> 

dsolve(ode,y(x));

Methods for first order ODEs:

--- Trying classification methods ---

trying a quadrature

trying 1st order linear

trying Bernoulli

trying separable

trying inverse linear

trying homogeneous types:

trying Chini

differential order: 1; looking for linear symmetries

trying exact

Looking for potential symmetries

trying inverse_Riccati

trying an equivalence to an Abel ODE

equivalence obtained to this Abel ODE: diff(y(x),x) = 3/2*(4*x^2+1)/x/(2*x^2-x-1)*y(x)-(x^2+2*x+3)/x/(2*x^2-x-1)^2*y(x)^2+3/8*(2*x+3)/(2*x^2-x-1)^3/x*y(x)^3

trying to solve the Abel ODE ...

The relative invariant s3 is: -1/432*(8*x^4+40*x^3+45*x^2-270*x+135)/x^3/(x-1)^6/(2*x+1)^4

The first absolute invariant s5^3/s3^5 is: 729/16*(128*x^8+1152*x^7+3696*x^6+1744*x^5+8148*x^4-31500*x^3+6615*x^2-5670*x+8505)^3/(2*x+1)^4/(8*x^4+40*x^3+45*x^2-270*x+135)^5

The second absolute invariant s3*s7/s5^2 is: 1/3*(8*x^4+40*x^3+45*x^2-270*x+135)*(10240*x^12+133120*x^11+697600*x^10+1710080*x^9+3358592*x^8-1701568*x^7+6692592*x^6-18182448*x^5+2088072*x^4-7938000*x^3+2525985*x^2+1786050*x+2679075)/(128*x^8+1152*x^7+3696*x^6+1744*x^5+8148*x^4-31500*x^3+6615*x^2-5670*x+8505)^2

...checking Abel class AIL (45)

...checking Abel class AIL (310)

...checking Abel class AIR (36)

...checking Abel class AIL (301)

...checking Abel class AIL (1000)

...checking Abel class AIL (42)

...checking Abel class AIL (185)

...checking Abel class AIA (by Halphen)

...checking Abel class AIL (205)

...checking Abel class AIA (147)

...checking Abel class AIL (581)

...checking Abel class AIL (200)

...checking Abel class AIL (257)

...checking Abel class AIL (400)

...checking Abel class AIA (515)

...checking Abel class AIR (1001)

...checking Abel class AIA (201)

...checking Abel class AIA (815)

Looking for potential symmetries

... changing x -> 1/x, trying again

Looking for potential symmetries

The third absolute invariant s5*s7/s3^4 is: 243/16*(10240*x^12+133120*x^11+697600*x^10+1710080*x^9+3358592*x^8-1701568*x^7+6692592*x^6-18182448*x^5+2088072*x^4-7938000*x^3+2525985*x^2+1786050*x+2679075)/(2*x+1)^4*(128*x^8+1152*x^7+3696*x^6+1744*x^5+8148*x^4-31500*x^3+6615*x^2-5670*x+8505)/(8*x^4+40*x^3+45*x^2-270*x+135)^4

 ->         ======================================

 ->             ...checking Abel class D (by Appell)

 -> Step 1: checking for a disqualifying factor on F after evaluating x at a number

Trying x = 2

*** No disqualifying factor on F was found ***

 -> Step 2: calculating resultants to eliminate F and get candidates for C

*** Candidates for C are {4/27} ***

 -> Step 3: looking for a solution F depending on x

*** No solution F of x was found ***

 ->         ======================================

 ->             ...checking Abel class B (by Liouville)

 -> Step 1: checking for a disqualifying factor on F after evaluating x at a number

Trying x = 2

*** No disqualifying factor on F was found ***

 -> Step 2: calculating resultants to eliminate F and get candidates for C

*** Candidates for C are {1, 4, 1/4} ***

 -> Step 3: looking for a solution F depending on x

*** No solution F of x was found ***

 ->         ======================================

 ->             ...checking Abel class A (by Abel)

 -> Step 1: checking for a disqualifying factor on F after evaluating x at a number

Trying x = 2

*** No disqualifying factor on F was found ***

 -> Step 2: calculating resultants to eliminate F and get candidates for C

*** Candidates for C are {0, -1/4} ***

 -> Step 3: looking for a solution F depending on x

*** No solution F of x was found ***

 ->         ======================================

 ->             ...checking Abel class C (by Abel)

 -> Step 1: checking for a disqualifying factor on F after evaluating x at a number

Trying x = 2

*** No disqualifying factor on F was found ***

 -> Step 2: calculating resultants to eliminate F and get candidates for C

*** Candidates for C are {2, -11676447873119/75975070592769, 9/5, 15632211369872/75439744512117, 46273613050865/52325357771027, 75312059745574/25138886548531} ***

 -> Step 3: looking for a solution F depending on x

_____________________________

C = 9/5 leads to a useless solution (F does not depend on x)

*** No solution F of x was found ***

 ->         ======================================

 ->             ...checking Abel class AIL 1.6

 -> Step 1: checking for a disqualifying factor on F after evaluating x at a number

Trying x = 2

*** No disqualifying factor on F was found ***

 -> Step 2: calculating resultants to eliminate F and get candidates for C

*** Candidates for C are {-4, 16} ***

 -> Step 3: looking for a solution F depending on x

*** No solution F of x was found ***

 ->         ======================================

 ->             ...checking Abel class AIL 1.8

 -> Step 1: checking for a disqualifying factor on F after evaluating x at a number

Trying x = 2

*** No disqualifying factor on F was found ***

 -> Step 2: calculating resultants to eliminate F and get candidates for C

*** Candidates for C are {0, -116457391291688/45108305127449, -96869842492381/35485755507516, -36964550865207/94238117721032, -32286830321303/11596568583712, 32286830321303/11596568583712, 36964550865207/94238117721032, 96869842492381/35485755507516, 116457391291688/45108305127449} ***

 -> Step 3: looking for a solution F depending on x

*** No solution F of x was found ***

 ->         ======================================

 ->             ...checking Abel class AIL 1.9

 -> Step 1: checking for a disqualifying factor on F after evaluating x at a number

Trying x = 2

*** No disqualifying factor on F was found ***

 -> Step 2: calculating resultants to eliminate F and get candidates for C

*** Candidates for C are {-2/9, -1/9} ***

 -> Step 3: looking for a solution F depending on x

*** No solution F of x was found ***

 ->         ======================================

 ->             ...checking Abel class AIA 1.51

 -> Step 1: checking for a disqualifying factor on F after evaluating x at a number

Trying x = 2

*** No disqualifying factor on F was found ***

 -> Step 2: calculating resultants to eliminate F and get candidates for C

*** Candidates for C are {0, -94917840318055/84247876515289, -85939756880989/51399391393709, -82210125508529/36853933366676, -74381886667083/82545981233858, -41168492684238/33804146399567, -15658703496425/19275443365317, -9175348901453/101481647952193, 3/4, 15/4, 5568553686203/113599855351490, 12774469621703/63437040534358, 17836021821409/102823494563886, 39657708622139/74009717243016, 82495450887526/27663991325651, 86656182727564/45157560524183, 90074893410229/54954593917906, 100200889070747/32282555481919, 113612565327585/103754255779069} ***

 -> Step 3: looking for a solution F depending on x

_____________________________

C = 15/4 leads to a useless solution (F does not depend on x)

*** No solution F of x was found ***

 ->         ======================================

 ->             ...checking Abel class AIA 1.5

 -> Step 1: checking for a disqualifying factor on F after evaluating x at a number

Trying x = 2

*** No disqualifying factor on F was found ***

 -> Step 2: calculating resultants to eliminate F and get candidates for C

*** Candidates for C are {-1, 1, -113553630998996/78694251194667, -112790344818825/35834119404842, -104905620984375/18860524785743, -95409943222181/78810323073434, -77648002983645/31218435062578, -67259194033608/9576982470445, -46892223838816/86694928762723, -45901561561111/29768419326991, -34674701564566/6522678435631, 26154715634141/21099761863911, 42841215778132/81925179545457, 52638927823233/15127919203723, 54069389554571/5444364811188, 54445812264368/10328928623117, 56815569067370/40738034746481, 75614540760757/62881656939350, 76459718737483/64786816765621, 85896394925571/88677987470966, 90623073438172/24246571690325, 103628692054633/17857341616628, 117754725919014/60191028908095} ***

 -> Step 3: looking for a solution F depending on x

_____________________________

C = -1 leads to a useless solution (F does not depend on x)

_____________________________

C = -113553630998996/78694251194667 leads to a useless solution (F does not depend on x)

_____________________________

C = -112790344818825/35834119404842 leads to a useless solution (F does not depend on x)

_____________________________

C = -104905620984375/18860524785743 leads to a useless solution (F does not depend on x)

_____________________________

C = -95409943222181/78810323073434 leads to a useless solution (F does not depend on x)

_____________________________

C = -77648002983645/31218435062578 leads to a useless solution (F does not depend on x)

_____________________________

C = -67259194033608/9576982470445 leads to a useless solution (F does not depend on x)

_____________________________

C = -46892223838816/86694928762723 leads to a useless solution (F does not depend on x)

_____________________________

C = -45901561561111/29768419326991 leads to a useless solution (F does not depend on x)

_____________________________

C = -34674701564566/6522678435631 leads to a useless solution (F does not depend on x)

_____________________________

C = 26154715634141/21099761863911 leads to a useless solution (F does not depend on x)

_____________________________

C = 42841215778132/81925179545457 leads to a useless solution (F does not depend on x)

_____________________________

C = 52638927823233/15127919203723 leads to a useless solution (F does not depend on x)

_____________________________

C = 54069389554571/5444364811188 leads to a useless solution (F does not depend on x)

_____________________________

C = 54445812264368/10328928623117 leads to a useless solution (F does not depend on x)

_____________________________

C = 56815569067370/40738034746481 leads to a useless solution (F does not depend on x)

_____________________________

C = 75614540760757/62881656939350 leads to a useless solution (F does not depend on x)

_____________________________

C = 76459718737483/64786816765621 leads to a useless solution (F does not depend on x)

_____________________________

C = 85896394925571/88677987470966 leads to a useless solution (F does not depend on x)

_____________________________

C = 90623073438172/24246571690325 leads to a useless solution (F does not depend on x)

_____________________________

C = 103628692054633/17857341616628 leads to a useless solution (F does not depend on x)

_____________________________

C = 117754725919014/60191028908095 leads to a useless solution (F does not depend on x)

*** No solution F of x was found ***

 ->         ======================================

 ->             ...checking Abel class AIA 1.52

 -> Step 1: checking for a disqualifying factor on F after evaluating x at a number

Trying x = 2

*** No disqualifying factor on F was found ***

 -> Step 2: calculating resultants to eliminate F and get candidates for C

*** Candidates for C are {-5, -4, -3, 0, 1, 2, -3/2} ***

 -> Step 3: looking for a solution F depending on x

*** No solution F of x was found ***

 ->         ======================================

 ->             ...checking Abel class AIA 1.53

 -> Step 1: checking for a disqualifying factor on F after evaluating x at a number

Trying x = 2

*** No disqualifying factor on F was found ***

 -> Step 2: calculating resultants to eliminate F and get candidates for C

*** Candidates for C are {-3, -1, 1, 2, -3/2, -2/3, -1/2} ***

 -> Step 3: looking for a solution F depending on x

_____________________________

C = -3 leads to a useless solution (F does not depend on x)

_____________________________

C = -3/2 leads to a useless solution (F does not depend on x)

*** No solution F of x was found ***

trying to map the Abel into a solvable 2nd order ODE

...checking Abel class AIA 2-parameter, reducible to Riccati

Error, (in dsolve) invalid subscript selector

> 

restart;
> 

ode := diff(y(x),x)/y(x)-(3*(4*x^2+y(x)^2+1))/(2*x*(4*x^2+y(x)^2-2-2*x))=0:
> 

dsolve(ode,y(x));

Error, (in dsolve) invalid subscript selector

> 

tracelast;

Error, (in dsolve) invalid subscript selector

 

 

Download dsolve_invalid_subscript_dec_27_2024.mw

Trouble Using Export Function in mpl Script...

Asked by: JoyDivisionMan 5
export mpl
December 27 2024
0  1

I am doing some work in Maple.  Specifically, I run the following commands in Maple worksheet mode:

with(Statistics);
L := abs(RandomVariable(UniformDistribution(0, 1)) - RandomVariable(UniformDistribution(0, 1)));
Export("LineDensity.jpg", DensityPlot(L));
PDF(L, x);

Everything works fine.  When I export these commands into an MPL script, I get the following:

with(Statistics);
L := abs(RandomVariable(UniformDistribution(0, 1)) - RandomVariable(UniformDistribution(0, 1)));
Export("LineDensity.jpg", DensityPlot(L));
PDF(L, x);
NULL;

When I execute this script, I get the following error message:

Warning: persistent store makes readlib obsolete
Error: (in Export) exported file LineDensity.jpg could not be created

I need to do the work in MPL script form so that I can have larger problems processed.  Does anyone know why I would be having this problem with the Export function?  

why taking double derivative with two different in...

Asked by: salim-barzani 185
differentiation physics
December 27 2024
0  6

I did a lot  of time but this time i don't know why not run any one have idea?

> 

restart
> 

with(PDEtools)
> 

with(LinearAlgebra)
> 

with(Physics)
> 

with(SolveTools)
> 

undeclare(prime)

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

 (1)
> 

declare(u(x, t)); declare(U(xi)); declare(G(xi))

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

  

U(xi)*`will now be displayed as`*U

  

G(xi)*`will now be displayed as`*G

 (2)
> 

T := xi = -V*t+x; T1 := u(x, t) = U(-V*t+x)*exp(I*(-k*x+t*w+theta))

xi = -V*t+x

  

u(x, t) = U(-V*t+x)*exp(I*(-k*x+t*w+theta))

 (3)
> 

P3 := diff(u(x, t), x, t)

``

 (4)
> 

P33 := diff(u(x, t), x)

diff(u(x, t), x)

 (5)
> 

P333 := diff(P33, t)
> 

NULL

Download why.mw

Error, (in dsolve) type `System` does not exist wh...

Asked by: nm 10411
dsolve threads parallelization
December 26 2024
1  4

I am trying to see if I can get speed up by using dsolve inside thread.

I made very simple example of global list of two differential equations to start with.

Next, created two threads where each picks one ode from the global list to process. So they should in theory run in parallel. The list of ode's is a global list in the worksheet for now.

But I keep getting error when calling dsolve 

               Error, (in dsolve) type `System` does not exist

I tried also passing the actual ode to the thread, still, same error.

Next, I did not pass anything, but called dsolve directly from inside thread proc on same ode. The ode is local variable inside the proc. I still get same error.

                        Does this mean dsolve is not supported by threads? 

But when I searched this subject, AI says it works in threads:

 

Everything works OK when I run dsolve in worksheet outside thread (i.e. normally).

I will show below worksheet showing these cases. I must not be doing something right. But what? Can one not pass data from global worksheet to the thread this way? Or does one needs to load something in each thread to make this work?

> 

interface(version);

`Standard Worksheet Interface, Maple 2024.2, Windows 10, October 29 2024 Build ID 1872373`

> 

Physics:-Version();

`The "Physics Updates" version in the MapleCloud is 1840 and is the same as the version installed in this computer, created 2024, December 2, 10:11 hours Pacific Time.`

> 

libname;

"C:\Users\Owner\maple\toolbox\2024\Physics Updates\lib", "C:\Program Files\Maple 2024\lib"

Example 1. Passing index of list to thread

 
> 

restart;

> 

g_list:=[sin(t)*diff(x(t),t$2)+cos(t)*diff(x(t),t)+2*x(t)=0,
         diff(y(x),x)=lambda*sin(lambda*x)*y(x)^2+a*cos(lambda*x)^n*y(x)-a*cos(lambda*x)^(n-1)]:

> 

work_func:=proc(i::posint)  
  :-dsolve(g_list[i]):
end proc:

> 

Threads:-Wait(  seq( Threads:-Create( work_func(i)), i=1..2) );

Error, (in dsolve) type `System` does not exist

Example 2. Passing actual ode itself to thread

 
> 

restart;

> 

g_list:=[sin(t)*diff(x(t),t$2)+cos(t)*diff(x(t),t)+2*x(t)=0,
         diff(y(x),x)=lambda*sin(lambda*x)*y(x)^2+a*cos(lambda*x)^n*y(x)-a*cos(lambda*x)^(n-1)]:

> 

work_func:=proc(ode::`=`)  
  :-dsolve(ode):
end proc:

> 

Threads:-Wait(  seq( Threads:-Create( work_func(g_list[i])), i=1..2) );

Error, (in dsolve) type `System` does not exist

> 

 

Example 3. Normal processing. No threads

 
> 

restart;

> 

g_list:=[sin(t)*diff(x(t),t$2)+cos(t)*diff(x(t),t)+2*x(t)=0,
         diff(y(x),x)=lambda*sin(lambda*x)*y(x)^2+a*cos(lambda*x)^n*y(x)-a*cos(lambda*x)^(n-1)]:

> 

work_func:=proc(ode::`=`)  
  :-dsolve(ode):
end proc:

> 

for item in g_list do
    work_func(item);
od:

> 

#no error

> 

 

Example 4. do not pass anything. Just call dsolve

 
> 

restart;

> 

work_func:=proc(i::posint)  
  local x,t;
  local ode:=sin(t)*diff(x(t),t$2)+cos(t)*diff(x(t),t)+2*x(t)=0;
  :-dsolve(ode):
end proc:

> 

Threads:-Wait(  seq( Threads:-Create( work_func(i)), i=1..2) );

Error, (in dsolve) type `System` does not exist

> 

 

 

 

Download error_dsolve_using_threads_dec_26_2024.mw

1 2 3 4 5 6 7 Last Page 1 of 2175