maxframe 0.1.0b5__cp39-cp39-macosx_11_0_arm64.whl

maxframe/dataframe/arithmetic/greater.py

@@ -0,0 +1,57 @@
+# Copyright 1999-2024 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+
+from ... import opcodes
+from ...utils import classproperty
+from .core import DataFrameBinopUfunc
+from .docstring import bin_compare_doc
+
+
+class DataFrameGreater(DataFrameBinopUfunc):
+    _op_type_ = opcodes.GT
+
+    _func_name = "gt"
+    _rfunc_name = "lt"
+
+    return_dtype = np.dtype(bool)
+
+    @classproperty
+    def _operator(self):
+        return lambda lhs, rhs: lhs.gt(rhs)
+
+    @classproperty
+    def tensor_op_type(self):
+        from ...tensor.arithmetic import TensorGreaterThan
+
+        return TensorGreaterThan
+
+
+_gt_example = """
+>>> a.gt(b, fill_value=0).execute()
+a     True
+b    False
+c    False
+d    False
+e     True
+f    False
+dtype: bool
+"""
+
+
+@bin_compare_doc("Greater than", equiv=">", series_example=_gt_example)
+def gt(df, other, axis="columns", level=None):
+    op = DataFrameGreater(axis=axis, level=level, lhs=df, rhs=other)
+    return op(df, other)

maxframe/dataframe/arithmetic/greater_equal.py

@@ -0,0 +1,57 @@
+# Copyright 1999-2024 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+
+from ... import opcodes
+from ...utils import classproperty
+from .core import DataFrameBinopUfunc
+from .docstring import bin_compare_doc
+
+
+class DataFrameGreaterEqual(DataFrameBinopUfunc):
+    _op_type_ = opcodes.GE
+
+    _func_name = "ge"
+    _rfunc_name = "le"
+
+    return_dtype = np.dtype(bool)
+
+    @classproperty
+    def _operator(self):
+        return lambda lhs, rhs: lhs.ge(rhs)
+
+    @classproperty
+    def tensor_op_type(self):
+        from ...tensor.arithmetic import TensorGreaterEqual
+
+        return TensorGreaterEqual
+
+
+_ge_example = """
+>>> a.ge(b, fill_value=0).execute()
+a     True
+b     True
+c    False
+d    False
+e     True
+f    False
+dtype: bool
+"""
+
+
+@bin_compare_doc("Greater than or equal to", equiv=">=", series_example=_ge_example)
+def ge(df, other, axis="columns", level=None):
+    op = DataFrameGreaterEqual(axis=axis, level=level, lhs=df, rhs=other)
+    return op(df, other)

maxframe/dataframe/arithmetic/invert.py

@@ -0,0 +1,33 @@
+# Copyright 1999-2024 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from ... import opcodes
+from ...utils import classproperty
+from .core import DataFrameUnaryUfunc
+
+
+class DataFrameNot(DataFrameUnaryUfunc):
+    _op_type_ = opcodes.INVERT
+    _func_name = "__invert__"
+
+    @classproperty
+    def tensor_op_type(self):
+        from ...tensor.arithmetic import TensorNot
+
+        return TensorNot
+
+
+def invert(df):
+    op = DataFrameNot()
+    return op(df)

maxframe/dataframe/arithmetic/is_ufuncs.py

@@ -0,0 +1,62 @@
+# Copyright 1999-2024 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+import pandas as pd
+
+from ... import opcodes
+from ...utils import classproperty
+from .core import DataFrameUnaryUfunc
+
+
+class DataFrameIsUFuncMixin:
+    @classmethod
+    def _get_output_dtype(cls, df):
+        if df.ndim == 2:
+            return pd.Series(np.dtype(bool), index=df.dtypes.index)
+        else:
+            return np.dtype(bool)
+
+
+class DataFrameIsNan(DataFrameIsUFuncMixin, DataFrameUnaryUfunc):
+    _op_type_ = opcodes.ISNAN
+    _func_name = "isnan"
+
+    @classproperty
+    def tensor_op_type(self):
+        from ...tensor.arithmetic import TensorIsNan
+
+        return TensorIsNan
+
+
+class DataFrameIsInf(DataFrameIsUFuncMixin, DataFrameUnaryUfunc):
+    _op_type_ = opcodes.ISINF
+    _func_name = "isinf"
+
+    @classproperty
+    def tensor_op_type(self):
+        from ...tensor.arithmetic import TensorIsInf
+
+        return TensorIsInf
+
+
+class DataFrameIsFinite(DataFrameIsUFuncMixin, DataFrameUnaryUfunc):
+    _op_type_ = opcodes.ISFINITE
+    _func_name = "isfinite"
+
+    @classproperty
+    def tensor_op_type(self):
+        from ...tensor.arithmetic import TensorIsFinite
+
+        return TensorIsFinite

maxframe/dataframe/arithmetic/less.py

@@ -0,0 +1,57 @@
+# Copyright 1999-2024 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+
+from ... import opcodes
+from ...utils import classproperty
+from .core import DataFrameBinopUfunc
+from .docstring import bin_compare_doc
+
+
+class DataFrameLess(DataFrameBinopUfunc):
+    _op_type_ = opcodes.LT
+
+    _func_name = "lt"
+    _rfunc_name = "gt"
+
+    return_dtype = np.dtype(bool)
+
+    @classproperty
+    def _operator(self):
+        return lambda lhs, rhs: lhs.lt(rhs)
+
+    @classproperty
+    def tensor_op_type(self):
+        from ...tensor.arithmetic import TensorLessThan
+
+        return TensorLessThan
+
+
+_lt_example = """
+>>> a.lt(b, fill_value=0).execute()
+a    False
+b    False
+c     True
+d    False
+e    False
+f     True
+dtype: bool
+"""
+
+
+@bin_compare_doc("Less than", equiv="<", series_example=_lt_example)
+def lt(df, other, axis="columns", level=None):
+    op = DataFrameLess(axis=axis, level=level, lhs=df, rhs=other)
+    return op(df, other)

maxframe/dataframe/arithmetic/less_equal.py

@@ -0,0 +1,57 @@
+# Copyright 1999-2024 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+
+from ... import opcodes
+from ...utils import classproperty
+from .core import DataFrameBinopUfunc
+from .docstring import bin_compare_doc
+
+
+class DataFrameLessEqual(DataFrameBinopUfunc):
+    _op_type_ = opcodes.LE
+
+    _func_name = "le"
+    _rfunc_name = "ge"
+
+    return_dtype = np.dtype(bool)
+
+    @classproperty
+    def _operator(self):
+        return lambda lhs, rhs: lhs.le(rhs)
+
+    @classproperty
+    def tensor_op_type(self):
+        from ...tensor.arithmetic import TensorLessEqual
+
+        return TensorLessEqual
+
+
+_le_example = """
+>>> a.le(b, fill_value=0).execute()
+a    False
+b     True
+c     True
+d    False
+e    False
+f     True
+dtype: bool
+"""
+
+
+@bin_compare_doc("Less than or equal to", equiv="<=", series_example=_le_example)
+def le(df, other, axis="columns", level=None):
+    op = DataFrameLessEqual(axis=axis, level=level, lhs=df, rhs=other)
+    return op(df, other)

maxframe/dataframe/arithmetic/log.py

@@ -0,0 +1,28 @@
+# Copyright 1999-2024 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from ... import opcodes
+from ...utils import classproperty
+from .core import DataFrameUnaryUfunc
+
+
+class DataFrameLog(DataFrameUnaryUfunc):
+    _op_type_ = opcodes.LOG
+    _func_name = "log"
+
+    @classproperty
+    def tensor_op_type(self):
+        from ...tensor.arithmetic import TensorLog
+
+        return TensorLog

maxframe/dataframe/arithmetic/log10.py

@@ -0,0 +1,28 @@
+# Copyright 1999-2024 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from ... import opcodes
+from ...utils import classproperty
+from .core import DataFrameUnaryUfunc
+
+
+class DataFrameLog10(DataFrameUnaryUfunc):
+    _op_type_ = opcodes.LOG10
+    _func_name = "log10"
+
+    @classproperty
+    def tensor_op_type(self):
+        from ...tensor.arithmetic import TensorLog10
+
+        return TensorLog10

maxframe/dataframe/arithmetic/log2.py

@@ -0,0 +1,28 @@
+# Copyright 1999-2024 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from ... import opcodes
+from ...utils import classproperty
+from .core import DataFrameUnaryUfunc
+
+
+class DataFrameLog2(DataFrameUnaryUfunc):
+    _op_type_ = opcodes.LOG2
+    _func_name = "log2"
+
+    @classproperty
+    def tensor_op_type(self):
+        from ...tensor.arithmetic import TensorLog2
+
+        return TensorLog2

maxframe/dataframe/arithmetic/mod.py

@@ -0,0 +1,60 @@
+# Copyright 1999-2024 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import operator
+
+from ... import opcodes
+from ...utils import classproperty
+from .core import DataFrameBinopUfunc
+from .docstring import bin_arithmetic_doc
+
+
+class DataFrameMod(DataFrameBinopUfunc):
+    _op_type_ = opcodes.MOD
+
+    _func_name = "mod"
+    _rfunc_name = "rmod"
+
+    @classproperty
+    def _operator(self):
+        return operator.mod
+
+    @classproperty
+    def tensor_op_type(self):
+        from ...tensor.arithmetic import TensorMod
+
+        return TensorMod
+
+
+_mod_example = """
+>>> a.mod(b, fill_value=0).execute()
+a    0.0
+b    NaN
+c    NaN
+d    0.0
+e    NaN
+dtype: float64
+"""
+
+
+@bin_arithmetic_doc("Modulo", equiv="%", series_example=_mod_example)
+def mod(df, other, axis="columns", level=None, fill_value=None):
+    op = DataFrameMod(axis=axis, level=level, fill_value=fill_value, lhs=df, rhs=other)
+    return op(df, other)
+
+
+@bin_arithmetic_doc("Modulo", equiv="%", series_example=_mod_example)
+def rmod(df, other, axis="columns", level=None, fill_value=None):
+    op = DataFrameMod(axis=axis, level=level, fill_value=fill_value, lhs=other, rhs=df)
+    return op.rcall(df, other)

maxframe/dataframe/arithmetic/multiply.py

@@ -0,0 +1,60 @@
+# Copyright 1999-2024 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import operator
+
+from ... import opcodes
+from ...utils import classproperty
+from .core import DataFrameBinopUfunc
+from .docstring import bin_arithmetic_doc
+
+
+class DataFrameMul(DataFrameBinopUfunc):
+    _op_type_ = opcodes.MUL
+
+    _func_name = "mul"
+    _rfunc_name = "rmul"
+
+    @classproperty
+    def _operator(self):
+        return operator.mul
+
+    @classproperty
+    def tensor_op_type(self):
+        from ...tensor.arithmetic import TensorMultiply
+
+        return TensorMultiply
+
+
+_mul_example = """
+>>> a.multiply(b, fill_value=0).execute()
+a    1.0
+b    0.0
+c    0.0
+d    0.0
+e    NaN
+dtype: float64
+"""
+
+
+@bin_arithmetic_doc("Multiplication", equiv="*", series_example=_mul_example)
+def mul(df, other, axis="columns", level=None, fill_value=None):
+    op = DataFrameMul(axis=axis, level=level, fill_value=fill_value, lhs=df, rhs=other)
+    return op(df, other)
+
+
+@bin_arithmetic_doc("Multiplication", equiv="*", series_example=_mul_example)
+def rmul(df, other, axis="columns", level=None, fill_value=None):
+    op = DataFrameMul(axis=axis, level=level, fill_value=fill_value, lhs=other, rhs=df)
+    return op.rcall(df, other)

maxframe/dataframe/arithmetic/negative.py

@@ -0,0 +1,33 @@
+# Copyright 1999-2024 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from ... import opcodes
+from ...utils import classproperty
+from .core import DataFrameUnaryUfunc
+
+
+class DataFrameNegative(DataFrameUnaryUfunc):
+    _op_type_ = opcodes.NEGATIVE
+    _func_name = "negative"
+
+    @classproperty
+    def tensor_op_type(self):
+        from ...tensor.arithmetic import TensorNegative
+
+        return TensorNegative
+
+
+def negative(df):
+    op = DataFrameNegative()
+    return op(df)

maxframe/dataframe/arithmetic/not_equal.py

@@ -0,0 +1,56 @@
+# Copyright 1999-2024 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+
+from ... import opcodes
+from ...utils import classproperty
+from .core import DataFrameBinopUfunc
+from .docstring import bin_compare_doc
+
+
+class DataFrameNotEqual(DataFrameBinopUfunc):
+    _op_type_ = opcodes.NE
+
+    _func_name = "ne"
+    _rfunc_name = "ne"
+
+    return_dtype = np.dtype(bool)
+
+    @classproperty
+    def _operator(self):
+        return lambda lhs, rhs: lhs.ne(rhs)
+
+    @classproperty
+    def tensor_op_type(self):
+        from ...tensor.arithmetic import TensorNotEqual
+
+        return TensorNotEqual
+
+
+_ne_example = """
+>>> a.ne(b, fill_value=0).execute()
+a    False
+b     True
+c     True
+d     True
+e     True
+dtype: bool
+"""
+
+
+@bin_compare_doc("Not equal to", equiv="!=", series_example=_ne_example)
+def ne(df, other, axis="columns", level=None):
+    op = DataFrameNotEqual(axis=axis, level=level, lhs=df, rhs=other)
+    return op(df, other)

maxframe/dataframe/arithmetic/power.py

@@ -0,0 +1,68 @@
+# Copyright 1999-2024 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import operator
+
+from ... import opcodes
+from ...utils import classproperty
+from .core import DataFrameBinopUfunc
+from .docstring import bin_arithmetic_doc
+
+
+class DataFramePower(DataFrameBinopUfunc):
+    _op_type_ = opcodes.POW
+
+    _func_name = "pow"
+    _rfunc_name = "rpow"
+
+    @classproperty
+    def _operator(self):
+        return operator.pow
+
+    @classproperty
+    def tensor_op_type(self):
+        from ...tensor.arithmetic import TensorPower
+
+        return TensorPower
+
+
+_pow_example = """
+>>> a.pow(b, fill_value=0).execute()
+a    1.0
+b    1.0
+c    1.0
+d    0.0
+e    NaN
+dtype: float64
+"""
+
+
+@bin_arithmetic_doc(
+    "Exponential power", op_name="pow", equiv="**", series_example=_pow_example
+)
+def power(df, other, axis="columns", level=None, fill_value=None):
+    op = DataFramePower(
+        axis=axis, level=level, fill_value=fill_value, lhs=df, rhs=other
+    )
+    return op(df, other)
+
+
+@bin_arithmetic_doc(
+    "Exponential power", op_name="rpow", equiv="**", series_example=_pow_example
+)
+def rpower(df, other, axis="columns", level=None, fill_value=None):
+    op = DataFramePower(
+        axis=axis, level=level, fill_value=fill_value, lhs=other, rhs=df
+    )
+    return op.rcall(df, other)