## 4009 Reputation

6 years, 176 days

## Maybe this ?Watchout: you did not say wh...

Maybe this ?

Watchout: you did not say what to do if A inter B is the empty set

 > restart:
 > p := proc(A::set, B::set, C::set)    local AB, ABC:    AB := A intersect B:    if AB <> {} then       ABC := AB intersect C:       if ABC <> {} then          return ABC       else          return `union`(seq(AB *~ C[n], n=1..nops(c)))       end if;    else       error  "It's not specified what to do when A inter B = {} "    end if: end proc:
 > a := {x6,x4,x2,x7,x8,x9,x10}:   b := {x2,x3,x5,x8}: c := {x4,x9,x11,x12,x13}:
 > p(a, b, c)
 (1)
 > a := {x6,x4}:   b := {x5,x8}: c := {x12,x13}: p(a, b, c)
 > a := {x6,x4}:   b := {x4, x5,x8}: c := {x4, x12,x13}: p(a, b, c)
 (2)
 >

Sorry, I do not know about this game and I can give an answer because this later depends on the strategy used to form the new teams.
I consider here 2 strategies (one could probably imagine a few others) . One gives the result proposed by CarlLove after Kitonum's correction, the second a rather different result.

You will find the correct values and a numerical simulation for each strategy

 > restart:
 > with(Statistics): with(combinat):
 > # How is the game managed (I do not know about it)? # # Strategy 1: # One decides to form the red team first by randomly picking 5 out of 15 members # Next one decides to form the green team by randomly picking 5 out of the 10 remaining members # The 5 remaining ones form the last (orange) team # # # Strategy 2 # One randomly form 3 new teams of 5 members and randomly decide to color thes teams as red, green, orange

STRATEGY 1

 > ProbabilityToPutFiveBluesInTheRedTeam := mul((6-n)/(15-n), n=0..4); ProbabilityToPutTheLastBlueInTheOrangeTeam := 1/2; ProbabilityStrategy1 := ProbabilityToPutFiveBluesInTheRedTeam * ProbabilityToPutTheLastBlueInTheOrangeTeam ;
 (1)
 > # simulation strategy 1 OriginalBlueTeam   := [B\$6]: OriginalYellowTeam := [Y\$9]: candidates         := [OriginalBlueTeam[], OriginalYellowTeam[]]: N := 10^6: NewTeams := Matrix(N, 3): for n from 1 to N do    x := randperm(candidates):    NewTeams[n, 1] := numelems(select(has, x[ 1.. 5], B)):    NewTeams[n, 2] := numelems(select(has, x[ 6..10], B)):    NewTeams[n, 3] := numelems(select(has, x[11..15], B)): end do: DesiredNumberOfBluesInNewTeams := [5, 0, 1]; # teams ordered red, green, orange FrequencyStrategy1 := add( map(n -> if [entries(NewTeams[n,..], nolist)] = [5, 0, 1] then 1 end if, [\$1..N]) ) / N
 (2)
 > evalf([ProbabilityStrategy1, FrequencyStrategy1]);
 (3)

STRATEGY 2

 > ProbabilityToPutFiveBluesInTheSameTeam   := mul((6-n)/(15-n), n=0..4) * 3; ProbabilityToPutTheLastBlueInAnotherTeam := 1; ProbabilityStrategy2 := ProbabilityToPutFiveBluesInTheSameTeam * ProbabilityToPutTheLastBlueInAnotherTeam ;
 (4)
 > # simulation strategy 2 OriginalBlueTeam   := [B\$6]: OriginalYellowTeam := [Y\$9]: candidates         := [OriginalBlueTeam[], OriginalYellowTeam[]]: N := 10^6: NewTeams := Matrix(N, 3): for n from 1 to N do    x := randperm(candidates):    NewTeams[n, 1] := numelems(select(has, x[ 1.. 5], B)):    NewTeams[n, 2] := numelems(select(has, x[ 6..10], B)):    NewTeams[n, 3] := numelems(select(has, x[11..15], B)): end do: DesiredPartitions := { permute([5, 0, 1])[] }; FrequencyStrategy2 := add( map(n -> if member([entries(NewTeams[n,..], nolist)], DesiredPartitions) then 1 end if, [\$1..N]) ) / N;
 (5)
 > evalf([ProbabilityStrategy2, FrequencyStrategy2]);
 (6)
 >

## plots:-implicitplot(    &...

plots:-implicitplot(
X^3-24.478115*X^2/Y-(0.2038793409e-2+19.08455282*Y/(Y-97.539))*X-.2550630228/Y,
X=0..50,
Y=0..1
);

You can add some options (see implicitplot help page), for onstance  gridrefine=2 to get a smoother plot.

## The Grid Package and the Grid Computing ...

The Grid Package and the Grid Computing Toolbox are two differents things :

• the latter has to be purchased separatetly

In the Maple 2015.2 help pages it's written
Before installing the Grid Computing Toolbox, you must install and activate Maple 18. For details and installation instructions, see the Install.html file on the product disc.
which seems to suggest that the Grid Computing Toolbox was introduced with Maple 18 (???)

## What I understand is that you solve num...

What I understand is that you solve numerically the Heat equation with a time explicit finite difference scheme:

• At each time t[j+1] the solution is explicitely constructed from the knowledge of the solution y(x,t[j]) at previous time t[j] and from the boundary conditions at x=0 and x=2
•
• You use a forward first order approximation of the evolution diff(y(x,t), t) term:
• diff(y(x,t), t) at t=t[j+1] ~ (y(x, t[j+1])-y(x, t[j]) / (t[j+1]-t[j])
•
• You use a centered finite difference approximation of diff(y(x, t), x, x) at point x[k]:
• diff(y(x,t), x, x) at x=x[k] ~ (-y(x[k-1], t) +2*y(x[k], t) - y(x[k+1], t)) /dx^2  where dx = x[k+1]-x[k] = x[k]-x[k-1]

Then your are right  saying that the there is somewhere a tridiagonal matrix (maybe you just did not explain this point clearly enough and that this is which led to all these exchanges).

In fact this tridiagonal matrix represents the discretization of  diff(y(x, t), x, x)  over the whole spatial domain (it would be pentadiagonal if the spatial domain was 2D)

I prepared this worksheet and tried to wrote it the more pedagogical way I could.

I other people here want to contribute to your problem, I hope this worksheet will help them to better understand your question

 > restart;
 > with(plots): interface(rtablesize=10):
 > f:=unapply(-x^2+1,x):
 > mu[1]:=unapply(1/(t^2+1),t):
 > mu[2]:=unapply(1/(t-5),t):
 > g:=unapply(t^3-7*x,[t,x]):
 > l   :=  2: T := 3:
 > n   := 10: m := n:
 > h   := l/n;
 > tau := T/m; CFL := tau/h^2; if CFL >= 1/2 then WARNING("The CFL condition is not verified, the scheme is unstable") end if;
 > # Finite differences approcimations # # y  stands for the solution at some time j # yF stands for the solution at next time j+1 (F = Future) FD_T  := k -> (yF[k]-y[k]) / tau: FD_X  := k -> (y[k+1]-y[k]) / h: CDD_X := k -> simplify((FD_X(k,j)-FD_X(k-1,j)) / h): # examples FD_T(k); FD_X(k); CDD_X(k);
 (1)
 > # Evolution equation from time j to time j+1, at centered location k eq := (k,j) -> FD_T(k) = CDD_X(k) + g(t[j], x[k]): Updator := (k, j) -> solve(eq(k,j), yF[k]): # examples eq(k, j); Updator(k, j);
 (2)
 > # Stationary matrix (boundary conditions not already accounted for) # interface(rtablesize=n+1): StationaryMatrix := Matrix(n+1, n+1, (k, kk) -> coeff(Updator(k, j), y[2*k-kk])):
 > # Source Vector at any time j > 0 SourceVector := Vector[column](n+1, k -> g(t[j], x[k-1])):
 > # Variables at time j  (boundary conditions not already accounted for) Vars := Vector[column](n+1, k -> y[k-1]):
 > # Boundary conditions at k=0 StationaryMatrix[1, 1]      := 1: StationaryMatrix[1, 2..n+1] := 0: SourceVector[1]             := mu[1](t[j]): # Boundary conditions at k=n StationaryMatrix[n+1, 1..n] := 0: StationaryMatrix[n+1, n+1]  := 1: SourceVector[n+1]           := mu[2](t[j]):
 > # uncomment to vizualize # StationaryMatrix , Vars,  SourceVector
 > # spatial mesh and time marching x := h *~ [\$0..n]; t := tau *~ [\$0..m];
 (3)
 > # Initial value of y (j=0) Y0 := [seq(f(x[k]), k=1..n+1)]
 (4)
 > # Value of y at future time j+1 given the solution at time j Y := Matrix(n+1, evalf(Y0)): for j from 2 to m do Y[.., j-1];   Y := < Y | StationaryMatrix . Y[.., j-1] + SourceVector > end do: # uncomment to vizualize # evalf[4](Y);
 > plots:-matrixplot(Y, heights=histogram, labels=['x', 't', 'Y'])

Let's do the same thing while respecting the CFL condition
Divide the time step by 20:

 > restart;
 > with(plots): interface(rtablesize=10):
 > f:=unapply(-x^2+1,x):
 > mu[1]:=unapply(1/(t^2+1),t):
 > mu[2]:=unapply(1/(t-5),t):
 > g:=unapply(t^3-7*x, [t,x]): l   :=  2: T := 3:
 > n   := 10: m := n*16:
 > h   := l/n:
 > tau := T/m: CFL := tau/h^2; if CFL >= 1/2 then WARNING("The CFL condition is not verified, the scheme is unstable") end if;
 (5)
 > FD_T  := k -> (yF[k]-y[k]) / tau: FD_X  := k -> (y[k+1]-y[k]) / h: CDD_X := k -> simplify((FD_X(k,j)-FD_X(k-1,j)) / h): eq := (k,j) -> FD_T(k) = CDD_X(k) + g(t[j], x[k]): Updator := (k, j) -> solve(eq(k,j), yF[k]): StationaryMatrix := Matrix(n+1, n+1, (k, kk) -> coeff(Updator(k, j), y[2*k-kk])): SourceVector     := Vector[column](n+1, k -> g(t[j], x[k-1])): Vars             := Vector[column](n+1, k -> y[k-1]): StationaryMatrix[1, 1]      := 1: StationaryMatrix[1, 2..n+1] := 0: SourceVector[1]             := mu[1](t[j]): StationaryMatrix[n+1, 1..n] := 0: StationaryMatrix[n+1, n+1]  := 1: SourceVector[n+1]           := mu[2](t[j]): x := h *~ [\$0..n]: t := tau *~ [\$0..m]: Y0 := [seq(f(x[k]), k=1..n+1)]: Y := Matrix(n+1, evalf(Y0)): for j from 2 to m do Y[.., j-1];   Y := < Y | StationaryMatrix . Y[.., j-1] + SourceVector > end do: plots:-matrixplot(Y, labels=['x', 't', 'Y'])
 (6)

## To complete tomleslie's answer... I...

I do not know if you are aware of the possibility to parameterize ode systems (ic problems only, not bv problems)?
This is a very interesting feature when the system to solve depends on a large number of parameters, or when you want to study the sensitivity of the solution to those parameters.

In case you would be interested, here is a modification of tomleslie's previous code ("new" commands are blue written).

 > restart:
 > interface(rtablesize=10):
 > # # Define gamma as local (don't like doing this!) #   local gamma:local pi:
 > # # Replaced 'indexed' parameters with 'inert subscript' # parameters - otherwise one gets a problem defining # both the unindexed 'phi' and the indexed phi[c] # if false then   M__h := 100: beta__o := 0.034: beta__j := .025: mu__1 := 0.0004:   epsilon := .7902: alpha := 0.11: psi := 0.000136: phi := 0.05:   omega := .7: eta := .134: delta := .245: f := 0.21:   M__v := 1000: beta__k := 0.09:   mu__v := .0005: M__c := .636:   beta__g := 0.15: mu__c := 0.0019: pi :=0.01231: theta := 0.12: mu__e := 0.005: end if:
 > # # D() is Maple's differential operator replated D(T) # with DD(T) in the following to avoid confusion #   ODE1 := diff(B(T), T) = M__h-beta__o*B(T)-beta__j*B(T)-mu__1*B(T)+epsilon*G(T)+alpha*F(T):   ODE2 := diff(C(T), T) = beta__o*B(T)*J(T)-beta__j*C(T)-(psi+mu__1+phi)*C(T):   ODE3 := diff(DD(T), T) = beta__j*B(T)*L(T)- beta__o*E(T)-(omega+mu__1+eta)*DD(T):   ODE4 := diff(E(T), T) = beta__o*E(T)-beta__j*C(T)-(delta+mu__1+eta+phi)*E(T):   ODE5 := diff(F(T), T) = psi*C(T)-(alpha+mu__1)*F(T)+f*delta*E(T):   ODE6 := diff(G(T), T) = omega*DD(T)-(epsilon+mu__1)*G(T)+(1-f)*delta*E(T):   ODE7 := diff(H(T), T) = M__v-beta__k*H(T)-mu__v*H(T):   ODE8 := diff(J(T), T) = beta__k*H(T)-mu__v*J(T):   ODE9 := diff(K(T), T) = M__c-beta__g*K(T)-mu__c*K(T):   ODE10:= diff(L(T), T) = beta__g*K(T)-mu__c*L(T):   ODE11:= diff(M(T), T) = pi*(DD(T)+ theta*E(T))-mu__e*M(T):
 > if false then   B0 := 100: C0 := 90: D0 := 45: E0 := 38:   F0 := 10: G0 := 45: H0 := 50: J0 := 70: K0 :=20: L0:= 65: M0 :=22: end if:
 > # system + ic sys := { ODE1, ODE2, ODE3, ODE4, ODE5, ODE6, ODE7, ODE8, ODE9, ODE10, ODE11,                    B(0) = B0, C(0) = C0, DD(0) = D0, E(0) = E0,                    F(0) = F0, G(0) = G0, H(0) = H0, J(0) = J0, K(0) = K0, L(0) = L0, M(0) = M0                  }: params := convert(indets(sys, name) minus {T}, list);
 (1)
 > # # Solve system #   ans := dsolve( { ODE1, ODE2, ODE3, ODE4, ODE5, ODE6, ODE7, ODE8, ODE9, ODE10, ODE11,                    B(0) = B0, C(0) = C0, DD(0) = D0, E(0) = E0,                    F(0) = F0, G(0) = G0, H(0) = H0, J(0) = J0, K(0) = K0, L(0) = L0, M(0) = M0                  },                  parameters = params,                  numeric                );
 (2)
 > # define parameter values DefaultValues := [    M__h    = 100,    beta__o = 0.034,    beta__j = .025,    mu__1   = 0.0004,    epsilon = .7902,    alpha   = 0.11,    psi     = 0.000136,    phi     = 0.05,    omega   = .7,    eta     = .134,    delta   = .245,    f       = 0.21,    M__v    = 1000,    beta__k = 0.09,    mu__v   = .0005,    M__c    = .636,    beta__g = 0.15,    mu__c   = 0.0019,    pi      = 0.01231,    theta   = 0.12,    mu__e   = 0.005,       B0 = 100,    C0 = 90,    D0 = 45,    E0 = 38,      F0 = 10,    G0 = 45,    H0 = 50,    J0 = 70,    K0 = 20,    L0 = 65,    M0 = 22 ]:
 > # Form the list of numerical values ordered as params ValuatedParams := subs(DefaultValues, params)
 (3)
 > # Instanciate the solution for this set of values ans(parameters=ValuatedParams)
 (4)
 > # # Plot solutions for a few of the dependent variablss # just to show everything is working (more-or-less!) #   plots:-odeplot( ans, [T, B(T)] , T=0..5); if false then   plots:-odeplot( ans, [T, C(T)] , T=0..5);   plots:-odeplot( ans, [T, DD(T)], T=0..5);   plots:-odeplot( ans, [T, E(T)] , T=0..5);   plots:-odeplot( ans, [T, F(T)] , T=0..5);   plots:-odeplot( ans, [T, G(T)] , T=0..5);   plots:-odeplot( ans, [T, H(T)] , T=0..5);   plots:-odeplot( ans, [T, J(T)] , T=0..5);   plots:-odeplot( ans, [T, K(T)] , T=0..5);   plots:-odeplot( ans, [T, L(T)] , T=0..5);   plots:-odeplot( ans, [T, M(T)] , T=0..5); end if:
 > # How two use the parametric solution? # # Here an example with only one variable parameter, but this could be generalized to many # (the main problem is then more a problem of "readability" than a technical one). # f := proc(VariableName::symbol, ParamName::symbol, ParamValues::list, params, ParamDefault, sol)   local V, k, p, MyChoice, ValuatedParams:   V := unapply(VariableName(T), T):   k := 0:   for p in ParamValues do     k := k+1:     MyChoice       := map(u -> if lhs(u)=ParamName then lhs(u)=p else u end if, ParamDefault):     ValuatedParams := subs(MyChoice, params):     sol(parameters=ValuatedParams):     plot||k := plots:-odeplot(                                sol,                                [T, V(T)] ,                                T=0..5,                                legend=p,                                color=ColorTools:-Color([rand()/10^12, rand()/10^12, rand()/10^12])                              );   end do:   plots:-display(seq(plot||k, k=1..numelems(ParamValues))); end proc:
 > f(C, beta__o, [0.030, 0.034, 0.038], params, DefaultValues, ans)
 >

## Here are a few simple ways to answer you...

 > restart
 > randomize():
 > with(LinearAlgebra):
 > A := RandomMatrix(3)
 (1)
 > # Theses lines to see what happens   1 /~ Diagonal(A): DiagonalMatrix(%):
 > A . DiagonalMatrix(1 /~ Diagonal(A) );
 (2)

Probably better to do this

 > restart:
 > NormalizeMatrix := proc(A::Matrix)   local NR, NL:   NR, NL := LinearAlgebra:-Dimension(A):   if NR <> NL then      error "the input matrix must be a square matrix":      return NULL:   end if:   if mul(A[i,i], i=1..NR) = 0 then      error "the diagonal of the input matrix contains zeroes":      return NULL:   end if:   return Matrix(NR, NR, (i,j) -> A[i,j] / A[i,i]); end proc:
 > randomize():
 > N := 3: A := LinearAlgebra:-RandomMatrix(N, generator=-2..2);
 (3)
 > NormalizeMatrix(A)
 >

## A solution "by hand"   ...

A solution "by hand"

 > restart;
 > sys_Pde := [ diff(V(x, t), x, x) = 0, diff(T(x, t), x, x) = 0 ]:
 > BC := [ eval(diff(V(x, t), x), x = 1) = 0, eval(V(x, t), x = 0) = 1+cos(w*t), eval(T(x, t), x = 0) = 0, eval(T(x, t), x = 1) = 1 ]:
 > sol__1 := pdsolve(sys_Pde);
 (1)
 > bc__0 := eval(sol__1, x=0); bc__1 := eval(sol__1, x=1);
 (2)
 > subs(bc__0 union bc__1, BC): F__cond := simplify(subs(sol__1, %));
 (3)
 > sol__2 := subs(F__cond, sol__1): print~(sol__2):  # _F1(t) is an arbitrary function.
 (4)
 > # check the partial diff. equations eval(sys_Pde, sol__2)
 (5)
 > # check the boundary conditions eval(BC, sol__2)
 (6)
 >

## Fourier coefficients are defined for&nbs...

Fourier coefficients are defined for periodic Lebesgue  integrable  functions.
Your function f does not belong to this class.

A common practice in signal processing for a signal f(t) recorded on a finite interval D, let's say D=[0, T >0] is to periodize f outside of D by replicating it by translations f(t+kT) where t is in Z.
Assuming then f is Lebesgue integrable then computing the Fourier coefficients makes sense (which makes new problems because of the dubbed "aliasing" phenomenon).
Another trick is to consider that a non periodic function is a function of perior=+infinity ... but even in this case f(t)=t^2 doen(t belong to L^1(R)

Your main problem is not to integrate f(t)*cos(omega*t) or f(t)*sin(omega*t), but to reshape f in order that it becomes a periodic Lebesgue square integrable  function.

Note that using Fourier transformation is of no help

## Constructing a plot like the one you giv...

Constructing a plot like the one you give is not a problem.

But I really doubt this kind of 3D plots could be of great interest in PCA.
In PCA, "Biplot" graphics not only represent individuals as points in the plan spanned by two principal directions, but these same individuals as numbers or names, plus the projections (as vectors) of the original factors with their names.
This is fundamental for the analysis of the PCA results where we are not concerned by the shape of a cloud of points, but by the closeness of each of them, considered as a particular individual, to the vector factors.
If you all of this together, it will be a real mess.

The only limit situation where a 2D plot seems more or less relevant is when the number of factors is equal to three
(in this case you can associate a color to each "factor vector", which avoids writting a 3D text to identify it, and interpret the PCA results)  and when the number of individuals is small enough to make the observation of one of them a simple task.

## @LichengZhang   @Carl LoveCarl...

@LichengZhang   @Carl Love

Carl Love already gave an elegant answer to the question "How many cycles of length n does a given Graph contain?" (which obiously includes your first one " I'd like to know  whether it contains a C4 (cycle of 4) as its subgraph"

I authorise myself to reproduce Carl's code here

 > restart:
 > with(GraphTheory): with(RandomGraphs):
 > randomize():
 > NV := 8: NE := 12: G  := RandomGraph(NV, NE):
 > # The code below has been written by Carl Love # https://www.mapleprimes.com/questions/226523-How-To-Determine-The-Number-Of-Circles-Of--Graph-#answer257002 kCycles:= (A::Matrix, n::posint, k::And(posint, Not({1,2})))->    add(        (-1)^(k-i)*binomial(n-i,n-k) *          add(LinearAlgebra:-Trace(A[S,S]^k), S= combinat:-choose(n,i)),        i= 2..k    )/2/k:
 > # How to use it (cf above link) A:= GraphTheory:-AdjacencyMatrix(G): seq(printf("G contains %2d cycles of length %2d\n", kCycles(A, NV, k), k), k= 3..NV);
 G contains  2 cycles of length  3 G contains  5 cycles of length  4 G contains  6 cycles of length  5 G contains  5 cycles of length  6 G contains  4 cycles of length  7 G contains  0 cycles of length  8
 >

Does a given Graph contain K(n) where K(n) is the complete graph with n vertices?
GraphTheory:-CliqueNumber(G) returns the highest value of N fpr wich K(N) is a complete subgraph of G.
Then, G contains at least one complete subgraph K(n) for n=3..N.
Conversely, G contains no complete subgraph K(n) such that n > N

## Here is an example (adapt it with  ...

Here is an example (your own file is treated later)

Be carefull: as recently mentioned in another thread, Maple doesn't support loops (FromVertex = ToVertex)

PS: if your graph is not oriented, you can replace
edges := { convert(M, listlist)[] }
by
edges := { convert~(convert(M, listlist), set)[] }

 > restart:
 > kernelopts(homedir): file := cat(%, "/Desktop/graph.xlsx"):
 > M := Import(file);
 (1)
 > M := map(round, M);
 (2)
 > edges := { convert(M, listlist)[] }
 (3)
 > G :=GraphTheory:-Graph(edges)
 (4)
 > GraphTheory:-DrawGraph(G)
 >

Now the worksheet with your own file (2896 Vertices graph)
You will have a lot of work to do to obtain a readable display !

Excel2Graph_bis.mw

## Here are plots for 1 and 2 categorical v...

Here are plots for 1 and 2 categorical variables.
They were done with Maple 2015. I do not have Maple 2018 on this laptop and I do not remember if Maple 2018 has, or not,  specific  features to plot categorical variables

For an unknown reason I can't load the content of the worksheet

CategoricalVariables.mw

PS to customize the 3D plots you might try other commands than
plottools:-line( [i, j, 0], [i, j, Sizes[i, j]], thickness=10, color=GenderColor[i]),
for instance, having set GenderColor := [blue, red]:
plottools:-cylinder([i, j, 0], 0.2, Sizes[i, j], color=GenderColor[i], style=surface),

## Why not solving  symbolically ...

Why not solving  symbolically with formal parameters instead of numeric ones, and next substituting the formal parameters by the suitable numerical values?

 > ode1 := (2/3)*diff(theta(t), t\$2)+A__1*theta(t)-A__2*x(t) = 0;
 (1)
 > ode2 := 2*diff(x(t),t\$2)+B__1*x(t)-B__2*theta(t) =B__3*sin(B__4*t);
 (2)
 > ics := theta(0) = 0, (D(theta))(0) = D__1, x(0) = 0, (D(x))(0) = 0
 (3)
 > solution := dsolve([ode1, ode2, ics]):
 > simplify~(eval(solution, [A__1=1250, A__2=500, B__1=1000, B__2=500, B__3=50, B__4=20, D__1=1/100]))
 (4)
 > simplify~(eval(solution, [A__1=1250, A__2=500, B__1=1000, B__2=500, B__3=50, B__4=90, D__1=1/100]))
 (5)
 >

## Here an answer obviously less concise th...

Here an answer obviously less concise than vv's answer, but I found funny to adress the problem from a pure geometrical point of view.

I had already done this exercise with Geogebra... and I wondered if Maple could do the same ?

Still this f... error
Maple Worksheet - Error
Failed to load the worksheet /maplenet/convert/geometry.mw .