Advanced Search

MaplePrimes Questions

Odegenerator plots ...

Asked by: janhardo 690
ode explore differential-equations
January 14 2025
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;
    uses plots, 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 := DEtools[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 := DEtools[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), odeadvisor(diff(y(t), t) = a__0*sin(t)+a__1*y(t)+a__2*y(t)^2+b__0*exp(-t))

  

diff(y(t), t) = sin(t)+y(t), odeadvisor(diff(y(t), t) = a__0*sin(t)+a__1*y(t)+a__2*y(t)^2+b__0*exp(-t)), [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), odeadvisor(diff(y(t), t) = a__0*sin(t)+a__1*y(t)+a__2*y(t)^2+b__0*exp(-t))

  

 

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), odeadvisor(diff(y(t), t) = a__0*sin(t)+a__1*y(t)+a__2*y(t)^2+b__0*exp(-t))

  

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

 (3)
 

 

> 

 


Download ODEGENERATORFUNCTIE_opgepakt-uitgebreid_naar_MprimesDEF_14-1-2025.mw

How do I generate a plot within a plot? ...

Asked by: nmacsai 260
plotting
January 13 2025
2  3

How do I generate a plot within a plot as shown in my example below? The fundemental issue is plot structures like Histogram() etc are not images and so combining them in the way I imagine is non-trivial. I couldn't find a standard way to do this in the help section.

Plot_within_a_plot.mw

restart

NULL``

with(plots)

NULL

Consider the two plots p1 and p2.

NULL

p1 := plot(sin(x), size = [300, 300])

  

p2 := plot(sin(x), view = [0 .. Pi, .5 .. 1], size = [300, 300], axes = boxed)

  

NULL

How do I generate a plot within a plot as shown below, if I calculated the plots ahead of time? Is there a standard way to do this?

NULL

NULL

NULL

Download Plot_within_a_plot.mw

How do i get the distance and midpoint in maple?...

Asked by: paulmcquad 105
geometry homework midpoint
January 13 2025
0  3

Is there an easy way to get the midpoint and distance in maple?

Thanks in advance.

Distance and Midpoint

 

 

Table 1: Key Skills

NULLdmf1 := [-3, 1]

[-3, 1]

 (1)

dmf2 := [3, 2]

[3, 2]

 (2)

dmf3 := [-2, -3]

[-2, -3]

 (3)

dmf4 := [3, -2]

[3, -2]

 (4)

dmf := [dmf1, dmf2, dmf3, dmf4]

[[-3, 1], [3, 2], [-2, -3], [3, -2]]

 (5)

plot(dmf)

  

NULL

dme1a1 := [1, 3]

[1, 3]``

 (6)

dme1a2 := [5, 6]

[5, 6]

 (7)

dme1a3 := [5, 3]

[5, 3]

 (8)

dme1 := [dme1a1, dme1a2, dme1a3]

[[1, 3], [5, 6], [5, 3]]

 (9)

plot(dme1)

  

NULL

``

NULL

NULL

NULL

NULL

NULL

NULL

NULL

Download 2.1-Distance_and_Midpoint.mw

How to solve a system of equations involving parti...

Asked by: Hamza Rafiq 30
homework pde pdsolve
January 13 2025
2  7

Hello everyone, I am facing problem to solve a system of partial differential equations of f, g & q in three variables x,y,t. I have attached the maple file and also a page that i am exploring, in attcahed page I need to find results given in (7) and (8). Maple file is also attached below, please help me to solve this system of PDEs for required results given in (7) and (8). Thanks
 


 

Download PDEs_system_solution.mw

> 

restart
> 

with(PDEtools):
> 

alias(u = u(x, y, t), f = f(x, y, t), g = g(x, y, t), q = q(x, y, t))

u, f, g, q

 (1)

eq1 := 24*g*(diff(q, y))*(diff(q, x))^3-12*(diff(q, y))*(diff(q, x))^2*g^2 = 0

24*g*(diff(q, y))*(diff(q, x))^3-12*(diff(q, y))*(diff(q, x))^2*g^2 = 0

 (2)

eq2 := 60*g*sigma*(diff(q, y))*(diff(q, x))^3-30*sigma*(diff(q, y))*(diff(q, x))^2*g^2+18*(diff(g, x))*(diff(q, y))*(diff(q, x))^2-15*(diff(q, y))*(diff(q, x))*(diff(g, x))*g+18*g*(diff(q, y))*(diff(q, x))*(diff(q, x, x))-3*(diff(q, y))*g^2*(diff(q, x, x))+6*(diff(g, y))*(diff(q, x))^3+18*g*(diff(q, x))^2*(diff(q, y, x))-9*(diff(g, y))*g*(diff(q, x))^2-3*g^2*(diff(q, x))*(diff(q, y, x)) = 0

60*g*sigma*(diff(q, y))*(diff(q, x))^3-30*sigma*(diff(q, y))*(diff(q, x))^2*g^2+18*(diff(g, x))*(diff(q, y))*(diff(q, x))^2-15*(diff(q, y))*(diff(q, x))*(diff(g, x))*g+18*g*(diff(q, y))*(diff(q, x))*(diff(diff(q, x), x))-3*(diff(q, y))*g^2*(diff(diff(q, x), x))+6*(diff(g, y))*(diff(q, x))^3+18*g*(diff(q, x))^2*(diff(diff(q, x), y))-9*(diff(g, y))*g*(diff(q, x))^2-3*g^2*(diff(q, x))*(diff(diff(q, x), y)) = 0

 (3)

eq3 := 36*g*sigma*(diff(q, y))*(diff(q, x))*(diff(q, x, x))-27*sigma*(diff(q, y))*(diff(q, x))*(diff(g, x))*g-3*(diff(q, y))*(diff(g, x))^2+6*(diff(g, y, x))*(diff(q, x))^2-9*(diff(g, y))*(diff(g, x))*(diff(q, x))+2*g*(diff(q, y))*(diff(q, t))+2*g*(diff(q, y))*(diff(q, x, x, x))-6*(diff(f, y))*(diff(q, x))^2*g+12*(diff(g, y))*sigma*(diff(q, x))^3+6*(diff(g, x))*(diff(q, y))*(diff(q, x, x))-3*(diff(q, y, x))*(diff(g, x))*g-3*(diff(q, y))*(diff(g, x, x))*g+6*(diff(q, y))*(diff(g, x, x))*(diff(q, x))-3*(diff(q, x, x))*(diff(g, y))*g-3*g*(diff(q, x))*(diff(g, y, x))+12*(diff(q, x))*(diff(g, x))*(diff(q, y, x))+6*g*(diff(q, y, x))*(diff(q, x, x))+6*(diff(q, x))*g*(diff(q, y, x, x))+6*(diff(g, y))*(diff(q, x))*(diff(q, x, x))-6*sigma*(diff(q, x))*(diff(q, y, x))*g^2+50*g*sigma^2*(diff(q, y))*(diff(q, x))^3-24*sigma^2*(diff(q, y))*(diff(q, x))^2*g^2+36*(diff(g, x))*sigma*(diff(q, y))*(diff(q, x))^2-15*(diff(q, x))^2*sigma*(diff(g, y))*g-6*(diff(f, x))*(diff(q, y))*(diff(q, x))*g-6*sigma*(diff(q, y))*(diff(q, x, x))*g^2+36*g*sigma*(diff(q, x))^2*(diff(q, y, x)) = 0

50*g*sigma^2*(diff(q, y))*(diff(q, x))^3-24*sigma^2*(diff(q, y))*(diff(q, x))^2*g^2+36*(diff(g, x))*sigma*(diff(q, y))*(diff(q, x))^2-15*(diff(q, x))^2*sigma*(diff(g, y))*g-6*(diff(f, x))*(diff(q, y))*(diff(q, x))*g-6*sigma*(diff(q, x))*(diff(diff(q, x), y))*g^2-6*sigma*(diff(q, y))*(diff(diff(q, x), x))*g^2+36*g*sigma*(diff(q, x))^2*(diff(diff(q, x), y))-3*(diff(q, y))*(diff(g, x))^2+6*(diff(diff(g, x), y))*(diff(q, x))^2+6*(diff(g, y))*(diff(q, x))*(diff(diff(q, x), x))+6*(diff(g, x))*(diff(q, y))*(diff(diff(q, x), x))-3*(diff(diff(q, x), y))*(diff(g, x))*g-3*(diff(q, y))*(diff(diff(g, x), x))*g+6*(diff(q, y))*(diff(diff(g, x), x))*(diff(q, x))-3*(diff(diff(q, x), x))*(diff(g, y))*g-3*g*(diff(q, x))*(diff(diff(g, x), y))+12*(diff(q, x))*(diff(g, x))*(diff(diff(q, x), y))+6*g*(diff(diff(q, x), y))*(diff(diff(q, x), x))+6*(diff(q, x))*g*(diff(diff(diff(q, x), x), y))+2*g*(diff(q, y))*(diff(diff(diff(q, x), x), x))+2*g*(diff(q, y))*(diff(q, t))+12*(diff(g, y))*sigma*(diff(q, x))^3-9*(diff(g, y))*(diff(g, x))*(diff(q, x))-6*(diff(f, y))*(diff(q, x))^2*g-27*sigma*(diff(q, y))*(diff(q, x))*(diff(g, x))*g+36*g*sigma*(diff(q, y))*(diff(q, x))*(diff(diff(q, x), x)) = 0

 (4)

eq4 := -3*g*(diff(f, y))*(diff(q, x, x))-3*(diff(q, y))*g*(diff(f, x, x))-3*g*(diff(q, x))*(diff(f, y, x))-3*g*(diff(q, y, x))*(diff(f, x))+15*g*sigma^3*(diff(q, y))*(diff(q, x))^3-6*sigma^3*(diff(q, y))*(diff(q, x))^2*g^2+21*(diff(g, x))*sigma^2*(diff(q, y))*(diff(q, x))^2-6*(diff(q, x))^2*sigma^2*(diff(g, y))*g-9*(diff(f, y))*(diff(q, x))^2*sigma*g+3*g*sigma*(diff(q, y))*(diff(q, t))-9*sigma*(diff(q, x))*(diff(g, x))*(diff(g, y))+9*(diff(g, y, x))*sigma*(diff(q, x))^2+7*(diff(g, y))*sigma^2*(diff(q, x))^3-3*sigma*(diff(q, y))*(diff(g, x))^2-6*(diff(g, x))*(diff(q, x))*(diff(f, y))-3*(diff(q, y))*(diff(g, x))*(diff(f, x))-3*(diff(g, y))*(diff(q, x))*(diff(f, x))-3*(diff(g, y, x))*(diff(g, x))-3*(diff(g, x, x))*(diff(g, y))+g*(diff(q, y, t))+9*g*sigma*(diff(q, y, x))*(diff(q, x, x))-3*sigma*(diff(q, x, x))*(diff(g, y))*g+9*sigma*(diff(q, x))*g*(diff(q, y, x, x))-3*sigma*(diff(q, y, x))*(diff(g, x))*g-3*sigma*(diff(q, x))*(diff(g, y, x))*g+9*(diff(g, y))*sigma*(diff(q, x))*(diff(q, x, x))+9*(diff(g, x))*sigma*(diff(q, y))*(diff(q, x, x))+3*g*sigma*(diff(q, y))*(diff(q, x, x, x))+18*sigma*(diff(q, x))*(diff(g, x))*(diff(q, y, x))+21*g*sigma^2*(diff(q, x))^2*(diff(q, y, x))-3*sigma^2*(diff(q, x))*(diff(q, y, x))*g^2+9*sigma*(diff(q, y))*(diff(g, x, x))*(diff(q, x))-3*sigma*(diff(q, y))*(diff(g, x, x))*g-3*sigma^2*(diff(q, y))*(diff(q, x, x))*g^2+21*g*sigma^2*(diff(q, y))*(diff(q, x))*(diff(q, x, x))-9*(diff(f, x))*(diff(q, y))*(diff(q, x))*sigma*g-12*sigma^2*(diff(q, y))*(diff(q, x))*(diff(g, x))*g+(diff(q, y))*(diff(g, t))+(diff(g, y))*(diff(q, t))+3*(diff(g, x, x))*(diff(q, y, x))+(diff(q, y))*(diff(g, x, x, x))+3*(diff(q, x))*(diff(g, y, x, x))+(diff(q, y, x, x, x))*g+3*(diff(g, x))*(diff(q, y, x, x))+(diff(g, y))*(diff(q, x, x, x))+3*(diff(g, y, x))*(diff(q, x, x)) = 0

7*(diff(g, y))*sigma^2*(diff(q, x))^3-3*sigma*(diff(q, y))*(diff(g, x))^2-6*(diff(g, x))*(diff(q, x))*(diff(f, y))-3*(diff(q, y))*(diff(g, x))*(diff(f, x))-3*(diff(g, y))*(diff(q, x))*(diff(f, x))-3*(diff(q, y))*g*(diff(diff(f, x), x))-3*g*(diff(q, x))*(diff(diff(f, x), y))-3*g*(diff(f, y))*(diff(diff(q, x), x))-3*g*(diff(diff(q, x), y))*(diff(f, x))+9*(diff(diff(g, x), y))*sigma*(diff(q, x))^2+15*g*sigma^3*(diff(q, y))*(diff(q, x))^3-6*sigma^3*(diff(q, y))*(diff(q, x))^2*g^2+21*(diff(g, x))*sigma^2*(diff(q, y))*(diff(q, x))^2-6*(diff(q, x))^2*sigma^2*(diff(g, y))*g-9*(diff(f, y))*(diff(q, x))^2*sigma*g+3*g*sigma*(diff(q, y))*(diff(q, t))-9*sigma*(diff(q, x))*(diff(g, x))*(diff(g, y))+9*g*sigma*(diff(diff(q, x), y))*(diff(diff(q, x), x))-3*sigma*(diff(diff(q, x), x))*(diff(g, y))*g+9*sigma*(diff(q, x))*g*(diff(diff(diff(q, x), x), y))-3*sigma*(diff(diff(q, x), y))*(diff(g, x))*g-3*sigma*(diff(q, x))*(diff(diff(g, x), y))*g+9*(diff(g, y))*sigma*(diff(q, x))*(diff(diff(q, x), x))+9*(diff(g, x))*sigma*(diff(q, y))*(diff(diff(q, x), x))+3*g*sigma*(diff(q, y))*(diff(diff(diff(q, x), x), x))+18*sigma*(diff(q, x))*(diff(g, x))*(diff(diff(q, x), y))+21*g*sigma^2*(diff(q, x))^2*(diff(diff(q, x), y))-3*sigma^2*(diff(q, x))*(diff(diff(q, x), y))*g^2+9*sigma*(diff(q, y))*(diff(diff(g, x), x))*(diff(q, x))-3*sigma*(diff(q, y))*(diff(diff(g, x), x))*g-3*sigma^2*(diff(q, y))*(diff(diff(q, x), x))*g^2-9*(diff(f, x))*(diff(q, y))*(diff(q, x))*sigma*g-12*sigma^2*(diff(q, y))*(diff(q, x))*(diff(g, x))*g+21*g*sigma^2*(diff(q, y))*(diff(q, x))*(diff(diff(q, x), x))+(diff(q, y))*(diff(g, t))+(diff(g, y))*(diff(q, t))-3*(diff(diff(g, x), y))*(diff(g, x))-3*(diff(diff(g, x), x))*(diff(g, y))+g*(diff(diff(q, t), y))+3*(diff(diff(g, x), x))*(diff(diff(q, x), y))+(diff(q, y))*(diff(diff(diff(g, x), x), x))+3*(diff(q, x))*(diff(diff(diff(g, x), x), y))+(diff(diff(diff(diff(q, x), x), x), y))*g+3*(diff(g, x))*(diff(diff(diff(q, x), x), y))+(diff(g, y))*(diff(diff(diff(q, x), x), x))+3*(diff(diff(g, x), y))*(diff(diff(q, x), x)) = 0

 (5)

eq5 := (diff(g, y))*sigma*(diff(q, t))+(diff(g, t))*sigma*(diff(q, y))+(diff(g, y))*sigma^3*(diff(q, x))^3+3*(diff(g, x))*sigma^3*(diff(q, y))*(diff(q, x))^2+g*sigma^2*(diff(q, y))*(diff(q, t))+g*sigma^4*(diff(q, y))*(diff(q, x))^3-3*(diff(f, x))*sigma*(diff(q, y))*(diff(g, x))-3*(diff(f, x))*sigma*(diff(q, x))*(diff(g, y))-6*(diff(f, y))*sigma*(diff(q, x))*(diff(g, x))+3*g*sigma^3*(diff(q, x))^2*(diff(q, y, x))+g*sigma^2*(diff(q, y))*(diff(q, x, x, x))-3*(diff(f, x))*sigma*(diff(q, y, x))*g-3*(diff(f, y))*sigma*(diff(q, x, x))*g-3*g*sigma*(diff(q, y))*(diff(f, x, x))-3*sigma*(diff(q, x))*g*(diff(f, y, x))+3*(diff(g, x, x))*sigma^2*(diff(q, y))*(diff(q, x))+6*(diff(g, x))*sigma^2*(diff(q, x))*(diff(q, y, x))+diff(g, y, t)-3*(diff(f, x))*(diff(q, y))*(diff(q, x))*sigma^2*g+3*g*sigma^3*(diff(q, y))*(diff(q, x))*(diff(q, x, x))+3*g*sigma^2*(diff(q, x))*(diff(q, y, x, x))-3*(diff(f, y))*(diff(q, x))^2*sigma^2*g+3*(diff(g, y))*sigma^2*(diff(q, x))*(diff(q, x, x))+3*g*sigma^2*(diff(q, y, x))*(diff(q, x, x))+3*(diff(g, x))*sigma^2*(diff(q, y))*(diff(q, x, x))-3*(diff(g, y))*(diff(f, x, x))-3*(diff(f, y))*(diff(g, x, x))-3*(diff(g, x))*(diff(f, y, x))-3*(diff(f, x))*(diff(g, y, x))+diff(g, y, x, x, x)+3*(diff(g, y, x))*sigma^2*(diff(q, x))^2+3*(diff(g, x, x))*sigma*(diff(q, y, x))+3*(diff(g, y, x, x))*sigma*(diff(q, x))+(diff(g, x, x, x))*sigma*(diff(q, y))+g*sigma*(diff(q, y, t))+3*(diff(g, x))*sigma*(diff(q, y, x, x))+3*(diff(g, y, x))*sigma*(diff(q, x, x))+g*sigma*(diff(q, y, x, x, x))+(diff(g, y))*sigma*(diff(q, x, x, x)) = 0

(diff(g, t))*sigma*(diff(q, y))+(diff(g, y))*sigma^3*(diff(q, x))^3+(diff(g, y))*sigma*(diff(q, t))+3*(diff(diff(g, x), y))*sigma^2*(diff(q, x))^2+3*(diff(diff(g, x), x))*sigma*(diff(diff(q, x), y))+3*(diff(diff(diff(g, x), x), y))*sigma*(diff(q, x))+(diff(diff(diff(g, x), x), x))*sigma*(diff(q, y))+g*sigma*(diff(diff(q, t), y))+3*(diff(g, x))*sigma*(diff(diff(diff(q, x), x), y))+3*(diff(diff(g, x), y))*sigma*(diff(diff(q, x), x))+g*sigma*(diff(diff(diff(diff(q, x), x), x), y))+(diff(g, y))*sigma*(diff(diff(diff(q, x), x), x))-3*(diff(f, x))*(diff(q, y))*(diff(q, x))*sigma^2*g+3*g*sigma^3*(diff(q, y))*(diff(q, x))*(diff(diff(q, x), x))-3*(diff(f, y))*(diff(q, x))^2*sigma^2*g+6*(diff(g, x))*sigma^2*(diff(q, x))*(diff(diff(q, x), y))+3*g*sigma^2*(diff(q, x))*(diff(diff(diff(q, x), x), y))+3*(diff(g, y))*sigma^2*(diff(q, x))*(diff(diff(q, x), x))+3*g*sigma^2*(diff(diff(q, x), y))*(diff(diff(q, x), x))+3*(diff(g, x))*sigma^2*(diff(q, y))*(diff(diff(q, x), x))+3*g*sigma^3*(diff(q, x))^2*(diff(diff(q, x), y))+g*sigma^2*(diff(q, y))*(diff(diff(diff(q, x), x), x))-3*(diff(f, x))*sigma*(diff(diff(q, x), y))*g-3*(diff(f, y))*sigma*(diff(diff(q, x), x))*g-3*g*sigma*(diff(q, y))*(diff(diff(f, x), x))-3*sigma*(diff(q, x))*g*(diff(diff(f, x), y))+3*(diff(diff(g, x), x))*sigma^2*(diff(q, y))*(diff(q, x))+3*(diff(g, x))*sigma^3*(diff(q, y))*(diff(q, x))^2+g*sigma^2*(diff(q, y))*(diff(q, t))+g*sigma^4*(diff(q, y))*(diff(q, x))^3-3*(diff(f, x))*sigma*(diff(q, y))*(diff(g, x))-3*(diff(f, x))*sigma*(diff(q, x))*(diff(g, y))-6*(diff(f, y))*sigma*(diff(q, x))*(diff(g, x))+diff(diff(g, t), y)+diff(diff(diff(diff(g, x), x), x), y)-3*(diff(g, y))*(diff(diff(f, x), x))-3*(diff(f, y))*(diff(diff(g, x), x))-3*(diff(g, x))*(diff(diff(f, x), y))-3*(diff(f, x))*(diff(diff(g, x), y)) = 0

 (6)

eq6 := -3*(diff(f, x))*(diff(f, y, x))-3*(diff(f, y))*(diff(f, x, x))+diff(f, y, x, x, x)+diff(f, y, t) = 0

-3*(diff(f, x))*(diff(diff(f, x), y))-3*(diff(f, y))*(diff(diff(f, x), x))+diff(diff(diff(diff(f, x), x), x), y)+diff(diff(f, t), y) = 0

 (7)
> 

pdsolve({eq1, eq2, eq3, eq4, eq5, eq6}, {f, g, q})

``

Download PDEs_system_solution.mw

How to solve a combined inequality?...

Asked by: paulmcquad 105
solve homework inequality
January 12 2025
0  2

Can maple simplify a Combined Inequality? At best it outputs imho a more complicated solution.

Thanks in Advance.

sl10 := -1 <= (3-5*x)*(1/2) and (3-5*x)*(1/2) <= 9

0 <= 5/2-(5/2)*x and -(5/2)*x <= 15/2

 (1)

The output should be:

 

-3 <= x and x <= 1


Download Combined_Inequality.mw

A task for geometry fans...

Asked by: Kitonum 21435
January 11 2025
3  6

Here's a puzzle for geometry lovers. It has a very short manual solution, but it's not that easy to find. Of course, you can solve it in Maple using coordinates. You need to find the radius of these two identical circles.

Command completion: is there a shortcut for ":-"...

Asked by: C_R 3412
January 11 2025
0  1

I am using the tab key to complete commands. Often I have to add a module to the command. On my keyboard typing ":-" is slow (for me) and interrupts the flow. I was wondering whether there is not a undocumented key or shortcut to insert ":-".

(I tried a second time hitting tab but this did not do anything. Would this be a good way to speed up typing?)

How do I find a derivative of a composite function...

Asked by: grit 5
January 10 2025
1  5

I wanted to derive the q(w) term in the following expression to get ∂ f/∂q(w), but I got an error

why my pdetest not satisfy?...

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

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

why odetest sometimes works and sometimes gives in...

Asked by: nm 11353
ode differential-equations recursion
January 09 2025
5  17

Is there something one can do to make Maple give same result each time? It seems all random.

Calling odetest sometimes gives internal error. 

            Error, (in trig/normal/sincosargs) too many levels of recursion

But it is random when and how it happens. Worksheet below shows that sometimes when adding infolevel[odetest]:=5; make the error go away. sometimes trying 2 or 3 times also makes the error go away.

This makes it impossible to reason about things, as sometimes I get different result using same exact code.

Is there something one can do to remove this internal error? Why it happens sometimes only?  Do I need to clear something before calling odetest to make sure same result is obtained each time?

> 

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"

> 

restart;
> 

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

y(x) = (1/2)*x*(-1-(1+I*3^(1/2))*((I*2^(1/2)+(-1+I))*(I*2^(1/2)+1+I)^2)^(2/3)-2*((I*2^(1/2)+(-1+I))*(I*2^(1/2)+1+I)^2)^(1/3)-I*((I*2^(1/2)+I)^2-1)*3^(1/2)+(I*2^(1/2)+I)^2)/(((I*2^(1/2)+(-1+I))*(I*2^(1/2)+1+I)^2)^(1/3)*(I*2^(1/2)+I))

x^3+3*x*y(x)^2+(y(x)^3+3*x^2*y(x))*(diff(y(x), x)) = 0

> 

odetest(sol,ode,y(x));

Error, (in trig/normal/sincosargs) too many levels of recursion

> 

odetest(sol,ode);

Error, (in trig/normal/sincosargs) too many levels of recursion

> 

infolevel[odetest]:=5;

5

> 

odetest(sol,ode);

odetest: Performing an implicit solution test

odetest: Performing an explicit (try hard) solution test

odetest: Performing an implicit solution (II) test

odetest: Performing another explicit (try soft) solution test

0

> 

odetest(sol,ode,y(x));

odetest: Performing an implicit solution test

odetest: Performing an explicit (try hard) solution test

odetest: Performing an implicit solution (II) test

odetest: Performing another explicit (try soft) solution test

0

> 

infolevel[odetest]:=0;

0

> 

odetest(sol,ode,y(x));

0

> 

restart;
> 

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

y(x) = (1/2)*x*(-1-(1+I*3^(1/2))*((I*2^(1/2)+(-1+I))*(I*2^(1/2)+1+I)^2)^(2/3)-2*((I*2^(1/2)+(-1+I))*(I*2^(1/2)+1+I)^2)^(1/3)-I*((I*2^(1/2)+I)^2-1)*3^(1/2)+(I*2^(1/2)+I)^2)/(((I*2^(1/2)+(-1+I))*(I*2^(1/2)+1+I)^2)^(1/3)*(I*2^(1/2)+I))

x^3+3*x*y(x)^2+(y(x)^3+3*x^2*y(x))*(diff(y(x), x)) = 0

> 

odetest(sol,ode,y(x));

Error, (in trig/normal/sincosargs) too many levels of recursion

> 

odetest(sol,ode,y(x));

Error, (in trig/normal/sincosargs) too many levels of recursion

> 

odetest(sol,ode,y(x));

0

Download why_odetest_sometimes_fail_internal.mw

Add tracelast; after an error gives long output with this at end

...
#(\`trig/normal\`,8): sincosargs := [\`trig/normal/sincosargs\`(a)];
 \`trig/normal/sincosargs\` called with arguments: ((-2472*2^(1/2)+3496)*3^(1/2)-4288*2^(1/2)+6064)*(10+7*2^(1/2))^(1/2)+(6008*6^(1/2)-8496*3^(1/2)+10408*2^(1/2)-14720)*cos((1/24)*Pi)
 #(\`trig/normal/sincosargs\`,2): return op(map(procname,{op(x)}))
 \`trig/normal/sincosargs\` called with arguments: ((-2472*2^(1/2)+3496)*3^(1/2)-4288*2^(1/2)+6064)*(10+7*2^(1/2))^(1/2)
 #(\`trig/normal/sincosargs\`,2): return op(map(procname,{op(x)}))
 \`trig/normal/sincosargs\` called with arguments: (-2472*2^(1/2)+3496)*3^(1/2)-4288*2^(1/2)+6064
 #(\`trig/normal/sincosargs\`,2): return op(map(procname,{op(x)}))
 \`trig/normal/sincosargs\` called with arguments: (-2472*2^(1/2)+3496)*3^(1/2)
 #(\`trig/normal/sincosargs\`,2): return op(map(procname,{op(x)}))
 \`trig/normal/sincosargs\` called with arguments: -2472*2^(1/2)+3496
 #(\`trig/normal/sincosargs\`,2): return op(map(procname,{op(x)}))
 \`trig/normal/sincosargs\` called with arguments: -2472*2^(1/2)
 #(\`trig/normal/sincosargs\`,2): return op(map(procname,{op(x)}))

Not only is it random error, it also can not be cought using try/catch. So the whole program now stop and there is no way around it. If it was at least possible to trap the error, then it will not be a big deal. But when not even possible to trap Maple errors, then what is one to do? 


Update Jan 18, 2025

I did not want to make new post on this, even though the error is different, but it is similar issue to this post.

I found another example of this random failure of odetest using same input.  May be this will help Maplesoft find the cause. 

The internal error this time is Error, (in depends) too many levels of recursion

In this worksheet below. the same ode and 3 solutions were used. As you see, sometimes odetest do not generate internal error, and sometimes it does. All happen on 3rd call to odetest. 

So it is completely random why this happen. The first and 4ht tries generate no error, but the second and the third do. All were run after restart is called. So one would expect same output from each try,

> 

restart;
> 

interface(version);
Physics:-Version();

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

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

First Try

 
> 

ode:=1+y(x)^2+(x-exp(-arctan(y(x))))*diff(y(x),x) = 0;
sol_1:=y(x) = -tan(LambertW(-x/exp(_C1))+_C1);
timelimit(30,odetest(sol_1,ode,y(x)));

sol_2:=x*exp(arctan(y(x)))-arctan(y(x)) = _C1;
timelimit(30,odetest(sol_2,ode,y(x)));

sol_3:=y(x) = tan(-LambertW(-x*exp(_C2))+_C2);
timelimit(30,odetest(sol_3,ode,y(x)));

1+y(x)^2+(x-exp(-arctan(y(x))))*(diff(y(x), x)) = 0

y(x) = -tan(LambertW(-x/exp(_C1))+_C1)

4*LambertW(-x*exp(-c__1))*exp(-I*arctanh(exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)/(exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)+1)-1/(exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)+1))+(2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)/((exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)+1)^2*x*(1+LambertW(-x*exp(-c__1))))+4*exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)/((exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)+1)^2*(1+LambertW(-x*exp(-c__1))))

x*exp(arctan(y(x)))-arctan(y(x)) = c__1

0

y(x) = tan(-LambertW(-x*exp(_C2))+_C2)

Error, (in depends) too many levels of recursion

 

 

 

 

Second Try

 
> 

restart;

> 

ode:=1+y(x)^2+(x-exp(-arctan(y(x))))*diff(y(x),x) = 0;
sol_1:=y(x) = -tan(LambertW(-x/exp(_C1))+_C1);
timelimit(30,odetest(sol_1,ode,y(x)));

sol_2:=x*exp(arctan(y(x)))-arctan(y(x)) = _C1;
timelimit(30,odetest(sol_2,ode,y(x)));

sol_3:=y(x) = tan(-LambertW(-x*exp(_C2))+_C2);
timelimit(30,odetest(sol_3,ode,y(x)));

1+y(x)^2+(x-exp(-arctan(y(x))))*(diff(y(x), x)) = 0

y(x) = -tan(LambertW(-x/exp(_C1))+_C1)

4*exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)/((exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)+1)^2*(1+LambertW(-x*exp(-c__1))))+4*LambertW(-x*exp(-c__1))*exp(-I*arctanh(exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)/(exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)+1)-1/(exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)+1))+(2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)/((1+LambertW(-x*exp(-c__1)))*x*(exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)+1)^2)

x*exp(arctan(y(x)))-arctan(y(x)) = c__1

0

y(x) = tan(-LambertW(-x*exp(_C2))+_C2)

4*LambertW(-x*exp(c__2))*exp((2*I)*LambertW(-x*exp(c__2))+(2*I)*c__2+I*arctanh(-exp((2*I)*LambertW(-x*exp(c__2)))/(exp((2*I)*LambertW(-x*exp(c__2)))+exp((2*I)*c__2))+exp((2*I)*c__2)/(exp((2*I)*LambertW(-x*exp(c__2)))+exp((2*I)*c__2))))/((exp((2*I)*LambertW(-x*exp(c__2)))+exp((2*I)*c__2))^2*(1+LambertW(-x*exp(c__2)))*x)+4*exp((2*I)*c__2+(2*I)*LambertW(-x*exp(c__2)))/((exp((2*I)*LambertW(-x*exp(c__2)))+exp((2*I)*c__2))^2*(1+LambertW(-x*exp(c__2))))

> 

 

> 

 

> 

 

Third  Try

 
> 

restart;

> 

ode:=1+y(x)^2+(x-exp(-arctan(y(x))))*diff(y(x),x) = 0;
sol_1:=y(x) = -tan(LambertW(-x/exp(_C1))+_C1);
timelimit(30,odetest(sol_1,ode,y(x)));

sol_2:=x*exp(arctan(y(x)))-arctan(y(x)) = _C1;
timelimit(30,odetest(sol_2,ode,y(x)));

sol_3:=y(x) = tan(-LambertW(-x*exp(_C2))+_C2);
timelimit(30,odetest(sol_3,ode,y(x)));

1+y(x)^2+(x-exp(-arctan(y(x))))*(diff(y(x), x)) = 0

y(x) = -tan(LambertW(-x/exp(_C1))+_C1)

4*LambertW(-x*exp(-c__1))*exp(-I*arctanh(exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)/(exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)+1)-1/(exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)+1))+(2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)/((1+LambertW(-x*exp(-c__1)))*x*(exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)+1)^2)+4*exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)/((exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)+1)^2*(1+LambertW(-x*exp(-c__1))))

x*exp(arctan(y(x)))-arctan(y(x)) = c__1

0

y(x) = tan(-LambertW(-x*exp(_C2))+_C2)

Error, (in depends) too many levels of recursion

> 

 

> 

 

> 

 

4th  Try

 
> 

restart;

> 

ode:=1+y(x)^2+(x-exp(-arctan(y(x))))*diff(y(x),x) = 0;
sol_1:=y(x) = -tan(LambertW(-x/exp(_C1))+_C1);
timelimit(30,odetest(sol_1,ode,y(x)));

sol_2:=x*exp(arctan(y(x)))-arctan(y(x)) = _C1;
timelimit(30,odetest(sol_2,ode,y(x)));

sol_3:=y(x) = tan(-LambertW(-x*exp(_C2))+_C2);
timelimit(30,odetest(sol_3,ode,y(x)));

1+y(x)^2+(x-exp(-arctan(y(x))))*(diff(y(x), x)) = 0

y(x) = -tan(LambertW(-x/exp(_C1))+_C1)

4*LambertW(-x*exp(-c__1))*exp(-I*arctanh(exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)/(exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)+1)-1/(exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)+1))+(2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)/((1+LambertW(-x*exp(-c__1)))*x*(exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)+1)^2)+4*exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)/((exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)+1)^2*(1+LambertW(-x*exp(-c__1))))

x*exp(arctan(y(x)))-arctan(y(x)) = c__1

0

y(x) = tan(-LambertW(-x*exp(_C2))+_C2)

4*exp((2*I)*c__2+(2*I)*LambertW(-x*exp(c__2)))/((exp((2*I)*LambertW(-x*exp(c__2)))+exp((2*I)*c__2))^2*(1+LambertW(-x*exp(c__2))))+4*LambertW(-x*exp(c__2))*exp((2*I)*LambertW(-x*exp(c__2))+(2*I)*c__2+I*arctanh(-exp((2*I)*LambertW(-x*exp(c__2)))/(exp((2*I)*LambertW(-x*exp(c__2)))+exp((2*I)*c__2))+exp((2*I)*c__2)/(exp((2*I)*LambertW(-x*exp(c__2)))+exp((2*I)*c__2))))/((exp((2*I)*LambertW(-x*exp(c__2)))+exp((2*I)*c__2))^2*(1+LambertW(-x*exp(c__2)))*x)

> 

 

Download bug_odetest_jan_18_2025.mw

Optimal solution for schedule?...

Asked by: brian bovril 914
optimization combinatorics schedule
January 09 2025
0  8

Hello

Following on from my earlier question:

https://www.mapleprimes.com/questions/239620-Round-Robin-With-Double-Bye

a colleague has produced (admittedly hurriedly) a sports schedule over 14 weeks for a 8-team double bye, and a 10-team over 15 weeks. 
Looking at it, and counting the possible combinations, neither seem optimal...

The 8 team has equal byes, the 10 uneven.

Edit. Ideally no team would have 2 byes in a row. 

Is there a solution in maple over these weeks? given the min duration would be 13 weeks and the max 15 weeks?
In the previous solution by mmcdara the 8 bye schedule each team has played 6 times after week 8, but since the roster is truncated to 14 or 15, there will be some weeks when no byes are required (all teams playing) to even things up.
Similarly, the 10 bye each team has played 8 times after week 10, but since the roster is truncated to 14 or 15, there will be some weeks when no byes are required.

Any help would be welcome!
double_bye.xls

Edit: I made some counting errors. It's 28 and 45 as Carl pointed out
double_bye_revised.xls

How can I understand and work the Output of Regula...

Asked by: Saalehorizontale 55
solve regularchains
January 08 2025
3  1

Hey guys,

I have to solve a bunch of systems of polynomial equations und dome restrictions given by inequalitites. I have 8 variables, 8 equations and and 13 inequalitites. Since the simple solve or SemiAlgebraic command are not able to solve every system I tryd some other ways. Right now I try to bring the set of equations and ineqaulities in a better from or structure using RealTriangulize from the RegularChains library. Later on I want to take those results and use solve or SemiAlgebraic again, hoping, that Maple than finds the solutions and is not calculating for houres without a result. I already know, that you can have diffrent outputs for RealTriangularize (I know list, record, piecewise and zerodimensional, althought the last one is not really helpful). Since I want to go on wirking with the results I need to have them in a form, that I can read of the new equations and inequalities to put them into solve. Often that works totaly fine, but sometimes I get an output I dont understand. I understand what It means but I dont understand why Maple uses that type of output. If you have a look in the attached file you can see what I mean:

> 

restart; with(RegularChains); eq_5334 := {y*(m*x-m-n+1)+(-x+1)*n-x = 0, (-p+t)*k+p*y-t = 0, (k-x-y)*t-k*p+y = 0, (-x-y+1)*t+(-k+y)*n+x*s = 0, (-x-y+1)*p+m*y^2+x-y = 0, (x^2-x)*m+y*(t-1)-n+1 = 0, -k*n+s*x = 0, m*x*y-p = 0, 0 < k, 0 < m, 0 < s, 0 < x, 0 < y, 0 < n+(t-1)*p, 0 < (m*y-1)*n+(1-p)*(m*x-m+1), 0 < (m*x-m-t+1)*p+m*y*(t-n), 1 < x+y, k < 1, m < 1, s < t, t < 1}; eq_5380 := {(-x-y+1)*p+m*x*y = 0, (-p+t)*k+p*y-t = 0, (k-x-y)*t-k*p+y = 0, (-x-y+1)*t+(-k+y)*n+x*s = 0, (m-1)*y^2+(-x+1)*y-p+x = 0, (x-1)*(m-1)*y-x^2-n+x = 0, m*x^2+(-m-n+1)*x+(-y+1)*n+t*y-1 = 0, -k*n+s*x = 0, 0 < k, 0 < m, 0 < s, 0 < x, 0 < y, 0 < n+(t-1)*p, 0 < (m*y-1)*n+(1-p)*(m*x-m+1), 0 < (m*x-m-t+1)*p+m*y*(t-n), 1 < x+y, k < 1, m < 1, s < t, t < 1}; eq_5382 := {(-x-y+1)*p+m*x*y = 0, y*(m*x-m-n+1)+(-x+1)*n-x = 0, (-p+t)*k+p*y-t = 0, (k-x-y)*t-k*p+y = 0, (-x-y+1)*t+(-k+y)*n+x*s = 0, (-x-y+1)*p+m*y^2+x-y = 0, m*x^2+(-m-n+1)*x+(-y+1)*n+t*y-1 = 0, -k*n+s*x = 0, 0 < k, 0 < m, 0 < s, 0 < x, 0 < y, 0 < n+(t-1)*p, 0 < (m*y-1)*n+(1-p)*(m*x-m+1), 0 < (m*x-m-t+1)*p+m*y*(t-n), 1 < x+y, k < 1, m < 1, s < t, t < 1}; sys := eq_5334; SuggestVariableOrder(sys); R := PolynomialRing(%); dec_5334 := RealTriangularize(sys, R, output = piecewise); sys := eq_5380; SuggestVariableOrder(sys); R := PolynomialRing(%); dec_5380 := RealTriangularize(sys, R, output = piecewise); sys := eq_5382; SuggestVariableOrder(sys); R := PolynomialRing(%); dec_5382 := RealTriangularize(sys, R, output = piecewise); sys := eq_5382; SuggestVariableOrder(sys); R := PolynomialRing(%); dec_5382_record := RealTriangularize(sys, R, output = record)

[AlgebraicGeometryTools, ChainTools, ConstructibleSetTools, Display, DisplayPolynomialRing, Equations, ExtendedRegularGcd, FastArithmeticTools, Inequations, Info, Initial, Intersect, Inverse, IsRegular, LazyRealTriangularize, MainDegree, MainVariable, MatrixCombine, MatrixTools, NormalForm, ParametricSystemTools, PolynomialRing, Rank, RealTriangularize, RegularGcd, RegularizeInitial, SamplePoints, SemiAlgebraicSetTools, Separant, SparsePseudoRemainder, SuggestVariableOrder, Tail, Triangularize]

  

[s, k, n, p, m, t, x, y]

  

R := polynomial_ring

  

dec_5334 := [[x*s+((-x^2+x)*m-t*y+y-1)*k = 0, (m*x*y-t)*k+(x+y)*t-y = 0, n+(-x^2+x)*m-t*y+y-1 = 0, -m*x*y+p = 0, (x^2*y+(y^2-y)*x-y^2)*m-x+y = 0, t*y^2-y^2+x = 0, (15*y^2+24*y+20)*x-6*y^2-13*y-10 = 0, y^3-y-2 = 0, 0 < k, 0 < m, 0 < s, 0 < x, 0 < y, 0 < 12891634966*y^2+19613071879*y+16947294542, 0 < 1256597*y^2+1911761*y+1651926, 0 < 6310892468*y^2+9601263717*y+8296275330, 0 < 1401*y^2+2130*y+1840, 0 < 1-k, 0 < 1-m, 0 < 72927541996846438*y^2+110950482461140595*y+95870270479707846, 0 < 1-t]]

  

[s, k, n, p, m, t, y, x]

  

R := polynomial_ring

  

dec_5380 := piecewise(`and`(`and`(`and`(0 < x^3-2*x^2+3*x-1, 0 < x^3+2*x^2+x-1), x^3+x^2+x < 1), 0 < 3*x-1), [[s*x+((1-x)*y*m+(x-1)*y+x^2-x)*k = 0, (m*y^2-y^2-t+(1-x)*y+x)*k+(y+x)*t-y = 0, n+(1-x)*y*m+(x-1)*y+x^2-x = 0, p-m*y^2+y^2+(x-1)*y-x = 0, m*y-x-y+1 = 0, t*y^2+(x-1)*y^2+(2*x^2-2*x)*y+x^3-2*x^2+x = 0, (3*x-1)*y^2+(3*x^2-3*x)*y+x^3-2*x^2+x = 0, 0 < k, 0 < m, 0 < s, 0 < y, 0 < -6*x^6-9*x^5*y+20*x^5+27*x^4*y-27*x^4-32*x^3*y+19*x^3+17*x^2*y-7*x^2-3*x*y+x, 0 < 3*x^6+3*x^5*y-14*x^5-10*x^4*y+26*x^4+11*x^3*y-24*x^3-3*x^2*y+11*x^2-2*x*y-2*x+y, 0 < 6*x^5+9*x^4*y-17*x^4-18*x^3*y+17*x^3+11*x^2*y-7*x^2-2*x*y+x, 0 < y+x-1, 0 < 1-k, 0 < -m+1, 0 < t-s, 0 < 1-t]], [])

  

[s, k, n, p, m, t, x, y]

  

R := polynomial_ring

  

dec_5382 := piecewise(`and`(`and`(y^3-2*y^2+y < 1, 0 < y-1), 23*y^3-37*y^2+13*y-3 <> 0), [[-k*n+s*x = 0, (p-t)*k+(y+x)*t-y = 0, (y+x-1)*n+(-x*y+y)*m+x-y = 0, (y+x-1)*p-m*y^2-x+y = 0, m*y-1 = 0, t*y^2+x^2+(y-1)*x-y^2 = 0, x^3+(3*y-2)*x^2+(2*y^2-3*y+1)*x-y^3+y^2 = 0, 0 < k, 0 < s, 0 < x, 0 < -2*x^2*y^2-2*x*y^3+2*y^4+x^2*y+3*x*y^2-3*y^3-x*y+y^2, 0 < x^2*y^2+2*x*y^3+y^4-x^2*y-4*x*y^2-3*y^3+2*x*y+3*y^2-y, 0 < -x^2*y-x*y^2+y^3+x*y-y^2, 0 < y+x-1, 0 < 1-k, 0 < t-s, 0 < 1-t]], 23*y^3-37*y^2+13*y-3 = 0, [[-k*n+s*x = 0, (p-t)*k+(y+x)*t-y = 0, (y+x-1)*n+(-x*y+y)*m+x-y = 0, (y+x-1)*p-m*y^2-x+y = 0, m*y-1 = 0, t*y^2+x^2+(y-1)*x-y^2 = 0, (2377326*y^2-1587000*y+302588)*x^2+(390793*y^2+497766*y+138115)*x-507805*y^2+152032*y-109047 = 0, 23*y^3-37*y^2+13*y-3 = 0, 0 < k, 0 < m, 0 < s, 0 < x, 0 < y, 0 < 700112222844255556263586865*x*y^2-260269572171898884295316974*x*y-93795749047261033657544191*y^2+73822886321394794237709987*x+34866975665513154551125606*y-9877974587657378842117575, 0 < -26166721441919*x*y^2+9412709182291*x*y+53422638514257*y^2-3387596446782*x-21180373503698*y+6484087812711, 0 < 21236600258115*x*y^2-8079468597142*x*y-3053799376681*y^2+2340822678357*x+1387037467490*y-370794765921, 0 < y+x-1, 0 < 1-k, 0 < -m+1, 0 < t-s, 0 < 1-t]], [])

  

[s, k, n, p, m, t, x, y]

  

R := polynomial_ring

  

`Non-fatal error while reading data from kernel.`

 (1)
> 

NULL

I would like to get results like in dec_5334. I can easily go on working with this kind of form. In dec_5380 you can see a diffrent output. I dont see the point of giving me this output. the second line i basically epmty. and in the first line the solution is broken into peaces. when a certain solution just works under some inequalitites, why dont they put those four inequalities inside of the list in front of it? Is there a workaround for the "normal" output? Or is there a way to read off the lines from this kind of structure, with the open { in front ?

The same problem appears in dec_5382. WHy dont give me a list with to lists of equations and inequalities to show me both solutions?
In the last example dec_5382_record you can see the output when you change the corresponding option in RealTrinagularize. But here I again have the problem that I dont know how to read of the equations and inequalities from the open curly bracket.

If anyone could help me, I would be very glad. Thank yu in advance.

Regards

Felix

Download Output_of_RegularChains.mw

A question of number theory...

Asked by: mmcdara 7891
simplification factorial
January 08 2025
1  6


Does any one have any idea to demonstrate, using Maple, that for any couple (a, b) of strictly positive integers

(a*b)! / (a! * (b!)^a)

is an integer?

How to split list of players into teams...

Asked by: brian bovril 914
list
January 08 2025
2  2

Hi

Can someone improve my AI code so I get to the final team's config directly, rather than a series of set iterations? thanks 

teams.mw

set 1: Michael K, Andy C
set 2: Michael G, Mitch
set 3: Jez, Dean B
set 4: Anthony B, Rik B
set 5: Ilya, Fariborz
set 6: Eugene, Tania
set 7: Bill, Stevs
set 8: Victor, Jane
set 9: Nash, Ben
 

Example Page 140 User manual...

Asked by: jeffreyrdavis75 35
worksheet loop editing
January 07 2025
1  2

Why doesnt this example work in my Maple 2021.1 from the user manual?

restart;
L := [seq(i, i = 2 .. 1000)];
divisor := 2;
while (numelems(L) > 0)  do  divisable,  L:=selectremove(i->(i mod divisor=0), L):
Error, unterminated loop

n:=numelems(divisable);  

if (n>0) then  printf("%d integers%s whose smallest prime divisor is %d\\n",n,  'if'(n>1, "s", ""), divisor):  end if;  

divisor :=nextprime(divisor);  

end do:
Error, unable to parse
 

First 39 40 41 42 43 44 45 Last Page 41 of 2425