using System;

using System.Collections;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Runtime.InteropServices;

using System.Text;

using Numpy.Models;

using Microsoft.VisualStudio.TestTools.UnitTesting;

using Assert = NUnit.Framework.Assert;

namespace Numpy.UnitTest

[TestClass]

public class NumPy_randomTest : BaseTestCase

{

[TestMethod]

public void randTest()

}

[TestMethod]

public void randnTest()

}

[TestMethod]

public void randintTest()

}

[TestMethod]

public void random_integersTest()

}

[TestMethod]

public void random_sampleTest()

}

[TestMethod]

public void randomTest()

}

[TestMethod]

public void ranfTest()

}

[TestMethod]

public void sampleTest()

}

[TestMethod]

public void choiceTest()

}

[TestMethod]

public void bytesTest()

}

[TestMethod]

public void shuffleTest()

}

[TestMethod]

public void permutationTest()

}

[TestMethod]

public void binomialTest()

}

[TestMethod]

public void chisquareTest()

}

[TestMethod]

public void dirichletTest()

}

[TestMethod]

public void fTest()

}

[TestMethod]

public void gammaTest()

{

// Draw samples from the distribution:

// >>> shape, scale = 2., 2. # mean=4, std=2*sqrt(2)

// >>> s = np.random.gamma(shape, scale, 1000)

//

#if TODO

var given= shape, scale = 2., 2. # mean=4, std=2*sqrt(2);

given= s = np.random.gamma(shape, scale, 1000);

#endif

// Display the histogram of the samples, along with

// the probability density function:

// >>> import matplotlib.pyplot as plt

// >>> import scipy.special as sps

// >>> count, bins, ignored = plt.hist(s, 50, density=True)

// >>> y = bins**(shape-1)*(np.exp(-bins/scale) /

// ... (sps.gamma(shape)*scale**shape))

// >>> plt.plot(bins, y, linewidth=2, color='r')

// >>> plt.show()

//

#if TODO

given= import matplotlib.pyplot as plt;

given= import scipy.special as sps;

given= count, bins, ignored = plt.hist(s, 50, density=True);

given= y = bins**(shape-1)*(np.exp(-bins/scale) /;

var expected=

"... (sps.gamma(shape)*scale**shape))";

Assert.AreEqual(expected, given.repr);

given= plt.plot(bins, y, linewidth=2, color='r');

given= plt.show();

#endif

}

[TestMethod]

public void geometricTest()

{

// Draw ten thousand values from the geometric distribution,

// with the probability of an individual success equal to 0.35:

// >>> z = np.random.geometric(p=0.35, size=10000)

//

#if TODO

var given= z = np.random.geometric(p=0.35, size=10000);

#endif

// How many trials succeeded after a single run?

// >>> (z == 1).sum() / 10000.

// 0.34889999999999999 #random

//

#if TODO

given= (z == 1).sum() / 10000.;

var expected=

"0.34889999999999999 #random";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void gumbelTest()

{

// Draw samples from the distribution:

// >>> mu, beta = 0, 0.1 # location and scale

// >>> s = np.random.gumbel(mu, beta, 1000)

//

#if TODO

var given= mu, beta = 0, 0.1 # location and scale;

given= s = np.random.gumbel(mu, beta, 1000);

#endif

// Display the histogram of the samples, along with

// the probability density function:

// >>> import matplotlib.pyplot as plt

// >>> count, bins, ignored = plt.hist(s, 30, density=True)

// >>> plt.plot(bins, (1/beta)*np.exp(-(bins - mu)/beta)

// ... * np.exp( -np.exp( -(bins - mu) /beta) ),

// ... linewidth=2, color='r')

// >>> plt.show()

//

#if TODO

given= import matplotlib.pyplot as plt;

given= count, bins, ignored = plt.hist(s, 30, density=True);

given= plt.plot(bins, (1/beta)*np.exp(-(bins - mu)/beta);

var expected=

"... * np.exp( -np.exp( -(bins - mu) /beta) ),\n" +

"... linewidth=2, color='r')";

Assert.AreEqual(expected, given.repr);

given= plt.show();

#endif

// Show how an extreme value distribution can arise from a Gaussian process

// and compare to a Gaussian:

// >>> means = []

// >>> maxima = []

// >>> for i in range(0,1000) :

// ... a = np.random.normal(mu, beta, 1000)

// ... means.append(a.mean())

// ... maxima.append(a.max())

// >>> count, bins, ignored = plt.hist(maxima, 30, density=True)

// >>> beta = np.std(maxima) * np.sqrt(6) / np.pi

// >>> mu = np.mean(maxima) - 0.57721*beta

// >>> plt.plot(bins, (1/beta)*np.exp(-(bins - mu)/beta)

// ... * np.exp(-np.exp(-(bins - mu)/beta)),

// ... linewidth=2, color='r')

// >>> plt.plot(bins, 1/(beta * np.sqrt(2 * np.pi))

// ... * np.exp(-(bins - mu)**2 / (2 * beta**2)),

// ... linewidth=2, color='g')

// >>> plt.show()

//

#if TODO

given= means = [];

given= maxima = [];

given= for i in range(0,1000) :;

expected=

"... a = np.random.normal(mu, beta, 1000)\n" +

"... means.append(a.mean())\n" +

"... maxima.append(a.max())";

Assert.AreEqual(expected, given.repr);

given= count, bins, ignored = plt.hist(maxima, 30, density=True);

given= beta = np.std(maxima) * np.sqrt(6) / np.pi;

given= mu = np.mean(maxima) - 0.57721*beta;

given= plt.plot(bins, (1/beta)*np.exp(-(bins - mu)/beta);

expected=

"... * np.exp(-np.exp(-(bins - mu)/beta)),\n" +

"... linewidth=2, color='r')";

Assert.AreEqual(expected, given.repr);

given= plt.plot(bins, 1/(beta * np.sqrt(2 * np.pi));

expected=

"... * np.exp(-(bins - mu)**2 / (2 * beta**2)),\n" +

"... linewidth=2, color='g')";

Assert.AreEqual(expected, given.repr);

given= plt.show();

#endif

}

[TestMethod]

public void hypergeometricTest()

{

// Draw samples from the distribution:

// >>> ngood, nbad, nsamp = 100, 2, 10

// # number of good, number of bad, and number of samples

// >>> s = np.random.hypergeometric(ngood, nbad, nsamp, 1000)

// >>> from matplotlib.pyplot import hist

// >>> hist(s)

// # note that it is very unlikely to grab both bad items

//

#if TODO

var given= ngood, nbad, nsamp = 100, 2, 10;

// number of good, number of bad, and number of samples

given= s = np.random.hypergeometric(ngood, nbad, nsamp, 1000);

given= from matplotlib.pyplot import hist;

given= hist(s);

// note that it is very unlikely to grab both bad items

#endif

// Suppose you have an urn with 15 white and 15 black marbles.

// If you pull 15 marbles at random, how likely is it that

// 12 or more of them are one color?

// >>> s = np.random.hypergeometric(15, 15, 15, 100000)

// >>> sum(s>=12)/100000. + sum(s<=3)/100000.

// # answer = 0.003 ... pretty unlikely!

//

#if TODO

given= s = np.random.hypergeometric(15, 15, 15, 100000);

given= sum(s>=12)/100000. + sum(s<=3)/100000.;

// answer = 0.003 ... pretty unlikely!

#endif

}

[TestMethod]

public void laplaceTest()

{

// Draw samples from the distribution

// >>> loc, scale = 0., 1.

// >>> s = np.random.laplace(loc, scale, 1000)

//

#if TODO

var given= loc, scale = 0., 1.;

given= s = np.random.laplace(loc, scale, 1000);

#endif

// Display the histogram of the samples, along with

// the probability density function:

// >>> import matplotlib.pyplot as plt

// >>> count, bins, ignored = plt.hist(s, 30, density=True)

// >>> x = np.arange(-8., 8., .01)

// >>> pdf = np.exp(-abs(x-loc)/scale)/(2.*scale)

// >>> plt.plot(x, pdf)

//

#if TODO

given= import matplotlib.pyplot as plt;

given= count, bins, ignored = plt.hist(s, 30, density=True);

given= x = np.arange(-8., 8., .01);

given= pdf = np.exp(-abs(x-loc)/scale)/(2.*scale);

given= plt.plot(x, pdf);

#endif

// Plot Gaussian for comparison:

// >>> g = (1/(scale * np.sqrt(2 * np.pi)) *

// ... np.exp(-(x - loc)**2 / (2 * scale**2)))

// >>> plt.plot(x,g)

//

#if TODO

given= g = (1/(scale * np.sqrt(2 * np.pi)) *;

var expected=

"... np.exp(-(x - loc)**2 / (2 * scale**2)))";

Assert.AreEqual(expected, given.repr);

given= plt.plot(x,g);

#endif

}

[TestMethod]

public void logisticTest()

{

// Draw samples from the distribution:

// >>> loc, scale = 10, 1

// >>> s = np.random.logistic(loc, scale, 10000)

// >>> import matplotlib.pyplot as plt

// >>> count, bins, ignored = plt.hist(s, bins=50)

//

#if TODO

var given= loc, scale = 10, 1;

given= s = np.random.logistic(loc, scale, 10000);

given= import matplotlib.pyplot as plt;

given= count, bins, ignored = plt.hist(s, bins=50);

#endif

// # plot against distribution

// >>> def logist(x, loc, scale):

// ... return exp((loc-x)/scale)/(scale*(1+exp((loc-x)/scale))**2)

// >>> plt.plot(bins, logist(bins, loc, scale)*count.max()/\

// ... logist(bins, loc, scale).max())

// >>> plt.show()

//

#if TODO

given= def logist(x, loc, scale):;

var expected=

"... return exp((loc-x)/scale)/(scale*(1+exp((loc-x)/scale))**2)";

Assert.AreEqual(expected, given.repr);

given= plt.plot(bins, logist(bins, loc, scale)*count.max()/\;

expected=

"... logist(bins, loc, scale).max())";

Assert.AreEqual(expected, given.repr);

given= plt.show();

#endif

}

[TestMethod]

public void lognormalTest()

{

// Draw samples from the distribution:

// >>> mu, sigma = 3., 1. # mean and standard deviation

// >>> s = np.random.lognormal(mu, sigma, 1000)

//

#if TODO

var given= mu, sigma = 3., 1. # mean and standard deviation;

given= s = np.random.lognormal(mu, sigma, 1000);

#endif

// Display the histogram of the samples, along with

// the probability density function:

// >>> import matplotlib.pyplot as plt

// >>> count, bins, ignored = plt.hist(s, 100, density=True, align='mid')

//

#if TODO

given= import matplotlib.pyplot as plt;

given= count, bins, ignored = plt.hist(s, 100, density=True, align='mid');

#endif

// >>> x = np.linspace(min(bins), max(bins), 10000)

// >>> pdf = (np.exp(-(np.log(x) - mu)**2 / (2 * sigma**2))

// ... / (x * sigma * np.sqrt(2 * np.pi)))

//

#if TODO

given= x = np.linspace(min(bins), max(bins), 10000);

given= pdf = (np.exp(-(np.log(x) - mu)**2 / (2 * sigma**2));

var expected=

"... / (x * sigma * np.sqrt(2 * np.pi)))";

Assert.AreEqual(expected, given.repr);

#endif

// >>> plt.plot(x, pdf, linewidth=2, color='r')

// >>> plt.axis('tight')

// >>> plt.show()

//

#if TODO

given= plt.plot(x, pdf, linewidth=2, color='r');

given= plt.axis('tight');

given= plt.show();

#endif

// Demonstrate that taking the products of random samples from a uniform

// distribution can be fit well by a log-normal probability density

// function.

// >>> # Generate a thousand samples: each is the product of 100 random

// >>> # values, drawn from a normal distribution.

// >>> b = []

// >>> for i in range(1000):

// ... a = 10. + np.random.random(100)

// ... b.append(np.product(a))

//

#if TODO

given= # Generate a thousand samples: each is the product of 100 random;

given= # values, drawn from a normal distribution.;

given= b = [];

given= for i in range(1000):;

expected=

"... a = 10. + np.random.random(100)\n" +

"... b.append(np.product(a))";

Assert.AreEqual(expected, given.repr);

#endif

// >>> b = np.array(b) / np.min(b) # scale values to be positive

// >>> count, bins, ignored = plt.hist(b, 100, density=True, align='mid')

// >>> sigma = np.std(np.log(b))

// >>> mu = np.mean(np.log(b))

//

#if TODO

given= b = np.array(b) / np.min(b) # scale values to be positive;

given= count, bins, ignored = plt.hist(b, 100, density=True, align='mid');

given= sigma = np.std(np.log(b));

given= mu = np.mean(np.log(b));

#endif

// >>> x = np.linspace(min(bins), max(bins), 10000)

// >>> pdf = (np.exp(-(np.log(x) - mu)**2 / (2 * sigma**2))