Hi, 

There exists no build-in procedure to do this, but you can use this code (done in Maple 2015, a lot of improvements for customizing a graph exist in earlier versions, so I'm not going to spend time for a better rendering)

 

restart
interface(version)
Standard Worksheet Interface, Maple 2015.2, Mac OS X, December 

   21 2015 Build ID 1097895

with(GraphTheory):

R := plottools:-transform((x,y) -> [-y,x]):

A    := `#mo(A)`:  # to have the same font aas notA
B    := `#mo(B)`:
C    := `#mo(C)`:
notA := `#mover(mo(A),mo("_"))`:
notB := `#mover(mo(B),mo("_"))`:
notC := `#mover(mo(C),mo("_"))`:

# Step 1
#
# A probability graph is either represented as:
#   1.  a weighted directed graph (Markov processes point of view)
#   2.  a weighted undirected graph (Probability point of view, but in this 
#       case there are implicit rules to avoid representing edges as oriented
#       arcs
#
# Set the boolean variable I_Prefer_Directed_Graphs as you want depending
# on your preference.

I_Prefer_Directed_Graphs := true:  # false

if I_Prefer_Directed_Graphs then

  # Step 1

  DG := Graph({
                [[Omega, A], 1/4], [[Omega, notA], 3/4], 
                [[A, B], 1/2], [[A, notB], 1/2], 
                [[notA, C], 0.237], [[notA, notC], 1-0.237]
             }):

  # Step2 
  #
  # But only undirected graphs can be represented in tree style,
  # So I create here the 

  G := Graph(convert~(Edges(DG), set)):
  P := DrawGraph(G, style=tree, root=Omega):

  # Step 3
  #
  # Now I get the vertices position of the tree graph G and set them as
  # vertices positions of the graph DG

  V  := GetVertexPositions(G):
  GD := Graph(convert~(Edges(G), list)):
  SetVertexPositions(DG, V):
  HighlightVertex(DG, Vertices(DG), white);

  DP := DrawGraph(DG):
  print( plots:-display(R(DP), size=[600, 600]) );

else
  G := Graph({
               [{Omega, A}, 1/4], [{Omega, notA}, 3/4], 
               [{A, B}, 1/2], [{A, notB}, 1/2], 
               [{notA, C}, 0.237], [{notA, notC}, 1-0.237]
            }):
  HighlightVertex(G, Vertices(G), white);
  P := DrawGraph(G, style=tree, root=Omega):
  HighlightVertex(G, Vertices(G), white);
  print( plots:-display(R(P), size=[600, 600]) );

end if:

Probability_Graph.mw

You might find useful informations here
How to redirect showstat(....) into a file ?

does this suit you?

restart:
expr:=y^2+y^3*sin(x)+3*x*y^5;
convert(expr, horner, y);
#
expr:=y^2*f(y)+y^3*sin(x)*g(y)+3*x;
convert(expr, horner, y);

horner.mw

Maybe this?
 

restart
assume(x::real, y::real):
z := x+I*y:
f := abs(z-1)+abs(z-I)-2:
plots:-implicitplot(f, x = -2..2, y= -2..2): # OK
g := abs(z-I)-abs(z+1)-2:
plots:-implicitplot(g, x = -2..2, y= -2..2): # KO
sol := [solve(g, y)];
plots:-complexplot(sol, x=-10..10, color=[red, blue]): # OK

Download Z.mw

2*sin(x)*cos(x) = sin(2*x)
next 
sin(2*x) = 2*sin(x)*cos(x)

Download prove.mw

Some typos in your pseudo code... here corrected
 

Download SomeTypos.mw

A possibility is to load the file manually and then read it (look to packages FileTools or ExcelTools, or use readdata).
a smarter one is to use the package URL :

URL:-Get( "https://www.gw-openscience.org/GW150914data/P150914/fig1-observed-H.txt" ):

... but this command returns an uncomprehensible error (maybe it will wotk for you?)
Error, (in URL:-Get) unknown SSL protocol error in connection to www.gw-openscience.org:-9836
 

There is no error with Maple 2015 (and I think with more recent versions neither)
You will find in the attached file 3 different syntaxes:

• with curly brackets,
• with square brackets
• without any brackets.

All of them work correctly but the result may depend on the syntax and the order ( (k, k1) vs (k1, k) ) you use

Maple_2015.mw

A way:


 

Download arrange.mw

Hi,

There are a lot of errors and I doubt you even tried to run this in a Maple worksheet?
Anyway, here is a minimum code to help you do something by yourself:

• change the values of the parameters as you want
• define your own plot (odeplot3 is not a procedure in Maple) and customize it as you want

The rest is on you

Download Try_This.mw

I believe one can print smart tables with Maple too:

(change the format of the column titles to see what happens)

This has been obtained with Maple 2015 and I think it will not work with Maple 2019 or later because the last command 

DocumentTools:-InsertContent(Worksheet(Group(Input( W )))):

has slightly changed from 2015 in more recent versions (unfortunately I do not remember what this change is)
Someone alse here (@acer for instancep will be able to fix this if there is indeed an issue.

 

Download Layout_1.mw

If you want to Export your data use the package ExcelTools (procedure Export).

It's still possible to save as a text file (package FileTools for instance) and next open this file from Excel by carefully choosing the forat of the data

You can also creat a spreadsheet within your MAPLE worksheet by using the Spread package.

Your code doesn' work with my 2015 version and OI have no time to adapt it.
So this is what you must do for this notional example
 

combs := combinat:-permute([a, b, c, d, e], 3)

arrangements := map(convert, {combs[]}, set)

First thing, a solution which uses all your code but the call to LeastSquaresPlot

restart:
UseHardwareFloats := false:

# your code

P := convert(points, listlist):
P := convert(P, Matrix):
Statistics:-LinearFit([1, x], P, x);
   1577.0067814989438 + 245.30627827585107 x

Second thing: your code is amazing slow to run;
You can improve Part A by observing that "dist" can be obtained by sampling a Binomial(n, 1/2) distribution

restart:
with(Statistics):

UseHardwareFloats := false:
dist := proc (n::nonnegint) 
  Sample(Binomial(n, 0.5), 1)[1]:
  round(%-(n-%))
end proc:
CodeTools:-Usage(dist(10^6))  # compare to your own "dist"

ave_dist is the mean of N (N=10000) realizations od dist(n).
A classical result in Statistics is this one :

• if B is Binomial(n, p) and B' is Binomial(n', p) and B and B' are mutually independant, then 
  B+B' is Binomial(n+n', p)

Applied here this gives simply

ave_dist := proc (n::nonnegint, N::nonnegint) 
local B:
B := RandomVariable(Binomial(n*N, 0.5));
# what you want is (Sample(B, 1)[1] - Mean(B))/N
# or more simply
return ( Sample(B, 1)[1] - n*N/2 )/N
end proc:

And there is not need of procedure "dist" any longer (only ave_dist matters)
Now, let's build A:

n := 1000:
N := 10000:
M := 10:
A := Vector(M, i -> ave_dist(n*i, N))

Here is the complete code
 

Download Faster.mw

The linear fit is of course very poor ... you are just trying to fit a random walk by a libear model...

Hi, 

This is not a cpomplete solution (see further) but an explanation: the problem comes from the equation eq2.
Considering it at the "theta equation" we expect (at least MAPLE does) fot it to be of the form 
theta''= F(theta', theta, + the other unknowns and their derivatives, eta) 
But it is fact of the form theta'' (a+b theta'') = F(...) which is not (at least in the classical theory of ODEs, but I do not know much from this one) an ODE.
Try just this to convince yourself

restart:
dsolve({ diff(x(t), t$2)*(1+diff(x(t), t$2))=diff(x(t), t)+1, x(0)=0, D(x)(0)=0}, numeric)
Error, (in DEtools/convertsys) unable to convert to an explicit first-order system

Again this is just an explanation.

But this simple example can be solved if you help MAPLE:
 

restart:
dsolve({ diff(x(t), t$2)*(1+diff(x(t), t$2))=diff(x(t), t)+1, x(0)=0, D(x)(0)=0}, numeric)
Error, (in DEtools/convertsys) unable to convert to an explicit first-order system

# isolate the term x''(t)
isolate(diff(x(t), t$2)*(1+diff(x(t), t$2))=diff(x(t), t)+1, diff(x(t), t$2));
                                                   (1/2)
         d  / d      \     1   1 /      / d      \\     
        --- |--- x(t)| = - - - - |5 + 4 |--- x(t)||     
         dt \ dt     /     2   2 \      \ dt     //     

# solve this new equation
dsolve({ %, x(0)=0, D(x)(0)=0}, numeric)

# of course it's possible that the solution becomes complex beyond some value 
# of t... but this is another problem

Explanation.mw

Applying this "isolation" strategy to your 4 equations makes the problem solvable.
Unfortunately an error occurs, probably because the discriminant the "isolated" eq2 contains is negative: 

 

Download Pblm2_isolated.mw

PS: these equations look like some boundary layer equations in fluid mechanics? If they are classical, algorithms do exist to solve them, have you done some research about this?