maxframe 1.3.1__cp39-cp39-win_amd64.whl → 2.0.0__cp39-cp39-win_amd64.whl

maxframe/codegen/spe/tensor/extensions.py

@@ -0,0 +1,35 @@
+# Copyright 1999-2025 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 typing import List
+
+from ....tensor.extensions.apply_chunk import TensorApplyChunk
+from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+
+
+@register_op_adapter(TensorApplyChunk)
+class TensorApplyChunkAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: TensorApplyChunk, context: SPECodeContext) -> List[str]:
+        input_var = context.get_input_tileable_variable(op.inputs[0])
+        output_var = context.get_output_tileable_variable(op.outputs[0])
+        func_var = self.translate_var(context, op.func)
+        kwargs = op.kwargs.copy()
+        if op.with_chunk_index:
+            kwargs["chunk_index"] = (0,) * op.inputs[0].ndim
+        args = self._translate_call_args(context, *op.args, **kwargs)
+        if args:
+            args_str = ", " + ", ".join(args)
+        else:
+            args_str = ""
+        return [f"{output_var} = {func_var}({input_var}{args_str})"]

maxframe/codegen/spe/tensor/fetch.py

@@ -0,0 +1,26 @@
+# Copyright 1999-2025 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 typing import List
+
+from ....tensor.fetch import TensorFetch
+from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+
+
+@register_op_adapter(TensorFetch)
+class TensorFetchAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: TensorFetch, context: SPECodeContext) -> List[str]:
+        # Simply register Fetch as SPE-executable.
+        # Actual codegen is done inside code generator itself.
+        return []

maxframe/codegen/spe/tensor/indexing.py

@@ -0,0 +1,63 @@
+# Copyright 1999-2025 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 typing import List
+
+from ....tensor.indexing import (
+    TensorIndex,
+    TensorIndexSetValue,
+    TensorNonzero,
+    TensorUnravelIndex,
+)
+from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+from ..utils import build_method_call_adapter
+
+
+@register_op_adapter(TensorIndex)
+class TensorIndexAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: TensorIndex, context: SPECodeContext) -> List[str]:
+        context.register_import("numpy", "np")
+        indexes_var_name = self.translate_var(context, op.indexes)
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        input_var_name = context.get_input_tileable_variable(op.inputs[0])
+        return [f"{res_var_name} = {input_var_name}[tuple({indexes_var_name})]"]
+
+
+@register_op_adapter(TensorIndexSetValue)
+class TensorIndexSetValueAdapter(SPEOperatorAdapter):
+    def generate_code(
+        self, op: TensorIndexSetValue, context: SPECodeContext
+    ) -> List[str]:
+        context.register_import("numpy", "np")
+        indexes_var_name = self.translate_var(context, op.indexes)
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        input_var_name = context.get_input_tileable_variable(op.inputs[0])
+        value_expr = self.translate_var(context, op.value)
+        return [
+            f"{res_var_name} = {input_var_name}.copy()",
+            f"{res_var_name}[tuple({indexes_var_name})] = {value_expr}",
+        ]
+
+
+TensorNonzeroAdapter = build_method_call_adapter(
+    TensorNonzero, "nonzero", 0, source_module="np"
+)
+TensorUnravelIndexAdapter = build_method_call_adapter(
+    TensorUnravelIndex,
+    "unravel_index",
+    0,
+    skip_none=True,
+    kw_keys=["dims", "order"],
+    source_module="np",
+)

maxframe/codegen/spe/tensor/linalg.py

@@ -0,0 +1,63 @@
+# Copyright 1999-2025 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 typing import List
+
+from ....tensor.linalg import (
+    TensorInv,
+    TensorLU,
+    TensorMatmul,
+    TensorQR,
+    TensorSolveTriangular,
+    TensorSVD,
+    TensorTensorDot,
+)
+from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+from ..utils import build_method_call_adapter
+
+TensorInvAdapter = build_method_call_adapter(
+    TensorInv, "inv", "input", source_module="npl"
+)
+TensorLUAdapter = build_method_call_adapter(
+    TensorLU, "lu", "input", source_module="spl"
+)
+TensorQRAdapter = build_method_call_adapter(TensorQR, "qr", 0, source_module="spl")
+TensorSVDAdapter = build_method_call_adapter(TensorSVD, "svd", 0, source_module="spl")
+TensorMatmulAdapter = build_method_call_adapter(
+    TensorMatmul, "matmul", "a", "b", source_module="np", kw_keys=["casting", "order"]
+)
+TensorSolveTriangularAdapter = build_method_call_adapter(
+    TensorSolveTriangular,
+    "solve_triangular",
+    "a",
+    "b",
+    source_module="spl",
+    kw_keys=["lower", "strict"],
+)
+
+
+@register_op_adapter(TensorTensorDot)
+class TensorTensorDotAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: TensorTensorDot, context: SPECodeContext) -> List[str]:
+        context.register_import("numpy.linalg", "npl")
+
+        lhs_var_name = context.get_input_tileable_variable(op.inputs[0])
+        rhs_var_name = context.get_input_tileable_variable(op.inputs[1])
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        axes_str = self.generate_call_args_with_attributes(
+            op, context, "a_axes", "b_axes"
+        )
+        return [
+            f"{res_var_name} = npl.tensordot({lhs_var_name}, {rhs_var_name}, ({axes_str}))"
+        ]

maxframe/codegen/spe/tensor/merge.py

@@ -0,0 +1,31 @@
+# Copyright 1999-2025 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 typing import List
+
+from ....tensor.core import Tensor
+from ....tensor.merge.concatenate import TensorConcatenate
+from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+
+
+@register_op_adapter(TensorConcatenate)
+class TensorConcatenateAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: Tensor, context: SPECodeContext) -> List[str]:
+        context.register_import("numpy", "np")
+        ndarr_str = ", ".join(context.get_input_tileable_variable(k) for k in op.inputs)
+        if len(op.inputs) == 1:
+            ndarr_str += ","
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        axis_var = context.register_operator_constants(op.axis)
+        return [f"{res_var_name} = np.concatenate(({ndarr_str}), axis={axis_var})"]

maxframe/codegen/spe/tensor/misc.py

@@ -0,0 +1,121 @@
+# Copyright 1999-2025 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 typing import List
+
+import numpy as np
+
+from ....tensor.misc import (
+    TensorDiff,
+    TensorIsIn,
+    TensorRepeat,
+    TensorSearchsorted,
+    TensorSqueeze,
+    TensorSwapAxes,
+    TensorTranspose,
+    TensorTrapezoid,
+    TensorUnique,
+    TensorWhere,
+)
+from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+from ..utils import build_method_call_adapter
+
+_trapz_func = "trapezoid" if hasattr(np, "trapezoid") else "trapz"
+
+
+TensorDiffAdapter = build_method_call_adapter(
+    TensorDiff, "diff", 0, skip_none=True, kw_keys=["n", "axis"], source_module="np"
+)
+TensorIsInAdapter = build_method_call_adapter(
+    TensorIsIn,
+    "isin",
+    0,
+    1,
+    skip_none=True,
+    kw_keys=["assume_unique", "invert"],
+    source_module="np",
+)
+TensorRepeatAdapter = build_method_call_adapter(
+    TensorRepeat,
+    "repeat",
+    0,
+    skip_none=True,
+    kw_keys=["repeats", "axis"],
+    source_module="np",
+)
+TensorSearchsortedAdapter = build_method_call_adapter(
+    TensorSearchsorted,
+    "searchsorted",
+    "a",
+    "v",
+    kw_keys=["side", "sorter"],
+    source_module="np",
+)
+
+
+@register_op_adapter(TensorTranspose)
+class TensorTransposeAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: TensorTranspose, context: SPECodeContext) -> List[str]:
+        context.register_import("numpy", "np")
+        input_var_name = context.get_input_tileable_variable(op.inputs[0])
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        axes_var = self.translate_var(context, op.axes)
+        return [f"{res_var_name} = np.transpose({input_var_name}, axes={axes_var})"]
+
+
+TensorTrapezoidAdapter = build_method_call_adapter(
+    TensorTrapezoid,
+    _trapz_func,
+    skip_none=True,
+    kw_keys=["y", "x", "dx", "axis"],
+    source_module="np",
+)
+
+
+@register_op_adapter(TensorSqueeze)
+class TensorSqueezeAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: TensorSqueeze, context: SPECodeContext) -> List[str]:
+        context.register_import("numpy", "np")
+        input_var_name = context.get_input_tileable_variable(op.inputs[0])
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        axis_var = self.translate_var(context, op.axis)
+        return [f"{res_var_name} = np.squeeze({input_var_name}, axis={axis_var})"]
+
+
+@register_op_adapter(TensorUnique)
+class TensorUniqueAdapter(SPEOperatorAdapter):
+    def generate_code(self, op, context):
+        context.register_import("numpy", "np")
+        input_var_name = context.get_input_tileable_variable(op.inputs[0])
+        output_var_names = [
+            context.get_output_tileable_variable(out) for out in op.outputs
+        ]
+        return_index_var = self.translate_var(context, op.return_index)
+        return_inverse_var = self.translate_var(context, op.return_inverse)
+        return_counts_var = self.translate_var(context, op.return_counts)
+        axis_var = self.translate_var(context, op.axis)
+        return [
+            f"{', '.join(output_var_names)} = "
+            f"np.unique({input_var_name}, return_index={return_index_var}, "
+            f"return_inverse={return_inverse_var}, return_counts={return_counts_var}, "
+            f"axis={axis_var})"
+        ]
+
+
+TensorSwapAxesAdapter = build_method_call_adapter(
+    TensorSwapAxes, "swapaxes", "axis1", "axis2", source_module="np"
+)
+TensorWhereAdapter = build_method_call_adapter(
+    TensorWhere, "where", "condition", "x", "y", source_module="np"
+)

maxframe/codegen/spe/tensor/random.py

@@ -0,0 +1,29 @@
+# Copyright 1999-2025 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 typing import List
+
+from ....tensor.random.rand import TensorRand
+from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+
+
+@register_op_adapter(TensorRand)
+class TensorRandAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: TensorRand, context: SPECodeContext) -> List[str]:
+        context.register_import("numpy", "np")
+        # Use shape to achieve backward compatibility for 1.0 SDK
+        shape = op.size or op.outputs[0].shape
+        shape_str = ", ".join(str(x) for x in shape) if shape else ""
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        return [f"{res_var_name} = np.random.rand({shape_str})"]

maxframe/codegen/spe/tensor/reduction.py

@@ -0,0 +1,39 @@
+# Copyright 1999-2025 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 typing import List
+
+from ....tensor.reduction.core import TensorCumReduction, TensorReduction
+from ....tensor.reduction.nanvar import TensorNanVar
+from ....tensor.reduction.var import TensorVar
+from ..core import register_op_adapter
+from .core import TensorUnaryCommonAdapter
+
+
+@register_op_adapter(TensorReduction)
+class TensorReductionAdapter(TensorUnaryCommonAdapter):
+    def _get_op_kw_args(self, op: TensorReduction) -> List[str]:
+        return ["axis", "keepdims"]
+
+
+@register_op_adapter([TensorVar, TensorNanVar])
+class TensorVarAdapter(TensorReductionAdapter):
+    def _get_op_kw_args(self, op: TensorReduction) -> List[str]:
+        return super()._get_op_kw_args(op) + ["ddof"]
+
+
+@register_op_adapter(TensorCumReduction)
+class TensorCumReductionAdapter(TensorUnaryCommonAdapter):
+    def _get_op_kw_args(self, op: TensorCumReduction) -> List[str]:
+        return ["axis"]

maxframe/codegen/spe/tensor/reshape.py

@@ -0,0 +1,26 @@
+# Copyright 1999-2025 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 ....tensor.reshape.reshape import TensorReshape
+from ..utils import build_method_call_adapter
+
+TensorReshapeAdapter = build_method_call_adapter(
+    TensorReshape,
+    "reshape",
+    "input",
+    "newshape",
+    "order",
+    skip_none=True,
+    source_module="np",
+)

maxframe/codegen/spe/tensor/sort.py

@@ -0,0 +1,42 @@
+# Copyright 1999-2025 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 typing import List
+
+from ....tensor.sort.sort import TensorSort
+from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+
+
+@register_op_adapter(TensorSort)
+class TensorSortAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: TensorSort, context: SPECodeContext) -> List[str]:
+        input_var_name = context.get_input_tileable_variable(op.inputs[0])
+        res_var_names = [
+            context.get_output_tileable_variable(out) for out in op.outputs
+        ]
+        res_name_iter = iter(res_var_names)
+
+        axes_str = self.generate_call_args_with_attributes(
+            op, context, kw_keys=["axis", "kind", "order"]
+        )
+        lines = []
+        if op.return_value:
+            lines.append(
+                f"{next(res_name_iter)} = np.sort({input_var_name}, {axes_str})"
+            )
+        if op.return_indices:
+            lines.append(
+                f"{next(res_name_iter)} = np.argsort({input_var_name}, {axes_str})"
+            )
+        return lines

maxframe/codegen/spe/tensor/special.py

@@ -0,0 +1,35 @@
+# Copyright 1999-2025 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 typing import List
+
+from ....tensor.special.core import TensorSpecialUnaryOp
+from ..core import SPECodeContext
+from .core import TensorUnaryCommonAdapter
+
+
+class TensorSpecialUnaryOpAdapter(TensorUnaryCommonAdapter):
+    @classmethod
+    def _gen_func_name(cls, op: TensorSpecialUnaryOp):
+        return f"spspecial.{op._func_name}"
+
+    @classmethod
+    def _get_op_kw_args(self, op: TensorSpecialUnaryOp) -> List[str]:
+        return []
+
+    def generate_code(
+        self, op: TensorSpecialUnaryOp, context: SPECodeContext
+    ) -> List[str]:
+        context.register_import("scipy.special", "spspecial")
+        return super().generate_code(op, context)

maxframe/codegen/spe/tensor/statistics.py

@@ -0,0 +1,24 @@
+# Copyright 1999-2025 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 ....tensor.statistics.bincount import TensorBinCount
+from ..utils import build_method_call_adapter
+
+TensorBinCountAdapter = build_method_call_adapter(
+    TensorBinCount,
+    "bincount",
+    0,
+    kw_keys=["weights", "minlength"],
+    source_module="np",
+)

maxframe/codegen/spe/tensor/tests/__init__.py

@@ -0,0 +1,13 @@
+# Copyright 1999-2025 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.

maxframe/codegen/spe/tensor/tests/test_arithmetic.py

@@ -0,0 +1,103 @@
+# Copyright 1999-2025 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 tensor as mt
+from ...core import SPECodeContext
+from ..arithmetic import (
+    TensorAngleAdapter,
+    TensorAroundAdapter,
+    TensorBinOpAdapter,
+    TensorIscloseAdapter,
+    TensorSetImagAdapter,
+    TensorSetRealAdapter,
+    TensorUnaryOpAdapter,
+)
+
+
+def test_unary_op():
+    s1 = mt.random.rand(1000, 5)
+    result = mt.sin(s1)
+
+    adapter = TensorUnaryOpAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(result.op, context)
+    expected_results = ["var_1 = np.sin(var_0, casting='same_kind', order='K')"]
+    assert results == expected_results
+
+
+def test_around():
+    s1 = mt.random.rand(1000, 5)
+    result = mt.around(s1, 2)
+
+    adapter = TensorAroundAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(result.op, context)
+    expected_results = ["var_1 = np.around(var_0, decimals=2)"]
+    assert results == expected_results
+
+
+def test_angle():
+    s1 = mt.random.rand(1000, 5)
+    result = mt.angle(s1, deg=True)
+
+    adapter = TensorAngleAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(result.op, context)
+    expected_results = ["var_1 = np.angle(var_0, deg=True)"]
+    assert results == expected_results
+
+
+def test_binary_op():
+    s1 = mt.random.rand(1000, 5)
+    s2 = mt.random.rand(1000, 5)
+    result = s1 + s2
+
+    adapter = TensorBinOpAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(result.op, context)
+    expected_results = ["var_2 = np.add(var_0, var_1, casting='same_kind', order='K')"]
+    assert results == expected_results
+
+
+def test_isclose():
+    s1 = mt.random.rand(10, 5)
+    s2 = mt.random.rand(10, 5)
+    result = mt.isclose(s1, s2, rtol=0.1, atol=0.2)
+    adapter = TensorIscloseAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(result.op, context)
+    expected_results = [
+        "var_2 = np.isclose(var_0, var_1, equal_nan=False, rtol=0.1, atol=0.2)"
+    ]
+    assert results == expected_results
+
+
+def test_set_imag():
+    a = mt.array([1 + 2j, 3 + 4j, 5 + 6j])
+    a.imag = mt.array([8, 10, 12])
+    adapter = TensorSetImagAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(a.op, context)
+    expected_results = ["var_0.imag = var_1", "var_2 = var_0"]
+    assert results == expected_results
+
+
+def test_set_real():
+    a = mt.array([1 + 2j, 3 + 4j, 5 + 6j])
+    a.real = mt.array([8, 10, 12])
+    adapter = TensorSetRealAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(a.op, context)
+    expected_results = ["var_0.real = var_1", "var_2 = var_0"]
+    assert results == expected_results