maxframe 0.1.0b5__cp39-cp39-macosx_11_0_arm64.whl

maxframe/tensor/arithmetic/clip.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# 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 numbers import Number
+
+import numpy as np
+
+from ... import opcodes
+from ...core import ENTITY_TYPE
+from ...serialization.serializables import AnyField, KeyField
+from ..core import Tensor
+from ..datasource import tensor as astensor
+from ..utils import broadcast_shape
+from .core import TensorElementWise, TensorOperator, filter_inputs
+
+
+class TensorClip(TensorOperator, TensorElementWise):
+    _op_type_ = opcodes.CLIP
+
+    a = KeyField("a", default=None)
+    a_min = AnyField("a_min", default=None)
+    a_max = AnyField("a_max", default=None)
+    out = KeyField("out", default=None)
+
+    def _set_inputs(self, inputs):
+        super()._set_inputs(inputs)
+        inputs_iter = iter(self._inputs)
+        self.a = next(inputs_iter)
+        if isinstance(self.a_min, ENTITY_TYPE):
+            self.a_min = next(inputs_iter)
+        if isinstance(self.a_max, ENTITY_TYPE):
+            self.a_max = next(inputs_iter)
+        if getattr(self, "_out", None) is not None:
+            self.out = next(inputs_iter)
+
+    def __call__(self, a, a_min, a_max, out=None):
+        a = astensor(a)
+        tensors = [a]
+        sparse = a.issparse()
+
+        if isinstance(a_min, Number):
+            if a_min > 0:
+                sparse = False
+            a_min_dtype = np.array(a_min).dtype
+        elif a_min is not None:
+            a_min = astensor(a_min)
+            tensors.append(a_min)
+            if not a_min.issparse():
+                sparse = False
+            a_min_dtype = a_min.dtype
+        else:
+            a_min_dtype = None
+        self.a_min = a_min
+
+        if isinstance(a_max, Number):
+            if a_max < 0:
+                sparse = False
+            a_max_dtype = np.array(a_max).dtype
+        elif a_max is not None:
+            a_max = astensor(a_max)
+            tensors.append(a_max)
+            if not a_max.issparse():
+                sparse = False
+            a_max_dtype = a_max.dtype
+        else:
+            a_max_dtype = None
+        self.a_max = a_max
+
+        if out is not None:
+            if isinstance(out, Tensor):
+                self.out = out
+            else:
+                raise TypeError(f"out should be Tensor object, got {type(out)} instead")
+
+        dtypes = [dt for dt in [a.dtype, a_min_dtype, a_max_dtype] if dt is not None]
+        dtype = np.result_type(*dtypes)
+        # check broadcast
+        shape = broadcast_shape(*[t.shape for t in tensors])
+
+        setattr(self, "sparse", sparse)
+        inputs = filter_inputs([a, a_min, a_max, out])
+        t = self.new_tensor(inputs, shape)
+
+        if out is None:
+            setattr(self, "dtype", dtype)
+            return t
+
+        # if `out` is specified, use out's dtype and shape
+        out_shape, out_dtype = out.shape, out.dtype
+
+        if t.shape != out_shape:
+            t = self.new_tensor(inputs, out_shape)
+        setattr(self, "dtype", out_dtype)
+
+        out.data = t.data
+        return out
+
+
+def clip(a, a_min, a_max, out=None):
+    """
+    Clip (limit) the values in a tensor.
+
+    Given an interval, values outside the interval are clipped to
+    the interval edges.  For example, if an interval of ``[0, 1]``
+    is specified, values smaller than 0 become 0, and values larger
+    than 1 become 1.
+
+    Parameters
+    ----------
+    a : array_like
+        Tensor containing elements to clip.
+    a_min : scalar or array_like or `None`
+        Minimum value. If `None`, clipping is not performed on lower
+        interval edge. Not more than one of `a_min` and `a_max` may be
+        `None`.
+    a_max : scalar or array_like or `None`
+        Maximum value. If `None`, clipping is not performed on upper
+        interval edge. Not more than one of `a_min` and `a_max` may be
+        `None`. If `a_min` or `a_max` are array_like, then the three
+        arrays will be broadcasted to match their shapes.
+    out : Tensor, optional
+        The results will be placed in this tensor. It may be the input
+        array for in-place clipping.  `out` must be of the right shape
+        to hold the output.  Its type is preserved.
+
+    Returns
+    -------
+    clipped_array : Tensor
+        An tensor with the elements of `a`, but where values
+        < `a_min` are replaced with `a_min`, and those > `a_max`
+        with `a_max`.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> a = mt.arange(10)
+    >>> mt.clip(a, 1, 8).execute()
+    array([1, 1, 2, 3, 4, 5, 6, 7, 8, 8])
+    >>> a.execute()
+    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+    >>> mt.clip(a, 3, 6, out=a).execute()
+    array([3, 3, 3, 3, 4, 5, 6, 6, 6, 6])
+    >>> a = mt.arange(10)
+    >>> a.execute()
+    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+    >>> mt.clip(a, [3, 4, 1, 1, 1, 4, 4, 4, 4, 4], 8).execute()
+    array([3, 4, 2, 3, 4, 5, 6, 7, 8, 8])
+
+    """
+    op = TensorClip(a=a, a_min=a_min, a_max=a_max, out=out)
+    return op(a, a_min, a_max, out=out)

maxframe/tensor/arithmetic/conj.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# 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 infer_dtype
+from .core import TensorUnaryOp
+from .utils import arithmetic_operator
+
+
+@arithmetic_operator(sparse_mode="unary")
+class TensorConj(TensorUnaryOp):
+    _op_type_ = opcodes.CONJ
+    _func_name = "conj"
+
+
+@infer_dtype(np.conj)
+def conj(x, out=None, where=None, **kwargs):
+    """
+    Return the complex conjugate, element-wise.
+
+    The complex conjugate of a complex number is obtained by changing the
+    sign of its imaginary part.
+
+    Parameters
+    ----------
+    x : array_like
+        Input value.
+    out : Tensor, None, or tuple of Tensor and None, optional
+        A location into which the result is stored. If provided, it must have
+        a shape that the inputs broadcast to. If not provided or `None`,
+        a freshly-allocated tensor is returned. A tuple (possible only as a
+        keyword argument) must have length equal to the number of outputs.
+    where : array_like, optional
+        Values of True indicate to calculate the ufunc at that position, values
+        of False indicate to leave the value in the output alone.
+    **kwargs
+
+    Returns
+    -------
+    y : Tensor
+        The complex conjugate of `x`, with same dtype as `y`.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.conjugate(1+2j).execute()
+    (1-2j)
+
+    >>> x = mt.eye(2) + 1j * mt.eye(2)
+    >>> mt.conjugate(x).execute()
+    array([[ 1.-1.j,  0.-0.j],
+           [ 0.-0.j,  1.-1.j]])
+    """
+    op = TensorConj(**kwargs)
+    return op(x, out=out, where=where)
+
+
+conjugate = conj

maxframe/tensor/arithmetic/copysign.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# 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 infer_dtype
+from .core import TensorBinOp
+from .utils import arithmetic_operator
+
+
+@arithmetic_operator(sparse_mode="always_false")
+class TensorCopysign(TensorBinOp):
+    _op_type_ = opcodes.COPYSIGN
+    _func_name = "copysign"
+
+
+@infer_dtype(np.copysign)
+def copysign(x1, x2, out=None, where=None, **kwargs):
+    """
+    Change the sign of x1 to that of x2, element-wise.
+
+    If both arguments are arrays or sequences, they have to be of the same
+    length. If `x2` is a scalar, its sign will be copied to all elements of
+    `x1`.
+
+    Parameters
+    ----------
+    x1 : array_like
+        Values to change the sign of.
+    x2 : array_like
+        The sign of `x2` is copied to `x1`.
+    out : Tensor, None, or tuple of Tensor and None, optional
+        A location into which the result is stored. If provided, it must have
+        a shape that the inputs broadcast to. If not provided or `None`,
+        a freshly-allocated tensor is returned. A tuple (possible only as a
+        keyword argument) must have length equal to the number of outputs.
+    where : array_like, optional
+        Values of True indicate to calculate the ufunc at that position, values
+        of False indicate to leave the value in the output alone.
+    **kwargs
+
+    Returns
+    -------
+    out : array_like
+        The values of `x1` with the sign of `x2`.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.copysign(1.3, -1).execute()
+    -1.3
+    >>> (1/mt.copysign(0, 1)).execute()
+    inf
+    >>> (1/mt.copysign(0, -1)).execute()
+    -inf
+
+    >>> mt.copysign([-1, 0, 1], -1.1).execute()
+    array([-1., -0., -1.])
+    >>> mt.copysign([-1, 0, 1], mt.arange(3)-1).execute()
+    array([-1.,  0.,  1.])
+    """
+    op = TensorCopysign(**kwargs)
+    return op(x1, x2, out=out, where=where)