From c81bd54d789720b35d7558c41b105d98caefc1cf Mon Sep 17 00:00:00 2001 From: Sergey Pokhodenko Date: Fri, 5 Jun 2020 13:48:47 +0300 Subject: [PATCH 1/5] SAT-2941 - SDC: Function tests failed for all platforms (#881) Clean usage of parquet. --- sdc/tests/gen_test_data.py | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/sdc/tests/gen_test_data.py b/sdc/tests/gen_test_data.py index fa5fbba0b..ee20249f5 100644 --- a/sdc/tests/gen_test_data.py +++ b/sdc/tests/gen_test_data.py @@ -120,16 +120,6 @@ def generate_csv_data(): with open("csv_data_date1.csv", "w") as f: f.write(data) - # generated data for parallel merge_asof testing - df1 = pd.DataFrame({'time': pd.DatetimeIndex( - ['2017-01-03', '2017-01-06', '2017-02-15', '2017-02-21']), - 'B': [4, 5, 9, 6]}) - df2 = pd.DataFrame({'time': pd.DatetimeIndex( - ['2017-01-01', '2017-01-14', '2017-01-16', '2017-02-23', '2017-02-23', - '2017-02-25']), 'A': [2, 3, 7, 8, 9, 10]}) - df1.to_parquet("asof1.pq") - df2.to_parquet("asof2.pq") - def generate_other_data(): df = pd.DataFrame({'A': ['bc'] + ["a"] * 3 + ["bc"] * 3 + ['a'], 'B': [-8, 1, 2, 3, 1, 5, 6, 7]}) From 6c02c43149b963b32cb35fe2359111f85271a34b Mon Sep 17 00:00:00 2001 From: Alexander Kalistratov Date: Fri, 5 Jun 2020 14:30:53 +0300 Subject: [PATCH 2/5] Enable Azure pipiline CI for all branches (#883) --- azure-pipelines.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/azure-pipelines.yml b/azure-pipelines.yml index 5c670130c..a61d1ec94 100644 --- a/azure-pipelines.yml +++ b/azure-pipelines.yml @@ -1,8 +1,8 @@ trigger: -- master +- '*' pr: -- master +- '*' jobs: - template: buildscripts/azure/template-windows.yml From d1df4086145ff993028e44fb7cb0f837c6a09aac Mon Sep 17 00:00:00 2001 From: Alexey Kozlov <52973316+kozlov-alexey@users.noreply.github.com> Date: Fri, 5 Jun 2020 16:11:29 +0300 Subject: [PATCH 3/5] SAT-2951 - SDC: 40 tests are failed on Linux 3.6 (#882) --- sdc/sdc_autogenerated.py | 194 +++++++++++++++++++--------------- sdc/sdc_function_templates.py | 28 ++--- 2 files changed, 126 insertions(+), 96 deletions(-) diff --git a/sdc/sdc_autogenerated.py b/sdc/sdc_autogenerated.py index 4be3090ea..965d3636b 100644 --- a/sdc/sdc_autogenerated.py +++ b/sdc/sdc_autogenerated.py @@ -122,15 +122,16 @@ def sdc_pandas_series_add(self, other, level=None, fill_value=None, axis=0): # specializations for numeric series only if not operands_are_series: def _series_add_scalar_impl(self, other, level=None, fill_value=None, axis=0): + _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa if self_is_series == True: # 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(self._data, inplace=True, value=_fill_value) result_data = numpy.empty(len(self._data), dtype=numpy.float64) result_data[:] = self._data + numpy.float64(other) return pandas.Series(result_data, index=self._index, name=self._name) else: if not (fill_value is None or numpy.isnan(fill_value)): - numpy_like.fillna(other._data, inplace=True, value=fill_value) + numpy_like.fillna(other._data, inplace=True, value=_fill_value) result_data = numpy.empty(len(other._data), dtype=numpy.float64) result_data[:] = numpy.float64(self) + other._data return pandas.Series(result_data, index=other._index, name=other._name) @@ -143,8 +144,8 @@ def _series_add_scalar_impl(self, other, level=None, fill_value=None, axis=0): def _series_add_none_indexes_impl(self, other, level=None, fill_value=None, axis=0): _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) + 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) @@ -181,8 +182,8 @@ def _series_add_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) + 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) @@ -286,15 +287,16 @@ def sdc_pandas_series_div(self, other, level=None, fill_value=None, axis=0): # specializations for numeric series only if not operands_are_series: def _series_div_scalar_impl(self, other, level=None, fill_value=None, axis=0): + _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa if self_is_series == True: # 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(self._data, inplace=True, value=_fill_value) result_data = numpy.empty(len(self._data), dtype=numpy.float64) result_data[:] = self._data / numpy.float64(other) return pandas.Series(result_data, index=self._index, name=self._name) else: if not (fill_value is None or numpy.isnan(fill_value)): - numpy_like.fillna(other._data, inplace=True, value=fill_value) + numpy_like.fillna(other._data, inplace=True, value=_fill_value) result_data = numpy.empty(len(other._data), dtype=numpy.float64) result_data[:] = numpy.float64(self) / other._data return pandas.Series(result_data, index=other._index, name=other._name) @@ -307,8 +309,8 @@ def _series_div_scalar_impl(self, other, level=None, fill_value=None, axis=0): def _series_div_none_indexes_impl(self, other, level=None, fill_value=None, axis=0): _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) + 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) @@ -345,8 +347,8 @@ def _series_div_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) + 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) @@ -450,15 +452,16 @@ def sdc_pandas_series_sub(self, other, level=None, fill_value=None, axis=0): # specializations for numeric series only if not operands_are_series: def _series_sub_scalar_impl(self, other, level=None, fill_value=None, axis=0): + _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa if self_is_series == True: # 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(self._data, inplace=True, value=_fill_value) result_data = numpy.empty(len(self._data), dtype=numpy.float64) result_data[:] = self._data - numpy.float64(other) return pandas.Series(result_data, index=self._index, name=self._name) else: if not (fill_value is None or numpy.isnan(fill_value)): - numpy_like.fillna(other._data, inplace=True, value=fill_value) + numpy_like.fillna(other._data, inplace=True, value=_fill_value) result_data = numpy.empty(len(other._data), dtype=numpy.float64) result_data[:] = numpy.float64(self) - other._data return pandas.Series(result_data, index=other._index, name=other._name) @@ -471,8 +474,8 @@ def _series_sub_scalar_impl(self, other, level=None, fill_value=None, axis=0): def _series_sub_none_indexes_impl(self, other, level=None, fill_value=None, axis=0): _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) + 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) @@ -509,8 +512,8 @@ def _series_sub_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) + 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) @@ -614,15 +617,16 @@ def sdc_pandas_series_mul(self, other, level=None, fill_value=None, axis=0): # specializations for numeric series only if not operands_are_series: def _series_mul_scalar_impl(self, other, level=None, fill_value=None, axis=0): + _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa if self_is_series == True: # 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(self._data, inplace=True, value=_fill_value) result_data = numpy.empty(len(self._data), dtype=numpy.float64) result_data[:] = self._data * numpy.float64(other) return pandas.Series(result_data, index=self._index, name=self._name) else: if not (fill_value is None or numpy.isnan(fill_value)): - numpy_like.fillna(other._data, inplace=True, value=fill_value) + numpy_like.fillna(other._data, inplace=True, value=_fill_value) result_data = numpy.empty(len(other._data), dtype=numpy.float64) result_data[:] = numpy.float64(self) * other._data return pandas.Series(result_data, index=other._index, name=other._name) @@ -635,8 +639,8 @@ def _series_mul_scalar_impl(self, other, level=None, fill_value=None, axis=0): def _series_mul_none_indexes_impl(self, other, level=None, fill_value=None, axis=0): _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) + 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) @@ -673,8 +677,8 @@ def _series_mul_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) + 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) @@ -778,15 +782,16 @@ def sdc_pandas_series_truediv(self, other, level=None, fill_value=None, axis=0): # specializations for numeric series only if not operands_are_series: def _series_truediv_scalar_impl(self, other, level=None, fill_value=None, axis=0): + _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa if self_is_series == True: # 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(self._data, inplace=True, value=_fill_value) result_data = numpy.empty(len(self._data), dtype=numpy.float64) result_data[:] = self._data / numpy.float64(other) return pandas.Series(result_data, index=self._index, name=self._name) else: if not (fill_value is None or numpy.isnan(fill_value)): - numpy_like.fillna(other._data, inplace=True, value=fill_value) + numpy_like.fillna(other._data, inplace=True, value=_fill_value) result_data = numpy.empty(len(other._data), dtype=numpy.float64) result_data[:] = numpy.float64(self) / other._data return pandas.Series(result_data, index=other._index, name=other._name) @@ -799,8 +804,8 @@ def _series_truediv_scalar_impl(self, other, level=None, fill_value=None, axis=0 def _series_truediv_none_indexes_impl(self, other, level=None, fill_value=None, axis=0): _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) + 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) @@ -837,8 +842,8 @@ def _series_truediv_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) + 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) @@ -942,15 +947,16 @@ def sdc_pandas_series_floordiv(self, other, level=None, fill_value=None, axis=0) # specializations for numeric series only if not operands_are_series: def _series_floordiv_scalar_impl(self, other, level=None, fill_value=None, axis=0): + _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa if self_is_series == True: # 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(self._data, inplace=True, value=_fill_value) result_data = numpy.empty(len(self._data), dtype=numpy.float64) result_data[:] = self._data // numpy.float64(other) return pandas.Series(result_data, index=self._index, name=self._name) else: if not (fill_value is None or numpy.isnan(fill_value)): - numpy_like.fillna(other._data, inplace=True, value=fill_value) + numpy_like.fillna(other._data, inplace=True, value=_fill_value) result_data = numpy.empty(len(other._data), dtype=numpy.float64) result_data[:] = numpy.float64(self) // other._data return pandas.Series(result_data, index=other._index, name=other._name) @@ -963,8 +969,8 @@ def _series_floordiv_scalar_impl(self, other, level=None, fill_value=None, axis= def _series_floordiv_none_indexes_impl(self, other, level=None, fill_value=None, axis=0): _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) + 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) @@ -1001,8 +1007,8 @@ def _series_floordiv_common_impl(self, other, level=None, fill_value=None, axis= 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) + 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) @@ -1106,15 +1112,16 @@ def sdc_pandas_series_mod(self, other, level=None, fill_value=None, axis=0): # specializations for numeric series only if not operands_are_series: def _series_mod_scalar_impl(self, other, level=None, fill_value=None, axis=0): + _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa if self_is_series == True: # 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(self._data, inplace=True, value=_fill_value) result_data = numpy.empty(len(self._data), dtype=numpy.float64) result_data[:] = self._data % numpy.float64(other) return pandas.Series(result_data, index=self._index, name=self._name) else: if not (fill_value is None or numpy.isnan(fill_value)): - numpy_like.fillna(other._data, inplace=True, value=fill_value) + numpy_like.fillna(other._data, inplace=True, value=_fill_value) result_data = numpy.empty(len(other._data), dtype=numpy.float64) result_data[:] = numpy.float64(self) % other._data return pandas.Series(result_data, index=other._index, name=other._name) @@ -1127,8 +1134,8 @@ def _series_mod_scalar_impl(self, other, level=None, fill_value=None, axis=0): def _series_mod_none_indexes_impl(self, other, level=None, fill_value=None, axis=0): _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) + 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) @@ -1165,8 +1172,8 @@ def _series_mod_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) + 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) @@ -1270,15 +1277,16 @@ def sdc_pandas_series_pow(self, other, level=None, fill_value=None, axis=0): # specializations for numeric series only if not operands_are_series: def _series_pow_scalar_impl(self, other, level=None, fill_value=None, axis=0): + _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa if self_is_series == True: # 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(self._data, inplace=True, value=_fill_value) result_data = numpy.empty(len(self._data), dtype=numpy.float64) result_data[:] = self._data ** numpy.float64(other) return pandas.Series(result_data, index=self._index, name=self._name) else: if not (fill_value is None or numpy.isnan(fill_value)): - numpy_like.fillna(other._data, inplace=True, value=fill_value) + numpy_like.fillna(other._data, inplace=True, value=_fill_value) result_data = numpy.empty(len(other._data), dtype=numpy.float64) result_data[:] = numpy.float64(self) ** other._data return pandas.Series(result_data, index=other._index, name=other._name) @@ -1291,8 +1299,8 @@ def _series_pow_scalar_impl(self, other, level=None, fill_value=None, axis=0): def _series_pow_none_indexes_impl(self, other, level=None, fill_value=None, axis=0): _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) + 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) @@ -1329,8 +1337,8 @@ def _series_pow_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) + 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) @@ -1432,13 +1440,14 @@ def sdc_pandas_series_lt(self, other, level=None, fill_value=None, axis=0): fill_value_is_none = isinstance(fill_value, (types.NoneType, types.Omitted)) or fill_value is None if not operands_are_series: def _series_lt_scalar_impl(self, other, level=None, fill_value=None, axis=0): + _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa if self_is_series == True: # 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(self._data, inplace=True, value=_fill_value) return pandas.Series(self._data < other, index=self._index, name=self._name) else: if not (fill_value is None or numpy.isnan(fill_value)): - numpy_like.fillna(other._data, inplace=True, value=fill_value) + numpy_like.fillna(other._data, inplace=True, value=_fill_value) return pandas.Series(self < other._data, index=other._index, name=other._name) return _series_lt_scalar_impl @@ -1448,9 +1457,10 @@ def _series_lt_scalar_impl(self, other, level=None, fill_value=None, axis=0): # 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_lt_none_indexes_impl(self, other, level=None, fill_value=None, axis=0): + _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) + 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) @@ -1467,9 +1477,10 @@ def _series_lt_none_indexes_impl(self, other, level=None, fill_value=None, axis= [ty_left_index_dtype, ty_right_index_dtype], []) def _series_lt_common_impl(self, other, level=None, fill_value=None, axis=0): + _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) + 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): @@ -1559,13 +1570,14 @@ def sdc_pandas_series_gt(self, other, level=None, fill_value=None, axis=0): fill_value_is_none = isinstance(fill_value, (types.NoneType, types.Omitted)) or fill_value is None if not operands_are_series: def _series_gt_scalar_impl(self, other, level=None, fill_value=None, axis=0): + _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa if self_is_series == True: # 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(self._data, inplace=True, value=_fill_value) return pandas.Series(self._data > other, index=self._index, name=self._name) else: if not (fill_value is None or numpy.isnan(fill_value)): - numpy_like.fillna(other._data, inplace=True, value=fill_value) + numpy_like.fillna(other._data, inplace=True, value=_fill_value) return pandas.Series(self > other._data, index=other._index, name=other._name) return _series_gt_scalar_impl @@ -1575,9 +1587,10 @@ def _series_gt_scalar_impl(self, other, level=None, fill_value=None, axis=0): # 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_gt_none_indexes_impl(self, other, level=None, fill_value=None, axis=0): + _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) + 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) @@ -1594,9 +1607,10 @@ def _series_gt_none_indexes_impl(self, other, level=None, fill_value=None, axis= [ty_left_index_dtype, ty_right_index_dtype], []) def _series_gt_common_impl(self, other, level=None, fill_value=None, axis=0): + _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) + 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): @@ -1686,13 +1700,14 @@ def sdc_pandas_series_le(self, other, level=None, fill_value=None, axis=0): fill_value_is_none = isinstance(fill_value, (types.NoneType, types.Omitted)) or fill_value is None if not operands_are_series: def _series_le_scalar_impl(self, other, level=None, fill_value=None, axis=0): + _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa if self_is_series == True: # 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(self._data, inplace=True, value=_fill_value) return pandas.Series(self._data <= other, index=self._index, name=self._name) else: if not (fill_value is None or numpy.isnan(fill_value)): - numpy_like.fillna(other._data, inplace=True, value=fill_value) + numpy_like.fillna(other._data, inplace=True, value=_fill_value) return pandas.Series(self <= other._data, index=other._index, name=other._name) return _series_le_scalar_impl @@ -1702,9 +1717,10 @@ def _series_le_scalar_impl(self, other, level=None, fill_value=None, axis=0): # 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_le_none_indexes_impl(self, other, level=None, fill_value=None, axis=0): + _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) + 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) @@ -1721,9 +1737,10 @@ def _series_le_none_indexes_impl(self, other, level=None, fill_value=None, axis= [ty_left_index_dtype, ty_right_index_dtype], []) def _series_le_common_impl(self, other, level=None, fill_value=None, axis=0): + _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) + 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): @@ -1813,13 +1830,14 @@ def sdc_pandas_series_ge(self, other, level=None, fill_value=None, axis=0): fill_value_is_none = isinstance(fill_value, (types.NoneType, types.Omitted)) or fill_value is None if not operands_are_series: def _series_ge_scalar_impl(self, other, level=None, fill_value=None, axis=0): + _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa if self_is_series == True: # 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(self._data, inplace=True, value=_fill_value) return pandas.Series(self._data >= other, index=self._index, name=self._name) else: if not (fill_value is None or numpy.isnan(fill_value)): - numpy_like.fillna(other._data, inplace=True, value=fill_value) + numpy_like.fillna(other._data, inplace=True, value=_fill_value) return pandas.Series(self >= other._data, index=other._index, name=other._name) return _series_ge_scalar_impl @@ -1829,9 +1847,10 @@ def _series_ge_scalar_impl(self, other, level=None, fill_value=None, axis=0): # 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_ge_none_indexes_impl(self, other, level=None, fill_value=None, axis=0): + _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) + 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) @@ -1848,9 +1867,10 @@ def _series_ge_none_indexes_impl(self, other, level=None, fill_value=None, axis= [ty_left_index_dtype, ty_right_index_dtype], []) def _series_ge_common_impl(self, other, level=None, fill_value=None, axis=0): + _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) + 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): @@ -1940,13 +1960,14 @@ def sdc_pandas_series_ne(self, other, level=None, fill_value=None, axis=0): fill_value_is_none = isinstance(fill_value, (types.NoneType, types.Omitted)) or fill_value is None if not operands_are_series: def _series_ne_scalar_impl(self, other, level=None, fill_value=None, axis=0): + _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa if self_is_series == True: # 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(self._data, inplace=True, value=_fill_value) return pandas.Series(self._data != other, index=self._index, name=self._name) else: if not (fill_value is None or numpy.isnan(fill_value)): - numpy_like.fillna(other._data, inplace=True, value=fill_value) + numpy_like.fillna(other._data, inplace=True, value=_fill_value) return pandas.Series(self != other._data, index=other._index, name=other._name) return _series_ne_scalar_impl @@ -1956,9 +1977,10 @@ def _series_ne_scalar_impl(self, other, level=None, fill_value=None, axis=0): # 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_ne_none_indexes_impl(self, other, level=None, fill_value=None, axis=0): + _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) + 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) @@ -1975,9 +1997,10 @@ def _series_ne_none_indexes_impl(self, other, level=None, fill_value=None, axis= [ty_left_index_dtype, ty_right_index_dtype], []) def _series_ne_common_impl(self, other, level=None, fill_value=None, axis=0): + _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) + 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): @@ -2067,13 +2090,14 @@ def sdc_pandas_series_eq(self, other, level=None, fill_value=None, axis=0): fill_value_is_none = isinstance(fill_value, (types.NoneType, types.Omitted)) or fill_value is None if not operands_are_series: def _series_eq_scalar_impl(self, other, level=None, fill_value=None, axis=0): + _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa if self_is_series == True: # 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(self._data, inplace=True, value=_fill_value) return pandas.Series(self._data == other, index=self._index, name=self._name) else: if not (fill_value is None or numpy.isnan(fill_value)): - numpy_like.fillna(other._data, inplace=True, value=fill_value) + numpy_like.fillna(other._data, inplace=True, value=_fill_value) return pandas.Series(self == other._data, index=other._index, name=other._name) return _series_eq_scalar_impl @@ -2083,9 +2107,10 @@ def _series_eq_scalar_impl(self, other, level=None, fill_value=None, axis=0): # 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_eq_none_indexes_impl(self, other, level=None, fill_value=None, axis=0): + _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) + 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) @@ -2102,9 +2127,10 @@ def _series_eq_none_indexes_impl(self, other, level=None, fill_value=None, axis= [ty_left_index_dtype, ty_right_index_dtype], []) def _series_eq_common_impl(self, other, level=None, fill_value=None, axis=0): + _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) + 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): diff --git a/sdc/sdc_function_templates.py b/sdc/sdc_function_templates.py index ba3d7e87b..d7e5c4dad 100644 --- a/sdc/sdc_function_templates.py +++ b/sdc/sdc_function_templates.py @@ -122,15 +122,16 @@ def sdc_pandas_series_binop(self, other, level=None, fill_value=None, axis=0): # specializations for numeric series only if not operands_are_series: def _series_binop_scalar_impl(self, other, level=None, fill_value=None, axis=0): + _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa if self_is_series == True: # 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(self._data, inplace=True, value=_fill_value) result_data = numpy.empty(len(self._data), dtype=numpy.float64) result_data[:] = self._data + numpy.float64(other) return pandas.Series(result_data, index=self._index, name=self._name) else: if not (fill_value is None or numpy.isnan(fill_value)): - numpy_like.fillna(other._data, inplace=True, value=fill_value) + numpy_like.fillna(other._data, inplace=True, value=_fill_value) result_data = numpy.empty(len(other._data), dtype=numpy.float64) result_data[:] = numpy.float64(self) + other._data return pandas.Series(result_data, index=other._index, name=other._name) @@ -143,8 +144,8 @@ def _series_binop_scalar_impl(self, other, level=None, fill_value=None, axis=0): def _series_binop_none_indexes_impl(self, other, level=None, fill_value=None, axis=0): _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) + 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) @@ -181,8 +182,8 @@ 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) + 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) @@ -283,13 +284,14 @@ def sdc_pandas_series_comp_binop(self, other, level=None, fill_value=None, axis= 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): + _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa if self_is_series == True: # 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(self._data, inplace=True, value=_fill_value) return pandas.Series(self._data < other, index=self._index, name=self._name) else: if not (fill_value is None or numpy.isnan(fill_value)): - numpy_like.fillna(other._data, inplace=True, value=fill_value) + 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 @@ -299,9 +301,10 @@ def _series_comp_binop_scalar_impl(self, other, level=None, fill_value=None, axi # 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): + _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) + 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) @@ -318,9 +321,10 @@ def _series_comp_binop_none_indexes_impl(self, other, level=None, fill_value=Non [ty_left_index_dtype, ty_right_index_dtype], []) def _series_comp_binop_common_impl(self, other, level=None, fill_value=None, axis=0): + _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) + 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): From b674bb16c59061185312db875c32b725a9164319 Mon Sep 17 00:00:00 2001 From: Alexey Kozlov <52973316+kozlov-alexey@users.noreply.github.com> Date: Tue, 16 Jun 2020 20:53:03 +0300 Subject: [PATCH 4/5] SAT-2966 - SDC: test_series_operator_lt_str fails on Linux 3.6 (#884) --- sdc/functions/numpy_like.py | 75 ++++--- sdc/sdc_autogenerated.py | 361 ++++++++++++++-------------------- sdc/sdc_function_templates.py | 51 ++--- sdc/tests/test_sdc_numpy.py | 89 +++++++++ 4 files changed, 306 insertions(+), 270 deletions(-) diff --git a/sdc/functions/numpy_like.py b/sdc/functions/numpy_like.py index 3e950cae9..c2c173db4 100644 --- a/sdc/functions/numpy_like.py +++ b/sdc/functions/numpy_like.py @@ -528,26 +528,61 @@ def sdc_fillna_overload(self, inplace=False, value=None): dtype = self.dtype isnan = get_isnan(dtype) + if ( (isinstance(inplace, types.Literal) and inplace.literal_value == True) or # noqa (isinstance(inplace, bool) and inplace == True) # noqa ): + + def sdc_fillna_inplace_noop(self, inplace=False, value=None): + return None + + if isinstance(value, (types.NoneType, types.Omitted)) or value is None: + return sdc_fillna_inplace_noop + if isinstance(dtype, (types.Integer, types.Boolean)): - def sdc_fillna_inplace_int_impl(self, inplace=False, value=None): + return sdc_fillna_inplace_noop + + if isinstance(dtype, types.Float): + def sdc_fillna_inplace_float_impl(self, inplace=False, value=None): + _value = np.nan if value is None else value + length = len(self) + for i in prange(length): + if isnan(self[i]): + self[i] = _value return None - return sdc_fillna_inplace_int_impl + return sdc_fillna_inplace_float_impl - def sdc_fillna_inplace_float_impl(self, inplace=False, value=None): - length = len(self) - for i in prange(length): - if isnan(self[i]): - self[i] = value + if isinstance(dtype, types.UnicodeType): + # TO-DO: not supported, since no generic setitem for StringArray return None - return sdc_fillna_inplace_float_impl - else: + + def sdc_fillna_noop(self, inplace=False, value=None): + return copy(self) + + if isinstance(value, (types.NoneType, types.Omitted)) or value is None: + return sdc_fillna_noop + + if isinstance(dtype, (types.Integer, types.Boolean)): + return sdc_fillna_noop + + if isinstance(dtype, types.Float): + def sdc_fillna_impl(self, inplace=False, value=None): + _value = np.nan if value is None else value + length = len(self) + filled_data = numpy.empty(length, dtype=dtype) + for i in prange(length): + if isnan(self[i]): + filled_data[i] = _value + else: + filled_data[i] = self[i] + return filled_data + + return sdc_fillna_impl + if isinstance(self.dtype, types.UnicodeType): def sdc_fillna_str_impl(self, inplace=False, value=None): n = len(self) @@ -556,9 +591,9 @@ def sdc_fillna_str_impl(self, inplace=False, value=None): for i in prange(n): s = self[i] if sdc.hiframes.api.isna(self, i): - num_chars += len(value) + num_chars += get_utf8_size(value) else: - num_chars += len(s) + num_chars += get_utf8_size(s) filled_data = pre_alloc_string_array(n, num_chars) for i in prange(n): @@ -570,24 +605,6 @@ def sdc_fillna_str_impl(self, inplace=False, value=None): return sdc_fillna_str_impl - if isinstance(dtype, (types.Integer, types.Boolean)): - def sdc_fillna_int_impl(self, inplace=False, value=None): - return copy(self) - - return sdc_fillna_int_impl - - def sdc_fillna_impl(self, inplace=False, value=None): - length = len(self) - filled_data = numpy.empty(length, dtype=dtype) - for i in prange(length): - if isnan(self[i]): - filled_data[i] = value - else: - filled_data[i] = self[i] - return filled_data - - return sdc_fillna_impl - def nanmin(a): pass diff --git a/sdc/sdc_autogenerated.py b/sdc/sdc_autogenerated.py index 965d3636b..9abffdaf0 100644 --- a/sdc/sdc_autogenerated.py +++ b/sdc/sdc_autogenerated.py @@ -79,7 +79,8 @@ def sdc_pandas_series_add(self, other, level=None, fill_value=None, axis=0): Test: python -m sdc.runtests sdc.tests.test_series.TestSeries.test_series_op5 """ - ty_checker = TypeChecker('Method add().') + _func_name = 'Method add().' + ty_checker = TypeChecker(_func_name) self_is_series, other_is_series = isinstance(self, SeriesType), isinstance(other, SeriesType) if not (self_is_series or other_is_series): return None @@ -115,23 +116,20 @@ def sdc_pandas_series_add(self, other, level=None, fill_value=None, axis=0): 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') + fill_value_is_none = isinstance(fill_value, (types.NoneType, types.Omitted)) or fill_value is None if not isinstance(axis, types.Omitted) and axis != 0: ty_checker.raise_exc(axis, 'int', 'axis') - fill_value_is_none = isinstance(fill_value, (types.NoneType, types.Omitted)) or fill_value is None # specializations for numeric series only if not operands_are_series: def _series_add_scalar_impl(self, other, level=None, fill_value=None, axis=0): - _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa if self_is_series == True: # 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(self._data, inplace=True, value=fill_value) result_data = numpy.empty(len(self._data), dtype=numpy.float64) result_data[:] = self._data + numpy.float64(other) return pandas.Series(result_data, index=self._index, name=self._name) else: - if not (fill_value is None or numpy.isnan(fill_value)): - numpy_like.fillna(other._data, inplace=True, value=_fill_value) + numpy_like.fillna(other._data, inplace=True, value=fill_value) result_data = numpy.empty(len(other._data), dtype=numpy.float64) result_data[:] = numpy.float64(self) + other._data return pandas.Series(result_data, index=other._index, name=other._name) @@ -142,10 +140,8 @@ def _series_add_scalar_impl(self, other, level=None, fill_value=None, axis=0): # 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_add_none_indexes_impl(self, other, level=None, fill_value=None, axis=0): - _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) + 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) @@ -156,6 +152,7 @@ def _series_add_none_indexes_impl(self, other, level=None, fill_value=None, axis 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)): @@ -180,10 +177,8 @@ def _series_add_none_indexes_impl(self, other, level=None, fill_value=None, axis def _series_add_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) + 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) @@ -201,6 +196,7 @@ def _series_add_common_impl(self, other, level=None, fill_value=None, axis=0): 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 @@ -244,7 +240,8 @@ def sdc_pandas_series_div(self, other, level=None, fill_value=None, axis=0): Test: python -m sdc.runtests sdc.tests.test_series.TestSeries.test_series_op5 """ - ty_checker = TypeChecker('Method div().') + _func_name = 'Method div().' + ty_checker = TypeChecker(_func_name) self_is_series, other_is_series = isinstance(self, SeriesType), isinstance(other, SeriesType) if not (self_is_series or other_is_series): return None @@ -280,23 +277,20 @@ def sdc_pandas_series_div(self, other, level=None, fill_value=None, axis=0): 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') + fill_value_is_none = isinstance(fill_value, (types.NoneType, types.Omitted)) or fill_value is None if not isinstance(axis, types.Omitted) and axis != 0: ty_checker.raise_exc(axis, 'int', 'axis') - fill_value_is_none = isinstance(fill_value, (types.NoneType, types.Omitted)) or fill_value is None # specializations for numeric series only if not operands_are_series: def _series_div_scalar_impl(self, other, level=None, fill_value=None, axis=0): - _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa if self_is_series == True: # 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(self._data, inplace=True, value=fill_value) result_data = numpy.empty(len(self._data), dtype=numpy.float64) result_data[:] = self._data / numpy.float64(other) return pandas.Series(result_data, index=self._index, name=self._name) else: - if not (fill_value is None or numpy.isnan(fill_value)): - numpy_like.fillna(other._data, inplace=True, value=_fill_value) + numpy_like.fillna(other._data, inplace=True, value=fill_value) result_data = numpy.empty(len(other._data), dtype=numpy.float64) result_data[:] = numpy.float64(self) / other._data return pandas.Series(result_data, index=other._index, name=other._name) @@ -307,10 +301,8 @@ def _series_div_scalar_impl(self, other, level=None, fill_value=None, axis=0): # 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_div_none_indexes_impl(self, other, level=None, fill_value=None, axis=0): - _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) + 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) @@ -321,6 +313,7 @@ def _series_div_none_indexes_impl(self, other, level=None, fill_value=None, axis 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)): @@ -345,10 +338,8 @@ def _series_div_none_indexes_impl(self, other, level=None, fill_value=None, axis def _series_div_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) + 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) @@ -366,6 +357,7 @@ def _series_div_common_impl(self, other, level=None, fill_value=None, axis=0): 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 @@ -409,7 +401,8 @@ def sdc_pandas_series_sub(self, other, level=None, fill_value=None, axis=0): Test: python -m sdc.runtests sdc.tests.test_series.TestSeries.test_series_op5 """ - ty_checker = TypeChecker('Method sub().') + _func_name = 'Method sub().' + ty_checker = TypeChecker(_func_name) self_is_series, other_is_series = isinstance(self, SeriesType), isinstance(other, SeriesType) if not (self_is_series or other_is_series): return None @@ -445,23 +438,20 @@ def sdc_pandas_series_sub(self, other, level=None, fill_value=None, axis=0): 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') + fill_value_is_none = isinstance(fill_value, (types.NoneType, types.Omitted)) or fill_value is None if not isinstance(axis, types.Omitted) and axis != 0: ty_checker.raise_exc(axis, 'int', 'axis') - fill_value_is_none = isinstance(fill_value, (types.NoneType, types.Omitted)) or fill_value is None # specializations for numeric series only if not operands_are_series: def _series_sub_scalar_impl(self, other, level=None, fill_value=None, axis=0): - _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa if self_is_series == True: # 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(self._data, inplace=True, value=fill_value) result_data = numpy.empty(len(self._data), dtype=numpy.float64) result_data[:] = self._data - numpy.float64(other) return pandas.Series(result_data, index=self._index, name=self._name) else: - if not (fill_value is None or numpy.isnan(fill_value)): - numpy_like.fillna(other._data, inplace=True, value=_fill_value) + numpy_like.fillna(other._data, inplace=True, value=fill_value) result_data = numpy.empty(len(other._data), dtype=numpy.float64) result_data[:] = numpy.float64(self) - other._data return pandas.Series(result_data, index=other._index, name=other._name) @@ -472,10 +462,8 @@ def _series_sub_scalar_impl(self, other, level=None, fill_value=None, axis=0): # 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_sub_none_indexes_impl(self, other, level=None, fill_value=None, axis=0): - _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) + 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) @@ -486,6 +474,7 @@ def _series_sub_none_indexes_impl(self, other, level=None, fill_value=None, axis 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)): @@ -510,10 +499,8 @@ def _series_sub_none_indexes_impl(self, other, level=None, fill_value=None, axis def _series_sub_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) + 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) @@ -531,6 +518,7 @@ def _series_sub_common_impl(self, other, level=None, fill_value=None, axis=0): 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 @@ -574,7 +562,8 @@ def sdc_pandas_series_mul(self, other, level=None, fill_value=None, axis=0): Test: python -m sdc.runtests sdc.tests.test_series.TestSeries.test_series_op5 """ - ty_checker = TypeChecker('Method mul().') + _func_name = 'Method mul().' + ty_checker = TypeChecker(_func_name) self_is_series, other_is_series = isinstance(self, SeriesType), isinstance(other, SeriesType) if not (self_is_series or other_is_series): return None @@ -610,23 +599,20 @@ def sdc_pandas_series_mul(self, other, level=None, fill_value=None, axis=0): 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') + fill_value_is_none = isinstance(fill_value, (types.NoneType, types.Omitted)) or fill_value is None if not isinstance(axis, types.Omitted) and axis != 0: ty_checker.raise_exc(axis, 'int', 'axis') - fill_value_is_none = isinstance(fill_value, (types.NoneType, types.Omitted)) or fill_value is None # specializations for numeric series only if not operands_are_series: def _series_mul_scalar_impl(self, other, level=None, fill_value=None, axis=0): - _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa if self_is_series == True: # 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(self._data, inplace=True, value=fill_value) result_data = numpy.empty(len(self._data), dtype=numpy.float64) result_data[:] = self._data * numpy.float64(other) return pandas.Series(result_data, index=self._index, name=self._name) else: - if not (fill_value is None or numpy.isnan(fill_value)): - numpy_like.fillna(other._data, inplace=True, value=_fill_value) + numpy_like.fillna(other._data, inplace=True, value=fill_value) result_data = numpy.empty(len(other._data), dtype=numpy.float64) result_data[:] = numpy.float64(self) * other._data return pandas.Series(result_data, index=other._index, name=other._name) @@ -637,10 +623,8 @@ def _series_mul_scalar_impl(self, other, level=None, fill_value=None, axis=0): # 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_mul_none_indexes_impl(self, other, level=None, fill_value=None, axis=0): - _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) + 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) @@ -651,6 +635,7 @@ def _series_mul_none_indexes_impl(self, other, level=None, fill_value=None, axis 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)): @@ -675,10 +660,8 @@ def _series_mul_none_indexes_impl(self, other, level=None, fill_value=None, axis def _series_mul_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) + 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) @@ -696,6 +679,7 @@ def _series_mul_common_impl(self, other, level=None, fill_value=None, axis=0): 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 @@ -739,7 +723,8 @@ def sdc_pandas_series_truediv(self, other, level=None, fill_value=None, axis=0): Test: python -m sdc.runtests sdc.tests.test_series.TestSeries.test_series_op5 """ - ty_checker = TypeChecker('Method truediv().') + _func_name = 'Method truediv().' + ty_checker = TypeChecker(_func_name) self_is_series, other_is_series = isinstance(self, SeriesType), isinstance(other, SeriesType) if not (self_is_series or other_is_series): return None @@ -775,23 +760,20 @@ def sdc_pandas_series_truediv(self, other, level=None, fill_value=None, axis=0): 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') + fill_value_is_none = isinstance(fill_value, (types.NoneType, types.Omitted)) or fill_value is None if not isinstance(axis, types.Omitted) and axis != 0: ty_checker.raise_exc(axis, 'int', 'axis') - fill_value_is_none = isinstance(fill_value, (types.NoneType, types.Omitted)) or fill_value is None # specializations for numeric series only if not operands_are_series: def _series_truediv_scalar_impl(self, other, level=None, fill_value=None, axis=0): - _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa if self_is_series == True: # 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(self._data, inplace=True, value=fill_value) result_data = numpy.empty(len(self._data), dtype=numpy.float64) result_data[:] = self._data / numpy.float64(other) return pandas.Series(result_data, index=self._index, name=self._name) else: - if not (fill_value is None or numpy.isnan(fill_value)): - numpy_like.fillna(other._data, inplace=True, value=_fill_value) + numpy_like.fillna(other._data, inplace=True, value=fill_value) result_data = numpy.empty(len(other._data), dtype=numpy.float64) result_data[:] = numpy.float64(self) / other._data return pandas.Series(result_data, index=other._index, name=other._name) @@ -802,10 +784,8 @@ def _series_truediv_scalar_impl(self, other, level=None, fill_value=None, axis=0 # 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_truediv_none_indexes_impl(self, other, level=None, fill_value=None, axis=0): - _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) + 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) @@ -816,6 +796,7 @@ def _series_truediv_none_indexes_impl(self, other, level=None, fill_value=None, 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)): @@ -840,10 +821,8 @@ def _series_truediv_none_indexes_impl(self, other, level=None, fill_value=None, def _series_truediv_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) + 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) @@ -861,6 +840,7 @@ def _series_truediv_common_impl(self, other, level=None, fill_value=None, axis=0 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 @@ -904,7 +884,8 @@ def sdc_pandas_series_floordiv(self, other, level=None, fill_value=None, axis=0) Test: python -m sdc.runtests sdc.tests.test_series.TestSeries.test_series_op5 """ - ty_checker = TypeChecker('Method floordiv().') + _func_name = 'Method floordiv().' + ty_checker = TypeChecker(_func_name) self_is_series, other_is_series = isinstance(self, SeriesType), isinstance(other, SeriesType) if not (self_is_series or other_is_series): return None @@ -940,23 +921,20 @@ def sdc_pandas_series_floordiv(self, other, level=None, fill_value=None, axis=0) 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') + fill_value_is_none = isinstance(fill_value, (types.NoneType, types.Omitted)) or fill_value is None if not isinstance(axis, types.Omitted) and axis != 0: ty_checker.raise_exc(axis, 'int', 'axis') - fill_value_is_none = isinstance(fill_value, (types.NoneType, types.Omitted)) or fill_value is None # specializations for numeric series only if not operands_are_series: def _series_floordiv_scalar_impl(self, other, level=None, fill_value=None, axis=0): - _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa if self_is_series == True: # 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(self._data, inplace=True, value=fill_value) result_data = numpy.empty(len(self._data), dtype=numpy.float64) result_data[:] = self._data // numpy.float64(other) return pandas.Series(result_data, index=self._index, name=self._name) else: - if not (fill_value is None or numpy.isnan(fill_value)): - numpy_like.fillna(other._data, inplace=True, value=_fill_value) + numpy_like.fillna(other._data, inplace=True, value=fill_value) result_data = numpy.empty(len(other._data), dtype=numpy.float64) result_data[:] = numpy.float64(self) // other._data return pandas.Series(result_data, index=other._index, name=other._name) @@ -967,10 +945,8 @@ def _series_floordiv_scalar_impl(self, other, level=None, fill_value=None, axis= # 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_floordiv_none_indexes_impl(self, other, level=None, fill_value=None, axis=0): - _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) + 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) @@ -981,6 +957,7 @@ def _series_floordiv_none_indexes_impl(self, other, level=None, fill_value=None, 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)): @@ -1005,10 +982,8 @@ def _series_floordiv_none_indexes_impl(self, other, level=None, fill_value=None, def _series_floordiv_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) + 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) @@ -1026,6 +1001,7 @@ def _series_floordiv_common_impl(self, other, level=None, fill_value=None, axis= 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 @@ -1069,7 +1045,8 @@ def sdc_pandas_series_mod(self, other, level=None, fill_value=None, axis=0): Test: python -m sdc.runtests sdc.tests.test_series.TestSeries.test_series_op5 """ - ty_checker = TypeChecker('Method mod().') + _func_name = 'Method mod().' + ty_checker = TypeChecker(_func_name) self_is_series, other_is_series = isinstance(self, SeriesType), isinstance(other, SeriesType) if not (self_is_series or other_is_series): return None @@ -1105,23 +1082,20 @@ def sdc_pandas_series_mod(self, other, level=None, fill_value=None, axis=0): 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') + fill_value_is_none = isinstance(fill_value, (types.NoneType, types.Omitted)) or fill_value is None if not isinstance(axis, types.Omitted) and axis != 0: ty_checker.raise_exc(axis, 'int', 'axis') - fill_value_is_none = isinstance(fill_value, (types.NoneType, types.Omitted)) or fill_value is None # specializations for numeric series only if not operands_are_series: def _series_mod_scalar_impl(self, other, level=None, fill_value=None, axis=0): - _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa if self_is_series == True: # 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(self._data, inplace=True, value=fill_value) result_data = numpy.empty(len(self._data), dtype=numpy.float64) result_data[:] = self._data % numpy.float64(other) return pandas.Series(result_data, index=self._index, name=self._name) else: - if not (fill_value is None or numpy.isnan(fill_value)): - numpy_like.fillna(other._data, inplace=True, value=_fill_value) + numpy_like.fillna(other._data, inplace=True, value=fill_value) result_data = numpy.empty(len(other._data), dtype=numpy.float64) result_data[:] = numpy.float64(self) % other._data return pandas.Series(result_data, index=other._index, name=other._name) @@ -1132,10 +1106,8 @@ def _series_mod_scalar_impl(self, other, level=None, fill_value=None, axis=0): # 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_mod_none_indexes_impl(self, other, level=None, fill_value=None, axis=0): - _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) + 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) @@ -1146,6 +1118,7 @@ def _series_mod_none_indexes_impl(self, other, level=None, fill_value=None, axis 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)): @@ -1170,10 +1143,8 @@ def _series_mod_none_indexes_impl(self, other, level=None, fill_value=None, axis def _series_mod_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) + 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) @@ -1191,6 +1162,7 @@ def _series_mod_common_impl(self, other, level=None, fill_value=None, axis=0): 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 @@ -1234,7 +1206,8 @@ def sdc_pandas_series_pow(self, other, level=None, fill_value=None, axis=0): Test: python -m sdc.runtests sdc.tests.test_series.TestSeries.test_series_op5 """ - ty_checker = TypeChecker('Method pow().') + _func_name = 'Method pow().' + ty_checker = TypeChecker(_func_name) self_is_series, other_is_series = isinstance(self, SeriesType), isinstance(other, SeriesType) if not (self_is_series or other_is_series): return None @@ -1270,23 +1243,20 @@ def sdc_pandas_series_pow(self, other, level=None, fill_value=None, axis=0): 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') + fill_value_is_none = isinstance(fill_value, (types.NoneType, types.Omitted)) or fill_value is None if not isinstance(axis, types.Omitted) and axis != 0: ty_checker.raise_exc(axis, 'int', 'axis') - fill_value_is_none = isinstance(fill_value, (types.NoneType, types.Omitted)) or fill_value is None # specializations for numeric series only if not operands_are_series: def _series_pow_scalar_impl(self, other, level=None, fill_value=None, axis=0): - _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa if self_is_series == True: # 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(self._data, inplace=True, value=fill_value) result_data = numpy.empty(len(self._data), dtype=numpy.float64) result_data[:] = self._data ** numpy.float64(other) return pandas.Series(result_data, index=self._index, name=self._name) else: - if not (fill_value is None or numpy.isnan(fill_value)): - numpy_like.fillna(other._data, inplace=True, value=_fill_value) + numpy_like.fillna(other._data, inplace=True, value=fill_value) result_data = numpy.empty(len(other._data), dtype=numpy.float64) result_data[:] = numpy.float64(self) ** other._data return pandas.Series(result_data, index=other._index, name=other._name) @@ -1297,10 +1267,8 @@ def _series_pow_scalar_impl(self, other, level=None, fill_value=None, axis=0): # 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_pow_none_indexes_impl(self, other, level=None, fill_value=None, axis=0): - _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) + 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) @@ -1311,6 +1279,7 @@ def _series_pow_none_indexes_impl(self, other, level=None, fill_value=None, axis 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)): @@ -1335,10 +1304,8 @@ def _series_pow_none_indexes_impl(self, other, level=None, fill_value=None, axis def _series_pow_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) + 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) @@ -1356,6 +1323,7 @@ def _series_pow_common_impl(self, other, level=None, fill_value=None, axis=0): 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 @@ -1440,14 +1408,11 @@ def sdc_pandas_series_lt(self, other, level=None, fill_value=None, axis=0): fill_value_is_none = isinstance(fill_value, (types.NoneType, types.Omitted)) or fill_value is None if not operands_are_series: def _series_lt_scalar_impl(self, other, level=None, fill_value=None, axis=0): - _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa if self_is_series == True: # 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(self._data, inplace=True, value=fill_value) return pandas.Series(self._data < other, index=self._index, name=self._name) else: - if not (fill_value is None or numpy.isnan(fill_value)): - numpy_like.fillna(other._data, inplace=True, value=_fill_value) + numpy_like.fillna(other._data, inplace=True, value=fill_value) return pandas.Series(self < other._data, index=other._index, name=other._name) return _series_lt_scalar_impl @@ -1457,10 +1422,8 @@ def _series_lt_scalar_impl(self, other, level=None, fill_value=None, axis=0): # 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_lt_none_indexes_impl(self, other, level=None, fill_value=None, axis=0): - _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) + 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) @@ -1477,10 +1440,8 @@ def _series_lt_none_indexes_impl(self, other, level=None, fill_value=None, axis= [ty_left_index_dtype, ty_right_index_dtype], []) def _series_lt_common_impl(self, other, level=None, fill_value=None, axis=0): - _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) + 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): @@ -1570,14 +1531,11 @@ def sdc_pandas_series_gt(self, other, level=None, fill_value=None, axis=0): fill_value_is_none = isinstance(fill_value, (types.NoneType, types.Omitted)) or fill_value is None if not operands_are_series: def _series_gt_scalar_impl(self, other, level=None, fill_value=None, axis=0): - _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa if self_is_series == True: # 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(self._data, inplace=True, value=fill_value) return pandas.Series(self._data > other, index=self._index, name=self._name) else: - if not (fill_value is None or numpy.isnan(fill_value)): - numpy_like.fillna(other._data, inplace=True, value=_fill_value) + numpy_like.fillna(other._data, inplace=True, value=fill_value) return pandas.Series(self > other._data, index=other._index, name=other._name) return _series_gt_scalar_impl @@ -1587,10 +1545,8 @@ def _series_gt_scalar_impl(self, other, level=None, fill_value=None, axis=0): # 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_gt_none_indexes_impl(self, other, level=None, fill_value=None, axis=0): - _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) + 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) @@ -1607,10 +1563,8 @@ def _series_gt_none_indexes_impl(self, other, level=None, fill_value=None, axis= [ty_left_index_dtype, ty_right_index_dtype], []) def _series_gt_common_impl(self, other, level=None, fill_value=None, axis=0): - _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) + 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): @@ -1700,14 +1654,11 @@ def sdc_pandas_series_le(self, other, level=None, fill_value=None, axis=0): fill_value_is_none = isinstance(fill_value, (types.NoneType, types.Omitted)) or fill_value is None if not operands_are_series: def _series_le_scalar_impl(self, other, level=None, fill_value=None, axis=0): - _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa if self_is_series == True: # 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(self._data, inplace=True, value=fill_value) return pandas.Series(self._data <= other, index=self._index, name=self._name) else: - if not (fill_value is None or numpy.isnan(fill_value)): - numpy_like.fillna(other._data, inplace=True, value=_fill_value) + numpy_like.fillna(other._data, inplace=True, value=fill_value) return pandas.Series(self <= other._data, index=other._index, name=other._name) return _series_le_scalar_impl @@ -1717,10 +1668,8 @@ def _series_le_scalar_impl(self, other, level=None, fill_value=None, axis=0): # 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_le_none_indexes_impl(self, other, level=None, fill_value=None, axis=0): - _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) + 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) @@ -1737,10 +1686,8 @@ def _series_le_none_indexes_impl(self, other, level=None, fill_value=None, axis= [ty_left_index_dtype, ty_right_index_dtype], []) def _series_le_common_impl(self, other, level=None, fill_value=None, axis=0): - _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) + 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): @@ -1830,14 +1777,11 @@ def sdc_pandas_series_ge(self, other, level=None, fill_value=None, axis=0): fill_value_is_none = isinstance(fill_value, (types.NoneType, types.Omitted)) or fill_value is None if not operands_are_series: def _series_ge_scalar_impl(self, other, level=None, fill_value=None, axis=0): - _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa if self_is_series == True: # 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(self._data, inplace=True, value=fill_value) return pandas.Series(self._data >= other, index=self._index, name=self._name) else: - if not (fill_value is None or numpy.isnan(fill_value)): - numpy_like.fillna(other._data, inplace=True, value=_fill_value) + numpy_like.fillna(other._data, inplace=True, value=fill_value) return pandas.Series(self >= other._data, index=other._index, name=other._name) return _series_ge_scalar_impl @@ -1847,10 +1791,8 @@ def _series_ge_scalar_impl(self, other, level=None, fill_value=None, axis=0): # 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_ge_none_indexes_impl(self, other, level=None, fill_value=None, axis=0): - _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) + 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) @@ -1867,10 +1809,8 @@ def _series_ge_none_indexes_impl(self, other, level=None, fill_value=None, axis= [ty_left_index_dtype, ty_right_index_dtype], []) def _series_ge_common_impl(self, other, level=None, fill_value=None, axis=0): - _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) + 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): @@ -1960,14 +1900,11 @@ def sdc_pandas_series_ne(self, other, level=None, fill_value=None, axis=0): fill_value_is_none = isinstance(fill_value, (types.NoneType, types.Omitted)) or fill_value is None if not operands_are_series: def _series_ne_scalar_impl(self, other, level=None, fill_value=None, axis=0): - _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa if self_is_series == True: # 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(self._data, inplace=True, value=fill_value) return pandas.Series(self._data != other, index=self._index, name=self._name) else: - if not (fill_value is None or numpy.isnan(fill_value)): - numpy_like.fillna(other._data, inplace=True, value=_fill_value) + numpy_like.fillna(other._data, inplace=True, value=fill_value) return pandas.Series(self != other._data, index=other._index, name=other._name) return _series_ne_scalar_impl @@ -1977,10 +1914,8 @@ def _series_ne_scalar_impl(self, other, level=None, fill_value=None, axis=0): # 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_ne_none_indexes_impl(self, other, level=None, fill_value=None, axis=0): - _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) + 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) @@ -1997,10 +1932,8 @@ def _series_ne_none_indexes_impl(self, other, level=None, fill_value=None, axis= [ty_left_index_dtype, ty_right_index_dtype], []) def _series_ne_common_impl(self, other, level=None, fill_value=None, axis=0): - _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) + 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): @@ -2090,14 +2023,11 @@ def sdc_pandas_series_eq(self, other, level=None, fill_value=None, axis=0): fill_value_is_none = isinstance(fill_value, (types.NoneType, types.Omitted)) or fill_value is None if not operands_are_series: def _series_eq_scalar_impl(self, other, level=None, fill_value=None, axis=0): - _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa if self_is_series == True: # 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(self._data, inplace=True, value=fill_value) return pandas.Series(self._data == other, index=self._index, name=self._name) else: - if not (fill_value is None or numpy.isnan(fill_value)): - numpy_like.fillna(other._data, inplace=True, value=_fill_value) + numpy_like.fillna(other._data, inplace=True, value=fill_value) return pandas.Series(self == other._data, index=other._index, name=other._name) return _series_eq_scalar_impl @@ -2107,10 +2037,8 @@ def _series_eq_scalar_impl(self, other, level=None, fill_value=None, axis=0): # 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_eq_none_indexes_impl(self, other, level=None, fill_value=None, axis=0): - _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) + 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) @@ -2127,10 +2055,8 @@ def _series_eq_none_indexes_impl(self, other, level=None, fill_value=None, axis= [ty_left_index_dtype, ty_right_index_dtype], []) def _series_eq_common_impl(self, other, level=None, fill_value=None, axis=0): - _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) + 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): @@ -2175,7 +2101,8 @@ def sdc_pandas_series_operator_add(self, other): The result of the operation """ - ty_checker = TypeChecker('Operator add().') + _func_name = 'Operator add().' + ty_checker = TypeChecker(_func_name) self_is_series, other_is_series = isinstance(self, SeriesType), isinstance(other, SeriesType) if not (self_is_series or other_is_series): return None @@ -2239,7 +2166,8 @@ def sdc_pandas_series_operator_sub(self, other): The result of the operation """ - ty_checker = TypeChecker('Operator sub().') + _func_name = 'Operator sub().' + ty_checker = TypeChecker(_func_name) self_is_series, other_is_series = isinstance(self, SeriesType), isinstance(other, SeriesType) if not (self_is_series or other_is_series): return None @@ -2303,7 +2231,8 @@ def sdc_pandas_series_operator_mul(self, other): The result of the operation """ - ty_checker = TypeChecker('Operator mul().') + _func_name = 'Operator mul().' + ty_checker = TypeChecker(_func_name) self_is_series, other_is_series = isinstance(self, SeriesType), isinstance(other, SeriesType) if not (self_is_series or other_is_series): return None @@ -2367,7 +2296,8 @@ def sdc_pandas_series_operator_truediv(self, other): The result of the operation """ - ty_checker = TypeChecker('Operator truediv().') + _func_name = 'Operator truediv().' + ty_checker = TypeChecker(_func_name) self_is_series, other_is_series = isinstance(self, SeriesType), isinstance(other, SeriesType) if not (self_is_series or other_is_series): return None @@ -2431,7 +2361,8 @@ def sdc_pandas_series_operator_floordiv(self, other): The result of the operation """ - ty_checker = TypeChecker('Operator floordiv().') + _func_name = 'Operator floordiv().' + ty_checker = TypeChecker(_func_name) self_is_series, other_is_series = isinstance(self, SeriesType), isinstance(other, SeriesType) if not (self_is_series or other_is_series): return None @@ -2495,7 +2426,8 @@ def sdc_pandas_series_operator_mod(self, other): The result of the operation """ - ty_checker = TypeChecker('Operator mod().') + _func_name = 'Operator mod().' + ty_checker = TypeChecker(_func_name) self_is_series, other_is_series = isinstance(self, SeriesType), isinstance(other, SeriesType) if not (self_is_series or other_is_series): return None @@ -2559,7 +2491,8 @@ def sdc_pandas_series_operator_pow(self, other): The result of the operation """ - ty_checker = TypeChecker('Operator pow().') + _func_name = 'Operator pow().' + ty_checker = TypeChecker(_func_name) self_is_series, other_is_series = isinstance(self, SeriesType), isinstance(other, SeriesType) if not (self_is_series or other_is_series): return None @@ -2619,7 +2552,8 @@ def sdc_pandas_series_operator_lt(self, other): The result of the operation """ - ty_checker = TypeChecker('Operator lt().') + _func_name = 'Operator lt().' + ty_checker = TypeChecker(_func_name) self_is_series, other_is_series = isinstance(self, SeriesType), isinstance(other, SeriesType) if not (self_is_series or other_is_series): return None @@ -2673,7 +2607,8 @@ def sdc_pandas_series_operator_gt(self, other): The result of the operation """ - ty_checker = TypeChecker('Operator gt().') + _func_name = 'Operator gt().' + ty_checker = TypeChecker(_func_name) self_is_series, other_is_series = isinstance(self, SeriesType), isinstance(other, SeriesType) if not (self_is_series or other_is_series): return None @@ -2727,7 +2662,8 @@ def sdc_pandas_series_operator_le(self, other): The result of the operation """ - ty_checker = TypeChecker('Operator le().') + _func_name = 'Operator le().' + ty_checker = TypeChecker(_func_name) self_is_series, other_is_series = isinstance(self, SeriesType), isinstance(other, SeriesType) if not (self_is_series or other_is_series): return None @@ -2781,7 +2717,8 @@ def sdc_pandas_series_operator_ge(self, other): The result of the operation """ - ty_checker = TypeChecker('Operator ge().') + _func_name = 'Operator ge().' + ty_checker = TypeChecker(_func_name) self_is_series, other_is_series = isinstance(self, SeriesType), isinstance(other, SeriesType) if not (self_is_series or other_is_series): return None @@ -2835,7 +2772,8 @@ def sdc_pandas_series_operator_ne(self, other): The result of the operation """ - ty_checker = TypeChecker('Operator ne().') + _func_name = 'Operator ne().' + ty_checker = TypeChecker(_func_name) self_is_series, other_is_series = isinstance(self, SeriesType), isinstance(other, SeriesType) if not (self_is_series or other_is_series): return None @@ -2889,7 +2827,8 @@ def sdc_pandas_series_operator_eq(self, other): The result of the operation """ - ty_checker = TypeChecker('Operator eq().') + _func_name = 'Operator eq().' + ty_checker = TypeChecker(_func_name) self_is_series, other_is_series = isinstance(self, SeriesType), isinstance(other, SeriesType) if not (self_is_series or other_is_series): return None diff --git a/sdc/sdc_function_templates.py b/sdc/sdc_function_templates.py index d7e5c4dad..7f049c631 100644 --- a/sdc/sdc_function_templates.py +++ b/sdc/sdc_function_templates.py @@ -79,7 +79,8 @@ def sdc_pandas_series_binop(self, other, level=None, fill_value=None, axis=0): Test: python -m sdc.runtests sdc.tests.test_series.TestSeries.test_series_op5 """ - ty_checker = TypeChecker('Method binop().') + _func_name = 'Method binop().' + ty_checker = TypeChecker(_func_name) self_is_series, other_is_series = isinstance(self, SeriesType), isinstance(other, SeriesType) if not (self_is_series or other_is_series): return None @@ -115,23 +116,20 @@ def sdc_pandas_series_binop(self, other, level=None, fill_value=None, axis=0): 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') + fill_value_is_none = isinstance(fill_value, (types.NoneType, types.Omitted)) or fill_value is None if not isinstance(axis, types.Omitted) and axis != 0: ty_checker.raise_exc(axis, 'int', 'axis') - fill_value_is_none = isinstance(fill_value, (types.NoneType, types.Omitted)) or fill_value is None # specializations for numeric series only if not operands_are_series: def _series_binop_scalar_impl(self, other, level=None, fill_value=None, axis=0): - _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa if self_is_series == True: # 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(self._data, inplace=True, value=fill_value) result_data = numpy.empty(len(self._data), dtype=numpy.float64) result_data[:] = self._data + numpy.float64(other) return pandas.Series(result_data, index=self._index, name=self._name) else: - if not (fill_value is None or numpy.isnan(fill_value)): - numpy_like.fillna(other._data, inplace=True, value=_fill_value) + numpy_like.fillna(other._data, inplace=True, value=fill_value) result_data = numpy.empty(len(other._data), dtype=numpy.float64) result_data[:] = numpy.float64(self) + other._data return pandas.Series(result_data, index=other._index, name=other._name) @@ -142,10 +140,8 @@ def _series_binop_scalar_impl(self, other, level=None, fill_value=None, axis=0): # 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_binop_none_indexes_impl(self, other, level=None, fill_value=None, axis=0): - _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) + 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) @@ -156,6 +152,7 @@ def _series_binop_none_indexes_impl(self, other, level=None, fill_value=None, ax 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)): @@ -180,10 +177,8 @@ def _series_binop_none_indexes_impl(self, other, level=None, fill_value=None, ax 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) + 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) @@ -201,6 +196,7 @@ def _series_binop_common_impl(self, other, level=None, fill_value=None, axis=0): 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 @@ -284,14 +280,11 @@ def sdc_pandas_series_comp_binop(self, other, level=None, fill_value=None, axis= 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): - _fill_value = numpy.nan if fill_value_is_none == True else fill_value # noqa if self_is_series == True: # 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(self._data, inplace=True, value=fill_value) return pandas.Series(self._data < other, index=self._index, name=self._name) else: - if not (fill_value is None or numpy.isnan(fill_value)): - numpy_like.fillna(other._data, inplace=True, value=_fill_value) + 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 @@ -301,10 +294,8 @@ def _series_comp_binop_scalar_impl(self, other, level=None, fill_value=None, axi # 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): - _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) + 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) @@ -321,10 +312,8 @@ def _series_comp_binop_none_indexes_impl(self, other, level=None, fill_value=Non [ty_left_index_dtype, ty_right_index_dtype], []) def _series_comp_binop_common_impl(self, other, level=None, fill_value=None, axis=0): - _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) + 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): @@ -368,7 +357,8 @@ def sdc_pandas_series_operator_binop(self, other): The result of the operation """ - ty_checker = TypeChecker('Operator binop().') + _func_name = 'Operator binop().' + ty_checker = TypeChecker(_func_name) self_is_series, other_is_series = isinstance(self, SeriesType), isinstance(other, SeriesType) if not (self_is_series or other_is_series): return None @@ -427,7 +417,8 @@ def sdc_pandas_series_operator_comp_binop(self, other): The result of the operation """ - ty_checker = TypeChecker('Operator comp_binop().') + _func_name = 'Operator comp_binop().' + ty_checker = TypeChecker(_func_name) self_is_series, other_is_series = isinstance(self, SeriesType), isinstance(other, SeriesType) if not (self_is_series or other_is_series): return None diff --git a/sdc/tests/test_sdc_numpy.py b/sdc/tests/test_sdc_numpy.py index 3646c5a39..cf1ef3985 100644 --- a/sdc/tests/test_sdc_numpy.py +++ b/sdc/tests/test_sdc_numpy.py @@ -30,6 +30,7 @@ import pandas as pd import sdc import unittest +from itertools import product from sdc.str_arr_ext import StringArray from sdc.str_ext import std_str_to_unicode, unicode_to_std_str @@ -359,6 +360,94 @@ def sdc_impl(a): with self.subTest(data=case): np.testing.assert_array_equal(ref_impl(array0), sdc_func(array1)) + def _test_fillna_numeric(self, pyfunc, cfunc, inplace): + data_to_test = [ + [True, False, False, True, True], + [5, 2, 0, 333, -4], + [3.3, 5.4, 7.9], + [3.3, 5.4, np.nan, 7.9, np.nan], + ] + values_to_test = [ + None, + np.nan, + 2.1, + 2 + ] + + for data, value in product(data_to_test, values_to_test): + a1 = np.asarray(data) + a2 = pd.Series(np.copy(a1)) if inplace else pd.Series(a1) + + with self.subTest(data=data, value=value): + result = cfunc(a1, value) + result_ref = pyfunc(a2, value) + if inplace: + result, result_ref = a1, a2 + np.testing.assert_array_equal(result, result_ref) + + def test_fillna_numeric_inplace_false(self): + def ref_impl(S, value): + if value is None: + return S.values.copy() + else: + return S.fillna(value=value, inplace=False).values + + def sdc_impl(a, value): + return numpy_like.fillna(a, inplace=False, value=value) + sdc_func = self.jit(sdc_impl) + + self._test_fillna_numeric(ref_impl, sdc_func, inplace=False) + + def test_fillna_numeric_inplace_true(self): + def ref_impl(S, value): + if value is None: + return None + else: + S.fillna(value=value, inplace=True) + return None + + def sdc_impl(a, value): + return numpy_like.fillna(a, inplace=True, value=value) + sdc_func = self.jit(sdc_impl) + + self._test_fillna_numeric(ref_impl, sdc_func, inplace=True) + + def test_fillna_str_inplace_false(self): + def ref_impl(S, value): + if value is None: + return S.values.copy() + else: + return S.fillna(value=value, inplace=False).values + + def sdc_impl(S, value): + str_arr = S.values + return numpy_like.fillna(str_arr, inplace=False, value=value) + sdc_func = self.jit(sdc_impl) + + data_to_test = [ + ['a', 'b', 'c', 'd'], + ['a', 'b', None, 'c', None, 'd'], + ] + values_to_test = [ + None, + '', + 'asd' + ] + for data, value in product(data_to_test, values_to_test): + S = pd.Series(data) + with self.subTest(data=data, value=value): + result = sdc_func(S, value) + result_ref = ref_impl(S, value) + + # FIXME: str_arr unifies None with np.nan and StringArray boxing always return np.nan + # to avoid mismatch in results for fill value == None use custom comparing func + def is_same_unify_nones(a, b): + return a == b or ((a is None or np.isnan(a)) and (b is None or np.isnan(b))) + cmp_result = np.asarray( + list(map(is_same_unify_nones, result, result_ref)) + ) + self.assertEqual(np.all(cmp_result), True) + class TestArrayReductions(TestCase): From 3fe23f52c5c28a7262f774d426a8a2db137918b2 Mon Sep 17 00:00:00 2001 From: Alexey Kozlov <52973316+kozlov-alexey@users.noreply.github.com> Date: Thu, 25 Jun 2020 23:04:14 +0300 Subject: [PATCH 5/5] SAT-3017 - Fix test_series_mean failed in SDC 0.33 (#888) --- sdc/tests/test_series.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sdc/tests/test_series.py b/sdc/tests/test_series.py index 64d3e57c1..244a6c1ef 100644 --- a/sdc/tests/test_series.py +++ b/sdc/tests/test_series.py @@ -2427,7 +2427,7 @@ def _check_mean(self, pyfunc, *args): if np.isnan(actual) or np.isnan(expected): self.assertEqual(np.isnan(actual), np.isnan(expected)) else: - self.assertEqual(actual, expected) + np.testing.assert_almost_equal(actual, expected) def test_series_mean(self): def test_impl(S):