diff --git a/RELEASE.rst b/RELEASE.rst index 25350555317bd..b97b9443032a4 100644 --- a/RELEASE.rst +++ b/RELEASE.rst @@ -32,9 +32,9 @@ pandas 0.11.0 - Allow mixed dtypes (e.g ``float32/float64/int32/int16/int8``) to coexist in DataFrames and propogate in operations - Add function to pandas.io.data for retrieving stock index components from - Yahoo! finance (#2795) + Yahoo! finance (GH2795_) - Add ``squeeze`` function to reduce dimensionality of 1-len objects - - Support slicing with time objects (#2681) + - Support slicing with time objects (GH2681_) **Improvements to existing features** @@ -46,7 +46,7 @@ pandas 0.11.0 return a datetime64[ns] dtype with non-convertibles set as ``NaT``; will preserve an all-nan object (e.g. strings) - Series print output now includes the dtype by default - - Optimize internal reindexing routines for upcasting cases (#2819) + - Optimize internal reindexing routines (GH2819_, GH2867_) - ``describe_option()`` now reports the default and current value of options. **API Changes** @@ -62,7 +62,8 @@ pandas 0.11.0 (float32/float64); other types will be operated on, and will try to cast back to the input dtype (e.g. if an int is passed, as long as the output doesn't have nans, then an int will be returned) - - backfill/pad/take/diff/ohlc will now support ``float32/int16/int8`` operations + - backfill/pad/take/diff/ohlc will now support ``float32/int16/int8`` + operations - Integer block types will upcast as needed in where operations (GH2793_) - Series now automatically will try to set the correct dtype based on passed datetimelike objects (datetime/Timestamp) @@ -83,22 +84,31 @@ pandas 0.11.0 (e.g. np.array(datetime(2001,1,1,0,0))), w/o dtype being passed - 0-dim ndarrays with a passed dtype are handled correctly (e.g. np.array(0.,dtype='float32')) - - Fix some boolean indexing inconsistencies in Series __getitem__/__setitem__ + - Fix some boolean indexing inconsistencies in Series.__getitem__/__setitem__ (GH2776_) + - Fix issues with DataFrame and Series constructor with integers that + overflow ``int64`` and some mixed typed type lists (GH2845_) ``HDFStore`` - Fix weird PyTables error when using too many selectors in a where - - Provide dotted attribute access to ``get`` from stores (e.g. store.df == store['df']) - - Internally, change all variables to be private-like (now have leading underscore) + - Provide dotted attribute access to ``get`` from stores + (e.g. store.df == store['df']) + - Internally, change all variables to be private-like (now have leading + underscore) .. _GH622: https://github.com/pydata/pandas/issues/622 .. _GH797: https://github.com/pydata/pandas/issues/797 -.. _GH2778: https://github.com/pydata/pandas/issues/2778 -.. _GH2793: https://github.com/pydata/pandas/issues/2793 -.. _GH2751: https://github.com/pydata/pandas/issues/2751 +.. _GH2681: https://github.com/pydata/pandas/issues/2681 .. _GH2747: https://github.com/pydata/pandas/issues/2747 +.. _GH2751: https://github.com/pydata/pandas/issues/2751 .. _GH2776: https://github.com/pydata/pandas/issues/2776 +.. _GH2778: https://github.com/pydata/pandas/issues/2778 +.. _GH2793: https://github.com/pydata/pandas/issues/2793 +.. _GH2795: https://github.com/pydata/pandas/issues/2795 +.. _GH2819: https://github.com/pydata/pandas/issues/2819 +.. _GH2845: https://github.com/pydata/pandas/issues/2845 +.. _GH2867: https://github.com/pydata/pandas/issues/2867 pandas 0.10.1 ============= @@ -107,7 +117,7 @@ pandas 0.10.1 **New features** - - Add data inferface to World Bank WDI pandas.io.wb (#2592) + - Add data inferface to World Bank WDI pandas.io.wb (GH2592_) **API Changes** @@ -125,7 +135,8 @@ pandas 0.10.1 - ``HDFStore`` - enables storing of multi-index dataframes (closes GH1277_) - - support data column indexing and selection, via ``data_columns`` keyword in append + - support data column indexing and selection, via ``data_columns`` keyword + in append - support write chunking to reduce memory footprint, via ``chunksize`` keyword to append - support automagic indexing via ``index`` keyword to append @@ -138,11 +149,14 @@ pandas 0.10.1 - added methods append_to_multiple/select_as_multiple/select_as_coordinates to do multiple-table append/selection - added support for datetime64 in columns - - added method ``unique`` to select the unique values in an indexable or data column + - added method ``unique`` to select the unique values in an indexable or + data column - added method ``copy`` to copy an existing store (and possibly upgrade) - - show the shape of the data on disk for non-table stores when printing the store - - added ability to read PyTables flavor tables (allows compatiblity to other HDF5 systems) - - Add ``logx`` option to DataFrame/Series.plot (GH2327_, #2565) + - show the shape of the data on disk for non-table stores when printing the + store + - added ability to read PyTables flavor tables (allows compatiblity to + other HDF5 systems) + - Add ``logx`` option to DataFrame/Series.plot (GH2327_, GH2565_) - Support reading gzipped data from file-like object - ``pivot_table`` aggfunc can be anything used in GroupBy.aggregate (GH2643_) - Implement DataFrame merges in case where set cardinalities might overflow @@ -173,11 +187,12 @@ pandas 0.10.1 - Fix DatetimeIndex handling of FixedOffset tz (GH2604_) - More robust detection of being in IPython session for wide DataFrame console formatting (GH2585_) - - Fix platform issues with ``file:///`` in unit test (#2564) + - Fix platform issues with ``file:///`` in unit test (GH2564_) - Fix bug and possible segfault when grouping by hierarchical level that contains NA values (GH2616_) - - Ensure that MultiIndex tuples can be constructed with NAs (seen in #2616) - - Fix int64 overflow issue when unstacking MultiIndex with many levels (#2616) + - Ensure that MultiIndex tuples can be constructed with NAs (GH2616_) + - Fix int64 overflow issue when unstacking MultiIndex with many levels + (GH2616_) - Exclude non-numeric data from DataFrame.quantile by default (GH2625_) - Fix a Cython C int64 boxing issue causing read_csv to return incorrect results (GH2599_) @@ -188,12 +203,14 @@ pandas 0.10.1 - Fix C parser-tokenizer bug with trailing fields. (GH2668_) - Don't exclude non-numeric data from GroupBy.max/min (GH2700_) - Don't lose time zone when calling DatetimeIndex.drop (GH2621_) - - Fix setitem on a Series with a boolean key and a non-scalar as value (GH2686_) + - Fix setitem on a Series with a boolean key and a non-scalar as value + (GH2686_) - Box datetime64 values in Series.apply/map (GH2627_, GH2689_) - Upconvert datetime + datetime64 values when concatenating frames (GH2624_) - Raise a more helpful error message in merge operations when one DataFrame has duplicate columns (GH2649_) - - Fix partial date parsing issue occuring only when code is run at EOM (GH2618_) + - Fix partial date parsing issue occuring only when code is run at EOM + (GH2618_) - Prevent MemoryError when using counting sort in sortlevel with high-cardinality MultiIndex objects (GH2684_) - Fix Period resampling bug when all values fall into a single bin (GH2070_) @@ -204,6 +221,7 @@ pandas 0.10.1 .. _GH1277: https://github.com/pydata/pandas/issues/1277 .. _GH2070: https://github.com/pydata/pandas/issues/2070 .. _GH2327: https://github.com/pydata/pandas/issues/2327 +.. _GH2565: https://github.com/pydata/pandas/issues/2565 .. _GH2585: https://github.com/pydata/pandas/issues/2585 .. _GH2599: https://github.com/pydata/pandas/issues/2599 .. _GH2604: https://github.com/pydata/pandas/issues/2604 @@ -232,6 +250,9 @@ pandas 0.10.1 .. _GH2694: https://github.com/pydata/pandas/issues/2694 .. _GH2686: https://github.com/pydata/pandas/issues/2686 .. _GH2618: https://github.com/pydata/pandas/issues/2618 +.. _GH2592: https://github.com/pydata/pandas/issues/2592 +.. _GH2564: https://github.com/pydata/pandas/issues/2564 +.. _GH2616: https://github.com/pydata/pandas/issues/2616 pandas 0.10.0 ============= @@ -708,7 +729,7 @@ pandas 0.9.1 .. _GH2117: https://github.com/pydata/pandas/issues/2117 .. _GH2133: https://github.com/pydata/pandas/issues/2133 .. _GH2114: https://github.com/pydata/pandas/issues/2114 -.. _GH2527: https://github.com/pydata/pandas/issues/2114 +.. _GH2527: https://github.com/pydata/pandas/issues/2527 .. _GH2128: https://github.com/pydata/pandas/issues/2128 .. _GH2008: https://github.com/pydata/pandas/issues/2008 .. _GH2179: https://github.com/pydata/pandas/issues/2179 diff --git a/pandas/core/common.py b/pandas/core/common.py index 98a92072fe608..4f2852f42f985 100644 --- a/pandas/core/common.py +++ b/pandas/core/common.py @@ -247,7 +247,7 @@ def _unpickle_array(bytes): return arr -def _view_wrapper(f, arr_dtype, out_dtype, fill_wrap=None): +def _view_wrapper(f, arr_dtype=None, out_dtype=None, fill_wrap=None): def wrapper(arr, indexer, out, fill_value=np.nan): if arr_dtype is not None: arr = arr.view(arr_dtype) @@ -259,17 +259,6 @@ def wrapper(arr, indexer, out, fill_value=np.nan): return wrapper -def _datetime64_fill_wrap(fill_value): - if isnull(fill_value): - return tslib.iNaT - try: - return lib.Timestamp(fill_value).value - except: - # the proper thing to do here would probably be to upcast to object - # (but numpy 1.6.1 doesn't do this properly) - return tslib.iNaT - - def _convert_wrapper(f, conv_dtype): def wrapper(arr, indexer, out, fill_value=np.nan): arr = arr.astype(conv_dtype) @@ -277,18 +266,21 @@ def wrapper(arr, indexer, out, fill_value=np.nan): return wrapper -def _take_2d_multi_generic(arr, indexer, out, fill_value=np.nan): - # this is not ideal, performance-wise, but it's better than - # raising an exception - if arr.shape[0] == 0 or arr.shape[1] == 0: - return +def _take_2d_multi_generic(arr, indexer, out, fill_value, mask_info): + # this is not ideal, performance-wise, but it's better than raising + # an exception (best to optimize in Cython to avoid getting here) row_idx, col_idx = indexer - row_mask = row_idx == -1 - col_mask = col_idx == -1 + if mask_info is not None: + (row_mask, col_mask), (row_needs, col_needs) = mask_info + else: + row_mask = row_idx == -1 + col_mask = col_idx == -1 + row_needs = row_mask.any() + col_needs = col_mask.any() if fill_value is not None: - if row_mask.any(): + if row_needs: out[row_mask, :] = fill_value - if col_mask.any(): + if col_needs: out[:, col_mask] = fill_value for i in range(len(row_idx)): u = row_idx[i] @@ -297,14 +289,16 @@ def _take_2d_multi_generic(arr, indexer, out, fill_value=np.nan): out[i, j] = arr[u, v] -def _take_nd_generic(arr, indexer, out, axis=0, fill_value=np.nan): - if arr.shape[axis] == 0: - return - mask = indexer == -1 - needs_masking = mask.any() +def _take_nd_generic(arr, indexer, out, axis, fill_value, mask_info): + if mask_info is not None: + mask, needs_masking = mask_info + else: + mask = indexer == -1 + needs_masking = mask.any() if arr.dtype != out.dtype: arr = arr.astype(out.dtype) - ndtake(arr, indexer, axis=axis, out=out) + if arr.shape[axis] > 0: + arr.take(_ensure_platform_int(indexer), axis=axis, out=out) if needs_masking: outindexer = [slice(None)] * arr.ndim outindexer[axis] = mask @@ -334,8 +328,7 @@ def _take_nd_generic(arr, indexer, out, axis=0, fill_value=np.nan): ('bool', 'object'): _view_wrapper(algos.take_1d_bool_object, np.uint8, None), ('datetime64[ns]','datetime64[ns]'): - _view_wrapper(algos.take_1d_int64_int64, np.int64, np.int64, - fill_wrap=_datetime64_fill_wrap) + _view_wrapper(algos.take_1d_int64_int64, np.int64, np.int64, np.int64) } @@ -363,7 +356,7 @@ def _take_nd_generic(arr, indexer, out, axis=0, fill_value=np.nan): _view_wrapper(algos.take_2d_axis0_bool_object, np.uint8, None), ('datetime64[ns]','datetime64[ns]'): _view_wrapper(algos.take_2d_axis0_int64_int64, np.int64, np.int64, - fill_wrap=_datetime64_fill_wrap) + fill_wrap=np.int64) } @@ -391,7 +384,7 @@ def _take_nd_generic(arr, indexer, out, axis=0, fill_value=np.nan): _view_wrapper(algos.take_2d_axis1_bool_object, np.uint8, None), ('datetime64[ns]','datetime64[ns]'): _view_wrapper(algos.take_2d_axis1_int64_int64, np.int64, np.int64, - fill_wrap=_datetime64_fill_wrap) + fill_wrap=np.int64) } @@ -419,159 +412,187 @@ def _take_nd_generic(arr, indexer, out, axis=0, fill_value=np.nan): _view_wrapper(algos.take_2d_multi_bool_object, np.uint8, None), ('datetime64[ns]','datetime64[ns]'): _view_wrapper(algos.take_2d_multi_int64_int64, np.int64, np.int64, - fill_wrap=_datetime64_fill_wrap) + fill_wrap=np.int64) } -def _get_take_1d_function(dtype, out_dtype): - try: - return _take_1d_dict[dtype.name, out_dtype.name] - except KeyError: - pass - - if dtype != out_dtype: - try: - func = _take_1d_dict[out_dtype.name, out_dtype.name] - return _convert_wrapper(func, out_dtype) - except KeyError: - pass - - def wrapper(arr, indexer, out, fill_value=np.nan): - return _take_nd_generic(arr, indexer, out, axis=0, - fill_value=fill_value) - return wrapper - - -def _get_take_2d_function(dtype, out_dtype, axis=0): - try: - if axis == 0: - return _take_2d_axis0_dict[dtype.name, out_dtype.name] - elif axis == 1: - return _take_2d_axis1_dict[dtype.name, out_dtype.name] - elif axis == 'multi': - return _take_2d_multi_dict[dtype.name, out_dtype.name] - else: # pragma: no cover - raise ValueError('bad axis: %s' % axis) - except KeyError: - pass - - if dtype != out_dtype: - try: +def _get_take_nd_function(ndim, arr_dtype, out_dtype, axis=0, mask_info=None): + if ndim <= 2: + tup = (arr_dtype.name, out_dtype.name) + if ndim == 1: + func = _take_1d_dict.get(tup, None) + elif ndim == 2: if axis == 0: - func = _take_2d_axis0_dict[out_dtype.name, out_dtype.name] - elif axis == 1: - func = _take_2d_axis1_dict[out_dtype.name, out_dtype.name] + func = _take_2d_axis0_dict.get(tup, None) else: - func = _take_2d_multi_dict[out_dtype.name, out_dtype.name] - return _convert_wrapper(func, out_dtype) - except KeyError: - pass - - if axis == 'multi': - return _take_2d_multi_generic - - def wrapper(arr, indexer, out, fill_value=np.nan): - return _take_nd_generic(arr, indexer, out, axis=axis, - fill_value=fill_value) - return wrapper - - -def _get_take_nd_function(ndim, dtype, out_dtype, axis=0): - if ndim == 2: - return _get_take_2d_function(dtype, out_dtype, axis=axis) - elif ndim == 1: - if axis != 0: - raise ValueError('axis must be 0 for one dimensional array') - return _get_take_1d_function(dtype, out_dtype) - elif ndim <= 0: - raise ValueError('ndim must be >= 1') - - def wrapper(arr, indexer, out, fill_value=np.nan): - return _take_nd_generic(arr, indexer, out, axis=axis, - fill_value=fill_value) - if (dtype.name, out_dtype.name) == ('datetime64[ns]','datetime64[ns]'): - wrapper = _view_wrapper(wrapper, np.int64, np.int64, - fill_wrap=_datetime64_fill_wrap) - return wrapper + func = _take_2d_axis1_dict.get(tup, None) + if func is not None: + return func + + tup = (out_dtype.name, out_dtype.name) + if ndim == 1: + func = _take_1d_dict.get(tup, None) + elif ndim == 2: + if axis == 0: + func = _take_2d_axis0_dict.get(tup, None) + else: + func = _take_2d_axis1_dict.get(tup, None) + if func is not None: + func = _convert_wrapper(func, out_dtype) + return func + + def func(arr, indexer, out, fill_value=np.nan): + _take_nd_generic(arr, indexer, out, axis=axis, + fill_value=fill_value, mask_info=mask_info) + return func -def take_1d(arr, indexer, out=None, fill_value=np.nan): +def take_nd(arr, indexer, axis=0, out=None, fill_value=np.nan, + mask_info=None, allow_fill=True): """ Specialized Cython take which sets NaN values in one pass + + Parameters + ---------- + arr : ndarray + Input array + indexer : ndarray + 1-D array of indices to take, subarrays corresponding to -1 value + indicies are filed with fill_value + axis : int, default 0 + Axis to take from + out : ndarray or None, default None + Optional output array, must be appropriate type to hold input and + fill_value together, if indexer has any -1 value entries; call + common._maybe_promote to determine this type for any fill_value + fill_value : any, default np.nan + Fill value to replace -1 values with + mask_info : tuple of (ndarray, boolean) + If provided, value should correspond to: + (indexer != -1, (indexer != -1).any()) + If not provided, it will be computed internally if necessary + allow_fill : boolean, default True + If False, indexer is assumed to contain no -1 values so no filling + will be done. This short-circuits computation of a mask. Result is + undefined if allow_fill == False and -1 is present in indexer. """ if indexer is None: - indexer = np.arange(len(arr), dtype=np.int64) + indexer = np.arange(arr.shape[axis], dtype=np.int64) dtype, fill_value = arr.dtype, arr.dtype.type() else: indexer = _ensure_int64(indexer) - dtype = _maybe_promote(arr.dtype, fill_value)[0] - if dtype != arr.dtype: - mask = indexer == -1 - needs_masking = mask.any() - if needs_masking: - if out is not None and out.dtype != dtype: - raise Exception('Incompatible type for fill_value') - else: - dtype, fill_value = arr.dtype, arr.dtype.type() - + if not allow_fill: + dtype, fill_value = arr.dtype, arr.dtype.type() + mask_info = None, False + else: + # check for promotion based on types only (do this first because + # it's faster than computing a mask) + dtype, fill_value = _maybe_promote(arr.dtype, fill_value) + if dtype != arr.dtype and (out is None or out.dtype != dtype): + # check if promotion is actually required based on indexer + if mask_info is not None: + mask, needs_masking = mask_info + else: + mask = indexer == -1 + needs_masking = mask.any() + mask_info = mask, needs_masking + if needs_masking: + if out is not None and out.dtype != dtype: + raise Exception('Incompatible type for fill_value') + else: + # if not, then depromote, set fill_value to dummy + # (it won't be used but we don't want the cython code + # to crash when trying to cast it to dtype) + dtype, fill_value = arr.dtype, arr.dtype.type() + + # at this point, it's guaranteed that dtype can hold both the arr values + # and the fill_value if out is None: - out = np.empty(len(indexer), dtype=dtype) - take_f = _get_take_1d_function(arr.dtype, out.dtype) - take_f(arr, indexer, out=out, fill_value=fill_value) + out_shape = list(arr.shape) + out_shape[axis] = len(indexer) + out_shape = tuple(out_shape) + if arr.flags.f_contiguous and axis == arr.ndim - 1: + # minor tweak that can make an order-of-magnitude difference + # for dataframes initialized directly from 2-d ndarrays + # (s.t. df.values is c-contiguous and df._data.blocks[0] is its + # f-contiguous transpose) + out = np.empty(out_shape, dtype=dtype, order='F') + else: + out = np.empty(out_shape, dtype=dtype) + + func = _get_take_nd_function(arr.ndim, arr.dtype, out.dtype, + axis=axis, mask_info=mask_info) + func(arr, indexer, out, fill_value) return out -def take_nd(arr, indexer, out=None, axis=0, fill_value=np.nan): - """ - Specialized Cython take which sets NaN values in one pass - """ - if indexer is None: - mask = None - needs_masking = False - fill_value = arr.dtype.type() - else: - indexer = _ensure_int64(indexer) - mask = indexer == -1 - needs_masking = mask.any() - if not needs_masking: - fill_value = arr.dtype.type() - return take_fast(arr, indexer, mask, needs_masking, axis, out, fill_value) +take_1d = take_nd -def take_2d_multi(arr, row_idx, col_idx, fill_value=np.nan, out=None): +def take_2d_multi(arr, indexer, out=None, fill_value=np.nan, + mask_info=None, allow_fill=True): """ Specialized Cython take which sets NaN values in one pass """ - if row_idx is None: + if indexer is None or (indexer[0] is None and indexer[1] is None): row_idx = np.arange(arr.shape[0], dtype=np.int64) - else: - row_idx = _ensure_int64(row_idx) - - if col_idx is None: col_idx = np.arange(arr.shape[1], dtype=np.int64) + indexer = row_idx, col_idx + dtype, fill_value = arr.dtype, arr.dtype.type() else: - col_idx = _ensure_int64(col_idx) - - dtype = _maybe_promote(arr.dtype, fill_value)[0] - if dtype != arr.dtype: - row_mask = row_idx == -1 - col_mask = col_idx == -1 - needs_masking = row_mask.any() or col_mask.any() - if needs_masking: - if out is not None and out.dtype != dtype: - raise Exception('Incompatible type for fill_value') + row_idx, col_idx = indexer + if row_idx is None: + row_idx = np.arange(arr.shape[0], dtype=np.int64) else: + row_idx = _ensure_int64(row_idx) + if col_idx is None: + col_idx = np.arange(arr.shape[1], dtype=np.int64) + else: + col_idx = _ensure_int64(col_idx) + indexer = row_idx, col_idx + if not allow_fill: dtype, fill_value = arr.dtype, arr.dtype.type() + mask_info = None, False + else: + # check for promotion based on types only (do this first because + # it's faster than computing a mask) + dtype, fill_value = _maybe_promote(arr.dtype, fill_value) + if dtype != arr.dtype and (out is None or out.dtype != dtype): + # check if promotion is actually required based on indexer + if mask_info is not None: + (row_mask, col_mask), (row_needs, col_needs) = mask_info + else: + row_mask = row_idx == -1 + col_mask = col_idx == -1 + row_needs = row_mask.any() + col_needs = col_mask.any() + mask_info = (row_mask, col_mask), (row_needs, col_needs) + if row_needs or col_needs: + if out is not None and out.dtype != dtype: + raise Exception('Incompatible type for fill_value') + else: + # if not, then depromote, set fill_value to dummy + # (it won't be used but we don't want the cython code + # to crash when trying to cast it to dtype) + dtype, fill_value = arr.dtype, arr.dtype.type() + + # at this point, it's guaranteed that dtype can hold both the arr values + # and the fill_value if out is None: out_shape = len(row_idx), len(col_idx) out = np.empty(out_shape, dtype=dtype) - take_f = _get_take_2d_function(arr.dtype, out.dtype, axis='multi') - take_f(arr, (row_idx, col_idx), out=out, fill_value=fill_value) - return out - -def ndtake(arr, indexer, axis=0, out=None): - return arr.take(_ensure_platform_int(indexer), axis=axis, out=out) + func = _take_2d_multi_dict.get((arr.dtype.name, out.dtype.name), None) + if func is None and arr.dtype != out.dtype: + func = _take_2d_multi_dict.get((out.dtype.name, out.dtype.name), None) + if func is not None: + func = _convert_wrapper(func, out.dtype) + if func is None: + def func(arr, indexer, out, fill_value=np.nan): + _take_2d_multi_generic(arr, indexer, out, + fill_value=fill_value, mask_info=mask_info) + func(arr, indexer, out=out, fill_value=fill_value) + return out _diff_special = { @@ -615,36 +636,6 @@ def diff(arr, n, axis=0): return out_arr -def take_fast(arr, indexer, mask, needs_masking, axis=0, out=None, - fill_value=np.nan): - """ - Specialized Cython take which sets NaN values in one pass - - (equivalent to take_nd but requires mask and needs_masking - to be set appropriately already; slightly more efficient) - """ - if indexer is None: - indexer = np.arange(arr.shape[axis], dtype=np.int64) - dtype = arr.dtype - else: - indexer = _ensure_int64(indexer) - if needs_masking: - dtype = _maybe_promote(arr.dtype, fill_value)[0] - if dtype != arr.dtype and out is not None and out.dtype != dtype: - raise Exception('Incompatible type for fill_value') - else: - dtype = arr.dtype - - if out is None: - out_shape = list(arr.shape) - out_shape[axis] = len(indexer) - out_shape = tuple(out_shape) - out = np.empty(out_shape, dtype=dtype) - take_f = _get_take_nd_function(arr.ndim, arr.dtype, out.dtype, axis=axis) - take_f(arr, indexer, out=out, fill_value=fill_value) - return out - - def _infer_dtype_from_scalar(val): """ interpret the dtype from a scalar, upcast floats and ints return the new value and the dtype """ @@ -689,6 +680,7 @@ def _infer_dtype_from_scalar(val): return dtype, val + def _maybe_promote(dtype, fill_value=np.nan): # returns tuple of (dtype, fill_value) if issubclass(dtype.type, np.datetime64): @@ -729,10 +721,10 @@ def _maybe_promote(dtype, fill_value=np.nan): dtype = np.object_ return dtype, fill_value + def _maybe_upcast(values, fill_value=np.nan, copy=False): """ provide explicty type promotion and coercion if copy == True, then a copy is created even if no upcast is required """ - new_dtype, fill_value = _maybe_promote(values.dtype, fill_value) if new_dtype != values.dtype: values = values.astype(new_dtype) @@ -740,6 +732,7 @@ def _maybe_upcast(values, fill_value=np.nan, copy=False): values = values.copy() return values, fill_value + def _possibly_cast_item(obj, item, dtype): chunk = obj[item] diff --git a/pandas/core/frame.py b/pandas/core/frame.py index ecd7d57a0e4d2..676c684f927f2 100644 --- a/pandas/core/frame.py +++ b/pandas/core/frame.py @@ -2644,8 +2644,9 @@ def _reindex_multi(self, new_index, new_columns, copy, fill_value): new_columns, col_indexer = self.columns.reindex(new_columns) if row_indexer is not None and col_indexer is not None: - new_values = com.take_2d_multi(self.values, row_indexer, - col_indexer, fill_value=fill_value) + indexer = row_indexer, col_indexer + new_values = com.take_2d_multi(self.values, indexer, + fill_value=fill_value) return DataFrame(new_values, index=new_index, columns=new_columns) elif row_indexer is not None: return self._reindex_with_indexers(new_index, row_indexer, diff --git a/pandas/core/groupby.py b/pandas/core/groupby.py index e89175ef72f43..fe7c281afb1b9 100644 --- a/pandas/core/groupby.py +++ b/pandas/core/groupby.py @@ -897,7 +897,7 @@ def _aggregate_series_fast(self, obj, func): dummy = obj[:0].copy() indexer = _algos.groupsort_indexer(group_index, ngroups)[0] obj = obj.take(indexer) - group_index = com.ndtake(group_index, indexer) + group_index = com.take_nd(group_index, indexer, allow_fill=False) grouper = lib.SeriesGrouper(obj, func, group_index, ngroups, dummy) result, counts = grouper.get_result() @@ -1686,7 +1686,9 @@ def aggregate(self, arg, *args, **kwargs): zipped = zip(result.index.levels, result.index.labels, result.index.names) for i, (lev, lab, name) in enumerate(zipped): - result.insert(i, name, com.ndtake(lev.values, lab)) + result.insert(i, name, + com.take_nd(lev.values, lab, + allow_fill=False)) result = result.consolidate() else: values = result.index.values @@ -2133,7 +2135,7 @@ def __init__(self, data, labels, ngroups, axis=0, keep_internal=False): @cache_readonly def slabels(self): # Sorted labels - return com.ndtake(self.labels, self.sort_idx) + return com.take_nd(self.labels, self.sort_idx, allow_fill=False) @cache_readonly def sort_idx(self): @@ -2411,11 +2413,11 @@ def _reorder_by_uniques(uniques, labels): mask = labels < 0 # move labels to right locations (ie, unsort ascending labels) - labels = com.ndtake(reverse_indexer, labels) + labels = com.take_nd(reverse_indexer, labels, allow_fill=False) np.putmask(labels, mask, -1) # sort observed ids - uniques = com.ndtake(uniques, sorter) + uniques = com.take_nd(uniques, sorter, allow_fill=False) return uniques, labels diff --git a/pandas/core/index.py b/pandas/core/index.py index bcd45a9fa9262..3a5f1d8147a99 100644 --- a/pandas/core/index.py +++ b/pandas/core/index.py @@ -12,7 +12,6 @@ import pandas.index as _index from pandas.lib import Timestamp -from pandas.core.common import ndtake from pandas.util.decorators import cache_readonly import pandas.core.common as com from pandas.util import py3compat @@ -608,7 +607,8 @@ def union(self, other): indexer = (indexer == -1).nonzero()[0] if len(indexer) > 0: - other_diff = ndtake(other.values, indexer) + other_diff = com.take_nd(other.values, indexer, + allow_fill=False) result = com._concat_compat((self.values, other_diff)) try: result.sort() @@ -1037,7 +1037,8 @@ def _join_level(self, other, level, how='left', return_indexers=False): rev_indexer = lib.get_reverse_indexer(left_lev_indexer, len(old_level)) - new_lev_labels = ndtake(rev_indexer, left.labels[level]) + new_lev_labels = com.take_nd(rev_indexer, left.labels[level], + allow_fill=False) omit_mask = new_lev_labels != -1 new_labels = list(left.labels) @@ -1057,8 +1058,9 @@ def _join_level(self, other, level, how='left', return_indexers=False): left_indexer = None if right_lev_indexer is not None: - right_indexer = ndtake(right_lev_indexer, - join_index.labels[level]) + right_indexer = com.take_nd(right_lev_indexer, + join_index.labels[level], + allow_fill=False) else: right_indexer = join_index.labels[level] @@ -2369,8 +2371,10 @@ def equals(self, other): return False for i in xrange(self.nlevels): - svalues = ndtake(self.levels[i].values, self.labels[i]) - ovalues = ndtake(other.levels[i].values, other.labels[i]) + svalues = com.take_nd(self.levels[i].values, self.labels[i], + allow_fill=False) + ovalues = com.take_nd(other.levels[i].values, other.labels[i], + allow_fill=False) if not np.array_equal(svalues, ovalues): return False diff --git a/pandas/core/internals.py b/pandas/core/internals.py index 56802c2cb3bae..cd7404532c431 100644 --- a/pandas/core/internals.py +++ b/pandas/core/internals.py @@ -120,14 +120,14 @@ def merge(self, other): # union_ref = self.ref_items + other.ref_items return _merge_blocks([self, other], self.ref_items) - def reindex_axis(self, indexer, mask, needs_masking, axis=0, - fill_value=np.nan): + def reindex_axis(self, indexer, axis=1, fill_value=np.nan, mask_info=None): """ Reindex using pre-computed indexer information """ - new_values = com.take_fast(self.values, indexer, - mask, needs_masking, axis=axis, - fill_value=fill_value) + if axis < 1: + raise AssertionError('axis must be at least 1, got %d' % axis) + new_values = com.take_nd(self.values, indexer, axis, + fill_value=fill_value, mask_info=mask_info) return make_block(new_values, self.items, self.ref_items) def reindex_items_from(self, new_ref_items, copy=True): @@ -146,12 +146,9 @@ def reindex_items_from(self, new_ref_items, copy=True): new_items = new_ref_items new_values = self.values.copy() if copy else self.values else: - mask = indexer != -1 - masked_idx = indexer[mask] - - new_values = com.take_fast(self.values, masked_idx, - mask=None, needs_masking=False, - axis=0) + masked_idx = indexer[indexer != -1] + new_values = com.take_nd(self.values, masked_idx, axis=0, + allow_fill=False) new_items = self.items.take(masked_idx) return make_block(new_values, new_items, new_ref_items) @@ -221,7 +218,10 @@ def fillna(self, value, inplace=False): return make_block(new_values, self.items, self.ref_items) def astype(self, dtype, copy = True, raise_on_error = True): - """ coerce to the new type (if copy=True, return a new copy) raise on an except if raise == True """ + """ + Coerce to the new type (if copy=True, return a new copy) + raise on an except if raise == True + """ try: newb = make_block(com._astype_nansafe(self.values, dtype, copy = copy), self.items, self.ref_items) @@ -231,12 +231,12 @@ def astype(self, dtype, copy = True, raise_on_error = True): newb = self.copy() if copy else self if newb.is_numeric and self.is_numeric: - if newb.shape != self.shape or (not copy and newb.itemsize < self.itemsize): - raise TypeError("cannot set astype for copy = [%s] for dtype (%s [%s]) with smaller itemsize that current (%s [%s])" % (copy, - self.dtype.name, - self.itemsize, - newb.dtype.name, - newb.itemsize)) + if (newb.shape != self.shape or + (not copy and newb.itemsize < self.itemsize)): + raise TypeError("cannot set astype for copy = [%s] for dtype " + "(%s [%s]) with smaller itemsize that current " + "(%s [%s])" % (copy, self.dtype.name, + self.itemsize, newb.dtype.name, newb.itemsize)) return newb def convert(self, copy = True, **kwargs): @@ -356,11 +356,11 @@ def interpolate(self, method='pad', axis=0, inplace=False, return make_block(values, self.items, self.ref_items) - def take(self, indexer, axis=1, fill_value=np.nan): + def take(self, indexer, axis=1): if axis < 1: raise AssertionError('axis must be at least 1, got %d' % axis) - new_values = com.take_fast(self.values, indexer, None, False, - axis=axis, fill_value=fill_value) + new_values = com.take_nd(self.values, indexer, axis=axis, + allow_fill=False) return make_block(new_values, self.items, self.ref_items) def get_values(self, dtype): @@ -1320,15 +1320,9 @@ def reindex_indexer(self, new_axis, indexer, axis=1, fill_value=np.nan): if axis == 0: return self._reindex_indexer_items(new_axis, indexer, fill_value) - mask = indexer == -1 - - # TODO: deal with length-0 case? or does it fall out? - needs_masking = len(new_axis) > 0 and mask.any() - new_blocks = [] for block in self.blocks: - newb = block.reindex_axis(indexer, mask, needs_masking, - axis=axis, fill_value=fill_value) + newb = block.reindex_axis(indexer, axis=axis, fill_value=fill_value) new_blocks.append(newb) new_axes = list(self.axes) @@ -1354,8 +1348,8 @@ def _reindex_indexer_items(self, new_items, indexer, fill_value): continue new_block_items = new_items.take(selector.nonzero()[0]) - new_values = com.take_fast(blk.values, blk_indexer[selector], - None, False, axis=0) + new_values = com.take_nd(blk.values, blk_indexer[selector], axis=0, + allow_fill=False) new_blocks.append(make_block(new_values, new_block_items, new_items)) @@ -1419,8 +1413,8 @@ def _make_na_block(self, items, ref_items, fill_value=np.nan): return na_block def take(self, indexer, axis=1): - if axis == 0: - raise NotImplementedError + if axis < 1: + raise AssertionError('axis must be at least 1, got %d' % axis) indexer = com._ensure_platform_int(indexer) @@ -1433,8 +1427,8 @@ def take(self, indexer, axis=1): new_axes[axis] = self.axes[axis].take(indexer) new_blocks = [] for blk in self.blocks: - new_values = com.take_fast(blk.values, indexer, None, False, - axis=axis) + new_values = com.take_nd(blk.values, indexer, axis=axis, + allow_fill=False) newb = make_block(new_values, blk.items, self.items) new_blocks.append(newb) diff --git a/pandas/core/panel.py b/pandas/core/panel.py index 6e52193a2c025..b418995ce3085 100644 --- a/pandas/core/panel.py +++ b/pandas/core/panel.py @@ -838,7 +838,7 @@ def _reindex_multi(self, items, major, minor): indexer2 = range(len(new_minor)) for i, ind in enumerate(indexer0): - com.take_2d_multi(values[ind], indexer1, indexer2, + com.take_2d_multi(values[ind], (indexer1, indexer2), out=new_values[i]) return Panel(new_values, items=new_items, major_axis=new_major, diff --git a/pandas/src/generate_code.py b/pandas/src/generate_code.py index c68154b27f7d1..c94ed8730f32a 100644 --- a/pandas/src/generate_code.py +++ b/pandas/src/generate_code.py @@ -5,6 +5,8 @@ cimport numpy as np cimport cython +from libc.string cimport memmove + from numpy cimport * from cpython cimport (PyDict_New, PyDict_GetItem, PyDict_SetItem, @@ -62,21 +64,13 @@ def take_1d_%(name)s_%(dest)s(ndarray[%(c_type_in)s] values, n = len(indexer) - if %(raise_on_na)s and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i] = %(preval)svalues[idx]%(postval)s - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - outbuf[i] = fv - else: - outbuf[i] = %(preval)svalues[idx]%(postval)s + fv = fill_value + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + outbuf[i] = fv + else: + outbuf[i] = %(preval)svalues[idx]%(postval)s """ @@ -93,25 +87,32 @@ def take_2d_axis0_%(name)s_%(dest)s(ndarray[%(c_type_in)s, ndim=2] values, n = len(indexer) k = values.shape[1] - if %(raise_on_na)s and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - outbuf[i, j] = %(preval)svalues[idx, j]%(postval)s - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - outbuf[i, j] = fv - else: - for j from 0 <= j < k: - outbuf[i, j] = %(preval)svalues[idx, j]%(postval)s + fv = fill_value + + IF %(can_copy)s: + cdef: + %(c_type_out)s *v, *o + + if values.flags.c_contiguous and out.flags.c_contiguous: + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + v = &values[idx, 0] + o = &outbuf[i, 0] + memmove(o, v, (sizeof(%(c_type_out)s) * k)) + return + + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + outbuf[i, j] = %(preval)svalues[idx, j]%(postval)s """ @@ -127,26 +128,33 @@ def take_2d_axis1_%(name)s_%(dest)s(ndarray[%(c_type_in)s, ndim=2] values, n = len(values) k = len(indexer) + + fv = fill_value + + IF %(can_copy)s: + cdef: + %(c_type_out)s *v, *o + + if values.flags.f_contiguous and out.flags.f_contiguous: + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + v = &values[0, idx] + o = &outbuf[0, j] + memmove(o, v, (sizeof(%(c_type_out)s) * n)) + return - if %(raise_on_na)s and _checknan(fill_value): - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - raise ValueError('No NA values allowed') - else: - for i from 0 <= i < n: - outbuf[i, j] = %(preval)svalues[i, idx]%(postval)s - else: - fv = fill_value - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - outbuf[i, j] = fv - else: - for i from 0 <= i < n: - outbuf[i, j] = %(preval)svalues[i, idx]%(postval)s + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + for i from 0 <= i < n: + outbuf[i, j] = %(preval)svalues[i, idx]%(postval)s """ @@ -165,31 +173,18 @@ def take_2d_multi_%(name)s_%(dest)s(ndarray[%(c_type_in)s, ndim=2] values, n = len(idx0) k = len(idx1) - if %(raise_on_na)s and _checknan(fill_value): - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - if idx1[j] == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i, j] = %(preval)svalues[idx, idx1[j]]%(postval)s - else: - fv = fill_value - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: + fv = fill_value + for i from 0 <= i < n: + idx = idx0[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + if idx1[j] == -1: outbuf[i, j] = fv - else: - for j from 0 <= j < k: - if idx1[j] == -1: - outbuf[i, j] = fv - else: - outbuf[i, j] = %(preval)svalues[idx, idx1[j]]%(postval)s + else: + outbuf[i, j] = %(preval)svalues[idx, idx1[j]]%(postval)s """ @@ -2156,40 +2151,40 @@ def generate_put_template(template, use_ints = True, use_floats = True): return output.getvalue() def generate_take_template(template, exclude=None): - # name, dest, ctypein, ctypeout, preval, postval, capable of holding NA + # name, dest, ctypein, ctypeout, preval, postval, cancopy function_list = [ - ('bool', 'bool', 'uint8_t', 'uint8_t', '', '', False), + ('bool', 'bool', 'uint8_t', 'uint8_t', '', '', True), ('bool', 'object', 'uint8_t', 'object', - 'True if ', ' > 0 else False', True), - ('int8', 'int8', 'int8_t', 'int8_t', '', '', False), + 'True if ', ' > 0 else False', False), + ('int8', 'int8', 'int8_t', 'int8_t', '', '', True), ('int8', 'int32', 'int8_t', 'int32_t', '', '', False), ('int8', 'int64', 'int8_t', 'int64_t', '', '', False), - ('int8', 'float64', 'int8_t', 'float64_t', '', '', True), - ('int16', 'int16', 'int16_t', 'int16_t', '', '', False), + ('int8', 'float64', 'int8_t', 'float64_t', '', '', False), + ('int16', 'int16', 'int16_t', 'int16_t', '', '', True), ('int16', 'int32', 'int16_t', 'int32_t', '', '', False), ('int16', 'int64', 'int16_t', 'int64_t', '', '', False), - ('int16', 'float64', 'int16_t', 'float64_t', '', '', True), - ('int32', 'int32', 'int32_t', 'int32_t', '', '', False), + ('int16', 'float64', 'int16_t', 'float64_t', '', '', False), + ('int32', 'int32', 'int32_t', 'int32_t', '', '', True), ('int32', 'int64', 'int32_t', 'int64_t', '', '', False), - ('int32', 'float64', 'int32_t', 'float64_t', '', '', True), - ('int64', 'int64', 'int64_t', 'int64_t', '', '', False), - ('int64', 'float64', 'int64_t', 'float64_t', '', '', True), + ('int32', 'float64', 'int32_t', 'float64_t', '', '', False), + ('int64', 'int64', 'int64_t', 'int64_t', '', '', True), + ('int64', 'float64', 'int64_t', 'float64_t', '', '', False), ('float32', 'float32', 'float32_t', 'float32_t', '', '', True), - ('float32', 'float64', 'float32_t', 'float64_t', '', '', True), + ('float32', 'float64', 'float32_t', 'float64_t', '', '', False), ('float64', 'float64', 'float64_t', 'float64_t', '', '', True), - ('object', 'object', 'object', 'object', '', '', True) + ('object', 'object', 'object', 'object', '', '', False) ] output = StringIO() for (name, dest, c_type_in, c_type_out, - preval, postval, can_hold_na) in function_list: + preval, postval, can_copy) in function_list: if exclude is not None and name in exclude: continue func = template % {'name': name, 'dest': dest, 'c_type_in': c_type_in, 'c_type_out': c_type_out, 'preval': preval, 'postval': postval, - 'raise_on_na': 'False' if can_hold_na else 'True'} + 'can_copy': 'True' if can_copy else 'False'} output.write(func) return output.getvalue() diff --git a/pandas/src/generated.pyx b/pandas/src/generated.pyx index 1723f2fb8b34c..ce83e08782ea2 100644 --- a/pandas/src/generated.pyx +++ b/pandas/src/generated.pyx @@ -2,6 +2,8 @@ cimport numpy as np cimport cython +from libc.string cimport memmove + from numpy cimport * from cpython cimport (PyDict_New, PyDict_GetItem, PyDict_SetItem, @@ -2208,21 +2210,13 @@ def take_1d_bool_bool(ndarray[uint8_t] values, n = len(indexer) - if True and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i] = values[idx] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - outbuf[i] = fv - else: - outbuf[i] = values[idx] + fv = fill_value + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + outbuf[i] = fv + else: + outbuf[i] = values[idx] @cython.wraparound(False) def take_1d_bool_object(ndarray[uint8_t] values, @@ -2235,21 +2229,13 @@ def take_1d_bool_object(ndarray[uint8_t] values, n = len(indexer) - if False and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i] = True if values[idx] > 0 else False - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - outbuf[i] = fv - else: - outbuf[i] = True if values[idx] > 0 else False + fv = fill_value + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + outbuf[i] = fv + else: + outbuf[i] = True if values[idx] > 0 else False @cython.wraparound(False) def take_1d_int8_int8(ndarray[int8_t] values, @@ -2262,21 +2248,13 @@ def take_1d_int8_int8(ndarray[int8_t] values, n = len(indexer) - if True and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i] = values[idx] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - outbuf[i] = fv - else: - outbuf[i] = values[idx] + fv = fill_value + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + outbuf[i] = fv + else: + outbuf[i] = values[idx] @cython.wraparound(False) def take_1d_int8_int32(ndarray[int8_t] values, @@ -2289,21 +2267,13 @@ def take_1d_int8_int32(ndarray[int8_t] values, n = len(indexer) - if True and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i] = values[idx] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - outbuf[i] = fv - else: - outbuf[i] = values[idx] + fv = fill_value + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + outbuf[i] = fv + else: + outbuf[i] = values[idx] @cython.wraparound(False) def take_1d_int8_int64(ndarray[int8_t] values, @@ -2316,21 +2286,13 @@ def take_1d_int8_int64(ndarray[int8_t] values, n = len(indexer) - if True and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i] = values[idx] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - outbuf[i] = fv - else: - outbuf[i] = values[idx] + fv = fill_value + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + outbuf[i] = fv + else: + outbuf[i] = values[idx] @cython.wraparound(False) def take_1d_int8_float64(ndarray[int8_t] values, @@ -2343,21 +2305,13 @@ def take_1d_int8_float64(ndarray[int8_t] values, n = len(indexer) - if False and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i] = values[idx] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - outbuf[i] = fv - else: - outbuf[i] = values[idx] + fv = fill_value + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + outbuf[i] = fv + else: + outbuf[i] = values[idx] @cython.wraparound(False) def take_1d_int16_int16(ndarray[int16_t] values, @@ -2370,21 +2324,13 @@ def take_1d_int16_int16(ndarray[int16_t] values, n = len(indexer) - if True and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i] = values[idx] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - outbuf[i] = fv - else: - outbuf[i] = values[idx] + fv = fill_value + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + outbuf[i] = fv + else: + outbuf[i] = values[idx] @cython.wraparound(False) def take_1d_int16_int32(ndarray[int16_t] values, @@ -2397,21 +2343,13 @@ def take_1d_int16_int32(ndarray[int16_t] values, n = len(indexer) - if True and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i] = values[idx] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - outbuf[i] = fv - else: - outbuf[i] = values[idx] + fv = fill_value + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + outbuf[i] = fv + else: + outbuf[i] = values[idx] @cython.wraparound(False) def take_1d_int16_int64(ndarray[int16_t] values, @@ -2424,21 +2362,13 @@ def take_1d_int16_int64(ndarray[int16_t] values, n = len(indexer) - if True and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i] = values[idx] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - outbuf[i] = fv - else: - outbuf[i] = values[idx] + fv = fill_value + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + outbuf[i] = fv + else: + outbuf[i] = values[idx] @cython.wraparound(False) def take_1d_int16_float64(ndarray[int16_t] values, @@ -2451,21 +2381,13 @@ def take_1d_int16_float64(ndarray[int16_t] values, n = len(indexer) - if False and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i] = values[idx] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - outbuf[i] = fv - else: - outbuf[i] = values[idx] + fv = fill_value + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + outbuf[i] = fv + else: + outbuf[i] = values[idx] @cython.wraparound(False) def take_1d_int32_int32(ndarray[int32_t] values, @@ -2478,21 +2400,13 @@ def take_1d_int32_int32(ndarray[int32_t] values, n = len(indexer) - if True and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i] = values[idx] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - outbuf[i] = fv - else: - outbuf[i] = values[idx] + fv = fill_value + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + outbuf[i] = fv + else: + outbuf[i] = values[idx] @cython.wraparound(False) def take_1d_int32_int64(ndarray[int32_t] values, @@ -2505,21 +2419,13 @@ def take_1d_int32_int64(ndarray[int32_t] values, n = len(indexer) - if True and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i] = values[idx] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - outbuf[i] = fv - else: - outbuf[i] = values[idx] + fv = fill_value + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + outbuf[i] = fv + else: + outbuf[i] = values[idx] @cython.wraparound(False) def take_1d_int32_float64(ndarray[int32_t] values, @@ -2532,21 +2438,13 @@ def take_1d_int32_float64(ndarray[int32_t] values, n = len(indexer) - if False and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i] = values[idx] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - outbuf[i] = fv - else: - outbuf[i] = values[idx] + fv = fill_value + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + outbuf[i] = fv + else: + outbuf[i] = values[idx] @cython.wraparound(False) def take_1d_int64_int64(ndarray[int64_t] values, @@ -2559,21 +2457,13 @@ def take_1d_int64_int64(ndarray[int64_t] values, n = len(indexer) - if True and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i] = values[idx] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - outbuf[i] = fv - else: - outbuf[i] = values[idx] + fv = fill_value + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + outbuf[i] = fv + else: + outbuf[i] = values[idx] @cython.wraparound(False) def take_1d_int64_float64(ndarray[int64_t] values, @@ -2586,21 +2476,13 @@ def take_1d_int64_float64(ndarray[int64_t] values, n = len(indexer) - if False and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i] = values[idx] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - outbuf[i] = fv - else: - outbuf[i] = values[idx] + fv = fill_value + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + outbuf[i] = fv + else: + outbuf[i] = values[idx] @cython.wraparound(False) def take_1d_float32_float32(ndarray[float32_t] values, @@ -2613,21 +2495,13 @@ def take_1d_float32_float32(ndarray[float32_t] values, n = len(indexer) - if False and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i] = values[idx] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - outbuf[i] = fv - else: - outbuf[i] = values[idx] + fv = fill_value + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + outbuf[i] = fv + else: + outbuf[i] = values[idx] @cython.wraparound(False) def take_1d_float32_float64(ndarray[float32_t] values, @@ -2640,21 +2514,13 @@ def take_1d_float32_float64(ndarray[float32_t] values, n = len(indexer) - if False and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i] = values[idx] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - outbuf[i] = fv - else: - outbuf[i] = values[idx] + fv = fill_value + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + outbuf[i] = fv + else: + outbuf[i] = values[idx] @cython.wraparound(False) def take_1d_float64_float64(ndarray[float64_t] values, @@ -2667,21 +2533,13 @@ def take_1d_float64_float64(ndarray[float64_t] values, n = len(indexer) - if False and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i] = values[idx] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - outbuf[i] = fv - else: - outbuf[i] = values[idx] + fv = fill_value + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + outbuf[i] = fv + else: + outbuf[i] = values[idx] @cython.wraparound(False) def take_1d_object_object(ndarray[object] values, @@ -2694,21 +2552,13 @@ def take_1d_object_object(ndarray[object] values, n = len(indexer) - if False and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i] = values[idx] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - outbuf[i] = fv - else: - outbuf[i] = values[idx] + fv = fill_value + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + outbuf[i] = fv + else: + outbuf[i] = values[idx] @cython.wraparound(False) @@ -2724,25 +2574,32 @@ def take_2d_axis0_bool_bool(ndarray[uint8_t, ndim=2] values, n = len(indexer) k = values.shape[1] - if True and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - outbuf[i, j] = fv - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] + fv = fill_value + + IF True: + cdef: + uint8_t *v, *o + + if values.flags.c_contiguous and out.flags.c_contiguous: + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + v = &values[idx, 0] + o = &outbuf[i, 0] + memmove(o, v, (sizeof(uint8_t) * k)) + return + + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + outbuf[i, j] = values[idx, j] @cython.wraparound(False) @cython.boundscheck(False) @@ -2757,25 +2614,32 @@ def take_2d_axis0_bool_object(ndarray[uint8_t, ndim=2] values, n = len(indexer) k = values.shape[1] - if False and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - outbuf[i, j] = True if values[idx, j] > 0 else False - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - outbuf[i, j] = fv - else: - for j from 0 <= j < k: - outbuf[i, j] = True if values[idx, j] > 0 else False + fv = fill_value + + IF False: + cdef: + object *v, *o + + if values.flags.c_contiguous and out.flags.c_contiguous: + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + v = &values[idx, 0] + o = &outbuf[i, 0] + memmove(o, v, (sizeof(object) * k)) + return + + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + outbuf[i, j] = True if values[idx, j] > 0 else False @cython.wraparound(False) @cython.boundscheck(False) @@ -2790,25 +2654,32 @@ def take_2d_axis0_int8_int8(ndarray[int8_t, ndim=2] values, n = len(indexer) k = values.shape[1] - if True and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - outbuf[i, j] = fv - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] + fv = fill_value + + IF True: + cdef: + int8_t *v, *o + + if values.flags.c_contiguous and out.flags.c_contiguous: + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + v = &values[idx, 0] + o = &outbuf[i, 0] + memmove(o, v, (sizeof(int8_t) * k)) + return + + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + outbuf[i, j] = values[idx, j] @cython.wraparound(False) @cython.boundscheck(False) @@ -2823,25 +2694,32 @@ def take_2d_axis0_int8_int32(ndarray[int8_t, ndim=2] values, n = len(indexer) k = values.shape[1] - if True and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - outbuf[i, j] = fv - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] + fv = fill_value + + IF False: + cdef: + int32_t *v, *o + + if values.flags.c_contiguous and out.flags.c_contiguous: + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + v = &values[idx, 0] + o = &outbuf[i, 0] + memmove(o, v, (sizeof(int32_t) * k)) + return + + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + outbuf[i, j] = values[idx, j] @cython.wraparound(False) @cython.boundscheck(False) @@ -2856,25 +2734,32 @@ def take_2d_axis0_int8_int64(ndarray[int8_t, ndim=2] values, n = len(indexer) k = values.shape[1] - if True and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - outbuf[i, j] = fv - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] + fv = fill_value + + IF False: + cdef: + int64_t *v, *o + + if values.flags.c_contiguous and out.flags.c_contiguous: + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + v = &values[idx, 0] + o = &outbuf[i, 0] + memmove(o, v, (sizeof(int64_t) * k)) + return + + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + outbuf[i, j] = values[idx, j] @cython.wraparound(False) @cython.boundscheck(False) @@ -2889,25 +2774,32 @@ def take_2d_axis0_int8_float64(ndarray[int8_t, ndim=2] values, n = len(indexer) k = values.shape[1] - if False and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - outbuf[i, j] = fv - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] + fv = fill_value + + IF False: + cdef: + float64_t *v, *o + + if values.flags.c_contiguous and out.flags.c_contiguous: + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + v = &values[idx, 0] + o = &outbuf[i, 0] + memmove(o, v, (sizeof(float64_t) * k)) + return + + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + outbuf[i, j] = values[idx, j] @cython.wraparound(False) @cython.boundscheck(False) @@ -2922,25 +2814,32 @@ def take_2d_axis0_int16_int16(ndarray[int16_t, ndim=2] values, n = len(indexer) k = values.shape[1] - if True and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - outbuf[i, j] = fv - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] + fv = fill_value + + IF True: + cdef: + int16_t *v, *o + + if values.flags.c_contiguous and out.flags.c_contiguous: + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + v = &values[idx, 0] + o = &outbuf[i, 0] + memmove(o, v, (sizeof(int16_t) * k)) + return + + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + outbuf[i, j] = values[idx, j] @cython.wraparound(False) @cython.boundscheck(False) @@ -2955,25 +2854,32 @@ def take_2d_axis0_int16_int32(ndarray[int16_t, ndim=2] values, n = len(indexer) k = values.shape[1] - if True and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - outbuf[i, j] = fv - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] + fv = fill_value + + IF False: + cdef: + int32_t *v, *o + + if values.flags.c_contiguous and out.flags.c_contiguous: + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + v = &values[idx, 0] + o = &outbuf[i, 0] + memmove(o, v, (sizeof(int32_t) * k)) + return + + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + outbuf[i, j] = values[idx, j] @cython.wraparound(False) @cython.boundscheck(False) @@ -2988,25 +2894,32 @@ def take_2d_axis0_int16_int64(ndarray[int16_t, ndim=2] values, n = len(indexer) k = values.shape[1] - if True and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - outbuf[i, j] = fv - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] + fv = fill_value + + IF False: + cdef: + int64_t *v, *o + + if values.flags.c_contiguous and out.flags.c_contiguous: + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + v = &values[idx, 0] + o = &outbuf[i, 0] + memmove(o, v, (sizeof(int64_t) * k)) + return + + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + outbuf[i, j] = values[idx, j] @cython.wraparound(False) @cython.boundscheck(False) @@ -3021,25 +2934,32 @@ def take_2d_axis0_int16_float64(ndarray[int16_t, ndim=2] values, n = len(indexer) k = values.shape[1] - if False and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - outbuf[i, j] = fv - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] + fv = fill_value + + IF False: + cdef: + float64_t *v, *o + + if values.flags.c_contiguous and out.flags.c_contiguous: + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + v = &values[idx, 0] + o = &outbuf[i, 0] + memmove(o, v, (sizeof(float64_t) * k)) + return + + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + outbuf[i, j] = values[idx, j] @cython.wraparound(False) @cython.boundscheck(False) @@ -3054,25 +2974,32 @@ def take_2d_axis0_int32_int32(ndarray[int32_t, ndim=2] values, n = len(indexer) k = values.shape[1] - if True and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - outbuf[i, j] = fv - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] + fv = fill_value + + IF True: + cdef: + int32_t *v, *o + + if values.flags.c_contiguous and out.flags.c_contiguous: + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + v = &values[idx, 0] + o = &outbuf[i, 0] + memmove(o, v, (sizeof(int32_t) * k)) + return + + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + outbuf[i, j] = values[idx, j] @cython.wraparound(False) @cython.boundscheck(False) @@ -3087,25 +3014,32 @@ def take_2d_axis0_int32_int64(ndarray[int32_t, ndim=2] values, n = len(indexer) k = values.shape[1] - if True and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - outbuf[i, j] = fv - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] + fv = fill_value + + IF False: + cdef: + int64_t *v, *o + + if values.flags.c_contiguous and out.flags.c_contiguous: + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + v = &values[idx, 0] + o = &outbuf[i, 0] + memmove(o, v, (sizeof(int64_t) * k)) + return + + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + outbuf[i, j] = values[idx, j] @cython.wraparound(False) @cython.boundscheck(False) @@ -3120,25 +3054,32 @@ def take_2d_axis0_int32_float64(ndarray[int32_t, ndim=2] values, n = len(indexer) k = values.shape[1] - if False and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - outbuf[i, j] = fv - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] + fv = fill_value + + IF False: + cdef: + float64_t *v, *o + + if values.flags.c_contiguous and out.flags.c_contiguous: + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + v = &values[idx, 0] + o = &outbuf[i, 0] + memmove(o, v, (sizeof(float64_t) * k)) + return + + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + outbuf[i, j] = values[idx, j] @cython.wraparound(False) @cython.boundscheck(False) @@ -3153,25 +3094,32 @@ def take_2d_axis0_int64_int64(ndarray[int64_t, ndim=2] values, n = len(indexer) k = values.shape[1] - if True and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - outbuf[i, j] = fv - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] + fv = fill_value + + IF True: + cdef: + int64_t *v, *o + + if values.flags.c_contiguous and out.flags.c_contiguous: + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + v = &values[idx, 0] + o = &outbuf[i, 0] + memmove(o, v, (sizeof(int64_t) * k)) + return + + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + outbuf[i, j] = values[idx, j] @cython.wraparound(False) @cython.boundscheck(False) @@ -3186,25 +3134,32 @@ def take_2d_axis0_int64_float64(ndarray[int64_t, ndim=2] values, n = len(indexer) k = values.shape[1] - if False and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - outbuf[i, j] = fv - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] + fv = fill_value + + IF False: + cdef: + float64_t *v, *o + + if values.flags.c_contiguous and out.flags.c_contiguous: + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + v = &values[idx, 0] + o = &outbuf[i, 0] + memmove(o, v, (sizeof(float64_t) * k)) + return + + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + outbuf[i, j] = values[idx, j] @cython.wraparound(False) @cython.boundscheck(False) @@ -3219,25 +3174,32 @@ def take_2d_axis0_float32_float32(ndarray[float32_t, ndim=2] values, n = len(indexer) k = values.shape[1] - if False and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - outbuf[i, j] = fv - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] + fv = fill_value + + IF True: + cdef: + float32_t *v, *o + + if values.flags.c_contiguous and out.flags.c_contiguous: + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + v = &values[idx, 0] + o = &outbuf[i, 0] + memmove(o, v, (sizeof(float32_t) * k)) + return + + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + outbuf[i, j] = values[idx, j] @cython.wraparound(False) @cython.boundscheck(False) @@ -3252,25 +3214,32 @@ def take_2d_axis0_float32_float64(ndarray[float32_t, ndim=2] values, n = len(indexer) k = values.shape[1] - if False and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - outbuf[i, j] = fv - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] + fv = fill_value + + IF False: + cdef: + float64_t *v, *o + + if values.flags.c_contiguous and out.flags.c_contiguous: + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + v = &values[idx, 0] + o = &outbuf[i, 0] + memmove(o, v, (sizeof(float64_t) * k)) + return + + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + outbuf[i, j] = values[idx, j] @cython.wraparound(False) @cython.boundscheck(False) @@ -3285,25 +3254,32 @@ def take_2d_axis0_float64_float64(ndarray[float64_t, ndim=2] values, n = len(indexer) k = values.shape[1] - if False and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - outbuf[i, j] = fv - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] + fv = fill_value + + IF True: + cdef: + float64_t *v, *o + + if values.flags.c_contiguous and out.flags.c_contiguous: + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + v = &values[idx, 0] + o = &outbuf[i, 0] + memmove(o, v, (sizeof(float64_t) * k)) + return + + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + outbuf[i, j] = values[idx, j] @cython.wraparound(False) @cython.boundscheck(False) @@ -3318,25 +3294,32 @@ def take_2d_axis0_object_object(ndarray[object, ndim=2] values, n = len(indexer) k = values.shape[1] - if False and _checknan(fill_value): - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] - else: - fv = fill_value - for i from 0 <= i < n: - idx = indexer[i] - if idx == -1: - for j from 0 <= j < k: - outbuf[i, j] = fv - else: - for j from 0 <= j < k: - outbuf[i, j] = values[idx, j] + fv = fill_value + + IF False: + cdef: + object *v, *o + + if values.flags.c_contiguous and out.flags.c_contiguous: + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + v = &values[idx, 0] + o = &outbuf[i, 0] + memmove(o, v, (sizeof(object) * k)) + return + + for i from 0 <= i < n: + idx = indexer[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + outbuf[i, j] = values[idx, j] @cython.wraparound(False) @@ -3351,26 +3334,33 @@ def take_2d_axis1_bool_bool(ndarray[uint8_t, ndim=2] values, n = len(values) k = len(indexer) - - if True and _checknan(fill_value): - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - raise ValueError('No NA values allowed') - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] - else: - fv = fill_value - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - outbuf[i, j] = fv - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] + + fv = fill_value + + IF True: + cdef: + uint8_t *v, *o + + if values.flags.f_contiguous and out.flags.f_contiguous: + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + v = &values[0, idx] + o = &outbuf[0, j] + memmove(o, v, (sizeof(uint8_t) * n)) + return + + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + for i from 0 <= i < n: + outbuf[i, j] = values[i, idx] @cython.wraparound(False) @cython.boundscheck(False) @@ -3384,26 +3374,33 @@ def take_2d_axis1_bool_object(ndarray[uint8_t, ndim=2] values, n = len(values) k = len(indexer) - - if False and _checknan(fill_value): - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - raise ValueError('No NA values allowed') - else: - for i from 0 <= i < n: - outbuf[i, j] = True if values[i, idx] > 0 else False - else: - fv = fill_value - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - outbuf[i, j] = fv - else: - for i from 0 <= i < n: - outbuf[i, j] = True if values[i, idx] > 0 else False + + fv = fill_value + + IF False: + cdef: + object *v, *o + + if values.flags.f_contiguous and out.flags.f_contiguous: + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + v = &values[0, idx] + o = &outbuf[0, j] + memmove(o, v, (sizeof(object) * n)) + return + + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + for i from 0 <= i < n: + outbuf[i, j] = True if values[i, idx] > 0 else False @cython.wraparound(False) @cython.boundscheck(False) @@ -3417,26 +3414,33 @@ def take_2d_axis1_int8_int8(ndarray[int8_t, ndim=2] values, n = len(values) k = len(indexer) - - if True and _checknan(fill_value): - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - raise ValueError('No NA values allowed') - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] - else: - fv = fill_value - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - outbuf[i, j] = fv - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] + + fv = fill_value + + IF True: + cdef: + int8_t *v, *o + + if values.flags.f_contiguous and out.flags.f_contiguous: + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + v = &values[0, idx] + o = &outbuf[0, j] + memmove(o, v, (sizeof(int8_t) * n)) + return + + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + for i from 0 <= i < n: + outbuf[i, j] = values[i, idx] @cython.wraparound(False) @cython.boundscheck(False) @@ -3450,26 +3454,33 @@ def take_2d_axis1_int8_int32(ndarray[int8_t, ndim=2] values, n = len(values) k = len(indexer) - - if True and _checknan(fill_value): - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - raise ValueError('No NA values allowed') - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] - else: - fv = fill_value - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - outbuf[i, j] = fv - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] + + fv = fill_value + + IF False: + cdef: + int32_t *v, *o + + if values.flags.f_contiguous and out.flags.f_contiguous: + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + v = &values[0, idx] + o = &outbuf[0, j] + memmove(o, v, (sizeof(int32_t) * n)) + return + + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + for i from 0 <= i < n: + outbuf[i, j] = values[i, idx] @cython.wraparound(False) @cython.boundscheck(False) @@ -3483,26 +3494,33 @@ def take_2d_axis1_int8_int64(ndarray[int8_t, ndim=2] values, n = len(values) k = len(indexer) - - if True and _checknan(fill_value): - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - raise ValueError('No NA values allowed') - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] - else: - fv = fill_value - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - outbuf[i, j] = fv - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] + + fv = fill_value + + IF False: + cdef: + int64_t *v, *o + + if values.flags.f_contiguous and out.flags.f_contiguous: + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + v = &values[0, idx] + o = &outbuf[0, j] + memmove(o, v, (sizeof(int64_t) * n)) + return + + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + for i from 0 <= i < n: + outbuf[i, j] = values[i, idx] @cython.wraparound(False) @cython.boundscheck(False) @@ -3516,26 +3534,33 @@ def take_2d_axis1_int8_float64(ndarray[int8_t, ndim=2] values, n = len(values) k = len(indexer) - - if False and _checknan(fill_value): - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - raise ValueError('No NA values allowed') - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] - else: - fv = fill_value - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - outbuf[i, j] = fv - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] + + fv = fill_value + + IF False: + cdef: + float64_t *v, *o + + if values.flags.f_contiguous and out.flags.f_contiguous: + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + v = &values[0, idx] + o = &outbuf[0, j] + memmove(o, v, (sizeof(float64_t) * n)) + return + + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + for i from 0 <= i < n: + outbuf[i, j] = values[i, idx] @cython.wraparound(False) @cython.boundscheck(False) @@ -3549,26 +3574,33 @@ def take_2d_axis1_int16_int16(ndarray[int16_t, ndim=2] values, n = len(values) k = len(indexer) - - if True and _checknan(fill_value): - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - raise ValueError('No NA values allowed') - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] - else: - fv = fill_value - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - outbuf[i, j] = fv - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] + + fv = fill_value + + IF True: + cdef: + int16_t *v, *o + + if values.flags.f_contiguous and out.flags.f_contiguous: + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + v = &values[0, idx] + o = &outbuf[0, j] + memmove(o, v, (sizeof(int16_t) * n)) + return + + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + for i from 0 <= i < n: + outbuf[i, j] = values[i, idx] @cython.wraparound(False) @cython.boundscheck(False) @@ -3582,26 +3614,33 @@ def take_2d_axis1_int16_int32(ndarray[int16_t, ndim=2] values, n = len(values) k = len(indexer) - - if True and _checknan(fill_value): - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - raise ValueError('No NA values allowed') - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] - else: - fv = fill_value - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - outbuf[i, j] = fv - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] + + fv = fill_value + + IF False: + cdef: + int32_t *v, *o + + if values.flags.f_contiguous and out.flags.f_contiguous: + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + v = &values[0, idx] + o = &outbuf[0, j] + memmove(o, v, (sizeof(int32_t) * n)) + return + + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + for i from 0 <= i < n: + outbuf[i, j] = values[i, idx] @cython.wraparound(False) @cython.boundscheck(False) @@ -3615,26 +3654,33 @@ def take_2d_axis1_int16_int64(ndarray[int16_t, ndim=2] values, n = len(values) k = len(indexer) - - if True and _checknan(fill_value): - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - raise ValueError('No NA values allowed') - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] - else: - fv = fill_value - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - outbuf[i, j] = fv - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] + + fv = fill_value + + IF False: + cdef: + int64_t *v, *o + + if values.flags.f_contiguous and out.flags.f_contiguous: + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + v = &values[0, idx] + o = &outbuf[0, j] + memmove(o, v, (sizeof(int64_t) * n)) + return + + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + for i from 0 <= i < n: + outbuf[i, j] = values[i, idx] @cython.wraparound(False) @cython.boundscheck(False) @@ -3648,26 +3694,33 @@ def take_2d_axis1_int16_float64(ndarray[int16_t, ndim=2] values, n = len(values) k = len(indexer) - - if False and _checknan(fill_value): - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - raise ValueError('No NA values allowed') - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] - else: - fv = fill_value - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - outbuf[i, j] = fv - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] + + fv = fill_value + + IF False: + cdef: + float64_t *v, *o + + if values.flags.f_contiguous and out.flags.f_contiguous: + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + v = &values[0, idx] + o = &outbuf[0, j] + memmove(o, v, (sizeof(float64_t) * n)) + return + + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + for i from 0 <= i < n: + outbuf[i, j] = values[i, idx] @cython.wraparound(False) @cython.boundscheck(False) @@ -3681,26 +3734,33 @@ def take_2d_axis1_int32_int32(ndarray[int32_t, ndim=2] values, n = len(values) k = len(indexer) - - if True and _checknan(fill_value): - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - raise ValueError('No NA values allowed') - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] - else: - fv = fill_value - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - outbuf[i, j] = fv - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] + + fv = fill_value + + IF True: + cdef: + int32_t *v, *o + + if values.flags.f_contiguous and out.flags.f_contiguous: + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + v = &values[0, idx] + o = &outbuf[0, j] + memmove(o, v, (sizeof(int32_t) * n)) + return + + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + for i from 0 <= i < n: + outbuf[i, j] = values[i, idx] @cython.wraparound(False) @cython.boundscheck(False) @@ -3714,26 +3774,33 @@ def take_2d_axis1_int32_int64(ndarray[int32_t, ndim=2] values, n = len(values) k = len(indexer) - - if True and _checknan(fill_value): - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - raise ValueError('No NA values allowed') - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] - else: - fv = fill_value - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - outbuf[i, j] = fv - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] + + fv = fill_value + + IF False: + cdef: + int64_t *v, *o + + if values.flags.f_contiguous and out.flags.f_contiguous: + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + v = &values[0, idx] + o = &outbuf[0, j] + memmove(o, v, (sizeof(int64_t) * n)) + return + + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + for i from 0 <= i < n: + outbuf[i, j] = values[i, idx] @cython.wraparound(False) @cython.boundscheck(False) @@ -3747,26 +3814,33 @@ def take_2d_axis1_int32_float64(ndarray[int32_t, ndim=2] values, n = len(values) k = len(indexer) - - if False and _checknan(fill_value): - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - raise ValueError('No NA values allowed') - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] - else: - fv = fill_value - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - outbuf[i, j] = fv - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] + + fv = fill_value + + IF False: + cdef: + float64_t *v, *o + + if values.flags.f_contiguous and out.flags.f_contiguous: + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + v = &values[0, idx] + o = &outbuf[0, j] + memmove(o, v, (sizeof(float64_t) * n)) + return + + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + for i from 0 <= i < n: + outbuf[i, j] = values[i, idx] @cython.wraparound(False) @cython.boundscheck(False) @@ -3780,26 +3854,33 @@ def take_2d_axis1_int64_int64(ndarray[int64_t, ndim=2] values, n = len(values) k = len(indexer) - - if True and _checknan(fill_value): - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - raise ValueError('No NA values allowed') - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] - else: - fv = fill_value - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - outbuf[i, j] = fv - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] + + fv = fill_value + + IF True: + cdef: + int64_t *v, *o + + if values.flags.f_contiguous and out.flags.f_contiguous: + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + v = &values[0, idx] + o = &outbuf[0, j] + memmove(o, v, (sizeof(int64_t) * n)) + return + + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + for i from 0 <= i < n: + outbuf[i, j] = values[i, idx] @cython.wraparound(False) @cython.boundscheck(False) @@ -3813,26 +3894,33 @@ def take_2d_axis1_int64_float64(ndarray[int64_t, ndim=2] values, n = len(values) k = len(indexer) - - if False and _checknan(fill_value): - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - raise ValueError('No NA values allowed') - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] - else: - fv = fill_value - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - outbuf[i, j] = fv - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] + + fv = fill_value + + IF False: + cdef: + float64_t *v, *o + + if values.flags.f_contiguous and out.flags.f_contiguous: + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + v = &values[0, idx] + o = &outbuf[0, j] + memmove(o, v, (sizeof(float64_t) * n)) + return + + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + for i from 0 <= i < n: + outbuf[i, j] = values[i, idx] @cython.wraparound(False) @cython.boundscheck(False) @@ -3846,26 +3934,33 @@ def take_2d_axis1_float32_float32(ndarray[float32_t, ndim=2] values, n = len(values) k = len(indexer) - - if False and _checknan(fill_value): - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - raise ValueError('No NA values allowed') - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] - else: - fv = fill_value - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - outbuf[i, j] = fv - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] + + fv = fill_value + + IF True: + cdef: + float32_t *v, *o + + if values.flags.f_contiguous and out.flags.f_contiguous: + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + v = &values[0, idx] + o = &outbuf[0, j] + memmove(o, v, (sizeof(float32_t) * n)) + return + + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + for i from 0 <= i < n: + outbuf[i, j] = values[i, idx] @cython.wraparound(False) @cython.boundscheck(False) @@ -3879,26 +3974,33 @@ def take_2d_axis1_float32_float64(ndarray[float32_t, ndim=2] values, n = len(values) k = len(indexer) - - if False and _checknan(fill_value): - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - raise ValueError('No NA values allowed') - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] - else: - fv = fill_value - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - outbuf[i, j] = fv - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] + + fv = fill_value + + IF False: + cdef: + float64_t *v, *o + + if values.flags.f_contiguous and out.flags.f_contiguous: + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + v = &values[0, idx] + o = &outbuf[0, j] + memmove(o, v, (sizeof(float64_t) * n)) + return + + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + for i from 0 <= i < n: + outbuf[i, j] = values[i, idx] @cython.wraparound(False) @cython.boundscheck(False) @@ -3912,26 +4014,33 @@ def take_2d_axis1_float64_float64(ndarray[float64_t, ndim=2] values, n = len(values) k = len(indexer) - - if False and _checknan(fill_value): - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - raise ValueError('No NA values allowed') - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] - else: - fv = fill_value - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - outbuf[i, j] = fv - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] + + fv = fill_value + + IF True: + cdef: + float64_t *v, *o + + if values.flags.f_contiguous and out.flags.f_contiguous: + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + v = &values[0, idx] + o = &outbuf[0, j] + memmove(o, v, (sizeof(float64_t) * n)) + return + + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + for i from 0 <= i < n: + outbuf[i, j] = values[i, idx] @cython.wraparound(False) @cython.boundscheck(False) @@ -3945,26 +4054,33 @@ def take_2d_axis1_object_object(ndarray[object, ndim=2] values, n = len(values) k = len(indexer) - - if False and _checknan(fill_value): - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - raise ValueError('No NA values allowed') - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] - else: - fv = fill_value - for j from 0 <= j < k: - idx = indexer[j] - if idx == -1: - for i from 0 <= i < n: - outbuf[i, j] = fv - else: - for i from 0 <= i < n: - outbuf[i, j] = values[i, idx] + + fv = fill_value + + IF False: + cdef: + object *v, *o + + if values.flags.f_contiguous and out.flags.f_contiguous: + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + v = &values[0, idx] + o = &outbuf[0, j] + memmove(o, v, (sizeof(object) * n)) + return + + for j from 0 <= j < k: + idx = indexer[j] + if idx == -1: + for i from 0 <= i < n: + outbuf[i, j] = fv + else: + for i from 0 <= i < n: + outbuf[i, j] = values[i, idx] @cython.wraparound(False) @@ -3982,31 +4098,18 @@ def take_2d_multi_bool_bool(ndarray[uint8_t, ndim=2] values, n = len(idx0) k = len(idx1) - if True and _checknan(fill_value): - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - if idx1[j] == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i, j] = values[idx, idx1[j]] - else: - fv = fill_value - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: + fv = fill_value + for i from 0 <= i < n: + idx = idx0[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + if idx1[j] == -1: outbuf[i, j] = fv - else: - for j from 0 <= j < k: - if idx1[j] == -1: - outbuf[i, j] = fv - else: - outbuf[i, j] = values[idx, idx1[j]] + else: + outbuf[i, j] = values[idx, idx1[j]] @cython.wraparound(False) @cython.boundscheck(False) @@ -4023,31 +4126,18 @@ def take_2d_multi_bool_object(ndarray[uint8_t, ndim=2] values, n = len(idx0) k = len(idx1) - if False and _checknan(fill_value): - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - if idx1[j] == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i, j] = True if values[idx, idx1[j]] > 0 else False - else: - fv = fill_value - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: + fv = fill_value + for i from 0 <= i < n: + idx = idx0[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + if idx1[j] == -1: outbuf[i, j] = fv - else: - for j from 0 <= j < k: - if idx1[j] == -1: - outbuf[i, j] = fv - else: - outbuf[i, j] = True if values[idx, idx1[j]] > 0 else False + else: + outbuf[i, j] = True if values[idx, idx1[j]] > 0 else False @cython.wraparound(False) @cython.boundscheck(False) @@ -4064,31 +4154,18 @@ def take_2d_multi_int8_int8(ndarray[int8_t, ndim=2] values, n = len(idx0) k = len(idx1) - if True and _checknan(fill_value): - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - if idx1[j] == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i, j] = values[idx, idx1[j]] - else: - fv = fill_value - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: + fv = fill_value + for i from 0 <= i < n: + idx = idx0[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + if idx1[j] == -1: outbuf[i, j] = fv - else: - for j from 0 <= j < k: - if idx1[j] == -1: - outbuf[i, j] = fv - else: - outbuf[i, j] = values[idx, idx1[j]] + else: + outbuf[i, j] = values[idx, idx1[j]] @cython.wraparound(False) @cython.boundscheck(False) @@ -4105,31 +4182,18 @@ def take_2d_multi_int8_int32(ndarray[int8_t, ndim=2] values, n = len(idx0) k = len(idx1) - if True and _checknan(fill_value): - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - if idx1[j] == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i, j] = values[idx, idx1[j]] - else: - fv = fill_value - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: + fv = fill_value + for i from 0 <= i < n: + idx = idx0[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + if idx1[j] == -1: outbuf[i, j] = fv - else: - for j from 0 <= j < k: - if idx1[j] == -1: - outbuf[i, j] = fv - else: - outbuf[i, j] = values[idx, idx1[j]] + else: + outbuf[i, j] = values[idx, idx1[j]] @cython.wraparound(False) @cython.boundscheck(False) @@ -4146,31 +4210,18 @@ def take_2d_multi_int8_int64(ndarray[int8_t, ndim=2] values, n = len(idx0) k = len(idx1) - if True and _checknan(fill_value): - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - if idx1[j] == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i, j] = values[idx, idx1[j]] - else: - fv = fill_value - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: + fv = fill_value + for i from 0 <= i < n: + idx = idx0[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + if idx1[j] == -1: outbuf[i, j] = fv - else: - for j from 0 <= j < k: - if idx1[j] == -1: - outbuf[i, j] = fv - else: - outbuf[i, j] = values[idx, idx1[j]] + else: + outbuf[i, j] = values[idx, idx1[j]] @cython.wraparound(False) @cython.boundscheck(False) @@ -4187,31 +4238,18 @@ def take_2d_multi_int8_float64(ndarray[int8_t, ndim=2] values, n = len(idx0) k = len(idx1) - if False and _checknan(fill_value): - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - if idx1[j] == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i, j] = values[idx, idx1[j]] - else: - fv = fill_value - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: + fv = fill_value + for i from 0 <= i < n: + idx = idx0[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + if idx1[j] == -1: outbuf[i, j] = fv - else: - for j from 0 <= j < k: - if idx1[j] == -1: - outbuf[i, j] = fv - else: - outbuf[i, j] = values[idx, idx1[j]] + else: + outbuf[i, j] = values[idx, idx1[j]] @cython.wraparound(False) @cython.boundscheck(False) @@ -4228,31 +4266,18 @@ def take_2d_multi_int16_int16(ndarray[int16_t, ndim=2] values, n = len(idx0) k = len(idx1) - if True and _checknan(fill_value): - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - if idx1[j] == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i, j] = values[idx, idx1[j]] - else: - fv = fill_value - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: + fv = fill_value + for i from 0 <= i < n: + idx = idx0[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + if idx1[j] == -1: outbuf[i, j] = fv - else: - for j from 0 <= j < k: - if idx1[j] == -1: - outbuf[i, j] = fv - else: - outbuf[i, j] = values[idx, idx1[j]] + else: + outbuf[i, j] = values[idx, idx1[j]] @cython.wraparound(False) @cython.boundscheck(False) @@ -4269,31 +4294,18 @@ def take_2d_multi_int16_int32(ndarray[int16_t, ndim=2] values, n = len(idx0) k = len(idx1) - if True and _checknan(fill_value): - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - if idx1[j] == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i, j] = values[idx, idx1[j]] - else: - fv = fill_value - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: + fv = fill_value + for i from 0 <= i < n: + idx = idx0[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + if idx1[j] == -1: outbuf[i, j] = fv - else: - for j from 0 <= j < k: - if idx1[j] == -1: - outbuf[i, j] = fv - else: - outbuf[i, j] = values[idx, idx1[j]] + else: + outbuf[i, j] = values[idx, idx1[j]] @cython.wraparound(False) @cython.boundscheck(False) @@ -4310,31 +4322,18 @@ def take_2d_multi_int16_int64(ndarray[int16_t, ndim=2] values, n = len(idx0) k = len(idx1) - if True and _checknan(fill_value): - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - if idx1[j] == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i, j] = values[idx, idx1[j]] - else: - fv = fill_value - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: + fv = fill_value + for i from 0 <= i < n: + idx = idx0[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + if idx1[j] == -1: outbuf[i, j] = fv - else: - for j from 0 <= j < k: - if idx1[j] == -1: - outbuf[i, j] = fv - else: - outbuf[i, j] = values[idx, idx1[j]] + else: + outbuf[i, j] = values[idx, idx1[j]] @cython.wraparound(False) @cython.boundscheck(False) @@ -4351,31 +4350,18 @@ def take_2d_multi_int16_float64(ndarray[int16_t, ndim=2] values, n = len(idx0) k = len(idx1) - if False and _checknan(fill_value): - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - if idx1[j] == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i, j] = values[idx, idx1[j]] - else: - fv = fill_value - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: + fv = fill_value + for i from 0 <= i < n: + idx = idx0[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + if idx1[j] == -1: outbuf[i, j] = fv - else: - for j from 0 <= j < k: - if idx1[j] == -1: - outbuf[i, j] = fv - else: - outbuf[i, j] = values[idx, idx1[j]] + else: + outbuf[i, j] = values[idx, idx1[j]] @cython.wraparound(False) @cython.boundscheck(False) @@ -4392,31 +4378,18 @@ def take_2d_multi_int32_int32(ndarray[int32_t, ndim=2] values, n = len(idx0) k = len(idx1) - if True and _checknan(fill_value): - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - if idx1[j] == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i, j] = values[idx, idx1[j]] - else: - fv = fill_value - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: + fv = fill_value + for i from 0 <= i < n: + idx = idx0[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + if idx1[j] == -1: outbuf[i, j] = fv - else: - for j from 0 <= j < k: - if idx1[j] == -1: - outbuf[i, j] = fv - else: - outbuf[i, j] = values[idx, idx1[j]] + else: + outbuf[i, j] = values[idx, idx1[j]] @cython.wraparound(False) @cython.boundscheck(False) @@ -4433,31 +4406,18 @@ def take_2d_multi_int32_int64(ndarray[int32_t, ndim=2] values, n = len(idx0) k = len(idx1) - if True and _checknan(fill_value): - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - if idx1[j] == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i, j] = values[idx, idx1[j]] - else: - fv = fill_value - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: + fv = fill_value + for i from 0 <= i < n: + idx = idx0[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + if idx1[j] == -1: outbuf[i, j] = fv - else: - for j from 0 <= j < k: - if idx1[j] == -1: - outbuf[i, j] = fv - else: - outbuf[i, j] = values[idx, idx1[j]] + else: + outbuf[i, j] = values[idx, idx1[j]] @cython.wraparound(False) @cython.boundscheck(False) @@ -4474,31 +4434,18 @@ def take_2d_multi_int32_float64(ndarray[int32_t, ndim=2] values, n = len(idx0) k = len(idx1) - if False and _checknan(fill_value): - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - if idx1[j] == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i, j] = values[idx, idx1[j]] - else: - fv = fill_value - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: + fv = fill_value + for i from 0 <= i < n: + idx = idx0[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + if idx1[j] == -1: outbuf[i, j] = fv - else: - for j from 0 <= j < k: - if idx1[j] == -1: - outbuf[i, j] = fv - else: - outbuf[i, j] = values[idx, idx1[j]] + else: + outbuf[i, j] = values[idx, idx1[j]] @cython.wraparound(False) @cython.boundscheck(False) @@ -4515,31 +4462,18 @@ def take_2d_multi_int64_int64(ndarray[int64_t, ndim=2] values, n = len(idx0) k = len(idx1) - if True and _checknan(fill_value): - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - if idx1[j] == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i, j] = values[idx, idx1[j]] - else: - fv = fill_value - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: + fv = fill_value + for i from 0 <= i < n: + idx = idx0[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + if idx1[j] == -1: outbuf[i, j] = fv - else: - for j from 0 <= j < k: - if idx1[j] == -1: - outbuf[i, j] = fv - else: - outbuf[i, j] = values[idx, idx1[j]] + else: + outbuf[i, j] = values[idx, idx1[j]] @cython.wraparound(False) @cython.boundscheck(False) @@ -4556,31 +4490,18 @@ def take_2d_multi_int64_float64(ndarray[int64_t, ndim=2] values, n = len(idx0) k = len(idx1) - if False and _checknan(fill_value): - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - if idx1[j] == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i, j] = values[idx, idx1[j]] - else: - fv = fill_value - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: + fv = fill_value + for i from 0 <= i < n: + idx = idx0[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + if idx1[j] == -1: outbuf[i, j] = fv - else: - for j from 0 <= j < k: - if idx1[j] == -1: - outbuf[i, j] = fv - else: - outbuf[i, j] = values[idx, idx1[j]] + else: + outbuf[i, j] = values[idx, idx1[j]] @cython.wraparound(False) @cython.boundscheck(False) @@ -4597,31 +4518,18 @@ def take_2d_multi_float32_float32(ndarray[float32_t, ndim=2] values, n = len(idx0) k = len(idx1) - if False and _checknan(fill_value): - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - if idx1[j] == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i, j] = values[idx, idx1[j]] - else: - fv = fill_value - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: + fv = fill_value + for i from 0 <= i < n: + idx = idx0[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + if idx1[j] == -1: outbuf[i, j] = fv - else: - for j from 0 <= j < k: - if idx1[j] == -1: - outbuf[i, j] = fv - else: - outbuf[i, j] = values[idx, idx1[j]] + else: + outbuf[i, j] = values[idx, idx1[j]] @cython.wraparound(False) @cython.boundscheck(False) @@ -4638,31 +4546,18 @@ def take_2d_multi_float32_float64(ndarray[float32_t, ndim=2] values, n = len(idx0) k = len(idx1) - if False and _checknan(fill_value): - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - if idx1[j] == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i, j] = values[idx, idx1[j]] - else: - fv = fill_value - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: + fv = fill_value + for i from 0 <= i < n: + idx = idx0[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + if idx1[j] == -1: outbuf[i, j] = fv - else: - for j from 0 <= j < k: - if idx1[j] == -1: - outbuf[i, j] = fv - else: - outbuf[i, j] = values[idx, idx1[j]] + else: + outbuf[i, j] = values[idx, idx1[j]] @cython.wraparound(False) @cython.boundscheck(False) @@ -4679,31 +4574,18 @@ def take_2d_multi_float64_float64(ndarray[float64_t, ndim=2] values, n = len(idx0) k = len(idx1) - if False and _checknan(fill_value): - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - if idx1[j] == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i, j] = values[idx, idx1[j]] - else: - fv = fill_value - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: + fv = fill_value + for i from 0 <= i < n: + idx = idx0[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + if idx1[j] == -1: outbuf[i, j] = fv - else: - for j from 0 <= j < k: - if idx1[j] == -1: - outbuf[i, j] = fv - else: - outbuf[i, j] = values[idx, idx1[j]] + else: + outbuf[i, j] = values[idx, idx1[j]] @cython.wraparound(False) @cython.boundscheck(False) @@ -4720,31 +4602,18 @@ def take_2d_multi_object_object(ndarray[object, ndim=2] values, n = len(idx0) k = len(idx1) - if False and _checknan(fill_value): - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: - raise ValueError('No NA values allowed') - else: - for j from 0 <= j < k: - if idx1[j] == -1: - raise ValueError('No NA values allowed') - else: - outbuf[i, j] = values[idx, idx1[j]] - else: - fv = fill_value - for i from 0 <= i < n: - idx = idx0[i] - if idx == -1: - for j from 0 <= j < k: + fv = fill_value + for i from 0 <= i < n: + idx = idx0[i] + if idx == -1: + for j from 0 <= j < k: + outbuf[i, j] = fv + else: + for j from 0 <= j < k: + if idx1[j] == -1: outbuf[i, j] = fv - else: - for j from 0 <= j < k: - if idx1[j] == -1: - outbuf[i, j] = fv - else: - outbuf[i, j] = values[idx, idx1[j]] + else: + outbuf[i, j] = values[idx, idx1[j]] @cython.boundscheck(False) diff --git a/pandas/tests/test_frame.py b/pandas/tests/test_frame.py index 09843667e4816..f2870f120f64b 100644 --- a/pandas/tests/test_frame.py +++ b/pandas/tests/test_frame.py @@ -8311,73 +8311,6 @@ def test_constructor_with_convert(self): None], np.object_)) assert_series_equal(result, expected) - def test_constructor_with_datetimes(self): - intname = np.dtype(np.int_).name - floatname = np.dtype(np.float_).name - datetime64name = np.dtype('M8[ns]').name - objectname = np.dtype(np.object_).name - - # single item - df = DataFrame({'A' : 1, 'B' : 'foo', 'C' : 'bar', 'D' : Timestamp("20010101"), 'E' : datetime(2001,1,2,0,0) }, - index=np.arange(10)) - result = df.get_dtype_counts() - expected = Series({intname: 1, datetime64name: 2, objectname : 2}) - result.sort() - expected.sort() - assert_series_equal(result, expected) - - # check with ndarray construction ndim==0 (e.g. we are passing a ndim 0 ndarray with a dtype specified) - df = DataFrame({'a': 1., 'b': 2, 'c': 'foo', floatname : np.array(1.,dtype=floatname), - intname : np.array(1,dtype=intname)}, index=np.arange(10)) - result = df.get_dtype_counts() - expected = Series({intname: 2, floatname : 2, objectname : 1}) - result.sort() - expected.sort() - assert_series_equal(result, expected) - - # check with ndarray construction ndim>0 - df = DataFrame({'a': 1., 'b': 2, 'c': 'foo', floatname : np.array([1.]*10,dtype=floatname), - intname : np.array([1]*10,dtype=intname)}, index=np.arange(10)) - result = df.get_dtype_counts() - expected = Series({intname: 2, floatname : 2, objectname : 1}) - result.sort() - expected.sort() - assert_series_equal(result, expected) - - # GH #2751 (construction with no index specified) - df = DataFrame({'a':[1,2,4,7], 'b':[1.2, 2.3, 5.1, 6.3], 'c':list('abcd'), 'd':[datetime(2000,1,1) for i in range(4)] }) - result = df.get_dtype_counts() - # TODO: fix this on 32-bit (or decide it's ok behavior?) - # expected = Series({intname: 1, floatname : 1, datetime64name: 1, objectname : 1}) - expected = Series({'int64': 1, floatname : 1, datetime64name: 1, objectname : 1}) - result.sort() - expected.sort() - assert_series_equal(result, expected) - - # GH 2809 - from pandas import date_range - ind = date_range(start="2000-01-01", freq="D", periods=10) - datetimes = [ts.to_pydatetime() for ts in ind] - datetime_s = Series(datetimes) - self.assert_(datetime_s.dtype == 'M8[ns]') - df = DataFrame({'datetime_s':datetime_s}) - result = df.get_dtype_counts() - expected = Series({ datetime64name : 1 }) - result.sort() - expected.sort() - assert_series_equal(result, expected) - - # GH 2810 - ind = date_range(start="2000-01-01", freq="D", periods=10) - datetimes = [ts.to_pydatetime() for ts in ind] - dates = [ts.date() for ts in ind] - df = DataFrame({'datetimes': datetimes, 'dates':dates}) - result = df.get_dtype_counts() - expected = Series({ datetime64name : 1, objectname : 1 }) - result.sort() - expected.sort() - assert_series_equal(result, expected) - def test_constructor_frame_copy(self): cop = DataFrame(self.frame, copy=True) cop['A'] = 5 diff --git a/pandas/tools/merge.py b/pandas/tools/merge.py index 6d699967915ba..b62e307b1f2a8 100644 --- a/pandas/tools/merge.py +++ b/pandas/tools/merge.py @@ -715,9 +715,7 @@ def _merge_blocks(self, merge_chunks): sofar = 0 for unit, blk in merge_chunks: out_chunk = out[sofar: sofar + len(blk)] - com.take_fast(blk.values, unit.indexer, - None, False, axis=self.axis, - out=out_chunk) + com.take_nd(blk.values, unit.indexer, self.axis, out=out_chunk) sofar += len(blk) # does not sort @@ -737,36 +735,24 @@ def __init__(self, blocks, indexer): @cache_readonly def mask_info(self): if self.indexer is None or not _may_need_upcasting(self.blocks): - mask = None - need_masking = False + return None else: mask = self.indexer == -1 - need_masking = mask.any() - - return mask, need_masking - - @property - def need_masking(self): - return self.mask_info[1] + needs_masking = mask.any() + return (mask, needs_masking) def get_upcasted_blocks(self): - # will short-circuit and not compute lneed_masking if indexer is None - if self.need_masking: + # will short-circuit and not compute needs_masking if indexer is None + if self.mask_info is not None and self.mask_info[1]: return _upcast_blocks(self.blocks) return self.blocks def reindex_block(self, block, axis, ref_items, copy=True): - # still some inefficiency here for bool/int64 because in the case where - # no masking is needed, take_fast will recompute the mask - - mask, need_masking = self.mask_info - if self.indexer is None: result = block.copy() if copy else block else: - result = block.reindex_axis(self.indexer, mask, need_masking, - axis=axis) - + result = block.reindex_axis(self.indexer, axis=axis, + mask_info=self.mask_info) result.ref_items = ref_items return result