6563 Reputation

8 years, 102 days

MaplePrimes Activity

These are questions asked by mmcdara

Maple

The automatic transformation below is a rule in Maple

```a := 3:
b := a^2
9
```

that we can prevent using single quotes for instance.

When a is a random variables this becomes

```a := Statistics:-RandomVariable(Uniform(0, 1));
_R
b := a^2
2
_R

# Thus, for instance
Statistics:-Mean(b);
1
-
3

```

Of course you do know that b is defined as a^2, but if you present this to a student it will be puzzled by the output of b containing _R and not a. Of course you can explain it why this happens, but if b has a more complex expression inoking several random variables, it becomes almost impossible to understand what its display means as it contains only names like _R, _R0, ...

To avoid this difficulty a possibility is to reverse the order of the operations this way

```a := 'a':
b := a^2;
2
a
a := Statistics:-RandomVariable(Uniform(0, 1));
_R
# And then
Statistics:-Mean(b);
1
-
3
```

But this become quite tricky in some situations, for instance

```restart:
b := a^2 - Mean(a)^2
2          2
a  - Mean(a)
a := Statistics:-RandomVariable(Uniform(0, 1)):

# The expected result can be got this way
eval(b, Mean = Statistics:-Mean):
Statistics:-Mean(%);
1
--
12
```

Or, if you upload the Statistics package

```restart
with(Statistics):
b := a^2 - ':-Mean'(a)^2
2          2
a  - Mean(a)
a := RandomVariable(Uniform(0, 1)):
eval(b, ':-Mean' = Mean):
Mean(%);
1
--
12
```

As we preserved a comprehensible expression for b in the last two examples, this come at the expense of a more complex calculation of the final result.

My goal is the quite simple:  I would like to preserve as long as possible the original names of the random variables (a in the examples above), and get the desired result without never make their "aliases" _R, _R0, _R1, .... appear in intermediate outputs.
The strategy I use is sketched in the file  Manipulation_of_random_variables.mw

Do you have another idea to achieve this goal?

In fact this question could be also stated "Given a random variable _R, could it be possible to recover the name it has been assigned to. I thought to something like this:

```restart:
a := Statistics:-RandomVariable(Uniform(0, 1));
b := Statistics:-RandomVariable(Uniform(0, 1));
c := 1:
d := [\$1..3]:
_R
_R0

# This seems correct
FromNames2RV := [anames(RandomVariable)] =~ eval([anames(RandomVariable)]);
[b = _R0, a = _R]

# Unfortunately further use of FromNames2RV evaluates its left hand sides
FromNames2RV
[_R0 = _R0, _R = _R]
```

TIA

Unfolding a matrix...

Maple

Let M a block matrix, for instance:

```restart:
S := [a, b, c, d]:
M := Matrix(2\$2, (i, j) -> Matrix(2\$2, symbol=S[2*(i-1)+j]))
```

It is quite simple to transform M into a 4x4 Matrix P with elements

`P[1, 1] = a[1, 1], P[1, 2] = a[1, 2], P[1, 3] = b[1, 1], ..., P[4, 4]= d[2, 2]`

But does it exist a built-in Maple function which does this "unfolding"?

Why am I not able to get the desired int...

Maple 2015

There are things that seem simple but rapidly turn into a nightmare.

Here is an example: what I want is to the expression given at equation (4) in the attached file.

Using Int gives a wrong result.
Using int gives a right one but not of the desired form (some double integrals are nested while others are not).

TIA

 > restart
 > use Statistics in   # For more generality defina an abstract probability distribution.   AbstractDistribution := proc(N)     Distribution(       PDF = (x -> varphi(seq(x[n], n=1..N)))     )   end proc:   # Define two random variables pf AbstractDistribution type.   X__1 := RandomVariable(AbstractDistribution(2)):   X__2 := RandomVariable(AbstractDistribution(2)): end use;
 (1)
 > F := (U1, U2) -> U1/(U1+U2); T := mtaylor(F(X__1, X__2), [X__1=1, X__2=1], 2):
 (2)

Error: x[2] is droped out of the double integral in the rightmost term

 > use IntegrationTools in J := eval([op(expand(T))], [seq(X__||i=x[i], i=1..2)]); L := add(        map(          j ->            if j::numeric then            j          else            (Expand@CollapseNested)(              Int(                j * Statistics:-PDF(X__1, x)                , seq(x[i]=-infinity..+infinity, i=1..2)              )            )          end if          , J        )        ): ET := % end use;
 (3)

I want this

 > 'ET' = 1/2        +        (1/4)*(Int(Int(x[1]*varphi(x[1], x[2]), x[1] = -infinity .. infinity), x[2] = -infinity .. infinity))        -(1/4)*(Int(Int(x[2]*varphi(x[1], x[2]), x[1] = -infinity .. infinity), x[2] = -infinity .. infinity))
 (4)

With int instead of Int one integral is double the other is double-nested

 > L := add(        map(          j ->            if j::numeric then            j          else              int(                j * Statistics:-PDF(X__1, x)                , seq(x[i]=-infinity..+infinity, i=1..2)              )          end if          , J        )        ): ET := %
 (5)

As the expression of ET is now correct, I tried to use IntegrationTools to get the
form I want (equation (4)).

But as soon as I replace int by Int x[2] is again droped out.

So it's not even worth thinking about using CollapseNested!

 > use IntegrationTools in   eval(ET, int=Int);   end use;
 (6)
 >

Should this be considered a simplify bug...

Maple 2015

A case where simplify(...) and simplify~(...) both return the wrong result.
Should we consider this a simplify bug?

 > restart:

A simple case

 > J := Int(r[1]^2*varphi[1](r[1]), r[1] = -infinity .. infinity)      *      Int(r[2]^2*varphi[2](r[2]), r[2] = -infinity .. infinity)
 (1)
 > # OK op(1, J) = simplify(op(1, J))
 (2)
 > # OK op(2, J) = simplify(op(2, J))
 (3)
 > # But... # # Not OK simplify(J)
 (4)
 > # Not OK simplify~(J)
 (5)
 > # OK map(simplify, J)
 (6)

A slightly more complex case

 > J := (Int(r[1]^2*varphi[1](r[1]), r[1] = -infinity .. infinity))*(Int(r[2]^2*varphi[2](r[2]), r[2] = -infinity .. infinity))-(Int(r[1]^2*varphi[1](r[1]), r[1] = -infinity .. infinity))*(Int(r[2]*varphi[2](r[2]), r[2] = -infinity .. infinity))^2;
 (7)
 > is(J=simplify(J))
 (8)
 > is(J=simplify~(J))
 (9)
 > is(J=map(simplify, J)); map(simplify, J);
 (10)
 > add(map(u -> map(simplify, u), [op(J)])); is(J=%);
 (11)
 >

How to define an ordering on partial de...

Maple

Notional example:
I use mtaylor compute the Taylor expansion of a function f (U) of several variables U1, .., UN.
In the resul the terms are ordered this way:

• the leftmost term is f (P) where P denotes the point where the expansion is done
• followed by a succession of terms :
• firstly ranked according to the total order of derivation of  f.
• and among terms of same derivation order, ranked in some kind of lexicographic order

For instance

 > Vars    := [seq(U[i], i=1..2)]: AtPoint := [seq(P[i], i=1..2)]: mt      := mtaylor(f(Vars[]), Vars =~ AtPoint, 3)

 (1)
 > map(t -> op([0, 0], select(has, [op(t)], D)[]), [op(mt)][2..-1])
 (2)

`D[1], D[1, 1], D[1, 2], D[2], D[2, 2]`