def crossings(y, value, x=None):
'''Finds the crossing points where a (poly-)line defined by a 1D y array has the given
values and return the (linearly) interpolated index or x value if an x array is given
'''
if x is None:
return _dsutils.crossings(y, value)
return _dsutils.crossings(x, y, value)
def normalise(a, allelements=True):
'''Normalise array so all elements lie between 0 and 1
Keyword argument:
allelements -- if True, then normalise for all elements rather than per-element
'''
if isinstance(a, _abscompoundds):
return _dsutils.norm(a, allelements)
return _dsutils.norm(a)
def centroid(weights, coords=None):
'''Calculate the centroid of an array with its (half) indexes or
coordinates (list of 1D arrays), if given, and returns it as a list
'''
if coords is None:
return _dsutils.centroid(weights)
from jycore import toList
return _dsutils.centroid(weights, toList(coords))
def append(arr, values, axis=None):
'''Append values to end of array
Keyword argument:
axis -- if None, then append flattened values to flattened array
'''
if not isinstance(values, _abstractds):
values = __cvt_jobj(values, dtype=None, copy=False, force=True)
if axis is None:
return _dsutils.append(arr.flatten(), values.flatten(), 0)
return _dsutils.append(arr, values, axis)
def logspace(start, stop, num=50, endpoint=True, base=10.0):
'''Create a 1D dataset of values equally spaced on a logarithmic scale'''
if complex(start).imag == 0 and complex(stop).imag == 0:
return _dsutils.logSpace(start, stop, num, base, endpoint)
else:
result = linspace(start, stop, num, endpoint)
return _maths.power(base, result)
def where(condition, x=None, y=None):
'''Return items from x or y depending on condition'''
if x and y:
return _dsutils.select(condition, (x, y), 0)
elif not x and not y:
return _cmps.nonZero(condition)
else:
raise ValueError, "Both x and y must be specified"
def linspace(start, stop, num=50, endpoint=True, retstep=False):
'''Create a 1D dataset from start to stop in given number of steps
Arguments:
start -- starting value
stop -- stopping value
num -- number of steps, defaults to 50
endpoint -- if True (default), include the stop value
retstep -- if False (default), do not include the calculated step value as part of return tuple
'''
if not endpoint:
step = (stop - start) / (num - 1.)
stop -= step
dtype = _getdtypefromobj(((start, stop)))
if dtype.value < float64.value:
dtype = float64
if dtype.value >= complex64.value:
dtype = complex128
if type(start) is _types.IntType:
start = start+0j
if type(stop) is _types.IntType:
stop = stop+0j
rresult = _dsutils.linSpace(start.real, stop.real, num, float64.value)
iresult = _dsutils.linSpace(start.imag, stop.imag, num, float64.value)
result = Sciwrap(_complexdoubleds(rresult, iresult))
del rresult, iresult
else:
result = Sciwrap(_dsutils.linSpace(start, stop, num, dtype.value))
if retstep:
step = result[1] - result[0]
return (step, result)
else:
return result
def choose(a, choices, mode='raise'):
'''Return dataset with items drawn from choices according to conditions'''
if mode == 'raise':
rf = True
cf = False
else:
rf = False
if mode == 'clip':
cf = True
elif mode == 'wrap':
cf = False
else:
raise ValueError, "mode is not one of raise, clip or wrap"
return _dsutils.choose(a, choices, rf, cf)
def maximum(a, b):
return _dsutils.maximum(a, b)
def swapaxes(a, axis1, axis2):
return _dsutils.swapAxes(a, axis1, axis2)
def transpose(a, axes=None):
if axes is None:
axes = ()
return _dsutils.transpose(a, asIterable(axes))
def select(condlist, choicelist, default=0):
'''Return dataset with items drawn from choices according to conditions'''
return _dsutils.select(condlist, choicelist, default)
def nan_to_num(a):
'''Create a copy with infinities replaced by max/min values and NaNs replaced by 0s
'''
c = a.copy()
_dsutils.removeNansAndInfinities(c)
return c
def rollaxis(a, axis, start=0):
return _dsutils.rollAxis(a, axis, start)
def indices(dimensions, dtype=int32):
ind = _dsutils.indices(asIterable(dimensions))
dtype = _translatenativetype(dtype)
if dtype != int32:
ind = _dsutils.cast(ind, dtype.value)
return ind
def tile(a, reps):
return _dsutils.tile(a, asIterable(reps))
def sort(a, axis=-1):
return _dsutils.sort(a, axis)
def array_split(ary, indices_or_sections, axis=0):
return _dsutils.split(ary, indices_or_sections, axis, False)
def split(ary, indices_or_sections, axis=0):
return _dsutils.split(ary, indices_or_sections, axis, True)
def dstack(tup):
return _dsutils.concatenate(toList(tup), 2)
def concatenate(a, axis=0):
return _dsutils.concatenate(toList(a), axis)
def minimum(a, b):
return _dsutils.minimum(a, b)
def meshgrid(*a):
axes = [ asDataset(x) for x in reversed(a) ]
coords = _dsutils.meshGrid(axes)
return tuple([ Sciwrap(x) for x in reversed(coords) ])
def diag(v, k=0):
x = asDataset(v)._jdataset()
return _dsutils.diag(x, k)
def roll(a, shift, axis=None):
return _dsutils.roll(a, shift, axis)
def cast(a, dtype):
return _dsutils.cast(a, dtype.value)
def compoundarray(a, view=True):
'''Create a compound array from an nd array by grouping last axis items into compound items
'''
return _dsutils.createCompoundDatasetFromLastAxis(a, view)
def resize(a, new_shape):
return _dsutils.resize(a, new_shape)
def repeat(a, repeats, axis=-1):
return _dsutils.repeat(a, asIterable(repeats), axis)
def diagflat(v, k=0):
x = asDataset(v).flatten()._jdataset()
return _dsutils.diag(x, k)
