Initialise

The Hertzian Dipole antenna

The Hertzian Dipole is a conceptual antenna that carries a constant current along its length.

By laying a number of these small current elements end to end, it is possible to model a physical antenna (such as a half-wave dipole for example).  But since we are only interested in obtaining an expression for the effective area of an Isotropic Antenna (in order to derive The Friis Transmission Equation) the Hertzian Dipole will be sufficient for our needs.

Maxwell's Equations

Since the purpose of a radio antenna is to either launch or to receive radio waves, we know that both the antenna, and the space surrounding the antenna, must satisfy Maxwell's Equations. We define Maxwell's Equations in terms of vector functions using spherical coordinates:

Maxwell–Faraday equation:

Ampère's circuital law (with Maxwell's addition):

Gauss' Law:

Gauss' Law for Magnetism:

Where:

        E is the electric field strength [Volts/m]

        H is the magnetic field strength [Amperes/m]

        J is the current density (current per unit area) [Amperes/m²]

        ρ is the charge density (charge per unit volume) [Coulombs/m³]

        ε is Electric Permittivity

        μ is Magnetic Permeability

Helmholtz decomposition

The Helmholtz Decomposition Theorem states that providing a vector field, (F) satisfies appropriate smoothness and decay conditions, it can be decomposed as the sum of components derived from a scalar field, (Φ) called the "scalar potential", and a vector field (A) called the "vector potential".

F = -VΦ + V×A

And that the scalar (Φ) and vector (A) potentials can be calculated from the field (F) as follows (image from https://en.wikipedia.org/wiki/Helmholtz_decomposition):

Where:

        r is the vector from the origin to the observation point (P) at which we wish to know the scalar or vector potential.

        r' is the vector from the origin to the source of the scalar or vector potential (i.e. a point on the Hertzian Dipole antenna).

        V'·F(r')  is the Divergence of the vector field (F) at source position r'.

        V'×F(r')  is the Curl of the vector field (F) at source position r'.

Calculating the Poynting Vector

We know that the magnitude of the Poynting Vector (S) can be calculated as the cross product of the electric field vector (E) and the magnetic field vector (H) :

        S = -E x H which is analogous to a resistive circuit where power is the product of voltage and current: P=V*I.

We also know that the impedance of free space (Z) can be calculated as the ratio of the electric field (E) and magnetic field (H) vectors: Z = E /H =

This is analogous to a resistive circuit where resistance is the ratio of voltage and current: R=V/I.

This provides two more methods for calculating the Poynting Vector (S):

        S = -E·E/Z which is analogous to a resistive circuit where power, P=V²/R, and:

        S = -H·H*Z which is analogous to a resistive circuit where power, P=I²R.

Since we have obtained an expression for the magnetic field vector (H), we can derive an expression for the Poynting Vector (S):

We can separate out the time variable part to yield:

Where:

And we can visualise this radiation pattern using Maple's plotting tools:

So the Hertzian Dipole produces a electromagnetic radiation pattern with a pleasing doughnut shape :-)

Calculating Antenna Gain

We can calculate the total power radiated by the Hertzian Dipole by integrating the power flux density over all solid angles dΩ=sin(θ) dθ dφ.  Since we have expressed power flux density in terms of watts per square meter, we multiply the solid angle by r² to convert the solid angle expressed in steradians into an area expressed in m².

We can now use this power to calculate the power flux density that would be produced by an isotropic antenna by dividing the total transmitted power by the area of a sphere with radius r:

The Gain of the Hertzian Dipole is defined as the ratio between the maximum power flux density produced by the Hertzian Dipole and the maximum power flux density produced by the isotropic antenna:

Calculating Radiation Resistance

The input impedance of the Hertzian Dipole will have both a real and a reactive part.  The reactive part will be associated with energy storage in the near field and will not contribute to the Poynting Vector in the far-field.  For an ideal antenna (with no resistive power loss) the real part will be responsible for the radiated power:

Calculating the power received by a Hertzian Dipole

If an electromagnetic field (E) is incident on the Hertzian Dipole antenna, it will generate an Electro-Motive Force (EMF) at the antenna terminals.  The EMF will be at a maximum when the transmitter is on the x-y-plane (that is when θ=π/2) and will be zero when the transmitter is on the z-axis.

For and incident E-field:

The z-axis component will be:

The z-axis component of the E-field will create an EMF at the antenna terminals that will draw charge out of the receiver to each tip of the antenna. We can calculate the work done per unit charge by integrating the z-axis component of (E) over the length of the antenna (L):

In order to extract the maximum possible power from the antenna, we will form a conjugate match between the impedance of the antenna and the load.  This means that the load resistance must be the same as the radiation resistance of the antenna.  The voltage developed across the load resistance will therefore be half of the open circuit EMF:

And so the power delivered to the load will be:

Calculating the Effective area of an Isotropic Antenna

We can also calculate the power received by the Hertzian Dipole by multiplying the power flux density arriving at the antenna with the effective area of an isotropic antenna and the gain of the Hertzian Dipole relative to an isotropic antenna:

We can express the incident power flux density in terms of electric field strength and wave impedance:

Rearranging, we obtain an expression for the effective area of the isotropic antenna:

The Friis Transmission Equation

We can calculate the power flux density that would be produced by an isotropic antenna at a distance r from the antenna by dividing the total transmitted power P_tx by the area of a sphere with radius r:

And so the power flux density that would be produced by an antenna with gain G_tx is:

We can calculate the power received by an isotropic antenna by multiplying the power flux density incident onto the antenna with the effective area of an isotropic antenna:

And so the power that would be received by an antenna with gain G_rx is:

The free space path loss is defined as the ratio between the received power and the transmitted power:

And so:

restart;

interface(imaginaryunit=II):

with(LinearAlgebra):

The Euler-Bernoulli beam equation
.

We wish to determine the natural modes of vibration of

a possibly multi-span Euler-Bernoulli beam.

Separate the variables by setting .   We get
-

whence
.

Let .  Then

 and

The idea behind the Krylov-Duncan technique is to express  

in terms an alternative (and equivalent) set of basis
functions  through ,, as
,

where the functions  through  are defined in the next section.

In some literature the symbols , are used for these

functions but I find it more sensible to use the indexed function

notation.

The Krylov-Duncan approach is particularly effective in formulating
and finding a multi-span beam's natural modes of vibration.

The Krylov-Duncan functions

The K[i](x) defined by this proc evaluates to the th

Krylov-Duncan function.

Normally the index  will be in the set, however the proc is

set up to accept any integer index (positive or negative).  The proc evaluates

the index modulo 4 to bring the index into the set .   For

instance, K[5](x) and K[-3](x)i are equivalent to K[1](x) .

Here are the Krylov-Duncan basis functions:

and here is what they look like.  All grow exponentially for large
but are significantly different near the origin.

The cyclic property of the derivatives: 
We have .  Let's verify that:

The fourth derivative of each   function equals itself. This is a consequence of the cyclic property:

The essential property of the Krylov-Duncan basis function is that their

zeroth through third derivatives at  form a basis for :

As noted earlier, in the case of a single-span beam, the modal  shapes

are expressed as
.

Then, due to the cyclic property of the derivatives of the Krylov-Duncan

functions, we see that:
.
.
.
Let us note, in particular, that
,
,
,
.

A general approach for solving multi-span beams

In a multi-span beam, we write  for the deflection of the th span, where

 and where  is the span's length.  The  coordinate indicates the

location within the span, with  corresponding to the span's left endpoint.

Thus, each span has its own  coordinate system.

 
We assume that the interface of the two adjoining spans is supported on springs

which (a) resist transverse displacement proportional to the displacement (constant of

proportionality of   (d for displacement), and (b) resist rotation proportional to the
slope (constant of proportionality of   (t for torsion or twist). The spans are numbered

from left to right. The interface conditions between spans  and +1 are

The special case of a pinned support corresponds to  and .
In that case, condition 3 above implies that ,
and condition 4 implies that

Let us write the displacements  and  in terms of the Krylov-Duncan

functions as:

Then applying the cyclic properties of the Krylov-Duncan functions described

earlier, the four interface conditions translate to the following system of four
equations involving the eight coefficients .

,

which we write as a matrix equation
.

That  coefficient matrix plays a central role in solving

for modal shapes of multi-span beams.  Let's call it .

Note that the value of  enters that matrix only in combinations with
 and .  Therefore we introduce the new symbols

,    .

The following proc generates the matrix .  The parameters  and  

are optional and are assigned the default values of infinity and zero, which

corresponds to a pinned support.

The % sign in front of each Krylov function makes the function inert, that is, it
prevents it from expanding into trig functions.  This is so that we can

see, visually, what our expressions look like in terms of the  functions.  To

force the evaluation of those inert function, we will apply Maple's value function,

as seen in the subsequent demos.

Here is the interface matrix for a pinned support:

And here is the interface matrix for a general springy support:

Note:  In Maple's Java interface, inert quantities are shown in gray.

Note:  The  in this matrix is the length of the span to the left of the interface.
Recall that it is  , not , in the derivation that leads to that matrix.

In a beam consisting of  spans, we write the th span's deflection  as

Solving the beam amounts to determining the  unknowns

which we order as

At each of the  interface supports we have a set of four equations as derived
above, for a total of  equations.  Additionally, we have four user-supplied

boundary conditions -- two at the extreme left and two at the extreme right of the

overall beam.  Thus, altogether we have  equations which then we solve for the

 unknown coefficients .   

The user-supplied boundary conditions at the left end are two equations, each in the
form of a linear combination of the coefficients .  We write  for the
 coefficient matrix of that set of equations.  Similarly, the user-supplied boundary
conditions at the right end are two equations, each in the form of a linear combination
of the coefficients .  We write  for the  coefficient matrix of
that set of equations.   Putting these equations together with those obtained at the interfaces,

we get a linear set of equations represented by a  matrix which can be assembled

easily from the matrices , and .  In the case of a 4-span beam the

assembled matrix looks like this:

The pattern generalizes to any number of spans in the obvious way.

For future use, here we record a few frequently occurring  and  matrices.

The following proc builds the overall matrix in the general case.  It takes
two or three arguments.  The first two arguments are the  matrices
which are called  and  in the discussion above.  If the beam
consists of a single span, that's all the information that need be supplied.
There is no need for the third argument.

In the case of a multi-span beam, in the third argument we supply the
list of the interface matrices  , as in , listed in order
of the supports,  from left to right.   An empty list is also
acceptable and is interpreted as having no internal supports,
i.e., a single-span beam.

For instance, for a single-span cantilever beam of length  we get the following  matrix:

For a two-span beam with with span lengths of  and , and all three
supports pinned,  we get the following  matrix:

The matrix  represents a homogeneous linear system (i.e., the right-hand side vector

is zero.)  To obtain a nonzero solution, we set the determinant of  equal to zero.

That gives us a generally transcendental equation in the single unknown .  Normally

the equation has infinitely many solutions.  We call these  

Remark: In the special case of pinned supports at the interfaces, that is, when
, the matrix  depends only on the span lengths .
It is independent of the parameters  that enter the Euler-Bernoulli
equations.  The frequencies , however, depend on those parameters.

This proc plots the calculated modal shape corresponding to the eigenvalue .
The params argument is a set of equations which define the  numerical values

of all the parameters that enter the problem's description, such as the span

lengths.

It is assumed that in a multi-span beam, the span lengths are named  etc.,
and in a single-span beam, the length is named .

A single-span pinned-pinned beam

Here we calculate the natural modes of vibration of a single span

beam, pinned at both ends.  The modes are of the form

The matrix  is:

The characteristic equation:

We conclude that the eigenvalues are .

A non-trivial solution of the system  is in the null-space of :

Here are the weights that go with the Krylov functions:

and here is the deflection:

We see that the shape functions are simple sinusoids.

A single-span free-free beam

Here we calculate the natural modes of vibration of a single span

beam, free at both ends.  The modes are of the form
.

The reasoning behind the calculations is very similar to that in the

previous section, therefore we don't comment on many details.

The characteristic equation:

Let .  Then the characteristic equation takes the form

Here are the graphs of the two sides of the characteristic equation:

The first three roots are:

A single-span clamped-free cantilever

We have a cantilever beam of length .  It is clamped at the

left end, and free at the right end.

Let .  Then the characteristic equation takes the form

Here are the graphs of the two sides of the characteristic equation:

A dual-span pinned-pinned-free cantilever beam

We have a two-span beam of span lengths  and , with the left end of the
first span pinned, the right end of the second span free, and the interface

between the spans on a pinned support.  .

The characteristic equation:

That equation does not seem to be amenable to simplification.  The special case of , however,

is much nicer:

Let :

That expression grows like , so we divide through by that to obtain

a better-behaved equation

Here are the first three roots:

A dual-span clamped-pinned-free cantilever beam

We have a two-span beam of span lengths  and , with the left end of the
first span clamped, the right end of the second span free, and the interface

between the spans on a pinned support.  This is different from the previous

case only in the nature of the left boundary condition.

The characteristic equation:

That equation does not seem to be amenable to simplification.  The special case of , however,

is much nicer:

Let :

That expression grows like , so we divide through by that to obtain

a better-behaved equation

Here are the first three roots:

A triple-span free-pinned-pinned-free beam

We have a triple-span beam with span lengths of .  The beam is supported

on two internal pinned supports.  The extreme ends of the beam are free.

The graphs of the first three modes agree with those

in Figure 3.22 on page 70 of the 2007 article of
Henrik Åkesson, Tatiana Smirnova, Thomas Lagö, and Lars Håkansson.

In the caption of Figure 2.12 on page 28 the span lengths are given
as 3.5, 5.0, 21.5.

The characteristic equation

That graphs grows much too fast to be useful.  We moderate it by dividing through
the fastest growing cosh term:

Here are the first three roots:

A triple-span free-spring-spring-free beam

We have a triple-span beam with span lengths of .  The beam is supported

on two internal springy supports.  The extreme ends of the beam are free.
The numerical data is from the worksheet posted on July 29, 2020 at
https://www.mapleprimes.com/questions/230085-Elasticfoundation-Multispan-EulerBernoulli-Beamthreespan#comment271586

The problem is pretty much the same as the one in the previous section, but the

pinned supports have been replaced by spring supports.

This section's calculations require a little more precision than

Maple's default of 10 digits:

Calculate the determinant of .  The result is quite large, so we terminate the command
with a colon so that not to have to look at the result.  If we bothered to peek,  however, we
will see that the determinant has a factor of .  But that quite obvious by looking at the
entries of the matrix shown above. Two of its rows have  in them and another two have
. When multiplied, they produce the overall factor of .

Here are the parameters that the determinant depends on:

So we provide values for those parameters:

Here is the characteristic equation.  We multiply it by  to remove the singularity at

We can't see anything useful in that graph.  Let's limit the vertical range:

restart:

with(LinearAlgebra):
with(plots):
with(Statistics):

# First example: both A1 and A2 are centered gaussian random variables
#                The order we use (A1 next A2 or A2 next A1) to define Ma doesn't matter

Y   := RandomVariable(Normal(0, .25)):
rho := .9:
Q   := 10^4:
A1  := Sample(Y, Q):
A2  := Sample(Y, Q):
Ma  := `<,>`(`<,>`(A1), `<,>`(A2)):
MA  := Transpose(Ma):
Cor := Matrix([[1, rho], [rho, 1]]):
Cd2 := LUDecomposition(Cor, method = 'Cholesky', output = ['U']):
Rs2 := MA . Cd2:


opts := titlefont = [TIMES, BOLD, 12], symbol=point, transparency=0.5:
A1A2 := ScatterPlot(Column(Rs2, 1), Column(Rs2, 2), title = "Correlated Normal RV", opts, color=blue):



Ma  := `<,>`(`<,>`(A2), `<,>`(A1)):
MA  := Transpose(Ma):
Cor := Matrix([[1, rho], [rho, 1]]):
Cd2 := LUDecomposition(Cor, method = 'Cholesky', output = ['U']):
Rs2 := MA . Cd2:

A2A1 := ScatterPlot(Column(Rs2, 2), Column(Rs2, 1), title = "Correlated Normal RV", opts, color=red):

display(A1A2, A2A1);

# Second example : both A1 and A2 are non-centered gaussian random variables with equal standard deviations.
#                  The order we use to define Ma does matter

Y   := RandomVariable(Normal(1, .25)):
rho := .9:
Q   := 10^4:
A1  := Sample(Y, Q):
A2  := Sample(Y, Q):
Ma  := `<,>`(`<,>`(A1), `<,>`(A2)):
MA  := Transpose(Ma):
Cor := Matrix([[1, rho], [rho, 1]]):
Cd2 := LUDecomposition(Cor, method = 'Cholesky', output = ['U']):
Rs2 := MA . Cd2:


opts := titlefont = [TIMES, BOLD, 12], symbol=point, transparency=0.5:


A1A2 := ScatterPlot(Column(Rs2, 1), Column(Rs2, 2), title = "Correlated Normal RV", opts, color=blue):



Ma  := `<,>`(`<,>`(A2), `<,>`(A1)):
MA  := Transpose(Ma):
Cor := Matrix([[1, rho], [rho, 1]]):
Cd2 := LUDecomposition(Cor, method = 'Cholesky', output = ['U']):
Rs2 := MA . Cd2:

A2A1 := ScatterPlot(Column(Rs2, 2), Column(Rs2, 1), title = "Correlated Normal RV", opts, color=red):

display(A1A2, A2A1);

 

# Second example corrected: to avoid order's dependency proceed this way
#    1/ center A1 and A2
#    2/ correlate the now centered rvs
#    3/ uncenter the couple of correlated rvs


C1  := convert(Scale(A1, scale=Mean), Vector[row]):
C2  := convert(Scale(A2, scale=Mean), Vector[row]):

Ma  := `<,>`(`<,>`(C1), `<,>`(C2)):
MA  := Transpose(Ma):
Cor := Matrix([[1, rho], [rho, 1]]):
Cd2 := LUDecomposition(Cor, method = 'Cholesky', output = ['U']):
Rs2 := MA . Cd2:


opts := titlefont = [TIMES, BOLD, 12], symbol=point, transparency=0.5:


A1A2 := ScatterPlot(Column(Rs2, 1)+~Mean(A1), Column(Rs2, 2)+~Mean(A2), title = "Correlated Normal RV", opts, color=blue):



Ma  := `<,>`(`<,>`(C2), `<,>`(C1)):
MA  := Transpose(Ma):
Cor := Matrix([[1, rho], [rho, 1]]):
Cd2 := LUDecomposition(Cor, method = 'Cholesky', output = ['U']):
Rs2 := MA . Cd2:

A2A1 := ScatterPlot(Column(Rs2, 2)+~Mean(A1), Column(Rs2, 1)+~Mean(A2), title = "Correlated Normal RV", opts, color=red):

display(A1A2, A2A1);

# Third example : both A1 and A2 are centered gaussian random variables with unequal standard deviations.
#                 The order we use to define Ma does matter

rho := .9:
Q   := 10^4:
A1  := Sample(Normal(0, 1), Q):
A2  := Sample(Normal(0, 2), Q):
Ma  := `<,>`(`<,>`(A1), `<,>`(A2)):
MA  := Transpose(Ma):
Cor := Matrix([[1, rho], [rho, 1]]):
Cd2 := LUDecomposition(Cor, method = 'Cholesky', output = ['U']):
Rs2 := MA . Cd2:


opts := titlefont = [TIMES, BOLD, 12], symbol=point, transparency=0.5:


A1A2 := ScatterPlot(Column(Rs2, 1), Column(Rs2, 2), title = "Correlated Normal RV", opts, color=blue):



Ma  := `<,>`(`<,>`(A2), `<,>`(A1)):
MA  := Transpose(Ma):
Cor := Matrix([[1, rho], [rho, 1]]):
Cd2 := LUDecomposition(Cor, method = 'Cholesky', output = ['U']):
Rs2 := MA . Cd2:

A2A1 := ScatterPlot(Column(Rs2, 2), Column(Rs2, 1), title = "Correlated Normal RV", opts, color=red):

display(A1A2, A2A1);

# Third example corrected: to avoid order's dependency proceed this way
#    1/ scale A1 and A2
#    2/ correlate the now scaled rvs
#    3/ unscale the couple of correlated rvs


C1  := A1 /~ StandardDeviation(A1):
C2  := A2 /~ StandardDeviation(A2):

Ma  := `<,>`(`<,>`(C1), `<,>`(C2)):
MA  := Transpose(Ma):
Cor := Matrix([[1, rho], [rho, 1]]):
Cd2 := LUDecomposition(Cor, method = 'Cholesky', output = ['U']):
Rs2 := MA . Cd2:


opts := titlefont = [TIMES, BOLD, 12], symbol=point, transparency=0.5:


A1A2 := ScatterPlot(Column(Rs2, 1)*~StandardDeviation(A1), Column(Rs2, 2)*~StandardDeviation(A2), title = "Correlated Normal RV", opts, color=blue):



Ma  := `<,>`(`<,>`(C2), `<,>`(C1)):
MA  := Transpose(Ma):
Cor := Matrix([[1, rho], [rho, 1]]):
Cd2 := LUDecomposition(Cor, method = 'Cholesky', output = ['U']):
Rs2 := MA . Cd2:

A2A1 := ScatterPlot(Column(Rs2, 2)*~StandardDeviation(A1), Column(Rs2, 1)*~StandardDeviation(A2), title = "Correlated Normal RV", opts, color=red):

display(A1A2, A2A1);

# More generally: to avoid order's dependency proceed this way
#    1/ transform A1 and A2 into standard gaussian random variables (mean and standard deviation scalings)
#    2/ correlate the now scaled rvs
#    3/ unscale the couple of correlated rvs

# Preliminary
#   the expectation (mean) of a LogNormal rv cannot be 0;
#   as a consequence it is expected that the order used to buid Ma will matter
#
# Proceed as Igor Hlivka did

 

Y   := RandomVariable(LogNormal(.5, .25)):
rho := .9:
Q   := 1000:
A1  := Sample(Y, Q):
A2  := Sample(Y, Q):
Ma  := `<,>`(`<,>`(A1), `<,>`(A2)):
MA  := Transpose(Ma):
Cor := Matrix([[1, rho], [rho, 1]]):
Cd2 := LUDecomposition(Cor, method = 'Cholesky', output = ['U']):
Rs2 := MA . Cd2:

ScatterPlot(A1, A2, color = red, title = ["Raw LogNormal RV", font = [TIMES, BOLD, 12]]):
A1A2 := ScatterPlot(Column(Rs2, 1), Column(Rs2, 2), title = "Correlated LogNormal RV", opts, color=blue):

# And now change, as usual, the order in Ma

Ma  := `<,>`(`<,>`(A2), `<,>`(A1)):
MA  := Transpose(Ma):
Cor := Matrix([[1, rho], [rho, 1]]):
Cd2 := LUDecomposition(Cor, method = 'Cholesky', output = ['U']):
Rs2 := MA . Cd2:

A2A1 := ScatterPlot(Column(Rs2, 2), Column(Rs2, 1), title = "Correlated LogNormal RV", opts, color=red):

display(A1A2, A2A1);

# How can we avoid that the order used to assemble Ma do matter?
#
# A close examination of what was done with gaussiann rvs show that in all the cases we
# went back to standard gaussian rvs before correlating them.
# So let's just do the same thing here.
#
# Of course it's not as immediate as previously...
# (please do not focus on the slowness of the code, it is written to clearly explain 
# what is done, not to be fast)



#-------------------------------------- from Y to standard gaussian
G  := RandomVariable(Normal(0, 1)):
G1 := Vector[row](Q, q -> Quantile(G, Probability(Y > A1[q], numeric), numeric)):
G2 := Vector[row](Q, q -> Quantile(G, Probability(Y > A2[q], numeric), numeric)):
# could be replaced by this faster code
#   cdf_Y := unapply(CDF(Y, z), z) assuming z > 0;
#   cdf_G := unapply(CDF(G, z), z);
#   S1    := sort(A1):
#   ini   := -10:
#   V     := Vector[row](Q):
#   for q from 1 to Q do
#     V[q] := fsolve(cdf_G(z)=cdf_Y(S1[q]), z=ini);
#     ini  := V[q]:
#   end do:
#------------------------------------------------------------------

Ma  := `<,>`(`<,>`(G1), `<,>`(G2)):
MA  := Transpose(Ma):
Cor := Matrix([[1, rho], [rho, 1]]):
Cd2 := LUDecomposition(Cor, method = 'Cholesky', output = ['U']):
Rs2 := MA . Cd2:


opts := titlefont = [TIMES, BOLD, 12], symbol=point, transparency=0.5:


#-------------------------------------- from standard gaussian to Y
C1 := Vector[row](Q, q -> Quantile(Y, Probability(G > Rs2[q, 1], numeric), numeric)):
C2 := Vector[row](Q, q -> Quantile(Y, Probability(G > Rs2[q, 2], numeric), numeric)):
#------------------------------------------------------------------
A1A2 := ScatterPlot(C1, C2, title = "Correlated Normal RV", opts, color=blue):



Ma  := `<,>`(`<,>`(G2), `<,>`(G1)):
MA  := Transpose(Ma):
Cor := Matrix([[1, rho], [rho, 1]]):
Cd2 := LUDecomposition(Cor, method = 'Cholesky', output = ['U']):
Rs2 := MA . Cd2:

#-------------------------------------- from standard gaussian to Y
C1 := Vector[row](Q, q -> Quantile(Y, Probability(G > Rs2[q, 1], numeric), numeric)):
C2 := Vector[row](Q, q -> Quantile(Y, Probability(G > Rs2[q, 2], numeric), numeric)):
#------------------------------------------------------------------

A2A1 := ScatterPlot(C2, C1, title = "Correlated Normal RV", opts, color=red):

display(A1A2, A2A1);

restart;

n:=100;

p:= x -> add(a[k]*x^k, k=0..n+1):

collect(expand( p(x+1) - p(x) - x^n ), x):

S:=solve([coeffs(%,x)]):

f:=unapply(expand(eval(p(1-x)-p(x), S)), x);

plot(f, 0..1); # Visual check: f(x)>0 for 0<x<1/2

f(0), f(1/4), f(1/2);

sturm(f(x), x, 0, 1/2);

restart:

with(LinearAlgebra):
with(plots):
with(Statistics):

KG := proc(X, Y, psi, sigma)
  local NX, DX, K, mu, k, y:
  NX := numelems(X);
  DX := < seq(Vector[row](NX, X), k=1..NX) >^+:
  K  := (sigma, psi) -> evalf( sigma^2 *~ exp~(-((DX - DX^+) /~ psi)^~2) ):
  mu := add(Y) / NX;
  k  := (x, sigma, psi) -> evalf( convert(sigma^2 *~ exp~(-((x -~ X ) /~ psi)^~2), Vector[row]) ):
  y  := mu + k(x, sigma, psi) . (K(sigma, psi))^(-1) . convert((Y -~ mu), Vector[column]):
  return y
end proc:


xkcd_hline := proc(p1::list, p2::list, a::nonnegative, lc::positive, col)
  # p1 : first ending point
  # p2 : second ending point
  # a  : amplitude of the random perturbations
  # lc : correlation length
  # col: color
  local roll, NX, LX, X, Z:
  roll := rand(-1.0 .. 1.0):
  NX   := 10:
  LX   := p2[1]-p1[1]:
  X    := [seq(p1[1]..p2[1], LX/(NX-1))]:
  Z    := [p1[2], seq(p1[2]+a*roll(), k=1..NX-1)]:
  return plot(KG(X, Z, lc*LX, 1), x=min(X)..max(X), color=col, scaling=constrained):
end proc:


xkcd_line := proc(L::list, a::nonnegative, lc::positive, col, {lsty::integer:=1})
  # L  : list which contains the two ending point
  # a  : amplitude of the random perturbations
  # lc : correlation length
  # col: color
  local T, roll, NX, DX, DY, LX, A, m, M, X, Z, P:
  T    := (a, x0, y0, l) ->
             plottools:-transform(
               (x,y) -> [ x0 + l * (x*cos(a)-y*sin(a)), y0 + l * (x*sin(a)+y*cos(a)) ]
             ):
  roll := rand(-1.0 .. 1.0):
  NX   := 5:
  DX   := L[2][1]-L[1][1]:
  DY   := L[2][2]-L[1][2]:
  LX := sqrt(DX^2+DY^2):
  if DX <> 0 then
     A := arcsin(DY/LX):
  else
     A:= Pi/2:
  end if:
  X := [seq(0..1, 1/(NX-1))]:
  Z := [ seq(a*roll(), k=1..NX)]:
  P := plot(KG(X, Z, lc, 1), x=0..1, color=col, scaling=constrained, linestyle=lsty):
  return T(A, op(L[1]), LX)(P)
end proc:


xkcd_func := proc(f, r::list, NX::posint, a::positive, lc::positive, col)
  # f  : function to draw
  # r  : plot range
  # NX : number of equidistant "nodes" in the range r (boundaries included)
  # a  : amplitude of the random perturbations
  # lc : correlation length
  # col: color
  local roll, F, LX, Pf, Xf, Zf:
  roll := rand(-1.0 .. 1.0):
  F    := unapply(f, indets(f, name)[1]);
  LX   := r[2]-r[1]:
  Pf   := [seq(r[1]..r[2], LX/(NX-1))]:
  Xf   := Pf +~ [seq(a*roll(), k=1..numelems(Pf))]:
  Zf   := F~(Pf) +~ [seq(a*roll(), k=1..numelems(Pf))]:
  return plot(KG(Xf, Zf, lc*LX, 1), x=min(Xf)..max(Xf), color=col):
end proc:




xkcd_hist := proc(H, ah, av, ax, ay, lch, lcv, lcx, lcy, colh, colxy)
  # H   : Histogram
  # ah  : amplitude of the random perturbations on the horizontal boundaries of the bins
  # av  : amplitude of the random perturbations on the vertical boundaries of the bins
  # ax  : amplitude of the random perturbations on the horizontal axis
  # ay  : amplitude of the random perturbations on the vertical axis
  # lch : correlation length on the horizontal boundaries of the bins
  # lcv : correlation length on the vertical boundaries of the bins
  # lcx : correlation length on the horizontal axis
  # lcy : correlation length on the vertical axis
  # colh: color of the histogram
  # col : color of the axes
  local data, horiz, verti, horizontal_lines, vertical_lines, po, rpo, p1, p2:
  data  := op(1..-2, op(1, H)):
  verti := sort( [seq(data[n][3..4][], n=1..numelems([data]))] , key=(x->x[1]) );
  verti := verti[1],
           map(
                n -> if verti[n][2] > verti[n+1][2] then
                        verti[n]
                      else
                        verti[n+1]
                      end if,
                [seq(2..numelems(verti)-2,2)]
           )[],
           verti[-1];
  horiz := seq(data[n][[4, 3]], n=1..numelems([data])):

  horizontal_lines := NULL:
  for po in horiz do
    horizontal_lines := horizontal_lines, xkcd_hline(po[1], po[2], ah, lch, colh):
  end do:

  vertical_lines := NULL:
  for po in [verti] do
    rpo := po[[2, 1]]:
    vertical_lines := vertical_lines, xkcd_hline([0, rpo[2]], rpo, av, lcv, colh):
  end do:

  p1 := [2*verti[1][1]-verti[2][1], 0]:
  p2 := [2*verti[-1][1]-verti[-2][1], 0]:

  return
    display(
      horizontal_lines,
      T~([vertical_lines]),
      xkcd_hline(p1, p2, ax, lcx, colxy),
      T(xkcd_hline([0, 0], [1.2*max(op~(2, [verti])), 0], ay, lcy, colxy)),
      axes=none,
      scaling=unconstrained
    );
end proc:


xkcd_polyline := proc(L::list, a::nonnegative, lc::positive, col)
  # xkcd_polyline reduces to xkcd_line whebn L has 2 elements
  # L  : List of points
  # a  : amplitude of the random perturbations
  # lc : correlation length
  # col: color
  local T, roll, NX, n, DX, DY, LX, A, m, M, X, Z, P:
  T    := (a, x0, y0, l) ->
             plottools:-transform(
               (x,y) -> [ x0 + l * (x*cos(a)-y*sin(a)), y0 + l * (x*sin(a)+y*cos(a)) ]
             ):
  roll := rand(-1.0 .. 1.0):
  NX   := 5:
  for n from 1 to numelems(L)-1 do
    DX   := L[n+1][1]-L[n][1]:
    DY   := L[n+1][2]-L[n][2]:
    LX := sqrt(DX^2+DY^2):
    if DX <> 0 then
      A := evalf(arcsin(abs(DY)/LX)):
      if DX >= 0 and DY <= 0 then A := -A end if:
      if DX <= 0 and DY >  0 then A := Pi-A end if:
      if DX <= 0 and DY <= 0 then A := Pi+A end if:
    else
      A:= Pi/2:
      if DY < 0 then A := 3*Pi/2 end if:
    end if:
    if n=1 then
      X := [seq(0..1, 1/(NX-1))]:
      Z := [seq(a*roll(), k=1..NX)]:
    else
      X := [0    , seq(1/(NX-1)..1, 1/(NX-1))]:
      Z := [Z[NX], seq(a*roll(), k=1..NX-1)]:
    end if:
    P    := plot(KG(X, Z, lc, 1), x=0..1, color=col, scaling=constrained):
    P||n := T(A, op(L[n]), LX)(P):
  end do;
  return seq(P||n, n=1..numelems(L)-1)
end proc:


xkcd_circle := proc(a::nonnegative, lc::positive, r::positive, cent::list, col)
  # a   : amplitude of the random perturbations
  # lc  : correlation length
  # r   : redius of the circle
  # cent: center of the circle
  # col : color
  local roll, NX, LX, X, Z, xkg, A:
  roll := rand(-1.0 .. 1.0):
  NX   := 10:
  X    := [seq(0..1, 1/(NX-1))]:
  Z    := [0, seq(a*roll(), k=1..NX-1)]:
  xkg  := KG(X, Z, lc, 1):
  A    := Pi*roll():
  return plot([cent[1]+r*(1+xkg)*cos(2*Pi*x+A), cent[2]+r*(1+xkg)*sin(2*Pi*x+A), x=0..1], color=col)
end proc:

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

# Axes plot

x_axis := xkcd_hline([0, 0], [10, 0], 0.03, 0.5, black):
y_axis := xkcd_hline([0, 0], [10, 0], 0.03, 0.5, black):
display(
  x_axis,
  T(y_axis),
  axes=none,
  scaling=constrained
)

# A simple function

f := 1+10*(x/5-1)^2:
F := xkcd_func(f, [0.5, 9.5], 6, 0.3, 0.4, red):

display(
  x_axis,
  T(y_axis),
  F,
  axes=none,
  scaling=constrained
)

# An histogram

S := Sample(Normal(0,1),100):
H := Histogram(S, maxbins=6):
xkcd_hist(H,   0, 0.02, 0.001, 0.01,   1, 0.1, 0.01, 1,   red, black)

# Axes plus grid with two red straight lines

r := rand(-0.1 .. 0.1):

x_axis := xkcd_line([[-2, 0], [10, 0]], 0.01, 0.2, black):
y_axis := xkcd_line([[0, -2], [0, 10]], 0.01, 0.2, black):
d1     := xkcd_line([[-1, 1], [9, 9]] , 0.01, 0.2, red):
d2     := xkcd_line([[-1, 9], [9, -1]], 0.01, 0.2, red):
display(
  x_axis, y_axis,
  seq( xkcd_line([[-2+0.3*r(), u+0.3*r()], [10+0.3*r(), u+0.3*r()]], 0.005, 0.5, gray), u in [seq(-1..9, 2)]),
  seq( xkcd_line([[u+0.3*r(), -2+0.3*r()], [u+0.3*r(), 10+0.3*r()]], 0.005, 0.5, gray), u in [seq(-1..9, 2)]),
  d1, d2,
  axes=none,
  scaling=constrained
)

# Axes and a couple of polygonal lines

d1 := xkcd_polyline([[0, 0], [1, 3], [3, 5], [7, 1], [9, 7]], 0.01, 1, red):
d2 := xkcd_polyline([[0, 9], [2, 8], [5, 2], [8, 3], [10, -1]], 0.01, 1, blue):

display(
  x_axis, y_axis,
  d1, d2,
  axes=none,
  scaling=constrained
)

# A few polygonal shapes

display(
  xkcd_polyline([[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]], 0.01, 1, red),
  xkcd_polyline([[1/3, 1/3], [2/3, 1/3], [2/3, 4/3], [-1, 4/3], [1/3, 1/3]], 0.01, 1, blue),
  xkcd_polyline([[-1/3, -1/3], [4/3, 1/2], [1/2, 1/2], [1/2,-1], [-1/3, -1/3]], 0.01, 1, green),
  axes=none,
  scaling=constrained
)

# A few circles

cols  := [red, green, blue, gold, black]:                                # colors
cents := convert( Statistics:-Sample(Uniform(-1, 3), [5, 2]), listlist): # centers
radii := Statistics:-Sample(Uniform(1/2, 2), 5):                         # radii
lcs   := Statistics:-Sample(Uniform(0.2, 0.7), 5):                       # correlations lengths

display(
  seq(
    xkcd_circle(0.02, lcs[n], radii[n], cents[n], cols[n]),
    n=1..5
  ),
  axes=none,
  scaling=constrained
)

# A 3D drawing

x_axis := xkcd_line([[0, 0], [5, 0]], 0.01, 0.2, black):
y_axis := xkcd_line([[0, 0], [4, 2]], 0.01, 0.2, black):
z_axis := xkcd_line([[0, 0], [0, 5]], 0.01, 0.2, black):

f1 := 4*cos(x/6)-1:
F1 := xkcd_func(f1, [0.5, 5], 6, 0.001, 0.8, red):
F2 := xkcd_line([[0.5, eval(f1, x=0.5)], [3, 4]], 0.01, 0.2, red):
f3 := 4*cos((x-2)/6):
F3 := xkcd_func(f3, [3, 7], 6, 0.001, 0.8, red):
F4 := xkcd_line([[5, eval(f1, x=5)], [7, eval(f3, x=7)]], 0.01, 0.2, red):

dx := xkcd_line([[2, 1], [4, 1]], 0.01, 0.2, gray, lsty=3):
dy := xkcd_line([[2, 0], [4, 1]], 0.01, 0.2, gray, lsty=3):
dz := xkcd_line([[4, 1], [4, 3]], 0.01, 0.2, gray, lsty=3):

po := xkcd_circle(0.02, 0.3, 0.1, [4, 3], blue):

# Numerical value come from "probe info + copy/paste"

nvect   := xkcd_polyline([[4, 3], [4.57, 4.26], [4.35, 4.1], [4.57, 4.26], [4.58, 4.02]], 0.01, 1, blue):
tg1vect := xkcd_polyline([[4, 3], [4.78, 2.59], [4.49, 2.87], [4.78, 2.59], [4.46, 2.57]], 0.01, 1, blue):
tg2vect := xkcd_polyline([[4, 3], [4.79, 3.35], [4.70, 3.13], [4.79, 3.35], [4.46, 3.35]], 0.01, 1, blue):
rec1    := xkcd_polyline([[4.118, 3.286], [4.365, 3.396], [4.257, 3.108]], 0.01, 1, blue):
rec2    := xkcd_polyline([[4.257, 3.108], [4.476, 2.985], [4.259, 2.876]], 0.01, 1, blue):



display(
  x_axis, y_axis, z_axis,
  F1, F2, F3, F4,
  dx, dy, dz,
  po,
  nvect, tg1vect, tg2vect, rec1, rec2,
  axes=none,
  scaling=constrained
)

# Arrow

d1 := xkcd_polyline([[0, 0], [1, 0], [0.9, 0.05], [1, 0], [0.9, -0.05]], 0.01, 1, red):


T := (a, x0, y0, l) ->
             plottools:-transform(
               (x,y) -> [ x0 + l * (x*cos(a)-y*sin(a)), y0 + l * (x*sin(a)+y*cos(a)) ]
             ):


display(
  seq( T(2*Pi*n/10, 0.5, 0, 1/2)(
           display(
              xkcd_polyline(
                  [[0, 0], [1, 0], [0.9, 0.05], [1, 0], [0.9, -0.05]],
                  0.01,
                  1,
                  ColorTools:-Color([rand()/10^12, rand()/10^12, rand()/10^12])
               )
           )
        ),
       n=1..10
  ),
  axes=none,
  scaling=constrained
)