def median(self, axis=None):
'''
Compute tha median along the specified axis.
:param axis: (*int*) Axis along which the standard deviation is computed.
The default is to compute the standard deviation of the flattened array.
returns: (*array_like*) Median result
'''
if axis is None:
return ArrayMath.median(self._array)
else:
return NDArray(ArrayMath.median(self._array, axis))
def sum(self, axis=None):
'''
Sum of array elements over a given axis.
:param axis: (*int*) Axis along which the standard deviation is computed.
The default is to compute the standard deviation of the flattened array.
returns: (*array_like*) Sum result
'''
if axis is None:
return ArrayMath.sum(self._array)
else:
r = ArrayMath.sum(self._array, axis)
return NDArray(r)
def cumsum(self, axis=None):
'''
Return the cumulative sum of the elements along a given axis.
:param axis: (*int*) Axis along which the standard deviation is computed.
The default is to compute the standard deviation of the flattened array.
returns: (*array_like*) Sum result
'''
if axis is None:
return ArrayMath.cumsum(self.flatten()._array, 0)
else:
r = ArrayMath.cumsum(self._array, axis)
return NDArray(r)
def max(self, axis=None):
'''
Get maximum value along an axis.
:param axis: (*int*) Axis along which the maximum is computed. The default is to
compute the maximum of the flattened array.
:returns: Maximum values.
'''
if axis is None:
r = ArrayMath.max(self._array)
return r
else:
r = ArrayMath.max(self._array, axis)
return NDArray(r)
def argmax(self, axis=None):
'''
Returns the indices of the minimum values along an axis.
:param axis: (*int*) By default, the index is into the flattened array, otherwise
along the specified axis.
:returns: Array of indices into the array. It has the same shape as a.shape with the
dimension along axis removed.
'''
if axis is None:
r = ArrayMath.argMax(self._array)
return r
else:
r = ArrayMath.argMax(self._array, axis)
return NDArray(r)
def contains_nan(self):
'''
Check if the array contains nan value.
:returns: (*boolean*) True if contains nan, otherwise return False.
'''
return ArrayMath.containsNaN(self._array)
def std(self, axis=None):
'''
Compute the standard deviation along the specified axis.
:param x: (*array_like or list*) Input values.
:param axis: (*int*) Axis along which the standard deviation is computed.
The default is to compute the standard deviation of the flattened array.
returns: (*array_like*) Standart deviation result.
'''
if axis is None:
r = ArrayMath.std(self._array)
return r
else:
r = ArrayMath.std(self._array, axis)
return NDArray(r)
def floor(self):
'''
Return the floor of the input, element-wise.
:return: The floor of each element.
'''
return NDArray(ArrayMath.floor(self._array))
def ceil(self):
'''
Return the ceiling of the input, element-wise.
:return: The ceiling of each element.
'''
return NDArray(ArrayMath.ceil(self._array))
def sign(self):
'''
Returns an element-wise indication of the sign of a number.
The sign function returns -1 if x < 0, 0 if x==0, 1 if x > 0. nan is returned for nan inputs.
'''
return NDArray(ArrayMath.sign(self._array))
def prod(self):
'''
Return the product of array elements.
:returns: (*float*) Produce value.
'''
return ArrayMath.prodDouble(self._array)
def var(self, axis=None, ddof=0):
'''
Compute variance along the specified axis.
:param axis: (*int*) Axis along which the variance is computed.
The default is to compute the variance of the flattened array.
:param ddof: (*int*) Delta Degrees of Freedom: the divisor used in the calculation is
N - ddof, where N represents the number of elements. By default ddof is zero.
returns: (*array_like*) Variance result.
'''
if self.ndim == 1 or axis is None:
r = ArrayMath.var(self._array, ddof)
return r
else:
r = ArrayMath.var(self._array, axis, ddof)
return NDArray(r)
def abs(self):
'''
Calculate the absolute value element-wise.
:returns: An array containing the absolute value of each element in x.
For complex input, a + ib, the absolute value is \sqrt{ a^2 + b^2 }.
'''
return NDArray(ArrayMath.abs(self._array))
def take(self, indices):
'''
Take elements from an array along an axis.
:param indices: (*array_like*) The indices of the values to extract.
:returns: (*array*) The returned array has the same type as a.
'''
ilist = [indices]
r = ArrayMath.take(self._array, ilist)
return NDArray(r)
def transpose(self):
'''
Transpose 2-D array.
:returns: Transposed array.
'''
if self.ndim == 1:
return self[:]
dim1 = 0
dim2 = 1
r = ArrayMath.transpose(self.asarray(), dim1, dim2)
return NDArray(r)
def dot(self, other):
"""
Matrix multiplication.
:param other: (*2D or 1D Array*) Matrix or vector b.
:returns: Result Matrix or vector.
"""
if isinstance(other, list):
other = array(other)
r = ArrayMath.dot(self._array, other._array)
return NDArray(r)
def take(self, indices, axis=None):
'''
Take elements from an array along an axis.
:param indices: (*array_like*) The indices of the values to extract.
:param axis: (*int*) The axis over which to select values.
:returns: (*array*) The returned array has the same type as a.
'''
if isinstance(indices, (list, tuple)):
indices = NDArray(indices)
r = ArrayMath.take(self._array, indices._array, axis)
return NDArray(r)
def in_values(self, other):
'''
Return the array with the value of 1 when the element value
in the list other, otherwise set value as 0.
:param other: (*list or array*) List value.
:returns: (*array*) Result array.
'''
if not isinstance(other, (list, tuple)):
other = other.aslist()
r = NDArray(ArrayMath.inValues(self._array, other))
return r
def linregress(x, y, outvdn=False):
'''
Calculate a linear least-squares regression for two sets of measurements.
:param x, y: (*array_like*) Two sets of measurements. Both arrays should have the same length.
:param outvdn: (*boolean*) Output validate data number or not. Default is False.
:returns: Result slope, intercept, relative coefficient, two-sided p-value for a hypothesis test
whose null hypothesis is that the slope is zero, standard error of the estimated gradient,
validate data number (remove NaN values).
'''
if isinstance(x, list):
x = np.array(x)
if isinstance(y, list):
y = np.array(y)
r = ArrayMath.lineRegress(x.asarray(), y.asarray())
if outvdn:
return r[0], r[1], r[2], r[3], r[4], r[5]
else:
return r[0], r[1], r[2], r[3], r[4]
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 maskout(data, mask, x=None, y=None):
"""
Maskout data by polygons - NaN values of elements outside polygons.
:param data: (*array_like*) Array data for maskout.
:param mask: (*list*) Polygon list as maskout borders.
:param x: (*array_like*) X coordinate array.
:param y: (*array_like*) Y coordinate array.
:returns: (*array_like*) Maskouted data array.
"""
if mask is None:
return data
elif isinstance(mask, (NDArray, DimArray)):
r = ArrayMath.maskout(data.asarray(), mask.asarray())
if isinstance(data, DimArray):
return DimArray(r, data.dims, data.fill_value, data.proj)
else:
return NDArray(r)
if x is None or y is None:
if isinstance(data, DimArray):
x = data.dimvalue(data.ndim - 1)
y = data.dimvalue(data.ndim - 2)
else:
return None
if not isinstance(mask, (list, ArrayList)):
mask = [mask]
if data.ndim == 2 and x.ndim == 1 and y.ndim == 1:
x, y = np.meshgrid(x, y)
r = GeometryUtil.maskout(data._array, x._array, y._array, mask)
if isinstance(data, DimArray):
return DimArray(r, data.dims, data.fill_value, data.proj)
else:
return NDArray(r)
def __getitem__(self, indices):
if self.variable.getDataType() in [DataType.STRUCTURE, DataType.SEQUENCE]:
if isinstance(indices, str): #metadata
return self.member_array(indices)
else:
a = self.dataset.read(self.name)
return StructureArray(a.getArrayObject())
if indices is None:
inds = []
for i in range(self.ndim):
inds.append(slice(None))
indices = tuple(inds)
if not isinstance(indices, tuple):
inds = []
inds.append(indices)
indices = inds
if len(indices) < self.ndim:
indices = list(indices)
for i in range(self.ndim - len(indices)):
indices.append(slice(None))
indices = tuple(indices)
if len(indices) != self.ndim:
print 'indices must be ' + str(self.ndim) + ' dimensions!'
return None
if not self.proj is None and not self.proj.isLonLat():
xlim = None
ylim = None
xidx = -1
yidx = -1
for i in range(0, self.ndim):
dim = self.dims[i]
if dim.getDimType() == DimensionType.X:
k = indices[i]
if isinstance(k, basestring):
xlims = k.split(':')
if len(xlims) == 1:
xlim = [float(xlims[0])]
else:
xlim = [float(xlims[0]), float(xlims[1])]
xidx = i
elif dim.getDimType() == DimensionType.Y:
k = indices[i]
if isinstance(k, basestring):
ylims = k.split(':')
if len(ylims) == 1:
ylim = [float(ylims[0])]
else:
ylim = [float(ylims[0]), float(ylims[1])]
yidx = i
if not xlim is None and not ylim is None:
fromproj=KnownCoordinateSystems.geographic.world.WGS1984
inpt = PointD(xlim[0], ylim[0])
outpt1 = Reproject.reprojectPoint(inpt, fromproj, self.proj)
if len(xlim) == 1:
xlim = [outpt1.X]
ylim = [outpt1.Y]
else:
inpt = PointD(xlim[1], ylim[1])
outpt2 = Reproject.reprojectPoint(inpt, fromproj, self.proj)
xlim = [outpt1.X, outpt2.X]
ylim = [outpt1.Y, outpt2.Y]
indices1 = []
for i in range(0, self.ndim):
if i == xidx:
if len(xlim) == 1:
indices1.append(str(xlim[0]))
else:
indices1.append(str(xlim[0]) + ':' + str(xlim[1]))
elif i == yidx:
if len(ylim) == 1:
indices1.append(str(ylim[0]))
else:
indices1.append(str(ylim[0]) + ':' + str(ylim[1]))
else:
indices1.append(indices[i])
indices = indices1
origin = []
size = []
stride = []
ranges = []
dims = []
flips = []
onlyrange = True
for i in range(0, self.ndim):
isrange = True
dimlen = self.dimlen(i)
k = indices[i]
if isinstance(k, int):
if k < 0:
k = self.dims[i].getLength() + k
sidx = k
eidx = k
step = 1
elif isinstance(k, slice):
if isinstance(k.start, basestring):
sv = float(k.start)
sidx = self.dims[i].getValueIndex(sv)
elif isinstance(k.start, datetime.datetime):
sv = miutil.date2num(k.start)
sidx = self.dims[i].getValueIndex(sv)
else:
sidx = 0 if k.start is None else k.start
if sidx < 0:
sidx = self.dimlen(i) + sidx
if isinstance(k.stop, basestring):
ev = float(k.stop)
eidx = self.dims[i].getValueIndex(ev)
elif isinstance(k.stop, datetime.datetime):
ev = miutil.date2num(k.stop)
eidx = self.dims[i].getValueIndex(ev)
else:
eidx = self.dimlen(i) if k.stop is None else k.stop
if eidx < 0:
eidx = self.dimlen(i) + eidx
eidx -= 1
if isinstance(k.step, basestring):
nv = float(k.step) + self.dims[i].getDimValue()[0]
nidx = self.dims[i].getValueIndex(nv)
step = nidx - sidx
elif isinstance(k.step, datetime.timedelta):
nv = miutil.date2num(k.start + k.step)
nidx = self.dims[i].getValueIndex(nv)
step = nidx - sidx
else:
step = 1 if k.step is None else k.step
if sidx > eidx:
iidx = eidx
eidx = sidx
sidx = iidx
elif isinstance(k, list):
onlyrange = False
isrange = False
if not isinstance(k[0], datetime.datetime):
ranges.append(k)
else:
tlist = []
for tt in k:
sv = miutil.date2num(tt)
idx = self.dims[i].getValueIndex(sv)
tlist.append(idx)
ranges.append(tlist)
k = tlist
elif isinstance(k, basestring):
dim = self.variable.getDimension(i)
kvalues = k.split(':')
sv = float(kvalues[0])
sidx = dim.getValueIndex(sv)
if len(kvalues) == 1:
eidx = sidx
step = 1
else:
ev = float(kvalues[1])
eidx = dim.getValueIndex(ev)
if len(kvalues) == 2:
step = 1
else:
step = int(float(kvalues[2]) / dim.getDeltaValue())
if sidx > eidx:
iidx = eidx
eidx = sidx
sidx = iidx
else:
print k
return None
if isrange:
if eidx >= dimlen:
print 'Index out of range!'
return None
origin.append(sidx)
n = eidx - sidx + 1
size.append(n)
if n > 1:
dim = self.variable.getDimension(i)
if dim.isReverse():
step = -step
dim = dim.extract(sidx, eidx, step)
dim.setReverse(False)
dims.append(dim)
stride.append(step)
if step < 0:
step = abs(step)
flips.append(i)
rr = Range(sidx, eidx, step)
ranges.append(rr)
else:
if len(k) > 1:
dim = self.variable.getDimension(i)
dim = dim.extract(k)
dim.setReverse(False)
dims.append(dim)
#rr = self.dataset.read(self.name, origin, size, stride).reduce()
if onlyrange:
rr = self.dataset.dataset.read(self.name, ranges)
else:
rr = self.dataset.dataset.take(self.name, ranges)
if rr.getSize() == 1:
iter = rr.getIndexIterator()
return iter.getObjectNext()
else:
for i in flips:
rr = rr.flip(i)
rr = rr.reduce()
ArrayMath.missingToNaN(rr, self.fill_value)
if len(flips) > 0:
rrr = Array.factory(rr.getDataType(), rr.getShape())
MAMath.copy(rrr, rr)
array = np.array(rrr)
else:
array = np.array(rr)
data = np.DimArray(array, dims, self.fill_value, self.dataset.proj)
return data
def join(self, b, dimidx):
r = ArrayMath.join(self._array, b._array, dimidx)
return NDArray(r)
def __getitem__(self, indices):
if not isinstance(indices, tuple):
inds = []
inds.append(indices)
indices = inds
if len(indices) < self.ndim:
if isinstance(indices, tuple):
indices = list(indices)
for i in range(self.ndim - len(indices)):
indices.append(slice(None))
allint = True
aindex = self._array.getIndex()
i = 0
for ii in indices:
if isinstance(ii, int):
if ii < 0:
ii = self.shape[i] + ii
aindex.setDim(i, ii)
else:
allint = False
break
i += 1
if allint:
return self._array.getObject(aindex)
if self.ndim == 0:
return self
newaxisn = 0
newaxis = False
if len(indices) > self.ndim:
newaxisn = len(indices) - self.ndim
newaxis = True
for i in range(newaxisn):
if not indices[-i - 1] is None:
newaxis = False
if newaxis:
indices = list(indices)
indices = indices[:-newaxisn]
if len(indices) != self.ndim:
print 'indices must be ' + str(self.ndim) + ' dimensions!'
raise IndexError()
ranges = []
flips = []
onlyrange = True
alllist = True
isempty = False
nshape = []
for i in range(0, self.ndim):
k = indices[i]
if isinstance(k, int):
if k < 0:
k = self._shape[i] + k
sidx = k
eidx = k
step = 1
alllist = False
elif isinstance(k, slice):
sidx = 0 if k.start is None else k.start
if sidx < 0:
sidx = self._shape[i] + sidx
eidx = self._shape[i] if k.stop is None else k.stop
if eidx < 0:
eidx = self._shape[i] + eidx
eidx -= 1
step = 1 if k.step is None else k.step
alllist = False
elif isinstance(k, (list, tuple, NDArray)):
if isinstance(k, NDArray):
k = k.aslist()
if isinstance(k[0], bool):
kk = []
for i in range(len(k)):
if k[i]:
kk.append(i)
k = kk
onlyrange = False
ranges.append(k)
continue
else:
print k
return None
if step < 0:
step = abs(step)
flips.append(i)
if eidx < sidx:
tempidx = sidx
sidx = eidx + 2
eidx = tempidx
if sidx >= self.shape[i]:
isempty = True
if eidx < sidx:
isempty = True
else:
rr = Range(sidx, eidx, step)
ranges.append(rr)
nshape.append(eidx - sidx + 1 if eidx - sidx >= 0 else 0)
if isempty:
r = ArrayUtil.empty([0], self.dtype._dtype)
return NDArray(r)
if onlyrange:
r = ArrayMath.section(self._array, ranges)
else:
if alllist:
r = ArrayMath.takeValues(self._array, ranges)
else:
r = ArrayMath.take(self._array, ranges)
if newaxis:
for i in flips:
r = r.flip(i)
rr = Array.factory(r.getDataType(), r.getShape())
MAMath.copy(rr, r)
rr = NDArray(rr)
newshape = list(rr.shape)
for i in range(newaxisn):
newshape.append(1)
return rr.reshape(newshape)
if r.getSize() == 1:
iter = r.getIndexIterator()
r = iter.getObjectNext()
if isinstance(r, Complex):
return complex(r.getReal(), r.getImaginary())
else:
return r
else:
for i in flips:
r = r.flip(i)
r = NDArray(r)
if onlyrange:
r.base = self.get_base()
return r
def tolist(self):
'''
Convert to a list
'''
r = ArrayMath.asList(self._array)
return list(r)
def aslist(self):
r = ArrayMath.asList(self._array)
return list(r)
def log10(self):
return NDArray(ArrayMath.log10(self._array))
def exp(self):
return NDArray(ArrayMath.exp(self._array))
def atan(self):
return NDArray(ArrayMath.atan(self._array))
def acos(self):
return NDArray(ArrayMath.acos(self._array))