The mean and variance have different units (the variance unit is the square of the mean unit), so it makes no sense to me that you want to add the mean and variance.

@JAMET

S1 must be assigned a value (such as the 441 you showed in the Question) before using that for loop.

@emendes I added a section to my Reply above (right under its gray-background code block) to explain the "level of evaluation", the 2nd argument of the eval command (as it's used for deconstructing unevaluated expressions).

@KIRAN SAJJAN I think you need to change Ans1[j] to Ans1[k] in all the seq statements that use k as the index variable. Also, the Ans1[k], or whatever stores the dsolve solution, must be the first argument of odeplot. There are some places where you have it as the second argument.

@emendes 

Type operator 'identical':

You asked:

•  I need help to understand why you have used identical. 

The type operator identical is an inert operator within the type sublanguage required to use an arbitrary item (in this case a name) as if it were a type. Specifically,

    type(e, identical(x))  if and only if  evalb(e = x).

With multiple arguments, identical(x, y, ...) is equivalent to {identical(x), identical(y), ...}. There is no global meaning of identical outside the type sublanguage.

Explicit arguments vs those assigned to names:

• Could you also tell me why my proc won't work unless I type Excl?

It doesn't require you to use Excl specifically, but as I wrote it above, it does require that the set of excluded names be assigned to some name (rather than being put directly in the procedure call). A modification to allow both forms is given below. Working with unevaluated expressions requires meticulous hygiene, and results are often counter-intuitive (such as this example). It should be avoided unless it's absolutely necessary, which it is in this case. Here's the modification:

SaveNames:= (excl::uneval, fname::{symbol, string})->
    subs(
        _V= remove(
            type, {anames}('user') minus {anames}(procedure), 
            identical(eval(excl, 2)[], eval(excl, 1)[], eval(excl, 1))
        )[],
        proc() save _V, fname end proc
    )()
:
# Now these both work:
SaveNames(
    {'x', 'y'}, 
    #...or...
    (* Excl, *) 
    "V.txt"
);

Levels of evaluation:

Here's how the levels of evaluation work. The level is the positive integer that's the second argument of eval, as in eval(excl, 2). (This usage of eval has no relation to the commonly used command eval(expr, x= a); that's an essentially different command that has the same name.) Suppose that the call to SaveNames is as in the example in my original Answer. Then

• eval(excl, 1) = 'Excl', the global variable passed to the command;
• eval(excl, 2) = {'x', 'y'}, the direct assignment to Excl;
• eval(excl, 3) = {3, 5}, which of course isn't useful for this procedure, it not being a set of names.

But if the call is SaveNames({'x', 'y'}, ...), then

• eval(excl, 1) = {'x', 'y'};
• eval(excl, 2) = {3, 5}. It's okay to have this in the code because it's something that's being remove'd, and remove'ing something that isn't there is harmless.

Using no 2nd argument, eval(excl) means "full evaluation", i.e., evaluation to a level such that a higher level doesn't cause a change.

Typewise exclusions of things akin to procedures:

• I have noticed that if I define SaveNames after Excl, CM_IsStandard will be saved.  How to avoid that?

My guess is that CM_IsStandard is an "appliable module" (a module whose name can be used as if it were a procedure because it has a local or export named ModuleApply). In the remove command, change procedure to appliable, which is a supertype of procedure. If that doesn't fix the problem, I'll need to know what exactly CM_IsStandard is.

I converted this to Post because it is just a statement of fact and suggestion for improvement.

Vote Up: I agree that the icon should be modified. I suggest some flourish (perhap waves with an arrow) that connotes "flow" in one corner.

I think the easiest thing to do is to replace dot (.) by underscore (_) in your file names, except for the file-type extensions if there are any. Although you may not be having major problems yet, this seems like a "bug waiting to happen".

@MaPal93 Maple's internal file format .m isn't human readable, so don't convert it to a PDF. In order to upload it here, change the name to .txt.

@Muhammad_Qozeem The green arrow is in the MaplePrimes editor, not in Maple itself.

Do you mean the mean and standard deviation of the underlying normal random variable, or of the lognormal r.v. itself? I think that the former would be more usual.

@Kitonum I think that your implicitplot3d command is missing a multiplication sign after the y.

@acer It's even more efficient if you avoid direct indexing of the rtable in rtable_scanblock's 1st argument and instead use the 2nd argument to literally specify a "block" (i.e., submatrix, slice, subarray, etc.) for it to "scan":

(m,n):= (99, 10^5):
M:= LinearAlgebra:-RandomMatrix((m,n), density= 0.3):
L1:= CodeTools:-Usage([seq](rtable_scanblock(M, [i, ..], ':-NonZeros'), i= 1..m)):
memory used=9.03KiB, alloc change=0 bytes,
cpu time=234.00ms, real time=231.00ms, gc time=0ns

L2:= CodeTools:-Usage([seq](rtable_scanblock(M[i, ..], [..], ':-NonZeros'), i= 1..m)):
memory used=75.56MiB, alloc change=0 bytes,
cpu time=687.00ms, real time=511.00ms, gc time=265.62ms

evalb(L1=L2);
                              true

What I give here is only a "hunch", i.e., a vague intuitive feeling not backed by direct evidence. I suspect that the solution that you want is a singular solution (like I wrote to you in another thread). That is, I suspect that there is some valuation of some parameters that will yield a solution that cannot be obtained by applying the same valuation to a general solution. The parameter valuations that lead to singular solutions can often be guessed by using valuations that would produce zeros in denominators in the general solution.

@sursumCorda The timing difference that you show is due almost entirely to the different methods of random-number generation: In your fast case, the random numbers are generated all at once in a matrix; in your slow do-loop case, they are generated one pair per iteration. In the example below, I've taken your do-loop case and modified it so that the random numbers are generated in a matrix.
 

Download iRandomPointVector3.mw

@vs140580 Why not just compute the 500x500 (symmetric) correlation matrix? It's much smaller than the 1000x125250 matrix that you're asking for.