maxframe 0.1.0b5__cp311-cp311-macosx_11_0_arm64.whl

maxframe/tensor/datasource/empty.py

@@ -0,0 +1,169 @@
+#!/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 ...serialization.serializables import KeyField, StringField
+from ..utils import get_order
+from .array import tensor
+from .core import TensorLike, TensorNoInput
+
+
+class TensorEmptyBase(object):
+    __slots__ = ()
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._gen_rand()
+
+    def _gen_rand(self):
+        if getattr(self, "_rand", None) is None:
+            self._obj_set("_rand", np.random.random())
+
+
+class TensorEmpty(TensorEmptyBase, TensorNoInput):
+    __slots__ = ("_rand",)
+    _op_type_ = opcodes.TENSOR_EMPTY
+
+    order = StringField("order", default=None)
+
+    def __init__(self, dtype=None, **kw):
+        dtype = np.dtype(dtype or "f8")
+        super().__init__(dtype=dtype, **kw)
+
+
+def empty(shape, dtype=None, chunk_size=None, gpu=None, order="C"):
+    """
+    Return a new tensor of given shape and type, without initializing entries.
+
+    Parameters
+    ----------
+    shape : int or tuple of int
+        Shape of the empty tensor
+    dtype : data-type, optional
+        Desired output data-type.
+    chunk_size : int or tuple of int or tuple of ints, optional
+        Desired chunk size on each dimension
+    gpu : bool, optional
+        Allocate the tensor on GPU if True, False as default
+    order : {'C', 'F'}, optional, default: 'C'
+        Whether to store multi-dimensional data in row-major
+        (C-style) or column-major (Fortran-style) order in
+        memory.
+
+    Returns
+    -------
+    out : Tensor
+        Tensor of uninitialized (arbitrary) data of the given shape, dtype, and
+        order.  Object arrays will be initialized to None.
+
+    See Also
+    --------
+    empty_like, zeros, ones
+
+    Notes
+    -----
+    `empty`, unlike `zeros`, does not set the array values to zero,
+    and may therefore be marginally faster.  On the other hand, it requires
+    the user to manually set all the values in the array, and should be
+    used with caution.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+    >>> mt.empty([2, 2]).execute()
+    array([[ -9.74499359e+001,   6.69583040e-309],
+           [  2.13182611e-314,   3.06959433e-309]])         #random
+    >>> mt.empty([2, 2], dtype=int).execute()
+    array([[-1073741821, -1067949133],
+           [  496041986,    19249760]])                     #random
+    """
+    tensor_order = get_order(
+        order,
+        None,
+        available_options="CF",
+        err_msg="only 'C' or 'F' order is permitted",
+    )
+    op = TensorEmpty(dtype=dtype, gpu=gpu, order=order)
+    return op(shape, chunk_size=chunk_size, order=tensor_order)
+
+
+class TensorEmptyLike(TensorEmptyBase, TensorLike):
+    __slots__ = ("_rand",)
+    _op_type_ = opcodes.TENSOR_EMPTY_LIKE
+
+    _input = KeyField("input")
+    order = StringField("order", default=None)
+
+    def __init__(self, dtype=None, gpu=None, sparse=False, **kw):
+        dtype = np.dtype(dtype) if dtype is not None else None
+        super().__init__(dtype=dtype, gpu=gpu, sparse=sparse, **kw)
+
+
+def empty_like(a, dtype=None, gpu=None, order="K"):
+    """
+    Return a new tensor with the same shape and type as a given tensor.
+
+    Parameters
+    ----------
+    a : array_like
+        The shape and data-type of `a` define these same attributes of the
+        returned tensor.
+    dtype : data-type, optional
+        Overrides the data type of the result.
+    gpu : bool, optional
+        Allocate the tensor on GPU if True, None as default
+    order : {'C', 'F', 'A', or 'K'}, optional
+        Overrides the memory layout of the result. 'C' means C-order,
+        'F' means F-order, 'A' means 'F' if ``prototype`` is Fortran
+        contiguous, 'C' otherwise. 'K' means match the layout of ``prototype``
+        as closely as possible.
+
+    Returns
+    -------
+    out : Tensor
+        Array of uninitialized (arbitrary) data with the same
+        shape and type as `a`.
+    See Also
+    --------
+    ones_like : Return a tensor of ones with shape and type of input.
+    zeros_like : Return a tensor of zeros with shape and type of input.
+    empty : Return a new uninitialized tensor.
+    ones : Return a new tensor setting values to one.
+    zeros : Return a new tensor setting values to zero.
+    Notes
+    -----
+    This function does *not* initialize the returned tensor; to do that use
+    `zeros_like` or `ones_like` instead.  It may be marginally faster than
+    the functions that do set the array values.
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+    >>> a = ([1,2,3], [4,5,6])                         # a is array-like
+    >>> mt.empty_like(a).execute()
+    array([[-1073741821, -1073741821,           3],    #ranm
+           [          0,           0, -1073741821]])
+    >>> a = mt.array([[1., 2., 3.],[4.,5.,6.]])
+    >>> mt.empty_like(a).execute()
+    array([[ -2.00000715e+000,   1.48219694e-323,  -2.00000572e+000],#random
+           [  4.38791518e-305,  -2.00000715e+000,   4.17269252e-309]])
+    """
+    a = tensor(a)
+    tensor_order = get_order(order, a.order)
+    gpu = a.op.gpu if gpu is None else gpu
+    op = TensorEmptyLike(dtype=dtype, gpu=gpu, sparse=a.issparse(), order=order)
+    return op(a, order=tensor_order)

maxframe/tensor/datasource/from_dataframe.py

@@ -0,0 +1,70 @@
+#!/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 ... import opcodes
+from ...serialization.serializables import BoolField, KeyField
+from ..core import TensorOrder
+from ..utils import to_numpy
+from .core import TensorHasInput
+
+
+class TensorFromDataFrame(TensorHasInput):
+    """represent tensor from DataFrame"""
+
+    _op_type_ = opcodes.TENSOR_FROM_DATAFRAME
+    _input = KeyField("_input")
+    extract_multi_index = BoolField("extract_multi_index", default=None)
+
+    def __call__(self, a, order=None):
+        from ...dataframe.core import INDEX_TYPE, IndexValue
+
+        if (
+            self.extract_multi_index
+            and isinstance(a, INDEX_TYPE)
+            and isinstance(a.index_value.value, IndexValue.MultiIndex)
+        ):
+            order = a.order if order is None else order
+            return self.new_tensor(
+                [a], (a.shape[0], len(a.index_value.value.names)), order=order
+            )
+        else:
+            self.extract_multi_index = False
+
+        return super().__call__(a, order=order)
+
+
+def from_dataframe(in_df, dtype=None):
+    from ...dataframe.utils import build_empty_df
+
+    if dtype is None:
+        empty_pdf = build_empty_df(in_df.dtypes)
+        dtype = to_numpy(empty_pdf).dtype
+    op = TensorFromDataFrame(dtype=dtype, gpu=in_df.op.gpu)
+    return op(in_df, order=TensorOrder.F_ORDER)  # return tensor with F-order always
+
+
+def from_series(in_series, dtype=None):
+    op = TensorFromDataFrame(dtype=dtype or in_series.dtype, gpu=in_series.op.gpu)
+    return op(in_series, order=TensorOrder.F_ORDER)  # return tensor with F-order always
+
+
+def from_index(in_index, dtype=None, extract_multi_index=False):
+    op = TensorFromDataFrame(
+        dtype=dtype or in_index.dtype,
+        gpu=in_index.op.gpu,
+        extract_multi_index=extract_multi_index,
+    )
+    return op(in_index, order=TensorOrder.F_ORDER)  # return tensor with F-order always

maxframe/tensor/datasource/from_dense.py

@@ -0,0 +1,54 @@
+#!/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 collections.abc import Iterable
+from functools import reduce
+from operator import and_
+
+import pandas as pd
+
+from ... import opcodes
+from ...serialization.serializables import AnyField, KeyField
+from .array import tensor
+from .core import TensorHasInput
+
+
+class DenseToSparse(TensorHasInput):
+    _op_type_ = opcodes.DENSE_TO_SPARSE
+
+    _input = KeyField("input")
+    missing = AnyField("missing", default=None)
+
+    def __init__(self, **kw):
+        super().__init__(sparse=True, **kw)
+
+    @staticmethod
+    def _get_mask(data, missing):
+        if isinstance(missing, Iterable):
+            return reduce(and_, (DenseToSparse._get_mask(data, m) for m in missing))
+        elif pd.isna(missing):
+            return ~pd.isna(data)
+        else:
+            return data != missing
+
+
+def fromdense(a, missing=None):
+    a = tensor(a)
+    if a.issparse():
+        return a
+
+    op = DenseToSparse(dtype=a.dtype, gpu=a.op.gpu, missing=missing)
+    return op(a)

maxframe/tensor/datasource/from_sparse.py

@@ -0,0 +1,47 @@
+#!/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 ... import opcodes
+from ...serialization.serializables import AnyField, KeyField, StringField
+from ..utils import get_order
+from .array import tensor
+from .core import TensorHasInput
+
+
+class SparseToDense(TensorHasInput):
+    _op_type_ = opcodes.SPARSE_TO_DENSE
+
+    _input = KeyField("input")
+    order = StringField("order", default=None)
+    fill_value = AnyField("fill_value", default=None)
+
+    def __init__(self, **kw):
+        super().__init__(sparse=False, **kw)
+
+
+def fromsparse(a, order="C", fill_value=None):
+    a = tensor(a)
+    if not a.issparse():
+        return a.astype(a.dtype, order=order, copy=False)
+
+    tensor_order = get_order(
+        order,
+        None,
+        available_options="CF",
+        err_msg="only 'C' or 'F' order is permitted",
+    )
+    op = SparseToDense(dtype=a.dtype, gpu=a.op.gpu, order=order, fill_value=fill_value)
+    return op(a, order=tensor_order)

maxframe/tensor/datasource/full.py

@@ -0,0 +1,186 @@
+#!/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 ...serialization.serializables import AnyField, KeyField, StringField
+from ..utils import get_order
+from .array import tensor
+from .core import TensorLike, TensorNoInput
+
+
+class TensorFull(TensorNoInput):
+    _op_type_ = opcodes.TENSOR_FULL
+
+    fill_value = AnyField("fill_value", default=None)
+    order = StringField("order", default=None)
+
+    def __init__(self, fill_value=None, dtype=None, **kw):
+        if dtype is not None:
+            dtype = np.dtype(dtype)
+            if fill_value is not None:
+                fill_value = dtype.type(fill_value)
+        elif fill_value is not None:
+            dtype = np.array(fill_value).dtype
+        super().__init__(fill_value=fill_value, dtype=dtype, **kw)
+
+
+def full(shape, fill_value, dtype=None, chunk_size=None, gpu=None, order="C"):
+    """
+    Return a new tensor of given shape and type, filled with `fill_value`.
+
+    Parameters
+    ----------
+    shape : int or sequence of ints
+        Shape of the new tensor, e.g., ``(2, 3)`` or ``2``.
+    fill_value : scalar
+        Fill value.
+    dtype : data-type, optional
+        The desired data-type for the tensor  The default, `None`, means
+         `np.array(fill_value).dtype`.
+    chunk_size : int or tuple of int or tuple of ints, optional
+        Desired chunk size on each dimension
+    gpu : bool, optional
+        Allocate the tensor on GPU if True, False as default
+    order : {'C', 'F'}, optional
+        Whether to store multidimensional data in C- or Fortran-contiguous
+        (row- or column-wise) order in memory.
+
+    Returns
+    -------
+    out : Tensor
+        Tensor of `fill_value` with the given shape, dtype, and order.
+
+    See Also
+    --------
+    zeros_like : Return a tensor of zeros with shape and type of input.
+    ones_like : Return a tensor of ones with shape and type of input.
+    empty_like : Return an empty tensor with shape and type of input.
+    full_like : Fill a tensor with shape and type of input.
+    zeros : Return a new tensor setting values to zero.
+    ones : Return a new tensor setting values to one.
+    empty : Return a new uninitialized tensor.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.full((2, 2), mt.inf).execute()
+    array([[ inf,  inf],
+           [ inf,  inf]])
+    >>> mt.full((2, 2), 10).execute()
+    array([[10, 10],
+           [10, 10]])
+
+    """
+    v = np.asarray(fill_value)
+    if len(v.shape) > 0:
+        from ..base import broadcast_to
+
+        return broadcast_to(
+            tensor(v, dtype=dtype, chunk_size=chunk_size, gpu=gpu, order=order), shape
+        )
+
+    tensor_order = get_order(
+        order,
+        None,
+        available_options="CF",
+        err_msg="only 'C' or 'F' order is permitted",
+    )
+    op = TensorFull(fill_value, dtype=dtype, gpu=gpu, order=order)
+    return op(shape, chunk_size=chunk_size, order=tensor_order)
+
+
+class TensorFullLike(TensorLike):
+    _op_type_ = opcodes.TENSOR_FULL_LIKE
+
+    _input = KeyField("input")
+    fill_value = AnyField("fill_value", default=None)
+    order = StringField("order", default=None)
+
+    def __init__(self, fill_value=None, dtype=None, gpu=None, sparse=False, **kw):
+        if dtype is not None:
+            dtype = np.dtype(dtype)
+            if fill_value is not None:
+                fill_value = dtype.type(fill_value)
+        elif fill_value is not None:
+            dtype = np.array(fill_value).dtype
+        super().__init__(
+            fill_value=fill_value, dtype=dtype, gpu=gpu, sparse=sparse, **kw
+        )
+
+
+def full_like(a, fill_value, dtype=None, gpu=None, order="K"):
+    """
+    Return a full tensor with the same shape and type as a given tensor.
+
+    Parameters
+    ----------
+    a : array_like
+        The shape and data-type of `a` define these same attributes of
+        the returned tensor.
+    fill_value : scalar
+        Fill value.
+    dtype : data-type, optional
+        Overrides the data type of the result.
+    gpu : bool, optional
+        Allocate the tensor on GPU if True, None as default
+    order : {'C', 'F', 'A', or 'K'}, optional
+        Overrides the memory layout of the result. 'C' means C-order,
+        'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
+        'C' otherwise. 'K' means match the layout of `a` as closely
+        as possible.
+
+    Returns
+    -------
+    out : Tensor
+        Tensor of `fill_value` with the same shape and type as `a`.
+
+    See Also
+    --------
+    empty_like : Return an empty tensor with shape and type of input.
+    ones_like : Return a tensor of ones with shape and type of input.
+    zeros_like : Return a tensor of zeros with shape and type of input.
+    full : Return a new tensor of given shape filled with value.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+    >>> x = mt.arange(6, dtype=int)
+    >>> mt.full_like(x, 1).execute()
+    array([1, 1, 1, 1, 1, 1])
+    >>> mt.full_like(x, 0.1).execute()
+    array([0, 0, 0, 0, 0, 0])
+    >>> mt.full_like(x, 0.1, dtype=mt.double).execute()
+    array([ 0.1,  0.1,  0.1,  0.1,  0.1,  0.1])
+    >>> mt.full_like(x, mt.nan, dtype=mt.double).execute()
+    array([ nan,  nan,  nan,  nan,  nan,  nan])
+
+    >>> y = mt.arange(6, dtype=mt.double)
+    >>> mt.full_like(y, 0.1).execute()
+    array([ 0.1,  0.1,  0.1,  0.1,  0.1,  0.1])
+
+    """
+    a = tensor(a)
+    tensor_order = get_order(order, a.order)
+    if dtype is None:
+        dtype = a.dtype
+    gpu = a.op.gpu if gpu is None else gpu
+    op = TensorFullLike(
+        fill_value=fill_value, dtype=dtype, gpu=gpu, sparse=a.issparse()
+    )
+    return op(a, order=tensor_order)

maxframe/tensor/datasource/ones.py

@@ -0,0 +1,173 @@
+#!/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 ...serialization.serializables import (
+    AnyField,
+    FieldTypes,
+    KeyField,
+    StringField,
+    TupleField,
+)
+from ..utils import get_order
+from .array import tensor
+from .core import TensorLike, TensorNoInput
+
+
+class TensorOnes(TensorNoInput):
+    _op_type_ = opcodes.TENSOR_ONES
+
+    order = StringField("order")
+    shape = TupleField("shape", FieldTypes.int64)
+    chunk_size = AnyField("chunk_size")
+
+    def __init__(self, shape=None, **kwargs):
+        if type(shape) is int:
+            shape = (shape,)
+        super().__init__(shape=shape, **kwargs)
+
+
+def ones(shape, dtype=None, chunk_size=None, gpu=None, order="C"):
+    """
+    Return a new tensor of given shape and type, filled with ones.
+
+    Parameters
+    ----------
+    shape : int or sequence of ints
+        Shape of the new tensor, e.g., ``(2, 3)`` or ``2``.
+    dtype : data-type, optional
+        The desired data-type for the tensor, e.g., `mt.int8`.  Default is
+        `mt.float64`.
+    chunk_size : int or tuple of int or tuple of ints, optional
+        Desired chunk size on each dimension
+    gpu : bool, optional
+        Allocate the tensor on GPU if True, False as default
+    order : {'C', 'F'}, optional, default: C
+        Whether to store multi-dimensional data in row-major
+        (C-style) or column-major (Fortran-style) order in
+        memory.
+
+    Returns
+    -------
+    out : Tensor
+        Tensor of ones with the given shape, dtype, and order.
+
+    See Also
+    --------
+    zeros, ones_like
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.ones(5).execute()
+    array([ 1.,  1.,  1.,  1.,  1.])
+
+    >>> mt.ones((5,), dtype=int).execute()
+    array([1, 1, 1, 1, 1])
+
+    >>> mt.ones((2, 1)).execute()
+    array([[ 1.],
+           [ 1.]])
+
+    >>> s = (2,2)
+    >>> mt.ones(s).execute()
+    array([[ 1.,  1.],
+           [ 1.,  1.]])
+
+    """
+    tensor_order = get_order(
+        order,
+        None,
+        available_options="CF",
+        err_msg="only 'C' or 'F' order is permitted",
+    )
+    dtype = np.dtype(dtype or "f8")
+    op = TensorOnes(
+        dtype=dtype, shape=shape, chunk_size=chunk_size, gpu=gpu, order=order
+    )
+    return op(shape, chunk_size=chunk_size, order=tensor_order)
+
+
+class TensorOnesLike(TensorLike):
+    _op_type_ = opcodes.TENSOR_ONES_LIKE
+
+    _input = KeyField("input")
+
+    def __init__(self, dtype=None, sparse=False, **kw):
+        dtype = np.dtype(dtype) if dtype is not None else None
+        super().__init__(dtype=dtype, sparse=sparse, **kw)
+
+
+def ones_like(a, dtype=None, gpu=None, order="K"):
+    """
+    Return a tensor of ones with the same shape and type as a given tensor.
+
+    Parameters
+    ----------
+    a : array_like
+        The shape and data-type of `a` define these same attributes of
+        the returned tensor.
+    dtype : data-type, optional
+        Overrides the data type of the result.
+    gpu : bool, optional
+        Allocate the tensor on GPU if True, None as default
+    order : {'C', 'F', 'A', or 'K'}, optional
+        Overrides the memory layout of the result. 'C' means C-order,
+        'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
+        'C' otherwise. 'K' means match the layout of `a` as closely
+        as possible.
+
+    Returns
+    -------
+    out : Tensor
+        Tensor of ones with the same shape and type as `a`.
+
+    See Also
+    --------
+    zeros_like : Return a tensor of zeros with shape and type of input.
+    empty_like : Return a empty tensor with shape and type of input.
+    zeros : Return a new tensor setting values to zero.
+    ones : Return a new tensor setting values to one.
+    empty : Return a new uninitialized tensor.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> x = mt.arange(6)
+    >>> x = x.reshape((2, 3))
+    >>> x.execute()
+    array([[0, 1, 2],
+           [3, 4, 5]])
+    >>> mt.ones_like(x).execute()
+    array([[1, 1, 1],
+           [1, 1, 1]])
+
+    >>> y = mt.arange(3, dtype=float)
+    >>> y.execute()
+    array([ 0.,  1.,  2.])
+    >>> mt.ones_like(y).execute()
+    array([ 1.,  1.,  1.])
+
+    """
+    a = tensor(a)
+    tensor_order = get_order(order, a.order)
+    gpu = a.op.gpu if gpu is None else gpu
+    op = TensorOnesLike(dtype=dtype, gpu=gpu, sparse=a.issparse(), order=order)
+    return op(a, order=tensor_order)