12158 Reputation

19 Badges

8 years, 7 days

MaplePrimes Activity

These are answers submitted by vv

This is the first problem of the "Hundred-dollar, Hundred-digit Challenge problems":


The Maple solution was obtained by Robert Israel:



Edit: Mathematica seems to have better algorithms for computing oscillatory integrals.

Too many errors ...

neville:=proc(X::list,Y::list,x) # polynomial interpolation
local T,i,j,n;
T:=Array(0..n, Y);
for j to n do
  for i from 0 to n-j do
  T[i] :=  normal( (T[i]*(X[j+i+1]-x) + T[i+1]*(x-X[i+1]) )/(X[j+i+1]-X[i+1]) )
od; od;



You were told that f is not a pdf unless d=0.

For d=0  f is a Negative binomial distribution which is implemented in Maple, so you can use it.

But you want d>0.

In this case, you probably want to mimic the moments defined for a pdf i.e.

M[k] = Sum( n^k * f(n), n=0..infinity);

But it can be shown that f(n) is equivalent (as n --> infinity) to K/n^2 where K is a nonzero constant.
Hence all the moments are infinite.

Actually, your with your procedure a sequence with both elements is produced. In Maple 2015, Eqplot(2,3) returns 2x+3 and the plot in a reduced size. 

If you use r := Eqplot(2,3), then r[1] equals 2*x+3 and r[2] equals a PLOT structure such that r[2] will display the plot when evaluated.

It would be better to use:

local y,x;
end proc:

This way, Eqplot(2,3) will return 2*x+3 ant the plot itself is produced as a side effect.


an:=2*int( f*cos(Pi*x*n),x=0..1) assuming n::integer;



To compare graphically f with a partial Fourier sum:

s3:=a0/2 + add( eval(an,n=k) * cos(k*Pi*x), k=1..3):

plot([f, s3], x=0..1, view=[-0.2..1.2,-2.2..0.5]);





Install the package in a directory where you have write permission. After the .hdb conversion you can move it into Program Files if you want.

For d=0, f is a PDF  (actually a Negative binomial distribution).

It seems to me (after some investigations) that this is the only case when f is a PDF.
According to Maple, for [r=3, b=2, d=0.01411053479]  f seemed to be a distribution
just because  Sum_x f(x)   is very close to 1 for a small d.


Why don't you use 1D math? Later, you may convert to 2D if you want. All these problems will disappear.

I think that 1D for input and 2D for output is the best choice for now. 

local x,s;
print(plot([f(x),s], x=a..b));
end proc:

f:=x -> x^2:


rad:=u -> `*`(op(map( z->op(1,z),factors(u)[2])));


If _C1 is constant just use _C1 instead of _C1(t).

If _C1(t) etc are already in an expression, use

subs( [_C1(t)=_C1, _C2(t)=_C2, _C3(t)=C3], expr);

You shoud not write in the Program Files directory.
Put your library in a directory where you have write permission. It will work.


local f;
  f:=proc(x,L) local t; member(x,L,t); t end;

# it works for nondistinct elements, provided that {op(L2)} subset {op(L1)}  (of course)
L1:=[a,b,a,a]; L2:=[b,b,b,a];

{op(L2)} subset {op(L1)};
                          [2, 2, 2, 1]
                   [b, b, b, a], [b, b, b, a]

It seems that you want to approach Riemann hypothesis using Maple. :-)

Mathematica seems to have a much better algorithm to approximate Zeta(z) for a large |z|.

Maple computes Zeta(0.6+I*1000000) very slowly (many seconds!). Other CAS-es even refuse to approximate.
It would be interesting to know the algorithm used by Mathematica and its robustness.


The probability of having 0 branch breakings after 40 steps is

1-(1-0.02)^40 = 0.5542995960 (> 1/2)

If you want a simulation to compute the number of branch breaking, you should run your code N times (in a loop) and compute the average number of breaks. (N = 10000 or something).

First 106 107 108 109 110 Page 108 of 110