Featured Post

A project that I have been working on is adding some functionality for Cluster Analysis to Maple (a small part of a much bigger project to increase Maple’s toolkit for exploratory data mining and data analysis). The launch of the MapleCloud package manager gave me a way to share my code for the project as it evolves, providing others with some useful new tools and hopefully gathering feedback (and collaborators) along the way.

At this point, there aren’t a lot of commands in the ClusterAnalysis package, but I have already hit upon several interesting applications. For example, while working on a command for plotting clusters of points, one problem I encountered was how to draw the minimal volume enclosing ellipsoid around a group (or cluster) of points. After doing some research, I stumbled upon Khachiyan’s Algorithm, which related to solving linear programming problems with rational data. The math behind this is definitely interesting, but I’m not going to spend any time on it here. For further reading, you can explore the following:

Khachiyan’s Algorithm had previously been applied in some other languages, but to the best of my knowledge, did not have any Maple implementations. As such, the following code is an implementation of Khachiyan’s Algorithm in 2-D, which could be extended to N-dimensional space rather easily.

This routine accepts an Nx2 dataset and outputs either a plot of the minimum volume enclosing ellipsoid (MVEE) or a list of results as described in the details for the ‘output’ option below.

MVEE( X :: DataSet, optional arguments, additional arguments passed to the plotting command );

The optional arguments are as follows:

  • tolerance : realcons;  specifies the convergence criterion
  • maxiterations : posint; specifies the maximum number of iterations
  • output : {identical(data,plot),list(identical(data,plot))}; specifies the output. If output includes plot, then a plot of the enclosing ellipsoid is returned. If output includes data, then the return includes is a list containing the matrix A, which defines the ellipsoid, the center of the ellipse, and the eigenvalues and eigenvectors that can be used to find the semi-axis coordinates and the angle of rotation, alpha, for the ellipse.
  • filled : truefalse; specifies if the returned plot should be filled or not

Code:

#Minimum Volume Enclosing Ellipsoid
MVEE := proc(XY, 
              {tolerance::positive:= 1e-4}, #Convergence Criterion
              {maxiterations::posint := 100},
              {output::{identical(data,plot),list(identical(data,plot))} := data},
              {filled::truefalse := false} 
            )

    local alpha, evalues, evectors, i, l_error, ldata, ldataext, M, maxvalindex, n, ncols, nrows, p1, semiaxes, stepsize, U, U1, x, X, y;
    local A, center, l_output; #Output

    if hastype(output, 'list') then
        l_output := output;
    else
        l_output := [output];
    end if;

    kernelopts(opaquemodules=false):

    ldata := Statistics:-PreProcessData(XY, 2, 'copy');

    nrows, ncols := upperbound(ldata);
    ldataext := Matrix([ldata, Vector[column](nrows, ':-fill' = 1)], 'datatype = float');

    if ncols <> 2 then
        error "expected 2 columns of data, got %1", ncols;
    end if;

    l_error := 1;

    U := Vector[column](1..nrows, 'fill' = 1/nrows);

    ##Khachiyan Algorithm##
    for n to maxiterations while l_error >= tolerance do

        X := LinearAlgebra:-Transpose(ldataext) . LinearAlgebra:-DiagonalMatrix(U) . ldataext;
        M := LinearAlgebra:-Diagonal(ldataext . LinearAlgebra:-MatrixInverse(X) . LinearAlgebra:-Transpose(ldataext));
        maxvalindex := max[index](map['evalhf', 'inplace'](abs, M));
        stepsize := (M[maxvalindex] - ncols - 1)/((ncols + 1) * (M[maxvalindex] - 1));
        U1 := (1 - stepsize) * U;
        U1[maxvalindex] := U1[maxvalindex] + stepsize;
        l_error := LinearAlgebra:-Norm(LinearAlgebra:-DiagonalMatrix(U1 - U));
        U := U1;

    end do;

    A := (1/ncols) * LinearAlgebra:-MatrixInverse(LinearAlgebra:-Transpose(ldata) . LinearAlgebra:-DiagonalMatrix(U) . ldata - (LinearAlgebra:-Transpose(ldata) . U) . LinearAlgebra:-Transpose((LinearAlgebra:-Transpose(ldata) . U)));
    center := LinearAlgebra:-Transpose(ldata) . U;
    evalues, evectors := LinearAlgebra:-Eigenvectors(A);
    evectors := evectors(.., sort[index](1 /~ (sqrt~(Re~(evalues))), `>`, ':-output' = ':-permutation'));
    semiaxes := sort(1 /~ (sqrt~(Re~(evalues))), `>`);
    alpha := arctan(Re(evectors[2,1]) / Re(evectors[1,1]));

    if l_output = [':-data'] then
        return A, center, evectors, evalues;
    elif has( l_output, ':-plot' ) then
            x := t -> center[1] + semiaxes[1] * cos(t) * cos(alpha) - semiaxes[2] * sin(t) * sin(alpha);
            y := t -> center[2] + semiaxes[1] * cos(t) * sin(alpha) + semiaxes[2] * sin(t) * cos(alpha);
            if filled then
                p1 := plots:-display(subs(CURVES=POLYGONS, plot([x(t), y(t), t = 0..2*Pi], ':-transparency' = 0.95, _rest)));
            else
                p1 := plot([x(t), y(t), t = 0..2*Pi], _rest);
            end if;
        return p1, `if`( has(l_output, ':-data'), op([A, center, evectors, evalues]), NULL );
    end if;

end proc:

 

You can run this as follows:

M:=Matrix(10,2,rand(0..3)):

plots:-display([MVEE(M,output=plot,filled,transparency=.3),
                plots:-pointplot(M, symbol=solidcircle,symbolsize=15)],
size=[0.5,"golden"]);

 

 

As it stands, this is not an export from the “work in progress” ClusterAnalysis package – it’s actually just a local procedure used by the ClusterPlot command. However, it seemed like an interesting enough application that it deserved its own post (and potentially even some consideration for inclusion in some future more geometry-specific package). Here’s an example of how this routine is used from ClusterAnalysis:

with(ClusterAnalysis);

X := Import(FileTools:-JoinPath(["datasets/iris.csv"], base = datadir));

kmeans_results := KMeans(X[[`Sepal Length`, `Sepal Width`]],
    clusters = 3, epsilon = 1.*10^(-7), initializationmethod = Forgy);

ClusterPlot(kmeans_results, style = ellipse);

 

 

The source code for this is stored on GitHub, here:

https://github.com/dskoog/Maple-ClusterAnalysis/blob/master/src/MVEE.mm

Comments and suggestions are welcomed.

 

If you don’t have a copy of the ClusterAnalysis package, you can install it from the MapleCloud window, or by running:

PackageTools:-Install(5629844458045440);

 

Featured Post


 

Maple 2017.1 and 2017.2 introduced several improvements in the solution of PDE & Boundary conditions problems (exact solutions).  Maple 2017.3 includes more improvements in this same area.

 

The following is a set of 25 examples of different PDE & Boundary Conditions problems that are solvable in Maple 2017.3 but not in Maple 2017.2 or previous releases. In the examples that follow, in some cases the PDE is different, in other cases the boundary conditions are of a different kind or solving the problem involves different computational strategies.

As usual, at the end there is a link pointing to the corresponding worksheet.

 

pde[1] := diff(u(x, t), t) = k*(diff(u(x, t), x, x)); bc[1] := u(x, 0) = 6+4*cos(3*Pi*x/L), (D[1](u))(0, t) = 0, (D[1](u))(L, t) = 0

diff(u(x, t), t) = k*(diff(diff(u(x, t), x), x))

 

u(x, 0) = 6+4*cos(3*Pi*x/L), (D[1](u))(0, t) = 0, (D[1](u))(L, t) = 0

(1)

`assuming`([pdsolve([pde[1], bc[1]], u(x, t))], [L > 0, k > 0])

u(x, t) = 6+4*cos(3*Pi*x/L)*exp(-9*k*Pi^2*t/L^2)

(2)

pde[2] := diff(g(t, x), t) = diff(g(t, x), x, x)+a*g(t, x); bc[2] := g(0, x) = 1

diff(g(t, x), t) = diff(diff(g(t, x), x), x)+a*g(t, x)

 

g(0, x) = 1

(3)

pdsolve([pde[2], bc[2]])

g(t, x) = exp(a*t)

(4)

pde[3] := diff(u(x, t), t) = diff(u(x, t), x, x)

bc[3] := u(x, 0) = f(x), u(-1, t) = 0, u(1, t) = 0

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

 

u(x, 0) = f(x), u(-1, t) = 0, u(1, t) = 0

(5)

pdsolve([pde[3], bc[3]], u(x, t))

u(x, t) = Sum((Int(f(x)*sin(n*Pi*x), x = -1 .. 1))*sin(n*Pi*x)*exp(-Pi^2*n^2*t), n = 1 .. infinity)

(6)

pde[4] := diff(u(x, t), t) = k*(diff(u(x, t), x, x)); bc[4] := u(0, t) = 0, u(L, t) = 0, u(x, 0) = piecewise(0 < x and x <= (1/2)*L, 1, (1/2)*L < x and x < L, 2)

pde[4] := diff(u(x, t), t) = k*(diff(u(x, t), x, x))

 

u(0, t) = 0, u(L, t) = 0, u(x, 0) = piecewise(0 < x and x <= (1/2)*L, 1, (1/2)*L < x and x < L, 2)

(7)

`assuming`([pdsolve([pde[4], bc[4]], u(x, t))], [L > 0])

u(x, t) = Sum((2*cos((1/2)*Pi*n)+2+4*(-1)^(1+n))*sin(n*Pi*x/L)*exp(-k*Pi^2*n^2*t/L^2)/(Pi*n), n = 1 .. infinity)

(8)

pde[5] := diff(u(x, t), t) = k*(diff(u(x, t), x, x))

bc[5] := (D[1](u))(0, t) = 0, (D[1](u))(L, t) = 0, u(x, 0) = -3*cos(8*Pi*x/L)

diff(u(x, t), t) = k*(diff(diff(u(x, t), x), x))

 

(D[1](u))(0, t) = 0, (D[1](u))(L, t) = 0, u(x, 0) = -3*cos(8*Pi*x/L)

(9)

`assuming`([pdsolve([pde[5], bc[5]], u(x, t))], [0 < L, 0 < k])

u(x, t) = -3*cos(8*Pi*x/L)*exp(-64*k*Pi^2*t/L^2)

(10)

pde[6] := diff(u(x, t), t) = k*(diff(u(x, t), x, x))+f(x, t); bc[6] := u(0, t) = 0, u(l, t) = 0, u(x, 0) = g(x)

diff(u(x, t), t) = k*(diff(diff(u(x, t), x), x))+f(x, t)

 

u(0, t) = 0, u(l, t) = 0, u(x, 0) = g(x)

(11)

pdsolve([pde[6], bc[6]], u(x, t))

u(x, t) = Sum(2*(Int(g(tau1)*sin(Pi*n1*tau1/l), tau1 = 0 .. l))*sin(Pi*n1*x/l)*exp(-k*Pi^2*n1^2*t/l^2)/l, n1 = 1 .. infinity)+Int(Sum(2*(Int(f(x, tau1)*sin(Pi*n*x/l), x = 0 .. l))*sin(Pi*n*x/l)*exp(-k*Pi^2*n^2*(t-tau1)/l^2)/l, n = 1 .. infinity), tau1 = 0 .. t)

(12)

pde[7] := diff(u(x, t), t) = diff(u(x, t), x, x); bc[7] := u(x, 0) = f(x), u(-1, t) = 0, u(1, t) = 0

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

 

u(x, 0) = f(x), u(-1, t) = 0, u(1, t) = 0

(13)

pdsolve([pde[7], bc[7]], u(x, t))

u(x, t) = Sum((Int(f(x)*sin(n*Pi*x), x = -1 .. 1))*sin(n*Pi*x)*exp(-Pi^2*n^2*t), n = 1 .. infinity)

(14)

pde[8] := diff(u(x, t), t) = k*(diff(u(x, t), x, x))-h*u(x, t); bc[8] := u(x, 0) = sin(x), u(-Pi, t) = u(Pi, t), (D[1](u))(-Pi, t) = (D[1](u))(Pi, t)

diff(u(x, t), t) = k*(diff(diff(u(x, t), x), x))-h*u(x, t)

 

u(x, 0) = sin(x), u(-Pi, t) = u(Pi, t), (D[1](u))(-Pi, t) = (D[1](u))(Pi, t)

(15)

pdsolve([pde[8], bc[8]], u(x, t))

u(x, t) = sin(x)*exp(-t*(k+h))

(16)

pde[9] := diff(u(x, t), t) = diff(u(x, t), x, x)

bc[9] := u(0, t) = 20, u(1, t) = 50, u(x, 0) = 0

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

 

u(0, t) = 20, u(1, t) = 50, u(x, 0) = 0

(17)

pdsolve([pde[9], bc[9]], u(x, t))

u(x, t) = 20+Sum((-40+100*(-1)^n)*sin(n*Pi*x)*exp(-Pi^2*n^2*t)/(Pi*n), n = 1 .. infinity)+30*x

(18)

pde[10] := diff(u(x, y), x, x)+diff(u(x, y), y, y) = 0; bc[10] := u(x, 0) = 0, u(x, 1) = 0, u(0, y) = y^2-y, u(1, y) = 0

diff(diff(u(x, y), x), x)+diff(diff(u(x, y), y), y) = 0

 

u(x, 0) = 0, u(x, 1) = 0, u(0, y) = y^2-y, u(1, y) = 0

(19)

pdsolve([pde[10], bc[10]], u(x, y))

u(x, y) = Sum(-4*((-1)^n-1)*sin(Pi*y*n)*(exp(Pi*n*(2*x-1))-exp(Pi*n))*exp(-Pi*n*(x-1))/((exp(2*Pi*n)-1)*Pi^3*n^3), n = 1 .. infinity)

(20)

pde[11] := diff(u(x, y), x, x)+diff(u(x, y), y, y) = 0

bc[11] := (D[1](u))(0, y) = 0, (D[1](u))(L, y) = 0, u(x, H) = f(x), u(x, 0) = 0

diff(diff(u(x, y), x), x)+diff(diff(u(x, y), y), y) = 0

 

(D[1](u))(0, y) = 0, (D[1](u))(L, y) = 0, u(x, H) = f(x), u(x, 0) = 0

(21)

`assuming`([pdsolve([pde[11], bc[11]], u(x, y))], [0 < L, 0 < H])

u(x, y) = Sum(2*(Int(cos(Pi*x*n/L)*f(x), x = 0 .. L))*cos(Pi*x*n/L)*exp(Pi*n*(H-y)/L)*(exp(2*Pi*y*n/L)-1)/(L*(exp(2*Pi*H*n/L)-1)), n = 1 .. infinity)

(22)

pde[12] := diff(u(x, y), x, x)+diff(u(x, y), y, y) = 0

bc[12] := (D[1](u))(L, y) = 0, u(x, H) = 0, u(x, 0) = 0, (D[1](u))(0, y) = g(y)

diff(diff(u(x, y), x), x)+diff(diff(u(x, y), y), y) = 0

 

(D[1](u))(L, y) = 0, u(x, H) = 0, u(x, 0) = 0, (D[1](u))(0, y) = g(y)

(23)

`assuming`([pdsolve([pde[12], bc[12]], u(x, y))], [0 < x, x <= L, 0 < y, y <= H])

u(x, y) = Sum(-2*(Int(sin(Pi*y*n/H)*g(y), y = 0 .. H))*sin(Pi*y*n/H)*(exp(-Pi*n*(L-2*x)/H)+exp(Pi*L*n/H))*exp(Pi*n*(L-x)/H)/(Pi*n*(exp(2*Pi*L*n/H)-1)), n = 1 .. infinity)

(24)

pde[13] := diff(u(x, y), x, x)+diff(u(x, y), y, y) = 0

bc[13] := (D[1](u))(0, y) = 0, u(x, 0) = 0, u(x, H) = 0, u(L, y) = g(y)

diff(diff(u(x, y), x), x)+diff(diff(u(x, y), y), y) = 0

 

(D[1](u))(0, y) = 0, u(x, 0) = 0, u(x, H) = 0, u(L, y) = g(y)

(25)

`assuming`([pdsolve([pde[13], bc[13]], u(x, y))], [0 < L, 0 < H])

u(x, y) = Sum(2*(Int(sin(Pi*y*n/H)*g(y), y = 0 .. H))*sin(Pi*y*n/H)*exp(Pi*n*(L-x)/H)*(exp(2*Pi*x*n/H)+1)/(H*(exp(2*Pi*L*n/H)+1)), n = 1 .. infinity)

(26)

pde[14] := diff(u(x, y), x, x)+diff(u(x, y), y, y) = 0

bc[14] := u(0, y) = g(y), u(L, y) = 0, (D[2](u))(x, 0) = 0, u(x, H) = 0

diff(diff(u(x, y), x), x)+diff(diff(u(x, y), y), y) = 0

 

u(0, y) = g(y), u(L, y) = 0, (D[2](u))(x, 0) = 0, u(x, H) = 0

(27)

`assuming`([pdsolve([pde[14], bc[14]], u(x, y))], [0 < x, x <= L, 0 < y, y <= H])

u(x, y) = Sum(-2*(exp(-(L-2*x)*(1/2+n)*Pi/H)-exp((1/2)*Pi*(1+2*n)*L/H))*cos((1/2)*Pi*(1+2*n)*y/H)*(Int(cos((1/2)*Pi*(1+2*n)*y/H)*g(y), y = 0 .. H))*exp((1/2)*Pi*(1+2*n)*(L-x)/H)/(H*(exp(Pi*(1+2*n)*L/H)-1)), n = 0 .. infinity)

(28)

pde[15] := diff(u(x, y), x, x)+diff(u(x, y), y, y) = 0

bc[15] := u(0, y) = 0, u(L, y) = 0, u(x, 0) = (D[2](u))(x, 0), u(x, H) = f(x)

diff(diff(u(x, y), x), x)+diff(diff(u(x, y), y), y) = 0

 

u(0, y) = 0, u(L, y) = 0, u(x, 0) = (D[2](u))(x, 0), u(x, H) = f(x)

(29)

`assuming`([pdsolve([pde[15], bc[15]], u(x, y))], [0 < x, x <= L, 0 < y, y <= H])

u(x, y) = Sum(2*exp(Pi*n*(H-y)/L)*sin(Pi*x*n/L)*((Pi*n+L)*exp(2*Pi*y*n/L)+Pi*n-L)*(Int(sin(Pi*x*n/L)*f(x), x = 0 .. L))/(L*((Pi*n+L)*exp(2*Pi*H*n/L)+Pi*n-L)), n = 1 .. infinity)

(30)

pde[16] := diff(u(x, t), t, t) = c^2*(diff(u(x, t), x, x))

bc[16] := u(0, t) = 0, (D[1](u))(L, t) = 0, (D[2](u))(x, 0) = 0, u(x, 0) = f(x)

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

 

u(0, t) = 0, (D[1](u))(L, t) = 0, (D[2](u))(x, 0) = 0, u(x, 0) = f(x)

(31)

`assuming`([pdsolve([pde[16], bc[16]], u(x, t))], [0 < x, x <= L])

u(x, t) = Sum(2*cos((1/2)*c*Pi*(1+2*n)*t/L)*(Int(sin((1/2)*Pi*(1+2*n)*x/L)*f(x), x = 0 .. L))*sin((1/2)*Pi*(1+2*n)*x/L)/L, n = 0 .. infinity)

(32)

pde[17] := diff(w(x1, x2, x3, t), t) = diff(w(x1, x2, x3, t), x1, x1)+diff(w(x1, x2, x3, t), x2, x2)+diff(w(x1, x2, x3, t), x3, x3)

bc[17] := w(x1, x2, x3, 0) = exp(x1)+x2*x3^5

diff(w(x1, x2, x3, t), t) = diff(diff(w(x1, x2, x3, t), x1), x1)+diff(diff(w(x1, x2, x3, t), x2), x2)+diff(diff(w(x1, x2, x3, t), x3), x3)

 

w(x1, x2, x3, 0) = exp(x1)+x2*x3^5

(33)

pdsolve([pde[17], bc[17]])

w(x1, x2, x3, t) = Sum(t^n*((proc (U) options operator, arrow; diff(diff(U, x1), x1)+diff(diff(U, x2), x2)+diff(diff(U, x3), x3) end proc)@@n)(exp(x1)+x2*x3^5)/factorial(n), n = 0 .. infinity)

(34)

pde[18] := diff(u(x, t), t)+u(x, t)*(diff(u(x, t), x)) = -x

bc[18] := u(x, 0) = x

diff(u(x, t), t)+u(x, t)*(diff(u(x, t), x)) = -x

 

u(x, 0) = x

(35)

pdsolve([pde[18], bc[18]], u(x, t))

u(x, t) = x/tan(t+(1/4)*Pi)

(36)

pde[19] := diff(u(x, t), t)-u(x, t)^2*(diff(u(x, t), x)) = 3*u(x, t)

bc[19] := u(x, 0) = x

diff(u(x, t), t)-u(x, t)^2*(diff(u(x, t), x)) = 3*u(x, t)

 

u(x, 0) = x

(37)

pdsolve([pde[19], bc[19]], u(x, t))

u(x, t) = -exp(3*t)*((-6*exp(6*t)*x+6*x+9)^(1/2)-3)/(exp(6*t)-1)

(38)

pde[20] := diff(u(x, t), t)-x*u(x, t)*(diff(u(x, t), x)) = 0

bc[20] := u(x, 0) = x

diff(u(x, t), t)-x*u(x, t)*(diff(u(x, t), x)) = 0

 

u(x, 0) = x

(39)

pdsolve([pde[20], bc[20]], u(x, t))

u(x, t) = -LambertW(-t*x)/t

(40)

pde[21] := diff(u(x, t), t)+u(x, t)*(diff(u(x, t), x)) = 0

bc[21] := u(x, 0) = x

diff(u(x, t), t)+u(x, t)*(diff(u(x, t), x)) = 0

 

u(x, 0) = x

(41)

pdsolve([pde[21], bc[21]], u(x, t))

u(x, t) = x/(t+1)

(42)

pde[22] := (t+u(x, t))*(diff(u(x, t), x))+t*(diff(u(x, t), t)) = 0; bc[22] := u(x, 1) = x

(t+u(x, t))*(diff(u(x, t), x))+t*(diff(u(x, t), t)) = 0

 

u(x, 1) = x

(43)

pdsolve([pde[22], bc[22]], u(x, t))

u(x, t) = (t-x-1)/(ln(1/t)-1)

(44)

pde[23] := (diff(r*(diff(u(r, theta), r)), r))/r+(diff(u(r, theta), theta, theta))/r^2 = 0; bc[23] := u(a, theta) = f(theta), u(r, -Pi) = u(r, Pi), (D[2](u))(r, -Pi) = (D[2](u))(r, Pi)

(diff(u(r, theta), r)+r*(diff(diff(u(r, theta), r), r)))/r+(diff(diff(u(r, theta), theta), theta))/r^2 = 0

 

u(a, theta) = f(theta), u(r, -Pi) = u(r, Pi), (D[2](u))(r, -Pi) = (D[2](u))(r, Pi)

(45)

`assuming`([pdsolve([pde[23], bc[23]], u(r, theta), HINT = boundedseries)], [a > 0])

u(r, theta) = (1/2)*(2*(Sum(r^n*(sin(n*theta)*(Int(f(theta)*sin(n*theta), theta = -Pi .. Pi))+cos(n*theta)*(Int(f(theta)*cos(n*theta), theta = -Pi .. Pi)))*a^(-n)/Pi, n = 1 .. infinity))*Pi+Int(f(theta), theta = -Pi .. Pi))/Pi

(46)

pde[24] := diff(g(t, x), t) = diff(g(t, x), x, x)+a*g(t, x); bc[24] := g(0, x) = f(x)

diff(g(t, x), t) = diff(diff(g(t, x), x), x)+a*g(t, x)

 

g(0, x) = f(x)

(47)

pdsolve([pde[24], bc[24]])

g(t, x) = exp(a*t)*invfourier(fourier(f(x), x, s1)*exp(-t*s1^2), s1, x)

(48)

pde[25] := diff(u(x, y), x, x)+diff(u(x, y), y, y) = 0; bc[25] := u(0, y) = y*(-y+1), u(1, y) = 0, (D[2](u))(x, 0) = 0, (D[2](u))(x, 1) = 0

diff(diff(u(x, y), x), x)+diff(diff(u(x, y), y), y) = 0

 

u(0, y) = y*(-y+1), u(1, y) = 0, (D[2](u))(x, 0) = 0, (D[2](u))(x, 1) = 0

(49)

pdsolve([pde[25], bc[25]], u(x, y))

u(x, y) = Sum(2*((-1)^n+1)*cos(Pi*y*n)*(exp(Pi*n*(2*x-1))-exp(Pi*n))*exp(-Pi*n*(x-1))/((exp(2*Pi*n)-1)*Pi^2*n^2), n = 1 .. infinity)

(50)

``


 

Download ImprovementsInPdsolve.mw

Edgardo S. Cheb-Terrab
Physics, Differential Equations and Mathematical Functions, Maplesoft



using with (VLA)

Maple asked by Bakry 5 October 14