def sdc_pandas_dataframe_rolling_cov(self, other=None, pairwise=None, ddof=1): ty_checker = TypeChecker('Method rolling.cov().') ty_checker.check(self, DataFrameRollingType) accepted_other = (Omitted, NoneType, DataFrameType, SeriesType) if not isinstance(other, accepted_other) and other is not None: ty_checker.raise_exc(other, 'DataFrame, Series', 'other') accepted_pairwise = (bool, Boolean, Omitted, NoneType) if not isinstance(pairwise, accepted_pairwise) and pairwise is not None: ty_checker.raise_exc(pairwise, 'bool', 'pairwise') if not isinstance(ddof, (int, Integer, Omitted)): ty_checker.raise_exc(ddof, 'int', 'ddof') none_other = isinstance(other, (Omitted, NoneType)) or other is None kws = {'other': 'None', 'pairwise': 'None', 'ddof': '1'} if none_other: # method _df_cov in comparison to method cov doesn't align input data # by replacing infinite and matched finite values with nans return gen_df_rolling_cov_other_none_impl('_df_cov', self, kws=kws) if isinstance(other, DataFrameType): return gen_df_rolling_method_other_df_impl('cov', self, other, kws=kws) return gen_df_rolling_method_impl('cov', self, kws=kws)
def sdc_pandas_dataframe_rolling_corr(self, other=None, pairwise=None): ty_checker = TypeChecker('Method rolling.corr().') ty_checker.check(self, DataFrameRollingType) accepted_other = (Omitted, NoneType, DataFrameType, SeriesType) if not isinstance(other, accepted_other) and other is not None: ty_checker.raise_exc(other, 'DataFrame, Series', 'other') accepted_pairwise = (bool, Boolean, Omitted, NoneType) if not isinstance(pairwise, accepted_pairwise) and pairwise is not None: ty_checker.raise_exc(pairwise, 'bool', 'pairwise') none_other = isinstance(other, (Omitted, NoneType)) or other is None kws = {'other': 'None', 'pairwise': 'None'} if none_other: return gen_df_rolling_method_other_none_impl('corr', self, kws=kws) if isinstance(other, DataFrameType): return gen_df_rolling_method_other_df_impl('corr', self, other, kws=kws) return gen_df_rolling_method_impl('corr', self, kws=kws)
def hpat_pandas_series_rolling_count(self): ty_checker = TypeChecker('Method rolling.count().') ty_checker.check(self, SeriesRollingType) def hpat_pandas_rolling_series_count_impl(self): win = self._window input_series = self._data input_arr = input_series._data length = len(input_arr) output_arr = numpy.empty(length, dtype=float64) boundary = min(win, length) for i in prange(boundary): arr_range = input_arr[:i + 1] output_arr[i] = arr_nonnan_count(arr_range) for i in prange(boundary, length): arr_range = input_arr[i + 1 - win:i + 1] output_arr[i] = arr_nonnan_count(arr_range) return pandas.Series(output_arr, input_series._index, name=input_series._name) return hpat_pandas_rolling_series_count_impl
def argsort_overload(a, axis=-1, kind=None, order=None): _func_name = 'argsort' ty_checker = TypeChecker(_func_name) ty_checker.check(a, types.Array) if not is_default(axis, -1): raise TypingError(f'{_func_name} Unsupported parameter axis') if not is_default(order, None): raise TypingError(f'{_func_name} Unsupported parameter order') def argsort_impl(a, axis=-1, kind=None, order=None): _kind = 'quicksort' if kind is not None: _kind = kind if _kind == 'quicksort': return parallel_argsort(a) elif _kind == 'mergesort': return parallel_stable_argsort(a) else: raise ValueError("Unsupported value of 'kind' parameter") return argsort_impl
def hpat_pandas_stringmethods_strip(self, to_strip=None): ty_checker = TypeChecker('Method strip().') ty_checker.check(self, StringMethodsType) if not isinstance(to_strip, (NoneType, StringLiteral, UnicodeType, Omitted)) and to_strip is not None: ty_checker.raise_exc(to_strip, 'str', 'to_strip') return sdc_pandas_series_str_strip_impl
def hpat_pandas_series_rolling_corr(self, other=None, pairwise=None): ty_checker = TypeChecker('Method rolling.corr().') ty_checker.check(self, SeriesRollingType) # TODO: check `other` is Series after a circular import of SeriesType fixed # accepted_other = (bool, Omitted, NoneType, SeriesType) # if not isinstance(other, accepted_other) and other is not None: # ty_checker.raise_exc(other, 'Series', 'other') accepted_pairwise = (bool, Boolean, Omitted, NoneType) if not isinstance(pairwise, accepted_pairwise) and pairwise is not None: ty_checker.raise_exc(pairwise, 'bool', 'pairwise') nan_other = isinstance(other, (Omitted, NoneType)) or other is None def hpat_pandas_rolling_series_corr_impl(self, other=None, pairwise=None): win = self._window minp = self._min_periods main_series = self._data main_arr = main_series._data main_arr_length = len(main_arr) if nan_other == True: # noqa other_arr = main_arr else: other_arr = other._data other_arr_length = len(other_arr) length = max(main_arr_length, other_arr_length) output_arr = numpy.empty(length, dtype=float64) def calc_corr(main, other, minp): # align arrays `main` and `other` by size and finiteness min_length = min(len(main), len(other)) main_valid_indices = numpy.isfinite(main[:min_length]) other_valid_indices = numpy.isfinite(other[:min_length]) valid = main_valid_indices & other_valid_indices if len(main[valid]) < minp: return numpy.nan else: return arr_corr(main[valid], other[valid]) for i in prange(min(win, length)): main_arr_range = main_arr[:i + 1] other_arr_range = other_arr[:i + 1] output_arr[i] = calc_corr(main_arr_range, other_arr_range, minp) for i in prange(win, length): main_arr_range = main_arr[i + 1 - win:i + 1] other_arr_range = other_arr[i + 1 - win:i + 1] output_arr[i] = calc_corr(main_arr_range, other_arr_range, minp) return pandas.Series(output_arr) return hpat_pandas_rolling_series_corr_impl
def hpat_pandas_series_rolling_var(self, ddof=1): ty_checker = TypeChecker('Method rolling.var().') ty_checker.check(self, SeriesRollingType) if not isinstance(ddof, (int, Integer, Omitted)): ty_checker.raise_exc(ddof, 'int', 'ddof') return sdc_pandas_series_rolling_var_impl
def sdc_pandas_dataframe_rolling_var(self, ddof=1): ty_checker = TypeChecker('Method rolling.var().') ty_checker.check(self, DataFrameRollingType) if not isinstance(ddof, (int, Integer, Omitted)): ty_checker.raise_exc(ddof, 'int', 'ddof') return gen_df_rolling_method_impl('var', self, kws={'ddof': '1'})
def hpat_pandas_stringmethods_center(self, width, fillchar=' '): """ Intel Scalable Dataframe Compiler User Guide ******************************************** Pandas API: pandas.Series.str.center Examples -------- .. literalinclude:: ../../../examples/series/str/series_str_center.py :language: python :lines: 27- :caption: Filling left and right side of strings in the Series with an additional character :name: ex_series_str_center .. command-output:: python ./series/str/series_str_center.py :cwd: ../../../examples .. seealso:: :ref:`Series.str.rjust <pandas.Series.str.rjust>` Fills the left side of strings with an arbitrary character. :ref:`Series.str.ljust <pandas.Series.str.ljust>` Fills the right side of strings with an arbitrary character. .. todo:: Add support of 32-bit Unicode for `str.center()` Intel Scalable Dataframe Compiler Developer Guide ************************************************* Pandas Series method :meth:`pandas.core.strings.StringMethods.center()` implementation. .. only:: developer Test: python -m sdc.runtests -k sdc.tests.test_series.TestSeries.test_series_center """ ty_checker = TypeChecker('Method center().') ty_checker.check(self, StringMethodsType) if not isinstance(width, Integer): ty_checker.raise_exc(width, 'int', 'width') accepted_types = (Omitted, StringLiteral, UnicodeType) if not isinstance(fillchar, accepted_types) and fillchar != ' ': ty_checker.raise_exc(fillchar, 'str', 'fillchar') def hpat_pandas_stringmethods_center_impl(self, width, fillchar=' '): mask = get_nan_mask(self._data._data) item_count = len(self._data) res_list = [''] * item_count for idx in numba.prange(item_count): res_list[idx] = self._data._data[idx].center(width, fillchar) str_arr = create_str_arr_from_list(res_list) result = str_arr_set_na_by_mask(str_arr, mask) return pandas.Series(result, self._data._index, name=self._data._name) return hpat_pandas_stringmethods_center_impl
def sdc_pandas_series_groupby_mean(self, *args): method_name = 'GroupBy.mean().' ty_checker = TypeChecker(method_name) ty_checker.check(self, SeriesGroupByType) method_args = ['self', '*args'] applied_func_name = 'mean' return sdc_pandas_series_groupby_apply_func(self, applied_func_name, method_args)
def sdc_pandas_dataframe_groupby_prod(self): method_name = 'GroupBy.prod().' ty_checker = TypeChecker(method_name) ty_checker.check(self, DataFrameGroupByType) method_args = ['self'] applied_func_name = 'prod' return sdc_pandas_dataframe_groupby_apply_func(self, applied_func_name, method_args)
def sdc_pandas_series_groupby_sum(self): method_name = 'GroupBy.sum().' ty_checker = TypeChecker(method_name) ty_checker.check(self, SeriesGroupByType) method_args = ['self'] applied_func_name = 'sum' return sdc_pandas_series_groupby_apply_func(self, applied_func_name, method_args)
def _almost_equal_overload(x, y): ty_checker = TypeChecker('Function sdc.common_functions._almost_equal_overload().') ty_checker.check(x, types.Float) ty_checker.check(x, types.Float) common_dtype = numpy.find_common_type([], [x.name, y.name]) def _almost_equal_impl(x, y): return abs(x - y) <= numpy.finfo(common_dtype).eps return _almost_equal_impl
def sdc_pandas_dataframe_rolling_apply(self, func, raw=None): ty_checker = TypeChecker('Method rolling.apply().') ty_checker.check(self, DataFrameRollingType) raw_accepted = (Omitted, NoneType, Boolean) if not isinstance(raw, raw_accepted) and raw is not None: ty_checker.raise_exc(raw, 'bool', 'raw') return gen_df_rolling_method_impl('apply', self, args=['func'], kws={'raw': 'None'})
def hpat_pandas_stringmethods_isnumeric(self): ty_checker = TypeChecker('Method isnumeric().') ty_checker.check(self, StringMethodsType) def hpat_pandas_stringmethods_isnumeric_impl(self): item_count = len(self._data) result = numpy.empty(item_count, numba.types.boolean) for idx, item in enumerate(self._data._data): result[idx] = item.isnumeric() return pandas.Series(result, self._data._index, name=self._data._name) return hpat_pandas_stringmethods_isnumeric_impl
def hpat_pandas_series_rolling_quantile(self, quantile, interpolation='linear'): ty_checker = TypeChecker('Method rolling.quantile().') ty_checker.check(self, SeriesRollingType) if not isinstance(quantile, Number): ty_checker.raise_exc(quantile, 'float', 'quantile') str_types = (Omitted, StringLiteral, UnicodeType) if not isinstance(interpolation, str_types) and interpolation != 'linear': ty_checker.raise_exc(interpolation, 'str', 'interpolation') def hpat_pandas_rolling_series_quantile_impl(self, quantile, interpolation='linear'): if quantile < 0 or quantile > 1: raise ValueError('quantile value not in [0, 1]') if interpolation != 'linear': raise ValueError('interpolation value not "linear"') win = self._window minp = self._min_periods input_series = self._data input_arr = input_series._data length = len(input_arr) output_arr = numpy.empty(length, dtype=float64) def calc_quantile(arr, quantile, minp): finite_arr = arr[numpy.isfinite(arr)] if len(finite_arr) < minp: return numpy.nan else: return arr_quantile(finite_arr, quantile) boundary = min(win, length) for i in prange(boundary): arr_range = input_arr[:i + 1] output_arr[i] = calc_quantile(arr_range, quantile, minp) for i in prange(boundary, length): arr_range = input_arr[i + 1 - win:i + 1] output_arr[i] = calc_quantile(arr_range, quantile, minp) return pandas.Series(output_arr, input_series._index, name=input_series._name) return hpat_pandas_rolling_series_quantile_impl
def sdc_pandas_dataframe_rolling_quantile(self, quantile, interpolation='linear'): ty_checker = TypeChecker('Method rolling.quantile().') ty_checker.check(self, DataFrameRollingType) if not isinstance(quantile, Number): ty_checker.raise_exc(quantile, 'float', 'quantile') str_types = (Omitted, StringLiteral, UnicodeType) if not isinstance(interpolation, str_types) and interpolation != 'linear': ty_checker.raise_exc(interpolation, 'str', 'interpolation') return gen_df_rolling_method_impl('quantile', self, args=['quantile'], kws={'interpolation': '"linear"'})
def hpat_pandas_stringmethods_len(self): """ Intel Scalable Dataframe Compiler User Guide ******************************************** Pandas API: pandas.Series.str.len Limitations ----------- Series elements are expected to be Unicode strings. Elements cannot be `NaNs`. Examples -------- .. literalinclude:: ../../../examples/series/str/series_str_len.py :language: python :lines: 27- :caption: Compute the length of each element in the Series :name: ex_series_str_len .. command-output:: python ./series/str/series_str_len.py :cwd: ../../../examples .. seealso:: `str.len` Python built-in function returning the length of an object. :ref:`Series.size <pandas.Series.size>` Returns the length of the Series. Intel Scalable Dataframe Compiler Developer Guide ************************************************* Pandas Series method :meth:`pandas.core.strings.StringMethods.len()` implementation. .. only:: developer Test: python -m sdc.runtests sdc.tests.test_series.TestSeries.test_series_str_len1 """ ty_checker = TypeChecker('Method len().') ty_checker.check(self, StringMethodsType) def hpat_pandas_stringmethods_len_impl(self): item_count = len(self._data) result = numpy.empty(item_count, numba.types.int64) for idx, item in enumerate(self._data._data): result[idx] = len(item) return pandas.Series(result, self._data._index, name=self._data._name) return hpat_pandas_stringmethods_len_impl
def _hpat_pandas_series_rolling_cov_check_types(self, other=None, pairwise=None, ddof=1): """Check types of parameters of series.rolling.cov()""" ty_checker = TypeChecker('Method rolling.cov().') ty_checker.check(self, SeriesRollingType) accepted_other = (bool, Omitted, NoneType, SeriesType) if not isinstance(other, accepted_other) and other is not None: ty_checker.raise_exc(other, 'Series', 'other') accepted_pairwise = (bool, Boolean, Omitted, NoneType) if not isinstance(pairwise, accepted_pairwise) and pairwise is not None: ty_checker.raise_exc(pairwise, 'bool', 'pairwise') if not isinstance(ddof, (int, Integer, Omitted)): ty_checker.raise_exc(ddof, 'int', 'ddof')
def hpat_pandas_stringmethods_casefold(self): ty_checker = TypeChecker('Method casefold().') ty_checker.check(self, StringMethodsType) def hpat_pandas_stringmethods_casefold_impl(self): mask = get_nan_mask(self._data._data) item_count = len(self._data) res_list = [''] * item_count for idx in numba.prange(item_count): res_list[idx] = self._data._data[idx].casefold() str_arr = create_str_arr_from_list(res_list) result = str_arr_set_na_by_mask(str_arr, mask) return pandas.Series(result, self._data._index, name=self._data._name) return hpat_pandas_stringmethods_casefold_impl
def _sdc_pandas_series_align_overload(series, other, size='max', finiteness=False): ty_checker = TypeChecker( 'Function sdc.common_functions._sdc_pandas_series_align().') ty_checker.check(series, SeriesType) ty_checker.check(other, SeriesType) str_types = (str, types.StringLiteral, types.UnicodeType, types.Omitted) if not isinstance(size, str_types): ty_checker.raise_exc(size, 'str', 'size') if not isinstance(finiteness, (bool, types.Boolean, types.Omitted)): ty_checker.raise_exc(finiteness, 'bool', 'finiteness') def _sdc_pandas_series_align_impl(series, other, size='max', finiteness=False): if size != 'max' and size != 'min': raise ValueError( "Function sdc.common_functions._sdc_pandas_series_align(). " "The object size\n expected: 'max' or 'min'") arr, other_arr = series._data, other._data arr_len, other_arr_len = len(arr), len(other_arr) min_length = min(arr_len, other_arr_len) length = max(arr_len, other_arr_len) if size == 'max' else min_length aligned_arr = numpy.repeat([numpy.nan], length) aligned_other_arr = numpy.repeat([numpy.nan], length) for i in numba.prange(min_length): if not finiteness or (numpy.isfinite(arr[i]) and numpy.isfinite(other_arr[i])): aligned_arr[i] = arr[i] aligned_other_arr[i] = other_arr[i] else: aligned_arr[i] = aligned_other_arr[i] = numpy.nan aligned = pandas.Series(aligned_arr, name=series._name) aligned_other = pandas.Series(aligned_other_arr, name=other._name) return aligned, aligned_other return _sdc_pandas_series_align_impl
def sdc_pandas_series_groupby_var(self, ddof=1, *args): method_name = 'GroupBy.var().' ty_checker = TypeChecker(method_name) ty_checker.check(self, SeriesGroupByType) if not isinstance(ddof, (types.Omitted, int, types.Integer)): ty_checker.raise_exc(ddof, 'int', 'ddof') method_args = ['self', 'ddof', '*args'] default_values = {'ddof': 1} impl_used_params = {'ddof': 'ddof'} applied_func_name = 'var' return sdc_pandas_series_groupby_apply_func(self, applied_func_name, method_args, default_values, impl_used_params)
def hpat_pandas_series_rolling_apply(self, func, raw=None): ty_checker = TypeChecker('Method rolling.apply().') ty_checker.check(self, SeriesRollingType) raw_accepted = (Omitted, NoneType, Boolean) if not isinstance(raw, raw_accepted) and raw is not None: ty_checker.raise_exc(raw, 'bool', 'raw') def hpat_pandas_rolling_series_apply_impl(self, func, raw=None): win = self._window minp = self._min_periods input_series = self._data input_arr = input_series._data length = len(input_arr) output_arr = numpy.empty(length, dtype=float64) def culc_apply(arr, func, minp): finite_arr = arr.copy() finite_arr[numpy.isinf(arr)] = numpy.nan if len(finite_arr) < minp: return numpy.nan else: return arr_apply(finite_arr, func) boundary = min(win, length) for i in prange(boundary): arr_range = input_arr[:i + 1] output_arr[i] = culc_apply(arr_range, func, minp) for i in prange(boundary, length): arr_range = input_arr[i + 1 - win:i + 1] output_arr[i] = culc_apply(arr_range, func, minp) return pandas.Series(output_arr, input_series._index, name=input_series._name) return hpat_pandas_rolling_series_apply_impl
def hpat_pandas_stringmethods_upper(self): ty_checker = TypeChecker('Method upper().') ty_checker.check(self, StringMethodsType) def hpat_pandas_stringmethods_upper_impl(self): mask = get_nan_mask(self._data._data) item_count = len(self._data) result = [''] * item_count for it in numba.prange(item_count): item = self._data._data[it] if len(item) > 0: result[it] = item.upper() else: result[it] = item str_arr = create_str_arr_from_list(result) result = str_arr_set_na_by_mask(str_arr, mask) return pandas.Series(result, self._data._index, name=self._data._name) return hpat_pandas_stringmethods_upper_impl
def sdc_pandas_dataframe_rolling_sum(self): ty_checker = TypeChecker('Method rolling.sum().') ty_checker.check(self, DataFrameRollingType) return gen_df_rolling_method_impl('sum', self)
def sdc_pandas_series_comp_binop(self, other, level=None, fill_value=None, axis=0): """ Intel Scalable Dataframe Compiler User Guide ******************************************** Pandas API: pandas.Series.comp_binop Limitations ----------- Parameters ``level`` and ``axis`` are currently unsupported by Intel Scalable Dataframe Compiler Examples -------- .. literalinclude:: ../../../examples/series/series_comp_binop.py :language: python :lines: 27- :caption: :name: ex_series_comp_binop .. command-output:: python ./series/series_comp_binop.py :cwd: ../../../examples Intel Scalable Dataframe Compiler Developer Guide ************************************************* Pandas Series method :meth:`pandas.Series.comp_binop` implementation. .. only:: developer Test: python -m sdc.runtests -k sdc.tests.test_series.TestSeries.test_series_op8 """ _func_name = 'Method comp_binop().' ty_checker = TypeChecker(_func_name) ty_checker.check(self, SeriesType) if not (isinstance(level, types.Omitted) or level is None): ty_checker.raise_exc(level, 'None', 'level') if not isinstance(fill_value, (types.Omitted, types.Number, types.NoneType)) and fill_value is not None: ty_checker.raise_exc(fill_value, 'number', 'fill_value') if not (isinstance(axis, types.Omitted) or axis == 0): ty_checker.raise_exc(axis, 'int', 'axis') self_is_series, other_is_series = isinstance(self, SeriesType), isinstance( other, SeriesType) if not (self_is_series or other_is_series): return None if not isinstance(self, (SeriesType, types.Number, types.UnicodeType)): ty_checker.raise_exc(self, 'pandas.series or scalar', 'self') if not isinstance(other, (SeriesType, types.Number, types.UnicodeType)): ty_checker.raise_exc(other, 'pandas.series or scalar', 'other') operands_are_series = self_is_series and other_is_series if operands_are_series: none_or_numeric_indexes = ((isinstance(self.index, types.NoneType) or check_index_is_numeric(self)) and (isinstance(other.index, types.NoneType) or check_index_is_numeric(other))) series_indexes_comparable = check_types_comparable( self.index, other.index) or none_or_numeric_indexes if not series_indexes_comparable: raise TypingError( '{} Not implemented for series with not-comparable indexes. \ Given: self.index={}, other.index={}'.format( _func_name, self.index, other.index)) series_data_comparable = check_types_comparable(self, other) if not series_data_comparable: raise TypingError('{} Not supported for not-comparable operands. \ Given: self={}, other={}'.format(_func_name, self, other)) fill_value_is_none = isinstance( fill_value, (types.NoneType, types.Omitted)) or fill_value is None if not operands_are_series: def _series_comp_binop_scalar_impl(self, other, level=None, fill_value=None, axis=0): if self_is_series == True: # noqa numpy_like.fillna(self._data, inplace=True, value=fill_value) return pandas.Series(self._data < other, index=self._index, name=self._name) else: numpy_like.fillna(other._data, inplace=True, value=fill_value) return pandas.Series(self < other._data, index=other._index, name=other._name) return _series_comp_binop_scalar_impl else: # optimization for series with default indexes, that can be aligned differently if (isinstance(self.index, types.NoneType) and isinstance(other.index, types.NoneType)): def _series_comp_binop_none_indexes_impl(self, other, level=None, fill_value=None, axis=0): numpy_like.fillna(self._data, inplace=True, value=fill_value) numpy_like.fillna(other._data, inplace=True, value=fill_value) left_size, right_size = len(self._data), len(other._data) if (left_size == right_size): return pandas.Series(self._data < other._data) else: raise ValueError( "Can only compare identically-labeled Series objects") return _series_comp_binop_none_indexes_impl else: left_index_is_range = isinstance(self.index, (RangeIndexType, types.NoneType)) index_dtypes_match = self.index.dtype == other.index.dtype if not index_dtypes_match: numba_index_common_dtype = find_common_dtype_from_numpy_dtypes( [self.index.dtype, other.index.dtype], []) else: numba_index_common_dtype = self.index.dtype def _series_comp_binop_common_impl(self, other, level=None, fill_value=None, axis=0): numpy_like.fillna(self._data, inplace=True, value=fill_value) numpy_like.fillna(other._data, inplace=True, value=fill_value) left_index, right_index = self.index, other.index if (left_index is right_index or numpy_like.array_equal(left_index, right_index)): if index_dtypes_match == False: # noqa new_index = numpy_like.astype( left_index, numba_index_common_dtype) else: new_index = left_index.values if left_index_is_range == True else left_index # noqa return pandas.Series(self._data < other._data, new_index) else: raise ValueError( "Can only compare identically-labeled Series objects") return _series_comp_binop_common_impl return None
def sdc_pandas_series_comp_binop(self, other, level=None, fill_value=None, axis=0): """ Intel Scalable Dataframe Compiler User Guide ******************************************** Pandas API: pandas.Series.comp_binop Limitations ----------- Parameters ``level`` and ``axis`` are currently unsupported by Intel Scalable Dataframe Compiler Examples -------- .. literalinclude:: ../../../examples/series/series_comp_binop.py :language: python :lines: 27- :caption: :name: ex_series_comp_binop .. command-output:: python ./series/series_comp_binop.py :cwd: ../../../examples Intel Scalable Dataframe Compiler Developer Guide ************************************************* Pandas Series method :meth:`pandas.Series.comp_binop` implementation. .. only:: developer Test: python -m sdc.runtests -k sdc.tests.test_series.TestSeries.test_series_op8 """ _func_name = 'Method comp_binop().' ty_checker = TypeChecker(_func_name) ty_checker.check(self, SeriesType) if not (isinstance(level, types.Omitted) or level is None): ty_checker.raise_exc(level, 'None', 'level') if not (isinstance(fill_value, (types.Omitted, types.Number, types.UnicodeType, types.NoneType)) or fill_value is None): ty_checker.raise_exc(fill_value, 'scalar', 'fill_value') if not (isinstance(axis, types.Omitted) or axis == 0): ty_checker.raise_exc(axis, 'int', 'axis') self_is_series, other_is_series = isinstance(self, SeriesType), isinstance(other, SeriesType) if not (self_is_series or other_is_series): return None if not isinstance(self, SeriesType): ty_checker.raise_exc(self, 'pandas.series', 'self') if not isinstance(other, (SeriesType, types.Number, types.UnicodeType)): ty_checker.raise_exc(other, 'pandas.series or scalar', 'other') operands_are_series = self_is_series and other_is_series if operands_are_series: series_indexes_comparable = check_types_comparable(self.index, other.index) if not series_indexes_comparable: raise TypingError('{} Not implemented for series with not-comparable indexes. \ Given: self.index={}, other.index={}'.format(_func_name, self.index, other.index)) series_data_comparable = check_types_comparable(self, other) if not series_data_comparable: raise TypingError('{} Not supported for not-comparable operands. \ Given: self={}, other={}'.format(_func_name, self, other)) # specializations for both numeric and string series def series_comp_binop_wrapper(self, other, level=None, fill_value=None, axis=0): return sdc_comp_binop(self, other, fill_value) return series_comp_binop_wrapper
def hpat_pandas_series_rolling_count(self): ty_checker = TypeChecker('Method rolling.count().') ty_checker.check(self, SeriesRollingType) return sdc_pandas_series_rolling_count_impl
def hpat_pandas_series_rolling_corr(self, other=None, pairwise=None): ty_checker = TypeChecker('Method rolling.corr().') ty_checker.check(self, SeriesRollingType) accepted_other = (bool, Omitted, NoneType, SeriesType) if not isinstance(other, accepted_other) and other is not None: ty_checker.raise_exc(other, 'Series', 'other') accepted_pairwise = (bool, Boolean, Omitted, NoneType) if not isinstance(pairwise, accepted_pairwise) and pairwise is not None: ty_checker.raise_exc(pairwise, 'bool', 'pairwise') nan_other = isinstance(other, (Omitted, NoneType)) or other is None def hpat_pandas_rolling_series_corr_impl(self, other=None, pairwise=None): win = self._window minp = self._min_periods main_series = self._data main_arr = main_series._data if nan_other == True: # noqa other_arr = main_arr else: other_arr = other._data main_arr_length = len(main_arr) other_arr_length = len(other_arr) min_length = min(main_arr_length, other_arr_length) length = max(main_arr_length, other_arr_length) output_arr = numpy.empty(length, dtype=float64) chunks = parallel_chunks(length) for i in prange(len(chunks)): chunk = chunks[i] nfinite = 0 result = (0., 0., 0., 0., 0.) if win == 0: for idx in range(chunk.start, chunk.stop): output_arr[idx] = corr_result_or_nan(nfinite, minp, result) continue prelude_start = max(0, chunk.start - win + 1) prelude_stop = min(chunk.start, min_length) interlude_start = chunk.start interlude_stop = min(prelude_start + win, chunk.stop, min_length) postlude_start = min(prelude_start + win, chunk.stop) postlude_stop = min(chunk.stop, min_length) for idx in range(prelude_start, prelude_stop): x, y = main_arr[idx], other_arr[idx] nfinite, result = put_corr(x, y, nfinite, result) for idx in range(interlude_start, interlude_stop): x, y = main_arr[idx], other_arr[idx] nfinite, result = put_corr(x, y, nfinite, result) output_arr[idx] = corr_result_or_nan(nfinite, minp, result) for idx in range(postlude_start, postlude_stop): put_x, put_y = main_arr[idx], other_arr[idx] pop_x, pop_y = main_arr[idx - win], other_arr[idx - win] nfinite, result = put_corr(put_x, put_y, nfinite, result) nfinite, result = pop_corr(pop_x, pop_y, nfinite, result) output_arr[idx] = corr_result_or_nan(nfinite, minp, result) last_start = max(min_length, interlude_start) for idx in range(last_start, postlude_start): output_arr[idx] = corr_result_or_nan(nfinite, minp, result) last_start = max(min_length, postlude_start) last_stop = min(min_length + win, chunk.stop) for idx in range(last_start, last_stop): x, y = main_arr[idx - win], other_arr[idx - win] nfinite, result = pop_corr(x, y, nfinite, result) output_arr[idx] = corr_result_or_nan(nfinite, minp, result) for idx in range(last_stop, chunk.stop): output_arr[idx] = numpy.nan return pandas.Series(output_arr) return hpat_pandas_rolling_series_corr_impl
def hpat_pandas_series_rolling_median(self): ty_checker = TypeChecker('Method rolling.median().') ty_checker.check(self, SeriesRollingType) return hpat_pandas_rolling_series_median_impl