def rand(*args):
"""
Random values in a given shape.
Create an array of the given shape and propagate it with random samples from a uniform
distribution over [0, 1).
:param d0, d1, ..., dn: (*int*) optional. The dimensions of the returned array, should all
be positive. If no argument is given a single Python float is returned.
:returns: Random values array.
"""
if len(args) == 0:
return RandomUtil.rand()
elif len(args) == 1:
return NDArray(RandomUtil.rand(args[0]))
else:
return NDArray(RandomUtil.rand(args))
def inv(a):
'''
Compute the (multiplicative) inverse of a matrix.
:param a: (*array_like*) Input array.
:returns: Inverse matrix.
'''
r = LinalgUtil.inv(a.asarray())
return NDArray(r)
def percentile(a, q, axis=None):
'''
Compute the qth percentile of the data along the specified axis.
:param a: (*array_like*) Input array.
:param q: (*float*) float in range of [0,100].
Percentile to compute, which must be between 0 and 100 inclusive.
:param axis: (*int*) Axis or axes along which the percentiles are computed. The default is
to compute the percentile along a flattened version of the array.
:returns: (*float*) qth percentile value.
'''
if isinstance(a, list):
a = NDArray(ArrayUtil.array(x))
if axis is None:
r = StatsUtil.percentile(a.asarray(), q)
else:
r = StatsUtil.percentile(a.asarray(), q, axis)
r = NDArray(r)
return r
def ds2uv(d, s):
'''
Calculate U/V from wind direction and wind speed.
:param d: (*array_like*) Wind direction.
:param s: (*array_like*) Wind speed.
:returns: Wind U/V.
'''
if isinstance(d, NDArray):
r = ArrayMath.ds2uv(d.asarray(), s.asarray())
u = NDArray(r[0])
v = NDArray(r[1])
if isinstance(d, DimArray) and isinstance(s, DimArray):
u = DimArray(u, d.dims, d.fill_value, d.proj)
v = DimArray(v, d.dims, d.fill_value, d.proj)
return u, v
else:
r = ArrayMath.ds2uv(d, s)
return r[0], r[1]
def count(a, size):
'''
Count none-zero points with window size
:param a: (*array_like*) 2-D array.
:param size: (*int*) Window size.
:returns: (*array_like*) Count result.
'''
r = ImageUtil.count(a.asarray(), size)
return NDArray(r)
def uv2ds(u, v):
'''
Calculate wind direction and wind speed from U/V.
:param u: (*array_like*) U component of wind field.
:param v: (*array_like*) V component of wind field.
:returns: Wind direction and wind speed.
'''
if isinstance(u, NDArray):
r = ArrayMath.uv2ds(u.asarray(), v.asarray())
d = NDArray(r[0])
s = NDArray(r[1])
if isinstance(u, DimArray) and isinstance(v, DimArray):
d = DimArray(d, u.dims, u.fill_value, u.proj)
s = DimArray(s, u.dims, u.fill_value, u.proj)
return d, s
else:
r = ArrayMath.uv2ds(u, v)
return r[0], r[1]
def polyval(p, x):
"""
Evaluate a polynomial at specific values.
If p is of length N, this function returns the value:
p[0]*x**(N-1) + p[1]*x**(N-2) + ... + p[N-2]*x + p[N-1]
If x is a sequence, then p(x) is returned for each element of x. If x is another polynomial then the
composite polynomial p(x(t)) is returned.
:param p: (*array_like*) 1D array of polynomial coefficients (including coefficients equal to zero)
from highest degree to the constant term.
:param x: (*array_like*) A number, an array of numbers, or an instance of poly1d, at which to evaluate
p.
:returns: Polynomial value
"""
if isinstance(x, list):
x = NDArray(ArrayUtil.array(x))
return NDArray(ArrayMath.polyVal(p, x.asarray()))
def imread(fname):
'''
Read RGB(A) data array from image file.
:param fname: (*String*) Image file name.
:returns: (*array*) RGB(A) data array.
'''
if not os.path.exists(fname):
raise IOError(fname)
r = ImageUtil.imageRead(fname)
return NDArray(r)
def mean(a, size, positive=True):
'''
Calculate mean value with window size
:param a: (*array_like*) 2-D array.
:param size: (*int*) Window size.
:param positive: (*boolean*) Only calculate the positive value or not.
:returns: (*array_like*) Mean result.
'''
r = ImageUtil.mean(a.asarray(), size, positive)
return NDArray(r)
def __getreturn(src, dst):
if isinstance(src, Graphic):
src.getShape().setImage(dst)
return src
elif isinstance(src, MILayer):
src.layer.setImage(dst)
return src
elif isinstance(src, NDArray):
r = ImageUtil.imageRead(dst)
return NDArray(r)
else:
return dst
def geotiffread(filename):
'''
Return data array from a GeoTiff data file.
:param filename: (*string*) The GeoTiff file name.
:returns: (*NDArray*) Readed data array.
'''
geotiff = GeoTiff(filename)
geotiff.read()
r = geotiff.readArray()
return NDArray(r)
def lstsq(a, b):
'''
Compute least-squares solution to equation Ax = b.
Compute a vector x such that the 2-norm |b - A x| is minimized.
Parameters
----------
a : (M, N) array
Left hand side matrix (2-D array).
b : (M,) array
Right hand side vector.
Returns
-------
x : (N,) array
Least-squares solution. Return shape matches shape of b.
residues : (0,) or () or (K,) ndarray
Sums of residues, squared 2-norm for each column in b - a x.
'''
r = StatsUtil.multipleLineRegress_OLS(b.asarray(), a.asarray(), True)
return NDArray(r[0]), NDArray(r[1])
def lu(a):
'''
Compute pivoted LU decomposition of a matrix.
The decomposition is::
A = P L U
where P is a permutation matrix, L lower triangular with unit
diagonal elements, and U upper triangular.
Parameters
----------
a : (M, M) array_like
Array to decompose
permute_l : bool, optional
Perform the multiplication P*L (Default: do not permute)
overwrite_a : bool, optional
Whether to overwrite data in a (may improve performance)
check_finite : bool, optional
Whether to check that the input matrix contains only finite numbers.
Disabling may give a performance gain, but may result in problems
(crashes, non-termination) if the inputs do contain infinities or NaNs.
Returns
-------
p : (M, M) ndarray
Permutation matrix
l : (M, M) ndarray
Lower triangular or trapezoidal matrix with unit diagonal.
u : (M, M) ndarray
Upper triangular or trapezoidal matrix
'''
r = LinalgUtil.lu(a.asarray())
p = NDArray(r[0])
l = NDArray(r[1])
u = NDArray(r[2])
return p, l, u
def mlinregress(y, x):
'''
Implements ordinary least squares (OLS) to estimate the parameters of a multiple linear
regression model.
:param y: (*array_like*) Y sample data - one dimension array.
:param x: (*array_like*) X sample data - two dimension array.
:returns: Estimated regression parameters and residuals.
'''
if isinstance(x, list):
x = NDArray(ArrayUtil.array(x))
if isinstance(y, list):
y = NDArray(ArrayUtil.array(y))
r = StatsUtil.multipleLineRegress_OLS(y.asarray(), x.asarray())
return NDArray(r[0]), NDArray(r[1])
def gifread(gif, frame=0):
'''
Read RGB(A) data array from a gif image file or a gif decoder object.
:param gif: (*string or GifDecoder*) Gif image file or gif decoder object.
:param frame: (*int*) Image frame index.
:returns: (*array*) RGB(A) data array.
'''
if isinstance(gif, basestring):
gif = gifopen(gif)
im = gif.getFrame(frame)
r = ImageUtil.imageRead(im)
return NDArray(r)
def exponential(scale=1.0, size=None):
"""
Draw samples from a exponential distribution.
:param scale: (*float*) The scale parameter.
:param size: (*int*) Output shape. If size is None (default), a single value is returned.
:returns: (*ndarray or scalar*) Drawn samples from the parameterized exponential distribution.
"""
dist = ExponentialDistribution(scale)
if size is None:
size = 1
r = DistributionUtil.rvs(dist, size)
return NDArray(r)
def standard_t(df, size=None):
"""
Draw samples from a standard Student’s t distribution with df degrees of freedom.
:param df: (*float*) Degrees of freedom, should be > 0.
:param size: (*int*) Output shape. If size is None (default), a single value is returned.
:returns: (*ndarray or scalar*) Drawn samples from the parameterized Student’s t distribution.
"""
dist = TDistribution(df)
if size is None:
size = 1
r = DistributionUtil.rvs(dist, size)
return NDArray(r)
def weibull(a, size=None):
"""
Draw samples from a Weibull distribution.
:param a: (*float*) Shape parameter of the distribution. Must be nonnegative.
:param size: (*int*) Output shape. If size is None (default), a single value is returned.
:returns: (*ndarray or scalar*) Drawn samples from the parameterized Weibull distribution.
"""
dist = WeibullDistribution(a, 1)
if size is None:
size = 1
r = DistributionUtil.rvs(dist, size)
return NDArray(r)
def rvs(self, *args, **kwargs):
'''
Random variates of given type.
:param loc: (*float*) location parameter (default=0).
:param scale: (*float*) scale parameter (default=1).
:param size: (*int*) Size.
:returns: Probability density function.
'''
dist = self._create_distribution(*args)
size = kwargs.pop('size', 1)
r = DistributionUtil.rvs(dist, size)
return NDArray(r)
def pareto(a, size=None):
"""
Draw samples from a Pareto II or Lomax distribution with specified shape.
:param a: (*float*) Shape of the distribution. Should be greater than zero.
:param size: (*int*) Output shape. If size is None (default), a single value is returned.
:returns: (*ndarray or scalar*) Drawn samples from the parameterized Pareto distribution.
"""
dist = ParetoDistribution(1, a)
if size is None:
size = 1
r = DistributionUtil.rvs(dist, size)
return NDArray(r)
def chisquare(df, size=None):
"""
Draw samples from a chi-square distribution.
:param df: (*float*) Number of degrees of freedom, should be > 0.
:param size: (*int*) Output shape. If size is None (default), a single value is returned.
:returns: (*ndarray or scalar*) Drawn samples from the parameterized chisquare distribution.
"""
dist = ChiSquaredDistribution(df)
if size is None:
size = 1
r = DistributionUtil.rvs(dist, size)
return NDArray(r)
def normal(loc=0.0, scale=1.0, size=None):
"""
Draw random samples from a normal (Gaussian) distribution.
:param loc: (*float*) Mean (“centre”) of the distribution.
:param scale: (*float*) Standard deviation (spread or “width”) of the distribution.
:param size: (*int*) Output shape. If size is None (default), a single value is returned.
"""
dist = NormalDistribution(loc, scale)
if size is None:
size = 1
r = DistributionUtil.rvs(dist, size)
return NDArray(r)
def p2h(press):
"""
Pressure to height
:param press: (*float*) Pressure - hPa.
:returns: (*float*) Height - meter.
"""
if isinstance(press, NDArray):
r = NDArray(ArrayMath.press2Height(press.asarray()))
if isinstance(press, DimArray):
r = DimArray(r, press.dims, press.fill_value, press.proj)
return r
else:
return MeteoMath.press2Height(press)
def lognormal(mean=0.0, sigma=1.0, size=None):
"""
Draw samples from the log-normal distribution.
:param mean: (*float*) Mean value of the underlying normal distribution. Default is 0.
:param sigma: (*float*) Standard deviation of the underlying normal distribution. Should be greater than zero. Default is 1.
:param size: (*int*) Output shape. If size is None (default), a single value is returned.
:returns: (*ndarray or scalar*) Drawn samples from the parameterized log-normal distribution.
"""
dist = LogNormalDistribution(loc, scale)
if size is None:
size = 1
r = DistributionUtil.rvs(dist, size)
return NDArray(r)
def logistic(loc=0.0, scale=1.0, size=None):
"""
Draw samples from the Logistic distribution.
:param loc: (*float*) Mean (“centre”) of the distribution.
:param scale: (*float*) Standard deviation (spread or “width”) of the distribution.
:param size: (*int*) Output shape. If size is None (default), a single value is returned.
:returns: (*ndarray or scalar*) Drawn samples from the parameterized Logistic distribution.
"""
dist = LogisticDistribution(loc, scale)
if size is None:
size = 1
r = DistributionUtil.rvs(dist, size)
return NDArray(r)
def laplace(loc=0.0, scale=1.0, size=None):
"""
Draw samples from the Laplace or double exponential distribution with specified location (or mean) and scale (decay).
:param loc: (*float*) Mean (“centre”) of the distribution.
:param scale: (*float*) Standard deviation (spread or “width”) of the distribution.
:param size: (*int*) Output shape. If size is None (default), a single value is returned.
:returns: (*ndarray or scalar*) Drawn samples from the parameterized Laplace distribution.
"""
dist = LaplaceDistribution(loc, scale)
if size is None:
size = 1
r = DistributionUtil.rvs(dist, size)
return NDArray(r)
def gamma(shape, scale=1.0, size=None):
"""
Draw random samples from a Gamma distribution.
:param shape: (*float*) The shape of the gamma distribution. Should be greater than zero.
:param scale: (*float*) Standard deviation (spread or “width”) of the distribution.
:param size: (*int*) Output shape. If size is None (default), a single value is returned.
:returns: (*ndarray or scalar*) Drawn samples from the parameterized Gamma distribution.
"""
dist = GammaDistribution(shape, scale)
if size is None:
size = 1
r = DistributionUtil.rvs(dist, size)
return NDArray(r)
def f(dfnum, dfden, size=None):
"""
Draw random samples from a F distribution.
:param dfnum: (*float*) Degrees of freedom in numerator, should be > 0.
:param dfden: (*float*) Degrees of freedom in denominator, should be > 0.
:param size: (*int*) Output shape. If size is None (default), a single value is returned.
:returns: (*ndarray or scalar*) Drawn samples from the parameterized Fisher distribution.
"""
dist = FDistribution(dfnum, dfden)
if size is None:
size = 1
r = DistributionUtil.rvs(dist, size)
return NDArray(r)
def poisson(lam=1.0, size=None):
"""
Draw samples from a Poisson distribution.
:param lam: (*float*) Expectation of interval, should be >= 0.
:param size: (*int or tuple*) Output shape. If the given shape is, e.g., (m, n, k), then m * n * k samples
are drawn. Default is None, in which case a single value is returned.
:returns: (*float or array*) Drawn samples from the parameterized Poisson distribution.
"""
if size is None:
r = RandomUtil.poisson(lam)
else:
r = NDArray(RandomUtil.poisson(lam, size))
return r
def h2p(height):
"""
Height to pressure
:param height: (*float*) Height - meter.
:returns: (*float*) Pressure - hPa.
"""
if isinstance(height, NDArray):
r = NDArray(ArrayMath.height2Press(height.asarray()))
if isinstance(height, DimArray):
r = DimArray(r, height.dims, height.fill_value, height.proj)
return r
else:
return MeteoMath.height2Press(height)