text
stringlengths 17
362k
| id
stringlengths 13
115
| metadata
dict | __index_level_0__
int64 0
75
|
|---|---|---|---|
from . import functional
| ivy/ivy/functional/frontends/paddle/nn/__init__.py/0 | {
"file_path": "ivy/ivy/functional/frontends/paddle/nn/__init__.py",
"repo_id": "ivy",
"token_count": 5
} | 32 |
# local
from ..attribute import * # noqa: F401
| ivy/ivy/functional/frontends/paddle/tensor/attribute.py/0 | {
"file_path": "ivy/ivy/functional/frontends/paddle/tensor/attribute.py",
"repo_id": "ivy",
"token_count": 16
} | 33 |
import ivy
import ivy.functional.frontends.pandas.series as series
from typing import Iterable
class Index:
def __init__(self, data, dtype=None, copy=False, name=None, tupleize_cols=True):
self.index = data
self.tokens = None
if not isinstance(data, ivy.Array):
try:
self.index_array = ivy.array(data, dtype=dtype)
except ivy.utils.exceptions.IvyBackendException:
# labels as strings
if isinstance(data, (list, tuple)):
self.tokens = data
self.index_array = Index._tokenize_1d(data)
else:
# todo: handle other cases
raise NotImplementedError
else:
self.index_array = data
self.tokens_exist = self.tokens is not None
self.dtype = dtype
self.name = name
self.copy = copy
self.tupleize_cols = tupleize_cols
@staticmethod
def _tokenize_1d(x: Iterable):
return ivy.array([v for v, _ in enumerate(x)])
def __repr__(self):
if self.tokens_exist:
return f"Index({list(self.tokens)})"
return f"Index({self.index_array.to_list()})"
def __getitem__(self, item):
if self.tokens_exist:
if isinstance(item, (list, tuple)):
return Index(self.tokens[item])
return self.tokens[item]
elif isinstance(item, (list, tuple)):
return Index(self.index_array[item])
return self.index_array[item]
def __len__(self):
return len(self.index_array)
def __iter__(self):
return iter(self.index_array.to_list())
@property
def ndim(self):
return self.index_array.ndim
@property
def size(self):
return self.index_array.size
@property
def array(self):
return self.index_array
@property
def shape(self):
return tuple(self.index_array.shape)
@property
def has_duplicates(self):
return not self.is_unique()
def unique(self, level=None):
# todo handle level with mutliindexer
self.index_array = ivy.unique_values(self)
return Index(self.index_array, dtype=self.dtype, copy=self.copy, name=self.name)
def is_unique(self):
uniques = ivy.unique_values(self)
return len(uniques) == len(self.index_array)
def to_list(self):
return self.index_array.to_list()
def to_numpy(self, dtype=None, copy=False, na_value=ivy.nan, **kwargs):
if dtype:
return self.index_array.astype(dtype).to_numpy(copy=copy)
return self.index_array.to_numpy(copy=copy)
def to_series(self, index=None, name=None):
if index is None:
index = self.index_array
return series.Series(index, index=index, name=name)
def min(self, axis=None, skipna=True, *args, **kwargs):
return self.index_array.min()
def max(self, axis=None, skipna=True, *args, **kwargs):
return self.index_array.max()
def isin(self, values, level=None):
# todo handle level with mutliindexer
return ivy.isin(self.index_array, values)
| ivy/ivy/functional/frontends/pandas/index.py/0 | {
"file_path": "ivy/ivy/functional/frontends/pandas/index.py",
"repo_id": "ivy",
"token_count": 1497
} | 34 |
from . import _samples_generator
from ._samples_generator import *
| ivy/ivy/functional/frontends/sklearn/datasets/__init__.py/0 | {
"file_path": "ivy/ivy/functional/frontends/sklearn/datasets/__init__.py",
"repo_id": "ivy",
"token_count": 20
} | 35 |
# global
import sys
# local
import ivy
from ivy.utils.exceptions import handle_exceptions
from ivy.functional.frontends import set_frontend_to_specific_version
from numbers import Number
from typing import Union, Tuple, Iterable
from .dtypes import DType
# Constructing dtypes are required as ivy.<dtype>
# will change dynamically on the backend and may not be available
tensorflow_enum_to_type = {
1: ivy.FloatDtype("float32"),
2: ivy.FloatDtype("float64"),
3: ivy.IntDtype("int32"),
4: ivy.UintDtype("uint8"),
5: ivy.IntDtype("int16"),
6: ivy.IntDtype("int8"),
8: ivy.ComplexDtype("complex64"),
9: ivy.IntDtype("int64"),
10: ivy.Dtype("bool"),
14: ivy.FloatDtype("bfloat16"),
17: ivy.UintDtype("uint16"),
18: ivy.ComplexDtype("complex128"),
19: ivy.FloatDtype("float16"),
22: ivy.UintDtype("uint32"),
23: ivy.UintDtype("uint64"),
}
tensorflow_type_to_enum = {v: k for k, v in tensorflow_enum_to_type.items()}
float32 = DType(1)
float64 = DType(2)
int32 = DType(3)
uint8 = DType(4)
int16 = DType(5)
int8 = DType(6)
int64 = DType(9)
bool = DType(10)
bfloat16 = DType(14)
uint16 = DType(17)
float16 = DType(19)
uint32 = DType(22)
uint64 = DType(23)
# type aliases
double = float64
half = float16
@handle_exceptions
def check_tensorflow_casting(x1, x2):
"""Check whether the two arguments provided in the function have the same
dtype, unless one of them is an array_like or scalar, where it gets casted
to the other input's dtype.
Parameters
----------
x1
First argument which can be tensor, array_like or scalar
x2
Second argument which can be tensor, array_like or scalar
Returns
-------
x1
First tensor promoted accordingly.
x2
Second tensor promoted accordingly.
"""
if hasattr(x1, "dtype") and not hasattr(x2, "dtype"):
x1 = ivy.asarray(x1)
x2 = ivy.asarray(x2, dtype=x1.dtype)
elif hasattr(x2, "dtype") and not hasattr(x1, "dtype"):
x2 = ivy.asarray(x2)
x1 = ivy.asarray(x1, dtype=x2.dtype)
else:
x1 = ivy.asarray(x1)
if not hasattr(x2, "dtype"):
x2 = ivy.asarray(x2, dtype=x1.dtype)
ivy.utils.assertions.check_same_dtype(x1, x2)
return x1, x2
from . import dtypes
from .dtypes import as_dtype, cast
from . import ragged
from .ragged import *
from . import tensor
from .tensor import EagerTensor, Tensor
from .tensorarray import TensorArray
from . import variable
from .variable import Variable, IndexedSlices
from .python.ops.resource_variable_ops import ResourceVariable
from . import keras
from . import compat
from . import image
from . import linalg
from .linalg import matmul, tensordot, eig, eye, norm
from . import math
from .math import *
from . import nest
from . import nn
from . import __operators__
from . import quantization
from . import random
from . import general_functions
from .general_functions import *
from . import raw_ops
from . import sets
from . import signal
from . import sparse
_frontend_array = constant
# setting to specific version #
# --------------------------- #
if ivy.is_local():
module = ivy.utils._importlib.import_cache[__name__]
else:
module = sys.modules[__name__]
__version__ = set_frontend_to_specific_version(module)
| ivy/ivy/functional/frontends/tensorflow/__init__.py/0 | {
"file_path": "ivy/ivy/functional/frontends/tensorflow/__init__.py",
"repo_id": "ivy",
"token_count": 1308
} | 36 |
# global
# local
import ivy
import ivy.functional.frontends.tensorflow as tf_frontend
class Variable:
def __init__(self, array, trainable=True, name=None, dtype=None):
self._ivy_array = (
ivy.array(array) if not isinstance(array, ivy.Array) else array
)
self._ivy_array = (
ivy.astype(self._ivy_array, dtype) if dtype is not None else self._ivy_array
)
self.trainable = trainable
def __repr__(self):
return (
repr(self._ivy_array).replace(
"ivy.array", "ivy.frontends.tensorflow.Variable"
)[:-1]
+ ", shape="
+ str(self._ivy_array.shape)
+ ", dtype="
+ str(self._ivy_array.dtype)
+ ")"
)
# Properties #
# ---------- #
@property
def ivy_array(self):
return self._ivy_array
@property
def device(self):
return self._ivy_array.device
@property
def dtype(self):
return tf_frontend.DType(
tf_frontend.tensorflow_type_to_enum[self._ivy_array.dtype]
)
@property
def shape(self):
return self._ivy_array.shape
# Instance Methods #
# ---------------- #
def assign(self, value, use_locking=None, name=None, read_value=True):
ivy.utils.assertions.check_equal(
value.ivy_array.shape if hasattr(value, "ivy_array") else ivy.shape(value),
self.shape,
as_array=False,
)
self._ivy_array = value._ivy_array
def assign_add(self, delta, use_locking=None, name=None, read_value=True):
ivy.utils.assertions.check_equal(
delta.ivy_array.shape if hasattr(delta, "ivy_array") else ivy.shape(delta),
self.shape,
as_array=False,
)
self._ivy_array = tf_frontend.math.add(self._ivy_array, delta._ivy_array)
def assign_sub(self, delta, use_locking=None, name=None, read_value=True):
ivy.utils.assertions.check_equal(
delta.ivy_array.shape if hasattr(delta, "ivy_array") else ivy.shape(delta),
self.shape,
as_array=False,
)
self._ivy_array = tf_frontend.math.subtract(self._ivy_array, delta._ivy_array)
def batch_scatter_update(
self, sparse_delta, use_locking=None, name=None, read_value=True
):
pass
def gather_nd(self, indices, name=None):
return tf_frontend.gather_nd(params=self._ivy_array, indices=indices)
def read_value(self):
return tf_frontend.Tensor(self._ivy_array)
def scatter_add(self, sparse_delta, use_locking=None, name=None, read_value=True):
pass
def scatter_div(self, sparse_delta, use_locking=None, name=None, read_value=True):
pass
def scatter_max(self, sparse_delta, use_locking=None, name=None, read_value=True):
pass
def scatter_min(self, sparse_delta, use_locking=None, name=None, read_value=True):
pass
def scatter_mul(self, sparse_delta, use_locking=None, name=None, read_value=True):
pass
def scatter_nd_add(self, indices, updates, use_locking=None, name=None):
pass
def scatter_nd_sub(self, indices, updates, use_locking=None, name=None):
pass
def scatter_nd_update(self, indices, updates, use_locking=None, name=None):
pass
def scatter_sub(self, sparse_delta, use_locking=None, name=None, read_value=True):
pass
def scatter_update(
self, sparse_delta, use_locking=None, name=None, read_value=True
):
pass
def set_shape(self, shape):
if shape is None:
return
x_shape = self._ivy_array.shape
if len(x_shape) != len(shape):
raise ValueError(
f"Tensor's shape {x_shape} is not compatible with supplied shape "
f"{shape}."
)
for i, v in enumerate(x_shape):
if v != shape[i] and (shape[i] is not None):
raise ValueError(
f"Tensor's shape {x_shape} is not compatible with supplied shape "
f"{shape}."
)
def get_shape(self):
return self._ivy_array.shape
def sparse_read(self, indices, name=None):
pass
def __add__(self, y, name="add"):
return self.__radd__(y)
def __div__(self, x, name="div"):
return tf_frontend.math.divide(x, self._ivy_array, name=name)
def __and__(self, y, name="and"):
return y.__rand__(self._ivy_array)
def __eq__(self, other):
return tf_frontend.raw_ops.Equal(
x=self._ivy_array, y=other, incompatible_shape_error=False
)
def __floordiv__(self, y, name="floordiv"):
return y.__rfloordiv__(self._ivy_array)
def __ge__(self, y, name="ge"):
return tf_frontend.raw_ops.GreaterEqual(
x=self._ivy_array, y=y._ivy_array, name=name
)
def __getitem__(self, slice_spec, var=None, name="getitem"):
ret = ivy.get_item(self._ivy_array, slice_spec)
return Variable(ivy.array(ret, dtype=ivy.dtype(ret), copy=False))
def __gt__(self, y, name="gt"):
return tf_frontend.raw_ops.Greater(x=self._ivy_array, y=y._ivy_array, name=name)
def __invert__(self, name="invert"):
return tf_frontend.raw_ops.Invert(x=self._ivy_array, name=name)
def __le__(self, y, name="le"):
return tf_frontend.raw_ops.LessEqual(
x=self._ivy_array, y=y._ivy_array, name=name
)
def __lt__(self, y, name="lt"):
return tf_frontend.raw_ops.Less(x=self._ivy_array, y=y._ivy_array, name=name)
def __matmul__(self, y, name="matmul"):
return y.__rmatmul__(self._ivy_array)
def __mul__(self, x, name="mul"):
return tf_frontend.math.multiply(x, self._ivy_array, name=name)
def __mod__(self, x, name="mod"):
return tf_frontend.math.mod(x, self._ivy_array, name=name)
def __ne__(self, other):
return tf_frontend.raw_ops.NotEqual(
x=self._ivy_array, y=other._ivy_array, incompatible_shape_error=False
)
def __neg__(self, name="neg"):
return tf_frontend.raw_ops.Neg(x=self._ivy_array, name=name)
def __or__(self, y, name="or"):
return y.__ror__(self._ivy_array)
def __pow__(self, y, name="pow"):
return tf_frontend.math.pow(x=self, y=y, name=name)
def __radd__(self, x, name="radd"):
return tf_frontend.math.add(x, self._ivy_array, name=name)
def __rand__(self, x, name="rand"):
return tf_frontend.math.logical_and(x, self._ivy_array, name=name)
def __rfloordiv__(self, x, name="rfloordiv"):
return tf_frontend.raw_ops.FloorDiv(x=x, y=self._ivy_array, name=name)
def __rmatmul__(self, x, name="rmatmul"):
return tf_frontend.raw_ops.MatMul(a=x, b=self._ivy_array, name=name)
def __rmul__(self, x, name="rmul"):
return tf_frontend.raw_ops.Mul(x=x, y=self._ivy_array, name=name)
def __ror__(self, x, name="ror"):
return tf_frontend.raw_ops.LogicalOr(x=x, y=self._ivy_array, name=name)
def __rpow__(self, x, name="rpow"):
return tf_frontend.raw_ops.Pow(x=x, y=self._ivy_array, name=name)
def __rsub__(self, x, name="rsub"):
return tf_frontend.math.subtract(x, self._ivy_array, name=name)
def __rtruediv__(self, x, name="rtruediv"):
return tf_frontend.math.truediv(x, self._ivy_array, name=name)
def __rxor__(self, x, name="rxor"):
return tf_frontend.math.logical_xor(x, self._ivy_array, name=name)
def __sub__(self, y, name="sub"):
return y.__rsub__(self._ivy_array)
def __truediv__(self, y, name="truediv"):
dtype = ivy.dtype(self._ivy_array)
if dtype in [ivy.uint8, ivy.int8, ivy.uint16, ivy.int16]:
return ivy.astype(y, ivy.float32).__rtruediv__(
ivy.astype(self._ivy_array, ivy.float32)
)
if dtype in [ivy.uint32, ivy.int32, ivy.uint64, ivy.int64]:
return ivy.astype(y, ivy.float64).__rtruediv__(
ivy.astype(self._ivy_array, ivy.float64)
)
return y.__rtruediv__(self._ivy_array)
def __xor__(self, y, name="xor"):
return y.__rxor__(self._ivy_array)
def __setitem__(self, key, value):
raise ivy.utils.exceptions.IvyException(
"ivy.functional.frontends.tensorflow.Variable object "
"doesn't support assignment"
)
class IndexedSlices:
def __init__(self, values, indices, dense_shape=None):
self._values = values
self._indices = indices
self._dense_shape = dense_shape
@property
def values(self):
"""A `Tensor` containing the values of the slices."""
return self._values
@property
def indices(self):
"""A 1-D `Tensor` containing the indices of the slices."""
return self._indices
@property
def dense_shape(self):
"""A 1-D `Tensor` containing the shape of the corresponding dense
tensor."""
return self._dense_shape
@property
def device(self):
"""The name of the device on which `values` will be produced, or
`None`."""
return self.values.device
@property
def dtype(self):
"""The `DType` of elements in this tensor."""
return self.values.dtype
def __repr__(self):
return "IndexedSlices(\nindices=%s,\nvalues=%s%s\n)" % (
self._indices,
self._values,
(
f", dense_shape={self._dense_shape}"
if self._dense_shape is not None
else ""
),
)
def __neg__(self):
return IndexedSlices(-self._values, self._indices, self._dense_shape)
| ivy/ivy/functional/frontends/tensorflow/variable.py/0 | {
"file_path": "ivy/ivy/functional/frontends/tensorflow/variable.py",
"repo_id": "ivy",
"token_count": 4711
} | 37 |
# local
import ivy
from ivy.func_wrapper import with_unsupported_dtypes
from ivy.functional.frontends.torch.func_wrapper import to_ivy_arrays_and_back
# ToDo: this function will be simplified once ivy.alpha_dropout is implemented
@to_ivy_arrays_and_back
@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch")
@with_unsupported_dtypes({"2.6.0 and below": ("float16", "bfloat16")}, "paddle")
def alpha_dropout(input, p=0.5, training=False, inplace=False):
if p == 0.0 or not training or input.shape == () or input.shape == (0,):
return input
neg_saturation = ivy.log1p(ivy.exp(-ivy.square(input)))
mask = ivy.where(
ivy.random_uniform(shape=input.shape, device=ivy.dev(input)) < p,
0.0,
1.0,
)
if inplace:
ivy.inplace_update(input, mask * input + (1 - mask) * neg_saturation)
ivy.inplace_update(input, input / ivy.sqrt(1 - p / (1 - p + 1e-5)))
return input
else:
masked = mask * input + (1 - mask) * neg_saturation
return masked / ivy.sqrt(1 - p / (1 - p + 1e-5))
@to_ivy_arrays_and_back
@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch")
def dropout(input, p=0.5, training=True, inplace=False):
return ivy.dropout(input, p, scale=True, training=training)
@to_ivy_arrays_and_back
@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch")
def dropout1d(input, p=0.5, training=True, inplace=False):
if inplace:
return ivy.dropout1d(input, p, training=training, data_format="NCW", out=input)
return ivy.dropout1d(input, p, training=training, data_format="NCW")
@to_ivy_arrays_and_back
@with_unsupported_dtypes({"2.2 and below": ("float16",)}, "torch")
def dropout2d(input, p=0.5, training=True, inplace=False):
if input.ndim < 2:
raise ValueError("Feature dropout requires at least 2 dimensions in the input")
ret = ivy.dropout2d(input, p, training=training, data_format="NCHW")
if inplace:
ivy.inplace_update(input, ret)
return input
return ret
@to_ivy_arrays_and_back
@with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch")
def dropout3d(input, p=0.5, training=True, inplace=False):
if inplace:
return ivy.dropout3d(
input, p, training=training, data_format="NDHWC", out=input
)
return ivy.dropout3d(input, p, training=training, data_format="NDHWC")
| ivy/ivy/functional/frontends/torch/nn/functional/dropout_functions.py/0 | {
"file_path": "ivy/ivy/functional/frontends/torch/nn/functional/dropout_functions.py",
"repo_id": "ivy",
"token_count": 1023
} | 38 |
import ivy
from ivy.func_wrapper import (
with_unsupported_dtypes,
)
from ivy.functional.frontends.torch.func_wrapper import (
to_ivy_arrays_and_back,
)
@with_unsupported_dtypes({"2.2 and below": ("float16", "complex")}, "torch")
@to_ivy_arrays_and_back
def erfc(input, *, out=None):
return 1.0 - ivy.erf(input, out=out)
@with_unsupported_dtypes({"2.2 and below": ("float16", "complex", "bfloat16")}, "torch")
@to_ivy_arrays_and_back
def erfcx(input, *, out=None):
ret = erfc(input) * ivy.exp(input**2)
return ret
@to_ivy_arrays_and_back
def erfinv(input, *, out=None):
return ivy.erfinv(input, out=out)
| ivy/ivy/functional/frontends/torch/special/special_funcs.py/0 | {
"file_path": "ivy/ivy/functional/frontends/torch/special/special_funcs.py",
"repo_id": "ivy",
"token_count": 276
} | 39 |
import ivy
from ivy.functional.frontends.sklearn.base import BaseEstimator as XGBModelBase
from ivy.functional.frontends.sklearn.base import ClassifierMixin as XGBClassifierBase
from .training import train
from .core import Booster
class XGBModel(XGBModelBase):
def __init__(
self,
max_depth=None,
max_leaves=None,
max_bin=None,
grow_policy=None,
learning_rate=None,
n_estimators=None,
verbosity=None,
objective=None,
booster=None,
tree_method=None,
n_jobs=None,
gamma=None,
min_child_weight=None,
max_delta_step=None,
subsample=None,
sampling_method=None,
colsample_bytree=None,
colsample_bylevel=None,
colsample_bynode=None,
reg_alpha=None,
reg_lambda=None,
scale_pos_weight=None,
base_score=None,
random_state=None,
missing=None,
num_parallel_tree=None,
monotone_constraints=None,
interaction_constraints=None,
importance_type=None,
device=None,
validate_parameters=None,
enable_categorical=False,
feature_types=None,
max_cat_to_onehot=None,
max_cat_threshold=None,
multi_strategy=None,
eval_metric=None,
early_stopping_rounds=None,
callbacks=None,
**kwargs,
):
self.n_estimators = n_estimators
self.objective = objective
self.max_depth = max_depth
self.max_leaves = max_leaves
self.max_bin = max_bin
self.grow_policy = grow_policy
self.learning_rate = learning_rate
self.verbosity = verbosity
self.booster = booster
self.tree_method = tree_method
self.gamma = gamma
self.min_child_weight = min_child_weight
self.max_delta_step = max_delta_step
self.subsample = subsample
self.sampling_method = sampling_method
self.colsample_bytree = colsample_bytree
self.colsample_bylevel = colsample_bylevel
self.colsample_bynode = colsample_bynode
self.reg_alpha = reg_alpha
self.reg_lambda = reg_lambda
self.scale_pos_weight = scale_pos_weight
self.base_score = base_score
self.missing = missing
self.num_parallel_tree = num_parallel_tree
self.random_state = random_state
self.n_jobs = n_jobs
self.monotone_constraints = monotone_constraints
self.interaction_constraints = interaction_constraints
self.importance_type = importance_type
self.device = device
self.validate_parameters = validate_parameters
self.enable_categorical = enable_categorical
self.feature_types = feature_types
self.max_cat_to_onehot = max_cat_to_onehot
self.max_cat_threshold = max_cat_threshold
self.multi_strategy = multi_strategy
self.eval_metric = eval_metric
self.early_stopping_rounds = early_stopping_rounds
self.callbacks = callbacks
self.compiled = False
if kwargs:
self.kwargs = kwargs
def __sklearn_is_fitted__(self):
return hasattr(self, "_Booster")
def get_booster(self):
"""Get the underlying xgboost Booster of this model. This will raise an
exception when fit was not called.
Returns
-------
booster : a xgboost booster of underlying model
"""
if not self.__sklearn_is_fitted__():
raise TypeError("need to call fit or load_model beforehand")
return self._Booster
def get_params(self, deep=True):
params = self.__dict__
# if kwargs is a dict, update params accordingly
if hasattr(self, "kwargs") and isinstance(self.kwargs, dict):
params.update(self.kwargs)
# take random_state into account only if it's an integer
if isinstance(params["random_state"], int):
ivy.seed(seed_value=params["random_state"])
return params
def get_xgb_params(self):
"""Get xgboost specific parameters."""
params = self.get_params()
# Parameters that should not go into native learner.
wrapper_specific = {
"importance_type",
"kwargs",
"missing",
"n_estimators",
"use_label_encoder",
"enable_categorical",
"early_stopping_rounds",
"callbacks",
"feature_types",
}
filtered = {}
for k, v in params.items():
if k not in wrapper_specific and not callable(v):
filtered[k] = v
return filtered
def get_num_boosting_rounds(self):
"""Gets the number of xgboost boosting rounds."""
# 100 is the default number of boosting rounds
return 100 if not self.n_estimators else self.n_estimators
def compile(self, X, y):
# set compiled flag
self.compiled = True
# instantiate Booster and compile funcs involved in calculations for training
params = self.get_xgb_params()
self._Booster = Booster(params, cache=[X, y], compile=True)
def fit(
self,
X,
y,
*,
sample_weight=None,
base_margin=None,
eval_set=None,
eval_metric=None,
early_stopping_rounds=None,
verbose=True,
xgb_model=None,
sample_weight_eval_set=None,
base_margin_eval_set=None,
feature_weights=None,
callbacks=None,
):
"""Fit gradient boosting model.
Note that calling ``fit()`` multiple times will cause the model object to be
re-fit from scratch. To resume training from a previous checkpoint, explicitly
pass ``xgb_model`` argument.
Parameters
----------
X
Feature matrix.
When the ``tree_method`` is set to ``hist``, internally, the
`QuantileDMatrix` will be used instead of the `DMatrix`
for conserving memory. However, this has performance implications when the
device of input data is not matched with algorithm. For instance, if the
input is a numpy array on CPU but ``cuda`` is used for training, then the
data is first processed on CPU then transferred to GPU.
y
Labels.
sample_weight
instance weights.
base_margin
global bias for each instance.
eval_set
A list of (X, y) tuple pairs to use as validation sets, for which
metrics will be computed.
Validation metrics will help us track the performance of the model.
eval_metric
str, list of str, or callable, optional(deprecated in fit method).
early_stopping_rounds
int(deprecated in fit method).
verbose
If `verbose` is True and an evaluation set is used, the evaluation metric
measured on the validation set is printed to stdout at each boosting stage.
If `verbose` is an integer, the evaluation metric is printed at each
`verbose` boosting stage. The last boosting stage / the boosting stage found
by using `early_stopping_rounds` is also printed.
xgb_model
file name of stored XGBoost model or 'Booster' instance XGBoost model to be
loaded before training (allows training continuation).
sample_weight_eval_set
A list of the form [L_1, L_2, ..., L_n], where each L_i is an array like
object storing instance weights for the i-th validation set.
base_margin_eval_set
A list of the form [M_1, M_2, ..., M_n], where each M_i is an array like
object storing base margin for the i-th validation set.
feature_weights
Weight for each feature, defines the probability of each feature being
selected when colsample is being used. All values must be greater than 0,
otherwise a `ValueError` is thrown.
callbacks
(deprecated in fit method).
"""
# skip all the validation as we're interested in calculations for now
# ToDo: add handling for custom objective
if self.compiled:
for i in range(self.get_num_boosting_rounds()):
self._Booster.update(X, y, i)
else:
params = self.get_xgb_params()
self._Booster = train(params, X, y, self.get_num_boosting_rounds())
return self
def predict(
self,
X,
output_margin=False,
validate_features=True,
base_margin=None,
iteration_range=None,
):
"""
Parameters
----------
X
Data to predict with.
output_margin
Whether to output the raw untransformed margin value.
validate_features
When this is True, validate that the Booster's and data's feature_names are
identical. Otherwise, it is assumed that the feature_names are the same.
base_margin
Margin added to prediction.
iteration_range
Specifies which layer of trees are used in prediction. For example, if a
random forest is trained with 100 rounds. Specifying ``iteration_range=(10,
20)``, then only the forests built during [10, 20) (half open set) rounds
are used in this prediction.
Returns
-------
prediction
"""
# skip the validation, as for now we simply call the predict method of
# underlying booster
return self.get_booster().predict(
data=X,
iteration_range=iteration_range,
output_margin=output_margin,
validate_features=validate_features,
)
class XGBClassifier(XGBModel, XGBClassifierBase):
# as for now simply calls the init method of a parent class, because we implement a
# minimal subset of functionality
def __init__(self, *, objective="binary:logistic", **kwargs):
super().__init__(objective=objective, **kwargs)
| ivy/ivy/functional/frontends/xgboost/sklearn.py/0 | {
"file_path": "ivy/ivy/functional/frontends/xgboost/sklearn.py",
"repo_id": "ivy",
"token_count": 4455
} | 40 |
# local
from typing import Optional, Union, Tuple, List, Sequence
from numbers import Number
import ivy
from ivy.func_wrapper import (
handle_out_argument,
to_native_arrays_and_back,
handle_nestable,
handle_partial_mixed_function,
handle_array_like_without_promotion,
inputs_to_ivy_arrays,
handle_array_function,
infer_dtype,
handle_device,
handle_backend_invalid,
)
from ivy.utils.exceptions import handle_exceptions
@handle_backend_invalid
@handle_nestable
@handle_array_like_without_promotion
@handle_out_argument
@to_native_arrays_and_back
@handle_array_function
@handle_device
def amax(
x: Union[ivy.Array, ivy.NativeArray],
/,
*,
axis: Optional[Union[int, Sequence[int]]] = None,
keepdims: bool = False,
out: Optional[ivy.Array] = None,
) -> ivy.Array:
"""Calculate the maximum value of the input array ``x``.
.. note::
``amax`` is an alias of ``max`` and both function
behaves similarly in every backend except PyTorch and PaddlePaddle
(see `PyTorch's amax function
documentation<https://pytorch.org/docs/stable/generated/torch.amax.html>`_`)
(see `PaddlePaddle's amax function documentation<https://www.paddlepaddle.org.cn/
documentation/docs/zh/api/paddle/amax_cn.html>`_`)
.. note::
When the number of elements over which to compute the maximum value is zero, the
maximum value is implementation-defined. Specification-compliant libraries may
choose to raise an error, return a sentinel value (e.g., if ``x`` is a
floating-point input array, return ``NaN``), or return the minimum possible
value for the input array ``x`` data type (e.g., if ``x`` is a floating-point
array, return ``-infinity``).
**Special Cases**
For floating-point operands,
- If ``x_i`` is ``NaN``, the maximum value is ``NaN``
(i.e., ``NaN`` values propagate).
Parameters
----------
x
input array. Should have a real-valued data type.
axis
axis or axes along which maximum values must be computed. By default, the
maximum value must be computed over the entire array. If a tuple of integers,
maximum values must be computed over multiple axes. Default: ``None``.
keepdims
optional boolean, if ``True``, the reduced axes (dimensions) must be included
in the result as singleton dimensions, and, accordingly, the result must be
compatible with the input array (see `broadcasting<https://data-apis.org/
array-api/latest/API_specification/broadcasting.html#broadcasting>`_).
Otherwise, if ``False``, the reduced axes (dimensions)
must not be included in the result.
Default: ``False``.
out
optional output array, for writing the result to.
Returns
-------
ret
if the maximum value was computed over the entire array, a zero-dimensional
array containing the maximum value; otherwise, a non-zero-dimensional array
containing the maximum values. The returned array must have the same data type
as ``x``.
This function conforms to the `Array API Standard
<https://data-apis.org/array-api/latest/>`_. This docstring is an extension of the
`docstring <https://data-apis.org/array-api/latest/
API_specification/generated/array_api.max.html>`_
in the standard.
Both the description and the type hints above assumes an array input for simplicity,
but this function is *nestable*, and therefore also accepts :class:`ivy.Container`
instances in place of any of the arguments.
Examples
--------
With :class:`ivy.Array` input:
>>> x = ivy.array([1, 2, 3])
>>> y = ivy.amax(x)
>>> print(y)
ivy.array(3)
>>> x = ivy.array([0, 1, 2])
>>> z = ivy.array([0, 0, 0])
>>> y = ivy.amax(x, out=z)
>>> print(z)
ivy.array(2)
>>> x = ivy.array([[0, 1, 2], [4, 6, 10]])
>>> y = ivy.amax(x, axis=0, keepdims=True)
>>> print(y)
ivy.array([[4, 6, 10]])
>>> x = ivy.native_array([[0, 1, 2], [4, 6, 10]])
>>> y = ivy.amax(x)
>>> print(y)
ivy.array(10)
With :class:`ivy.Container` input:
>>> x = ivy.Container(a=ivy.array([1, 2, 3]), b=ivy.array([2, 3, 4]))
>>> y = ivy.amax(x)
>>> print(y)
{
a: ivy.array(3),
b: ivy.array(4)
}
"""
return ivy.current_backend(x).amax(x, axis=axis, keepdims=keepdims, out=out)
@handle_backend_invalid
@handle_nestable
@handle_array_like_without_promotion
@handle_out_argument
@to_native_arrays_and_back
@handle_array_function
@handle_device
def amin(
x: Union[ivy.Array, ivy.NativeArray],
/,
*,
axis: Optional[Union[int, Sequence[int]]] = None,
keepdims: bool = False,
out: Optional[ivy.Array] = None,
) -> ivy.Array:
"""Calculate the minimum value of the input array ``x``.
.. note::
``amin`` is an alias of ``min`` and both function
behaves similarly in every backend except PyTorch and PaddlePaddle
(see `PyTorch's amin function
documentation<https://pytorch.org/docs/stable/generated/torch.amin.html>`_`)
(see `PaddlePaddle's amin function documentation<https://www.paddlepaddle.org.cn/
documentation/docs/zh/api/paddle/amin_cn.html>`_`)
.. note::
When the number of elements over which to compute the minimum value is zero, the
minimum value is implementation-defined. Specification-compliant libraries may
choose to raise an error, return a sentinel value (e.g., if ``x`` is a
floating-point input array, return ``NaN``), or return the maximum possible value
for the input array ``x`` data type (e.g., if ``x`` is a floating-point array,
return ``+infinity``).
**Special Cases**
For floating-point operands,
- If ``x_i`` is ``NaN``, the minimum value is ``NaN``
(i.e., ``NaN`` values propagate).
Parameters
----------
x
input array. Should have a real-valued data type.
axis
axis or axes along which minimum values must be computed. By default, the
minimum value must be computed over the entire array. If a tuple of integers,
minimum values must be computed over multiple axes. Default: ``None``.
keepdims
optional boolean, if ``True``, the reduced axes (dimensions) must be included
in the result as singleton dimensions, and, accordingly, the result must be
compatible with the input array (see `broadcasting<https://data-apis.org/
array-api/latest/API_specification/broadcasting.html#broadcasting>`_).
Otherwise, if ``False``, the reduced axes (dimensions)
must not be included in the result.
Default: ``False``.
out
optional output array, for writing the result to.
Returns
-------
ret
if the minimum value was computed over the entire array, a zero-dimensional
array containing the minimum value; otherwise, a non-zero-dimensional array
containing the minimum values. The returned array must have the same data type
as ``x``.
This function conforms to the `Array API Standard
<https://data-apis.org/array-api/latest/>`_. This docstring is an extension of the
`docstring <https://data-apis.org/array-api/latest/
API_specification/generated/array_api.min.html>`_
in the standard.
Both the description and the type hints above assumes an array input for simplicity,
but this function is *nestable*, and therefore also accepts :class:`ivy.Container`
instances in place of any of the arguments.
Examples
--------
With :class:`ivy.Array` input:
>>> x = ivy.array([1, 2, 3])
>>> y = ivy.amin(x)
>>> print(y)
ivy.array(1)
>>> x = ivy.array([0, 1, 2])
>>> z = ivy.array([0, 0, 0])
>>> y = ivy.amin(x, out=z)
>>> print(z)
ivy.array(0)
>>> x = ivy.array([[0, 1, 2], [4, 6, 10]])
>>> y = ivy.amin(x, axis=0, keepdims=True)
>>> print(y)
ivy.array([[0, 1, 2]])
>>> x = ivy.native_array([[0, 1, 2], [4, 6, 10]])
>>> y = ivy.amin(x)
>>> print(y)
ivy.array(0)
With :class:`ivy.Container` input:
>>> x = ivy.Container(a=ivy.array([1, 2, 3]), b=ivy.array([2, 3, 4]))
>>> y = ivy.amin(x)
>>> print(y)
{
a: ivy.array(1),
b: ivy.array(2)
}
"""
return ivy.current_backend(x).amin(x, axis=axis, keepdims=keepdims, out=out)
@handle_exceptions
@handle_backend_invalid
@handle_nestable
@handle_array_like_without_promotion
@handle_out_argument
@to_native_arrays_and_back
@handle_array_function
def lgamma(
x: Union[ivy.Array, ivy.NativeArray],
/,
*,
out: Optional[ivy.Array] = None,
) -> ivy.Array:
"""Compute the natural logarithm of the absolute value of the gamma
function on x.
Parameters
----------
x
input array. Should have a floating-point data type.
out
optional output array, for writing the result to. It must have a shape that the
inputs broadcast to.
Returns
-------
ret
an array containing the natural log of Gamma(x) of each element in x.
The returned array must have a floating-point data type determined
by :ref:`type-promotion`.
Examples
--------
>>> x = ivy.array([1.6, 2.6, 3.5])
>>> y = x.lgamma()
>>> print(y)
ivy.array([-0.11259177, 0.3574118 , 1.20097363])
>>> x = ivy.array([1., 2., 3. ])
>>> y = x.lgamma()
>>> print(y)
ivy.array([0. ,0. ,0.69314718])
>>> x = ivy.array([4.5, -4, -5.6])
>>> x.lgamma(out = x)
>>> print(x)
ivy.array([2.45373654, inf, -4.6477685 ])
"""
return ivy.current_backend(x).lgamma(x, out=out)
@handle_exceptions
@handle_backend_invalid
@handle_nestable
@handle_array_like_without_promotion
@handle_out_argument
@to_native_arrays_and_back
@handle_device
def sinc(
x: Union[ivy.Array, ivy.NativeArray],
/,
*,
out: Optional[ivy.Array] = None,
) -> ivy.Array:
"""Calculate an implementation-dependent approximation of the principal
value of the normalized sinc function, having domain ``(-infinity,
+infinity)`` and codomain ``[-0.217234, 1]``, for each element ``x_i`` of
the input array ``x``. Each element ``x_i`` is assumed to be expressed in
radians.
**Special cases**
For floating-point operands,
- If x_i is NaN, the result is NaN.
- If ``x_i`` is ``0``, the result is ``1``.
- If ``x_i`` is either ``+infinity`` or ``-infinity``, the result is ``NaN``.
Parameters
----------
x
input array. Should have a floating-point data type.
out
optional output array, for writing the result to. It must have a shape that the
inputs broadcast to.
Returns
-------
ret
an array containing the normalized sinc function of each element in x.
The returned array must have a floating-point data type determined
by :ref:`type-promotion`.
Examples
--------
With :class:`ivy.Array` input:
>>> x = ivy.array([0.5, 1.5, 2.5, 3.5])
>>> y = x.sinc()
>>> print(y)
ivy.array([0.637,-0.212,0.127,-0.0909])
>>> x = ivy.array([1.5, 0.5, -1.5])
>>> y = ivy.zeros(3)
>>> ivy.sinc(x, out=y)
>>> print(y)
ivy.array([-0.212,0.637,-0.212])
With :class:`ivy.NativeArray` input:
>>> x = ivy.array([0.5, 1.5, 2.5, 3.5])
>>> y = ivy.sinc(x)
>>> print(y)
ivy.array([0.637,-0.212,0.127,-0.0909])
With :class:`ivy.Container` input:
>>> x = ivy.Container(a=ivy.array([0.5, 1.5, 2.5]),
... b=ivy.array([3.5, 4.5, 5.5]))
>>> y = x.sinc()
>>> print(y)
{
a: ivy.array([0.637,-0.212,0.127]),
b: ivy.array([-0.0909,0.0707,-0.0579])
}
"""
return ivy.current_backend(x).sinc(x, out=out)
@handle_backend_invalid
@handle_nestable
@handle_out_argument
@to_native_arrays_and_back
@handle_device
def fmax(
x1: Union[ivy.Array, ivy.NativeArray],
x2: Union[ivy.Array, ivy.NativeArray],
/,
*,
out: Optional[Union[ivy.Array, ivy.NativeArray]] = None,
) -> Union[ivy.Array, ivy.NativeArray]:
"""Compute the element-wise maximums of two arrays. Differs from
ivy.maximum in the case where one of the elements is NaN. ivy.maximum
returns the NaN element while ivy.fmax returns the non-NaN element.
Parameters
----------
x1
First input array.
x2
Second input array.
out
optional output array, for writing the result to.
Returns
-------
ret
Array with element-wise maximums.
Examples
--------
>>> x1 = ivy.array([2, 3, 4])
>>> x2 = ivy.array([1, 5, 2])
>>> ivy.fmax(x1, x2)
ivy.array([ 2., 5., 4.])
>>> x1 = ivy.array([ivy.nan, 0, ivy.nan])
>>> x2 = ivy.array([0, ivy.nan, ivy.nan])
>>> ivy.fmax(x1, x2)
ivy.array([ 0., 0., nan])
"""
return ivy.current_backend().fmax(x1, x2, out=out)
@handle_backend_invalid
@handle_nestable
@handle_out_argument
@to_native_arrays_and_back
@handle_device
def float_power(
x1: Union[ivy.Array, float, list, tuple],
x2: Union[ivy.Array, float, list, tuple],
/,
*,
out: Optional[ivy.Array] = None,
) -> ivy.Array:
"""Raise each base in x1 to the positionally-corresponding power in x2. x1
and x2 must be broadcastable to the same shape. This differs from the power
function in that integers, float16, and float32 are promoted to floats with
a minimum precision of float64 so that the result is always inexact.
Parameters
----------
x1
Array-like with elements to raise in power.
x2
Array-like of exponents. If x1.shape != x2.shape,
they must be broadcastable to a common shape
(which becomes the shape of the output).
out
optional output array, for writing the result to.
Returns
-------
ret
The bases in x1 raised to the exponents in x2.
This is a scalar if both x1 and x2 are scalars
Examples
--------
>>> x1 = ivy.array([1, 2, 3, 4, 5])
>>> ivy.float_power(x1, 3)
ivy.array([1., 8., 27., 64., 125.])
>>> x1 = ivy.array([1, 2, 3, 4, 5])
>>> x2 = ivy.array([2, 3, 3, 2, 1])
>>> ivy.float_power(x1, x2)
ivy.array([1., 8., 27., 16., 5.])
"""
return ivy.current_backend().float_power(x1, x2, out=out)
@handle_exceptions
@handle_backend_invalid
@handle_nestable
@handle_out_argument
@to_native_arrays_and_back
@handle_device
def copysign(
x1: Union[ivy.Array, ivy.NativeArray, Number],
x2: Union[ivy.Array, ivy.NativeArray, Number],
/,
*,
out: Optional[Union[ivy.Array, ivy.NativeArray]] = None,
) -> ivy.Array:
"""Change the signs of x1 to match x2 x1 and x2 must be broadcastable to a
common shape.
Parameters
----------
x1
Array or scalar to change the sign of
x2
Array or scalar from which the new signs are applied
Unsigned zeroes are considered positive.
out
optional output array, for writing the result to.
Returns
-------
ret
x1 with the signs of x2.
This is a scalar if both x1 and x2 are scalars.
Examples
--------
>>> x1 = ivy.array([-1, 0, 23, 2])
>>> x2 = ivy.array([1, -1, -10, 44])
>>> ivy.copysign(x1, x2)
ivy.array([ 1., -0., -23., 2.])
>>> ivy.copysign(x1, -1)
ivy.array([ -1., -0., -23., -2.])
>>> ivy.copysign(-10, 1)
ivy.array(10.)
"""
return ivy.current_backend().copysign(x1, x2, out=out)
@handle_exceptions
@handle_backend_invalid
@handle_nestable
@handle_array_like_without_promotion
@to_native_arrays_and_back
@infer_dtype
@handle_device
def count_nonzero(
a: Union[ivy.Array, ivy.NativeArray],
/,
*,
axis: Optional[Union[int, Tuple[int, ...]]] = None,
keepdims: bool = False,
dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None,
out: Optional[Union[ivy.Array, ivy.NativeArray]] = None,
) -> ivy.Array:
"""Count the number of non-zero values in the array a.
Parameters
----------
a
array for which to count non-zeros.
axis
optional axis or tuple of axes along which to count non-zeros. Default is
None, meaning that non-zeros will be counted along a flattened
version of the input array.
keepdims
optional, if this is set to True, the axes that are counted are left in the
result as dimensions with size one. With this option, the result
will broadcast correctly against the input array.
dtype
optional output dtype. Default is of type integer.
out
optional output array, for writing the result to.
Returns
-------
ret
Number of non-zero values in the array along a given axis. Otherwise,
the total number of non-zero values in the array is returned.
Examples
--------
>>> a = ivy.array([[0, 1, 2, 3],[4, 5, 6, 7]])
>>> ivy.count_nonzero(a)
ivy.array(7)
>>> a = ivy.array([[0, 1, 2, 3],[4, 5, 6, 7]])
>>> ivy.count_nonzero(a, axis=0)
ivy.array([1, 2, 2, 2])
>>> a = ivy.array([[[0,1],[2,3]],[[4,5],[6,7]]])
>>> ivy.count_nonzero(a, axis=(0,1), keepdims=True)
ivy.array([[[3, 4]]])
"""
return ivy.current_backend().count_nonzero(
a, axis=axis, keepdims=keepdims, dtype=dtype, out=out
)
@handle_exceptions
@handle_backend_invalid
@handle_nestable
@handle_array_like_without_promotion
@handle_out_argument
@to_native_arrays_and_back
@infer_dtype
@handle_device
def nansum(
x: Union[ivy.Array, ivy.NativeArray],
/,
*,
axis: Optional[Union[Tuple[int, ...], int]] = None,
dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None,
keepdims: bool = False,
out: Optional[ivy.Array] = None,
) -> ivy.Array:
"""Return the sum of array elements over a given axis treating Not a
Numbers (NaNs) as zero.
Parameters
----------
x
Input array.
axis
Axis or axes along which the sum is computed.
The default is to compute the sum of the flattened array.
dtype
The type of the returned array and of the accumulator in
which the elements are summed. By default, the dtype of input is used.
keepdims
If this is set to True, the axes which are reduced are left
in the result as dimensions with size one.
out
Alternate output array in which to place the result.
The default is None.
Returns
-------
ret
A new array holding the result is returned unless out is specified,
in which it is returned.
Examples
--------
>>> a = ivy.array([[ 2.1, 3.4, ivy.nan], [ivy.nan, 2.4, 2.1]])
>>> ivy.nansum(a)
10.0
>>> ivy.nansum(a, axis=0)
ivy.array([2.1, 5.8, 2.1])
>>> ivy.nansum(a, axis=1)
ivy.array([5.5, 4.5])
"""
return ivy.current_backend().nansum(
x, axis=axis, dtype=dtype, keepdims=keepdims, out=out
)
@handle_exceptions
@handle_backend_invalid
@handle_nestable
@handle_array_like_without_promotion
@handle_out_argument
@to_native_arrays_and_back
@handle_device
def isclose(
a: Union[ivy.Array, ivy.NativeArray],
b: Union[ivy.Array, ivy.NativeArray],
/,
*,
rtol: float = 1e-05,
atol: float = 1e-08,
equal_nan: bool = False,
out: Optional[ivy.Array] = None,
) -> ivy.Array:
"""Return a boolean array where two arrays are element-wise equal within a
tolerance.
The tolerance values are positive, typically very small numbers.
The relative difference (rtol * abs(b)) and the absolute difference
atol are added together to compare against the absolute difference
between a and b.
The default atol is not appropriate for comparing numbers that are
much smaller than one
Parameters
----------
a
First input array.
b
Second input array.
rtol
The relative tolerance parameter.
atol
The absolute tolerance parameter.
equal_nan
Whether to compare NaN's as equal. If True, NaN's in a will be
considered equal to NaN's in b in the output array.
out
Alternate output array in which to place the result.
The default is None.
Returns
-------
ret
Returns a boolean array of where a and b are equal within the given
tolerance. If both a and b are scalars, returns a single boolean value.
Examples
--------
>>> ivy.isclose([1e10,1e-7], [1.00001e10,1e-8])
ivy.array([True, False])
>>> ivy.isclose([1.0, ivy.nan], [1.0, ivy.nan], equal_nan=True)
ivy.array([True, True])
>>> ivy.isclose([1e-100, 1e-7], [0.0, 0.0], atol=0.0)
ivy.array([False, False])
>>> ivy.isclose([1e-10, 1e-10], [1e-20, 0.999999e-10], rtol=0.005, atol=0.0)
ivy.array([False, True])
"""
return ivy.current_backend().isclose(
a, b, rtol=rtol, atol=atol, equal_nan=equal_nan, out=out
)
@handle_backend_invalid
@handle_nestable
@handle_array_like_without_promotion
@handle_out_argument
@to_native_arrays_and_back
@handle_device
def signbit(
x: Union[ivy.Array, ivy.NativeArray, float, int, list, tuple],
/,
*,
out: Optional[ivy.Array] = None,
) -> ivy.Array:
"""Return element-wise True where signbit is set (less than zero).
Parameters
----------
x
Array-like input.
out
optional output array, for writing the result to.
Returns
-------
ret
Output array, or reference to out if that was supplied.
This is a scalar if x is a scalar.
Examples
--------
>>> x = ivy.array([1, -2, 3])
>>> ivy.signbit(x)
ivy.array([False, True, False])
"""
return ivy.current_backend(x).signbit(x, out=out)
@handle_backend_invalid
@handle_nestable
@handle_out_argument
@to_native_arrays_and_back
@handle_device
def hypot(
x1: Union[ivy.Array, ivy.NativeArray],
x2: Union[ivy.Array, ivy.NativeArray],
/,
*,
out: Optional[Union[ivy.Array, ivy.NativeArray]] = None,
) -> Union[ivy.Array, ivy.NativeArray]:
"""Return the hypotenuse given the two sides of a right angle triangle.
Parameters
----------
x1
The first input array
x2
The second input array
Returns
-------
ret
An array with the hypotenuse
Examples
--------
>>> a = ivy.array([3.0, 4.0, 5.0])
>>> b = ivy.array([4.0, 5.0, 6.0])
>>> ivy.hypot(a, b)
ivy.array([5.0, 6.4031, 7.8102])
"""
return ivy.current_backend(x1, x2).hypot(x1, x2, out=out)
@handle_backend_invalid
@handle_nestable
@handle_array_like_without_promotion
@handle_out_argument
@to_native_arrays_and_back
@handle_device
def diff(
x: Union[ivy.Array, ivy.NativeArray, list, tuple],
/,
*,
n: int = 1,
axis: int = -1,
prepend: Optional[Union[ivy.Array, ivy.NativeArray, int, list, tuple]] = None,
append: Optional[Union[ivy.Array, ivy.NativeArray, int, list, tuple]] = None,
out: Optional[ivy.Array] = None,
) -> ivy.Array:
"""Return the n-th discrete difference along the given axis.
Parameters
----------
x
Array-like input.
n
The number of times values are differenced. If zero, the input is returned
as-is.
axis
The axis along which the difference is taken, default is the last axis.
prepend,append
Values to prepend/append to x along given axis prior to performing the
difference. Scalar values are expanded to arrays with length 1 in the direction
of axis and the shape of the input array in along all other axes. Otherwise the
dimension and shape must match x except along axis.
out
optional output array, for writing the result to.
Returns
-------
ret
Returns the n-th discrete difference along the given axis.
Both the description and the type hints above assumes an array input for simplicity,
but this function is *nestable*, and therefore also accepts :class:`ivy.Container`
instances in place of any of the arguments.
Examples
--------
>>> x = ivy.array([1, 2, 4, 7, 0])
>>> ivy.diff(x)
ivy.array([ 1, 2, 3, -7])
"""
return ivy.current_backend().diff(
x, n=n, axis=axis, prepend=prepend, append=append, out=out
)
@handle_exceptions
@handle_backend_invalid
@handle_nestable
@handle_array_like_without_promotion
@to_native_arrays_and_back
@handle_device
def allclose(
a: Union[ivy.Array, ivy.NativeArray],
b: Union[ivy.Array, ivy.NativeArray],
/,
*,
rtol: float = 1e-05,
atol: float = 1e-08,
equal_nan: bool = False,
out: Optional[ivy.Array] = None,
) -> bool:
"""Return a True if the two arrays are element-wise equal within given
tolerance; otherwise False.
The tolerance values are positive, typically very small numbers.
The relative difference (rtol * abs(x2)) and the absolute difference
atol are added together to compare against the absolute difference
between x1 and x2.
The default atol is not appropriate for comparing numbers that are
much smaller than one
Parameters
----------
x1
First input array.
x2
Second input array.
rtol
The relative tolerance parameter.
atol
The absolute tolerance parameter.
equal_nan
Whether to compare NaN's as equal. If True, NaN's in x1 will be
considered equal to NaN's in x2 in the output array.
out
Alternate output array in which to place the result.
The default is None.
Returns
-------
ret
Returns True if the two arrays are equal within the given tolerance;
False otherwise.
Examples
--------
>>> x1 = ivy.array([1e10, 1e-7])
>>> x2 = ivy.array([1.00001e10, 1e-8])
>>> y = ivy.allclose(x1, x2)
>>> print(y)
ivy.array(False)
>>> x1 = ivy.array([1.0, ivy.nan])
>>> x2 = ivy.array([1.0, ivy.nan])
>>> y = ivy.allclose(x1, x2, equal_nan=True)
>>> print(y)
ivy.array(True)
>>> x1 = ivy.array([1e-10, 1e-10])
>>> x2 = ivy.array([1.00001e-10, 1e-10])
>>> y = ivy.allclose(x1, x2, rtol=0.005, atol=0.0)
>>> print(y)
ivy.array(True)
"""
return ivy.current_backend().allclose(
a, b, rtol=rtol, atol=atol, equal_nan=equal_nan, out=out
)
@handle_backend_invalid
@handle_nestable
@handle_array_like_without_promotion
@handle_out_argument
@to_native_arrays_and_back
@handle_device
def fix(
x: Union[ivy.Array, ivy.NativeArray, float, int, list, tuple],
/,
*,
out: Optional[ivy.Array] = None,
) -> ivy.Array:
"""Round an array of floats element-wise to nearest integer towards zero.
The rounded values are returned as floats.
Parameters
----------
x
Array input.
out
optional output array, for writing the result to.
Returns
-------
ret
Array of floats with elements corresponding to input elements
rounded to nearest integer towards zero, element-wise.
Examples
--------
>>> x = ivy.array([2.1, 2.9, -2.1])
>>> ivy.fix(x)
ivy.array([ 2., 2., -2.])
"""
return ivy.current_backend(x).fix(x, out=out)
@handle_exceptions
@handle_backend_invalid
@handle_nestable
@handle_array_like_without_promotion
@handle_out_argument
@to_native_arrays_and_back
@handle_device
def nextafter(
x1: Union[ivy.Array, ivy.NativeArray],
x2: Union[ivy.Array, ivy.NativeArray],
/,
*,
out: Optional[ivy.Array] = None,
) -> bool:
"""Return the next floating-point value after x1 towards x2, element-wise.
Parameters
----------
x1
First input array.
x2
Second input array.
out
Alternate output array in which to place the result.
The default is None.
Returns
-------
ret
The next representable values of x1 in the direction of x2.
Examples
--------
>>> x1 = ivy.array([1.0e-50, 2.0e+50])
>>> x2 = ivy.array([2.0, 1.0])
>>> ivy.nextafter(x1, x2)
ivy.array([1.4013e-45., 3.4028e+38])
"""
return ivy.current_backend(x1, x2).nextafter(x1, x2, out=out)
@handle_exceptions
@handle_backend_invalid
@handle_nestable
@handle_array_like_without_promotion
@handle_out_argument
@to_native_arrays_and_back
@handle_device
def zeta(
x: Union[ivy.Array, ivy.NativeArray],
q: Union[ivy.Array, ivy.NativeArray],
/,
*,
out: Optional[ivy.Array] = None,
) -> bool:
"""Compute the Hurwitz zeta function elementwisely with each pair of floats
in two arrays.
Parameters
----------
x
First input array.
q
Second input array, must have the same shape as the first input array
out
Alternate output array in which to place the result.
The default is None.
Returns
-------
ret
Array with values computed from zeta function from
input arrays' values.
Examples
--------
>>> x = ivy.array([5.0, 3.0])
>>> q = ivy.array([2.0, 2.0])
>>> ivy.zeta(x, q)
ivy.array([0.0369, 0.2021])
"""
return ivy.current_backend(x, q).zeta(x, q, out=out)
@handle_exceptions
@handle_backend_invalid
@handle_nestable
@handle_array_like_without_promotion
@to_native_arrays_and_back
@handle_device
def gradient(
x: Union[ivy.Array, ivy.NativeArray],
/,
*,
spacing: Union[int, list, tuple] = 1,
edge_order: int = 1,
axis: Optional[Union[int, list, tuple]] = None,
) -> Union[ivy.Array, List[ivy.Array]]:
"""Calculate gradient of x with respect to (w.r.t.) spacing.
Parameters
----------
x
input array representing outcomes of the function
spacing
if not given, indices of x will be used
if scalar indices of x will be scaled with this value
if array gradient of x w.r.t. spacing
edge_order
1 or 2, for 'frist order' and 'second order' estimation
of boundary values of gradient respectively.
Note: jax supports edge_order=1 case only
axis
dimension(s) to approximate the gradient over
by default partial gradient is computed in every dimension
Returns
-------
ret
Array with values computed from gradient function from
inputs
Examples
--------
>>> spacing = (ivy.array([-2., -1., 1., 4.]),)
>>> x = ivy.array([4., 1., 1., 16.], )
>>> ivy.gradient(x, spacing=spacing)
ivy.array([-3., -2., 2., 5.])
>>> x = ivy.array([[1, 2, 4, 8], [10, 20, 40, 80]])
>>> ivy.gradient(x)
[ivy.array([[ 9., 18., 36., 72.],
[ 9., 18., 36., 72.]]), ivy.array([[ 1. , 1.5, 3. , 4. ],
[10. , 15. , 30. , 40. ]])]
>>> x = ivy.array([[1, 2, 4, 8], [10, 20, 40, 80]])
>>> ivy.gradient(x, spacing=2.0)
[ivy.array([[ 4.5, 9. , 18. , 36. ],
[ 4.5, 9. , 18. , 36. ]]), ivy.array([[ 0.5 , 0.75, 1.5 , 2. ],
[ 5. , 7.5 , 15. , 20. ]])]
>>> x = ivy.array([[1, 2, 4, 8], [10, 20, 40, 80]])
>>> ivy.gradient(x, axis=1)
ivy.array([[ 1. , 1.5, 3. , 4. ],
[10. , 15. , 30. , 40. ]])
>>> x = ivy.array([[1, 2, 4, 8], [10, 20, 40, 80]])
>>> ivy.gradient(x, spacing=[3., 2.])
[ivy.array([[ 3., 6., 12., 24.],
[ 3., 6., 12., 24.]]), ivy.array([[ 0.5 , 0.75, 1.5 , 2. ],
[ 5. , 7.5 , 15. , 20. ]])]
>>> spacing = (ivy.array([0, 2]), ivy.array([0, 3, 6, 9]))
>>> ivy.gradient(x, spacing=spacing)
[ivy.array([[ 4.5, 9. , 18. , 36. ],
[ 4.5, 9. , 18. , 36. ]]), ivy.array([[ 0.33333333, 0.5, 1., 1.33333333],
[ 3.33333333, 5. , 10. , 13.33333333]])]
"""
return ivy.current_backend(x).gradient(
x, spacing=spacing, edge_order=edge_order, axis=axis
)
@handle_exceptions
@handle_backend_invalid
@handle_nestable
@handle_out_argument
@to_native_arrays_and_back
@handle_device
def xlogy(
x: Union[ivy.Array, ivy.NativeArray],
y: Union[ivy.Array, ivy.NativeArray],
/,
*,
out: Optional[ivy.Array] = None,
) -> bool:
"""Compute x*log(y) element-wise so that the result is 0 if x = 0.
Parameters
----------
x
First input array.
y
Second input array.
out
Alternate output array in which to place the result.
The default is None.
Returns
-------
ret
The next representable values of x1 in the direction of x2.
Examples
--------
>>> x = ivy.zeros(3)
>>> y = ivy.array([-1.0, 0.0, 1.0])
>>> ivy.xlogy(x, y)
ivy.array([0.0, 0.0, 0.0])
>>> x = ivy.array([1.0, 2.0, 3.0])
>>> y = ivy.array([3.0, 2.0, 1.0])
>>> ivy.xlogy(x, y)
ivy.array([1.0986, 1.3863, 0.0000])
"""
return ivy.current_backend(x, y).xlogy(x, y, out=out)
@handle_exceptions
@handle_nestable
@handle_array_like_without_promotion
@handle_out_argument
@inputs_to_ivy_arrays
def binarizer(
x: Union[ivy.Array, ivy.NativeArray],
/,
*,
threshold: float = 0,
out: Optional[ivy.Array] = None,
) -> ivy.Array:
"""Map the values of the input tensor to either 0 or 1, element-wise, based
on the outcome of a comparison against a threshold value.
Parameters
----------
x
Data to be binarized
threshold
Values greater than this are
mapped to 1, others to 0.
out
optional output array, for writing the result to.
It must have a shape that the inputs broadcast to.
Returns
-------
ret
Binarized output data
"""
xc = ivy.copy_array(x, out=out)
if ivy.is_bool_dtype(xc) and ivy.current_backend_str() == "torch":
xc = ivy.astype(xc, ivy.default_float_dtype())
if ivy.is_complex_dtype(xc):
xc = ivy.abs(xc)
ret = ivy.where(xc > threshold, 1, 0)
return ret
@handle_exceptions
@handle_backend_invalid
@handle_nestable
@handle_array_like_without_promotion
@handle_out_argument
@to_native_arrays_and_back
@handle_device
def conj(
x: Union[ivy.Array, ivy.NativeArray],
/,
*,
out: Optional[ivy.Array] = None,
) -> ivy.Array:
"""Return the complex conjugate for each element ``x_i`` of the input array
``x``.
For complex number of the form
.. math::
a + bj
the complex conjugate is defined as
.. math::
a - bj
Hence, the returned conjugates must be computed by negating
the imaginary component of each element ``x_i``
This method conforms to the
`Array API Standard <https://data-apis.org/array-api/latest/>`_.
This docstring is an extension of the
`docstring <https://data-apis.org/array-api/latest/
API_specification/generated/array_api.conj.html>`_
in the standard.
Both the description and the type hints above assumes an array input for simplicity,
but this function is *nestable*, and therefore also accepts :class:`ivy.Container`
instances in place of any of the arguments.
Parameters
----------
x
input array.
out
optional output array, for writing the result to.
It must have a shape that the inputs broadcast to.
Returns
-------
ret
an array of the same dtype as the input array with
the complex conjugates of the complex values present
in the input array. If x is a scalar then a scalar
will be returned.
The descriptions above assume an array input for simplicity, but
the method also accepts :class:`ivy.Container` instances
in place of: class:`ivy.Array` or :class:`ivy.NativeArray`
instances, as shown in the type hints and also the examples below.
Examples
--------
With :class:`ivy.Array` inputs:
>>> x = ivy.array([4.2-0j, 3j, 7+5j])
>>> z = ivy.conj(x)
>>> print(z)
ivy.array([4.2-0.j, 0. -3.j, 7. -5.j])
With :class:`ivy.Container` input:
>>> x = ivy.Container(a=ivy.array([-6.7-7j, 0.314+0.355j, 1.23]),
... b=ivy.array([5j, 5.32-6.55j, 3.001]))
>>> z = ivy.conj(x)
>>> print(z)
{
a: ivy.array([-6.7+7.j, 0.314-0.355j, 1.23-0.j]),
b: ivy.array([0.-5.j, 5.32+6.55j, 3.001-0.j])
}
"""
return ivy.current_backend(x).conj(x, out=out)
@handle_exceptions
@handle_backend_invalid
@handle_nestable
@handle_array_like_without_promotion
@handle_out_argument
@to_native_arrays_and_back
@handle_device
def ldexp(
x1: Union[ivy.Array, ivy.NativeArray],
x2: Union[ivy.Array, ivy.NativeArray],
/,
*,
out: Optional[ivy.Array] = None,
) -> ivy.Array:
"""Return x1 * (2**x2), element-wise.
Parameters
----------
x1
Input array.
x2
Input array.
out
optional output array, for writing the result to.
It must have a shape that the inputs broadcast to.
Returns
-------
ret
The next representable values of x1 in the direction of x2.
Examples
--------
>>> x1 = ivy.array([1, 2, 3])
>>> x2 = ivy.array([0, 1, 2])
>>> ivy.ldexp(x1, x2)
ivy.array([1, 4, 12])
"""
return ivy.current_backend(x1, x2).ldexp(x1, x2, out=out)
@handle_exceptions
@handle_nestable
@handle_partial_mixed_function
@handle_array_like_without_promotion
@inputs_to_ivy_arrays
@handle_array_function
@handle_device
def lerp(
input: Union[ivy.Array, ivy.NativeArray],
end: Union[ivy.Array, ivy.NativeArray],
weight: Union[ivy.Array, ivy.NativeArray, float],
/,
*,
out: Optional[ivy.Array] = None,
) -> ivy.Array:
"""Return a linear interpolation of two arrays start (given by input) and
end.
based on a scalar or array weight.
input + weight * (end - input), element-wise.
Parameters
----------
input
array of starting points
end
array of ending points
weight
the weight for the interpolation formula. Scalar or Array.
out
optional output array, for writing the result to.
It must have a shape that the inputs broadcast to.
Returns
-------
ret
The result of input + ((end - input) * weight)
Examples
--------
With :class:`ivy.Array` inputs:
>>> input = ivy.array([1, 2, 3])
>>> end = ivy.array([10, 10, 10])
>>> weight = 0.5
>>> y = ivy.lerp(input, end, weight)
>>> print(y)
ivy.array([5.5, 6. , 6.5])
>>> input = ivy.array([1.1, 1.2, 1.3])
>>> end = ivy.array([20])
>>> weight = ivy.array([0.4, 0.5, 0.6])
>>> y = ivy.zeros(3)
>>> ivy.lerp(input, end, weight, out=y)
>>> print(y)
ivy.array([ 8.65999985, 10.60000038, 12.52000046])
>>> input = ivy.array([[4, 5, 6],[4.1, 4.2, 4.3]])
>>> end = ivy.array([10])
>>> weight = ivy.array([0.5])
>>> ivy.lerp(input, end, weight, out=input)
>>> print(input)
ivy.array([[7. , 7.5 , 8. ],
[7.05000019, 7.0999999 , 7.1500001 ]])
With :class:`ivy.Container` input:
>>> input = ivy.Container(a=ivy.array([0., 1., 2.]), b=ivy.array([3., 4., 5.]))
>>> end = ivy.array([10.])
>>> weight = 1.1
>>> y = input.lerp(end, weight)
>>> print(y)
{
a: ivy.array([11., 10.90000057, 10.80000019]),
b: ivy.array([10.70000076, 10.60000038, 10.5])
}
>>> input = ivy.Container(a=ivy.array([10.1, 11.1]), b=ivy.array([10, 11]))
>>> end = ivy.Container(a=ivy.array([5]), b=ivy.array([0]))
>>> weight = 0.5
>>> y = input.lerp(end, weight)
>>> print(y)
{
a: ivy.array([7.55000019, 8.05000019]),
b: ivy.array([5., 5.5])
}
"""
input_end_allowed_types = [
"int8",
"int16",
"int32",
"int64",
"float16",
"bfloat16",
"float32",
"float64",
"complex",
]
weight_allowed_types = ["float16", "bfloat16", "float32", "float64"]
if not ivy.is_array(input):
input = ivy.array([input])
if not ivy.is_array(end):
end = ivy.array([end])
if (
ivy.dtype(input) not in input_end_allowed_types
or ivy.dtype(end) not in input_end_allowed_types
):
input = ivy.astype(input, "float64")
end = ivy.astype(end, "float64")
if ivy.is_array(weight):
if ivy.dtype(weight) not in weight_allowed_types:
weight = ivy.astype(weight, "float64")
elif not isinstance(weight, float):
weight = ivy.astype(ivy.array([weight]), "float64")
return ivy.add(input, ivy.multiply(weight, ivy.subtract(end, input)), out=out)
lerp.mixed_backend_wrappers = {
"to_add": (
"handle_backend_invalid",
"inputs_to_native_arrays",
"outputs_to_ivy_arrays",
"handle_device",
),
"to_skip": ("inputs_to_ivy_arrays", "handle_partial_mixed_function"),
}
@handle_exceptions
@handle_backend_invalid
@handle_nestable
@handle_array_like_without_promotion
@handle_out_argument
@to_native_arrays_and_back
@handle_device
def frexp(
x: Union[ivy.Array, ivy.NativeArray],
/,
*,
out: Optional[Tuple[ivy.Array, ivy.Array]] = None,
) -> Tuple[ivy.Array, ivy.Array]:
"""Decompose the elements of x into mantissa and twos exponent.
Parameters
----------
x
Input array.
out
optional output array, for writing the result to.
It must have a shape that the inputs broadcast to.
Returns
-------
ret
A tuple of two arrays, the mantissa and the twos exponent.
Examples
--------
>>> x = ivy.array([1, 2, 3])
>>> ivy.frexp(x)
(ivy.array([0.5, 0.5, 0.75]), ivy.array([1, 2, 2]))
"""
return ivy.current_backend(x).frexp(x, out=out)
@handle_exceptions
@handle_backend_invalid
@handle_nestable
@handle_array_like_without_promotion
@handle_out_argument
@to_native_arrays_and_back
def modf(
x: Union[ivy.Array, ivy.NativeArray],
/,
*,
out: Optional[Tuple[ivy.Array, ivy.Array]] = None,
) -> Tuple[ivy.Array, ivy.Array]:
"""Decompose the elements of x into fractional and integral parts.
Parameters
----------
x
Input array.
out
Optional output array for writing the result to.
It must have a shape that the inputs broadcast to.
Returns
-------
ret
A tuple of two arrays, the fractional and integral parts.
Examples
--------
>>> x = ivy.array([1.5, 2.7, 3.9])
>>> ivy.modf(x)
(ivy.array([0.5, 0.7, 0.9]), ivy.array([1, 2, 3]))
"""
return ivy.current_backend(x).modf(x, out=out)
@handle_exceptions
@handle_nestable
@handle_out_argument
@to_native_arrays_and_back
def digamma(
x: Union[ivy.Array, ivy.NativeArray],
/,
*,
out: Optional[ivy.Array] = None,
) -> ivy.Array:
"""Compute the logarithmic derivative of the gamma function at x.
Note
----
The Ivy version only accepts real-valued inputs.
Parameters
----------
x
Input array.
out
Alternate output array in which to place the result.
The default is None.
Returns
-------
ret
Array with values computed from digamma function from
input arrays' values, element-wise.
Examples
--------
>>> x = ivy.array([.9, 3, 3.2])
>>> y = ivy.digamma(x)
ivy.array([-0.7549271 0.92278427 0.9988394])
"""
return ivy.current_backend(x).digamma(x, out=out)
@handle_exceptions
@handle_nestable
@inputs_to_ivy_arrays
@handle_array_function
def sparsify_tensor(
x: Union[ivy.Array, ivy.NativeArray],
card: int,
/,
*,
out: Optional[ivy.Array] = None,
) -> ivy.Array:
"""Zeros out all elements in the tensor except `card` elements with maximum
absolute values.
Parameters
----------
x
Tensor to be sparsified
card
Desired number of non-zero elements in the tensor
out
Optional output array for writing the result to.
Returns
-------
ivy.array of shape tensor.shape
Examples
--------
>>> x = ivy.arange(100)
>>> x = ivy.reshape(x, (10, 10))
>>> sparsify_tensor(x, 10)
ivy.array([[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]])
"""
if card >= ivy.prod(ivy.array(x.shape)):
return ivy.inplace_update(out, x) if ivy.exists(out) else x
_shape = ivy.shape(x)
x = ivy.reshape(ivy.sort(ivy.abs(x)), (-1,))
tensor = ivy.concat([ivy.zeros(len(x) - card, dtype=x.dtype), x[-card:]], axis=0)
return ivy.reshape(tensor, _shape, out=out)
@handle_exceptions
@handle_nestable
@handle_array_like_without_promotion
@handle_out_argument
@to_native_arrays_and_back
@handle_device
def erfc(
x: Union[ivy.Array, ivy.NativeArray],
/,
*,
out: Optional[ivy.Array] = None,
) -> ivy.Array:
"""
Complementary error function, 1 - erf(x)
Parameters
----------
x
Input array of real or complex valued argument.
out
optional output array, for writing the result to.
It must have a shape that the inputs broadcast to.
Returns
-------
ret
Values of the complementary error function.
Examples
--------
>>> x = ivy.array([2, -1., 0])
>>> ivy.erfc(x)
ivy.array([0.00467773, 1.84270084, 1. ])
"""
return ivy.current_backend(x).erfc(x, out=out)
@handle_exceptions
@handle_nestable
@handle_array_like_without_promotion
@handle_out_argument
@to_native_arrays_and_back
@handle_device
def erfinv(
x: Union[ivy.Array, ivy.NativeArray],
/,
*,
out: Optional[ivy.Array] = None,
):
"""Compute the inverse error function.
Parameters
----------
x
Input array of real or complex valued argument.
out
optional output array, for writing the result to.
It must have a shape that the inputs broadcast to.
Returns
-------
ret
Values of the inverse error function.
Examples
--------
>>> x = ivy.array([0, 0.5, -1.])
>>> ivy.erfinv(x)
ivy.array([0.0000, 0.4769, -inf])
"""
return ivy.current_backend(x).erfinv(x, out=out)
| ivy/ivy/functional/ivy/experimental/elementwise.py/0 | {
"file_path": "ivy/ivy/functional/ivy/experimental/elementwise.py",
"repo_id": "ivy",
"token_count": 19863
} | 41 |
# global
from typing import Optional
# local
import ivy
from ivy import handle_out_argument, handle_nestable
from ivy.utils.exceptions import handle_exceptions
@handle_out_argument
@handle_nestable
@handle_exceptions
def optional_get_element(
x: Optional[ivy.Array] = None,
/,
*,
out: Optional[ivy.Array] = None,
) -> ivy.Array:
"""If the input is a tensor or sequence type, it returns the input. If the
input is an optional type, it outputs the element in the input. It is an
error if the input is an empty optional-type (i.e. does not have an
element) and the behavior is undefined in this case.
Parameters
----------
x
Input array
out
Optional output array, for writing the result to.
Returns
-------
ret
Input array if it is not None
"""
if x is None:
raise ivy.utils.exceptions.IvyError(
"The requested optional input has no value."
)
return x
| ivy/ivy/functional/ivy/experimental/utility.py/0 | {
"file_path": "ivy/ivy/functional/ivy/experimental/utility.py",
"repo_id": "ivy",
"token_count": 359
} | 42 |
from . import activations
from .activations import *
from . import converters
from .converters import *
from . import initializers
from .initializers import *
from . import layers
from .layers import *
from . import losses
from .losses import *
from . import module
from .module import *
from . import norms
from .norms import *
from . import optimizers
from .optimizers import *
from . import sequential
from .sequential import *
| ivy/ivy/stateful/__init__.py/0 | {
"file_path": "ivy/ivy/stateful/__init__.py",
"repo_id": "ivy",
"token_count": 112
} | 43 |
# global
import os
import copy
import types
import ivy
import importlib
import functools
import numpy as np
import gc
from ivy.utils import _importlib, verbosity
# local
from ivy.func_wrapper import _wrap_function
from ivy.utils.backend.sub_backend_handler import (
_clear_current_sub_backends,
fn_name_from_version_specific_fn_name,
)
from ivy.utils.exceptions import _handle_inplace_mode
backend_stack = []
compiled_backends = {}
_compiled_backends_ids = {}
implicit_backend = "numpy"
ivy_original_dict = ivy.__dict__.copy()
ivy_original_fn_dict = {}
class ContextManager:
def __init__(self, module):
self.module = module
def __enter__(self):
return set_backend(self.module)
def __exit__(self, exc_type, exc_val, exc_tb):
previous_backend()
_backends_subpackage_path = "ivy.functional.backends"
_backend_dict = {}
_backend_reverse_dict = {}
for backend in os.listdir(
os.path.join(
ivy.__path__[0].rpartition(os.path.sep)[0], # type: ignore
_backends_subpackage_path.replace(".", os.path.sep),
)
):
if backend.startswith("__"):
continue
backend_path = f"{_backends_subpackage_path}.{backend}"
_backend_dict[backend] = backend_path
_backend_reverse_dict[backend_path] = backend
# Backend Getting/Setting #
# ----------------------- #
def prevent_access_locally(fn):
@functools.wraps(fn)
def _prevent_access_locally(*args, **kwargs):
if ivy.is_local():
raise RuntimeError(f"Calling {fn.__name__} is not allowed on this object.")
return fn(*args, **kwargs)
return _prevent_access_locally
@functools.lru_cache
def _get_backend_for_arg(arg_module_name):
for backend, module_name in _backend_dict.items():
if backend in arg_module_name:
return importlib.import_module(module_name)
def _determine_backend_from_args(args):
"""Return the appropriate Ivy backend, given some arguments.
Parameters
----------
args
the arguments from which to figure out the corresponding Ivy backend.
Returns
-------
ret
the Ivy backend inferred from `args`.
Examples
--------
If `args` is a jax.numpy array, then Ivy's jax backend will be returned:
>>> from ivy.utils.backend.handler import _determine_backend_from_args
>>> import jax.numpy as jnp
>>> x = jnp.array([1])
>>> print(_determine_backend_from_args(x))
<module 'ivy.functional.backends.jax' from '/ivy/ivy/functional/backends/jax/__init__.py'> # noqa
""" # noqa: E501
arg_type = type(args)
if isinstance(args, ivy.Array):
args = args.data
if isinstance(args, dict):
for value in args.values():
# recursively call the function for each value in the dictionary
lib = _determine_backend_from_args(value)
if lib:
return lib
# check if args is a list or tuple
elif arg_type in [list, tuple]:
for arg in args:
# recursively call the function for each element in the list/tuple
lib = _determine_backend_from_args(arg)
if lib:
return lib
else:
# check if the class module of the arg is in _array_types
return _get_backend_for_arg(args.__class__.__module__)
def set_backend_to_specific_version(backend):
"""Update the backend dict to make the original function name point to the
version specific one.
Parameters
----------
backend
the backend module for which we provide the version support
"""
# TODO: add functionality and tests
f = str(backend.__name__)
f = f[f.index("backends") + 9 :]
f = importlib.import_module(f)
f_version = f.__version__
for key in list(backend.__dict__):
if "_v_" in key:
orig_name = fn_name_from_version_specific_fn_name(key, f_version)
if orig_name:
backend.__dict__[orig_name] = backend.__dict__[key]
backend.__dict__[orig_name].__name__ = orig_name
def current_backend(*args, **kwargs):
"""Return the current backend. Priorities: global_backend > argument's
backend.
Parameters
----------
*args/**kwargs
the arguments from which to try to infer the backend, when there is
no globally set backend.
Returns
-------
ret
Ivy's current backend.
Examples
--------
If no global backend is set, then the backend is inferred from the arguments:
>>> import numpy as np
>>> x = np.array([2.0])
>>> print(ivy.current_backend(x))
<module 'ivy.functional.backends.numpy' from '/ivy/ivy/functional/backends/numpy/__init__.py'> # noqa
The global backend set in set_backend has priority over any arguments
passed to current_backend:
>>> import numpy as np
>>> ivy.set_backend("jax")
>>> x = np.array([2.0])
>>> print(ivy.current_backend(x))
<module 'ivy.functional.backends.jax' from '/ivy/ivy/functional/backends/jax/__init__.py'> # noqa
""" # noqa: E501
global implicit_backend
# if a global backend has been set with
# set_backend then this will be returned
if backend_stack:
f = backend_stack[-1]
if verbosity.level > 0:
verbosity.cprint(f"Using backend from stack: {f}")
return f
# if no global backend exists, we try to infer
# the backend from the arguments
f = _determine_backend_from_args(list(args) + list(kwargs.values()))
if f is not None:
if verbosity.level > 0:
verbosity.cprint(f"Using backend from type: {f}")
implicit_backend = f.current_backend_str()
return f
return importlib.import_module(_backend_dict[implicit_backend])
def _set_module_backend(
original_dict, target, backend, invalid_dtypes=None, backend_str=None
):
invalid_dtypes = (
backend.invalid_dtypes if invalid_dtypes is None else invalid_dtypes
)
backend_str = backend.current_backend_str() if backend_str is None else backend_str
for k, v in original_dict.items():
if k in ivy.GLOBAL_PROPS:
continue
compositional = k not in backend.__dict__
if compositional:
if k in invalid_dtypes and k in target.__dict__:
del target.__dict__[k]
continue
backend.__dict__[k] = v
target.__dict__[k] = _wrap_function(
key=k, to_wrap=backend.__dict__[k], original=v, compositional=compositional
)
if (
isinstance(v, types.ModuleType)
and "ivy.functional." in v.__name__
and os.path.join("{}", "__init__.py").format(backend_str) not in v.__file__
):
_set_module_backend(
v.__dict__,
target.__dict__[k],
backend.__dict__[k],
invalid_dtypes=invalid_dtypes,
backend_str=backend_str,
)
def _handle_backend_specific_vars(target, backend):
if backend.current_backend_str() == "numpy":
target.set_default_device("cpu")
elif backend.current_backend_str() == "jax":
target.set_global_attr("RNG", target.functional.backends.jax.random.RNG)
def _data_to_new_backend(x, previous_backend):
device = previous_backend.dev(x.data)
try:
result = ivy.from_dlpack(previous_backend.to_dlpack(x.data))
result = ivy.to_device(result, device)
except Exception:
np_res = previous_backend.to_numpy(x.data)
result = ivy.asarray(np_res, device=device)
return result
def dynamic_backend_converter(backend_stack):
from ivy.functional.ivy.gradients import _variable
def _is_var(obj, backend):
if isinstance(obj, ivy.Container):
def _map_fn(x):
x = x.data if isinstance(x, ivy.Array) else x
if x.__class__.__module__ in (
"numpy",
"jax.interpreters.xla",
"jaxlib.xla_extension",
):
return False
return backend.gradients._is_variable(x)
return obj.cont_map(lambda x, kc: _map_fn(x)).cont_all_true()
else:
obj = obj.data if isinstance(obj, ivy.Array) else obj
if obj.__class__.__module__ in (
"numpy",
"jax.interpreters.xla",
"jaxlib.xla_extension",
):
return False
return backend.gradients._is_variable(obj)
# get all ivy array instances in the project scope
container_list = [
obj
for obj in gc.get_objects()
if "ivy" in type(obj).__module__ and isinstance(obj, ivy.Container)
]
cont_array_idxs = ivy.nested_argwhere(
container_list,
lambda x: isinstance(x, ivy.Array) and x.backend != ivy.current_backend_str(),
)
cont_array_vals = ivy.multi_index_nest(container_list, cont_array_idxs)
array_list = [
obj
for obj in gc.get_objects()
if "ivy" in type(obj).__module__ and isinstance(obj, ivy.Array)
]
array_list.extend(cont_array_vals)
# filter uninitialized arrays and arrays with other backends, and ensure the order
array_list = [
arr
for arr in array_list
if arr.__dict__ and arr.backend != ivy.current_backend_str()
]
new_objs = [obj for obj in array_list if obj.dynamic_backend]
# now convert all ivy.Array and ivy.Container instances
# to the new backend
for obj in new_objs:
# the following if condition avoids converting arrays that were already
# updated inplace i.e. are references to other arrays
if obj.backend != ivy.current_backend_str():
backend = ivy.with_backend(obj.backend, cached=True)
if _is_var(obj, backend):
native_var = backend.gradients._variable_data(obj)
data = _data_to_new_backend(native_var, backend)
new_data = _variable(data)
else:
new_data = _data_to_new_backend(obj, backend)
if isinstance(obj, ivy.Container):
obj.cont_inplace_update(new_data)
else:
obj.data = new_data.data
@prevent_access_locally
def set_backend(backend: str, dynamic: bool = False):
"""Set `backend` to be the global backend.
Will also convert all Array and Container objects to the new backend if `dynamic` =
True
Examples
--------
If we set the global backend to be numpy, then subsequent calls to ivy functions
will be called from Ivy's numpy backend:
>>> ivy.set_backend("numpy")
>>> native = ivy.native_array([1])
>>> print(type(native))
<class 'numpy.ndarray'>
Or with jax as the global backend:
>>> ivy.set_backend("jax")
>>> native = ivy.native_array([1])
>>> print(type(native))
<class 'jaxlib.xla_extension.ArrayImpl'>
""" # noqa
ivy.utils.assertions.check_false(
isinstance(backend, str) and backend not in _backend_dict,
f"backend must be one from {list(_backend_dict.keys())}",
)
# update the global dict with the new backend
with ivy.locks["backend_setter"]:
global ivy_original_dict
if not backend_stack:
ivy_original_dict = ivy.__dict__.copy()
_clear_current_sub_backends()
if isinstance(backend, str):
temp_stack = []
while backend_stack:
temp_stack.append(previous_backend())
backend = importlib.import_module(_backend_dict[backend])
for fw in reversed(temp_stack):
backend_stack.append(fw)
if backend.current_backend_str() == "numpy":
ivy.set_default_device("cpu")
elif backend.current_backend_str() == "jax":
ivy.set_global_attr("RNG", ivy.functional.backends.jax.random.RNG)
backend_stack.append(backend)
set_backend_to_specific_version(backend)
_set_module_backend(ivy_original_dict, ivy, backend)
# following snippet is required to update the ivy.functional namespace with
# backend-specific functions
for key in ivy.__dict__.keys():
if key in ivy.functional.__dict__ and not key.startswith("__"):
ivy.functional.__dict__[key] = ivy.__dict__[key]
if dynamic:
dynamic_backend_converter(backend_stack)
for sub_backend in ivy.available_sub_backends:
ivy.set_sub_backend(sub_backend)
if verbosity.level > 0:
verbosity.cprint(f"backend stack: {backend_stack}")
_handle_inplace_mode()
return ivy
def set_numpy_backend():
"""Set NumPy to be the global backend.
equivalent to `ivy.set_backend("numpy")`.
""" # noqa
set_backend("numpy")
def set_jax_backend():
"""Set JAX to be the global backend.
equivalent to `ivy.set_backend("jax")`.
""" # noqa
set_backend("jax")
def set_tensorflow_backend():
"""Set TensorFlow to be the global backend.
equivalent to `ivy.set_backend("tensorflow")`.
"""
set_backend("tensorflow")
def set_torch_backend():
"""Set torch to be the global backend.
equivalent to `ivy.set_backend("torch")`.
""" # noqa
set_backend("torch")
def set_paddle_backend():
"""Set paddle to be the global backend.
equivalent to `ivy.set_backend("paddle")`.
""" # noqa
set_backend("paddle")
def set_mxnet_backend():
"""Set MXNet to be the global backend.
equivalent to `ivy.set_backend("mx")`.
""" # noqa
set_backend("mxnet")
@prevent_access_locally
def previous_backend():
"""Unset the current global backend, and adjusts the ivy dict such that
either a previously set global backend is then used as the backend,
otherwise we return to Ivy's implementations.
Returns
-------
ret
the backend that was unset, or None if there was no set global backend.
Examples
--------
Torch is the last set backend hence is the backend used in the first examples.
However, as seen in the example after, if `previous_backend` is called before
`ivy.native_array` then tensorflow will become the current backend and any
torch backend implementations in the Ivy dict will be swapped with the
tensorflow implementation::
>>> ivy.set_backend("tensorflow")
>>> ivy.set_backend("torch")
>>> x = ivy.native_array([1])
>>> print(type(x))
<class 'torch.Tensor'>
>>> ivy.set_backend("tensorflow")
>>> ivy.set_backend("torch")
>>> ivy.previous_backend()
>>> x = ivy.native_array([1])
>>> print(type(x))
<class'tensorflow.python.framework.ops.EagerTensor'>
""" # noqa
backend = None
# if the backend stack is empty, nothing is done then we just return `None`
if backend_stack:
backend = backend_stack.pop(-1) # remove last backend from the stack
if backend.current_backend_str() == "numpy":
ivy.unset_default_device()
elif backend.current_backend_str() == "jax":
ivy.del_global_attr("RNG")
# the new backend is the backend that was set before the one
# we just removed from the stack, or Ivy if there was no
# previously set backend
if backend_stack:
new_backend = backend_stack[-1]
if new_backend.current_backend_str() == "numpy":
ivy.set_default_device("cpu")
elif new_backend.current_backend_str() == "jax":
ivy.set_global_attr("RNG", ivy.functional.backends.jax.random.RNG)
new_backend_dict = (
backend_stack[-1].__dict__ if backend_stack else ivy_original_dict
)
# wrap backend functions if there still is a backend, and add functions
# to ivy namespace
for k, v in new_backend_dict.items():
if k in ivy.GLOBAL_PROPS:
continue
if backend_stack and k in ivy_original_dict:
v = _wrap_function(k, v, ivy_original_dict[k])
if k in ivy_original_dict:
ivy.__dict__[k] = v
if k in ivy.functional.__dict__ and not k.startswith("__"):
ivy.functional.__dict__[k] = v
if verbosity.level > 0:
verbosity.cprint(f"backend stack: {backend_stack}")
_handle_inplace_mode()
return backend
@prevent_access_locally
def unset_backend():
while backend_stack:
previous_backend()
@prevent_access_locally
def choose_random_backend(excluded=None):
excluded = [] if excluded is None else excluded
while True:
ivy.utils.assertions.check_equal(
len(excluded),
4,
inverse=True,
message="""Unable to select backend, all backends are excluded,\
or not installed.""",
as_array=False,
)
f = np.random.choice(
[f_srt for f_srt in list(_backend_dict.keys()) if f_srt not in excluded]
)
if f is None:
excluded.append(f)
continue
else:
print(f"\nselected backend: {f}\n")
return f
# noinspection PyProtectedMember
@prevent_access_locally
def with_backend(backend: str, cached: bool = True):
# Use already compiled object
if cached and backend in compiled_backends:
cached_backend = compiled_backends[backend][-1]
return cached_backend
with _importlib.LocalIvyImporter():
ivy_pack = _importlib._import_module("ivy")
ivy_pack._is_local_pkg = True
ivy_pack._compiled_id = id(ivy_pack)
backend_module = _importlib._import_module(
ivy_pack.utils.backend.handler._backend_dict[backend], ivy_pack.__package__
)
_handle_backend_specific_vars(ivy_pack, backend_module)
set_backend_to_specific_version(backend_module)
# We know for sure that the backend stack is empty
# no need to do backend unsetting
ivy_pack.utils.backend.handler._set_module_backend(
ivy_pack.__dict__.copy(), ivy_pack, backend_module
)
# TODO use a refactored code from ivy.set_backend
for key in ivy_pack.__dict__.keys():
if key in ivy_pack.functional.__dict__ and not key.startswith("__"):
ivy_pack.functional.__dict__[key] = ivy_pack.ivy.__dict__[key]
ivy_pack.backend_stack.append(backend_module)
ivy_pack.utils.backend._importlib.import_cache = copy.copy(
_importlib.import_cache
)
_compiled_backends_ids[ivy_pack._compiled_id] = ivy_pack
_importlib._clear_cache()
try:
compiled_backends[backend].append(ivy_pack)
except KeyError:
compiled_backends[backend] = [ivy_pack]
if ivy.backend != backend:
# to avoid warning users when not using set_backend with ivy.Array.__repr__
_handle_inplace_mode(ivy_pack=ivy_pack)
return ivy_pack
| ivy/ivy/utils/backend/handler.py/0 | {
"file_path": "ivy/ivy/utils/backend/handler.py",
"repo_id": "ivy",
"token_count": 8294
} | 44 |
from pytest import mark
from pathlib import Path
skip_ids = []
skips_path = Path(__file__).parent / "skips.txt"
if skips_path.exists():
with open(skips_path) as f:
for line in f:
if line.startswith("ivy_tests"):
id_ = line.strip("\n")
skip_ids.append(id_)
def pytest_collection_modifyitems(items):
skip_ivy = mark.skip(reason="ivy skip - see ivy_tests/skips.txt for details")
for item in items:
# skip if specified in skips.txt
for id_ in skip_ids:
if item.nodeid.startswith(id_):
item.add_marker(skip_ivy)
break
| ivy/ivy_tests/array_api_testing/conftest.py/0 | {
"file_path": "ivy/ivy_tests/array_api_testing/conftest.py",
"repo_id": "ivy",
"token_count": 311
} | 45 |
from hypothesis import strategies as st
from hypothesis.internal.floats import float_of
# local
from . import general_helpers as gh, dtype_helpers
import ivy_tests.test_ivy.helpers.globals as test_globals
floats_info = {
"float16": {"cast_type": "float16", "width": 16},
"bfloat16": {"cast_type": "float32", "width": 32},
"float32": {"cast_type": "float32", "width": 32},
"float64": {"cast_type": "float64", "width": 64},
}
@st.composite
def floats(
draw,
*,
min_value=None,
max_value=None,
abs_smallest_val=None,
allow_nan=False,
allow_inf=False,
allow_subnormal=False,
exclude_min=True,
exclude_max=True,
large_abs_safety_factor=1.1,
small_abs_safety_factor=1.1,
safety_factor_scale="linear",
mixed_fn_compos=True,
):
"""Draws an arbitrarily sized list of floats with a safety factor applied
to avoid values being generated at the edge of a dtype limit.
Parameters
----------
draw
special function that draws data randomly (but is reproducible) from a given
data-set (ex. list).
min_value
minimum value of floats generated.
max_value
maximum value of floats generated.
abs_smallest_val
the absolute smallest representable value of the data type.
allow_nan
if True, allow Nans in the list.
allow_inf
if True, allow inf in the list.
allow_subnormal
if True, allow subnormals in the list.
exclude_min
if True, exclude the minimum limit.
exclude_max
if True, exclude the maximum limit.
large_abs_safety_factor
A safety factor of 1 means that all values are included without limitation,
when a "linear" safety factor scaler is used, a safety factor of 2 means
that only 50% of the range is included, a safety factor of 3 means that
only 33% of the range is included etc.
when a "log" safety factor scaler is used, a data type with maximum
value of 2^32 and a safety factor of 2 transforms the maximum to 2^16.
small_abs_safety_factor
A safety factor of 1 means that all values are included without limitation,
when a "linear" safety factor scaler is used, a data type with minimum
representable number of 0.0001 and a safety factor of 2 transforms the
minimum to 0.0002, a safety factor of 3 transforms the minimum to 0.0003 etc.
when a "log" safety factor scaler is used, a data type with minimum
representable number of 0.5 * 2^-16 and a safety factor of 2 transforms the
minimum to 0.5 * 2^-8, a safety factor of 3 transforms the minimum to 0.5 * 2^-4
safety_factor_scale
The operation to use for the safety factor scaling. Can be "linear" or "log".
Default value = "linear".
mixed_fn_compos
boolean if True, the function will generate using the float dtypes
of the compositional implementation for mixed partial functions and
if False, it will generate using the float dtypes of the
primary implementation.
Returns
-------
ret
A strategy that draws floats.
"""
# ToDo assert that if min or max can be represented
dtype = draw(
dtype_helpers.get_dtypes(
"float", mixed_fn_compos=mixed_fn_compos, full=False, prune_function=False
)
)
dtype = dtype[0]
# ToDo add support for not applying safety factor
min_value, max_value, abs_smallest_val = gh.apply_safety_factor(
dtype,
backend=test_globals.CURRENT_BACKEND,
min_value=min_value,
max_value=max_value,
abs_smallest_val=abs_smallest_val,
small_abs_safety_factor=small_abs_safety_factor,
large_abs_safety_factor=large_abs_safety_factor,
safety_factor_scale=safety_factor_scale,
)
# The smallest possible value is determined by one of the arguments
if min_value > -abs_smallest_val or max_value < abs_smallest_val:
float_strategy = st.floats(
min_value=float_of(min_value, floats_info[dtype]["width"]),
max_value=float_of(max_value, floats_info[dtype]["width"]),
allow_nan=allow_nan,
allow_subnormal=allow_subnormal,
allow_infinity=allow_inf,
width=floats_info[dtype]["width"],
exclude_min=exclude_min,
exclude_max=exclude_max,
)
else:
float_strategy = st.one_of(
st.floats(
min_value=float_of(min_value, floats_info[dtype]["width"]),
max_value=float_of(-abs_smallest_val, floats_info[dtype]["width"]),
allow_nan=allow_nan,
allow_subnormal=allow_subnormal,
allow_infinity=allow_inf,
width=floats_info[dtype]["width"],
exclude_min=exclude_min,
exclude_max=exclude_max,
),
st.floats(
min_value=float_of(abs_smallest_val, floats_info[dtype]["width"]),
max_value=float_of(max_value, floats_info[dtype]["width"]),
allow_nan=allow_nan,
allow_subnormal=allow_subnormal,
allow_infinity=allow_inf,
width=floats_info[dtype]["width"],
exclude_min=exclude_min,
exclude_max=exclude_max,
),
)
values = draw(float_strategy)
return values
@st.composite
def ints(
draw,
*,
min_value=None,
max_value=None,
safety_factor=1.1,
safety_factor_scale=None,
mixed_fn_compos=True,
):
"""Draws an integer with a safety factor if specified.
Parameters
----------
draw
special function that draws data randomly (but is reproducible) from a given
data-set (ex. list).
min_value
minimum value of integers generated.
max_value
maximum value of integers generated.
safety_factor
A safety factor of 1 means that all values are included without limitation,
when a "linear" safety factor scaler is used, a safety factor of 2 means
that only 50% of the range is included, a safety factor of 3 means that
only 33% of the range is included etc.
when a "log" safety factor scaler is used, a data type with maximum
value of 2^32 and a safety factor of 2 transforms the maximum to 2^16.
safety_factor_scale
The operation to use for the safety factor scaling. Can be "linear" or "log".
Default value = "linear".
mixed_fn_compos
boolean if True, the function will generate using the integer dtypes
of the compositional implementation for mixed partial functions and
if False, it will generate using the integer dtypes of the
primary implementation.
Returns
-------
ret
A strategy that draws integers.
"""
dtype = draw(
dtype_helpers.get_dtypes(
"integer", mixed_fn_compos=mixed_fn_compos, full=False, prune_function=False
)
)
if min_value is None and max_value is None:
safety_factor_scale = "linear"
if safety_factor_scale is not None:
min_value, max_value, _ = gh.apply_safety_factor(
dtype[0],
backend=test_globals.CURRENT_BACKEND,
min_value=min_value,
max_value=max_value,
large_abs_safety_factor=safety_factor,
safety_factor_scale=safety_factor_scale,
)
return draw(st.integers(min_value, max_value))
@st.composite
def number(
draw,
*,
min_value=None,
max_value=None,
large_abs_safety_factor=1.1,
small_abs_safety_factor=1.1,
safety_factor_scale="linear",
mixed_fn_compos=True,
):
"""Draws integers or floats with a safety factor applied to values.
Parameters
----------
draw
special function that draws data randomly (but is reproducible) from a given
data-set (ex. list).
min_value
minimum value of integers generated.
max_value
maximum value of integers generated.
large_abs_safety_factor
A safety factor of 1 means that all values are included without limitation,
when a "linear" safety factor scaler is used, a safety factor of 2 means
that only 50% of the range is included, a safety factor of 3 means that
only 33% of the range is included etc.
when a "log" safety factor scaler is used, a data type with maximum
value of 2^32 and a safety factor of 2 transforms the maximum to 2^16.
small_abs_safety_factor
A safety factor of 1 means that all values are included without limitation,
this has no effect on integer data types.
when a "linear" safety factor scaler is used, a data type with minimum
representable number of 0.0001 and a safety factor of 2 transforms the
minimum to 0.0002, a safety factor of 3 transforms the minimum to 0.0003 etc.
when a "log" safety factor scaler is used, a data type with minimum
representable number of 0.5 * 2^-16 and a safety factor of 2 transforms the
minimum to 0.5 * 2^-8, a safety factor of 3 transforms the minimum to 0.5 * 2^-4
safety_factor_scale
The operation to use for the safety factor scaling. Can be "linear" or "log".
Default value = "linear".
mixed_fn_compos
boolean if True, the function will generate using the numeric dtypes
of the compositional implementation for mixed partial functions and
if False, it will generate using the numeric dtypes of the
primary implementation.
Returns
-------
ret
A strategy that draws integers or floats.
"""
return draw(
ints(
min_value=min_value,
max_value=max_value,
safety_factor=large_abs_safety_factor,
safety_factor_scale=safety_factor_scale,
mixed_fn_compos=mixed_fn_compos,
)
| floats(
min_value=min_value,
max_value=max_value,
small_abs_safety_factor=small_abs_safety_factor,
large_abs_safety_factor=large_abs_safety_factor,
safety_factor_scale=safety_factor_scale,
mixed_fn_compos=mixed_fn_compos,
)
)
| ivy/ivy_tests/test_ivy/helpers/hypothesis_helpers/number_helpers.py/0 | {
"file_path": "ivy/ivy_tests/test_ivy/helpers/hypothesis_helpers/number_helpers.py",
"repo_id": "ivy",
"token_count": 4197
} | 46 |
from .base import FrontendConfigWithBackend
def get_config():
return TensorflowFrontendConfig()
class TensorflowFrontendConfig(FrontendConfigWithBackend):
backend_str = "tensorflow"
| ivy/ivy_tests/test_ivy/test_frontends/config/tensorflow.py/0 | {
"file_path": "ivy/ivy_tests/test_ivy/test_frontends/config/tensorflow.py",
"repo_id": "ivy",
"token_count": 60
} | 47 |
# global
import numpy as np
import ivy.functional.frontends.jax.lax as jlax
import ivy.functional.frontends.jax.numpy as jnp
from hypothesis import assume, strategies as st
import random
from jax.lax import ConvDimensionNumbers
# local
import ivy
import ivy_tests.test_ivy.helpers as helpers
import ivy_tests.test_ivy.helpers.globals as test_globals
from ivy_tests.test_ivy.helpers import handle_frontend_test, BackendHandler
from ivy_tests.test_ivy.test_functional.test_experimental.test_nn.test_layers import (
_reduce_window_helper,
)
from ivy_tests.test_ivy.test_functional.test_nn.test_layers import (
_assume_tf_dilation_gt_1,
)
from ivy.functional.frontends.jax.numpy import can_cast
from ivy.functional.frontends.jax.lax.operators import (
_dimension_numbers,
_argsort_tuple,
)
# --- Helpers --- #
# --------------- #
# noinspection DuplicatedCode
@st.composite
def _arrays_idx_n_dtypes(draw):
num_dims = draw(st.shared(helpers.ints(min_value=1, max_value=4), key="num_dims"))
num_arrays = draw(
st.shared(helpers.ints(min_value=2, max_value=4), key="num_arrays")
)
common_shape = draw(
helpers.list_of_size(
x=helpers.ints(min_value=2, max_value=4),
size=num_dims - 1,
)
)
unique_idx = draw(helpers.ints(min_value=0, max_value=num_dims - 1))
unique_dims = draw(
helpers.list_of_size(
x=helpers.ints(min_value=2, max_value=3),
size=num_arrays,
)
)
xs = []
input_dtypes = draw(
helpers.array_dtypes(
available_dtypes=draw(helpers.get_dtypes("numeric")),
shared_dtype=True,
)
)
for ud, dt in zip(unique_dims, input_dtypes):
x = draw(
helpers.array_values(
shape=common_shape[:unique_idx] + [ud] + common_shape[unique_idx:],
dtype=dt,
)
)
xs.append(x)
return xs, input_dtypes, unique_idx
@st.composite
def _div_dtypes_and_xs(draw):
dtype, dividend, shape = draw(
helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"), ret_shape=True
)
)
divisor = draw(
helpers.array_values(dtype=dtype[0], min_value=-20, max_value=20, shape=shape)
)
return dtype, [dividend[0], divisor]
# select
@st.composite
def _dtype_pred_ontrue_on_false(draw):
shape = draw(helpers.get_shape(min_num_dims=1, min_dim_size=1))
pred = draw(helpers.array_values(dtype="bool", shape=shape))
dtypes, on_true_on_false = draw(
helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
num_arrays=2,
shape=shape,
large_abs_safety_factor=16,
small_abs_safety_factor=16,
safety_factor_scale="log",
shared_dtype=True,
)
)
return dtypes, pred, on_true_on_false
@st.composite
def _dtype_values_dims(draw):
dtype, values, shape = draw(
helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
min_num_dims=1,
ret_shape=True,
)
)
size = len(shape)
permutations = draw(
st.lists(
st.integers(min_value=0, max_value=len(shape) - 1),
min_size=size,
max_size=size,
unique=True,
)
)
return dtype, values, tuple(permutations)
@st.composite
def _fill_value(draw):
dtype = draw(helpers.get_dtypes("numeric", full=False, key="dtype"))[0]
with BackendHandler.update_backend(test_globals.CURRENT_BACKEND) as ivy_backend:
if ivy_backend.is_uint_dtype(dtype):
return draw(helpers.ints(min_value=0, max_value=5))
elif ivy_backend.is_int_dtype(dtype):
return draw(helpers.ints(min_value=-5, max_value=5))
return draw(helpers.floats(min_value=-5, max_value=5))
@st.composite
def _general_dot_helper(draw):
input_dtype, lhs, lshape = draw(
helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid"),
min_value=-1e04,
max_value=1e04,
min_num_dims=2,
ret_shape=True,
)
)
ndims = len(lshape)
perm_id = random.sample(list(range(ndims)), ndims)
rshape = [lshape[i] for i in perm_id]
input_dtype, rhs = draw(
helpers.dtype_and_values(
dtype=input_dtype,
min_value=-1e04,
max_value=1e04,
shape=rshape,
)
)
ind_list = list(range(ndims))
batch_n = draw(st.integers(min_value=1, max_value=len(lshape) - 1))
lhs_batch = random.sample(ind_list, batch_n)
rhs_batch = [perm_id.index(i) for i in lhs_batch]
lhs_contracting = [i for i in ind_list if i not in lhs_batch]
rhs_contracting = [perm_id.index(i) for i in lhs_contracting]
is_pref = draw(st.booleans())
pref_dtype = None
if is_pref:
uint_cast_st = helpers.get_castable_dtype(
draw(helpers.get_dtypes("unsigned")),
input_dtype[0],
)
int_cast_st = helpers.get_castable_dtype(
draw(helpers.get_dtypes("signed_integer")),
input_dtype[0],
)
float_cast_st = helpers.get_castable_dtype(
draw(helpers.get_dtypes("float")),
input_dtype[0],
)
complex_cast_st = helpers.get_castable_dtype(
draw(helpers.get_dtypes("complex")),
input_dtype[0],
)
if "uint" in input_dtype[0]:
pref_dtype = draw(st.one_of(uint_cast_st, float_cast_st))[-1]
elif "int" in input_dtype[0]:
pref_dtype = draw(st.one_of(int_cast_st, float_cast_st))[-1]
elif "float" in input_dtype[0]:
pref_dtype = draw(float_cast_st)[-1]
elif "complex" in input_dtype[0]:
pref_dtype = draw(complex_cast_st)[-1]
else:
raise ivy.exceptions.IvyException("unsupported dtype")
return (
input_dtype * 2,
(lhs[0], rhs[0]),
((lhs_contracting, rhs_contracting), (lhs_batch, rhs_batch)),
pref_dtype,
)
@st.composite
def _get_clamp_inputs(draw):
shape = draw(
helpers.get_shape(
min_num_dims=1, max_num_dims=5, min_dim_size=2, max_dim_size=10
)
)
x_dtype, x = draw(
helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("float"),
shape=shape,
)
)
min = draw(
helpers.array_values(dtype=x_dtype[0], shape=shape, min_value=-25, max_value=0)
)
max = draw(
helpers.array_values(dtype=x_dtype[0], shape=shape, min_value=1, max_value=25)
)
return x_dtype, x, min, max
@st.composite
def _get_dtype_inputs_for_batch_matmul(draw):
dtype, lhs = draw(
helpers.dtype_and_values(
min_num_dims=2,
max_num_dims=6,
min_value=2,
max_value=5,
)
)
lhs_shape = lhs[0].shape
rhs_shape = list(lhs_shape)
rhs_shape[-1], rhs_shape[-2] = rhs_shape[-2], rhs_shape[-1]
rhs_shape = tuple(rhs_shape)
rhs = draw(
helpers.array_values(
dtype=dtype[0],
shape=rhs_shape,
min_value=2,
max_value=5,
)
)
return dtype, lhs[0], rhs
@st.composite
def _get_dtype_inputs_for_dot(draw):
dim_size = draw(helpers.ints(min_value=1, max_value=5))
dtype = draw(helpers.get_dtypes("numeric", index=1, full=False))
if dim_size == 1:
lhs = draw(
helpers.array_values(
dtype=dtype[0], shape=(dim_size,), min_value=2, max_value=5
)
)
rhs = draw(
helpers.array_values(
dtype=dtype[0], shape=(dim_size,), min_value=2, max_value=5
)
)
else:
lhs = draw(
helpers.array_values(
dtype=dtype[0], shape=(dim_size, dim_size), min_value=2, max_value=5
)
)
rhs = draw(
helpers.array_values(
dtype=dtype[0], shape=(dim_size, dim_size), min_value=2, max_value=5
)
)
is_pref = draw(st.booleans())
if is_pref:
dtype, values, pref = draw(
helpers.get_castable_dtype(
draw(helpers.get_dtypes("numeric")), dtype[0], [lhs, rhs]
)
)
assume(can_cast(dtype, pref))
return [dtype], pref, values[0], values[1]
else:
return dtype, None, lhs, rhs
def _get_reduce_func(dtype):
if dtype[0] == "bool":
return st.sampled_from([jnp.logical_and, jnp.logical_or])
else:
return st.sampled_from([jlax.add, jlax.max, jlax.min, jlax.mul, jnp.multiply])
@st.composite
def _pad_helper(draw):
dtype, x, shape = draw(
helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("bool"),
ret_shape=True,
min_num_dims=1,
min_dim_size=2,
min_value=-100,
max_value=100,
).filter(lambda _x: _x[0][0] not in ["float16", "bfloat16"])
)
ndim = len(shape)
min_dim = min(shape)
padding_config = draw(
st.lists(
st.tuples(
st.integers(min_value=-(min_dim - 1), max_value=min_dim - 1),
st.integers(min_value=-(min_dim - 1), max_value=min_dim - 1),
st.integers(min_value=0, max_value=min_dim - 1),
),
min_size=ndim,
max_size=ndim,
)
)
padding_value = draw(st.booleans())
return dtype, x[0], padding_value, padding_config
@st.composite
def _reshape_helper(draw):
# generate a shape s.t len(shape) > 0
shape = draw(
helpers.get_shape(
allow_none=False,
min_num_dims=1,
max_num_dims=3,
min_dim_size=1,
max_dim_size=3,
)
)
reshape_shape = draw(helpers.reshape_shapes(shape=shape))
dtypes, x = draw(
helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
shape=shape,
)
)
is_dim = draw(st.booleans())
if is_dim:
dims = [x for x in range(len(shape))]
permut = draw(st.permutations(dims))
return x, dtypes, reshape_shape, permut
else:
return x, dtypes, reshape_shape, None
@st.composite
def _slice_helper(draw):
dtype, x, shape = draw(
helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid"),
min_num_dims=1,
ret_shape=True,
),
)
start_indices, limit_indices, strides = [], [], []
for i in shape:
start_indices += [draw(st.integers(min_value=0, max_value=i - 1))]
limit_indices += [
draw(
st.integers(min_value=0, max_value=i - 1).filter(
lambda _x: _x > start_indices[-1]
)
)
]
strides += [draw(st.integers(min_value=1, max_value=i))]
return dtype, x, start_indices, limit_indices, strides
@st.composite
def _slice_in_dim_helper(draw):
dtype, x, axis = draw(
helpers.dtype_values_axis(
available_dtypes=helpers.get_dtypes("valid"),
min_num_dims=1,
force_int_axis=True,
valid_axis=True,
),
)
operand = x[0]
start_index = draw(
st.integers(min_value=-abs(operand.shape[axis]), max_value=operand.shape[axis])
)
if start_index < 0:
limit_index = draw(
st.integers(
min_value=start_index + operand.shape[axis],
max_value=operand.shape[axis],
)
)
else:
limit_index = draw(
st.integers(
min_value=-abs(operand.shape[axis]), max_value=operand.shape[axis]
).filter(lambda _x: _x >= start_index)
)
stride = draw(st.integers(min_value=1, max_value=abs(limit_index + 1)))
return dtype, x, start_index, limit_index, stride, axis
# squeeze
@st.composite
def _squeeze_helper(draw):
shape = draw(st.shared(helpers.get_shape(), key="value_shape"))
valid_axes = []
for index, axis in enumerate(shape):
if axis == 1:
valid_axes.append(index)
return valid_axes
@st.composite
def _x_and_filters(draw, dim=2, transpose=False, general=False):
if not isinstance(dim, int):
dim = draw(dim)
batch_size = draw(st.integers(1, 5))
filter_shape = draw(
helpers.get_shape(
min_num_dims=dim, max_num_dims=dim, min_dim_size=1, max_dim_size=5
)
)
dtype = draw(helpers.get_dtypes("float", full=False))
padding = draw(
st.one_of(
st.lists(
st.tuples(
st.integers(min_value=0, max_value=3),
st.integers(min_value=0, max_value=3),
),
min_size=dim,
max_size=dim,
),
st.sampled_from(["SAME", "VALID"]),
)
)
input_channels = draw(st.integers(1, 3))
output_channels = draw(st.integers(1, 3))
group_list = [i for i in range(1, 6)]
if not transpose:
group_list = list(filter(lambda x: (input_channels % x == 0), group_list))
else:
group_list = list(filter(lambda x: (output_channels % x == 0), group_list))
fc = draw(st.sampled_from(group_list)) if general else 1
strides = draw(st.lists(st.integers(1, 3), min_size=dim, max_size=dim))
dilations = draw(st.lists(st.integers(1, 3), min_size=dim, max_size=dim))
if general:
if dim == 2:
dim_num_st1 = st.sampled_from(["NCHW", "NHWC"])
dim_num_st2 = st.sampled_from(["OIHW", "HWIO"])
elif dim == 1:
dim_num_st1 = st.sampled_from(["NWC", "NCW"])
dim_num_st2 = st.sampled_from(["OIW", "WIO"])
else:
dim_num_st1 = st.sampled_from(["NDHWC", "NCDHW"])
dim_num_st2 = st.sampled_from(["OIDHW", "DHWIO"])
dim_seq = [*range(0, dim + 2)]
dimension_numbers = draw(
st.sampled_from(
[
None,
(draw(dim_num_st1), draw(dim_num_st2), draw(dim_num_st1)),
ConvDimensionNumbers(
*map(
tuple,
draw(
st.lists(
st.permutations(dim_seq), min_size=3, max_size=3
)
),
)
),
]
)
)
else:
dimension_numbers = (
("NCH", "OIH", "NCH")
if dim == 1
else ("NCHW", "OIHW", "NCHW")
if dim == 2
else ("NCDHW", "OIDHW", "NCDHW")
)
dim_nums = _dimension_numbers(dimension_numbers, dim + 2, transp=transpose)
if not transpose:
output_channels = output_channels * fc
channel_shape = (output_channels, input_channels // fc)
else:
input_channels = input_channels * fc
channel_shape = (output_channels // fc, input_channels)
x_dim = []
for i in range(dim):
min_x = filter_shape[i] + (filter_shape[i] - 1) * (dilations[i] - 1)
x_dim.append(draw(st.integers(min_x, min_x + 1)))
x_shape = (batch_size, input_channels, *x_dim)
filter_shape = channel_shape + filter_shape
vals = draw(
helpers.array_values(
dtype=dtype[0],
shape=x_shape,
min_value=0.0,
max_value=1.0,
)
)
vals = ivy.permute_dims(vals, axes=_argsort_tuple(dim_nums[0]))
filters = draw(
helpers.array_values(
dtype=dtype[0],
shape=filter_shape,
min_value=0.0,
max_value=1.0,
)
)
filters = ivy.permute_dims(filters, axes=_argsort_tuple(dim_nums[1]))
if general and not transpose:
x_dilation = draw(st.lists(st.integers(1, 3), min_size=dim, max_size=dim))
dilations = (dilations, x_dilation)
if draw(st.booleans()):
p_dtype, pref = draw(
helpers.get_castable_dtype(draw(helpers.get_dtypes("float")), dtype[0])
)
assume(can_cast(p_dtype, pref))
else:
pref = None
return (
dtype,
vals,
filters,
dilations,
dimension_numbers,
strides,
padding,
fc,
pref,
)
# --- Main --- #
# ------------ #
# abs
@handle_frontend_test(
fn_tree="jax.lax.abs",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("signed_integer"),
),
test_with_out=st.just(False),
)
def test_jax_abs(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
)
# acos
@handle_frontend_test(
fn_tree="jax.lax.acos",
dtype_and_x=helpers.dtype_and_values(available_dtypes=helpers.get_dtypes("float")),
test_with_out=st.just(False),
)
def test_jax_acos(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
)
# add
@handle_frontend_test(
fn_tree="jax.lax.add",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
num_arrays=2,
shared_dtype=True,
),
test_with_out=st.just(False),
)
def test_jax_add(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
y=x[1],
)
@handle_frontend_test(
fn_tree="jax.lax.argmax",
dtype_x_axis=helpers.dtype_values_axis(
available_dtypes=helpers.get_dtypes("numeric"),
min_num_dims=1,
min_dim_size=1,
valid_axis=True,
force_int_axis=True,
allow_neg_axes=False,
),
index_dtype=helpers.get_dtypes("integer", full=False),
test_with_out=st.just(False),
)
def test_jax_argmax(
*,
dtype_x_axis,
index_dtype,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x, axis = dtype_x_axis
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
operand=x[0],
axis=axis,
index_dtype=index_dtype[0],
)
@handle_frontend_test(
fn_tree="jax.lax.argmin",
dtype_x_axis=helpers.dtype_values_axis(
available_dtypes=helpers.get_dtypes("numeric"),
min_num_dims=1,
min_dim_size=1,
valid_axis=True,
force_int_axis=True,
allow_neg_axes=False,
),
index_dtype=helpers.get_dtypes("integer", full=False),
test_with_out=st.just(False),
)
def test_jax_argmin(
*,
dtype_x_axis,
index_dtype,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x, axis = dtype_x_axis
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
operand=x[0],
axis=axis,
index_dtype=index_dtype[0],
)
# asin
@handle_frontend_test(
fn_tree="jax.lax.asin",
dtype_and_x=helpers.dtype_and_values(available_dtypes=helpers.get_dtypes("float")),
test_with_out=st.just(False),
)
def test_jax_asin(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
)
# asinh
@handle_frontend_test(
fn_tree="jax.lax.asinh",
dtype_and_x=helpers.dtype_and_values(available_dtypes=helpers.get_dtypes("float")),
test_with_out=st.just(False),
)
def test_jax_asinh(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
)
# atan
@handle_frontend_test(
fn_tree="jax.lax.atan",
dtype_and_x=helpers.dtype_and_values(available_dtypes=helpers.get_dtypes("float")),
test_with_out=st.just(False),
)
def test_jax_atan(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
)
# atan2
@handle_frontend_test(
fn_tree="jax.lax.atan2",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("float"),
num_arrays=2,
shared_dtype=True,
),
)
def test_jax_atan2(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
y=x[1],
)
# atanh
@handle_frontend_test(
fn_tree="jax.lax.atanh",
dtype_and_x=helpers.dtype_and_values(available_dtypes=helpers.get_dtypes("float")),
test_with_out=st.just(False),
)
def test_jax_atanh(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
)
@handle_frontend_test(
fn_tree="jax.lax.batch_matmul",
dtypes_and_xs=_get_dtype_inputs_for_batch_matmul(),
test_with_out=st.just(False),
)
def test_jax_batch_matmul(
*,
dtypes_and_xs,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtypes, lhs, rhs = dtypes_and_xs
helpers.test_frontend_function(
input_dtypes=input_dtypes,
frontend=frontend,
backend_to_test=backend_fw,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
rtol=1e-2,
atol=1e-2,
lhs=lhs,
rhs=rhs,
precision=None,
)
# bitwise_and
@handle_frontend_test(
fn_tree="jax.lax.bitwise_and",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("integer"),
num_arrays=2,
shared_dtype=True,
),
test_with_out=st.just(False),
)
def test_jax_bitwise_and(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
y=x[1],
)
# bitwise_not
@handle_frontend_test(
fn_tree="jax.lax.bitwise_not",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("integer"),
num_arrays=1,
),
test_with_out=st.just(False),
)
def test_jax_bitwise_not(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
)
# bitwise_or
@handle_frontend_test(
fn_tree="jax.lax.bitwise_or",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("integer"),
num_arrays=2,
shared_dtype=True,
),
test_with_out=st.just(False),
)
def test_jax_bitwise_or(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
y=x[1],
)
# bitwise_xor
@handle_frontend_test(
fn_tree="jax.lax.bitwise_xor",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("integer"),
num_arrays=2,
shared_dtype=True,
),
test_with_out=st.just(False),
)
def test_jax_bitwise_xor(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
y=x[1],
)
@handle_frontend_test(
fn_tree="jax.lax.broadcast",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
),
sizes=helpers.get_shape(min_num_dims=1),
test_with_out=st.just(False),
)
def test_jax_broadcast(
*,
dtype_and_x,
sizes,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
operand=x[0],
sizes=sizes,
)
# cbrt
@handle_frontend_test(
fn_tree="jax.lax.cbrt",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid"), min_value=0.0
),
test_with_out=st.just(False),
)
def test_jax_cbrt(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
)
@handle_frontend_test(
fn_tree="jax.lax.ceil",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("float"),
),
test_with_out=st.just(False),
)
def test_jax_ceil(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
)
@handle_frontend_test(
fn_tree="jax.lax.clamp",
dtype_x_min_max=_get_clamp_inputs(),
test_with_out=st.just(False),
)
def test_jax_clamp(
*,
dtype_x_min_max,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtypes, x, min_vals, max_vals = dtype_x_min_max
helpers.test_frontend_function(
input_dtypes=input_dtypes,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
min=min_vals,
x=x[0],
max=max_vals,
)
# complex
@handle_frontend_test(
fn_tree="jax.lax.complex",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
num_arrays=2,
shared_dtype=True,
),
test_with_out=st.just(False),
)
def test_jax_complex(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
y=x[1],
)
# concat
@handle_frontend_test(
fn_tree="jax.lax.concatenate",
xs_n_input_dtypes_n_unique_idx=_arrays_idx_n_dtypes(),
test_with_out=st.just(False),
)
def test_jax_concat(
*,
xs_n_input_dtypes_n_unique_idx,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
xs, input_dtypes, unique_idx = xs_n_input_dtypes_n_unique_idx
helpers.test_frontend_function(
input_dtypes=input_dtypes,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
operands=xs,
dimension=unique_idx,
)
# conj
@handle_frontend_test(
fn_tree="jax.lax.conj",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=["complex64"],
),
)
def test_jax_conj(
*,
dtype_and_x,
test_flags,
on_device,
fn_tree,
frontend,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
test_flags=test_flags,
frontend=frontend,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
)
@handle_frontend_test(
fn_tree="jax.lax.conv",
x_f_d_other=_x_and_filters(),
test_with_out=st.just(False),
)
def test_jax_conv(
*,
x_f_d_other,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
dtype, x, filters, dilation, dim_num, stride, pad, fc, pref = x_f_d_other
_assume_tf_dilation_gt_1(backend_fw, on_device, dilation)
helpers.test_frontend_function(
input_dtypes=dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
lhs=x,
rhs=filters,
window_strides=stride,
padding=pad,
precision=None,
preferred_element_type=pref,
)
@handle_frontend_test(
fn_tree="jax.lax.conv_general_dilated",
x_f_d_other=_x_and_filters(general=True),
test_with_out=st.just(False),
)
def test_jax_conv_general_dilated(
*,
x_f_d_other,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
dtype, x, filters, dilations, dim_num, stride, pad, fc, pref = x_f_d_other
_assume_tf_dilation_gt_1(ivy.current_backend_str(), on_device, dilations[0])
assume(not isinstance(pad, str) or len(dilations[1]) == dilations[1].count(1))
helpers.test_frontend_function(
input_dtypes=dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
lhs=x,
rhs=filters,
window_strides=stride,
padding=pad,
lhs_dilation=dilations[1],
rhs_dilation=dilations[0],
dimension_numbers=dim_num,
feature_group_count=fc,
batch_group_count=1,
precision=None,
preferred_element_type=pref,
)
@handle_frontend_test(
fn_tree="jax.lax.conv_transpose",
x_f_d_other=_x_and_filters(general=True, transpose=True),
test_with_out=st.just(False),
)
def test_jax_conv_transpose(
*,
x_f_d_other,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
dtype, x, filters, dilation, dim_num, stride, pad, fc, pref = x_f_d_other
_assume_tf_dilation_gt_1(ivy.current_backend_str(), on_device, dilation)
helpers.test_frontend_function(
input_dtypes=dtype,
backend_to_test=backend_fw,
test_flags=test_flags,
frontend=frontend,
fn_tree=fn_tree,
on_device=on_device,
lhs=x,
rhs=filters,
strides=stride,
padding=pad,
rhs_dilation=dilation,
dimension_numbers=dim_num,
transpose_kernel=False,
precision=None,
preferred_element_type=pref,
)
@handle_frontend_test(
fn_tree="jax.lax.convert_element_type",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid"),
),
new_dtype=helpers.get_dtypes("valid", full=False),
test_with_out=st.just(False),
)
def test_jax_convert_element_type(
*,
dtype_and_x,
new_dtype,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
assume(can_cast(input_dtype[0], new_dtype[0]))
helpers.test_frontend_function(
input_dtypes=input_dtype + new_dtype,
frontend=frontend,
backend_to_test=backend_fw,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
operand=x[0],
new_dtype=new_dtype[0],
)
# cos
@handle_frontend_test(
fn_tree="jax.lax.cos",
dtype_and_x=helpers.dtype_and_values(available_dtypes=helpers.get_dtypes("float")),
test_with_out=st.just(False),
)
def test_jax_cos(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
)
# cosh
@handle_frontend_test(
fn_tree="jax.lax.cosh",
dtype_and_x=helpers.dtype_and_values(available_dtypes=helpers.get_dtypes("float")),
test_with_out=st.just(False),
)
def test_jax_cosh(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
)
# cummin
@handle_frontend_test(
fn_tree="jax.lax.cummin",
dtype_x_axis=helpers.dtype_values_axis(
available_dtypes=helpers.get_dtypes("valid"),
min_num_dims=1,
max_num_dims=5,
valid_axis=True,
allow_neg_axes=False,
max_axes_size=1,
force_int_axis=True,
),
reverse=st.booleans(),
test_with_out=st.just(False),
)
def test_jax_cummin(
*,
dtype_x_axis,
reverse,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x, axis = dtype_x_axis
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
rtol=1e-2,
atol=1e-2,
operand=x[0],
axis=axis,
reverse=reverse,
)
@handle_frontend_test(
fn_tree="jax.lax.cumprod",
dtype_x_axis=helpers.dtype_values_axis(
available_dtypes=helpers.get_dtypes("numeric"),
min_num_dims=1,
max_num_dims=5,
min_value=-5,
max_value=5,
valid_axis=True,
allow_neg_axes=False,
max_axes_size=1,
force_int_axis=True,
),
reverse=st.booleans(),
test_with_out=st.just(False),
)
def test_jax_cumprod(
*,
dtype_x_axis,
reverse,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x, axis = dtype_x_axis
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
rtol=1e-2,
atol=1e-2,
operand=x[0],
axis=axis,
reverse=reverse,
)
@handle_frontend_test(
fn_tree="jax.lax.cumsum",
dtype_x_axis=helpers.dtype_values_axis(
available_dtypes=helpers.get_dtypes("numeric"),
min_num_dims=1,
max_num_dims=5,
valid_axis=True,
allow_neg_axes=False,
max_axes_size=1,
force_int_axis=True,
),
reverse=st.booleans(),
test_with_out=st.just(False),
)
def test_jax_cumsum(
*,
dtype_x_axis,
reverse,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x, axis = dtype_x_axis
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
operand=x[0],
axis=axis,
reverse=reverse,
)
@handle_frontend_test(
fn_tree="jax.lax.div",
dtypes_and_xs=_div_dtypes_and_xs(),
test_with_out=st.just(False),
)
def test_jax_div(
*,
dtypes_and_xs,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtypes, xs = dtypes_and_xs
assume(not np.any(np.isclose(xs[1], 0)))
helpers.test_frontend_function(
input_dtypes=input_dtypes,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=xs[0],
y=xs[1],
)
@handle_frontend_test(
fn_tree="jax.lax.dot",
dtypes_and_xs=_get_dtype_inputs_for_dot(),
test_with_out=st.just(False),
)
def test_jax_dot(
*,
dtypes_and_xs,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtypes, dtype, lhs, rhs = dtypes_and_xs
helpers.test_frontend_function(
input_dtypes=input_dtypes,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
rtol=1e-2,
atol=1e-2,
lhs=lhs,
rhs=rhs,
precision=None,
preferred_element_type=dtype,
)
@handle_frontend_test(
fn_tree="jax.lax.dot_general",
dtypes_lr_dims=_general_dot_helper(),
test_with_out=st.just(False),
)
def test_jax_dot_general(
*,
dtypes_lr_dims,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
dtypes, lr, dims, dtype = dtypes_lr_dims
helpers.test_frontend_function(
input_dtypes=dtypes,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
lhs=lr[0],
rhs=lr[1],
dimension_numbers=dims,
precision=None,
preferred_element_type=dtype,
)
@handle_frontend_test(
fn_tree="jax.lax.eq",
dtypes_and_xs=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
num_arrays=2,
shared_dtype=True,
),
test_with_out=st.just(False),
)
def test_jax_eq(
*,
dtypes_and_xs,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtypes, xs = dtypes_and_xs
helpers.test_frontend_function(
input_dtypes=input_dtypes,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=xs[0],
y=xs[1],
)
@handle_frontend_test(
fn_tree="jax.lax.erf",
dtype_and_x=helpers.dtype_and_values(available_dtypes=helpers.get_dtypes("float")),
test_with_out=st.just(False),
)
def test_jax_erf(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
rtol=1e-2,
atol=1e-2,
x=x[0],
)
# erfc
@handle_frontend_test(
fn_tree="jax.lax.erfc",
dtype_and_x=helpers.dtype_and_values(available_dtypes=helpers.get_dtypes("valid")),
test_with_out=st.just(False),
)
def test_jax_erfc(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
rtol=1e-2,
atol=1e-2,
x=x[0],
)
@handle_frontend_test(
fn_tree="jax.lax.exp",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("float"),
),
test_with_out=st.just(False),
)
def test_jax_exp(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
)
# expand_dims
@handle_frontend_test(
fn_tree="jax.lax.expand_dims",
dtype_x_axis=helpers.dtype_values_axis(
available_dtypes=helpers.get_dtypes("valid"),
min_num_dims=1,
max_num_dims=5,
min_dim_size=2,
max_dim_size=10,
force_int_axis=True,
valid_axis=True,
),
test_with_out=st.just(False),
)
def test_jax_expand_dims(
*,
dtype_x_axis,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
x_dtype, x, axis = dtype_x_axis
helpers.test_frontend_function(
input_dtypes=x_dtype,
frontend=frontend,
backend_to_test=backend_fw,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
array=x[0],
dimensions=(axis,),
)
@handle_frontend_test(
fn_tree="jax.lax.expm1",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("float"),
),
test_with_out=st.just(False),
)
def test_jax_expm1(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
)
@handle_frontend_test(
fn_tree="jax.lax.full",
shape=helpers.get_shape(
allow_none=False,
min_num_dims=1,
max_num_dims=5,
min_dim_size=1,
max_dim_size=10,
),
fill_value=_fill_value(),
dtypes=helpers.get_dtypes("numeric", full=False, key="dtype"),
)
def test_jax_full(
*,
shape,
fill_value,
dtypes,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
helpers.test_frontend_function(
input_dtypes=dtypes,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
shape=shape,
fill_value=fill_value,
dtype=dtypes[0],
)
@handle_frontend_test(
fn_tree="jax.lax.full_like",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric", full=False, key="dtype")
),
fill_val=_fill_value(),
shape=st.one_of(helpers.get_shape() | st.none()),
dtype=st.shared(helpers.get_dtypes("numeric", full=False), key="dtype"),
test_with_out=st.just(False),
)
def test_jax_full_like(
*,
dtype_and_x,
fill_val,
shape,
dtype,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
fill_val = fill_val
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
fill_value=fill_val,
dtype=dtype,
shape=shape,
)
@handle_frontend_test(
fn_tree="jax.lax.ge",
dtypes_and_xs=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
num_arrays=2,
shared_dtype=True,
),
test_with_out=st.just(False),
)
def test_jax_ge(
*,
dtypes_and_xs,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtypes, xs = dtypes_and_xs
helpers.test_frontend_function(
input_dtypes=input_dtypes,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=xs[0],
y=xs[1],
)
@handle_frontend_test(
fn_tree="jax.lax.gt",
dtypes_and_xs=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
num_arrays=2,
shared_dtype=True,
),
test_with_out=st.just(False),
)
def test_jax_gt(
*,
dtypes_and_xs,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtypes, xs = dtypes_and_xs
helpers.test_frontend_function(
input_dtypes=input_dtypes,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=xs[0],
y=xs[1],
)
# igamma
@handle_frontend_test(
fn_tree="jax.lax.igamma",
dtypes_and_xs=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
num_arrays=2,
shared_dtype=True,
),
test_with_out=st.just(False),
)
def test_jax_igamma(
*,
dtypes_and_xs,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtypes, (x, y) = dtypes_and_xs
helpers.test_frontend_function(
input_dtypes=input_dtypes,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
test_values=True,
x=x,
y=y,
)
# imag
@handle_frontend_test(
fn_tree="jax.lax.imag",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("complex")
),
)
def test_jax_imag(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
test_values=True,
x=x[0],
)
# iota
@handle_frontend_test(
fn_tree="jax.lax.iota",
dtypes=helpers.get_dtypes("valid", full=False),
size=helpers.ints(min_value=0, max_value=10),
test_with_out=st.just(False),
)
def test_jax_iota(
*,
dtypes,
size,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
helpers.test_frontend_function(
input_dtypes=dtypes,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
dtype=dtypes[0],
size=size,
)
# is_finite
@handle_frontend_test(
fn_tree="jax.lax.is_finite",
dtype_and_x=helpers.dtype_and_values(available_dtypes=helpers.get_dtypes("float")),
test_with_out=st.just(False),
)
def test_jax_is_finite(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
)
@handle_frontend_test(
fn_tree="jax.lax.le",
dtypes_and_xs=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
num_arrays=2,
shared_dtype=True,
),
test_with_out=st.just(False),
)
def test_jax_le(
*,
dtypes_and_xs,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtypes, xs = dtypes_and_xs
helpers.test_frontend_function(
input_dtypes=input_dtypes,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=xs[0],
y=xs[1],
)
@handle_frontend_test(
fn_tree="jax.lax.log",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("float"),
min_value=1,
),
test_with_out=st.just(False),
)
def test_jax_log(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
)
# log1p
@handle_frontend_test(
fn_tree="jax.lax.log1p",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("float"),
small_abs_safety_factor=2,
safety_factor_scale="log",
),
test_with_out=st.just(False),
)
def test_jax_log1p(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
)
@handle_frontend_test(
fn_tree="jax.lax.lt",
dtypes_and_xs=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
num_arrays=2,
shared_dtype=True,
),
test_with_out=st.just(False),
)
def test_jax_lt(
*,
dtypes_and_xs,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtypes, xs = dtypes_and_xs
helpers.test_frontend_function(
input_dtypes=input_dtypes,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=xs[0],
y=xs[1],
)
# max
@handle_frontend_test(
fn_tree="jax.lax.max",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
num_arrays=2,
shared_dtype=True,
),
test_with_out=st.just(False),
)
def test_jax_max(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
y=x[1],
)
@handle_frontend_test(
fn_tree="jax.lax.min",
dtypes_and_xs=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
num_arrays=2,
shared_dtype=True,
),
test_with_out=st.just(False),
)
def test_jax_min(
*,
dtypes_and_xs,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtypes, xs = dtypes_and_xs
helpers.test_frontend_function(
input_dtypes=input_dtypes,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=xs[0],
y=xs[1],
)
@handle_frontend_test(
fn_tree="jax.lax.mul",
dtypes_and_xs=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
num_arrays=2,
shared_dtype=True,
small_abs_safety_factor=2,
large_abs_safety_factor=2,
safety_factor_scale="log",
),
test_with_out=st.just(False),
)
def test_jax_mul(
*,
dtypes_and_xs,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtypes, xs = dtypes_and_xs
helpers.test_frontend_function(
input_dtypes=input_dtypes,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=xs[0],
y=xs[1],
)
@handle_frontend_test(
fn_tree="jax.lax.ne",
dtypes_and_xs=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
num_arrays=2,
shared_dtype=True,
),
test_with_out=st.just(False),
)
def test_jax_ne(
*,
dtypes_and_xs,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtypes, xs = dtypes_and_xs
helpers.test_frontend_function(
input_dtypes=input_dtypes,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=xs[0],
y=xs[1],
)
@handle_frontend_test(
fn_tree="jax.lax.neg",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("signed_integer"),
),
test_with_out=st.just(False),
)
def test_jax_neg(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
)
# nextafter
@handle_frontend_test(
fn_tree="jax.lax.nextafter",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=["float32", "float64"],
min_value=-100,
max_value=100,
min_num_dims=1,
max_num_dims=3,
min_dim_size=1,
max_dim_size=3,
num_arrays=2,
shared_dtype=True,
),
test_with_out=st.just(False),
)
def test_jax_nextafter(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x1=x[0],
x2=x[0],
)
@handle_frontend_test(
fn_tree="jax.lax.pad",
dtype_x_params=_pad_helper(),
test_with_out=st.just(False),
)
def test_jax_pad(
*,
dtype_x_params,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
dtype, operand, padding_value, padding_config = dtype_x_params
helpers.test_frontend_function(
input_dtypes=dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
operand=operand,
padding_value=padding_value,
padding_config=padding_config,
)
@handle_frontend_test(
fn_tree="jax.lax.pow",
dtypes_and_values=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("float"),
num_arrays=2,
shared_dtype=True,
),
test_with_out=st.just(False),
)
def test_jax_pow(
*,
dtypes_and_values,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtypes, xs = dtypes_and_values
helpers.test_frontend_function(
input_dtypes=input_dtypes,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=xs[0],
y=xs[1],
)
# real
@handle_frontend_test(
fn_tree="jax.lax.real",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("complex")
),
)
def test_jax_real(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
test_values=True,
x=x[0],
)
@handle_frontend_test(
fn_tree="jax.lax.reciprocal",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("float"),
),
test_with_out=st.just(False),
)
def test_jax_reciprocal(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
)
@handle_frontend_test(
fn_tree="jax.lax.reduce_window",
all_args=_reduce_window_helper(_get_reduce_func),
test_with_out=st.just(False),
)
def test_jax_reduce_window(
*,
all_args,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
dtypes, operand, init_value, computation, others, padding = all_args
helpers.test_frontend_function(
input_dtypes=dtypes,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
operand=operand[0],
init_value=init_value[0],
computation=computation,
window_dimensions=others[0],
window_strides=others[1],
padding=padding,
base_dilation=others[2],
window_dilation=None,
)
@handle_frontend_test(
fn_tree="jax.lax.rem",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
num_arrays=2,
shared_dtype=True,
allow_inf=False,
),
test_with_out=st.just(False),
)
def test_jax_rem(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
assume(not np.any(np.isclose(x[0], 0))) # ToDO, should use safety factor?
assume(not np.any(np.isclose(x[1], 0)))
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
y=x[1],
)
@handle_frontend_test(
fn_tree="jax.lax.reshape",
x_reshape_permut=_reshape_helper(),
test_with_out=st.just(False),
)
def test_jax_reshape(
*,
x_reshape_permut,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
x, dtype, shape, dimensions = x_reshape_permut
helpers.test_frontend_function(
input_dtypes=dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
operand=x[0],
new_sizes=shape,
dimensions=dimensions,
)
@handle_frontend_test(
fn_tree="jax.lax.rev",
dtype_x_axis=helpers.dtype_values_axis(
available_dtypes=helpers.get_dtypes("numeric"),
min_num_dims=1,
min_dim_size=2,
valid_axis=True,
force_int_axis=True,
allow_neg_axes=False,
),
test_with_out=st.just(False),
)
def test_jax_rev(
*,
dtype_x_axis,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x, axis = dtype_x_axis
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
operand=x[0],
dimensions=(axis,),
)
# round
@handle_frontend_test(
fn_tree="jax.lax.round",
dtype_and_x=helpers.dtype_and_values(available_dtypes=helpers.get_dtypes("float")),
rounding_method=st.sampled_from([0, 1]),
test_with_out=st.just(False),
)
def test_jax_round(
*,
dtype_and_x,
rounding_method,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
rounding_method=rounding_method,
)
@handle_frontend_test(
fn_tree="jax.lax.rsqrt",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("float"),
),
test_with_out=st.just(False),
)
def test_jax_rsqrt(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
rtol=1e-02,
x=x[0],
)
@handle_frontend_test(
fn_tree="jax.lax.select",
dtype_pred_ontrue_on_false=_dtype_pred_ontrue_on_false(),
test_with_out=st.just(False),
)
def test_jax_select(
*,
dtype_pred_ontrue_on_false,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, pred, on_true_on_false = dtype_pred_ontrue_on_false
helpers.test_frontend_function(
input_dtypes=["bool"] + input_dtype,
frontend=frontend,
backend_to_test=backend_fw,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
pred=pred,
on_true=on_true_on_false[0],
on_false=on_true_on_false[0],
)
@handle_frontend_test(
fn_tree="jax.lax.shift_left",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("integer"),
num_arrays=2,
shared_dtype=True,
),
test_with_out=st.just(False),
)
def test_jax_shift_left(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
# negative shifts will throw an exception
# shifts >= dtype width produce backend-defined behavior
x[1] = np.asarray(
np.clip(x[1], 0, np.iinfo(input_dtype[1]).bits - 1), dtype=input_dtype[1]
)
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
y=x[1],
)
@handle_frontend_test(
fn_tree="jax.lax.shift_right_logical",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("integer"),
num_arrays=2,
min_value=0,
shared_dtype=True,
),
test_with_out=st.just(False),
)
def test_jax_shift_right_logical(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
# negative shifts will throw an exception
# shifts >= dtype width produce backend-defined behavior
x[1] = np.asarray(
np.clip(x[1], 0, np.iinfo(input_dtype[1]).bits - 1), dtype=input_dtype[1]
)
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
y=x[1],
)
# sign
@handle_frontend_test(
fn_tree="jax.lax.sign",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric")
),
test_with_out=st.just(False),
)
def test_jax_sign(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
)
# sin
@handle_frontend_test(
fn_tree="jax.lax.sin",
dtype_and_x=helpers.dtype_and_values(available_dtypes=helpers.get_dtypes("float")),
test_with_out=st.just(False),
)
def test_jax_sin(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
)
# sinh
@handle_frontend_test(
fn_tree="jax.lax.sinh",
dtype_and_x=helpers.dtype_and_values(available_dtypes=helpers.get_dtypes("float")),
test_with_out=st.just(False),
)
def test_jax_sinh(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
)
@handle_frontend_test(
fn_tree="jax.lax.slice",
dtype_x_params=_slice_helper(),
test_with_out=st.just(False),
)
def test_jax_slice(
*,
dtype_x_params,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
dtype, x, start_indices, limit_indices, strides = dtype_x_params
helpers.test_frontend_function(
input_dtypes=dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
operand=x[0],
start_indices=start_indices,
limit_indices=limit_indices,
strides=strides,
)
@handle_frontend_test(
fn_tree="jax.lax.slice_in_dim",
dtype_x_params=_slice_in_dim_helper(),
test_with_out=st.just(False),
)
def test_jax_slice_in_dim(
*,
dtype_x_params,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
dtype, x, start_index, limit_index, stride, axis = dtype_x_params
helpers.test_frontend_function(
input_dtypes=dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
operand=x[0],
start_index=start_index,
limit_index=limit_index,
stride=stride,
axis=axis,
)
@handle_frontend_test(
fn_tree="jax.lax.sort",
dtype_x_bounded_axis=helpers.dtype_values_axis(
available_dtypes=helpers.get_dtypes("numeric"),
min_num_dims=1,
valid_axis=True,
force_int_axis=True,
),
is_stable=st.booleans(),
test_with_out=st.just(False),
)
def test_jax_sort(
*,
dtype_x_bounded_axis,
is_stable,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x, axis = dtype_x_bounded_axis
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
operand=x[0],
dimension=axis,
is_stable=is_stable,
)
# sqrt
@handle_frontend_test(
fn_tree="jax.lax.sqrt",
dtype_and_x=helpers.dtype_and_values(available_dtypes=helpers.get_dtypes("float")),
test_with_out=st.just(False),
)
def test_jax_sqrt(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
)
@handle_frontend_test(
fn_tree="jax.lax.square",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
small_abs_safety_factor=2,
large_abs_safety_factor=2,
safety_factor_scale="log",
),
test_with_out=st.just(False),
)
def test_jax_square(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
)
@handle_frontend_test(
fn_tree="jax.lax.squeeze",
dtype_and_values=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("float"),
shape=st.shared(
helpers.get_shape(
allow_none=False,
min_num_dims=1,
max_num_dims=10,
min_dim_size=1,
max_dim_size=5,
),
key="value_shape",
),
),
dim=_squeeze_helper(),
)
def test_jax_squeeze(
*,
dtype_and_values,
dim,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, value = dtype_and_values
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
array=value[0],
dimensions=dim,
)
@handle_frontend_test(
fn_tree="jax.lax.sub",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
num_arrays=2,
shared_dtype=True,
),
test_with_out=st.just(False),
)
def test_jax_sub(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
y=x[1],
)
# tan
@handle_frontend_test(
fn_tree="jax.lax.tan",
dtype_and_x=helpers.dtype_and_values(available_dtypes=helpers.get_dtypes("float")),
test_with_out=st.just(False),
)
def test_jax_tan(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
)
# tie_in
@handle_frontend_test(
fn_tree="jax.lax.tie_in",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid"),
num_arrays=2,
shared_dtype=True,
),
test_with_out=st.just(False),
)
def test_jax_tie_in(
*,
dtype_and_x,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=x[0],
y=x[1],
)
# top_k
@handle_frontend_test(
fn_tree="jax.lax.top_k",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("float"),
min_num_dims=1,
large_abs_safety_factor=8,
small_abs_safety_factor=8,
safety_factor_scale="log",
min_dim_size=4,
max_dim_size=10,
),
k=helpers.ints(min_value=1, max_value=4),
test_with_out=st.just(False),
)
def test_jax_top_k(
*,
dtype_and_x,
k,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
dtype, x = dtype_and_x
helpers.test_frontend_function(
input_dtypes=dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
operand=x[0],
k=k,
# test_values=False,
)
@handle_frontend_test(
fn_tree="jax.lax.transpose",
dtype_x_dims=_dtype_values_dims(),
test_with_out=st.just(False),
)
def test_jax_transpose(
*,
dtype_x_dims,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
input_dtype, x, dims = dtype_x_dims
helpers.test_frontend_function(
input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
operand=x[0],
permutation=dims,
)
| ivy/ivy_tests/test_ivy/test_frontends/test_jax/test_lax/test_operators.py/0 | {
"file_path": "ivy/ivy_tests/test_ivy/test_frontends/test_jax/test_lax/test_operators.py",
"repo_id": "ivy",
"token_count": 39585
} | 48 |
from ivy_tests.test_ivy.test_frontends import NativeClass
mindspore_classes_to_ivy_classes = {}
def convmindspore(argument):
"""Convert NativeClass in argument to ivy frontend counterpart for jax."""
if isinstance(argument, NativeClass):
return mindspore_classes_to_ivy_classes.get(argument._native_class)
return argument
| ivy/ivy_tests/test_ivy/test_frontends/test_mindspore/__init__.py/0 | {
"file_path": "ivy/ivy_tests/test_ivy/test_frontends/test_mindspore/__init__.py",
"repo_id": "ivy",
"token_count": 116
} | 49 |
# global
import numpy as np
from hypothesis import assume, strategies as st, given
# local
import ivy
from ivy.functional.frontends.numpy import ndarray
import ivy_tests.test_ivy.helpers as helpers
from ivy_tests.test_ivy.helpers import (
handle_frontend_method,
assert_all_close,
BackendHandler,
)
from ivy_tests.test_ivy.test_functional.test_core.test_statistical import (
_statistical_dtype_values,
)
import ivy_tests.test_ivy.test_frontends.test_numpy.helpers as np_frontend_helpers
from ivy_tests.test_ivy.test_functional.test_core.test_linalg import (
_get_first_matrix_and_dtype,
_get_second_matrix_and_dtype,
)
# from ivy.functional.frontends.numpy import ndarray
from ivy_tests.test_ivy.test_frontends.test_numpy.test_mathematical_functions.test_miscellaneous import ( # noqa
_get_clip_inputs,
)
from ivy_tests.test_ivy.test_frontends.test_numpy.test_mathematical_functions.test_sums_products_differences import ( # noqa
_get_castable_dtypes_values,
)
from ivy_tests.test_ivy.test_frontends.test_numpy.test_manipulation_routines.test_changing_number_of_dimensions import ( # noqa
_squeeze_helper,
)
CLASS_TREE = "ivy.functional.frontends.numpy.ndarray"
# --- Helpers --- #
# --------------- #
# item
@st.composite
def _item_helper(draw):
dtype = draw(
helpers.array_dtypes(
num_arrays=1,
available_dtypes=helpers.get_dtypes("numeric"),
)
)
shape = draw(
helpers.get_shape(
min_num_dims=1,
max_num_dims=3,
min_dim_size=1,
max_dim_size=10,
)
)
array = draw(
helpers.array_values(
dtype=dtype[0],
shape=shape,
large_abs_safety_factor=2,
small_abs_safety_factor=2,
)
)
index = ()
for s in shape:
index += (draw(st.integers(min_value=-s + 1, max_value=s - 1)),)
index_samples = [index, draw(helpers.ints(min_value=0, max_value=array.size - 1))]
if array.size == 1:
index_samples.append(None)
sampled_index = draw(st.sampled_from(index_samples))
if sampled_index is None:
method_all_as_kwargs_np = {}
num_positional_args = 0
else:
method_all_as_kwargs_np = {"args": sampled_index}
num_positional_args = 1
return dtype, array, method_all_as_kwargs_np, num_positional_args
# swapaxes
@st.composite
def dtype_values_and_axes(draw):
dtype, x, x_shape = draw(
helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
min_num_dims=1,
max_num_dims=5,
ret_shape=True,
)
)
axis1, axis2 = draw(
helpers.get_axis(
shape=x_shape,
sort_values=False,
unique=True,
min_size=2,
max_size=2,
force_tuple=True,
)
)
return dtype, x, axis1, axis2
@st.composite
def dtypes_x_reshape(draw):
dtypes, x = draw(
helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid"),
shape=helpers.get_shape(
allow_none=False,
min_num_dims=1,
max_num_dims=5,
min_dim_size=1,
max_dim_size=10,
),
)
)
shape = draw(helpers.reshape_shapes(shape=np.array(x).shape))
return dtypes, x, shape
# --- Main --- #
# ------------ #
@given(
dtype_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid", prune_function=False),
ret_shape=True,
),
)
def test_numpy_T(
dtype_x,
backend_fw,
frontend,
):
dtype, data, shape = dtype_x
with BackendHandler.update_backend(backend_fw) as ivy_backend:
x = ivy_backend.functional.frontends.numpy.ndarray(shape, dtype[0])
x.ivy_array = data[0]
ret = helpers.flatten_and_to_np(ret=x.T.ivy_array, backend=backend_fw)
ret_gt = helpers.flatten_and_to_np(
ret=ivy_backend.permute_dims(
ivy_backend.native_array(data[0]), list(range(len(shape)))[::-1]
),
backend=backend_fw,
)
helpers.value_test(
ret_np_flat=ret,
ret_np_from_gt_flat=ret_gt,
backend=backend_fw,
ground_truth_backend="numpy",
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__abs__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
min_num_dims=1,
allow_inf=False,
large_abs_safety_factor=4,
safety_factor_scale="linear",
),
)
def test_numpy___abs__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__add__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"), num_arrays=2
),
)
def test_numpy___add__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": xs[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"value": xs[1],
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__and__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=("bool",),
num_arrays=2,
),
)
def test_numpy___and__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": xs[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"value": xs[1],
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
# __array__
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__array__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid"),
),
)
def test_numpy___array__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"dtype": np.dtype(input_dtypes[0]),
},
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
frontend_method_data=frontend_method_data,
on_device=on_device,
)
# __array_wrap__
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__array_wrap__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid"),
num_arrays=2,
),
)
def test_numpy___array_wrap__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"array": x[1],
"context": None,
},
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
frontend_method_data=frontend_method_data,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__bool__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid"),
max_dim_size=1,
),
)
def test_numpy___bool__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__complex__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
min_dim_size=1,
max_dim_size=1,
),
)
def test_numpy___complex__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
method_input_dtypes=input_dtypes,
init_all_as_kwargs_np={
"object": xs[0],
},
method_all_as_kwargs_np={},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__contains__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid"),
),
)
def test_numpy___contains__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
key = np.asarray(xs[0].reshape(-1)[0])
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
method_input_dtypes=input_dtypes,
init_all_as_kwargs_np={
"object": xs[0],
},
method_all_as_kwargs_np={
"key": key,
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__copy__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
min_num_dims=1,
),
)
def test_numpy___copy__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__deepcopy__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
min_num_dims=1,
),
)
def test_numpy___deepcopy__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"memo": {},
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__eq__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
num_arrays=2,
),
)
def test_numpy___eq__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": xs[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"value": xs[1],
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__float__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
max_num_dims=0,
),
)
def test_numpy___float__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
# Numpy doesn't support complex to float conversion
assume(not np.issubdtype(input_dtypes[0], np.complexfloating))
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
method_input_dtypes=input_dtypes,
init_all_as_kwargs_np={
"object": xs[0],
},
method_all_as_kwargs_np={},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
# __floordiv__ test
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__floordiv__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("integer"),
num_arrays=2,
allow_inf=False,
large_abs_safety_factor=4,
safety_factor_scale="linear",
shared_dtype=True,
),
)
def test_numpy___floordiv__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
assume(not np.any(np.isclose(xs[1], 0)))
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": xs[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"value": xs[1],
},
init_flags=init_flags,
method_flags=method_flags,
frontend_method_data=frontend_method_data,
frontend=frontend,
atol_=1,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__ge__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
num_arrays=2,
),
)
def test_numpy___ge__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": xs[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"value": xs[1],
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__gt__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
num_arrays=2,
),
)
def test_numpy___gt__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": xs[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"value": xs[1],
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__iadd__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"), num_arrays=2
),
)
def test_numpy___iadd__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
method_input_dtypes=input_dtypes,
init_all_as_kwargs_np={
"object": xs[0],
},
method_all_as_kwargs_np={
"value": xs[1],
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__iand__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=("bool",),
num_arrays=2,
),
)
def test_numpy___iand__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
method_input_dtypes=input_dtypes,
init_all_as_kwargs_np={
"object": xs[0],
},
method_all_as_kwargs_np={
"value": xs[1],
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__ifloordiv__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("integer"),
num_arrays=2,
allow_inf=False,
large_abs_safety_factor=4,
safety_factor_scale="linear",
shared_dtype=True,
),
)
def test_numpy___ifloordiv__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
assume(not np.any(np.isclose(xs[1], 0)))
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": xs[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"value": xs[1],
},
init_flags=init_flags,
method_flags=method_flags,
frontend_method_data=frontend_method_data,
frontend=frontend,
atol_=1,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__imod__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("float"),
num_arrays=2,
min_value=0,
exclude_min=True,
),
)
def test_numpy___imod__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
method_input_dtypes=input_dtypes,
init_all_as_kwargs_np={
"object": xs[0],
},
method_all_as_kwargs_np={
"value": xs[1],
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__imul__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"), num_arrays=2
),
)
def test_numpy___imul__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
method_input_dtypes=input_dtypes,
init_all_as_kwargs_np={
"object": xs[0],
},
method_all_as_kwargs_np={
"value": xs[1],
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__int__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
max_num_dims=0,
min_value=-1e15,
max_value=1e15,
),
)
def test_numpy___int__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
# Numpy doesn't support complex to int conversion
assume(not np.issubdtype(input_dtypes[0], np.complexfloating))
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
method_input_dtypes=input_dtypes,
init_all_as_kwargs_np={
"object": xs[0],
},
method_all_as_kwargs_np={},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__invert__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes(kind="integer"),
num_arrays=1,
),
)
def test_numpy___invert__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
frontend,
backend_fw,
on_device,
):
input_dtypes, xs = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
init_all_as_kwargs_np={
"object": xs[0],
},
method_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
method_all_as_kwargs_np={},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__ior__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=("bool",),
num_arrays=2,
),
)
def test_numpy___ior__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
method_input_dtypes=input_dtypes,
init_all_as_kwargs_np={
"object": xs[0],
},
method_all_as_kwargs_np={
"value": xs[1],
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__ipow__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("float"),
),
power=helpers.ints(min_value=1, max_value=3),
)
def test_numpy___ipow__(
dtype_and_x,
power,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
method_input_dtypes=input_dtypes,
init_all_as_kwargs_np={
"object": xs[0],
},
method_all_as_kwargs_np={
"value": power,
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
# __irshift__
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__irshift__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("integer"),
num_arrays=2,
),
)
def test_numpy___irshift__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
frontend,
backend_fw,
on_device,
):
input_dtypes, x = dtype_and_x
max_bits = np.iinfo(input_dtypes[0]).bits
max_shift = max_bits - 1
x[1] = np.asarray(np.clip(x[1], 0, max_shift), dtype=input_dtypes[1])
max_value_before_shift = 2 ** (max_bits - x[1]) - 1
overflow_threshold = 2 ** (max_bits - 1)
x[0] = np.asarray(
np.clip(x[0], None, max_value_before_shift), dtype=input_dtypes[0]
)
if np.any(x[0] > overflow_threshold):
x[0] = np.clip(x[0], None, overflow_threshold)
if np.any(x[0] < 0):
x[0] = np.abs(x[0])
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
method_all_as_kwargs_np={
"value": x[1],
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__isub__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"), num_arrays=2
),
)
def test_numpy___isub__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
method_input_dtypes=input_dtypes,
init_all_as_kwargs_np={
"object": xs[0],
},
method_all_as_kwargs_np={
"value": xs[1],
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
# __itruediv__
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__itruediv__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("float"),
num_arrays=2,
shared_dtype=True,
),
)
def test_numpy___itruediv__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": xs[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"value": xs[1],
},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__ixor__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=("bool",),
num_arrays=2,
),
)
def test_numpy___ixor__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
method_input_dtypes=input_dtypes,
init_all_as_kwargs_np={
"object": xs[0],
},
method_all_as_kwargs_np={
"value": xs[1],
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__le__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
num_arrays=2,
),
)
def test_numpy___le__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": xs[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"value": xs[1],
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
# __len__
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__len__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
min_num_dims=1,
max_num_dims=5,
),
)
def test_numpy___len__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={},
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
frontend_method_data=frontend_method_data,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__lt__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
num_arrays=2,
),
)
def test_numpy___lt__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": xs[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"value": xs[1],
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__matmul__",
x=_get_first_matrix_and_dtype(),
y=_get_second_matrix_and_dtype(),
)
def test_numpy___matmul__(
x,
y,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
dtype1, x1 = x
dtype2, x2 = y
input_dtypes = dtype1 + dtype2
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x1,
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"value": x2,
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
# mod
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__mod__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("float"),
num_arrays=2,
large_abs_safety_factor=2,
small_abs_safety_factor=2,
safety_factor_scale="log",
min_value=0,
exclude_min=True,
),
)
def test_numpy___mod__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
method_input_dtypes=input_dtypes,
init_all_as_kwargs_np={
"object": xs[0],
},
method_all_as_kwargs_np={
"value": xs[1],
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
rtol_=1e-5,
atol_=1e-5,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__mul__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
num_arrays=2,
),
)
def test_numpy___mul__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": xs[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"value": xs[1],
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__ne__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
num_arrays=2,
),
)
def test_numpy___ne__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": xs[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"value": xs[1],
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__neg__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
min_num_dims=1,
),
)
def test_numpy___neg__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__or__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=("bool",),
num_arrays=2,
),
)
def test_numpy___or__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": xs[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"value": xs[1],
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__pos__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
min_num_dims=1,
),
)
def test_numpy___pos__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__pow__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("float"),
),
power=helpers.ints(min_value=1, max_value=3),
)
def test_numpy___pow__(
dtype_and_x,
power,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": xs[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"value": power,
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__radd__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"), num_arrays=2
),
)
def test_numpy___radd__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": xs[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"value": xs[1],
},
method_flags=method_flags,
init_flags=init_flags,
frontend=frontend,
frontend_method_data=frontend_method_data,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__rmul__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
num_arrays=2,
),
)
def test_numpy___rmul__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": xs[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"value": xs[1],
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__rshift__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("integer"),
num_arrays=2,
),
)
def test_numpy___rshift__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
frontend,
backend_fw,
on_device,
):
input_dtypes, x = dtype_and_x
max_bits = np.iinfo(input_dtypes[0]).bits
max_shift = max_bits - 1
x[1] = np.asarray(np.clip(x[1], 0, max_shift), dtype=input_dtypes[1])
max_value_before_shift = 2 ** (max_bits - x[1]) - 1
overflow_threshold = 2 ** (max_bits - 1)
x[0] = np.asarray(
np.clip(x[0], None, max_value_before_shift), dtype=input_dtypes[0]
)
if np.any(x[0] > overflow_threshold):
x[0] = np.clip(x[0], None, overflow_threshold)
if np.any(x[0] < 0):
x[0] = np.abs(x[0])
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
method_all_as_kwargs_np={
"value": x[1],
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__rtruediv__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
num_arrays=2,
),
)
def test_numpy___rtruediv__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
assume(not np.any(np.isclose(xs[0], 0)))
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": xs[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"value": xs[1],
},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__sub__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"), num_arrays=2
),
)
def test_numpy___sub__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
helpers.test_frontend_method(
backend_to_test=backend_fw,
init_input_dtypes=input_dtypes,
init_all_as_kwargs_np={
"object": xs[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"value": xs[1],
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__truediv__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
num_arrays=2,
),
)
def test_numpy___truediv__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
assume(not np.any(np.isclose(xs[0], 0)))
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": xs[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"value": xs[1],
},
init_flags=init_flags,
method_flags=method_flags,
frontend_method_data=frontend_method_data,
frontend=frontend,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__xor__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=("bool",),
num_arrays=2,
),
)
def test_numpy___xor__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": xs[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"value": xs[1],
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="all",
dtype_x_axis=helpers.dtype_values_axis(
available_dtypes=helpers.get_dtypes("valid", full=True),
min_num_dims=1,
max_num_dims=5,
min_dim_size=1,
valid_axis=True,
force_int_axis=True,
allow_neg_axes=True,
),
keepdims=st.booleans(),
where=np_frontend_helpers.where(),
)
def test_numpy_all(
dtype_x_axis,
keepdims,
where,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
init_input_dtypes, x, axis = dtype_x_axis
(
where,
method_input_dtypes,
method_flags,
) = np_frontend_helpers.handle_where_and_array_bools(
where=[where[0][0]] if isinstance(where, list) else where,
input_dtype=init_input_dtypes,
test_flags=method_flags,
)
helpers.test_frontend_method(
init_input_dtypes=init_input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=method_input_dtypes[1:],
method_all_as_kwargs_np={
"axis": axis,
"dtype": bool,
"out": None,
"keepdims": keepdims,
"where": where,
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
# any
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="any",
dtype_x_axis=helpers.dtype_values_axis(
available_dtypes=helpers.get_dtypes("valid"),
min_num_dims=1,
max_num_dims=5,
min_dim_size=1,
valid_axis=True,
force_int_axis=True,
allow_neg_axes=True,
),
keepdims=st.booleans(),
where=np_frontend_helpers.where(),
)
def test_numpy_any(
dtype_x_axis,
keepdims,
where,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
init_input_dtypes, x, axis = dtype_x_axis
(
where,
method_input_dtypes,
method_flags,
) = np_frontend_helpers.handle_where_and_array_bools(
where=[where[0][0]] if isinstance(where, list) else where,
input_dtype=init_input_dtypes,
test_flags=method_flags,
)
helpers.test_frontend_method(
init_input_dtypes=init_input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=method_input_dtypes[1:],
method_all_as_kwargs_np={
"axis": axis,
"dtype": bool,
"out": None,
"keepdims": keepdims,
"where": where,
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="argmax",
dtype_x_axis=helpers.dtype_values_axis(
available_dtypes=st.one_of(
helpers.get_dtypes("numeric"),
),
min_axis=-1,
max_axis=0,
min_num_dims=1,
force_int_axis=True,
),
keep_dims=st.booleans(),
)
def test_numpy_argmax(
dtype_x_axis,
keep_dims,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, x, axis = dtype_x_axis
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"axis": axis,
"keepdims": keep_dims,
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="argmin",
dtype_x_axis=helpers.dtype_values_axis(
available_dtypes=helpers.get_dtypes("numeric"),
min_num_dims=1,
valid_axis=True,
force_int_axis=True,
),
keepdims=st.booleans(),
)
def test_numpy_argmin(
dtype_x_axis,
keepdims,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, x, axis = dtype_x_axis
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"axis": axis,
"keepdims": keepdims,
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="argsort",
dtype_x_axis=helpers.dtype_values_axis(
available_dtypes=helpers.get_dtypes("numeric"),
min_axis=-1,
max_axis=0,
min_num_dims=1,
force_int_axis=True,
),
)
def test_numpy_argsort(
dtype_x_axis,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, x, axis = dtype_x_axis
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
method_input_dtypes=input_dtypes,
init_all_as_kwargs_np={
"object": x[0],
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
method_all_as_kwargs_np={
"axis": axis,
"kind": None,
"order": None,
},
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="astype",
dtypes_values_casting=np_frontend_helpers.dtypes_values_casting_dtype(
arr_func=[
lambda: helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
)
],
),
order=st.sampled_from(["C", "F", "A", "K"]),
copy=st.booleans(),
)
def test_numpy_astype(
dtypes_values_casting,
order,
copy,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, x, casting, dtype = dtypes_values_casting
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"dtype": dtype if dtype else input_dtypes[0],
"order": order,
"casting": casting,
"copy": copy,
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="clip",
input_and_ranges=_get_clip_inputs(),
)
def test_numpy_clip(
input_and_ranges,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, x, min, max = input_and_ranges
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
method_input_dtypes=input_dtypes,
init_all_as_kwargs_np={
"object": x[0],
},
method_all_as_kwargs_np={
"min": min,
"max": max,
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="compress",
dtype_arr_ax=helpers.dtype_values_axis(
available_dtypes=helpers.get_dtypes("valid"),
min_num_dims=1,
max_num_dims=5,
min_dim_size=10,
max_dim_size=100,
valid_axis=True,
force_int_axis=True,
),
condition=helpers.array_values(
dtype=helpers.get_dtypes("bool"),
shape=helpers.get_shape(
min_num_dims=1, max_num_dims=1, min_dim_size=1, max_dim_size=5
),
),
)
def test_numpy_compress(
dtype_arr_ax,
condition,
frontend_method_data,
init_flags,
method_flags,
frontend,
backend_fw,
on_device,
):
input_dtypes, arr, ax = dtype_arr_ax
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
init_all_as_kwargs_np={
"object": arr[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"condition": condition,
"axis": ax,
"out": None,
},
frontend=frontend,
backend_to_test=backend_fw,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="conjugate",
dtype_and_x=helpers.dtype_values_axis(
available_dtypes=helpers.get_dtypes("real_and_complex"),
),
)
def test_numpy_conjugate(
dtype_and_x,
on_device,
frontend,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
):
input_dtype, x, axis = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="copy",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
min_num_dims=1,
),
)
def test_numpy_copy(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="cumprod",
dtype_x_axis=helpers.dtype_values_axis(
available_dtypes=helpers.get_dtypes("numeric"),
min_axis=-1,
max_axis=0,
min_num_dims=1,
force_int_axis=True,
),
dtype=helpers.get_dtypes("float", full=False, none=True),
)
def test_numpy_cumprod(
dtype_x_axis,
dtype,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, x, axis = dtype_x_axis
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"axis": axis,
"dtype": dtype[0],
"out": None,
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="cumsum",
dtype_x_axis_dtype=_get_castable_dtypes_values(),
)
def test_numpy_cumsum(
dtype_x_axis_dtype,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, x, axis, dtype = dtype_x_axis_dtype
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"axis": axis,
"dtype": dtype,
"out": None,
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="diagonal",
dtype_x_axis=helpers.dtype_values_axis(
available_dtypes=helpers.get_dtypes("numeric"),
min_num_dims=2,
min_axes_size=2,
max_axes_size=2,
valid_axis=True,
),
offset=st.integers(min_value=-2, max_value=2),
)
def test_numpy_diagonal(
dtype_x_axis,
offset,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, x, axis = dtype_x_axis
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"axis1": axis[0],
"axis2": axis[1],
"offset": offset,
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="dot",
dtype_and_x=np_frontend_helpers._get_dtype_input_and_vectors(),
)
def test_numpy_dot(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtype, x, other = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x,
},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={
"b": other,
},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
@given(
dtype_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid", prune_function=False),
ret_shape=True,
),
)
def test_numpy_dtype(dtype_x, backend_fw, frontend):
dtype, data, shape = dtype_x
with BackendHandler.update_backend(backend_fw) as ivy_backend:
x = ivy_backend.functional.frontends.numpy.ndarray(shape, dtype[0])
x.ivy_array = data[0]
ivy_backend.utils.assertions.check_equal(
x.dtype, ivy.Dtype(dtype[0]), as_array=False
)
# fill
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="fill",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
),
num=st.integers(min_value=1, max_value=10) | st.floats(min_value=1, max_value=10),
)
def test_numpy_fill(
dtype_and_x,
num,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=[],
method_all_as_kwargs_np={
"num": num,
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@given(
dtype_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric", prune_function=False),
num_arrays=1,
ret_shape=True,
)
)
def test_numpy_flat(dtype_x, backend_fw):
dtype, data, shape = dtype_x
with BackendHandler.update_backend(backend_fw) as ivy_backend:
x = ivy_backend.functional.frontends.numpy.ndarray(shape, dtype[0])
x.ivy_array = data[0]
flat_ivy = x.flat
flat_ivy = flat_ivy.ivy_array.to_numpy()
flat_generated = ivy_backend.to_numpy(data[0]).flatten()
ivy_backend.utils.assertions.check_equal(
flat_ivy, flat_generated, as_array=True
)
# __getitem__
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__getitem__",
dtype_x_index=helpers.dtype_array_query(
available_dtypes=helpers.get_dtypes("valid"),
),
)
def test_numpy_getitem(
dtype_x_index,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtype, x, index = dtype_x_index
helpers.test_frontend_method(
init_input_dtypes=[input_dtype[0]],
init_all_as_kwargs_np={"object": x},
method_input_dtypes=[*input_dtype[1:]],
method_all_as_kwargs_np={"key": index},
backend_to_test=backend_fw,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
# __ilshift__
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__ilshift__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("integer"),
num_arrays=2,
max_dim_size=1,
max_value=2**31 - 1,
),
)
def test_numpy_instance_ilshift__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
frontend,
backend_fw,
on_device,
):
input_dtypes, x = dtype_and_x
max_bits = np.iinfo(input_dtypes[0]).bits
max_shift = max_bits - 1
x[1] = np.asarray(np.clip(x[1], 0, max_shift), dtype=input_dtypes[1])
max_value_before_shift = 2 ** (max_bits - x[1]) - 1
overflow_threshold = 2 ** (max_bits - 1)
x[0] = np.asarray(
np.clip(x[0], None, max_value_before_shift), dtype=input_dtypes[0]
)
if np.any(x[0] > overflow_threshold):
x[0] = np.clip(x[0], None, overflow_threshold)
if np.any(x[0] < 0):
x[0] = np.abs(x[0])
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
method_all_as_kwargs_np={
"value": x[1],
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__lshift__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("integer"),
num_arrays=2,
max_dim_size=1,
max_value=2**31 - 1,
),
)
def test_numpy_instance_lshift__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
frontend,
backend_fw,
on_device,
):
input_dtypes, x = dtype_and_x
max_bits = np.iinfo(input_dtypes[0]).bits
max_shift = max_bits - 1
x[1] = np.asarray(np.clip(x[1], 0, max_shift), dtype=input_dtypes[1])
max_value_before_shift = 2 ** (max_bits - x[1]) - 1
overflow_threshold = 2 ** (max_bits - 1)
x[0] = np.asarray(
np.clip(x[0], None, max_value_before_shift), dtype=input_dtypes[0]
)
if np.any(x[0] > overflow_threshold):
x[0] = np.clip(x[0], None, overflow_threshold)
if np.any(x[0] < 0):
x[0] = np.abs(x[0])
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
method_all_as_kwargs_np={
"value": x[1],
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="item",
args_kwargs=_item_helper(),
)
def test_numpy_item(
args_kwargs,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtype, x, method_all_as_kwargs_np, num_positional_args = args_kwargs
method_flags.num_positional_args = num_positional_args
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
init_all_as_kwargs_np={"object": x},
method_input_dtypes=input_dtype,
backend_to_test=backend_fw,
method_all_as_kwargs_np=method_all_as_kwargs_np,
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@given(
dtype_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid", prune_function=False),
ret_shape=True,
),
)
def test_numpy_ivy_array(
dtype_x,
frontend,
backend_fw,
):
dtype, data, shape = dtype_x
with BackendHandler.update_backend(backend_fw) as ivy_backend:
x = ivy_backend.functional.frontends.numpy.ndarray(shape, dtype[0])
x.ivy_array = data[0]
ret = helpers.flatten_and_to_np(ret=x.ivy_array.data, backend=backend_fw)
ret_gt = helpers.flatten_and_to_np(ret=data[0], backend=frontend)
helpers.value_test(
ret_np_flat=ret,
ret_np_from_gt_flat=ret_gt,
backend=backend_fw,
ground_truth_backend="numpy",
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="max",
dtype_x_axis=helpers.dtype_values_axis(
available_dtypes=helpers.get_dtypes("numeric"),
min_axis=-1,
max_axis=0,
min_num_dims=1,
force_int_axis=True,
),
keepdims=st.booleans(),
)
def test_numpy_max(
dtype_x_axis,
keepdims,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, x, axis = dtype_x_axis
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"axis": axis,
"keepdims": keepdims,
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="mean",
dtype_and_x=_statistical_dtype_values(function="mean"),
dtype=helpers.get_dtypes("float", full=False, none=True),
where=np_frontend_helpers.where(),
keep_dims=st.booleans(),
)
def test_numpy_mean(
dtype_and_x,
dtype,
where,
keep_dims,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, x, axis = dtype_and_x
where, input_dtypes, test_flags = np_frontend_helpers.handle_where_and_array_bools(
where=where,
input_dtype=input_dtypes,
test_flags=method_flags,
)
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
method_input_dtypes=input_dtypes[1:],
init_all_as_kwargs_np={
"object": x[0],
},
method_all_as_kwargs_np={
"axis": axis,
"dtype": dtype[0],
"out": None,
"keepdims": keep_dims,
"where": where,
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
rtol_=1e-2,
atol_=1e-2,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="min",
dtype_x_axis=helpers.dtype_values_axis(
available_dtypes=helpers.get_dtypes("numeric"),
min_axis=-1,
max_axis=0,
min_num_dims=1,
force_int_axis=True,
),
keepdims=st.booleans(),
)
def test_numpy_min(
dtype_x_axis,
keepdims,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, x, axis = dtype_x_axis
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"axis": axis,
"keepdims": keepdims,
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="nonzero",
dtype_and_a=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid"),
),
)
def test_numpy_nonzero(
dtype_and_a,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, a = dtype_and_a
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
init_all_as_kwargs_np={
"object": a[0],
},
method_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
method_all_as_kwargs_np={},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
# prod
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="prod",
dtype_x_axis_dtype=_get_castable_dtypes_values(use_where=True),
keep_dims=st.booleans(),
initial=st.one_of(st.floats(min_value=-100, max_value=100)),
)
def test_numpy_prod(
dtype_x_axis_dtype,
keep_dims,
initial,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, x, axis, dtype, where = dtype_x_axis_dtype
if ivy.current_backend_str() == "torch":
assume(not method_flags.as_variable[0])
(
where,
input_dtypes,
method_flags,
) = np_frontend_helpers.handle_where_and_array_bools(
where=where,
input_dtype=input_dtypes,
test_flags=method_flags,
)
where = ivy.array(where, dtype="bool")
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"axis": axis,
"dtype": dtype,
"keepdims": keep_dims,
"initial": initial,
"where": where,
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@given(
dtype_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid", prune_function=False),
ret_shape=True,
),
)
def test_numpy_property_ndim(dtype_x, backend_fw):
dtype, data, shape = dtype_x
with BackendHandler.update_backend(backend_fw) as ivy_backend:
x = ivy_backend.functional.frontends.numpy.ndarray(shape, dtype[0])
x.ivy_array = data[0]
ivy_backend.utils.assertions.check_equal(x.ndim, data[0].ndim, as_array=False)
# ptp
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="ptp",
dtype_x_axis=helpers.dtype_values_axis(
available_dtypes=helpers.get_dtypes("numeric"),
valid_axis=True,
),
)
def test_numpy_ptp(
dtype_x_axis,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, x, axis = dtype_x_axis
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"axis": axis,
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="ravel",
dtype_and_a=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid"),
),
)
def test_numpy_ravel(
dtype_and_a,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, a = dtype_and_a
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
init_all_as_kwargs_np={
"object": a[0],
},
method_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
method_all_as_kwargs_np={},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="repeat",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid"),
min_num_dims=2,
min_dim_size=2,
),
repeats=helpers.ints(min_value=2, max_value=5),
axis=helpers.ints(min_value=-1, max_value=1),
)
def test_numpy_repeat(
dtype_and_x,
repeats,
axis,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"repeats": repeats,
"axis": axis,
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="reshape",
dtypes_x_shape=dtypes_x_reshape(),
order=st.sampled_from(["C", "F", "A"]),
)
def test_numpy_reshape(
dtypes_x_shape,
order,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, x, shape = dtypes_x_shape
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=[],
method_all_as_kwargs_np={
"newshape": shape,
"order": order,
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
# round
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="round",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("float", full=False),
num_arrays=1,
max_value=50,
min_value=-50,
),
decimals=st.integers(min_value=0, max_value=3),
)
def test_numpy_round(
dtype_and_x,
decimals,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
method_input_dtypes=input_dtype,
backend_to_test=backend_fw,
frontend=frontend,
init_all_as_kwargs_np={
"object": x,
},
method_all_as_kwargs_np={
"decimals": decimals,
},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="searchsorted",
dtype_x_v=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("signed_integer"),
min_num_dims=1,
max_num_dims=1,
num_arrays=2,
),
side=st.sampled_from(["left", "right"]),
)
def test_numpy_searchsorted(
dtype_x_v,
side,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_x_v
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
init_all_as_kwargs_np={
"object": xs[0],
},
method_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
method_all_as_kwargs_np={
"v": xs[1],
"side": side,
"sorter": np.argsort(xs[0]),
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
# __setitem__
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="__setitem__",
dtypes_x_index_val=helpers.dtype_array_query_val(
available_dtypes=helpers.get_dtypes("valid"),
),
)
def test_numpy_setitem(
dtypes_x_index_val,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtype, x, index, val = dtypes_x_index_val
helpers.test_frontend_method(
init_input_dtypes=[input_dtype[0]],
init_all_as_kwargs_np={"object": x},
method_input_dtypes=[*input_dtype[1:]],
method_all_as_kwargs_np={"key": index, "value": val},
backend_to_test=backend_fw,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
@given(
dtype_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid", prune_function=False),
ret_shape=True,
),
)
def test_numpy_shape(
dtype_x,
backend_fw,
):
dtype, data, shape = dtype_x
with BackendHandler.update_backend(backend_fw) as ivy_backend:
x = ivy_backend.functional.frontends.numpy.ndarray(shape, dtype[0])
x.ivy_array = data[0]
ivy_backend.utils.assertions.check_equal(
x.shape, ivy.Shape(shape), as_array=False
)
@given(
dtype_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid", prune_function=False),
ret_shape=True,
),
)
def test_numpy_size(
dtype_x,
):
dtype, data, shape = dtype_x
x = ndarray(shape, dtype[0])
x.ivy_array = data[0]
ivy.utils.assertions.check_equal(x.size, data[0].size, as_array=False)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="sort",
dtype_x_axis=helpers.dtype_values_axis(
available_dtypes=helpers.get_dtypes("float"),
min_axis=-1,
max_axis=0,
min_num_dims=1,
force_int_axis=True,
),
)
def test_numpy_sort(
dtype_x_axis,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, x, axis = dtype_x_axis
ret, frontend_ret = helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"axis": axis,
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
test_values=False,
on_device=on_device,
)
frontend_ret = np.sort(x[0], axis=axis)
assert_all_close(
ret_np=ret,
ret_from_gt_np=frontend_ret,
rtol=1e-2,
atol=1e-2,
backend=backend_fw,
ground_truth_backend="numpy",
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="squeeze",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid"),
shape=st.shared(helpers.get_shape(), key="value_shape"),
),
axis=_squeeze_helper(),
)
def test_numpy_squeeze(
dtype_and_x,
axis,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={
"axis": axis,
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="std",
dtype_x_axis=helpers.dtype_values_axis(
available_dtypes=helpers.get_dtypes("valid"),
max_value=100,
valid_axis=True,
force_int_axis=True,
),
keepdims=st.booleans(),
where=np_frontend_helpers.where(),
)
def test_numpy_std(
dtype_x_axis,
keepdims,
where,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, x, axis = dtype_x_axis
(
where,
input_dtypes,
method_flags,
) = np_frontend_helpers.handle_where_and_array_bools(
where=[where[0][0]] if isinstance(where, list) else where,
input_dtype=input_dtypes,
test_flags=method_flags,
)
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
method_input_dtypes=input_dtypes,
init_all_as_kwargs_np={
"data": x[0],
},
method_all_as_kwargs_np={
"axis": axis,
"out": None,
"ddof": 0,
"keepdims": keepdims,
"where": where,
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
# sum
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="sum",
dtype_x_axis_dtype=_get_castable_dtypes_values(use_where=True),
keep_dims=st.booleans(),
initial=st.one_of(st.floats(min_value=-100, max_value=100)),
)
def test_numpy_sum(
dtype_x_axis_dtype,
keep_dims,
initial,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtypes, x, axis, dtype, where = dtype_x_axis_dtype
if ivy.current_backend_str() == "torch":
assume(not method_flags.as_variable[0])
(
where,
input_dtypes,
method_flags,
) = np_frontend_helpers.handle_where_and_array_bools(
where=where,
input_dtype=input_dtypes,
test_flags=method_flags,
)
where = ivy.array(where, dtype="bool")
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"axis": axis,
"dtype": dtype,
"keepdims": keep_dims,
"initial": initial,
"where": where,
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
backend_to_test=backend_fw,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="swapaxes",
dtype_x_and_axes=dtype_values_and_axes(),
)
def test_numpy_swapaxes(
dtype_x_and_axes,
frontend,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
on_device,
):
input_dtypes, x, axis1, axis2 = dtype_x_and_axes
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
method_input_dtypes=input_dtypes,
init_all_as_kwargs_np={
"object": x[0],
},
method_all_as_kwargs_np={
"axis1": axis1,
"axis2": axis2,
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
# tobytes
@given(
dtype_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid", prune_function=False),
ret_shape=True,
),
order=st.sampled_from(["C", "F"]),
)
def test_numpy_tobytes(
dtype_x,
order,
backend_fw,
):
dtype, data, shape = dtype_x
with BackendHandler.update_backend(backend_fw) as ivy_backend:
x = ivy_backend.functional.frontends.numpy.ndarray(shape, dtype[0])
x.ivy_array = data[0]
ivy_backend.utils.assertions.check_equal(
x.tobytes(order=order), data[0].tobytes(order=order), as_array=False
)
# tofile
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="tofile",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid"),
),
path=st.text(
alphabet=st.characters(whitelist_categories=("Lu", "Ll", "Nd", "Pc")),
min_size=1,
max_size=50,
),
)
def test_numpy_tofile(
dtype_and_x,
path,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"fid": path,
},
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
frontend_method_data=frontend_method_data,
on_device=on_device,
)
# tolist
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="tolist",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid"),
),
)
def test_numpy_tolist(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={},
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
frontend_method_data=frontend_method_data,
on_device=on_device,
test_values=False, # Todo change this after we add __iter__ to ndarray
)
# trace
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="trace",
dtype_x_axis=helpers.dtype_values_axis(
available_dtypes=helpers.get_dtypes("numeric"),
min_num_dims=2,
min_axes_size=2,
max_axes_size=2,
valid_axis=True,
),
offset=st.integers(min_value=-2, max_value=2),
)
def test_numpy_trace(
dtype_x_axis,
offset,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, x, axis = dtype_x_axis
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"axis1": axis[0],
"axis2": axis[1],
"offset": offset,
"out": None,
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="transpose",
array_and_axes=np_frontend_helpers._array_and_axes_permute_helper(
min_num_dims=2,
max_num_dims=5,
min_dim_size=2,
max_dim_size=10,
),
)
def test_numpy_transpose(
array_and_axes,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
array, input_dtypes, axes = array_and_axes
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": np.array(array),
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"axes": axes,
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
# var
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="var",
dtype_x_axis=_statistical_dtype_values(function="var"),
dtype=helpers.get_dtypes("valid", full=False, none=True),
where=np_frontend_helpers.where(),
keepdims=st.booleans(),
)
def test_numpy_var(
dtype_x_axis,
frontend_method_data,
init_flags,
method_flags,
frontend,
backend_fw,
on_device,
keepdims,
where,
dtype,
):
input_dtypes, x, axis = dtype_x_axis
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
method_input_dtypes=input_dtypes,
init_all_as_kwargs_np={
"object": x[0],
},
method_all_as_kwargs_np={
"axis": axis,
"dtype": dtype,
"keepdims": keepdims,
"where": where,
},
frontend=frontend,
backend_to_test=backend_fw,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
rtol_=1e-2,
atol_=1e-2,
on_device=on_device,
)
# view
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="numpy.array",
method_name="view",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid"),
),
)
def test_numpy_view(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={},
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
frontend_method_data=frontend_method_data,
on_device=on_device,
)
| ivy/ivy_tests/test_ivy/test_frontends/test_numpy/test_ndarray/test_ndarray.py/0 | {
"file_path": "ivy/ivy_tests/test_ivy/test_frontends/test_numpy/test_ndarray/test_ndarray.py",
"repo_id": "ivy",
"token_count": 49490
} | 50 |
# import tensorflow
from ivy_tests.test_ivy.test_frontends import NativeClass
onnx_classes_to_ivy_classes = {}
def convtensor(argument):
"""Convert NativeClass in argument to ivy frontend counterpart for onnx."""
if isinstance(argument, NativeClass):
return onnx_classes_to_ivy_classes.get(argument._native_class)
return argument
| ivy/ivy_tests/test_ivy/test_frontends/test_onnx/__init__.py/0 | {
"file_path": "ivy/ivy_tests/test_ivy/test_frontends/test_onnx/__init__.py",
"repo_id": "ivy",
"token_count": 122
} | 51 |
# global
from hypothesis import assume
# local
import ivy_tests.test_ivy.helpers as helpers
from ivy_tests.test_ivy.helpers import handle_frontend_test
from ivy_tests.test_ivy.test_frontends.test_torch.test_nn.test_functional.test_convolution_functions import ( # noqa: E501
_x_and_filters,
_output_shape,
)
from ivy_tests.test_ivy.test_functional.test_nn.test_layers import (
_assume_tf_dilation_gt_1,
)
# conv1d
@handle_frontend_test(
fn_tree="paddle.nn.functional.conv1d",
dtype_vals=_x_and_filters(dim=1),
)
def test_paddle_conv1d(
*,
dtype_vals,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
dtype, vals, weight, bias, dilations, strides, padding, fc = dtype_vals
helpers.test_frontend_function(
input_dtypes=dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=vals,
weight=weight,
bias=bias,
stride=strides,
padding=padding,
dilation=dilations,
groups=fc,
)
# conv1d_transpose
@handle_frontend_test(
fn_tree="paddle.nn.functional.conv1d_transpose",
dtype_vals=_x_and_filters(dim=1, transpose=True),
)
def test_paddle_conv1d_tranpose(
*,
dtype_vals,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
dtype, vals, weight, bias, dilations, strides, padding, output_pad, fc = dtype_vals
dilations = 1 # ToDo: remove this when support for dilation > 1 is added
assume(
all(
x > 0
for x in _output_shape(
1, dilations, strides, padding, output_pad, vals.shape, weight.shape
)
)
)
helpers.test_frontend_function(
input_dtypes=dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=vals,
weight=weight,
bias=bias,
stride=strides,
padding=padding,
output_padding=output_pad,
groups=fc,
dilation=dilations,
)
# conv2d
@handle_frontend_test(
fn_tree="paddle.nn.functional.conv2d",
dtype_vals=_x_and_filters(dim=2),
)
def test_paddle_conv2d(
*,
dtype_vals,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
dtype, vals, weight, bias, dilations, strides, padding, fc = dtype_vals
helpers.test_frontend_function(
input_dtypes=dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=vals,
weight=weight,
bias=bias,
stride=strides,
padding=padding,
dilation=dilations,
groups=fc,
)
# conv2d_transpose
@handle_frontend_test(
fn_tree="paddle.nn.functional.conv2d_transpose",
dtype_vals=_x_and_filters(dim=2, transpose=True),
)
def test_paddle_conv2d_tranpose(
*,
dtype_vals,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
dtype, vals, weight, bias, dilations, strides, padding, output_pad, fc = dtype_vals
dilations = 1 # ToDo: remove this when support for dilation > 1 is added
assume(
all(
x > 0
for x in _output_shape(
2, dilations, strides, padding, output_pad, vals.shape, weight.shape
)
)
)
helpers.test_frontend_function(
input_dtypes=dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=vals,
weight=weight,
bias=bias,
stride=strides,
padding=padding,
output_padding=output_pad,
dilation=dilations,
groups=fc,
)
# conv3d
@handle_frontend_test(
fn_tree="paddle.nn.functional.conv3d",
dtype_vals=_x_and_filters(dim=3),
)
def test_paddle_conv3d(
*,
dtype_vals,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
dtype, vals, weight, bias, dilations, strides, padding, fc = dtype_vals
# ToDo: Enable gradient tests for dilations > 1 when tensorflow supports it.
_assume_tf_dilation_gt_1(backend_fw, on_device, dilations)
helpers.test_frontend_function(
input_dtypes=dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=vals,
weight=weight,
bias=bias,
stride=strides,
padding=padding,
dilation=dilations,
groups=fc,
)
# conv3d_transpose
@handle_frontend_test(
fn_tree="paddle.nn.functional.conv3d_transpose",
dtype_vals=_x_and_filters(dim=3, transpose=True),
)
def test_paddle_conv3d_tranpose(
*,
dtype_vals,
on_device,
fn_tree,
frontend,
test_flags,
backend_fw,
):
dtype, vals, weight, bias, dilations, strides, padding, output_pad, fc = dtype_vals
dilations = 1 # ToDo: remove this when support for dilation > 1 is added
assume(
all(
x > 0
for x in _output_shape(
3, dilations, strides, padding, output_pad, vals.shape, weight.shape
)
)
)
helpers.test_frontend_function(
input_dtypes=dtype,
backend_to_test=backend_fw,
frontend=frontend,
test_flags=test_flags,
fn_tree=fn_tree,
on_device=on_device,
x=vals,
weight=weight,
bias=bias,
stride=strides,
padding=padding,
output_padding=output_pad,
groups=fc,
dilation=dilations,
)
| ivy/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_conv.py/0 | {
"file_path": "ivy/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_conv.py",
"repo_id": "ivy",
"token_count": 2873
} | 52 |
# global
import numpy as np
from hypothesis import assume, given
from hypothesis import strategies as st
import ivy
# local
import ivy_tests.test_ivy.helpers as helpers
from ivy.functional.frontends.paddle import Tensor
from ivy_tests.test_ivy.helpers import assert_all_close
from ivy_tests.test_ivy.helpers import handle_frontend_method, BackendHandler
from ivy_tests.test_ivy.test_functional.test_experimental.test_core.test_manipulation import ( # noqa E501
_get_dtype_values_k_axes_for_rot90,
)
from ivy_tests.test_ivy.test_functional.test_core.test_statistical import (
_statistical_dtype_values,
)
from ivy_tests.test_ivy.test_frontends.test_torch.test_blas_and_lapack_ops import (
_get_dtype_and_3dbatch_matrices,
)
from ivy_tests.test_ivy.test_frontends.test_paddle.test_manipulation import (
_tile_helper,
)
CLASS_TREE = "ivy.functional.frontends.paddle.Tensor"
# --- Helpers --- #
# --------------- #
@st.composite
def _array_and_shape(
draw,
*,
min_num_dims=1,
max_num_dims=3,
min_dim_size=1,
max_dim_size=10,
):
if isinstance(min_dim_size, st._internal.SearchStrategy):
min_dim_size = draw(min_dim_size)
if isinstance(max_dim_size, st._internal.SearchStrategy):
max_dim_size = draw(max_dim_size)
available_dtypes = draw(helpers.get_dtypes("numeric"))
dtype = draw(
helpers.array_dtypes(
num_arrays=1,
available_dtypes=available_dtypes,
)
)
dtype.append("int32")
shape = draw(
st.shared(
helpers.get_shape(
min_num_dims=min_num_dims,
max_num_dims=max_num_dims,
min_dim_size=min_dim_size,
max_dim_size=max_dim_size,
),
key="shape",
)
)
array = draw(
helpers.array_values(
dtype=dtype[0],
shape=shape,
)
)
to_shape = [(None if draw(st.booleans()) else _) for _ in shape]
return dtype, [array, to_shape]
def _filter_query(query):
return (
query.ndim > 1
if isinstance(query, np.ndarray)
else (
not any(isinstance(i, np.ndarray) and i.ndim <= 1 for i in query)
if isinstance(query, tuple)
else True
)
)
# as_complex
@st.composite
def _get_as_complex_inputs_(draw):
shape = draw(
helpers.get_shape(
min_num_dims=2, max_num_dims=5, min_dim_size=2, max_dim_size=10
)
)
x_dtype, x = draw(
helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid"),
shape=(*shape, 2),
min_value=0,
max_value=50,
)
)
return x_dtype, x
# clip
@st.composite
def _get_clip_inputs(draw):
shape = draw(
helpers.get_shape(
min_num_dims=1, max_num_dims=5, min_dim_size=1, max_dim_size=10
)
)
x_dtype, x = draw(
helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid"),
shape=shape,
min_value=0,
max_value=50,
)
)
min = draw(
helpers.array_values(dtype=x_dtype[0], shape=(1,), min_value=0, max_value=25)
)
max = draw(
helpers.array_values(dtype=x_dtype[0], shape=(1,), min_value=26, max_value=50)
)
if draw(st.booleans()):
min = None
elif draw(st.booleans()):
max = None
return x_dtype, x, min, max
# clip_
@st.composite
def _get_clip_inputs_(draw):
shape = draw(
helpers.get_shape(
min_num_dims=1, max_num_dims=5, min_dim_size=1, max_dim_size=10
)
)
x_dtype, x = draw(
helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid"),
shape=shape,
min_value=0,
max_value=50,
)
)
min = draw(
helpers.array_values(dtype=x_dtype[0], shape=(1,), min_value=0, max_value=25)
)
max = draw(
helpers.array_values(dtype=x_dtype[0], shape=(1,), min_value=26, max_value=50)
)
return x_dtype, x, min, max
@st.composite
def _get_dtype_and_3dbatch_matrices_for_matmul(draw):
dim_size1 = draw(helpers.ints(min_value=2, max_value=5))
dim_size2 = draw(helpers.ints(min_value=2, max_value=5))
shared_size = draw(helpers.ints(min_value=2, max_value=5))
dtype = draw(helpers.get_dtypes("float", full=True))
dtype = [
draw(st.sampled_from(tuple(set(dtype).difference({"bfloat16", "float16"}))))
]
batch_size = draw(helpers.ints(min_value=2, max_value=4))
transpose_x = draw(st.booleans())
transpose_y = draw(st.booleans())
mat1_shape = (
(batch_size, dim_size1, shared_size)
if not transpose_x
else (batch_size, shared_size, dim_size1)
)
mat2_shape = (
(batch_size, shared_size, dim_size2)
if not transpose_y
else (batch_size, dim_size2, shared_size)
)
mat1 = draw(
helpers.array_values(dtype=dtype[0], shape=mat1_shape, min_value=2, max_value=5)
)
mat2 = draw(
helpers.array_values(dtype=dtype[0], shape=mat2_shape, min_value=2, max_value=5)
)
return dtype, mat1, mat2, transpose_x, transpose_y
# cond
@st.composite
def _get_dtype_and_matrix_non_singular(draw, dtypes):
while True:
matrix = draw(
helpers.dtype_and_values(
available_dtypes=dtypes,
min_value=-10,
max_value=10,
min_num_dims=2,
max_num_dims=2,
min_dim_size=1,
max_dim_size=5,
shape=st.tuples(st.integers(1, 5), st.integers(1, 5)).filter(
lambda x: x[0] == x[1]
),
allow_inf=False,
allow_nan=False,
)
)
if np.linalg.det(matrix[1][0]) != 0:
break
return matrix[0], matrix[1]
@st.composite
def _get_dtype_and_multiplicative_matrices(draw):
return draw(
st.one_of(
_get_dtype_input_and_matrices_for_matmul(),
_get_dtype_and_3dbatch_matrices_for_matmul(),
)
)
@st.composite
def _get_dtype_and_square_matrix(draw):
dim_size = draw(helpers.ints(min_value=2, max_value=5))
dtype = draw(helpers.get_dtypes("float", index=1, full=False))
mat = draw(
helpers.array_values(
dtype=dtype[0], shape=(dim_size, dim_size), min_value=0, max_value=10
)
)
return dtype, mat
# bmm helper function
@st.composite
def _get_dtype_and_values_bmm(draw):
# arrays x and y of sizes (b, m, k) and (b, k, n) respectively
b = draw(helpers.ints(min_value=1, max_value=10))
k = draw(helpers.ints(min_value=1, max_value=10))
m = draw(helpers.ints(min_value=1, max_value=10))
n = draw(helpers.ints(min_value=1, max_value=10))
dtype = draw(helpers.get_dtypes("float", index=1, full=False))
x = draw(
helpers.array_values(
dtype=dtype[0], shape=(b, m, k), min_value=-10, max_value=10
)
)
y = draw(
helpers.array_values(
dtype=dtype[0], shape=(b, k, n), min_value=-10, max_value=10
)
)
return dtype, x, y
# lerp helper function
@st.composite
def _get_dtype_and_values_for_lerp(draw):
is_tensor = draw(st.booleans())
if is_tensor:
input_dtype, x = draw(
helpers.dtype_and_values(
num_arrays=3,
available_dtypes=helpers.get_dtypes("valid"),
shared_dtype=True,
)
)
return input_dtype, x[0], x[1], x[2]
else:
input_dtype, x = draw(
helpers.dtype_and_values(
num_arrays=2,
available_dtypes=helpers.get_dtypes("valid"),
shared_dtype=True,
)
)
weight = draw(st.floats())
return input_dtype, x[0], x[1], weight
@st.composite
def _get_dtype_input_and_matrices_for_matmul(draw):
dim_size1 = draw(helpers.ints(min_value=2, max_value=5))
dim_size2 = draw(helpers.ints(min_value=2, max_value=5))
shared_size = draw(helpers.ints(min_value=2, max_value=5))
dtype = draw(helpers.get_dtypes("float", full=True))
dtype = [
draw(st.sampled_from(tuple(set(dtype).difference({"bfloat16", "float16"}))))
]
transpose_x = draw(st.booleans())
transpose_y = draw(st.booleans())
mat1_shape = (shared_size, dim_size1) if transpose_x else (dim_size1, shared_size)
mat2_shape = (dim_size2, shared_size) if transpose_y else (shared_size, dim_size2)
mat1 = draw(
helpers.array_values(dtype=dtype[0], shape=mat1_shape, min_value=2, max_value=5)
)
mat2 = draw(
helpers.array_values(dtype=dtype[0], shape=mat2_shape, min_value=2, max_value=5)
)
return dtype, mat1, mat2, transpose_x, transpose_y
@st.composite
def _get_dtype_value1_value2_cov(
draw,
available_dtypes,
min_num_dims,
max_num_dims,
min_dim_size,
max_dim_size,
abs_smallest_val=None,
min_value=None,
max_value=None,
allow_inf=False,
exclude_min=False,
exclude_max=False,
large_abs_safety_factor=4,
small_abs_safety_factor=4,
safety_factor_scale="log",
):
shape = draw(
helpers.get_shape(
allow_none=False,
min_num_dims=min_num_dims,
max_num_dims=max_num_dims,
min_dim_size=min_dim_size,
max_dim_size=max_dim_size,
)
)
dtype = draw(st.sampled_from(draw(available_dtypes)))
values = []
for i in range(1):
values.append(
draw(
helpers.array_values(
dtype=dtype,
shape=shape,
abs_smallest_val=abs_smallest_val,
min_value=min_value,
max_value=max_value,
allow_inf=allow_inf,
exclude_min=exclude_min,
exclude_max=exclude_max,
large_abs_safety_factor=large_abs_safety_factor,
small_abs_safety_factor=small_abs_safety_factor,
safety_factor_scale=safety_factor_scale,
)
)
)
value = values[0]
# modifiers: rowVar, bias, ddof
rowVar = draw(st.booleans())
ddof = draw(st.booleans())
numVals = None
if rowVar is False:
numVals = -1 if numVals == 0 else 0
else:
numVals = 0 if len(shape) == 1 else -1
fweights = draw(
helpers.array_values(
dtype="int64",
shape=shape[numVals],
abs_smallest_val=1,
min_value=1,
max_value=10,
allow_inf=False,
)
)
aweights = draw(
helpers.array_values(
dtype="float64",
shape=shape[numVals],
abs_smallest_val=1,
min_value=1,
max_value=10,
allow_inf=False,
small_abs_safety_factor=1,
)
)
return [dtype], value, rowVar, ddof, fweights, aweights
@st.composite
def _reshape_helper(draw):
# generate a shape s.t len(shape) > 0
shape = draw(
helpers.get_shape(
allow_none=False,
min_num_dims=1,
max_num_dims=3,
min_dim_size=1,
max_dim_size=3,
)
)
reshape_shape = draw(helpers.reshape_shapes(shape=shape))
dtypes, x = draw(
helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid"),
shape=shape,
)
)
return dtypes, x, reshape_shape
# expand helper function
@st.composite
def dtypes_x_shape(draw):
dtypes, x = draw(
helpers.dtype_and_values(
min_dim_size=1,
min_num_dims=1,
available_dtypes=["float32"],
shape=st.shared(
helpers.get_shape(
min_num_dims=1,
max_num_dims=6,
),
key="shape",
),
)
)
shape = draw(
st.shared(
helpers.get_shape(
min_num_dims=1,
max_num_dims=6,
),
key="shape",
)
)
return dtypes, x, shape
# --- Main --- #
# ------------ #
# __add__
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="__add__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid"), num_arrays=2, shared_dtype=True
),
)
def test_paddle___add__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"data": x[0],
},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={
"y": x[1],
},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="__float__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
max_num_dims=0,
),
)
def test_paddle___float__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
# Numpy doesn't support complex to float conversion
assume(not np.issubdtype(input_dtypes[0], np.complexfloating))
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
method_input_dtypes=input_dtypes,
init_all_as_kwargs_np={
"object": xs[0],
},
method_all_as_kwargs_np={},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="__floordiv__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("float"),
num_arrays=2,
large_abs_safety_factor=2.5,
small_abs_safety_factor=2.5,
safety_factor_scale="log",
),
)
def test_paddle___floordiv__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtype, x = dtype_and_x
assume(not np.any(np.isclose(x[1], 0)))
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"data": x[0],
},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={
"other": x[1],
},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
atol_=1,
)
# __ge__
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="__ge__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"), num_arrays=2, shared_dtype=True
),
)
def test_paddle___ge__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"data": x[0],
},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={
"y": x[1],
},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
# __getitem__
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="__getitem__",
dtype_x_index=helpers.dtype_array_query(
available_dtypes=helpers.get_dtypes("valid"),
allow_neg_step=False,
).filter(lambda x: x[0][0] == x[0][-1] and _filter_query(x[-2])),
)
def test_paddle___getitem__(
dtype_x_index,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtype, x, index = dtype_x_index
helpers.test_frontend_method(
init_input_dtypes=[input_dtype[0]],
backend_to_test=backend_fw,
init_all_as_kwargs_np={"data": x},
method_input_dtypes=[*input_dtype[1:]],
method_all_as_kwargs_np={"item": index},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
# __gt__
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="__gt__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"), num_arrays=2, shared_dtype=True
),
)
def test_paddle___gt__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"data": x[0],
},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={
"y": x[1],
},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="__int__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("integer"),
max_num_dims=0,
min_value=-1e15,
max_value=1e15,
),
)
def test_paddle___int__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
# Numpy doesn't support complex to int conversion
assume(not np.issubdtype(input_dtypes[0], np.complexfloating))
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
method_input_dtypes=input_dtypes,
init_all_as_kwargs_np={
"object": xs[0],
},
method_all_as_kwargs_np={},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
# invert
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="__invert__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
max_num_dims=0,
),
)
def test_paddle___invert__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
method_input_dtypes=input_dtypes,
init_all_as_kwargs_np={
"object": xs[0],
},
method_all_as_kwargs_np={},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
# __le__
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="__le__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid"), num_arrays=2, shared_dtype=True
),
)
def test_paddle___le__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"data": x[0],
},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={
"y": x[1],
},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
# __len__
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="__len__",
dtype_and_x=_array_and_shape(
min_num_dims=1,
max_num_dims=5,
),
)
def test_paddle___len__(
dtype_and_x,
frontend,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
on_device,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"value": x[0],
},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
# long
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="__long__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("integer"),
max_num_dims=0,
min_value=-1e15,
max_value=1e15,
),
)
def test_paddle___long__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
frontend,
on_device,
):
input_dtypes, xs = dtype_and_x
# Numpy doesn't support complex to int conversion
assume(not np.issubdtype(input_dtypes[0], np.complexfloating))
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
method_input_dtypes=input_dtypes,
init_all_as_kwargs_np={
"object": xs[0],
},
method_all_as_kwargs_np={},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
# __lt__
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="__lt__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"), num_arrays=2, shared_dtype=True
),
)
def test_paddle___lt__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"data": x[0],
},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={
"y": x[1],
},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
# __mul__
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="__mul__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"), num_arrays=2, shared_dtype=True
),
)
def test_paddle___mul__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"data": x[0],
},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={
"y": x[1],
},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
# __ne__
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="__ne__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("float"),
num_arrays=2,
min_value=-1e04,
max_value=1e04,
allow_inf=False,
),
)
def test_paddle___ne__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"data": x[0],
},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={
"other": x[1],
},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
# __neg__
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="__neg__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("float"),
min_value=-1e04,
max_value=1e04,
allow_inf=False,
),
)
def test_paddle___neg__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"data": x[0],
},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
# __or__
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="__or__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("integer"), num_arrays=2, shared_dtype=True
),
)
def test_paddle___or__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"data": x[0],
},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={
"y": x[1],
},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
# __radd__
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="__radd__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid"), num_arrays=2, shared_dtype=True
),
)
def test_paddle___radd__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"data": x[0],
},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={
"x": x[1],
},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="__rdiv__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
num_arrays=2,
shared_dtype=True,
large_abs_safety_factor=10,
small_abs_safety_factor=10,
safety_factor_scale="log",
),
)
def test_paddle___rdiv__(
dtype_and_x,
frontend,
frontend_method_data,
init_flags,
method_flags,
on_device,
backend_fw,
):
input_dtype, x = dtype_and_x
assume(not np.any(np.isclose(x[0], 0)))
assume(not np.any(np.isclose(x[1], 0)))
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"value": x[0],
},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={
"y": x[1],
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
# __rmul__
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="__rmul__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("float"),
num_arrays=2,
min_value=-1e04,
max_value=1e04,
allow_inf=False,
),
)
def test_paddle___rmul__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"data": x[0],
},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={
"other": x[1],
},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
# __rsub__
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="__rsub__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
num_arrays=2,
shared_dtype=True,
),
)
def test_paddle___rsub__(
dtype_and_x,
frontend,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
on_device,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"value": x[0],
},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={
"x": x[1],
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="__rtruediv__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("numeric"),
num_arrays=2,
shared_dtype=True,
large_abs_safety_factor=10,
small_abs_safety_factor=10,
safety_factor_scale="log",
),
)
def test_paddle___rtruediv__(
dtype_and_x,
frontend,
frontend_method_data,
init_flags,
method_flags,
on_device,
backend_fw,
):
input_dtype, x = dtype_and_x
assume(not np.any(np.isclose(x[0], 0)))
assume(not np.any(np.isclose(x[1], 0)))
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"value": x[0],
},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={
"y": x[1],
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
# __setitem__
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="__setitem__",
dtypes_x_index_val=helpers.dtype_array_query_val(
available_dtypes=helpers.get_dtypes("valid"),
).filter(lambda x: x[0][0] == x[0][-1] and _filter_query(x[-2])),
)
def test_paddle___setitem__(
dtypes_x_index_val,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtype, x, index, val = dtypes_x_index_val
helpers.test_frontend_method(
init_input_dtypes=[input_dtype[0]],
backend_to_test=backend_fw,
init_all_as_kwargs_np={"data": x},
method_input_dtypes=[*input_dtype[1:]],
method_all_as_kwargs_np={"item": index, "value": val},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
# __sub__
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="__sub__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid"), num_arrays=2, shared_dtype=True
),
)
def test_paddle___sub__(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"data": x[0],
},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={
"y": x[1],
},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
# __xor__
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="__xor__",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("integer"),
num_arrays=2,
shared_dtype=True,
),
)
def test_paddle___xor__(
dtype_and_x,
frontend,
frontend_method_data,
init_flags,
method_flags,
backend_fw,
on_device,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"value": x[0],
},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={
"y": x[1],
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
# abs
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="abs",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("float"),
),
)
def test_paddle_abs(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"data": x[0],
},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
# acosh
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="acosh",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("float"),
),
)
def test_paddle_acosh(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"data": x[0],
},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
# add_
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="add_",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid"), num_arrays=2, shared_dtype=True
),
test_inplace=st.just(True),
)
def test_paddle_add_(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"data": x[0],
},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={"y": x[1]},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="add_n",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("float"),
num_arrays=helpers.ints(min_value=1, max_value=5),
shared_dtype=True,
),
)
def test_paddle_add_n(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={"inputs": x},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={"inputs": x},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
# addmm
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="addmm",
dtype_input_xy=_get_dtype_and_3dbatch_matrices(with_input=True, input_3d=True),
beta=st.floats(
min_value=-5,
max_value=5,
allow_nan=False,
allow_subnormal=False,
allow_infinity=False,
),
alpha=st.floats(
min_value=-5,
max_value=5,
allow_nan=False,
allow_subnormal=False,
allow_infinity=False,
),
)
def test_paddle_addmm(
*,
dtype_input_xy,
beta,
alpha,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtype, input, x, y = dtype_input_xy
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"data": input[0],
},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={"x": x[0], "y": y[0], "beta": beta, "alpha": alpha},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
# all
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="all",
dtype_x_axis=helpers.dtype_values_axis(
available_dtypes=helpers.get_dtypes("bool"),
min_axis=-1,
max_axis=0,
min_num_dims=1,
force_int_axis=True,
),
keep_dims=st.booleans(),
)
def test_paddle_all(
dtype_x_axis,
keep_dims,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtypes, x, axis = dtype_x_axis
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"axis": axis,
"keepdim": keep_dims,
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
# allclose
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="allclose",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("float"),
num_arrays=2,
shared_dtype=True,
),
# rtol=1e-05,
# atol=1e-08,
# equal_nan=st.booleans(),
)
def test_paddle_allclose(
dtype_and_x,
# rtol,
# atol,
# equal_nan,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"data": x[0],
},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={
"other": x[1],
# "rtol": rtol,
# "atol": atol,
# "equal_nan": equal_nan,
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="angle",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=["float64", "complex64", "complex128"],
),
)
def test_paddle_angle(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"data": x[0],
},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
# any
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="any",
dtype_x_axis=helpers.dtype_values_axis(
available_dtypes=st.one_of(helpers.get_dtypes("float")),
min_axis=-1,
max_axis=0,
min_num_dims=1,
force_int_axis=True,
),
keep_dims=st.booleans(),
)
def test_paddle_any(
dtype_x_axis,
keep_dims,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtypes, x, axis = dtype_x_axis
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"data": x[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"axis": axis,
"keepdim": keep_dims,
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
# argmax
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="argmax",
dtype_x_axis=helpers.dtype_values_axis(
available_dtypes=st.one_of(helpers.get_dtypes("float")),
min_axis=-1,
max_axis=0,
min_num_dims=1,
force_int_axis=True,
),
keep_dims=st.booleans(),
)
def test_paddle_argmax(
dtype_x_axis,
keep_dims,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtypes, x, axis = dtype_x_axis
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"axis": axis,
"keepdim": keep_dims,
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
# argmin
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="argmin",
dtype_x_axis=helpers.dtype_values_axis(
available_dtypes=st.one_of(helpers.get_dtypes("valid")),
min_axis=-1,
max_axis=0,
min_num_dims=1,
force_int_axis=True,
),
keep_dims=st.booleans(),
)
def test_paddle_argmin(
dtype_x_axis,
keep_dims,
on_device,
backend_fw,
frontend_method_data,
init_flags,
method_flags,
frontend,
):
input_dtypes, x, axis = dtype_x_axis
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"axis": axis,
"keepdim": keep_dims,
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
# argsort
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="argsort",
dtype_x_axis=helpers.dtype_values_axis(
available_dtypes=st.one_of(helpers.get_dtypes("float")),
min_axis=-1,
max_axis=0,
min_num_dims=1,
force_int_axis=True,
),
descending=st.booleans(),
)
def test_paddle_argsort(
dtype_x_axis,
descending,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtypes, x, axis = dtype_x_axis
helpers.test_frontend_method(
init_input_dtypes=input_dtypes,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"object": x[0],
},
method_input_dtypes=input_dtypes,
method_all_as_kwargs_np={
"axis": axis,
"descending": descending,
},
frontend=frontend,
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
on_device=on_device,
)
# as_complex
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="as_complex",
dtypes_and_x=_get_as_complex_inputs_(),
)
def test_paddle_as_complex(
dtypes_and_x,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtype, x = dtypes_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={"data": x[0]},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
# as_real
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="as_real",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid"),
num_arrays=1,
),
)
def test_paddle_as_real(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
frontend,
backend_fw,
on_device,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
init_all_as_kwargs_np={
"data": x[0],
},
method_input_dtypes=input_dtype,
backend_to_test=backend_fw,
method_all_as_kwargs_np={},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
# asin
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="asin",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("float"),
),
)
def test_paddle_asin(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"data": x[0],
},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
# asinh
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="asinh",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("float"),
),
)
def test_paddle_asinh(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"data": x[0],
},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
# astype
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="astype",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("float"),
),
dtype=st.one_of(helpers.get_dtypes("valid")),
)
def test_paddle_astype(
dtype_and_x,
dtype,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtype, x = dtype_and_x
if dtype is None:
dtype = input_dtype
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"data": x[0],
},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={
"dtype": dtype,
},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
# atan
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="atan",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("float"),
),
)
def test_paddle_atan(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
init_all_as_kwargs_np={
"data": x[0],
},
backend_to_test=backend_fw,
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
# bitwise_and
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="bitwise_and",
dtypes_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid"), num_arrays=2, shared_dtype=True
),
)
def test_paddle_bitwise_and(
dtypes_and_x,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtype, x = dtypes_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={"data": x[0]},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={"y": x[1]},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
# bitwise_not
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="bitwise_not",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid"),
),
)
def test_paddle_bitwise_not(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtype, x = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={
"data": x[0],
},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="bitwise_or",
dtypes_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid"), num_arrays=2, shared_dtype=True
),
)
def test_paddle_bitwise_or(
dtypes_and_x,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtype, x = dtypes_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={"data": x[0]},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={"y": x[1]},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
# bitwise_xor
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="bitwise_xor",
dtypes_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid"), num_arrays=2, shared_dtype=True
),
)
def test_paddle_bitwise_xor(
dtypes_and_x,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtype, x = dtypes_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={"data": x[0]},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={"y": x[1]},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
# bmm
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="bmm",
dtype_and_x=_get_dtype_and_values_bmm(),
)
def test_paddle_bmm(
dtype_and_x,
frontend_method_data,
init_flags,
method_flags,
frontend,
on_device,
backend_fw,
):
input_dtype, x, y = dtype_and_x
helpers.test_frontend_method(
init_input_dtypes=input_dtype,
backend_to_test=backend_fw,
init_all_as_kwargs_np={"data": x},
method_input_dtypes=input_dtype,
method_all_as_kwargs_np={"y": y},
frontend_method_data=frontend_method_data,
init_flags=init_flags,
method_flags=method_flags,
frontend=frontend,
on_device=on_device,
)
# cast
@handle_frontend_method(
class_tree=CLASS_TREE,
init_tree="paddle.to_tensor",
method_name="cast",
dtype_and_x=helpers.dtype_and_values(
available_dtypes=helpers.get_dtypes("valid"),
),
dtype=h |