The following are code examples for showing how to use . They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don’t like. You can also save this page to your account.
Example 1
def __deepcopy__(self, memo):
obj = type(self).__new__(type(self))
if isinstance(self.base_value, VectorizedIterable): # special case, but perhaps need to rethink
obj.base_value = self.base_value # whether deepcopy is appropriate everywhere
else:
try:
obj.base_value = deepcopy(self.base_value)
except TypeError: # base_value cannot be copied, e.g. is a generator (but see generator_tools from PyPI)
obj.base_value = self.base_value # so here we create a reference rather than deepcopying - could cause problems
obj._shape = self._shape
obj.dtype = self.dtype
obj.operations = []
for f, arg in self.operations:
if isinstance(f, numpy.ufunc):
obj.operations.append((f, deepcopy(arg)))
else:
obj.operations.append((deepcopy(f), deepcopy(arg)))
return obj Example 2
def __array_prepare__(self, result, context=None):
"""
Gets called prior to a ufunc
"""
# nice error message for non-ufunc types
if context is not None and not isinstance(self._values, np.ndarray):
obj = context[1][0]
raise TypeError("{obj} with dtype {dtype} cannot perform "
"the numpy op {op}".format(
obj=type(obj).__name__,
dtype=getattr(obj, 'dtype', None),
op=context[0].__name__))
return result
# complex Example 3
def __array_wrap__(self, result, context=None):
"""
Gets called after a ufunc. Needs additional handling as
PeriodIndex stores internal data as int dtype
Replace this to __numpy_ufunc__ in future version
"""
if isinstance(context, tuple) and len(context) > 0:
func = context[0]
if (func is np.add):
return self._add_delta(context[1][1])
elif (func is np.subtract):
return self._add_delta(-context[1][1])
elif isinstance(func, np.ufunc):
if 'M->M' not in func.types:
msg = "ufunc '{0}' not supported for the PeriodIndex"
# This should be TypeError, but TypeError cannot be raised
# from here because numpy catches.
raise ValueError(msg.format(func.__name__))
if com.is_bool_dtype(result):
return result
return PeriodIndex(result, freq=self.freq, name=self.name) Example 4
def __init__(self, scalar_op, inplace_pattern=None, name=None,
nfunc_spec=None, openmp=None):
if inplace_pattern is None:
inplace_pattern = {}
self.name = name
self.scalar_op = scalar_op
self.inplace_pattern = inplace_pattern
self.destroy_map = dict((o, [i]) for o, i in inplace_pattern.items())
self.ufunc = None
self.nfunc = None
if nfunc_spec is None:
nfunc_spec = getattr(scalar_op, 'nfunc_spec', None)
self.nfunc_spec = nfunc_spec
if nfunc_spec:
self.nfunc = getattr(numpy, nfunc_spec[0])
# precompute the hash of this node
self._rehash()
super(Elemwise, self).__init__(openmp=openmp) Example 5
def set_ufunc(self, scalar_op):
# This is probably a speed up of the implementation
if isinstance(scalar_op, theano.scalar.basic.Add):
self.ufunc = numpy.add
elif isinstance(scalar_op, theano.scalar.basic.Mul):
self.ufunc = numpy.multiply
elif isinstance(scalar_op, theano.scalar.basic.Maximum):
self.ufunc = numpy.maximum
elif isinstance(scalar_op, theano.scalar.basic.Minimum):
self.ufunc = numpy.minimum
elif isinstance(scalar_op, theano.scalar.basic.AND):
self.ufunc = numpy.bitwise_and
elif isinstance(scalar_op, theano.scalar.basic.OR):
self.ufunc = numpy.bitwise_or
elif isinstance(scalar_op, theano.scalar.basic.XOR):
self.ufunc = numpy.bitwise_xor
else:
self.ufunc = numpy.frompyfunc(scalar_op.impl, 2, 1) Example 6
def _check_binary_ufunc(ufunc):
""" Check that ufunc is suitable for ``ireduce_ufunc`` """
if not isinstance(ufunc, np.ufunc):
raise TypeError('{} is not a NumPy Ufunc'.format(ufunc.__name__))
if not ufunc.nin == 2:
raise ValueError('Only binary ufuncs are supported, and {} is \
not one of them'.format(ufunc.__name__))
# Ufuncs that always return bool are problematic because they can be reduced
# but not be accumulated.
# Recall: numpy.dtype('?') == np.bool
if all(type_signature[-1] == '?' for type_signature in ufunc.types):
raise ValueError('Only binary ufuncs that preserve type are supported, \
and {} is not one of them'.format(ufunc.__name__)) Example 7
def _ireduce_ufunc_new_axis(arrays, ufunc, **kwargs):
"""
Reduction operation for arrays, in the direction of a new axis (i.e. stacking).
Parameters
----------
arrays : iterable
Arrays to be reduced.
ufunc : numpy.ufunc
Binary universal function. Must have a signature of the form ufunc(x1, x2, ...)
kwargs
Keyword arguments are passed to ``ufunc``.
Yields
------
reduced : ndarray
"""
arrays = iter(arrays)
first = next(arrays)
kwargs.pop('axis')
dtype = kwargs.get('dtype', None)
if dtype is None:
dtype = first.dtype
else:
kwargs['casting'] = 'unsafe'
# If the out parameter was already given
# we create the accumulator from it
# Otherwise, it is a copy of the first array
accumulator = kwargs.pop('out', None)
if accumulator is not None:
accumulator[:] = first
else:
accumulator = np.array(first, copy = True).astype(dtype)
yield accumulator
for array in arrays:
ufunc(accumulator, array, out = accumulator, **kwargs)
yield accumulator Example 8
def _ireduce_ufunc_all_axes(arrays, ufunc, **kwargs):
"""
Reduction operation for arrays, over all axes.
Parameters
----------
arrays : iterable
Arrays to be reduced.
ufunc : numpy.ufunc
Binary universal function. Must have a signature of the form ufunc(x1, x2, ...)
kwargs
Keyword arguments are passed to ``ufunc``. The ``out`` parameter is ignored.
Yields
------
reduced : scalar
"""
arrays = iter(arrays)
first = next(arrays)
kwargs['axis'] = None
kwargs.pop('out', None) # Remove the out-parameter if provided.
axis_reduce = partial(ufunc.reduce, **kwargs)
accumulator = axis_reduce(first)
yield accumulator
for array in arrays:
accumulator = axis_reduce([accumulator, axis_reduce(array)])
yield accumulator Example 9
def _validate_method(method, dy, fit_bias, nterms,
frequency, assume_regular_frequency):
fast_method_ok = hasattr(np.ufunc, 'at')
if not fast_method_ok:
warnings.warn("Fast Lomb-Scargle methods require numpy version 1.8 "
"or newer. Using slower methods instead.")
# automatically choose the appropiate method
if method == 'auto':
if nterms != 1:
if (fast_method_ok and len(frequency) > 100
and _is_regular(frequency, assume_regular_frequency)):
method = 'fastchi2'
else:
method = 'chi2'
elif (fast_method_ok and len(frequency) > 100
and _is_regular(frequency, assume_regular_frequency)):
method = 'fast'
elif dy is None and not fit_bias:
method = 'scipy'
else:
method = 'slow'
if method not in METHODS:
raise ValueError("invalid method: {0}".format(method))
return method Example 10
def _build_ufunc(func):
"""Return a ufunc that works with lazy arrays"""
def larray_compatible_ufunc(x):
if isinstance(x, larray):
y = deepcopy(x)
y.apply(func)
return y
else:
return func(x)
return larray_compatible_ufunc Example 11
def __array_wrap__(self, result, context=None):
"""
Gets called after a ufunc
"""
return self._constructor(result, index=self.index,
copy=False).__finalize__(self) Example 12
def apply(self, func, axis=0, broadcast=False, reduce=False):
"""
Analogous to DataFrame.apply, for SparseDataFrame
Parameters
----------
func : function
Function to apply to each column
axis : {0, 1, 'index', 'columns'}
broadcast : bool, default False
For aggregation functions, return object of same size with values
propagated
Returns
-------
applied : Series or SparseDataFrame
"""
if not len(self.columns):
return self
axis = self._get_axis_number(axis)
if isinstance(func, np.ufunc):
new_series = {}
for k, v in compat.iteritems(self):
applied = func(v)
applied.fill_value = func(applied.fill_value)
new_series[k] = applied
return self._constructor(
new_series, index=self.index, columns=self.columns,
default_fill_value=self._default_fill_value,
kind=self._default_kind).__finalize__(self)
else:
if not broadcast:
return self._apply_standard(func, axis, reduce=reduce)
else:
return self._apply_broadcast(func, axis) Example 13
def __getstate__(self):
d = copy(self.__dict__)
d.pop('ufunc')
d.pop('nfunc')
d.pop('__epydoc_asRoutine', None)
d.pop('_hashval')
return d Example 14
def __setstate__(self, d):
super(Elemwise, self).__setstate__(d)
self.ufunc = None
self.nfunc = None
if getattr(self, 'nfunc_spec', None):
self.nfunc = getattr(numpy, self.nfunc_spec[0])
elif 0 < self.scalar_op.nin < 32:
self.ufunc = numpy.frompyfunc(self.scalar_op.impl,
self.scalar_op.nin,
self.scalar_op.nout)
self._rehash() Example 15
def reduce_ufunc(*args, **kwargs):
"""
Streaming reduction generator function from a binary NumPy ufunc. Essentially the
function equivalent to `ireduce_ufunc`.
``ufunc`` must be a NumPy binary Ufunc (i.e. it takes two arguments). Moreover,
for performance reasons, ufunc must have the same return types as input types.
This precludes the use of ``numpy.greater``, for example.
Note that performance is much better for the default ``axis = -1``. In such a case,
reduction operations can occur in-place. This also allows to operate in constant-memory.
Parameters
----------
arrays : iterable
Arrays to be reduced.
ufunc : numpy.ufunc
Binary universal function.
axis : int or None, optional
Reduction axis. Default is to reduce the arrays in the stream as if
they had been stacked along a new axis, then reduce along this new axis.
If None, arrays are flattened before reduction. If `axis` is an int larger that
the number of dimensions in the arrays of the stream, arrays are reduced
along the new axis. Note that not all of NumPy Ufuncs support
``axis = None``, e.g. ``numpy.subtract``.
dtype : numpy.dtype or None, optional
Overrides the dtype of the calculation and output arrays.
ignore_nan : bool, optional
If True and ufunc has an identity value (e.g. ``numpy.add.identity`` is 0), then NaNs
are replaced with this identity. An error is raised if ``ufunc`` has no identity (e.g. ``numpy.maximum.identity`` is ``None``).
kwargs
Keyword arguments are passed to ``ufunc``. Note that some valid ufunc keyword arguments
(e.g. ``keepdims``) are not valid for all streaming functions. Note that
contrary to NumPy v. 1.10+, ``casting = 'unsafe`` is the default in npstreams.
Yields
------
reduced : ndarray or scalar
Raises
------
TypeError : if ``ufunc`` is not NumPy ufunc.
ValueError : if ``ignore_nan`` is True but ``ufunc`` has no identity
ValueError: if ``ufunc`` is not a binary ufunc
ValueError: if ``ufunc`` does not have the same input type as output type
"""
return last(ireduce_ufunc(*args, **kwargs)) Example 16
def _ireduce_ufunc_existing_axis(arrays, ufunc, **kwargs):
"""
Reduction operation for arrays, in the direction of an existing axis.
Parameters
----------
arrays : iterable
Arrays to be reduced.
ufunc : numpy.ufunc
Binary universal function. Must have a signature of the form ufunc(x1, x2, ...)
kwargs
Keyword arguments are passed to ``ufunc``. The ``out`` parameter is ignored.
Yields
------
reduced : ndarray
"""
arrays = iter(arrays)
first = next(arrays)
if kwargs['axis'] not in range(first.ndim):
raise ValueError('Axis {} not supported on arrays of shape {}.'.format(kwargs['axis'], first.shape))
# Remove the out-parameter if provided.
kwargs.pop('out', None)
dtype = kwargs.get('dtype')
if dtype is None:
dtype = first.dtype
axis_reduce = partial(ufunc.reduce, **kwargs)
accumulator = np.atleast_1d(axis_reduce(first))
yield accumulator
# On the first pass of the following loop, accumulator is missing a dimensions
# therefore, the stacking function cannot be 'concatenate'
second = next(arrays)
accumulator = np.stack([accumulator, np.atleast_1d(axis_reduce(second))], axis = -1)
yield accumulator
# On the second pass, the new dimensions exists, and thus we switch to
# using concatenate.
for array in arrays:
reduced = np.expand_dims(np.atleast_1d(axis_reduce(array)), axis = accumulator.ndim - 1)
accumulator = np.concatenate([accumulator, reduced], axis = accumulator.ndim - 1)
yield accumulator Example 17
def compute_group(cls, data, scales, **params):
fun = params['fun']
n = params['n']
args = params['args']
xlim = params['xlim']
try:
range_x = xlim or scales.x.dimension((0, 0))
except AttributeError:
raise PlotnineError(
"Missing 'x' aesthetic and 'xlim' is {}".format(xlim))
if not hasattr(fun, '__call__'):
raise PlotnineError(
"stat_function requires parameter 'fun' to be " +
"a function or any other callable object")
old_fun = fun
if isinstance(args, (list, tuple)):
def fun(x):
return old_fun(x, *args)
elif isinstance(args, dict):
def fun(x):
return old_fun(x, **args)
elif args is not None:
def fun(x):
return old_fun(x, args)
else:
def fun(x):
return old_fun(x)
x = np.linspace(range_x[0], range_x[1], n)
# continuous scale
with suppress(AttributeError):
x = scales.x.trans.inverse(x)
# We know these can handle array-likes
if isinstance(old_fun, (np.ufunc, np.vectorize)):
y = fun(x)
else:
y = [fun(val) for val in x]
new_data = pd.DataFrame({'x': x, 'y': y})
return new_data Example 18
def prepare_node(self, node, storage_map, compute_map, impl):
# Postpone the ufunc building to the last minutes
# NumPy ufunc support only up to 31 inputs.
# But our c code support more.
if (len(node.inputs) < 32 and
(self.nfunc is None or
self.scalar_op.nin != len(node.inputs)) and
self.ufunc is None and
impl == 'py'):
ufunc = numpy.frompyfunc(self.scalar_op.impl,
len(node.inputs),
self.scalar_op.nout)
if self.scalar_op.nin > 0:
# We can reuse it for many nodes
self.ufunc = ufunc
else:
node.tag.ufunc = ufunc
# Numpy ufuncs will sometimes perform operations in
# float16, in particular when the input is int8.
# This is not something that we want, and we do not
# do it in the C code, so we specify that the computation
# should be carried out in the returned dtype.
# This is done via the "sig" kwarg of the ufunc, its value
# should be something like "ff->f", where the characters
# represent the dtype of the inputs and outputs.
# NumPy 1.10.1 raise an error when giving the signature
# when the input is complex. So add it only when inputs is int.
out_dtype = node.outputs[0].dtype
if (out_dtype in float_dtypes and
isinstance(self.nfunc, numpy.ufunc) and
node.inputs[0].dtype in discrete_dtypes):
char = numpy.sctype2char(out_dtype)
sig = char * node.nin + '->' + char * node.nout
node.tag.sig = sig
node.tag.fake_node = Apply(
self.scalar_op,
[get_scalar_type(dtype=input.type.dtype).make_variable()
for input in node.inputs],
[get_scalar_type(dtype=output.type.dtype).make_variable()
for output in node.outputs])
self.scalar_op.prepare_node(node.tag.fake_node, None, None, impl) Example 19
def perform(self, node, inp, out):
input, = inp
output, = out
axis = self.axis
if axis is None:
axis = list(range(input.ndim))
variable = input
to_reduce = reversed(sorted(axis))
if hasattr(self, 'acc_dtype') and self.acc_dtype is not None:
acc_dtype = self.acc_dtype
else:
acc_dtype = node.outputs[0].type.dtype
if to_reduce:
for dimension in to_reduce:
# If it's a zero-size array, use scalar_op.identity
# if available
if variable.shape[dimension] == 0:
if hasattr(self.scalar_op, 'identity'):
# Compute the shape of the output
v_shape = list(variable.shape)
del v_shape[dimension]
variable = numpy.empty(tuple(v_shape),
dtype=acc_dtype)
variable.fill(self.scalar_op.identity)
else:
raise ValueError((
"Input (%s) has zero-size on axis %s, but "
"self.scalar_op (%s) has no attribute 'identity'"
% (variable, dimension, self.scalar_op)))
else:
# Numpy 1.6 has a bug where you sometimes have to specify
# "dtype='object'" in reduce for it to work, if the ufunc
# was built with "frompyfunc". We need to find out if we
# are in one of these cases (only "object" is supported in
# the output).
if ((self.ufunc.ntypes == 1) and
(self.ufunc.types[0][-1] == 'O')):
variable = self.ufunc.reduce(variable, dimension,
dtype='object')
else:
variable = self.ufunc.reduce(variable, dimension,
dtype=acc_dtype)
variable = numpy.asarray(variable)
if numpy.may_share_memory(variable, input):
# perhaps numpy is clever for reductions of size 1?
# We don't want this.
variable = variable.copy()
output[0] = theano._asarray(variable,
dtype=node.outputs[0].type.dtype)
else:
# Force a copy
output[0] = numpy.array(variable, copy=True,
dtype=node.outputs[0].type.dtype) 