tomleslie

Seems like very complicated code...

Answered: tomleslie 13876

February 14 2019

1 23

to solve something which is pretty simple - so I may have misunderstood something.

The attached code solves your ODE system for one set off parameter values.

Do you need any more than this??

>

restart;

>

ODEs:= {diff(phi(y), y, y)-Re*Sc*v(y)*(diff(phi(y), y))+Nt*(diff(theta(y), y, y)+(diff(theta(y), y))/y)/Nb = 0,
diff(v(y), y, y)+(diff(v(y), y))/y-(Ha^2/(1-eta)^2+1/y^2)*v(y)-Re*v(y)*(diff(v(y), y)) = 0,
diff(theta(y), y, y)+Ec*Pr*(diff(v(y), y)-v(y)/y)^2-Pr*Re*v(y)*(diff(theta(y), y))+Nb*(diff(theta(y), y))*(diff(phi(y), y))+Nt*(diff(theta(y), y))^2 = 0};

${diff(diff(phi(y), y), y)-Re*Sc*v(y)*(diff(phi(y), y))+Nt*(diff(diff(theta(y), y), y)+(diff(theta(y), y))/y)/Nb = 0, diff(diff(v(y), y), y)+(diff(v(y), y))/y-(Ha^2/(1-eta)^2+1/y^2)*v(y)-Re*v(y)*(diff(v(y), y)) = 0, diff(diff(theta(y), y), y)+Ec*Pr*(diff(v(y), y)-v(y)/y)^2-Pr*Re*v(y)*(diff(theta(y), y))+Nb*(diff(theta(y), y))*(diff(phi(y), y))+Nt*(diff(theta(y), y))^2 = 0}$

(1)

>	BCs := {phi(1) = 0, phi(eta) = 1, theta(1) = 0, theta(eta) = 1, v(1) = 0, v(eta) = 1};

(2)

>	pVals := [eta = .5, Ha = 1, Sc = .8, Nt = .1, Nb = .1, Re = 2, Ec = 0.1e-1, Pr = 10]; sol:=dsolve( `union`(eval(ODEs,pVals), eval(BCs, pVals)), numeric); plots:-odeplot(sol, [y, theta(y)], y=0.5..1); plots:-odeplot(sol, [y, phi(y)], y=0.5..1); plots:-odeplot(sol, [y, v(y)], y=0.5..1);

>

Download odeProb.mw

If you mean...

Answered: tomleslie 13876

February 14 2019

0 1

by "difference quotient", that you want to compute (1/h)*(f(x+h)-f(x)), then the attached should work

>

  restart;
  DQ:= proc( expr, var:=x)
             local f:= unapply(expr, var);
             return simplify((f(var+h)-f(var))/h);
       end proc:
##############################################
# Some examples
##############################################
# If no variable name is supplied as a second
# argument to procedure DQ, then 'x' will be
# used as default
#
  DQ(3-x^2-x);
  DQ(a*x^2+b*x+c);
#
# If using a different variable name, then
# variable name has to be specified
#
  DQ((t-3)/(5-t), t);
  DQ((t-a)/(b-t), t);
  DQ((t-3)/(b-t), t);

(1)

>

Download DQ.mw

Assuming...

Answered: tomleslie 13876

February 14 2019

0 6

that you want to find a set of 16 values which makes the expression=0, or as close as possible.

I didn't have any luck with commands from Maple's in-built Optimization package
Using the (free) addon DirectSearch() available from the Maple Application Centre a pretty plausible solution can be found - ie one can find a set of values for the 16 coefficients so that the resulting value of the original expression will be ~10^-10

If this is not your intent, then you will have to clarify

NB you will not been able to execute the attached until/unless you have the DirectSearch package loaded :-(

>

restart;
#
# Coefficients in OP's expression have about 15-16
# digits. Maple's defauly Digits setting is 10, so
# wind it up a little just to ensure that rounding
# issues won't happen
#
Digits:=20:
expr:=1.47449729919434*10^10*c[0, 1]*c[0, 2]*c[2, 2]*c[3, 0]+3.38624318440755*10^8*c[0, 1]*c[0, 3]*c[1, 0]*c[2, 1]+1.54309415817260*10^10*c[0, 1]*c[0, 3]*c[1, 3]*c[2, 0]+1.69527735464914*10^14*c[0, 2]*c[0, 3]*c[1, 3]*c[3, 3]+5.64571777979530*10^11*c[0, 1]*c[1, 3]*c[3, 0]*c[3, 1]+5.64571777979530*10^11*c[0, 1]*c[1, 1]*c[3, 0]*c[3, 3]+3.44365358352662*10^11*c[0, 1]*c[1, 1]*c[3, 1]*c[3, 2]+4.56141047477722*10^11*c[0, 1]*c[0, 2]*c[2, 1]*c[3, 3]+1.47449729919434*10^10*c[0, 1]*c[0, 2]*c[2, 0]*c[3, 2]+1.00292015075684*10^10*c[0, 1]*c[0, 2]*c[2, 1]*c[3, 1]+4.96419365552208*10^14*c[1, 1]*c[2, 3]*c[3, 1]*c[3, 2]+2.41547661753786*10^16*c[1, 1]*c[2, 3]*c[3, 2]*c[3, 3]+3.09237360954284*10^11*c[0, 2]*c[1, 1]*c[1, 3]*c[3, 1]+2.07077209298372*10^13*c[0, 2]*c[2, 2]*c[2, 3]*c[3, 0]+2.77395036220550*10^11*c[0, 2]*c[1, 1]*c[1, 2]*c[3, 2]+3.25883571082134*10^15*c[1, 2]*c[2, 3]*c[3, 1]*c[3, 2]+2.77442234357198*10^11*c[0, 2]*c[1, 1]*c[2, 1]*c[2, 3]+7.80736282336175*10^14*c[2, 0]*c[2, 1]*c[3, 2]*c[3, 3]+3.25883571082134*10^15*c[1, 2]*c[2, 2]*c[3, 1]*c[3, 3]+5.35593751087840*10^15*c[1, 2]*c[2, 3]*c[3, 0]*c[3, 3]+3.63255405301248*10^15*c[1, 1]*c[2, 3]*c[3, 1]*c[3, 3]+3.25883571082134*10^15*c[1, 2]*c[2, 1]*c[3, 2]*c[3, 3]+1.48022406855142*10^13*c[1, 0]*c[2, 1]*c[2, 2]*c[3, 3]+5.19766484559825*10^15*c[0, 1]*c[2, 3]*c[3, 2]*c[3, 3]+3.63255405301248*10^15*c[1, 3]*c[2, 1]*c[3, 1]*c[3, 3]+1.03156027712140*10^14*c[0, 3]*c[1, 2]*c[1, 3]*c[2, 3]+6.84418565576730*10^13*c[1, 1]*c[1, 2]*c[1, 3]*c[3, 3]+1.36253689407226*10^13*c[0, 1]*c[1, 2]*c[2, 3]*c[3, 2]+4.50722523384354*10^11*c[0, 1]*c[0, 2]*c[1, 2]*c[3, 3]+4.63272867590191*10^14*c[1, 1]*c[1, 3]*c[2, 3]*c[3, 2]+9.56722337372450*10^9*c[0, 1]*c[0, 2]*c[1, 2]*c[1, 3]+7.56283392524430*10^14*c[0, 3]*c[1, 1]*c[2, 3]*c[3, 3]+1.51879056084535*10^13*c[0, 3]*c[1, 1]*c[2, 3]*c[3, 1]+8.15436050904650*10^14*c[1, 1]*c[2, 3]*c[3, 0]*c[3, 3]+1.51879056084535*10^13*c[0, 1]*c[1, 1]*c[2, 3]*c[3, 3]+3.05712170936082*10^11*c[0, 1]*c[1, 1]*c[1, 3]*c[2, 3]+2.21942429315476*10^9*c[0, 1]*c[0, 2]*c[1, 0]*c[3, 2]+1.50960286458333*10^9*c[0, 1]*c[0, 2]*c[1, 1]*c[3, 1]+6.37602806091310*10^9*c[0, 1]*c[1, 1]*c[1, 2]*c[1, 3]+2.22015380859375*10^7*c[0, 0]*c[1, 0]*c[1, 1]*c[3, 0]+2.24812825520834*10^6*c[0, 0]*c[0, 1]*c[1, 0]*c[2, 1]+2.24812825520834*10^6*c[0, 0]*c[0, 1]*c[1, 1]*c[2, 0]+4.45556640625000*10^5*c[0, 0]*c[0, 1]*c[0, 2]*c[1, 0]+1.80236816406250*10^7*c[0, 0]*c[0, 2]*c[0, 3]*c[1, 0]+9.99813988095240*10^6*c[0, 1]*c[1, 0]*c[1, 1]*c[2, 0]+1.64310515873016*10^7*c[0, 0]*c[0, 1]*c[1, 0]*c[3, 1]+1.09924316406250*10^7*c[0, 0]*c[0, 1]*c[0, 2]*c[1, 2]+1.22578938802084*10^7*c[0, 0]*c[0, 1]*c[0, 3]*c[1, 1]+6.74438476562500*10^5*c[0, 0]*c[0, 1]*c[1, 0]*c[2, 0]+3.27484130859375*10^7*c[0, 0]*c[0, 1]*c[2, 0]*c[3, 0]+4.96419365552208*10^14*c[1, 1]*c[2, 2]*c[3, 1]*c[3, 3]+1.48022406855142*10^13*c[1, 2]*c[2, 0]*c[2, 1]*c[3, 3]+1.48022406855142*10^13*c[1, 2]*c[2, 0]*c[2, 3]*c[3, 1]+7.00457388588595*10^14*c[1, 2]*c[2, 0]*c[2, 3]*c[3, 3]+9.01806926154510*10^12*c[1, 2]*c[2, 1]*c[2, 2]*c[3, 1]+4.26195329427362*10^14*c[1, 1]*c[2, 2]*c[2, 3]*c[3, 2]+8.70017911044035*10^14*c[1, 1]*c[3, 0]*c[3, 2]*c[3, 3]+1.64960358855012*10^13*c[1, 2]*c[1, 3]*c[3, 0]*c[3, 1]+8.70017911044035*10^14*c[1, 3]*c[3, 0]*c[3, 1]*c[3, 2]+4.11701503132284*10^16*c[1, 3]*c[3, 0]*c[3, 2]*c[3, 3]+1.32823657812862*10^13*c[2, 0]*c[2, 1]*c[2, 2]*c[2, 3]+2.49782355477406*10^13*c[0, 1]*c[0, 3]*c[3, 1]*c[3, 3]+1.86077008928572*10^7*c[0, 0]*c[0, 1]*c[0, 2]*c[0, 3]+4.50750425170068*10^11*c[0, 3]*c[1, 2]*c[1, 3]*c[2, 0]+2.41765159606934*10^10*c[0, 0]*c[0, 2]*c[2, 0]*c[3, 3]+1.28155946659681*10^15*c[2, 0]*c[2, 3]*c[3, 0]*c[3, 3]+7.80736282336175*10^14*c[2, 0]*c[2, 3]*c[3, 1]*c[3, 2]+2.95015059452266*10^13*c[2, 0]*c[2, 3]*c[3, 0]*c[3, 1]+1.64424324035644*10^10*c[0, 1]*c[0, 3]*c[2, 0]*c[3, 1]+7.80736282336175*10^14*c[2, 0]*c[2, 2]*c[3, 1]*c[3, 3]+3.38624318440755*10^8*c[0, 1]*c[0, 3]*c[1, 1]*c[2, 0]+6.83811849201320*10^14*c[0, 2]*c[2, 1]*c[2, 3]*c[3, 3]+4.96419365552208*10^14*c[1, 1]*c[2, 1]*c[3, 2]*c[3, 3]+4.50722523384354*10^11*c[0, 1]*c[0, 2]*c[1, 3]*c[3, 2]+2.74640085129511*10^12*c[0, 3]^2*c[1, 3]*c[3, 0]+4.53797990504672*10^10*c[0, 2]^2*c[2, 0]*c[2, 3]+2.76260943995885*10^10*c[0, 2]^2*c[2, 1]*c[2, 2]+5.63905988420760*10^10*c[0, 3]^2*c[1, 0]*c[3, 1]+2.74640085129511*10^12*c[0, 3]^2*c[1, 0]*c[3, 3]+5.63905988420760*10^10*c[0, 3]^2*c[1, 1]*c[3, 0]+1.67039675031390*10^12*c[0, 3]^2*c[1, 1]*c[3, 2]+1.67039675031390*10^12*c[0, 3]^2*c[1, 2]*c[3, 1]:

>

#
# Assuming OP wants expr=0, the simplest(?) way is
# probably to minimise expr^2
#
  sol:=DirectSearch:-GlobalSearch( expr^2 );
#
# Although DirectSearch is supposed to order all
# the found solutions, it is safer to check the
# value of expr^2 with each of the solutions in
# turn, then seelct the one which provides the
# minimum residual
#
  ind:=min[index]([seq(eval( expr^2, sol[j,2]), j=1..100)]);
#
# Display the solution with the minimum residual
#
  sol[ind,..];
  eval(expr^2, sol[ind,2]);

Array(%id = 18446744074372250670)

(1)

>	# # If one is being pedantic I suppose one ought to # evaluate the residual of the original expression # (ie expr, rather than expr^2 # eval(expr, sol[ind,2]);

(2)

>

Download optProb.mw

Someone smarter than me...

Answered: tomleslie 13876

February 13 2019

0 0

has managed to transfer this from a "post" to a "question", but in doing so has mislaid my original comment/answer, which is now available here

https://www.mapleprimes.com/questions/226450-Sets

For the non-gurus...

Answered: tomleslie 13876

February 13 2019

1 1

My original response stands, but I have been somewhat amused by subsequent contributions. I have therefore (reluctantly) decided to provide an explanation which the casual user of the tolerances() package might actually understand.

So the following is intended for the casual user

#########################################################################################################

When one loads a Maple package such as Tolerances, a few things can happen. The most obvious is that some "new" commands become available: this is pretty obvious. Slightly less obvious, and generally not so clear from the documentation, is that some "existing" commands (and operators) are redefined. This redefinition is referred to by a variety of names such as "overloading" or "rebinding". The drawback with such redefinition is that the casual user may not evan be aware that it has taken place!!!

It is possible to check newly-available commands, and redefinitions by using the exports() command. So for example

restart:
with(Tolerances):
exports(Tolerances);

will return

NominalValue, ToleranceValue, `&+-`, `+`, `*`, `-`, `^`, sqrt, sin, cos, tan, cot, csc, sec, arcsin, arccos, arctan, arccot, arccsc, arcsec, sinh, cosh, coth, tanh, csch, sech, arcsinh, arccosh, arccoth, arctanh, arccsch, arcsech, abs, exp, ln, Ei, FresnelC, FresnelS, Fresnelf, Fresnelg, GAMMA, Psi, LambertW, Zeta, dilog, erf, erfc, Precision, _pexports

Reading this list, it is fairly obvious that a large number of basic Maple commands get redefined/rebound when the Tolerances package is loaded. The most relevant rebindings for the current problem are `+`, and `*`.

Let's be brutally clear: once the Tolerances package is loaded simple addition and multiplication are redefined. However neither the add() command (which must contain a '+' operator somewhere!) not the elementwise operator (~) is respecting these redefinitions.

So congratulations! In the one simple statement

Z := add([3, 2] *~ [x, y]);

you managed to come up with two bugs.

Including my original response, there are many ways to work around these two bugs which I have summarised in the attached. You are of course perfectly free to use whichever you find most convenient/understandable

>

  restart:
  with(Tolerances):
  x := 10 &+-1:
  y := 20 &+- 2:
  z := 3*x+2*y;
  NominalValue(z);      # returns 70 as expected
  ToleranceValue(z);   # returns 7 as expected
  add([3, 2] *~ [x, y]);
#
# My original suggestion
#
  Z:=evalr( add([3, 2] *~ [x, y]));
#
# Acer suggestion
#
  Z:=`+`(zip(`*`,[3,2],[x,y])[]);
#
# Carl Love suggestion
#
  Z:=subsindets(add([3, 2] *~ [x, y]), {:-`*`, :-`+`}, e-> `if`(e:::-`*`, `*`, `+`)(e));

(1)

>

Download tolProb2.mw

use evalr()...

Answered: tomleslie 13876

February 13 2019

1 1

as in the attached - although I'm not exactly sure why this "extra" evaluation stage is necessary

>	restart: with(Tolerances): x := 10 &+-1: y := 20 &+- 2: z := 3x+2y; NominalValue(z); # returns 70 as expected ToleranceValue(z); # returns 7 as expected add([3, 2] ~ [x, y]); Z:=evalr( add([3, 2] ~ [x, y])); NominalValue(Z); ToleranceValue(Z);

(1)

>

Download tolProb.mw

A random guess...

Answered: tomleslie 13876

February 12 2019

0 0

Maybe you and your professor have different typesetting 'levels' set. From the menus try

Tools->Options->Display->TypesettingLevel

whatever you have this set to, "Standard" or "Extended", toggle it to the other setting to see if it makes any difference

A couple of syntax problems...

Answered: tomleslie 13876

February 12 2019

1 0

'if' clause should be if...then...fi rather than if...the...fi
there is an extra '(' in the then clause: either needs to be deleted, or a matching ')' added, depending exactly on what you are trying to calculate

The attached will execute

Download fracProc.mw

I have trouble figuring out...

Answered: tomleslie 13876

February 11 2019

1 4

why you want to do this - I mean do you literally just want to print, maybe for headers in a table or something??? Assuming that this is all you wish to achieve then the the simplest way is shown in the attached

Download oddPrint.mw

Possible(?) solution...

Answered: tomleslie 13876

February 11 2019

4 7

If you use the VectorCalculus (rather than the Student[VectorCalculus]), package then you can define (almost?) any coordinate system you want. So if you don't like default 'spherical' definition, you can change it.

Consider the attached

>

restart;
with(VectorCalculus):
assume( r>0,
        0<=theta, theta<=2*Pi,
        0<=phi,     phi<=Pi
      );
AddCoordinates( mypolar[r, theta, phi],
                [ r*cos(theta)*sin(phi), r*sin(theta)*sin(phi), r*cos(phi)]
              ):
PlotVector( VectorField( <0, theta, 0>,
                         mypolar[r, theta, phi]
                       ),
            r = 0 .. 1,
            theta = 0 .. 2*Pi,
            phi = 0 .. Pi,
            view = [-5..5, -5..5, -10..10],
            arrows = THICK,
            color = black,
            grid = [10, 10, 3],
            view = [-1..1, -1..1, -1..1]
          )

>

Download VFplot.mw

Misuse of brackets (and a few other thin...

Answered: tomleslie 13876

February 11 2019

2 0

In your final expression you have used square brackets (ie '[]') to group terms in an expression. You should only use round brackets (ie '()') to achieve this. Square brackets in Maple designate an indexable quantity (ie list, Array, table, whatever), which I'm pretty sure(?) you don't want
I don't understand why you are plotting 'Re(u)' rather than just 'u'. The latter expression is real for all specified values of the independent variables 'x' and 't, so plotting 'Re(u)' isn't wrong, just superfluous
The way you have defined the plot ranges in your original post, ie plot3d(Re(u), x = -20 .. .20, t = -20 .. .20); implies that x will vary from -20.0 to +0.2. The spacing of the '.' characters is important. This might be a cut-and-paste problem, particularly if your original worksheet was written using 2D-math input). I have assumed that you actually want both independent variables ro vary from -20.0 to +20.0
There is a lot of structure on this plot over the required range which is dominated by the values of +/-1500 at a few points, so I have added a plot which 'zooms' into the z-range -100..100 just to make this detail more visible

See the attached

>

  restart:
  A[0]:= 0:
  A[1]:= sqrt(2*(k[1]^2-w[1]^2))/sqrt(lambda):
  A[2]:= sqrt(2*(k[2]^2-w[2]^2))/sqrt(lambda):
  c[1]:= 1: c[2]:= 1: c[3]:= 1: c[4]:= 1:
  c[5]:= 1: c[6]:= 1:
  k[1]:= 10.5:k[2]:= 3.5:
  w[1]:= 5.05:w[2]:= .5:
  m:= 1.9:
  lambda:= 1.75:
  xi[1]:= -t*w[1]+x*k[1]:
  xi[2]:= -t*w[2]+x*k[2]:
  a:= m/sqrt(k[1]^2-w[1]^2):
  b:= m/sqrt(k[2]^2-w[2]^2):
  g:= a*(c[2]*cos(a*xi[1])-c[3]*sin(a*xi[1])):
  h:= c[1]+c[2]*sin(a*xi[1])+c[3]*cos(a*xi[1]):
  G:= b*(c[5]*cos(b*xi[2])-c[6]*sin(b*xi[2])):
  H:= c[4]+c[5]*sin(b*xi[2])+c[6]*cos(b*xi[2]):
  u:= A[0]+A[1]*(g/h)+A[2]*(G/H);
  plot3d(u, x = -20..20, t = -20..20);
  plot3d(u, x = -20..20, t = -20..20, view=[-20..20, -20..20, -100..100]);

9.841457496*(.2063907138*cos(1.042273105*t-2.167102495*x)+.2063907138*sin(1.042273105*t-2.167102495*x))/(1-sin(1.042273105*t-2.167102495*x)+cos(1.042273105*t-2.167102495*x))+3.703280398*(.5484827558*cos(.2742413779*t-1.919689645*x)+.5484827558*sin(.2742413779*t-1.919689645*x))/(1-sin(.2742413779*t-1.919689645*x)+cos(.2742413779*t-1.919689645*x))

>

Download badpars.mw

Not exactly sure I understand...

Answered: tomleslie 13876

February 08 2019

1 2

but you can control Maple styles from the dropdown menus using (for example)

Format->Styles->Heading1->Modify

This will permit you to adjust (for example) the lineSpacing within, spaceAbove and spaceBelow for all occurrences of the style 'Heading1'

If you wish you can also create your own paragraph styles

So which functionality (exactly) are you missing

Please clarify...

Answered: tomleslie 13876

February 08 2019

1 1

You say that you are

trying element-wise addition of two arrays

How else would arrays add - other than elementwise?? If you have two arrays 'A' and 'B' then 'A+B' will add them (elementwise). So will 'A+~B', but it is just superfluous

In your code, you run a loop 100 times. On each iteration you generate 5000 samples from a Cauchy distribution, add these to a pre-existing array and the throw away the result (since it is never assigned to anything). Thius the array 'AA' will be the same after the loop has terminated as it was before the loop was executed. Is this intentional?

In the Sample() command of your code, you generate samples with the default output format of Vector(), then use these to initialise an Array(), before doing the array addition - seems a very inefficient way to do things??? Either use Vectors throughout, or ensure that the options to the Sample() command are set to automatically return an Array.

Exactly what constitutes too much memory? Maple's memory usage has increased by about 30MB after the calculation. Is this too much?

See the attached for assorted fixes to the above, where (in some cases) I have "guessed" your actual intentions

>

##############################################
# Use Vectors for storage probably(?) the most
# efficient
##############################################
  restart;
  with(Statistics):
#
# Get start time
#
  t1:=time():
#
# Function to obtain "memory usage" in MBytes
#
  getMem:=()-> add
               ( k[3],
                 k in kernelopts(memusage)
               )/(1.0*10^6):
  ss:= 2:
  MaxIt:= 5000:
  AA:= Vector[row]
       ( MaxIt,
         [ seq
           ( i,
             i = 1 .. MaxIt
           )
         ]
       ):
#
# Get memory usage before calculation
#
  M1:= getMem():
  for i to MaxIt do
      AA:= AA+Sample
              ( Cauchy(0, ss),
                MaxIt
              ):
      ss:= ss-1/MaxIt:
  end do:
#
# Get elapsed time
#
  t2:= time()-t1;
#
# Get memory usage after calculation
#
  getMem()-M1;
#
# Force a garbage collection, then
# check the memory again
#
  gc();
  getMem()-M1;

(1)

>

##############################################
# Using Arrays rather than Vectors for storage
##############################################
  restart;
  with(Statistics):
#
# Get start time
#
  t1:= time():
#
# Function to obtain "memory usage" in MBytes
#
  getMem:=()->add( k[3],
                   k in kernelopts(memusage)
                 )/(1.0*10^6):
  ss:= 2:
  MaxIt:= 5000:
  AA:= Array
       ( 1..MaxIt,
         [ seq
           ( i,
             i = 1 .. MaxIt
           )
         ]
       ):
#
# Get memory usage before calculation
#
  M1:= getMem():
  for i to MaxIt do
      AA:= AA+Sample
              ( Cauchy(0, ss),
                1..MaxIt
              ):
      ss:= ss-1/MaxIt:
  end do:
#
# Get elapsed time
#
  t2:=time()-t1;
#
# Get memory usage after calculation
#
  getMem()-M1;
#
# Force a garbage collection, then
# check the memory again
#
  gc();
  getMem()-M1;

(2)

>

Download cauchySample.mw

Sampling witha distribution with zero va...

Answered: tomleslie 13876

February 07 2019

1 1

Same problem as the last time you asked this at

https://www.mapleprimes.com/questions/226422-Gaussian-Distribution-Error

If you want to fail quickly, then try the attached which will 'Error' in less than one second - and it errors when you ask for samples from a normal distribution with zero variance - essentially the same problem as your previous post.

Try thinking!