r"""

if isinstance(values, LArray):

return values.all(axis)

else:

r"""

if isinstance(values, LArray):

return values.any(axis)

else:

r"""

# XXX: we might want to be more aggressive here (more types to convert), however, generators should still be

# computed via the builtin.

if isinstance(array, (np.ndarray, list)):

array = LArray(array)

if isinstance(array, LArray):

return array.sum(*args, **kwargs)

else:

r"""

r"""

r"""

r"""

if isinstance(array, LArray):

return array.min(*args, **kwargs)

else:

r"""

if isinstance(array, LArray):

return array.max(*args, **kwargs)

else:

r"""

r"""

r"""

r"""

r"""

r"""

r"""Concatenate arrays along axis

# Get axis by name, so that we do *NOT* check they are "compatible", because it makes sense to append axes of

# different length

name = arrays[0].axes[axis].name

arrays_labels = [array.axes[axis].labels for array in arrays]

# switch to object dtype if labels are of incompatible types, so that we do not implicitly convert numeric types to

# strings (numpy should not do this in the first place but that is another story). This can happen for example when

# we want to add a "total" tick to a numeric axis (eg age).

labels_type = common_type(arrays_labels)

if labels_type is object:

# astype always copies, while asarray only copies if necessary

arrays_labels = [np.asarray(labels, dtype=object) for labels in arrays_labels]

combined_axis = Axis(np.concatenate(arrays_labels), name)

# combine all axes (using labels from any side if any)

result_axes = arrays[0].axes.replace(axis, combined_axis).union(*[array.axes - axis for array in arrays[1:]])

if dtype is None:

dtype = common_type(arrays)

result = empty(result_axes, dtype=dtype)

start = 0

for labels, array in zip(arrays_labels, arrays):

stop = start + len(labels)

result[combined_axis.i[start:stop]] = array

start = stop

__slots__ = ('next',)

def __init__(self, array):

data_iter = iter(array.data)

next_data_func = data_iter.next

res_axes = array.axes[1:]

# this case should not happen (handled by the fastpath in LArray.__iter__)

assert len(res_axes) > 0

def next_func():

return LArray(next_data_func(), res_axes)

self.next = next_func

def __iter__(self):

__slots__ = ('__next__',)

def __init__(self, array):

data_iter = iter(array.data)

next_data_func = data_iter.__next__

res_axes = array.axes[1:]

# this case should not happen (handled by the fastpath in LArray.__iter__)

assert len(res_axes) > 0

def next_func():

return LArray(next_data_func(), res_axes)

self.__next__ = next_func

def __iter__(self):

"""

__slots__ = ('array',)

def __init__(self, array):

self.array = array

def _translate_key(self, key):

r"""

if not isinstance(key, tuple):

key = (key,)

if len(key) > self.array.ndim:

raise IndexError("key has too many indices (%d) for array with %d dimensions" % (len(key), self.array.ndim))

# no need to create a full nd key as that will be done later anyway

return tuple(axis.i[axis_key]

for axis_key, axis in zip(key, self.array.axes))

def __getitem__(self, key):

ndim = self.array.ndim

full_scalar_key = (

(isinstance(key, (int, np.integer)) and ndim == 1) or

(isinstance(key, tuple) and len(key) == ndim and all(isinstance(k, (int, np.integer)) for k in key))

)

# fast path when the result is a scalar

if full_scalar_key:

return self.array.data[key]

else:

return self.array[self._translate_key(key)]

def __setitem__(self, key, value):

array = self.array

ndim = array.ndim

full_scalar_key = (

(isinstance(key, (int, np.integer)) and ndim == 1) or

(isinstance(key, tuple) and len(key) == ndim and all(isinstance(k, (int, np.integer)) for k in key))

)

# fast path when setting a single cell

if full_scalar_key:

array.data[key] = value

else:

array[self._translate_key(key)] = value

def __len__(self):

return len(self.array)

def __iter__(self):

array = self.array

# fast path for 1D arrays (where we return scalars)

if array.ndim <= 1:

return iter(array.data)

else:

__slots__ = ('array',)

def __init__(self, array):

self.array = array

def _prepare_key(self, key, wildcard=False):

axes = self.array.axes

# 1) complete key & translate (those two cannot be dissociated because to complete

# the key we need to know which axis each key belongs to and to do that, we need to

# translate the key to indices)

translated_key = axes._translated_key(key)

# 2) transform keys to IGroup and non-LArray advanced keys to LArray with a combined axis

return axes._adv_keys_to_combined_axis_la_keys(translated_key, wildcard)

def __getitem__(self, key):

return self.array.__getitem__(self._prepare_key(key), translate_key=False)

def __setitem__(self, key, value):

r"""

__slots__ = ('array',)

def __init__(self, array):

self.array = array

def __getitem__(self, flat_key, sep='_'):

if isinstance(flat_key, ABCLArray):

flat_np_key = flat_key.data

res_axes = flat_key.axes

else:

flat_np_key = np.asarray(flat_key)

axes = self.array.axes

nd_key = np.unravel_index(flat_np_key, axes.shape)

# the following lines are equivalent to (but faster than) "return array.ipoints[nd_key]"

# TODO: extract a function which only computes the combined axes because we do not use the actual LArrays

# produced here, which is wasteful. AxisCollection._flat_lookup seems related (but not usable as-is).

la_key = axes._adv_keys_to_combined_axis_la_keys(nd_key, sep=sep)

first_axis_key_axes = la_key[0].axes

assert all(isinstance(axis_key, ABCLArray) and axis_key.axes is first_axis_key_axes

for axis_key in la_key[1:])

res_axes = first_axis_key_axes

return LArray(self.array.data.flat[flat_np_key], res_axes)

def __setitem__(self, flat_key, value):

# np.ndarray.flat is a flatiter object but it is indexable despite the name

self.array.data.flat[flat_key] = value

def __len__(self):

__slots__ = ('array',)

"""

def __init__(self, array):

self.array = array

def _prepare_key(self, key, wildcard=False):

return self.array.axes._adv_keys_to_combined_axis_la_keys(key, wildcard)

def __getitem__(self, key):

return self.array.__getitem__(self._prepare_key(key), translate_key=False)

def __setitem__(self, key, value):

# we still need to prepare the key instead of letting numpy handle everything so that

# existing (integer)LArray keys are broadcasted correctly (using axes names).

r"""

'q': """

'dtype': {'value': None, 'doc': """

The data type of the returned array. Defaults to None (the dtype of the input array)."""},

'out': {'value': None, 'doc': """

Axes and labels can be different, only the shape matters. Defaults to None (create a new array)."""},

'ddof': {'value': 1, 'doc': """

the number of elements. Defaults to 1."""},

'skipna': {'value': None, 'doc': """

cells is NaN. Defaults to True."""},

'keepaxes': {'value': False, 'doc': """

(e.g. keepaxes='summation'). Defaults to False."""},

'interpolation': {'value': 'linear', 'doc': """

Defaults to 'linear'."""}

if not long_name:

long_name = func.__name__

_args = ','.join(extra_args) + ', ' if len(extra_args) > 0 else ''

_kwargs = ', '.join(["{}={!r}".format(k, _kwarg_agg[k]['value']) for k in kwargs]) + ', ' if len(kwargs) > 0 else ''

signature = '{name}({args}*axes_and_groups, {kwargs}**explicit_axes)'.format(name=func.__name__,

args=_args, kwargs=_kwargs)

if by:

specific_template = """The {long_name} is {action_verb}ed along all axes except the given one(s).

else:

specific_template = "Axis(es) or group(s) along which the {long_name} is {action_verb}ed."

doc_specific = specific_template.format(long_name=long_name, action_verb=action_verb)

doc_args = "".join(_arg_agg[arg] for arg in extra_args)

doc_kwargs = "".join(_kwarg_agg[kw]['doc'] for kw in kwargs)

doc_varargs = r"""

* ('a1:a3 >> a123', 'b[b0,b2] >> b12') : operator ' >> ' allows to rename groups."""\

.format(specific=doc_specific, action_verb=action_verb, long_name=long_name)

parameters = """Parameters

----------{args}{varargs}{kwargs}""".format(args=doc_args, varargs=doc_varargs, kwargs=doc_kwargs)

import warnings

warnings.warn("element_equal() is deprecated. Use array1.eq(array2, rtol, atol, nan_equals) instead.",

FutureWarning, stacklevel=2)

a1 = aslarray(a1)

import warnings

warnings.warn("nan_equal() is deprecated. Use array1.eq(array2, nans_equal=True) instead.",

FutureWarning, stacklevel=2)

"""

if title is not None:

if meta is None:

meta = Metadata()

warnings.warn("title argument is deprecated. Please use meta argument instead", FutureWarning, stacklevel=2)

meta['title'] = title

if meta is None or isinstance(meta, Metadata):

return meta

# XXX: move this test in Metadata.__init__?

if not isinstance(meta, (list, dict, OrderedDict)):

raise TypeError("Expected None, list of pairs, dict, OrderedDict or Metadata object "

"instead of {}".format(type(meta).__name__))

r"""

__slots__ = ('data', 'axes', '_meta')

def __init__(self, data, axes=None, title=None, meta=None, dtype=None):

data = np.asarray(data, dtype=dtype)

ndim = data.ndim

if axes is None:

axes = AxisCollection(data.shape)

else:

if not isinstance(axes, AxisCollection):

axes = AxisCollection(axes)

if axes.ndim != ndim:

raise ValueError("number of axes (%d) does not match "

"number of dimensions of data (%d)"

% (axes.ndim, ndim))

if axes.shape != data.shape:

raise ValueError("length of axes %s does not match "

"data shape %s" % (axes.shape, data.shape))

self.data = data

self.axes = axes

meta = _handle_meta(meta, title)

self._meta = meta

@property

def title(self):

import warnings

warnings.warn("title attribute is deprecated. Please use meta.title instead", FutureWarning, stacklevel=2)

return self._meta.title if self._meta is not None and 'title' in self._meta else None

@title.setter

def title(self, title):

import warnings

warnings.warn("title attribute is deprecated. Please use meta.title instead", FutureWarning, stacklevel=2)

if not isinstance(title, basestring):

raise TypeError("Expected string value, got {}".format(type(title).__name__))

self._meta.title = title

@property

def meta(self):

r"""Returns metadata of the array.

if self._meta is None:

self._meta = Metadata()

return self._meta

@meta.setter

def meta(self, meta):

self._meta = _handle_meta(meta, None)

# TODO: rename to inonzero and implement a label version of nonzero

# TODO: implement wildcard argument to avoid producing the combined labels

def nonzero(self):

r"""

# the next step will be to return a Grid instead so that cond.nonzero() *displays*

# (however it is stored!) as something like:

# option a)

# a_b a0_b2 a1_b0 a1_b1 a1_b2

# a0,b2 a1,b0 a1,b1 a1,b2

# PRO: * result axes are the same as grid axes

# CON: * does not support getting the indexing for one axis (or at least it does not make it obvious that it

# is supported)

# * in the case of ambiguous labels (same label on several axes), this is not explicit enough

# OR

# option b)

# source_axis\a_b a0_b2 a1_b0 a1_b1 a1_b2

# a a0 a1 a1 a1

# b b2 b0 b1 b2

# in the presence of duplicate labels on the same axis (e.g. assuming we replace 'b2' by a duplicate 'b1' label)

# source_axis\a_b a0_b1#1 a1_b0 a1_b1#0 a1_b1#1

# a a0 a1 a1 a1

# b b1#1 b0 b1#0 b1#1

# OR

# option c)

# a_b\source_axis a b

# a0_b2 a0 b2

# a1_b0 a1 b0

# a1_b1 a1 b1

# a1_b2 a1 b2

# Notes

# -----

# dtypes of a and b column can be different but since we probably only store indices, we will not even need

# an LFrame so this shouldn't be a problem.

ikey = self.data.nonzero()

la_key = self.axes._adv_keys_to_combined_axis_la_keys(ikey)

return tuple(IGroup(axis_key, axis=axis) for axis_key, axis in zip(la_key, self.axes))

def set_axes(self, axes_to_replace=None, new_axis=None, inplace=False, **kwargs):

r"""