def _series_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) if (len(self._data) == len(other._data)): result_data = numpy_like.astype(self._data, numpy.float64) result_data = result_data + other._data return pandas.Series(result_data) else: left_size, right_size = len(self._data), len(other._data) min_data_size = min(left_size, right_size) max_data_size = max(left_size, right_size) result_data = numpy.empty(max_data_size, dtype=numpy.float64) _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa if (left_size == min_data_size): result_data[:min_data_size] = self._data for i in range(min_data_size, len(result_data)): result_data[i] = _fill_value result_data = result_data + other._data else: result_data[:min_data_size] = other._data for i in range(min_data_size, len(result_data)): result_data[i] = _fill_value result_data = self._data + result_data return pandas.Series(result_data)
def _series_binop_common_impl(self, other, level=None, fill_value=None, axis=0): left_index, right_index = self.index, other.index _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa if not (fill_value is None or numpy.isnan(fill_value)): numpy_like.fillna(self._data, inplace=True, value=fill_value) numpy_like.fillna(other._data, inplace=True, value=fill_value) # check if indexes are equal and series don't have to be aligned if sdc_check_indexes_equal(left_index, right_index): result_data = numpy.empty(len(self._data), dtype=numpy.float64) result_data[:] = self._data + other._data if none_or_numeric_indexes == True: # noqa result_index = numpy_like.astype(left_index, numba_index_common_dtype) else: result_index = self._index return pandas.Series(result_data, index=result_index) # TODO: replace below with core join(how='outer', return_indexers=True) when implemented joined_index, left_indexer, right_indexer = sdc_join_series_indexes(left_index, right_index) result_size = len(joined_index) left_values = numpy.empty(result_size, dtype=numpy.float64) right_values = numpy.empty(result_size, dtype=numpy.float64) for i in range(result_size): left_pos, right_pos = left_indexer[i], right_indexer[i] left_values[i] = self._data[left_pos] if left_pos != -1 else _fill_value right_values[i] = other._data[right_pos] if right_pos != -1 else _fill_value result_data = left_values + right_values return pandas.Series(result_data, joined_index)
def _series_operator_binop_common_impl(self, other): left_index, right_index = self.index, other.index # check if indexes are equal and series don't have to be aligned if sdc_check_indexes_equal(left_index, right_index): result_data = numpy.empty(len(self._data), dtype=numpy.float64) result_data[:] = self._data + other._data if none_or_numeric_indexes == True: # noqa result_index = astype(left_index, numba_index_common_dtype) else: result_index = self._index return pandas.Series(result_data, index=result_index) # TODO: replace below with core join(how='outer', return_indexers=True) when implemented joined_index, left_indexer, right_indexer = sdc_join_series_indexes( left_index, right_index) result_size = len(joined_index) left_values = numpy.empty(result_size, dtype=numpy.float64) right_values = numpy.empty(result_size, dtype=numpy.float64) for i in numba.prange(result_size): left_pos, right_pos = left_indexer[i], right_indexer[i] left_values[i] = self._data[ left_pos] if left_pos != -1 else numpy.nan right_values[i] = other._data[ right_pos] if right_pos != -1 else numpy.nan result_data = left_values + right_values return pandas.Series(result_data, joined_index)
def pd_indexes_join_array_indexes_impl(left, right): _left = left.values if convert_left == True else left # noqa _right = right.values if convert_right == True else right # noqa if (_left is _right or numpy_like.array_equal(_left, _right)): if index_dtypes_match == False: # noqa joined_index = numpy_like.astype(_left, res_index_dtype) else: joined_index = _left return joined_index, None, None return _sdc_internal_join(_left, _right)
def _series_operator_comp_binop_common_impl(self, other): left_index, right_index = self.index, other.index if sdc_check_indexes_equal(left_index, right_index): if none_or_numeric_indexes == True: # noqa new_index = astype(left_index, numba_index_common_dtype) else: new_index = self._index return pandas.Series(self._data < other._data, new_index) else: raise ValueError( "Can only compare identically-labeled Series objects")
def sdc_unify_index_types_impl(left, right): if index_dtypes_match == True: # noqa return left else: if is_left_index_cached == True: # noqa index_data = left.values if is_left_index_array == False else left # noqa elif is_right_index_cached == True: # noqa index_data = right.values if is_right_index_array == False else right # noqa else: # using numpy_like.astype but not index.astype since latter works differently index_data = numpy_like.astype(left, numba_index_common_dtype) return fix_df_index(index_data)
def _series_comp_binop_common_impl(self, other, level=None, fill_value=None, axis=0): if not (fill_value is None or numpy.isnan(fill_value)): 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 sdc_check_indexes_equal(left_index, right_index): if none_or_numeric_indexes == True: # noqa new_index = numpy_like.astype(left_index, numba_index_common_dtype) else: new_index = self._index return pandas.Series(self._data < other._data, new_index) else: raise ValueError("Can only compare identically-labeled Series objects")
def _series_comp_binop_common_impl(self, other, fill_value=None): left_index, right_index = self.index, other.index if not (left_index is right_index or numpy_like.array_equal(left_index, right_index)): raise ValueError( "Can only compare identically-labeled Series objects") _left, _right = pandas.Series(self._data), pandas.Series( other._data) partial_res = _left.comp_binop(_right, fill_value=fill_value) if index_dtypes_match == False: # noqa result_index = numpy_like.astype(left_index, numba_index_common_dtype) else: result_index = left_index.values if left_index_is_range == True else left_index # noqa return pandas.Series(partial_res._data, result_index)
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")
def pd_int64_index_ctor_impl(data, dtype=None, copy=False, name=None): if not (dtype is None or dtype_is_numpy_signed_int or dtype_is_unicode_str and dtype in ('int8', 'int16', 'int32', 'int64')): raise ValueError("Incorrect `dtype` passed: expected signed integer") if is_data_array == True: # noqa _data = data elif is_data_index == True: # noqa _data = data.values else: _data = fix_df_index(data)._data if data_dtype_is_int64 == False: # noqa _data = numpy_like.astype(_data, dtype=types.int64) else: if copy: _data = np.copy(_data) return init_int64_index(_data, name)
def _series_binop_common_impl(self, other, level=None, fill_value=None, axis=0): left_index, right_index = self.index, other.index numpy_like.fillna(self._data, inplace=True, value=fill_value) numpy_like.fillna(other._data, inplace=True, value=fill_value) if check_index_equal == True: # noqa equal_indexes = numpy_like.array_equal( left_index, right_index) else: equal_indexes = False if (left_index is right_index or equal_indexes): result_data = numpy.empty(len(self._data), dtype=numpy.float64) result_data[:] = self._data + other._data if index_dtypes_match == False: # noqa result_index = numpy_like.astype( left_index, numba_index_common_dtype) else: result_index = left_index.values if left_index_is_range == True else left_index # noqa return pandas.Series(result_data, index=result_index) # TODO: replace below with core join(how='outer', return_indexers=True) when implemented joined_index, left_indexer, right_indexer = sdc_join_series_indexes( left_index, right_index) result_size = len(joined_index) left_values = numpy.empty(result_size, dtype=numpy.float64) right_values = numpy.empty(result_size, dtype=numpy.float64) _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa for i in range(result_size): left_pos, right_pos = left_indexer[i], right_indexer[i] left_values[i] = self._data[ left_pos] if left_pos != -1 else _fill_value right_values[i] = other._data[ right_pos] if right_pos != -1 else _fill_value result_data = left_values + right_values return pandas.Series(result_data, joined_index)
def _series_operator_binop_none_indexes_impl(self, other): if (len(self._data) == len(other._data)): result_data = astype(self._data, numpy.float64) result_data = result_data + other._data return pandas.Series(result_data) else: left_size, right_size = len(self._data), len(other._data) min_data_size = min(left_size, right_size) max_data_size = max(left_size, right_size) result_data = numpy.empty(max_data_size, dtype=numpy.float64) if (left_size == min_data_size): result_data[:min_data_size] = self._data result_data[min_data_size:] = numpy.nan result_data = result_data + other._data else: result_data[:min_data_size] = other._data result_data[min_data_size:] = numpy.nan result_data = self._data + result_data return pandas.Series(result_data)
def sdc_binop_impl(self, other, fill_value=None): # check if indexes are equal and series don't have to be aligned left_index, right_index = self.index, other.index if (left_index is right_index or numpy_like.array_equal(left_index, right_index)): _left = pandas.Series(self._data) _right = pandas.Series(other._data) partial_res = _left.binop(_right, fill_value=fill_value) if index_dtypes_match == False: # noqa result_index = numpy_like.astype( left_index, numba_index_common_dtype) else: result_index = left_index.values if left_index_is_range == True else left_index # noqa return pandas.Series(partial_res._data, index=result_index) _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa # TODO: replace below with core join(how='outer', return_indexers=True) when implemented joined_index, left_indexer, right_indexer = sdc_join_series_indexes( left_index, right_index) result_size = len(joined_index) result_data = numpy.empty(result_size, dtype=numpy.float64) for i in numba.prange(result_size): left_pos, right_pos = left_indexer[i], right_indexer[i] left_nan = (left_pos == -1 or numpy.isnan(self._data[left_pos])) right_nan = (right_pos == -1 or numpy.isnan(other._data[right_pos])) _left = _fill_value if left_nan else self._data[left_pos] _right = _fill_value if right_nan else other._data[ right_pos] result_data[i] = numpy.nan if ( left_nan and right_nan) else _left + _right return pandas.Series(result_data, index=joined_index)
def sdc_impl(a): return numpy_like.astype(a, str)
def sdc_impl(a): return numpy_like.astype(a, np.int64)
def sdc_impl(a): return numpy_like.astype(a, 'float64')
def sdc_func(index): return astype(index, np.int64)