saad
/
ai-content-maker
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
ai-content-maker/.venv/Lib/site-packages/pandas/tests/frame/test_ufunc.py

304 lines
10 KiB
Python
Raw Blame History

from functools import partial
import numpy as np
import pytest
from pandas.compat.numpy import np_version_gte1p22
import pandas.util._test_decorators as td
import pandas as pd
import pandas._testing as tm
from pandas.api.types import is_extension_array_dtype
dtypes = [
"int64",
"Int64",
{"A": "int64", "B": "Int64"},
]
@pytest.mark.parametrize("dtype", dtypes)
def test_unary_unary(dtype):
# unary input, unary output
values = np.array([[-1, -1], [1, 1]], dtype="int64")
df = pd.DataFrame(values, columns=["A", "B"], index=["a", "b"]).astype(dtype=dtype)
result = np.positive(df)
expected = pd.DataFrame(
np.positive(values), index=df.index, columns=df.columns
).astype(dtype)
tm.assert_frame_equal(result, expected)
@pytest.mark.parametrize("dtype", dtypes)
def test_unary_binary(request, dtype):
# unary input, binary output
if is_extension_array_dtype(dtype) or isinstance(dtype, dict):
request.node.add_marker(
pytest.mark.xfail(
reason="Extension / mixed with multiple outputs not implemented."
)
)
values = np.array([[-1, -1], [1, 1]], dtype="int64")
df = pd.DataFrame(values, columns=["A", "B"], index=["a", "b"]).astype(dtype=dtype)
result_pandas = np.modf(df)
assert isinstance(result_pandas, tuple)
assert len(result_pandas) == 2
expected_numpy = np.modf(values)
for result, b in zip(result_pandas, expected_numpy):
expected = pd.DataFrame(b, index=df.index, columns=df.columns)
tm.assert_frame_equal(result, expected)
@pytest.mark.parametrize("dtype", dtypes)
def test_binary_input_dispatch_binop(dtype):
# binop ufuncs are dispatched to our dunder methods.
values = np.array([[-1, -1], [1, 1]], dtype="int64")
df = pd.DataFrame(values, columns=["A", "B"], index=["a", "b"]).astype(dtype=dtype)
result = np.add(df, df)
expected = pd.DataFrame(
np.add(values, values), index=df.index, columns=df.columns
).astype(dtype)
tm.assert_frame_equal(result, expected)
@pytest.mark.parametrize(
"func,arg,expected",
[
(np.add, 1, [2, 3, 4, 5]),
(
partial(np.add, where=[[False, True], [True, False]]),
np.array([[1, 1], [1, 1]]),
[0, 3, 4, 0],
),
(np.power, np.array([[1, 1], [2, 2]]), [1, 2, 9, 16]),
(np.subtract, 2, [-1, 0, 1, 2]),
(
partial(np.negative, where=np.array([[False, True], [True, False]])),
None,
[0, -2, -3, 0],
),
],
)
def test_ufunc_passes_args(func, arg, expected):
# GH#40662
arr = np.array([[1, 2], [3, 4]])
df = pd.DataFrame(arr)
result_inplace = np.zeros_like(arr)
# 1-argument ufunc
if arg is None:
result = func(df, out=result_inplace)
else:
result = func(df, arg, out=result_inplace)
expected = np.array(expected).reshape(2, 2)
tm.assert_numpy_array_equal(result_inplace, expected)
expected = pd.DataFrame(expected)
tm.assert_frame_equal(result, expected)
@pytest.mark.parametrize("dtype_a", dtypes)
@pytest.mark.parametrize("dtype_b", dtypes)
def test_binary_input_aligns_columns(request, dtype_a, dtype_b):
if (
is_extension_array_dtype(dtype_a)
or isinstance(dtype_a, dict)
or is_extension_array_dtype(dtype_b)
or isinstance(dtype_b, dict)
):
request.node.add_marker(
pytest.mark.xfail(
reason="Extension / mixed with multiple inputs not implemented."
)
)
df1 = pd.DataFrame({"A": [1, 2], "B": [3, 4]}).astype(dtype_a)
if isinstance(dtype_a, dict) and isinstance(dtype_b, dict):
dtype_b["C"] = dtype_b.pop("B")
df2 = pd.DataFrame({"A": [1, 2], "C": [3, 4]}).astype(dtype_b)
with tm.assert_produces_warning(FutureWarning):
result = np.heaviside(df1, df2)
# Expected future behaviour:
# expected = np.heaviside(
# np.array([[1, 3, np.nan], [2, 4, np.nan]]),
# np.array([[1, np.nan, 3], [2, np.nan, 4]]),
# )
# expected = pd.DataFrame(expected, index=[0, 1], columns=["A", "B", "C"])
expected = pd.DataFrame([[1.0, 1.0], [1.0, 1.0]], columns=["A", "B"])
tm.assert_frame_equal(result, expected)
# ensure the expected is the same when applying with numpy array
result = np.heaviside(df1, df2.values)
tm.assert_frame_equal(result, expected)
@pytest.mark.parametrize("dtype", dtypes)
def test_binary_input_aligns_index(request, dtype):
if is_extension_array_dtype(dtype) or isinstance(dtype, dict):
request.node.add_marker(
pytest.mark.xfail(
reason="Extension / mixed with multiple inputs not implemented."
)
)
df1 = pd.DataFrame({"A": [1, 2], "B": [3, 4]}, index=["a", "b"]).astype(dtype)
df2 = pd.DataFrame({"A": [1, 2], "B": [3, 4]}, index=["a", "c"]).astype(dtype)
with tm.assert_produces_warning(FutureWarning):
result = np.heaviside(df1, df2)
# Expected future behaviour:
# expected = np.heaviside(
# np.array([[1, 3], [3, 4], [np.nan, np.nan]]),
# np.array([[1, 3], [np.nan, np.nan], [3, 4]]),
# )
# # TODO(FloatArray): this will be Float64Dtype.
# expected = pd.DataFrame(expected, index=["a", "b", "c"], columns=["A", "B"])
expected = pd.DataFrame(
[[1.0, 1.0], [1.0, 1.0]], columns=["A", "B"], index=["a", "b"]
)
tm.assert_frame_equal(result, expected)
# ensure the expected is the same when applying with numpy array
result = np.heaviside(df1, df2.values)
tm.assert_frame_equal(result, expected)
@pytest.mark.filterwarnings("ignore:Calling a ufunc on non-aligned:FutureWarning")
def test_binary_frame_series_raises():
# We don't currently implement
df = pd.DataFrame({"A": [1, 2]})
# with pytest.raises(NotImplementedError, match="logaddexp"):
with pytest.raises(ValueError, match=""):
np.logaddexp(df, df["A"])
# with pytest.raises(NotImplementedError, match="logaddexp"):
with pytest.raises(ValueError, match=""):
np.logaddexp(df["A"], df)
def test_unary_accumulate_axis():
# https://github.com/pandas-dev/pandas/issues/39259
df = pd.DataFrame({"a": [1, 3, 2, 4]})
result = np.maximum.accumulate(df)
expected = pd.DataFrame({"a": [1, 3, 3, 4]})
tm.assert_frame_equal(result, expected)
df = pd.DataFrame({"a": [1, 3, 2, 4], "b": [0.1, 4.0, 3.0, 2.0]})
result = np.maximum.accumulate(df)
# in theory could preserve int dtype for default axis=0
expected = pd.DataFrame({"a": [1.0, 3.0, 3.0, 4.0], "b": [0.1, 4.0, 4.0, 4.0]})
tm.assert_frame_equal(result, expected)
result = np.maximum.accumulate(df, axis=0)
tm.assert_frame_equal(result, expected)
result = np.maximum.accumulate(df, axis=1)
expected = pd.DataFrame({"a": [1.0, 3.0, 2.0, 4.0], "b": [1.0, 4.0, 3.0, 4.0]})
tm.assert_frame_equal(result, expected)
def test_frame_outer_deprecated():
df = pd.DataFrame({"A": [1, 2]})
with tm.assert_produces_warning(FutureWarning):
np.subtract.outer(df, df)
def test_alignment_deprecation():
# https://github.com/pandas-dev/pandas/issues/39184
df1 = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
df2 = pd.DataFrame({"b": [1, 2, 3], "c": [4, 5, 6]})
s1 = pd.Series([1, 2], index=["a", "b"])
s2 = pd.Series([1, 2], index=["b", "c"])
# binary dataframe / dataframe
expected = pd.DataFrame({"a": [2, 4, 6], "b": [8, 10, 12]})
with tm.assert_produces_warning(None):
# aligned -> no warning!
result = np.add(df1, df1)
tm.assert_frame_equal(result, expected)
with tm.assert_produces_warning(FutureWarning):
# non-aligned -> warns
result = np.add(df1, df2)
tm.assert_frame_equal(result, expected)
result = np.add(df1, df2.values)
tm.assert_frame_equal(result, expected)
result = np.add(df1.values, df2)
expected = pd.DataFrame({"b": [2, 4, 6], "c": [8, 10, 12]})
tm.assert_frame_equal(result, expected)
# binary dataframe / series
expected = pd.DataFrame({"a": [2, 3, 4], "b": [6, 7, 8]})
with tm.assert_produces_warning(None):
# aligned -> no warning!
result = np.add(df1, s1)
tm.assert_frame_equal(result, expected)
with tm.assert_produces_warning(FutureWarning):
result = np.add(df1, s2)
tm.assert_frame_equal(result, expected)
with tm.assert_produces_warning(FutureWarning):
result = np.add(s2, df1)
tm.assert_frame_equal(result, expected)
result = np.add(df1, s2.values)
tm.assert_frame_equal(result, expected)
@td.skip_if_no("numba")
def test_alignment_deprecation_many_inputs(request):
# https://github.com/pandas-dev/pandas/issues/39184
# test that the deprecation also works with > 2 inputs -> using a numba
# written ufunc for this because numpy itself doesn't have such ufuncs
from numba import (
float64,
vectorize,
)
if np_version_gte1p22:
mark = pytest.mark.filterwarnings(
"ignore:`np.MachAr` is deprecated.*:DeprecationWarning"
)
request.node.add_marker(mark)
@vectorize([float64(float64, float64, float64)])
def my_ufunc(x, y, z):
return x + y + z
df1 = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
df2 = pd.DataFrame({"b": [1, 2, 3], "c": [4, 5, 6]})
df3 = pd.DataFrame({"a": [1, 2, 3], "c": [4, 5, 6]})
with tm.assert_produces_warning(FutureWarning):
result = my_ufunc(df1, df2, df3)
expected = pd.DataFrame([[3.0, 12.0], [6.0, 15.0], [9.0, 18.0]], columns=["a", "b"])
tm.assert_frame_equal(result, expected)
# all aligned -> no warning
with tm.assert_produces_warning(None):
result = my_ufunc(df1, df1, df1)
tm.assert_frame_equal(result, expected)
# mixed frame / arrays
with tm.assert_produces_warning(FutureWarning):
result = my_ufunc(df1, df2, df3.values)
tm.assert_frame_equal(result, expected)
# single frame -> no warning
with tm.assert_produces_warning(None):
result = my_ufunc(df1, df2.values, df3.values)
tm.assert_frame_equal(result, expected)
# takes indices of first frame
with tm.assert_produces_warning(FutureWarning):
result = my_ufunc(df1.values, df2, df3)
expected = expected.set_axis(["b", "c"], axis=1)
tm.assert_frame_equal(result, expected)
Reference in New Issue View Git Blame Copy Permalink