// Copyright (c) 2019 by the SciSharp Team

// Code generated by CodeMinion: https://github.com/SciSharp/CodeMinion

using System;

using System.Collections;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Runtime.InteropServices;

using System.Text;

using Python.Runtime;

using Numpy.Models;

namespace Numpy

{

public partial class NumPy

{

/// <summary>

/// Random values in a given shape.<br></br>

///

/// Create an array of the given shape and populate it with

/// random samples from a uniform distribution

/// over [0, 1).<br></br>

///

/// Notes

///

/// This is a convenience function.<br></br>

/// If you want an interface that

/// takes a shape-tuple as the first argument, refer to

/// np.random.random_sample .

/// </summary>

/// <returns>

/// Random values.

/// </returns>

public float random_rand()

{

//auto-generated code, do not change

var random = self.GetAttr("random");

var __self__=random;

dynamic py = __self__.InvokeMethod("rand");

return ToCsharp<float>(py);

}

/// <summary>

/// Return a sample (or samples) from the “standard normal” distribution.<br></br>

///

/// If positive, int_like or int-convertible arguments are provided,

/// randn generates an array of shape (d0, d1, ..., dn), filled

/// with random floats sampled from a univariate “normal” (Gaussian)

/// distribution of mean 0 and variance 1 (if any of the are

/// floats, they are first converted to integers by truncation).<br></br>

/// A single

/// float randomly sampled from the distribution is returned if no

/// argument is provided.<br></br>

///

/// This is a convenience function.<br></br>

/// If you want an interface that takes a

/// tuple as the first argument, use numpy.random.standard_normal instead.<br></br>

///

/// Notes

///

/// For random samples from , use:

///

/// sigma * np.random.randn(...) + mu

/// </summary>

/// <returns>

/// A (d0, d1, ..., dn)-shaped array of floating-point samples from

/// the standard normal distribution, or a single such float if

/// no parameters were supplied.

/// </returns>

public float random_randn()

{

//auto-generated code, do not change

var random = self.GetAttr("random");

var __self__=random;

dynamic py = __self__.InvokeMethod("randn");

return ToCsharp<float>(py);

}

/// <summary>

/// Return random integers from low (inclusive) to high (exclusive).<br></br>

///

/// Return random integers from the “discrete uniform” distribution of

/// the specified dtype in the “half-open” interval [low, high).<br></br>

/// If

/// high is None (the default), then results are from [0, low).

/// </summary>

/// <param name="low">

/// Lowest (signed) integer to be drawn from the distribution (unless

/// high=None, in which case this parameter is one above the

/// highest such integer).

/// </param>

/// <param name="high">

/// If provided, one above the largest (signed) integer to be drawn

/// from the distribution (see above for behavior if high=None).

/// </param>

/// <param name="size">

/// Output shape.<br></br>

/// If the given shape is, e.g., (m, n, k), then

/// m * n * k samples are drawn.<br></br>

/// Default is None, in which case a

/// single value is returned.

/// </param>

/// <param name="dtype">

/// Desired dtype of the result.<br></br>

/// All dtypes are determined by their

/// name, i.e., ‘int64’, ‘int’, etc, so byteorder is not available

/// and a specific precision may have different C types depending

/// on the platform.<br></br>

/// The default value is ‘np.int’.

/// </param>

/// <returns>

/// size-shaped array of random integers from the appropriate

/// distribution, or a single such random int if size not provided.

/// </returns>

public NDarray<int> random_randint(int low, int? high = null, int[] size = null, Dtype dtype = null)

{

//auto-generated code, do not change

var random = self.GetAttr("random");

var __self__=random;

var pyargs=ToTuple(new object[]

{

low,

});

var kwargs=new PyDict();

if (high!=null) kwargs["high"]=ToPython(high);

if (size!=null) kwargs["size"]=ToPython(size);

if (dtype!=null) kwargs["dtype"]=ToPython(dtype);

dynamic py = __self__.InvokeMethod("randint", pyargs, kwargs);

return ToCsharp<NDarray<int>>(py);

}

/// <summary>

/// Random integers of type np.int between low and high, inclusive.<br></br>

///

/// Return random integers of type np.int from the “discrete uniform”

/// distribution in the closed interval [low, high].<br></br>

/// If high is

/// None (the default), then results are from [1, low].<br></br>

/// The np.int

/// type translates to the C long type used by Python 2 for “short”

/// integers and its precision is platform dependent.<br></br>

///

/// This function has been deprecated.<br></br>

/// Use randint instead.<br></br>

///

/// Notes

///

/// To sample from N evenly spaced floating-point numbers between a and b,

/// use:

/// </summary>

/// <param name="low">

/// Lowest (signed) integer to be drawn from the distribution (unless

/// high=None, in which case this parameter is the highest such

/// integer).

/// </param>

/// <param name="high">

/// If provided, the largest (signed) integer to be drawn from the

/// distribution (see above for behavior if high=None).

/// </param>

/// <param name="size">

/// Output shape.<br></br>

/// If the given shape is, e.g., (m, n, k), then

/// m * n * k samples are drawn.<br></br>

/// Default is None, in which case a

/// single value is returned.

/// </param>

/// <returns>

/// size-shaped array of random integers from the appropriate

/// distribution, or a single such random int if size not provided.

/// </returns>

public NDarray<int> random_random_integers(int low, int? high = null, int[] size = null)

{

//auto-generated code, do not change

var random = self.GetAttr("random");

var __self__=random;

var pyargs=ToTuple(new object[]

{

low,

});

var kwargs=new PyDict();

if (high!=null) kwargs["high"]=ToPython(high);

if (size!=null) kwargs["size"]=ToPython(size);

dynamic py = __self__.InvokeMethod("random_integers", pyargs, kwargs);

return ToCsharp<NDarray<int>>(py);

}

/// <summary>

/// Return random floats in the half-open interval [0.0, 1.0).<br></br>

///

/// Results are from the “continuous uniform” distribution over the

/// stated interval.<br></br>

/// To sample multiply

/// the output of random_sample by (b-a) and add a:

/// </summary>

/// <param name="size">

/// Output shape.<br></br>

/// If the given shape is, e.g., (m, n, k), then

/// m * n * k samples are drawn.<br></br>

/// Default is None, in which case a

/// single value is returned.

/// </param>

/// <returns>

/// Array of random floats of shape size (unless size=None, in which

/// case a single float is returned).

/// </returns>

public NDarray<float> random_random_sample(params int[] size)

{

//auto-generated code, do not change

var random = self.GetAttr("random");

var __self__=random;

var pyargs=ToTuple(new object[]

{

});

var kwargs=new PyDict();

if (size!=null) kwargs["size"]=ToPython(size);

dynamic py = __self__.InvokeMethod("random_sample", pyargs, kwargs);

return ToCsharp<NDarray<float>>(py);

}

/// <summary>

/// Return random floats in the half-open interval [0.0, 1.0).<br></br>

///

/// Results are from the “continuous uniform” distribution over the

/// stated interval.<br></br>

/// To sample multiply

/// the output of random_sample by (b-a) and add a:

/// </summary>

/// <param name="size">

/// Output shape.<br></br>

/// If the given shape is, e.g., (m, n, k), then

/// m * n * k samples are drawn.<br></br>

/// Default is None, in which case a

/// single value is returned.

/// </param>

/// <returns>

/// Array of random floats of shape size (unless size=None, in which

/// case a single float is returned).

/// </returns>

public NDarray<float> random_random(params int[] size)

{

//auto-generated code, do not change

var random = self.GetAttr("random");

var __self__=random;

var pyargs=ToTuple(new object[]

{

});

var kwargs=new PyDict();

if (size!=null) kwargs["size"]=ToPython(size);

dynamic py = __self__.InvokeMethod("random", pyargs, kwargs);

return ToCsharp<NDarray<float>>(py);

}

/// <summary>

/// Return random floats in the half-open interval [0.0, 1.0).<br></br>

///

/// Results are from the “continuous uniform” distribution over the

/// stated interval.<br></br>

/// To sample multiply

/// the output of random_sample by (b-a) and add a:

/// </summary>

/// <param name="size">

/// Output shape.<br></br>

/// If the given shape is, e.g., (m, n, k), then

/// m * n * k samples are drawn.<br></br>

/// Default is None, in which case a

/// single value is returned.

/// </param>

/// <returns>

/// Array of random floats of shape size (unless size=None, in which

/// case a single float is returned).

/// </returns>

public NDarray<float> random_ranf(params int[] size)

{

//auto-generated code, do not change

var random = self.GetAttr("random");

var __self__=random;

var pyargs=ToTuple(new object[]

{

});

var kwargs=new PyDict();

if (size!=null) kwargs["size"]=ToPython(size);

dynamic py = __self__.InvokeMethod("ranf", pyargs, kwargs);

return ToCsharp<NDarray<float>>(py);

}

/// <summary>

/// Return random floats in the half-open interval [0.0, 1.0).<br></br>

///

/// Results are from the “continuous uniform” distribution over the

/// stated interval.<br></br>

/// To sample multiply

/// the output of random_sample by (b-a) and add a:

/// </summary>

/// <param name="size">

/// Output shape.<br></br>

/// If the given shape is, e.g., (m, n, k), then

/// m * n * k samples are drawn.<br></br>

/// Default is None, in which case a

/// single value is returned.

/// </param>

/// <returns>

/// Array of random floats of shape size (unless size=None, in which

/// case a single float is returned).

/// </returns>

public NDarray<float> random_sample(params int[] size)

{

//auto-generated code, do not change

var random = self.GetAttr("random");

var __self__=random;

var pyargs=ToTuple(new object[]

{

});

var kwargs=new PyDict();

if (size!=null) kwargs["size"]=ToPython(size);

dynamic py = __self__.InvokeMethod("sample", pyargs, kwargs);

return ToCsharp<NDarray<float>>(py);

}

/// <summary>

/// Generates a random sample from a given 1-D array

/// </summary>

/// <param name="a">

/// If an ndarray, a random sample is generated from its elements.<br></br>

///

/// If an int, the random sample is generated as if a were np.arange(a)

/// </param>

/// <param name="size">

/// Output shape.<br></br>

/// If the given shape is, e.g., (m, n, k), then

/// m * n * k samples are drawn.<br></br>

/// Default is None, in which case a

/// single value is returned.

/// </param>

/// <param name="replace">

/// Whether the sample is with or without replacement

/// </param>

/// <param name="p">

/// The probabilities associated with each entry in a.<br></br>

///

/// If not given the sample assumes a uniform distribution over all

/// entries in a.

/// </param>

/// <returns>

/// The generated random samples

/// </returns>

public NDarray random_choice(NDarray a, int[] size = null, bool? replace = true, NDarray p = null)

{

//auto-generated code, do not change

var random = self.GetAttr("random");

var __self__=random;

var pyargs=ToTuple(new object[]

{

a,

});

var kwargs=new PyDict();

if (size!=null) kwargs["size"]=ToPython(size);

if (replace!=true) kwargs["replace"]=ToPython(replace);

if (p!=null) kwargs["p"]=ToPython(p);

dynamic py = __self__.InvokeMethod("choice", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Generates a random sample from a given 1-D array

/// </summary>

/// <param name="a">

/// If an ndarray, a random sample is generated from its elements.<br></br>

///

/// If an int, the random sample is generated as if a were np.arange(a)

/// </param>

/// <param name="size">

/// Output shape.<br></br>

/// If the given shape is, e.g., (m, n, k), then

/// m * n * k samples are drawn.<br></br>

/// Default is None, in which case a

/// single value is returned.

/// </param>

/// <param name="replace">

/// Whether the sample is with or without replacement

/// </param>

/// <param name="p">

/// The probabilities associated with each entry in a.<br></br>

///

/// If not given the sample assumes a uniform distribution over all

/// entries in a.

/// </param>

/// <returns>

/// The generated random samples

/// </returns>

public NDarray random_choice(int a, int[] size = null, bool? replace = true, NDarray p = null)

{

//auto-generated code, do not change

var random = self.GetAttr("random");

var __self__=random;

var pyargs=ToTuple(new object[]

{

a,

});

var kwargs=new PyDict();

if (size!=null) kwargs["size"]=ToPython(size);

if (replace!=true) kwargs["replace"]=ToPython(replace);

if (p!=null) kwargs["p"]=ToPython(p);

dynamic py = __self__.InvokeMethod("choice", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Return random bytes.

/// </summary>

/// <param name="length">

/// Number of random bytes.

/// </param>

/// <returns>

/// String of length length.

/// </returns>

public string random_bytes(int length)

{

//auto-generated code, do not change

var random = self.GetAttr("random");

var __self__=random;

var pyargs=ToTuple(new object[]

{

length,

});

var kwargs=new PyDict();

dynamic py = __self__.InvokeMethod("bytes", pyargs, kwargs);

return ToCsharp<string>(py);

}

/// <summary>

/// Modify a sequence in-place by shuffling its contents.<br></br>

///

/// This function only shuffles the array along the first axis of a

/// multi-dimensional array.<br></br>

/// The order of sub-arrays is changed but

/// their contents remains the same.

/// </summary>

/// <param name="x">

/// The array or list to be shuffled.

/// </param>

public void random_shuffle(NDarray x)

{

//auto-generated code, do not change

var random = self.GetAttr("random");

var __self__=random;

var pyargs=ToTuple(new object[]

{

x,

});

var kwargs=new PyDict();

dynamic py = __self__.InvokeMethod("shuffle", pyargs, kwargs);

}

/// <summary>

/// Randomly permute a sequence, or return a permuted range.<br></br>

///

/// If x is a multi-dimensional array, it is only shuffled along its

/// first index.

/// </summary>

/// <param name="x">

/// If x is an integer, randomly permute np.arange(x).<br></br>

///

/// If x is an array, make a copy and shuffle the elements

/// randomly.

/// </param>

/// <returns>

/// Permuted sequence or array range.

/// </returns>

public NDarray random_permutation(NDarray x)

{

//auto-generated code, do not change

var random = self.GetAttr("random");

var __self__=random;

var pyargs=ToTuple(new object[]

{

x,

});

var kwargs=new PyDict();

dynamic py = __self__.InvokeMethod("permutation", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Randomly permute a sequence, or return a permuted range.<br></br>

///

/// If x is a multi-dimensional array, it is only shuffled along its

/// first index.

/// </summary>

/// <param name="x">

/// If x is an integer, randomly permute np.arange(x).<br></br>

///

/// If x is an array, make a copy and shuffle the elements

/// randomly.

/// </param>

/// <returns>

/// Permuted sequence or array range.

/// </returns>

public NDarray random_permutation(int x)

{

//auto-generated code, do not change

var random = self.GetAttr("random");

var __self__=random;

var pyargs=ToTuple(new object[]

{

x,

});

var kwargs=new PyDict();

dynamic py = __self__.InvokeMethod("permutation", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Draw samples from a Beta distribution.<br></br>

///

/// The Beta distribution is a special case of the Dirichlet distribution,

/// and is related to the Gamma distribution.<br></br>

/// It has the probability

/// distribution function

///

/// where the normalisation, B, is the beta function,

///

/// It is often seen in Bayesian inference and order statistics.

/// </summary>

/// <param name="a">

/// Alpha, positive (&gt;0).

/// </param>

/// <param name="b">

/// Beta, positive (&gt;0).

/// </param>

/// <param name="size">

/// Output shape.<br></br>

/// If the given shape is, e.g., (m, n, k), then

/// m * n * k samples are drawn.<br></br>

/// If size is None (default),

/// a single value is returned if a and b are both scalars.<br></br>

///

/// Otherwise, np.broadcast(a, b).size samples are drawn.

/// </param>

/// <returns>

/// Drawn samples from the parameterized beta distribution.

/// </returns>

public NDarray random_beta(NDarray<float> a, NDarray<float> b, int[] size = null)

{

//auto-generated code, do not change

var random = self.GetAttr("random");

var __self__=random;

var pyargs=ToTuple(new object[]

{

a,

b,

});

var kwargs=new PyDict();

if (size!=null) kwargs["size"]=ToPython(size);

dynamic py = __self__.InvokeMethod("beta", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Draw samples from a binomial distribution.<br></br>

///

/// Samples are drawn from a binomial distribution with specified

/// parameters, n trials and p probability of success where

/// n an integer &gt;= 0 and p is in the interval [0,1].<br></br>

/// (n may be

/// input as a float, but it is truncated to an integer in use)

///

/// Notes

///

/// The probability density for the binomial distribution is

///

/// where is the number of trials, is the probability

/// of success, and is the number of successes.<br></br>

///

/// When estimating the standard error of a proportion in a population by

/// using a random sample, the normal distribution works well unless the

/// product p*n &lt;=5, where p = population proportion estimate, and n =

/// number of samples, in which case the binomial distribution is used

/// instead.<br></br>

/// For example, a sample of 15 people shows 4 who are left

/// handed, and 11 who are right handed.<br></br>

/// Then p = 4/15 = 27%. 0.27*15 = 4,

/// so the binomial distribution should be used in this case.<br></br>

///

/// References

/// </summary>

/// <param name="n">

/// Parameter of the distribution, &gt;= 0.<br></br>

/// Floats are also accepted,

/// but they will be truncated to integers.

/// </param>

/// <param name="p">

/// Parameter of the distribution, &gt;= 0 and &lt;=1.

/// </param>

/// <param name="size">

/// Output shape.<br></br>

/// If the given shape is, e.g., (m, n, k), then

/// m * n * k samples are drawn.<br></br>

/// If size is None (default),

/// a single value is returned if n and p are both scalars.<br></br>

///

/// Otherwise, np.broadcast(n, p).size samples are drawn.

/// </param>

/// <returns>

/// Drawn samples from the parameterized binomial distribution, where

/// each sample is equal to the number of successes over the n trials.

/// </returns>

public NDarray random_binomial(NDarray<int> n, NDarray<float> p, int[] size = null)

{

//auto-generated code, do not change

var random = self.GetAttr("random");

var __self__=random;

var pyargs=ToTuple(new object[]

{

n,

p,

});

var kwargs=new PyDict();

if (size!=null) kwargs["size"]=ToPython(size);

dynamic py = __self__.InvokeMethod("binomial", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Draw samples from a binomial distribution.<br></br>

///

/// Samples are drawn from a binomial distribution with specified

/// parameters, n trials and p probability of success where

/// n an integer &gt;= 0 and p is in the interval [0,1].<br></br>

/// (n may be

/// input as a float, but it is truncated to an integer in use)

///

/// Notes

///

/// The probability density for the binomial distribution is

///

/// where is the number of trials, is the probability

/// of success, and is the number of successes.<br></br>

///

/// When estimating the standard error of a proportion in a population by

/// using a random sample, the normal distribution works well unless the

/// product p*n &lt;=5, where p = population proportion estimate, and n =

/// number of samples, in which case the binomial distribution is used

/// instead.<br></br>

/// For example, a sample of 15 people shows 4 who are left

/// handed, and 11 who are right handed.<br></br>

/// Then p = 4/15 = 27%. 0.27*15 = 4,

/// so the binomial distribution should be used in this case.<br></br>

///

/// References

/// </summary>

/// <param name="n">

/// Parameter of the distribution, &gt;= 0.<br></br>

/// Floats are also accepted,

/// but they will be truncated to integers.

/// </param>

/// <param name="p">

/// Parameter of the distribution, &gt;= 0 and &lt;=1.

/// </param>

/// <param name="size">

/// Output shape.<br></br>

/// If the given shape is, e.g., (m, n, k), then

/// m * n * k samples are drawn.<br></br>

/// If size is None (default),

/// a single value is returned if n and p are both scalars.<br></br>

///

/// Otherwise, np.broadcast(n, p).size samples are drawn.

/// </param>

/// <returns>

/// Drawn samples from the parameterized binomial distribution, where

/// each sample is equal to the number of successes over the n trials.

/// </returns>

public NDarray random_binomial(int n, NDarray<float> p, int[] size = null)

{

//auto-generated code, do not change

var random = self.GetAttr("random");

var __self__=random;

var pyargs=ToTuple(new object[]

{

n,

p,

});

var kwargs=new PyDict();

if (size!=null) kwargs["size"]=ToPython(size);

dynamic py = __self__.InvokeMethod("binomial", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Draw samples from a chi-square distribution.<br></br>

///

/// When df independent random variables, each with standard normal

/// distributions (mean 0, variance 1), are squared and summed, the

/// resulting distribution is chi-square (see Notes).<br></br>

/// This distribution

/// is often used in hypothesis testing.<br></br>

///

/// Notes

///

/// The variable obtained by summing the squares of df independent,

/// standard normally distributed random variables:

///

/// is chi-square distributed, denoted

///

/// The probability density function of the chi-squared distribution is

///

/// where is the gamma function,

///

/// References

/// </summary>

/// <param name="df">

/// Number of degrees of freedom, should be &gt; 0.

/// </param>

/// <param name="size">

/// Output shape.<br></br>

/// If the given shape is, e.g., (m, n, k), then

/// m * n * k samples are drawn.<br></br>

/// If size is None (default),

/// a single value is returned if df is a scalar.<br></br>

/// Otherwise,

/// np.array(df).size samples are drawn.

/// </param>

/// <returns>

/// Drawn samples from the parameterized chi-square distribution.

/// </returns>

public NDarray random_chisquare(NDarray<float> df, int[] size = null)

{

//auto-generated code, do not change

var random = self.GetAttr("random");

var __self__=random;

var pyargs=ToTuple(new object[]

{

df,

});

var kwargs=new PyDict();

if (size!=null) kwargs["size"]=ToPython(size);

dynamic py = __self__.InvokeMethod("chisquare", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Draw samples from the Dirichlet distribution.<br></br>

///

/// Draw size samples of dimension k from a Dirichlet distribution.<br></br>

/// A

/// Dirichlet-distributed random variable can be seen as a multivariate

/// generalization of a Beta distribution.<br></br>

/// Dirichlet pdf is the conjugate

/// prior of a multinomial in Bayesian inference.<br></br>

///

/// Notes

///

/// Uses the following property for computation: for each dimension,

/// draw a random sample y_i from a standard gamma generator of shape

/// alpha_i, then

/// is

/// Dirichlet distributed.<br></br>

///

/// References

/// </summary>

/// <param name="alpha">

/// Parameter of the distribution (k dimension for sample of

/// dimension k).

/// </param>

/// <param name="size">

/// Output shape.<br></br>

/// If the given shape is, e.g., (m, n, k), then

/// m * n * k samples are drawn.<br></br>

/// Default is None, in which case a

/// single value is returned.

/// </param>

/// <returns>

/// The drawn samples, of shape (size, alpha.ndim).

/// </returns>

public NDarray random_dirichlet(NDarray alpha, int[] size = null)

{

//auto-generated code, do not change

var random = self.GetAttr("random");

var __self__=random;

var pyargs=ToTuple(new object[]

{

alpha,

});

var kwargs=new PyDict();

if (size!=null) kwargs["size"]=ToPython(size);

dynamic py = __self__.InvokeMethod("dirichlet", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Draw samples from an exponential distribution.<br></br>

///

/// Its probability density function is

///

/// for x &gt; 0 and 0 elsewhere.<br></br>

/// is the scale parameter,

/// which is the inverse of the rate parameter .

/// The rate parameter is an alternative, widely used parameterization

/// of the exponential distribution [3].<br></br>

///

/// The exponential distribution is a continuous analogue of the

/// geometric distribution.<br></br>

/// It describes many common situations, such as

/// the size of raindrops measured over many rainstorms [1], or the time

/// between page requests to Wikipedia [2].<br></br>

///

/// References

/// </summary>

/// <param name="scale">

/// The scale parameter, .

/// </param>

/// <param name="size">

/// Output shape.<br></br>

/// If the given shape is, e.g., (m, n, k), then

/// m * n * k samples are drawn.<br></br>

/// If size is None (default),

/// a single value is returned if scale is a scalar.<br></br>

/// Otherwise,

/// np.array(scale).size samples are drawn.

/// </param>

/// <returns>

/// Drawn samples from the parameterized exponential distribution.

/// </returns>

public NDarray random_exponential(NDarray<float> scale = null, int[] size = null)

{

//auto-generated code, do not change

var random = self.GetAttr("random");

var __self__=random;

var pyargs=ToTuple(new object[]

{

});

var kwargs=new PyDict();

if (scale!=null) kwargs["scale"]=ToPython(scale);

if (size!=null) kwargs["size"]=ToPython(size);

dynamic py = __self__.InvokeMethod("exponential", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Draw samples from an F distribution.<br></br>

///

/// Samples are drawn from an F distribution with specified parameters,

/// dfnum (degrees of freedom in numerator) and dfden (degrees of

/// freedom in denominator), where both parameters should be greater than

/// zero.<br></br>

///

/// The random variate of the F distribution (also known as the

/// Fisher distribution) is a continuous probability distribution

/// that arises in ANOVA tests, and is the ratio of two chi-square

/// variates.<br></br>

///

/// Notes

///

/// The F statistic is used to compare in-group variances to between-group

/// variances.<br></br>

/// Calculating the distribution depends on the sampling, and

/// so it is a function of the respective degrees of freedom in the

/// problem.<br></br>

/// The variable dfnum is the number of samples minus one, the

/// between-groups degrees of freedom, while dfden is the within-groups

/// degrees of freedom, the sum of the number of samples in each group

/// minus the number of groups.<br></br>

///

/// References

/// </summary>

/// <param name="dfnum">

/// Degrees of freedom in numerator, should be &gt; 0.

/// </param>

/// <param name="dfden">

/// Degrees of freedom in denominator, should be &gt; 0.

/// </param>

/// <param name="size">

/// Output shape.<br></br>

/// If the given shape is, e.g., (m, n, k), then

/// m * n * k samples are drawn.<br></br>

/// If size is None (default),

/// a single value is returned if dfnum and dfden are both scalars.<br></br>

///

/// Otherwise, np.broadcast(dfnum, dfden).size samples are drawn.

/// </param>

/// <returns>

/// Drawn samples from the parameterized Fisher distribution.

/// </returns>

public NDarray random_f(NDarray<float> dfnum, NDarray<float> dfden, int[] size = null)

{

//auto-generated code, do not change

var random = self.GetAttr("random");

var __self__=random;

var pyargs=ToTuple(new object[]

{

dfnum,

dfden,

});

var kwargs=new PyDict();

if (size!=null) kwargs["size"]=ToPython(size);

dynamic py = __self__.InvokeMethod("f", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Draw samples from a Gamma distribution.<br></br>

///

/// Samples are drawn from a Gamma distribution with specified parameters,

/// shape (sometimes designated “k”) and scale (sometimes designated

/// “theta”), where both parameters are &gt; 0.<br></br>

///

/// Notes

///

/// The probability density for the Gamma distribution is

///

/// where is the shape and the scale,

/// and is the Gamma function.<br></br>

///

/// The Gamma distribution is often used to model the times to failure of

/// electronic components, and arises naturally in processes for which the

/// waiting times between Poisson distributed events are relevant.<br></br>

///

/// References

/// </summary>

/// <param name="shape">

/// The shape of the gamma distribution.<br></br>

/// Should be greater than zero.

/// </param>

/// <param name="scale">

/// The scale of the gamma distribution.<br></br>

/// Should be greater than zero.<br></br>

///

/// Default is equal to 1.

/// </param>

/// <param name="size">

/// Output shape.<br></br>

/// If the given shape is, e.g., (m, n, k), then

/// m * n * k samples are drawn.<br></br>

/// If size is None (default),

/// a single value is returned if shape and scale are both scalars.<br></br>

///

/// Otherwise, np.broadcast(shape, scale).size samples are drawn.

/// </param>

/// <returns>

/// Drawn samples from the parameterized gamma distribution.

/// </returns>

public NDarray random_gamma(Shape shape, NDarray<float> scale = null, int[] size = null)

{

//auto-generated code, do not change

var random = self.GetAttr("random");

var __self__=random;

var pyargs=ToTuple(new object[]

{

shape,

});

var kwargs=new PyDict();

if (scale!=null) kwargs["scale"]=ToPython(scale);

if (size!=null) kwargs["size"]=ToPython(size);

dynamic py = __self__.InvokeMethod("gamma", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Draw samples from the geometric distribution.<br></br>

///

/// Bernoulli trials are experiments with one of two outcomes:

/// success or failure (an example of such an experiment is flipping

/// a coin).<br></br>

/// The geometric distribution models the number of trials

/// that must be run in order to achieve success.<br></br>

/// It is therefore

/// supported on the positive integers, k = 1, 2, ....

///

/// The probability mass function of the geometric distribution is

///

/// where p is the probability of success of an individual trial.

/// </summary>

/// <param name="p">

/// The probability of success of an individual trial.

/// </param>

/// <param name="size">

/// Output shape.<br></br>

/// If the given shape is, e.g., (m, n, k), then

/// m * n * k samples are drawn.<br></br>

/// If size is None (default),

/// a single value is returned if p is a scalar.<br></br>

/// Otherwise,

/// np.array(p).size samples are drawn.

/// </param>

/// <returns>

/// Drawn samples from the parameterized geometric distribution.

/// </returns>

public NDarray random_geometric(NDarray<float> p, int[] size = null)

{

//auto-generated code, do not change

var random = self.GetAttr("random");

var __self__=random;

var pyargs=ToTuple(new object[]

{

p,

});

var kwargs=new PyDict();

if (size!=null) kwargs["size"]=ToPython(size);

dynamic py = __self__.InvokeMethod("geometric", pyargs, kwargs);