test_numpy_interoperability.py

# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

# pylint: skip-file
from __future__ import absolute_import
from __future__ import division
from distutils.version import StrictVersion
import sys
import platform
import itertools
import numpy as _np
import unittest
import pytest
from mxnet import np, util
from mxnet.test_utils import assert_almost_equal
from mxnet.test_utils import use_np
from mxnet.test_utils import is_op_runnable
from common import assertRaises, random_seed
from mxnet.numpy_dispatch_protocol import with_array_function_protocol, with_array_ufunc_protocol
from mxnet.numpy_dispatch_protocol import _NUMPY_ARRAY_FUNCTION_LIST, _NUMPY_ARRAY_UFUNC_LIST


_INT_DTYPES = [np.int8, np.int32, np.int64, np.uint8]
_FLOAT_DTYPES = [np.float16, np.float32, np.float64]
_DTYPES = _INT_DTYPES + _FLOAT_DTYPES
_TVM_OPS = [
    'equal',
    'not_equal',
    'less',
    'less_equal',
    'greater',
    'greater_equal',
    'logical_and',
    'logical_or',
    'logical_xor',
]


class OpArgMngr(object):
    """Operator argument manager for storing operator workloads."""
    _args = {}

    @staticmethod
    def add_workload(name, *args, **kwargs):
        if name not in OpArgMngr._args:
            OpArgMngr._args[name] = []
        OpArgMngr._args[name].append({'args': args, 'kwargs': kwargs})

    @staticmethod
    def get_workloads(name):
        if OpArgMngr._args == {}:
            _prepare_workloads()
        return OpArgMngr._args.get(name, None)

    @staticmethod
    def randomize_workloads():
        # Force a new _prepare_workloads(), which will be based on new random numbers
        OpArgMngr._args = {}


def _add_workload_all():
    # check bad element in all positions
    for i in range(256-7):
        e = np.array([True] * 256, dtype=bool)[7::]
        e[i] = False
        OpArgMngr.add_workload('all', e)
    # big array test for blocked libc loops
    for i in list(range(9, 6000, 507)) + [7764, 90021, -10]:
        e = np.array([True] * 100043, dtype=bool)
        e[i] = False
        OpArgMngr.add_workload('all', e)


def _add_workload_any():
    # check bad element in all positions
    for i in range(256-7):
        d = np.array([False] * 256, dtype=bool)[7::]
        d[i] = True
        OpArgMngr.add_workload('any', d)
    # big array test for blocked libc loops
    for i in list(range(9, 6000, 507)) + [7764, 90021, -10]:
        d = np.array([False] * 100043, dtype=bool)
        d[i] = True
        OpArgMngr.add_workload('any', d)


def _add_workload_sometrue():
    # check bad element in all positions
    for i in range(256-7):
        d = np.array([False] * 256, dtype=bool)[7::]
        d[i] = True
        OpArgMngr.add_workload('sometrue', d)
    # big array test for blocked libc loops
    for i in list(range(9, 6000, 507)) + [7764, 90021, -10]:
        d = np.array([False] * 100043, dtype=bool)
        d[i] = True
        OpArgMngr.add_workload('sometrue', d)


def _add_workload_unravel_index():
    OpArgMngr.add_workload('unravel_index', indices=np.array([2],dtype=_np.int64), shape=(2, 2))
    OpArgMngr.add_workload('unravel_index', np.array([(2*3 + 1)*6 + 4], dtype=_np.int64), (4, 3, 6))
    OpArgMngr.add_workload('unravel_index', np.array([22, 41, 37], dtype=_np.int32), (7, 6))
    OpArgMngr.add_workload('unravel_index', np.array([1621],dtype=_np.uint8), (6, 7, 8, 9))
    OpArgMngr.add_workload('unravel_index', np.array([],dtype=_np.int64), (10, 3, 5))
    OpArgMngr.add_workload('unravel_index', np.array([3], dtype=_np.int32), (2,2))


def _add_workload_diag_indices_from():
    a = np.random.uniform(-4, 4, size=(4,4))
    OpArgMngr.add_workload('diag_indices_from', a)


def _add_workload_bincount():
    y = np.arange(4).astype(int)
    y1 = np.array([1, 5, 2, 4, 1], dtype=_np.int64)
    y2 = np.array((), dtype=_np.int8)
    w = np.array([0.2, 0.3, 0.5, 0.1])
    w1 = np.array([0.2, 0.3, 0.5, 0.1, 0.2])

    OpArgMngr.add_workload('bincount', y)
    OpArgMngr.add_workload('bincount', y1)
    OpArgMngr.add_workload('bincount', y, w)
    OpArgMngr.add_workload('bincount', y1, w1)
    OpArgMngr.add_workload('bincount', y1, w1, 8)
    OpArgMngr.add_workload('bincount', y, minlength=3)
    OpArgMngr.add_workload('bincount', y, minlength=8)
    OpArgMngr.add_workload('bincount', y2, minlength=0)
    OpArgMngr.add_workload('bincount', y2, minlength=5)


def _add_workload_cross():
    shapes = [
        # (a_shape, b_shape, (a_axis, b_axis, c_axis))
        ((2,), (2,), (-1, -1, -1)),
        ((1, 2), (1, 2), (-1, -1, -1)),
        ((2, 5, 4, 3), (5, 2, 4, 3), (0, 1, 2)),
        ((2, 5, 1, 3), (1, 2, 4, 3), (0, 1, 2)),

        ((2,), (3,), (-1, -1, -1)),
        ((1, 2,), (1, 3,), (-1, -1, -1)),
        ((6, 2, 5, 4), (6, 5, 3, 4), (1, 2, 0)),
        ((6, 2, 1, 4), (1, 5, 3, 4), (1, 2, 0)),

        ((3,), (2,), (-1, -1, -1)),
        ((1, 3,), (1, 2,), (-1, -1, -1)),
        ((6, 3, 5, 4), (6, 5, 2, 4), (1, 2, 0)),
        ((6, 3, 1, 4), (1, 5, 2, 4), (1, 2, 0)),

        ((3,), (3,), (-1, -1, -1)),
        ((1, 3,), (1, 3,), (-1, -1, -1)),
        ((6, 3, 5, 4), (6, 5, 3, 4), (1, 2, 0)),
        ((6, 3, 1, 4), (1, 5, 3, 4), (1, 2, 0)),
    ]
    dtypes = [np.float32, np.float64]
    for shape, dtype in itertools.product(shapes, dtypes):
        a_shape, b_shape, (a_axis, b_axis, c_axis) = shape
        a_np = _np.random.uniform(-10., 10., size=a_shape)
        b_np = _np.random.uniform(-10., 10., size=b_shape)
        a = np.array(a_np, dtype=dtype)
        b = np.array(b_np, dtype=dtype)
        OpArgMngr.add_workload('cross', a, b, axisa=a_axis, axisb=b_axis, axisc=c_axis)


def _add_workload_diag():
    def get_mat(n):
        data = _np.arange(n)
        data = _np.add.outer(data, data)
        return data

    A = np.array([[1, 2], [3, 4], [5, 6]])
    vals = (100 * np.arange(5)).astype('l')
    vals_c = (100 * np.array(get_mat(5)) + 1).astype('l')
    vals_f = _np.array((100 * get_mat(5) + 1), order='F', dtype='l')
    vals_f = np.array(vals_f)

    OpArgMngr.add_workload('diag', A, k=2)
    OpArgMngr.add_workload('diag', A, k=1)
    OpArgMngr.add_workload('diag', A, k=0)
    OpArgMngr.add_workload('diag', A, k=-1)
    OpArgMngr.add_workload('diag', A, k=-2)
    OpArgMngr.add_workload('diag', A, k=-3)
    OpArgMngr.add_workload('diag', vals, k=0)
    OpArgMngr.add_workload('diag', vals, k=2)
    OpArgMngr.add_workload('diag', vals, k=-2)
    OpArgMngr.add_workload('diag', vals_c, k=0)
    OpArgMngr.add_workload('diag', vals_c, k=2)
    OpArgMngr.add_workload('diag', vals_c, k=-2)
    OpArgMngr.add_workload('diag', vals_f, k=0)
    OpArgMngr.add_workload('diag', vals_f, k=2)
    OpArgMngr.add_workload('diag', vals_f, k=-2)


def _add_workload_diagonal():
    A = np.arange(12).reshape((3, 4))
    B = np.arange(8).reshape((2,2,2))

    OpArgMngr.add_workload('diagonal', A)
    OpArgMngr.add_workload('diagonal', A, offset=0)
    OpArgMngr.add_workload('diagonal', A, offset=-1)
    OpArgMngr.add_workload('diagonal', A, offset=1)
    OpArgMngr.add_workload('diagonal', B, offset=0)
    OpArgMngr.add_workload('diagonal', B, offset=1)
    OpArgMngr.add_workload('diagonal', B, offset=-1)
    OpArgMngr.add_workload('diagonal', B, 0, 1, 2)
    OpArgMngr.add_workload('diagonal', B, 0, 0, 1)
    OpArgMngr.add_workload('diagonal', B, offset=1, axis1=0, axis2=2)
    OpArgMngr.add_workload('diagonal', B, 0, 2, 1)


def _add_workload_median(array_pool):
    OpArgMngr.add_workload('median', array_pool['4x1'])
    OpArgMngr.add_workload('median', array_pool['4x1'], axis=0, keepdims=True)
    OpArgMngr.add_workload('median', np.array([[1, 2, 3], [4, 5, 6]]))
    OpArgMngr.add_workload('median', np.array([[1, 2, 3], [4, 5, 6]]), axis=0)
    OpArgMngr.add_workload('median', np.array([[1, 2, 3], [4, 5, 6]]), axis=1)


def _add_workload_quantile():
    x1 = np.arange(8) * 0.5
    x2 = np.arange(100.)
    q1 = np.array(0)
    q2 = np.array(1)
    q3 = np.array(0.5)
    q4 = np.array([0, 0.75, 0.25, 0.5, 1.0])
    q5 = 0.4

    OpArgMngr.add_workload('quantile', x1, q1)
    OpArgMngr.add_workload('quantile', x1, q2)
    OpArgMngr.add_workload('quantile', x1, q3)
    OpArgMngr.add_workload('quantile', x2, q4, interpolation="midpoint")
    OpArgMngr.add_workload('quantile', x2, q4, interpolation="nearest")
    OpArgMngr.add_workload('quantile', x2, q4, interpolation="lower")
    OpArgMngr.add_workload('quantile', x2, q5, interpolation="midpoint")
    OpArgMngr.add_workload('quantile', x2, q5, interpolation="nearest")
    OpArgMngr.add_workload('quantile', x2, q5, interpolation="lower")


def _add_workload_percentile():
    x1 = np.ones(5)
    q1 = np.array(5)
    x2 = np.array([[1, 1, 1],
                   [1, 1, 1],
                   [4, 4, 3],
                   [1, 1, 1],
                   [1, 1, 1]])
    q2 = np.array(60)
    x3 = np.arange(10)
    q3 = np.array([25, 50, 100])
    q4 = 65
    x4 = np.arange(11 * 2).reshape(11, 1, 2, 1)
    x5 = np.array([0, _np.nan])

    OpArgMngr.add_workload('percentile', x1, q1, None, None, None)
    OpArgMngr.add_workload('percentile', x1, q1, None, None, None, 'linear')
    OpArgMngr.add_workload('percentile', x2, q2, axis=0)
    OpArgMngr.add_workload('percentile', x3, q2, interpolation='linear')
    OpArgMngr.add_workload('percentile', x3, q2, interpolation='lower')
    OpArgMngr.add_workload('percentile', x3, q2, interpolation='higher')
    OpArgMngr.add_workload('percentile', x3, q2, interpolation='midpoint')
    OpArgMngr.add_workload('percentile', x3, q2, interpolation='nearest')
    OpArgMngr.add_workload('percentile', x3, q3)
    OpArgMngr.add_workload('percentile', x4, q2, axis=0)
    OpArgMngr.add_workload('percentile', x4, q2, axis=1)
    OpArgMngr.add_workload('percentile', x4, q4, axis=2)
    OpArgMngr.add_workload('percentile', x4, q4, axis=3)
    OpArgMngr.add_workload('percentile', x4, q2, axis=-1)
    OpArgMngr.add_workload('percentile', x4, q2, axis=-2)
    OpArgMngr.add_workload('percentile', x4, q4, axis=-3)
    OpArgMngr.add_workload('percentile', x4, q4, axis=-4)
    OpArgMngr.add_workload('percentile', x4, q2, axis=(1,2))
    OpArgMngr.add_workload('percentile', x4, q3, axis=(-2,-1))
    OpArgMngr.add_workload('percentile', x4, q2, axis=(1,2), keepdims=True)
    OpArgMngr.add_workload('percentile', x5, q2)
    OpArgMngr.add_workload('percentile', x5, q3)


def _add_workload_concatenate(array_pool):
    OpArgMngr.add_workload('concatenate', [array_pool['4x1'], array_pool['4x1']])
    OpArgMngr.add_workload('concatenate', [array_pool['4x1'], array_pool['4x1']], axis=1)
    OpArgMngr.add_workload('concatenate', [np.random.uniform(size=(3, 3))])
    OpArgMngr.add_workload('concatenate', (np.arange(4).reshape((2, 2)), np.arange(4).reshape((2, 2))))
    OpArgMngr.add_workload('concatenate', (np.arange(4),))
    OpArgMngr.add_workload('concatenate', (np.array(np.arange(4)),))
    OpArgMngr.add_workload('concatenate', (np.arange(4), np.arange(3)))
    OpArgMngr.add_workload('concatenate', (np.array(np.arange(4)), np.arange(3)))
    OpArgMngr.add_workload('concatenate', (np.arange(4), np.arange(3)), axis=0)
    OpArgMngr.add_workload('concatenate', (np.arange(4), np.arange(3)), axis=-1)
    a23 = np.random.uniform(size=(2, 3))
    a13 = np.random.uniform(size=(1, 3))
    OpArgMngr.add_workload('concatenate', (a23, a13))
    OpArgMngr.add_workload('concatenate', (a23, a13), axis=0)
    OpArgMngr.add_workload('concatenate', (a23.T, a13.T), axis=1)
    OpArgMngr.add_workload('concatenate', (a23.T, a13.T), axis=-1)
    res = np.arange(2*3*7).reshape((2, 3, 7))
    a0 = res[..., :4]
    a1 = res[..., 4:6]
    a2 = res[..., 6:]
    OpArgMngr.add_workload('concatenate', (a0, a1, a2), axis=2)
    OpArgMngr.add_workload('concatenate', (a0, a1, a2), axis=-1)
    OpArgMngr.add_workload('concatenate', (a0.T, a1.T, a2.T), axis=0)
    out = np.empty(4, dtype=np.float32)
    OpArgMngr.add_workload('concatenate', (np.array([1, 2]), np.array([3, 4])), out=out)
    OpArgMngr.add_workload('concatenate', [array_pool['4x1'], array_pool['4x1']], axis=None)
    OpArgMngr.add_workload('concatenate', (np.arange(4).reshape((2, 2)), np.arange(4).reshape((2, 2))), axis=None)
    OpArgMngr.add_workload('concatenate', (a23, a13), axis=None)


def _add_workload_append():

    def get_new_shape(shape, axis):
        shape_lst = list(shape)
        if axis is not None:
            shape_lst[axis] = _np.random.randint(0, 3)
        return tuple(shape_lst)

    for shape in [(0, 0), (2, 3), (2, 1, 3)]:
        for axis in [0, 1, None]:
            a = np.random.uniform(-1.0, 1.0, size=get_new_shape(shape, axis))
            b = np.random.uniform(-1.0, 1.0, size=get_new_shape(shape, axis))
            OpArgMngr.add_workload('append', a, b, axis=axis)

    OpArgMngr.add_workload('append', np.array([]), np.array([]))


def _add_workload_copy():
    OpArgMngr.add_workload('copy', np.random.uniform(size=(4, 1)))
    OpArgMngr.add_workload('copy', np.random.uniform(size=(2, 2)))
    OpArgMngr.add_workload('copy', np.random.uniform(size=(2,2)))


def _add_workload_expand_dims():
    OpArgMngr.add_workload('expand_dims', np.random.uniform(size=(4, 1)), -1)
    OpArgMngr.add_workload('expand_dims', np.random.uniform(size=(4, 1)) > 0.5, -1)
    for axis in range(-5, 4):
        OpArgMngr.add_workload('expand_dims', np.empty((2, 3, 4, 5)), axis)


def _add_workload_split():
    OpArgMngr.add_workload('split', np.random.uniform(size=(4, 1)), 2)
    OpArgMngr.add_workload('split', np.arange(10), 2)
    OpArgMngr.add_workload('split', np.random.uniform(size=(10, 10, 3)), 3, -1)
    assertRaises(ValueError, np.split, np.arange(10), 3)


def _add_workload_array_split():
    a = np.arange(10)
    b = np.array([np.arange(10), np.arange(10)])

    for i in range(1, 12):
        OpArgMngr.add_workload('array_split', a, i)
    OpArgMngr.add_workload('array_split', b, 3, axis=0)
    OpArgMngr.add_workload('array_split', b, [0, 1, 2], axis=0)
    OpArgMngr.add_workload('array_split', b, 3, axis=-1)
    OpArgMngr.add_workload('array_split', b, 3)


def _add_workload_hsplit():
    a = np.array([1, 2, 3, 4])
    OpArgMngr.add_workload('hsplit', a, 2)
    b = np.array([[1, 2, 3, 4], [1, 2, 3, 4]])
    OpArgMngr.add_workload('hsplit', b, 2)


def _add_workload_vsplit():
    assertRaises(ValueError, np.vsplit, np.array([1, 2, 3, 4]), 2)
    a = np.array([[1, 2, 3, 4], [1, 2, 3, 4]])
    OpArgMngr.add_workload('vsplit', a, 2)
    assertRaises(ValueError, np.vsplit, np.array(1), 2)


def _add_workload_dsplit():
    a = np.array([[[1, 2, 3, 4], [1, 2, 3, 4]],
                  [[1, 2, 3, 4], [1, 2, 3, 4]]])
    OpArgMngr.add_workload('dsplit', a, 2)
    assertRaises(ValueError, np.dsplit, np.array(1), 2)
    assertRaises(ValueError, np.dsplit, np.array([1, 2, 3, 4]), 2)
    assertRaises(ValueError, np.dsplit, np.array([[1, 2, 3, 4], [1, 2, 3, 4]]), 2)


def _add_workload_squeeze():
    OpArgMngr.add_workload('squeeze', np.random.uniform(size=(4, 1)))
    OpArgMngr.add_workload('squeeze', np.random.uniform(size=(20, 10, 10, 1, 1)))
    OpArgMngr.add_workload('squeeze', np.random.uniform(size=(20, 1, 10, 1, 20)))
    OpArgMngr.add_workload('squeeze', np.random.uniform(size=(1, 1, 20, 10)))
    OpArgMngr.add_workload('squeeze', np.array([[[1.5]]]))


def _add_workload_std():
    OpArgMngr.add_workload('std', np.random.uniform(size=(4, 1)))
    A = np.array([[1, 2, 3], [4, 5, 6]])
    OpArgMngr.add_workload('std', A)
    OpArgMngr.add_workload('std', A, 0)
    OpArgMngr.add_workload('std', A, 1)
    OpArgMngr.add_workload('std', np.array([1, -1, 1, -1]))
    OpArgMngr.add_workload('std', np.array([1, -1, 1, -1]), ddof=1)
    OpArgMngr.add_workload('std', np.array([1, -1, 1, -1]), ddof=2)
    OpArgMngr.add_workload('std', np.arange(10), out=np.array(0.))


def _add_workload_swapaxes():
    OpArgMngr.add_workload('swapaxes', np.random.uniform(size=(4, 1)), 0, 1)
    OpArgMngr.add_workload('swapaxes', np.array([[[0, 1], [2, 3]], [[4, 5], [6, 7]]]), 0, 2)
    a = np.arange(1*2*3*4).reshape(1, 2, 3, 4).copy()
    b = a.copy()
    # no AxisError defined in mxnet numpy
    # assertRaises(np.AxisError, np.swapaxes, -5, 0)
    for i in range(-4, 4):
        for j in range(-4, 4):
            for src in (a, b):
                OpArgMngr.add_workload('swapaxes', src, i, j)


def _add_workload_tensordot():
    OpArgMngr.add_workload('tensordot', np.random.uniform(size=(4, 1)), np.random.uniform(size=(4, 1)))
    OpArgMngr.add_workload('tensordot', np.random.uniform(size=(3, 0)), np.random.uniform(size=(0, 4)), (1, 0))
    OpArgMngr.add_workload('tensordot', np.array(1), np.array(1), ([], []))


def _add_workload_tile():
    OpArgMngr.add_workload('tile', np.random.uniform(size=(4, 1)), 2)
    a = np.array([0, 1, 2])
    b = np.array([[1, 2], [3, 4]])
    OpArgMngr.add_workload('tile', a, 2)
    OpArgMngr.add_workload('tile', a, (2, 2))
    OpArgMngr.add_workload('tile', a, (1, 2))
    OpArgMngr.add_workload('tile', b, 2)
    OpArgMngr.add_workload('tile', b, (2, 1))
    OpArgMngr.add_workload('tile', b, (2, 2))
    OpArgMngr.add_workload('tile', np.arange(5), 1)
    OpArgMngr.add_workload('tile', np.array([[], []]), 2)
    OpArgMngr.add_workload('tile', np.array([[[]]]), (3, 2, 5))
    reps = [(2,), (1, 2), (2, 1), (2, 2), (2, 3, 2), (3, 2)]
    shape = [(3,), (2, 3), (3, 4, 3), (3, 2, 3), (4, 3, 2, 4), (2, 2)]
    for s in shape:
        b = np.random.randint(0, 10, size=s)
        for _ in reps:
            # RuntimeError to be tracked
            # where s = (3, 4, 3), r = (2, 3, 2)
            # OpArgMngr.add_workload('tile', b, r)
            pass


def _add_workload_transpose():
    OpArgMngr.add_workload('transpose', np.random.uniform(size=(4, 1)))
    OpArgMngr.add_workload('transpose', np.array([[]]))
    OpArgMngr.add_workload('transpose', np.array([[1, 2]]))
    OpArgMngr.add_workload('transpose', np.array([[1, 2, 3], [4, 5, 6]]))
    OpArgMngr.add_workload('transpose', np.array([[1, 2], [3, 4], [5, 6]]), (1, 0))
    OpArgMngr.add_workload('transpose', np.array([[1, 2], [3, 4]]))


def _add_workload_linalg_norm():
    OpArgMngr.add_workload('linalg.norm', np.random.uniform(size=(4, 1)))
    for dt in ["float64", "float32"]:
        OpArgMngr.add_workload('linalg.norm', np.array([], dtype=dt))
        OpArgMngr.add_workload('linalg.norm', np.array([np.array([]), np.array([])], dtype=dt))
        for v in ([1, 2, 3, 4], [-1, -2, -3, -4], [-1, 2, -3, 4]):
            OpArgMngr.add_workload('linalg.norm', np.array(v, dtype=dt))
        A = np.array([[1, 2, 3], [4, 5, 6]], dtype=dt)
        [OpArgMngr.add_workload('linalg.norm', A[:, k]) for k in range(A.shape[1])]
        OpArgMngr.add_workload('linalg.norm', A, axis=0)
        [OpArgMngr.add_workload('linalg.norm', A[k, :]) for k in range(A.shape[0])]
        OpArgMngr.add_workload('linalg.norm', A, axis=1)
        B = np.arange(1, 25).reshape(2, 3, 4).astype(dt)
        for axis in itertools.combinations(range(-B.ndim, B.ndim), 2):
            row_axis, col_axis = axis
            if row_axis < 0:
                row_axis += B.ndim
            if col_axis < 0:
                col_axis += B.ndim
            if row_axis == col_axis:
                # improper assertion behavior
                # assertRaises(ValueError, np.linalg.norm, B, axis=axis)
                pass
            else:
                OpArgMngr.add_workload('linalg.norm', B, axis=axis)
                k_index = B.ndim - row_axis - col_axis
                for k in range(B.shape[k_index]):
                    if row_axis < col_axis:
                        OpArgMngr.add_workload('linalg.norm', np.take(B[:], np.array(k), axis=k_index))
                    else:
                        OpArgMngr.add_workload('linalg.norm', np.take(B[:], np.array(k), axis=k_index).T)
        A = np.arange(1, 25, dtype=dt).reshape(2, 3, 4)
        OpArgMngr.add_workload('linalg.norm', A, ord=None, axis=None)
        OpArgMngr.add_workload('linalg.norm', A, ord=None, axis=None, keepdims=True)
        for k in range(A.ndim):
            OpArgMngr.add_workload('linalg.norm', A, axis=k)
            OpArgMngr.add_workload('linalg.norm', A, axis=k, keepdims=True)
        for k in itertools.permutations(range(A.ndim), 2):
            OpArgMngr.add_workload('linalg.norm', A, axis=k)
            OpArgMngr.add_workload('linalg.norm', A, axis=k, keepdims=True)
        OpArgMngr.add_workload('linalg.norm', np.array([[]], dtype=dt))
        A = np.array([[1, 3], [5, 7]], dtype=dt)
        OpArgMngr.add_workload('linalg.norm', A, 2)
        OpArgMngr.add_workload('linalg.norm', A, -2)
        OpArgMngr.add_workload('linalg.norm', A, 'nuc')
        A = (1 / 10) * np.array([[1, 2, 3], [6, 0, 5], [3, 2, 1]], dtype=dt)
        OpArgMngr.add_workload('linalg.norm', A)
        OpArgMngr.add_workload('linalg.norm', A, 'fro')
        OpArgMngr.add_workload('linalg.norm', A, 1)
        OpArgMngr.add_workload('linalg.norm', A, -1)
    for dt in [np.float32, np.float64]:
        OpArgMngr.add_workload('linalg.norm', np.array([[1, 0, 1], [0, 1, 1]], dtype=dt))
        OpArgMngr.add_workload('linalg.norm', np.array([[1, 0, 1], [0, 1, 1]], dtype=dt), 'fro')


def _add_workload_linalg_cholesky():
    shapes = [(1, 1), (2, 2), (3, 3), (50, 50), (3, 10, 10)]
    dtypes = (np.float32, np.float64)

    with random_seed(1):
        for shape, dtype in itertools.product(shapes, dtypes):
            a = _np.random.randn(*shape)

        t = list(range(len(shape)))
        t[-2:] = -1, -2

        a = _np.matmul(a.transpose(t).conj(), a)

        OpArgMngr.add_workload('linalg.cholesky', np.array(a, dtype=dtype))

    # test_0_size
    for dtype in dtypes:
        a = np.zeros((0, 1, 1))
        OpArgMngr.add_workload('linalg.cholesky', np.array(a, dtype=dtype))
        a = np.zeros((1, 0, 0))
        OpArgMngr.add_workload('linalg.cholesky', np.array(a, dtype=dtype))


def _add_workload_linalg_qr():
    A = np.array([[0, 1], [1, 1], [1, 1], [2, 1]])
    OpArgMngr.add_workload('linalg.qr', A)
    # default mode in numpy is 'reduced'
    OpArgMngr.add_workload('linalg.qr', A, mode='reduced')


def _add_workload_linalg_inv():
    OpArgMngr.add_workload('linalg.inv', np.array(_np.ones((0, 0)), dtype=np.float32))
    OpArgMngr.add_workload('linalg.inv', np.array(_np.ones((0, 1, 1)), dtype=np.float64))


def _add_workload_linalg_solve():
    shapes = [(0,0), (1,1), (5,5), (6,6), (3,5,5), (3,0,0), (2,5,5), (0,5,5), (2,3,4,4)]
    nrhs = (0, 1, 2, 3)
    dtypes = (np.float32, np.float64)
    for dtype, shape in itertools.product(dtypes, shapes):
        a = _np.random.rand(*shape)
        shape_b = list(shape)
        shape_b[-1] = 1
        x = _np.random.rand(*shape_b)
        b = _np.matmul(a, x)
        shape_b.pop()
        b = b.reshape(shape_b)
        OpArgMngr.add_workload('linalg.solve', np.array(a, dtype=dtype), np.array(b, dtype=dtype))
        for nrh in nrhs:
            shape_b = list(shape)
            shape_b[-1] = nrh
            x = _np.random.rand(*shape_b)
            b = _np.matmul(a, x)
            OpArgMngr.add_workload('linalg.solve', np.array(a, dtype=dtype), np.array(b, dtype=dtype))


def _add_workload_linalg_det():
    OpArgMngr.add_workload('linalg.det', np.array(_np.ones((2, 2)), dtype=np.float32))
    OpArgMngr.add_workload('linalg.det', np.array(_np.ones((0, 1, 1)), dtype=np.float64))


def _add_workload_linalg_tensorinv():
    shapes = [
        (1, 20, 4, 5),
        (2, 2, 10, 4, 5),
        (2, 12, 5, 3, 4, 5),
        (3, 2, 3, 4, 24)
    ]
    dtypes = (np.float32, np.float64)
    for dtype, shape in itertools.product(dtypes, shapes):
        ind = shape[0]
        prod_front = 1
        prod_back = 1
        for k in shape[1:ind + 1]:
            prod_front *= k
        for k in shape[1 + ind:]:
            prod_back *= k
        a_shape = (prod_back, prod_front)
        a = _np.random.randn(*a_shape)
        if prod_back == prod_front:
            if _np.allclose(_np.dot(a, _np.linalg.inv(a)), _np.eye(prod_front)):
                a_shape = shape[1:]
                a = a.reshape(a_shape)
                OpArgMngr.add_workload('linalg.tensorinv', np.array(a, dtype=dtype), ind)


def _add_workload_linalg_tensorsolve():
    shapes = [
        # a_shape.ndim <= 6
        # (a_shape, b_shape, axes)
        ((1, 1), (1,), None),
        ((1, 1), (1, 1, 1, 1, 1), None),
        ((4, 4), (4,), None),
        ((2, 3, 3, 4, 2), (3, 4), (0, 2, 4)),
        ((1, 3, 3, 4, 4), (1, 3, 4), (1, 3)),
        ((1, 4, 1, 12, 3), (1, 2, 1, 2, 1, 3, 1), (1, 2, 4)),
    ]
    dtypes = (np.float32, np.float64)
    for dtype in dtypes:
        for a_shape, b_shape, axes in shapes:
            a_ndim = len(a_shape)
            b_ndim = len(b_shape)
            a_trans_shape = list(a_shape)
            a_axes = list(range(0, a_ndim))
            if axes is not None:
                for k in axes:
                    a_axes.remove(k)
                    a_axes.insert(a_ndim, k)
                for k in range(a_ndim):
                    a_trans_shape[k] = a_shape[a_axes[k]]
            x_shape = a_trans_shape[-(a_ndim - b_ndim):]
            prod = 1
            for k in x_shape:
                prod *= k
            if prod * prod != _np.prod(a_shape):
                raise ValueError("a is not square")
            if prod != _np.prod(b_shape):
                raise ValueError("a's shape and b's shape dismatch")
            mat_shape = (prod, prod)
            a_trans_shape = tuple(a_trans_shape)
            x_shape = tuple(x_shape)

            a_np = _np.eye(prod)
            shape = mat_shape
            while 1:
                # generate well-conditioned matrices with small eigenvalues
                D = _np.diag(_np.random.uniform(-1.0, 1.0, shape[-1]))
                I = _np.eye(shape[-1]).reshape(shape)
                v = _np.random.uniform(-1., 1., shape[-1]).reshape(shape[:-1] + (1,))
                v = v / _np.linalg.norm(v, axis=-2, keepdims=True)
                v_T = _np.swapaxes(v, -1, -2)
                U = I - 2 * _np.matmul(v, v_T)
                a = _np.matmul(U, D)
                if (_np.linalg.cond(a, 2) < 4):
                    a_np = a.reshape(a_trans_shape)
                    break
            x_np = _np.random.randn(*x_shape)
            b_np = _np.tensordot(a_np, x_np, axes=len(x_shape))
            a_origin_axes = list(range(a_np.ndim))
            if axes is not None:
                for k in range(a_np.ndim):
                    a_origin_axes[a_axes[k]] = k
            a_np = a_np.transpose(a_origin_axes)
            OpArgMngr.add_workload('linalg.tensorsolve', np.array(a_np, dtype=dtype), np.array(b_np, dtype=dtype), axes)


def _add_workload_linalg_pinv():
    shapes = [
        ((1, 1), ()),
        ((5, 5), ()),
        ((5, 6), ()),
        ((6, 5), ()),
        ((2, 3, 3), (1,)),
        ((4, 6, 5), (4,)),
        ((2, 2, 3, 4), (2, 2)),
    ]
    dtypes = (np.float32, np.float64)
    for dtype in dtypes:
        for a_shape, rcond_shape in shapes:
            hermitian = False
            a_np = _np.random.uniform(-10.0, 10.0, a_shape)
            a_np = _np.array(a_np, dtype=dtype)
            rcond_np = _np.random.uniform(0., 0.1, rcond_shape)
            rcond_np = _np.array(rcond_np, dtype=dtype)
            OpArgMngr.add_workload('linalg.pinv', np.array(a_np, dtype=dtype), np.array(rcond_np, dtype=dtype), hermitian)


def _add_workload_linalg_lstsq():
    shapes = [
        ((0, 0), (0,)),
        ((0, 0), (0, 0)),
        ((4, 0), (4,)),
        ((4, 0), (4, 2)),
        ((0, 2), (0, 4)),
        ((4, 2), (4, 0)),
        ((0, 0), (0, 4)),
        ((0, 2), (0, 0)),
        ((4, 0), (4, 0)),
        ((4, 2), (4,)),
        ((4, 2), (4, 3)),
        ((4, 6), (4, 3)),
    ]
    rconds = [None, "random", "warn"]
    dtypes = (np.float32, np.float64)
    for dtype, rcond in itertools.product(dtypes, rconds):
        for a_shape, b_shape in shapes:
            if rcond == "random":
                rcond = _np.random.uniform(100, 200)
            if rcond == "warn":
                rcond = -1
            a_np = _np.random.uniform(-10.0, 10.0, a_shape)
            b_np = _np.random.uniform(-10.0, 10.0, b_shape)
            a = np.array(a_np, dtype=dtype)
            b = np.array(b_np, dtype=dtype)
            OpArgMngr.add_workload('linalg.lstsq', a, b, rcond)


def _add_workload_linalg_eigvals():
    OpArgMngr.add_workload('linalg.eigvals', np.array(_np.diag((0, 0)), dtype=np.float64))
    OpArgMngr.add_workload('linalg.eigvals', np.array(_np.diag((1, 1)), dtype=np.float64))
    OpArgMngr.add_workload('linalg.eigvals', np.array(_np.diag((2, 2)), dtype=np.float64))


def _add_workload_linalg_eig():
    OpArgMngr.add_workload('linalg.eig', np.array(_np.diag((0, 0)), dtype=np.float64))
    OpArgMngr.add_workload('linalg.eig', np.array(_np.diag((1, 1)), dtype=np.float64))
    OpArgMngr.add_workload('linalg.eig', np.array(_np.diag((2, 2)), dtype=np.float64))


def _add_workload_linalg_eigvalsh():
    OpArgMngr.add_workload('linalg.eigvalsh', np.array(_np.diag((0, 0)), dtype=np.float64))
    OpArgMngr.add_workload('linalg.eigvalsh', np.array(_np.diag((1, 1)), dtype=np.float64))
    OpArgMngr.add_workload('linalg.eigvalsh', np.array(_np.diag((2, 2)), dtype=np.float64))


def _add_workload_linalg_eigh():
    OpArgMngr.add_workload('linalg.eigh', np.array(_np.diag((0, 0)), dtype=np.float64))
    OpArgMngr.add_workload('linalg.eigh', np.array(_np.diag((1, 1)), dtype=np.float64))
    OpArgMngr.add_workload('linalg.eigh', np.array(_np.diag((2, 2)), dtype=np.float64))


def _add_workload_linalg_slogdet():
    OpArgMngr.add_workload('linalg.slogdet', np.array(_np.ones((2, 2)), dtype=np.float32))
    OpArgMngr.add_workload('linalg.slogdet', np.array(_np.ones((0, 1, 1)), dtype=np.float64))


def _add_workload_trace():
    OpArgMngr.add_workload('trace', np.random.uniform(size=(4, 1)))
    OpArgMngr.add_workload('trace', np.random.uniform(size=(3, 2)))


def _add_workload_tril():
    OpArgMngr.add_workload('tril', np.random.uniform(size=(4, 1)))
    for dt in ['float16', 'float32', 'float64', 'int32', 'int64', 'int8', 'uint8']:
        OpArgMngr.add_workload('tril', np.ones((2, 2), dtype=dt))
        a = np.array([
            [[1, 1], [1, 1]],
            [[1, 1], [1, 0]],
            [[1, 1], [0, 0]],
        ], dtype=dt)
        OpArgMngr.add_workload('tril', a)
        arr = np.array([[1, 1, _np.inf],
                        [1, 1, 1],
                        [_np.inf, 1, 1]])
        OpArgMngr.add_workload('tril', arr)
        OpArgMngr.add_workload('tril', np.zeros((3, 3), dtype=dt))
    import mxnet as mx
    assertRaises(mx.MXNetError, np.tril, 10)
    assertRaises(mx.MXNetError, np.tril, 2, 10)


def _add_workload_triu():
    OpArgMngr.add_workload('triu', np.random.uniform(size=(4, 1)))
    for dt in ['float16', 'float32', 'float64', 'int32', 'int64', 'int8', 'uint8']:
        OpArgMngr.add_workload('triu', np.ones((2, 2), dtype=dt))
        a = np.array([
            [[1, 1], [1, 1]],
            [[1, 1], [1, 0]],
            [[1, 1], [0, 0]],
        ], dtype=dt)
        OpArgMngr.add_workload('triu', a)
        arr = np.array([[1, 1, _np.inf],
                        [1, 1, 1],
                        [_np.inf, 1, 1]])
        OpArgMngr.add_workload('triu', arr)
        OpArgMngr.add_workload('triu', np.zeros((3, 3), dtype=dt))


def _add_workload_einsum():
    chars = 'abcdefghij'
    sizes = [2, 3, 4, 5, 4, 3, 2, 6, 5, 4]
    size_dict = dict(zip(chars, sizes))

    configs = [
        # test_einsum_broadcast
        ('ij...,j...->ij...', [(2, 3, 4), (3,)]),
        ('ij...,...j->ij...', [(2, 3, 4), (3,)]),
        ('ij...,j->ij...', [(2, 3, 4), (3,)]),
        ('cl, cpx->lpx', [(2, 3), (2, 3, 2731)]),
        ('aabb->ab', [(5, 5, 5, 5)]),
        ('mi,mi,mi->m', [(5, 5), (5, 5), (5, 5)]),
        ('a,ab,abc->abc', None),
        ('a,b,ab->ab', None),
        ('ea,fb,gc,hd,abcd->efgh', None),
        ('ea,fb,abcd,gc,hd->efgh', None),
        ('abcd,ea,fb,gc,hd->efgh', None),
        # test_complex
        ('acdf,jbje,gihb,hfac,gfac,gifabc,hfac', None),
        ('acdf,jbje,gihb,hfac,gfac,gifabc,hfac', None),
        ('cd,bdhe,aidb,hgca,gc,hgibcd,hgac', None),
        ('abhe,hidj,jgba,hiab,gab', None),
        ('bde,cdh,agdb,hica,ibd,hgicd,hiac', None),
        ('chd,bde,agbc,hiad,hgc,hgi,hiad', None),
        ('chd,bde,agbc,hiad,bdi,cgh,agdb', None),
        ('bdhe,acad,hiab,agac,hibd', None),
        # test_collapse
        ('ab,ab,c->', None),
        ('ab,ab,c->c', None),
        ('ab,ab,cd,cd->', None),
        ('ab,ab,cd,cd->ac', None),
        ('ab,ab,cd,cd->cd', None),
        ('ab,ab,cd,cd,ef,ef->', None),
        # test_inner_product
        ('ab,ab', None),
        ('ab,ba', None),
        ('abc,abc', None),
        ('abc,bac', None),
        ('abc,cba', None),
        # test_random_cases
        ('aab,fa,df,ecc->bde', None),
        ('ecb,fef,bad,ed->ac', None),
        ('bcf,bbb,fbf,fc->', None),
        ('bb,ff,be->e', None),
        ('bcb,bb,fc,fff->', None),
        ('fbb,dfd,fc,fc->', None),
        ('afd,ba,cc,dc->bf', None),
        ('adb,bc,fa,cfc->d', None),
        ('bbd,bda,fc,db->acf', None),
        ('dba,ead,cad->bce', None),
        ('aef,fbc,dca->bde', None),
        # test_broadcasting_dot_cases
        ('ijk,kl,jl', [(1, 5, 4), (4, 6), (5, 6)]),
        ('ijk,kl,jl,i->i', [(1, 5, 4), (4, 6), (5, 6), (10)]),
        ('abjk,kl,jl', [(1, 1, 5, 4), (4, 6), (5, 6)]),
        ('abjk,kl,jl,ab->ab', [(1, 1, 5, 4), (4, 6), (5, 6), (7, 7)]),
        ('obk,ijk->ioj', [(2, 4, 8), (2, 4, 8)]),
    ]
    # check_einsum_sums
    configs.extend([('i->', [(i,)]) for i in range(1, 17)])
    configs.extend([('...i->...', [(2, 3, i,)]) for i in range(1, 17)])
    configs.extend([('i...->...', [(2, i,)]) for i in range(1, 17)])
    configs.extend([('i...->...', [(2, 3, i,)]) for i in range(1, 17)])
    configs.extend([('ii', [(i, i,)]) for i in range(1, 17)])
    configs.extend([('..., ...', [(3, i,), (2, 3, i,)]) for i in range(1, 17)])
    configs.extend([('...i, ...i', [(2, 3, i,), (i,)]) for i in range(1, 17)])
    configs.extend([('i..., i...', [(i, 3, 2,), (i,)]) for i in range(1, 11)])
    configs.extend([('i, j', [(3,), (i,)]) for i in range(1, 17)])
    configs.extend([('ij, j', [(4, i), (i,)]) for i in range(1, 17)])
    configs.extend([('ji, j', [(i, 4), (i,)]) for i in range(1, 17)])
    configs.extend([('ij, jk', [(4, i), (i, 6)]) for i in range(1, 8)])
    configs.extend([
        ('ij,jk,kl', [(3, 4), (4, 5), (5, 6)]),
        ('ijk, jil -> kl', [(3, 4, 5), (4, 3, 2)]),
        ('i, i, i -> i', [(8,), (8,), (8,)]),
        (',i->', [(), (9,)]),
        ('i,->', [(9,), ()]),
    ])
    configs.extend([('...,...', [(n,), (n,)]) for n in range(1, 25)])
    configs.extend([('i,i', [(n,), (n,)]) for n in range(1, 25)])
    configs.extend([('i,->i', [(n,), ()]) for n in range(1, 25)])
    configs.extend([(',i->i', [(), (n,)]) for n in range(1, 25)])
    configs.extend([('i,->', [(n,), ()]) for n in range(1, 25)])
    configs.extend([(',i->', [(), (n,)]) for n in range(1, 25)])
    configs.extend([('...,...', [(n - 1,), (n - 1,)]) for n in range(1, 25)])
    configs.extend([('i,i', [(n - 1,), (n - 1,)]) for n in range(1, 25)])
    configs.extend([('i,->i', [(n - 1,), ()]) for n in range(1, 25)])
    configs.extend([(',i->i', [(), (n - 1,)]) for n in range(1, 25)])
    configs.extend([('i,->', [(n - 1,), ()]) for n in range(1, 25)])
    configs.extend([(',i->', [(), (n - 1,)]) for n in range(1, 25)])

    for optimize in [False, True]:
        for config in configs:
            subscripts, args = config
            if args is None:
                args = []
                terms = subscripts.split('->')[0].split(',')
                for term in terms:
                    dims = [size_dict[x] for x in term]
                    args.append(np.random.uniform(size=dims))
            else:
                args = [np.random.uniform(size=arg) for arg in args]
            OpArgMngr.add_workload('einsum', subscripts, *args, optimize=optimize)


def _add_workload_expm1():
    OpArgMngr.add_workload('expm1', np.random.uniform(size=(4, 1)))
    OpArgMngr.add_workload('expm1', np.random.uniform(size=(1, 1)))
    OpArgMngr.add_workload('expm1', np.array([_np.inf]))
    OpArgMngr.add_workload('expm1', np.array([-_np.inf]))
    OpArgMngr.add_workload('expm1', np.array([0.]))
    OpArgMngr.add_workload('expm1', np.array([-0.]))


def _add_workload_argmax():
    OpArgMngr.add_workload('argmax', np.random.uniform(size=(4, 5, 6, 7, 8)), 0)
    OpArgMngr.add_workload('argmax', np.random.uniform(size=(4, 5, 6, 7, 8)), 1)
    OpArgMngr.add_workload('argmax', np.random.uniform(size=(4, 5, 6, 7, 8)), 2)
    OpArgMngr.add_workload('argmax', np.random.uniform(size=(4, 5, 6, 7, 8)), 3)
    OpArgMngr.add_workload('argmax', np.random.uniform(size=(4, 5, 6, 7, 8)), 4)
    # OpArgMngr.add_workload('argmax', np.array([0, 1, 2, 3, _np.nan]))
    # OpArgMngr.add_workload('argmax', np.array([0, 1, 2, _np.nan, 3]))
    # OpArgMngr.add_workload('argmax', np.array([_np.nan, 0, 1, 2, 3]))
    # OpArgMngr.add_workload('argmax', np.array([_np.nan, 0, _np.nan, 2, 3]))
    OpArgMngr.add_workload('argmax', np.array([False, False, False, False, True]))
    OpArgMngr.add_workload('argmax', np.array([False, False, False, True, False]))
    OpArgMngr.add_workload('argmax', np.array([True, False, False, False, False]))
    OpArgMngr.add_workload('argmax', np.array([True, False, True, False, False]))


def _add_workload_argmin():
    OpArgMngr.add_workload('argmin', np.random.uniform(size=(4, 5, 6, 7, 8)), 0)
    OpArgMngr.add_workload('argmin', np.random.uniform(size=(4, 5, 6, 7, 8)), 1)
    OpArgMngr.add_workload('argmin', np.random.uniform(size=(4, 5, 6, 7, 8)), 2)
    OpArgMngr.add_workload('argmin', np.random.uniform(size=(4, 5, 6, 7, 8)), 3)
    OpArgMngr.add_workload('argmin', np.random.uniform(size=(4, 5, 6, 7, 8)), 4)
    # OpArgMngr.add_workload('argmin', np.array([0, 1, 2, 3, _np.nan]))
    # OpArgMngr.add_workload('argmin', np.array([0, 1, 2, _np.nan, 3]))
    # OpArgMngr.add_workload('argmin', np.array([_np.nan, 0, 1, 2, 3]))
    # OpArgMngr.add_workload('argmin', np.array([_np.nan, 0, _np.nan, 2, 3]))
    OpArgMngr.add_workload('argmin', np.array([False, False, False, False, True]))
    OpArgMngr.add_workload('argmin', np.array([False, False, False, True, False]))
    OpArgMngr.add_workload('argmin', np.array([True, False, False, False, False]))
    OpArgMngr.add_workload('argmin', np.array([True, False, True, False, False]))


def _add_workload_around():
    OpArgMngr.add_workload('around', np.array([1.56, 72.54, 6.35, 3.25]), decimals=1)


def _add_workload_round():
    OpArgMngr.add_workload('round', np.array([1.56, 72.54, 6.35, 3.25]), decimals=1)


def _add_workload_round_():
    OpArgMngr.add_workload('round_', np.array([1.56, 72.54, 6.35, 3.25]), decimals=1)


def _add_workload_argsort():
    for dtype in [np.int32, np.float32]:
        a = np.arange(101, dtype=dtype)
        OpArgMngr.add_workload('argsort', a)
    OpArgMngr.add_workload('argsort', np.array([[3, 2], [1, 0]]), 1)
    OpArgMngr.add_workload('argsort', np.array([[3, 2], [1, 0]]), 0)
    a = np.ones((3, 2, 1, 0))
    for axis in range(-a.ndim, a.ndim):
        OpArgMngr.add_workload('argsort', a, axis)


def _add_workload_sort():
    OpArgMngr.add_workload('sort', np.random.uniform(0, 100), axis=None)
    OpArgMngr.add_workload('sort', np.random.uniform(0, 100, size=()), axis=None)
    OpArgMngr.add_workload('sort', np.random.uniform(0, 100, size=(2, 3, 4)), axis=None)
    OpArgMngr.add_workload('sort', np.random.uniform(0, 100, size=(4, 3, 0)), axis=None)
    OpArgMngr.add_workload('sort', np.random.randint(0, 100, size=(2, 3, 4)), axis=-1)
    OpArgMngr.add_workload('sort', np.random.randint(0, 100, size=(4, 3, 5)), axis=-1, kind='mergesort')
    OpArgMngr.add_workload('sort', np.random.randint(0, 100, size=(2, 3, 4)), axis=None, kind='quicksort')
    OpArgMngr.add_workload('sort', np.random.uniform(0, 100, size=(4, 3, 0)))


def _add_workload_broadcast_arrays(array_pool):
    OpArgMngr.add_workload('broadcast_arrays', array_pool['4x1'], array_pool['1x2'])


def _add_workload_broadcast_to():
    OpArgMngr.add_workload('broadcast_to', np.array(0), (0,))
    OpArgMngr.add_workload('broadcast_to', np.array(0), (1,))
    OpArgMngr.add_workload('broadcast_to', np.array(0), (3,))
    OpArgMngr.add_workload('broadcast_to', np.ones(1), (1,))
    OpArgMngr.add_workload('broadcast_to', np.ones(1), (2,))
    OpArgMngr.add_workload('broadcast_to', np.ones(1), (1, 2, 3))
    OpArgMngr.add_workload('broadcast_to', np.arange(3), (3,))
    OpArgMngr.add_workload('broadcast_to', np.arange(3), (1, 3))
    OpArgMngr.add_workload('broadcast_to', np.arange(3), (2, 3))
    OpArgMngr.add_workload('broadcast_to', np.ones(0), 0)
    OpArgMngr.add_workload('broadcast_to', np.ones(1), 1)
    OpArgMngr.add_workload('broadcast_to', np.ones(1), 2)
    OpArgMngr.add_workload('broadcast_to', np.ones(1), (0,))
    OpArgMngr.add_workload('broadcast_to', np.ones((1, 2)), (0, 2))
    OpArgMngr.add_workload('broadcast_to', np.ones((2, 1)), (2, 0))


def _add_workload_clip():
    OpArgMngr.add_workload('clip', (np.random.normal(size=(1000,)) * 1024).astype("float"), -12.8, 100.2)
    OpArgMngr.add_workload('clip', (np.random.normal(size=(1000,)) * 1024).astype("float"), 0, 0)
    OpArgMngr.add_workload('clip', (np.random.normal(size=(1000,)) * 1024).astype("int"), -120, 100)
    OpArgMngr.add_workload('clip', (np.random.normal(size=(1000,)) * 1024).astype("int"), 0.0, 2.0)
    OpArgMngr.add_workload('clip', (np.random.normal(size=(1000,)) * 1024).astype("int"), 0, 0)
    OpArgMngr.add_workload('clip', (np.random.normal(size=(1000,)) * 1024).astype("uint8"), 0, 0)
    OpArgMngr.add_workload('clip', (np.random.normal(size=(1000,)) * 1024).astype("uint8"), 0.0, 2.0)
    OpArgMngr.add_workload('clip', (np.random.normal(size=(1000,)) * 1024).astype("uint8"), -120, 100)
    # OpArgMngr.add_workload('clip', np.random.normal(size=(1000,)), np.zeros((1000,))+0.5, 1)
    # OpArgMngr.add_workload('clip', np.random.normal(size=(1000,)), 0, np.zeros((1000,))+0.5)
    # OpArgMngr.add_workload('clip', np.array([0, 1, 2, 3, 4, 5, 6, 7]), 3)
    # OpArgMngr.add_workload('clip', np.array([0, 1, 2, 3, 4, 5, 6, 7]), a_min=3)
    # OpArgMngr.add_workload('clip', np.array([0, 1, 2, 3, 4, 5, 6, 7]), a_max=4)
    OpArgMngr.add_workload('clip', np.array([-2., _np.nan, 0.5, 3., 0.25, _np.nan]), -1, 1)


def _add_workload_cumsum():
    for ctype in _DTYPES:
        OpArgMngr.add_workload('cumsum', np.array([1, 2, 10, 11, 6, 5, 4], dtype=ctype))
        OpArgMngr.add_workload('cumsum', np.array([[1, 2, 3, 4], [5, 6, 7, 9], [10, 3, 4, 5]], dtype=ctype), axis=0)
        OpArgMngr.add_workload('cumsum', np.array([[1, 2, 3, 4], [5, 6, 7, 9], [10, 3, 4, 5]], dtype=ctype), axis=1)


def _add_workload_ravel():
    OpArgMngr.add_workload('ravel', np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]))


def _add_workload_dot():
    OpArgMngr.add_workload('dot', np.random.normal(size=(2, 4)), np.random.normal(size=(4, 2)))
    OpArgMngr.add_workload('dot', np.random.normal(size=(4, 2)), np.random.normal(size=(2, 1)))
    OpArgMngr.add_workload('dot', np.random.normal(size=(4, 2)), np.random.normal(size=(2,)))
    OpArgMngr.add_workload('dot', np.random.normal(size=(1, 2)), np.random.normal(size=(2, 4)))
    OpArgMngr.add_workload('dot', np.random.normal(size=(2, 4)), np.random.normal(size=(4,)))
    OpArgMngr.add_workload('dot', np.random.normal(size=(1, 2)), np.random.normal(size=(2, 1)))
    OpArgMngr.add_workload('dot', np.ones((3, 1)), np.array([5.3]))
    OpArgMngr.add_workload('dot', np.array([5.3]), np.ones((1, 3)))
    OpArgMngr.add_workload('dot', np.random.normal(size=(1, 1)), np.random.normal(size=(1, 4)))
    OpArgMngr.add_workload('dot', np.random.normal(size=(4, 1)), np.random.normal(size=(1, 1)))

    dims = [(), (1,), (1, 1)]
    for (dim1, dim2) in itertools.product(dims, dims):
        b1 = np.zeros(dim1)
        b2 = np.zeros(dim2)
        OpArgMngr.add_workload('dot', b1, b2)
    OpArgMngr.add_workload('dot', np.array([[1, 2], [3, 4]], dtype=float), np.array([[1, 0], [1, 1]], dtype=float))
    OpArgMngr.add_workload('dot', np.random.normal(size=(1024, 16)), np.random.normal(size=(16, 32)))


def _add_workload_fix():
    OpArgMngr.add_workload('fix', np.array([[1.0, 1.1, 1.5, 1.8], [-1.0, -1.1, -1.5, -1.8]]))
    OpArgMngr.add_workload('fix', np.array([3.14]))


def _add_workload_flip():
    OpArgMngr.add_workload('flip', np.random.normal(size=(4, 4)), 1)
    OpArgMngr.add_workload('flip', np.array([[0, 1, 2], [3, 4, 5]]), 1)
    OpArgMngr.add_workload('flip', np.random.normal(size=(4, 4)), 0)
    OpArgMngr.add_workload('flip', np.array([[0, 1, 2], [3, 4, 5]]), 0)
    OpArgMngr.add_workload('flip', np.array([[[0, 1], [2, 3]], [[4, 5], [6, 7]]]), 0)
    OpArgMngr.add_workload('flip', np.array([[[0, 1], [2, 3]], [[4, 5], [6, 7]]]), 1)
    OpArgMngr.add_workload('flip', np.array([[[0, 1], [2, 3]], [[4, 5], [6, 7]]]), 2)
    for i in range(4):
        OpArgMngr.add_workload('flip', np.arange(2 * 3 * 4 * 5).reshape(2, 3, 4, 5), i)
    OpArgMngr.add_workload('flip', np.array([[1, 2, 3], [4, 5, 6]]))
    OpArgMngr.add_workload('flip', np.array([[[0, 1], [2, 3]], [[4, 5], [6, 7]]]), ())
    OpArgMngr.add_workload('flip', np.array([[[0, 1], [2, 3]], [[4, 5], [6, 7]]]), (0, 2))
    OpArgMngr.add_workload('flip', np.array([[[0, 1], [2, 3]], [[4, 5], [6, 7]]]), (1, 2))


def _add_workload_flipud():
    OpArgMngr.add_workload('flipud', np.random.normal(size=(4, 4)))
    OpArgMngr.add_workload('flipud', np.array([[0, 1, 2], [3, 4, 5]]))
    OpArgMngr.add_workload('flipud', np.array([[[0, 1], [2, 3]], [[4, 5], [6, 7]]]))


def _add_workload_fliplr():
    OpArgMngr.add_workload('fliplr', np.random.normal(size=(4, 4)))
    OpArgMngr.add_workload('fliplr', np.array([[0, 1, 2], [3, 4, 5]]))
    OpArgMngr.add_workload('fliplr', np.array([[[0, 1], [2, 3]], [[4, 5], [6, 7]]]))


def _add_workload_max(array_pool):
    OpArgMngr.add_workload('max', array_pool['4x1'])


def _add_workload_amax(array_pool):
    a = np.array([3, 4, 5, 10, -3, -5, 6.0])
    b = np.array([[3, 6.0, 9.0],
                  [4, 10.0, 5.0],
                  [8, 3.0, 2.0]])
    c = np.array(1)
    OpArgMngr.add_workload('amax', array_pool['4x1'])
    OpArgMngr.add_workload('amax', a)
    OpArgMngr.add_workload('amax', b, axis=0)
    OpArgMngr.add_workload('amax', b, axis=1)
    OpArgMngr.add_workload('amax', c)
    OpArgMngr.add_workload('amax', c, axis=None)


def _add_workload_min(array_pool):
    OpArgMngr.add_workload('min', array_pool['4x1'])


def _add_workload_amin(array_pool):
    a = np.array([3, 4, 5, 10, -3, -5, 6.0])
    b = np.array([[3, 6.0, 9.0],
                  [4, 10.0, 5.0],
                  [8, 3.0, 2.0]])
    c = np.array(1)
    OpArgMngr.add_workload('amin', array_pool['4x1'])
    OpArgMngr.add_workload('amin', a)
    OpArgMngr.add_workload('amin', b, axis=0)
    OpArgMngr.add_workload('amin', b, axis=1)
    OpArgMngr.add_workload('amin', c)
    OpArgMngr.add_workload('amin', c, axis=None)


def _add_workload_mean(array_pool):
    OpArgMngr.add_workload('mean', array_pool['4x1'])
    OpArgMngr.add_workload('mean', array_pool['4x1'], axis=0, keepdims=True)
    OpArgMngr.add_workload('mean', np.array([[1, 2, 3], [4, 5, 6]]))
    OpArgMngr.add_workload('mean', np.array([]).reshape(2,0,0))
    OpArgMngr.add_workload('mean', np.array([[1, 2, 3], [4, 5, 6]]), axis=0)
    OpArgMngr.add_workload('mean', np.array([[1, 2, 3], [4, 5, 6]]), axis=1)


def _add_workload_ones_like(array_pool):
    OpArgMngr.add_workload('ones_like', array_pool['4x1'])


def _add_workload_atleast_nd():
    a_0 = np.array(1)
    b_0 = np.array(2)
    a_1 = np.array([1, 2])
    b_1 = np.array([2, 3])
    a_2 = np.array([[1, 2], [1, 2]])
    b_2 = np.array([[2, 3], [2, 3]])
    a_3 = [a_2, a_2]
    b_3 = [b_2, b_2]

    OpArgMngr.add_workload('atleast_1d', a_0, b_0)
    OpArgMngr.add_workload('atleast_1d', a_1, b_1)
    OpArgMngr.add_workload('atleast_1d', a_2, b_2)
    OpArgMngr.add_workload('atleast_1d', a_3, b_3)
    OpArgMngr.add_workload('atleast_2d', a_0, b_0)
    OpArgMngr.add_workload('atleast_2d', a_1, b_1)
    OpArgMngr.add_workload('atleast_2d', a_2, b_2)
    OpArgMngr.add_workload('atleast_2d', a_3, b_3)
    OpArgMngr.add_workload('atleast_3d', a_0, b_0)
    OpArgMngr.add_workload('atleast_3d', a_1, b_1)
    OpArgMngr.add_workload('atleast_3d', a_2, b_2)
    OpArgMngr.add_workload('atleast_3d', a_3, b_3)


def _add_workload_prod(array_pool):
    OpArgMngr.add_workload('prod', array_pool['4x1'])
    OpArgMngr.add_workload('prod', np.array([]).reshape(2,0,0))


def _add_workload_product(array_pool):
    OpArgMngr.add_workload('product', array_pool['4x1'])


def _add_workload_repeat(array_pool):
    OpArgMngr.add_workload('repeat', array_pool['4x1'], 3)
    OpArgMngr.add_workload('repeat', np.array(_np.arange(12).reshape(4, 3)[:, 2]), 3)
    m = _np.array([1, 2, 3, 4, 5, 6])
    m_rect = m.reshape((2, 3))

    OpArgMngr.add_workload('repeat', np.array(m), [1, 3, 2, 1, 1, 2]) # Argument "repeats" only supports int
    OpArgMngr.add_workload('repeat', np.array(m), 2)
    B = np.array(m_rect)
    OpArgMngr.add_workload('repeat', B, [2, 1], axis=0)  # Argument "repeats" only supports int
    OpArgMngr.add_workload('repeat', B, [1, 3, 2], axis=1)  # Argument "repeats" only supports int
    OpArgMngr.add_workload('repeat', B, 2, axis=0)
    OpArgMngr.add_workload('repeat', B, 2, axis=1)

    # test_repeat_broadcasting
    a = _np.arange(60).reshape(3, 4, 5)
    for axis in itertools.chain(range(-a.ndim, a.ndim), [None]):
        OpArgMngr.add_workload('repeat', np.array(a), 2, axis=axis)
        OpArgMngr.add_workload('repeat', np.array(a), [2], axis=axis)   # Argument "repeats" only supports int


def _add_workload_reshape():
    arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
    OpArgMngr.add_workload('reshape', arr, (2, 6))
    OpArgMngr.add_workload('reshape', arr, (3, 4))
    # OpArgMngr.add_workload('reshape', arr, (3, 4), order='F') # Items are not equal with order='F'
    OpArgMngr.add_workload('reshape', arr, (3, 4), order='C')
    OpArgMngr.add_workload('reshape', np.array(_np.ones(100)), (100, 1, 1))

    # test_reshape_order
    a = np.array(_np.arange(6))
    # OpArgMngr.add_workload('reshape', a, (2, 3), order='F')  # Items are not equal with order='F'
    a = np.array([[1, 2], [3, 4], [5, 6], [7, 8]])
    b = a[:, 1]
    # OpArgMngr.add_workload('reshape', b, (2, 2), order='F')  # Items are not equal with order='F'

    a = np.array(_np.ones((0, 2)))
    OpArgMngr.add_workload('reshape', a, (-1, 2))


def _add_workload_rint(array_pool):
    OpArgMngr.add_workload('rint', np.array(4607998452777363968))
    OpArgMngr.add_workload('rint', array_pool['4x1'])


def _add_workload_roll():
    # test_roll1d(self)
    OpArgMngr.add_workload('roll', np.array(_np.arange(10)), 2)

    # test_roll2d(self)
    x2 = np.array(_np.reshape(_np.arange(10), (2, 5)))
    OpArgMngr.add_workload('roll', x2, 1)
    OpArgMngr.add_workload('roll', x2, 1, axis=0)
    OpArgMngr.add_workload('roll', x2, 1, axis=1)
    # # Roll multiple axes at once.
    OpArgMngr.add_workload('roll', x2, 1, axis=(0, 1))
    OpArgMngr.add_workload('roll', x2, (1, 0), axis=(0, 1))
    OpArgMngr.add_workload('roll', x2, (-1, 0), axis=(0, 1))
    OpArgMngr.add_workload('roll', x2, (0, 1), axis=(0, 1))
    OpArgMngr.add_workload('roll', x2, (0, -1), axis=(0, 1))
    OpArgMngr.add_workload('roll', x2, (1, 1), axis=(0, 1))
    OpArgMngr.add_workload('roll', x2, (-1, -1), axis=(0, 1))
    # # Roll the same axis multiple times.
    # OpArgMngr.add_workload('roll', x2, 1, axis=(0, 0)) # Check failed: axes[i - 1] < axes[i] (0 vs. 0) : axes have duplicates [0,0]
    # OpArgMngr.add_workload('roll', x2, 1, axis=(1, 1)) # Check failed: axes[i - 1] < axes[i] (1 vs. 1) : axes have duplicates [1,1]
    # # Roll more than one turn in either direction.
    OpArgMngr.add_workload('roll', x2, 6, axis=1)
    OpArgMngr.add_workload('roll', x2, -4, axis=1)
    # # test_roll_empty
    OpArgMngr.add_workload('roll', np.array([]), 1)


def _add_workload_stack(array_pool):
    OpArgMngr.add_workload('stack', [array_pool['4x1']] * 2)
    OpArgMngr.add_workload('stack', [array_pool['4x1']] * 2, 1)
    OpArgMngr.add_workload('stack', [array_pool['4x1']] * 2, -1)
    OpArgMngr.add_workload('stack', [array_pool['4x1']] * 2, -2)
    OpArgMngr.add_workload('stack', np.random.normal(size=(2, 4, 3)), 2)
    OpArgMngr.add_workload('stack', np.random.normal(size=(2, 4, 3)), -3)
    OpArgMngr.add_workload('stack', np.array([[], [], []]), 1)
    OpArgMngr.add_workload('stack', np.array([[], [], []]))


def _add_workload_sum():
    # OpArgMngr.add_workload('sum', np.ones(101, dtype=bool))
    OpArgMngr.add_workload('sum', np.arange(1, 10).reshape((3, 3)), axis=1, keepdims=True)
    OpArgMngr.add_workload('sum', np.ones(500, dtype=np.float32)/10.)
    OpArgMngr.add_workload('sum', np.ones(500, dtype=np.float64)/10.)
    for dt in (np.float16, np.float32, np.float64):
        for v in (0, 1, 2, 7, 8, 9, 15, 16, 19, 127,
                  128, 1024, 1235):
            d = np.arange(1, v + 1, dtype=dt)
            OpArgMngr.add_workload('sum', d)
        d = np.ones(500, dtype=dt)
        OpArgMngr.add_workload('sum', d[::2])
        OpArgMngr.add_workload('sum', d[1::2])
        OpArgMngr.add_workload('sum', d[::3])
        OpArgMngr.add_workload('sum', d[1::3])
        OpArgMngr.add_workload('sum', d[::-2])
        OpArgMngr.add_workload('sum', d[-1::-2])
        OpArgMngr.add_workload('sum', d[::-3])
        OpArgMngr.add_workload('sum', d[-1::-3])
        d = np.ones((1,), dtype=dt)
        d += d
        OpArgMngr.add_workload('sum', d)
    # OpArgMngr.add_workload('sum', np.array([3]), initial=2)
    # OpArgMngr.add_workload('sum', np.array([0.2]), initial=0.1)


def _add_workload_take():
    OpArgMngr.add_workload('take', np.array([[1, 2], [3, 4]], dtype=int), np.array([], int))
    for mode in ['wrap', 'clip']:
        OpArgMngr.add_workload('take', np.array([[1, 2], [3, 4]], dtype=int), np.array(-1, int), mode=mode)
        OpArgMngr.add_workload('take', np.array([[1, 2], [3, 4]], dtype=int), np.array(4, int), mode=mode)
        OpArgMngr.add_workload('take', np.array([[1, 2], [3, 4]], dtype=int), np.array([-1], int), mode=mode)
        OpArgMngr.add_workload('take', np.array([[1, 2], [3, 4]], dtype=int), np.array([4], int), mode=mode)
    x = (np.random.normal(size=24)*100).reshape((2, 3, 4))
    # OpArgMngr.add_workload('take', x, np.array([-1], int), axis=0)
    OpArgMngr.add_workload('take', x, np.array([-1], int), axis=0, mode='clip')
    OpArgMngr.add_workload('take', x, np.array([2], int), axis=0, mode='clip')
    OpArgMngr.add_workload('take', x, np.array([-1], int), axis=0, mode='wrap')
    OpArgMngr.add_workload('take', x, np.array([2], int), axis=0, mode='wrap')
    OpArgMngr.add_workload('take', x, np.array([3], int), axis=0, mode='wrap')


def _add_workload_unique():
    OpArgMngr.add_workload('unique', np.array([5, 7, 1, 2, 1, 5, 7]*10), True, True, True)
    OpArgMngr.add_workload('unique', np.array([]), True, True, True)
    OpArgMngr.add_workload('unique', np.array([[0, 1, 0], [0, 1, 0]]))
    OpArgMngr.add_workload('unique', np.array([[0, 1, 0], [0, 1, 0]]), axis=0)
    OpArgMngr.add_workload('unique', np.array([[0, 1, 0], [0, 1, 0]]), axis=1)
    # OpArgMngr.add_workload('unique', np.arange(10, dtype=np.uint8).reshape(-1, 2).astype(bool), axis=1)


def _add_workload_delete():
    a = np.arange(5)
    nd_a = np.arange(5).repeat(2).reshape(1, 5, 2)
    lims = [-6, -2, 0, 1, 2, 4, 5]
    steps = [-3, -1, 1, 3]
    for start in lims:
        for stop in lims:
            for step in steps:
                s = slice(start, stop, step)
                OpArgMngr.add_workload('delete', a, s)
                OpArgMngr.add_workload('delete', nd_a, s, axis=1)
    # mxnet.numpy arrays, even 0-sized, have a float32 dtype.  Starting with numpy 1.19, the
    # index array's of delete() must be of integer or boolean type, so we force that below.
    OpArgMngr.add_workload('delete', a, np.array([], dtype='int32'), axis=0)
    OpArgMngr.add_workload('delete', a, 0)
    OpArgMngr.add_workload('delete', a, np.array([], dtype='int32'))
    OpArgMngr.add_workload('delete', a, np.array([0, 1], dtype='int32'))
    OpArgMngr.add_workload('delete', a, slice(1, 2))
    OpArgMngr.add_workload('delete', a, slice(1, -2))
    k = np.arange(10).reshape(2, 5)
    OpArgMngr.add_workload('delete', k, slice(60, None), axis=1)


def _add_workload_var(array_pool):
    OpArgMngr.add_workload('var', array_pool['4x1'])
    OpArgMngr.add_workload('var', np.array([_np.float16(1.)]))
    OpArgMngr.add_workload('var', np.array([1]))
    OpArgMngr.add_workload('var', np.array([1.]))
    OpArgMngr.add_workload('var', np.array([[1, 2, 3], [4, 5, 6]]))
    OpArgMngr.add_workload('var', np.array([[1, 2, 3], [4, 5, 6]]), 0)
    OpArgMngr.add_workload('var', np.array([[1, 2, 3], [4, 5, 6]]), 1)
    OpArgMngr.add_workload('var', np.array([_np.nan]))
    OpArgMngr.add_workload('var', np.array([1, -1, 1, -1]))
    OpArgMngr.add_workload('var', np.array([1,2,3,4], dtype='f8'))


def _add_workload_zeros_like(array_pool):
    OpArgMngr.add_workload('zeros_like', array_pool['4x1'])
    OpArgMngr.add_workload('zeros_like', np.random.uniform(size=(3, 3)).astype(np.float64), dtype=np.int64)
    OpArgMngr.add_workload('zeros_like', np.random.uniform(size=(3, 3)).astype(np.float32), dtype=np.float64)
    OpArgMngr.add_workload('zeros_like', np.random.randint(2, size = (3, 3)), dtype=int)


def _add_workload_full_like(array_pool):
    OpArgMngr.add_workload('full_like', array_pool['4x1'], 1)
    OpArgMngr.add_workload('full_like', np.random.uniform(low=0, high=100, size=(1,3,4), dtype='float64'), 1)
    OpArgMngr.add_workload('full_like', np.random.uniform(low=0, high=100, size=(9,3,1)), 2, dtype=np.int64)
    OpArgMngr.add_workload('full_like', np.random.uniform(low=0, high=100, size=(9,3)), _np.nan)
    OpArgMngr.add_workload('full_like', np.random.uniform(low=0, high=100, size=(2,0)), 0, dtype=np.float32)


def _add_workload_outer():
    OpArgMngr.add_workload('outer', np.ones((5)), np.ones((2)))


def _add_workload_kron():
    OpArgMngr.add_workload('kron', np.ones((5)), np.ones((2)))
    OpArgMngr.add_workload('kron', np.arange(16).reshape((4,4)), np.ones((4,4)))
    OpArgMngr.add_workload('kron', np.ones((2,4)), np.zeros((2,4)))
    OpArgMngr.add_workload('kron', np.ones(()), np.ones(()))


def _add_workload_meshgrid():
    OpArgMngr.add_workload('meshgrid', np.array([1, 2, 3]))
    OpArgMngr.add_workload('meshgrid', np.array([1, 2, 3]), np.array([4, 5, 6, 7]))
    OpArgMngr.add_workload('meshgrid', np.array([1, 2, 3]), np.array([4, 5, 6, 7]), indexing='ij')


def _add_workload_abs():
    OpArgMngr.add_workload('abs', np.random.uniform(size=(11,)).astype(np.float32))
    OpArgMngr.add_workload('abs', np.random.uniform(size=(5,)).astype(np.float64))
    OpArgMngr.add_workload('abs', np.array([_np.inf, -_np.inf, _np.nan]))


def _add_workload_fabs():
    OpArgMngr.add_workload('fabs', np.random.uniform(size=(11,)).astype(np.float32))
    OpArgMngr.add_workload('fabs', np.random.uniform(size=(5,)).astype(np.float64))
    OpArgMngr.add_workload('fabs', np.array([_np.inf, -_np.inf, _np.nan]))


def _add_workload_add(array_pool):
    OpArgMngr.add_workload('add', array_pool['4x1'], array_pool['1x2'])
    OpArgMngr.add_workload('add', array_pool['4x1'], 2)
    OpArgMngr.add_workload('add', 2, array_pool['4x1'])
    OpArgMngr.add_workload('add', array_pool['4x1'], array_pool['1x1x0'])


def _add_workload_arctan2():
    OpArgMngr.add_workload('arctan2', np.array([1, -1, 1]), np.array([1, 1, -1]))
    OpArgMngr.add_workload('arctan2', np.array([np.PZERO, np.NZERO]), np.array([np.NZERO, np.NZERO]))
    OpArgMngr.add_workload('arctan2', np.array([np.PZERO, np.NZERO]), np.array([np.PZERO, np.PZERO]))
    OpArgMngr.add_workload('arctan2', np.array([np.PZERO, np.NZERO]), np.array([-1, -1]))
    OpArgMngr.add_workload('arctan2', np.array([np.PZERO, np.NZERO]), np.array([1, 1]))
    OpArgMngr.add_workload('arctan2', np.array([-1, -1]), np.array([np.PZERO, np.NZERO]))
    OpArgMngr.add_workload('arctan2', np.array([1, 1]), np.array([np.PZERO, np.NZERO]))
    OpArgMngr.add_workload('arctan2', np.array([1, -1, 1, -1]), np.array([-_np.inf, -_np.inf, _np.inf, _np.inf]))
    OpArgMngr.add_workload('arctan2', np.array([_np.inf, -_np.inf]), np.array([1, 1]))
    OpArgMngr.add_workload('arctan2', np.array([_np.inf, -_np.inf]), np.array([-_np.inf, -_np.inf]))
    OpArgMngr.add_workload('arctan2', np.array([_np.inf, -_np.inf]), np.array([_np.inf, _np.inf]))


def _add_workload_copysign():
    OpArgMngr.add_workload('copysign', np.array([1, 0, 0]), np.array([-1, -1, 1]))
    OpArgMngr.add_workload('copysign', np.array([-2, 5, 1, 4, 3], dtype=np.float16), np.array([0, 1, 2, 4, 2], dtype=np.float16))


def _add_workload_degrees():
    OpArgMngr.add_workload('degrees', np.array(np.pi))
    OpArgMngr.add_workload('degrees', np.array(-0.5*np.pi))


def _add_workload_true_divide():
    for dt in [np.float32, np.float64, np.float16]:
        OpArgMngr.add_workload('true_divide', np.array([10, 10, -10, -10], dt), np.array([20, -20, 20, -20], dt))


def _add_workload_inner():
    OpArgMngr.add_workload('inner', np.zeros(shape=(1, 80), dtype=np.float64), np.zeros(shape=(1, 80), dtype=np.float64))
    for dt in [np.float32, np.float64]:
        # OpArgMngr.add_workload('inner', np.array(3, dtype=dt)[()], np.array([1, 2], dtype=dt))
        # OpArgMngr.add_workload('inner', np.array([1, 2], dtype=dt), np.array(3, dtype=dt)[()])
        A = np.array([[1, 2], [3, 4]], dtype=dt)
        B = np.array([[1, 3], [2, 4]], dtype=dt)
        C = np.array([1, 1], dtype=dt)
        OpArgMngr.add_workload('inner', A.T, C)
        OpArgMngr.add_workload('inner', C, A.T)
        OpArgMngr.add_workload('inner', B, C)
        OpArgMngr.add_workload('inner', C, B)
        OpArgMngr.add_workload('inner', A, B)
        OpArgMngr.add_workload('inner', A, A)
        OpArgMngr.add_workload('inner', A, A.copy())
        a = np.arange(5).astype(dt)
        b = a[::-1]
        OpArgMngr.add_workload('inner', b, a)
        a = np.arange(24).reshape(2,3,4).astype(dt)
        b = np.arange(24, 48).reshape(2,3,4).astype(dt)
        OpArgMngr.add_workload('inner', a, b)
        OpArgMngr.add_workload('inner', b, a)


def _add_workload_insert():
    a = np.arange(10)
    OpArgMngr.add_workload('insert', a, 0, np.array([0]))
    OpArgMngr.add_workload('insert', a, np.array([], dtype=np.int64), np.array([]))
    OpArgMngr.add_workload('insert', a, np.array([0, 1], dtype=np.int64), np.array([1, 2]))
    OpArgMngr.add_workload('insert', a, slice(1, 2), np.array([1, 2]))
    OpArgMngr.add_workload('insert', a, slice(1, -2, -1), np.array([]))
    OpArgMngr.add_workload('insert', np.array([0, 1, 2]), np.array([1, 1, 1], dtype=np.int64), np.array([3, 4, 5]))
    OpArgMngr.add_workload('insert', np.array(1), 0, np.array([0]))


def _add_workload_interp():
    xp0 = np.linspace(0, 1, 5)
    fp0 = np.linspace(0, 1, 5)
    x0 = np.linspace(0, 1, 50)
    xp1 = np.array([1, 2, 3, 4])
    fp1 = np.array([1, 2, _np.inf, 4])
    x1 = np.array([1, 2, 2.5, 3, 4])
    xp2 = np.arange(0, 10, 0.0001)
    fp2 = np.sin(xp2)
    xp3 = np.array([190, -190, 350, -350])
    fp3 = np.array([5, 10, 3, 4])
    x3 = np.array([-180, -170, -185, 185, -10, -5, 0, 365])

    OpArgMngr.add_workload('interp', x0, xp0, fp0)
    OpArgMngr.add_workload('interp', x1, xp1, fp1)
    OpArgMngr.add_workload('interp', np.pi, xp2, fp2)
    OpArgMngr.add_workload('interp', x3, xp3, fp3, period=360)
    for size in range(1, 10):
        xp = np.arange(size, dtype=np.float64)
        fp = np.ones(size, dtype=np.float64)
        incpts = np.array([-1, 0, size - 1, size], dtype=np.float64)
        decpts = incpts[::-1]
        OpArgMngr.add_workload('interp', incpts, xp, fp)
        OpArgMngr.add_workload('interp', decpts, xp, fp)
        OpArgMngr.add_workload('interp', incpts, xp, fp, left=0)
        OpArgMngr.add_workload('interp', decpts, xp, fp, left=0)
        OpArgMngr.add_workload('interp', incpts, xp, fp, right=2)
        OpArgMngr.add_workload('interp', decpts, xp, fp, right=2)
        OpArgMngr.add_workload('interp', incpts, xp, fp, left=0, right=2)
        OpArgMngr.add_workload('interp', decpts, xp, fp, left=0, right=2)


def _add_workload_hypot():
    OpArgMngr.add_workload('hypot', np.array(1), np.array(1))
    OpArgMngr.add_workload('hypot', np.array(0), np.array(0))
    OpArgMngr.add_workload('hypot', np.array(_np.nan), np.array(_np.nan))
    OpArgMngr.add_workload('hypot', np.array(_np.nan), np.array(1))
    OpArgMngr.add_workload('hypot', np.array(_np.nan), np.array(_np.inf))
    OpArgMngr.add_workload('hypot', np.array(_np.inf), np.array(_np.nan))
    OpArgMngr.add_workload('hypot', np.array(_np.inf), np.array(0))
    OpArgMngr.add_workload('hypot', np.array(0), np.array(_np.inf))
    OpArgMngr.add_workload('hypot', np.array(_np.inf), np.array(_np.inf))
    OpArgMngr.add_workload('hypot', np.array(_np.inf), np.array(23.0))


def _add_workload_lcm():
    OpArgMngr.add_workload('lcm', np.array([12, 120], dtype=np.int8), np.array([20, 200], dtype=np.int8))
    OpArgMngr.add_workload('lcm', np.array([12, 120], dtype=np.uint8), np.array([20, 200], dtype=np.uint8))
    OpArgMngr.add_workload('lcm', np.array(195225786*2, dtype=np.int32), np.array(195225786*5, dtype=np.int32))


def _add_workload_gcd():
    OpArgMngr.add_workload('gcd', np.array([24, 30], dtype=np.int8), np.array([20, 75], dtype=np.int8))
    OpArgMngr.add_workload('gcd', np.array([24, 30], dtype=np.uint8), np.array([20, 75], dtype=np.uint8))
    OpArgMngr.add_workload('gcd', np.array(195225786*2, dtype=np.int32), np.array(195225786*5, dtype=np.int32))


def _add_workload_bitwise_or():
    OpArgMngr.add_workload('bitwise_or', np.array([False, False, True, True], dtype=bool),
                           np.array([False, True, False, True], dtype=bool))
    for dtype in [np.int8, np.int32, np.int64]:
        zeros = np.array([0], dtype=dtype)
        ones = np.array([-1], dtype=dtype)
        OpArgMngr.add_workload('bitwise_or', zeros, zeros)
        OpArgMngr.add_workload('bitwise_or', ones, zeros)
        OpArgMngr.add_workload('bitwise_or', zeros, ones)
        OpArgMngr.add_workload('bitwise_or', ones, ones)


def _add_workload_bitwise_and():
    OpArgMngr.add_workload('bitwise_and', np.array([False, False, True, True], dtype=bool),
                           np.array([False, True, False, True], dtype=bool))
    for dtype in [np.int8, np.int32, np.int64]:
        zeros = np.array([0], dtype=dtype)
        ones = np.array([-1], dtype=dtype)
        OpArgMngr.add_workload('bitwise_and', zeros, zeros)
        OpArgMngr.add_workload('bitwise_and', ones, zeros)
        OpArgMngr.add_workload('bitwise_and', zeros, ones)
        OpArgMngr.add_workload('bitwise_and', ones, ones)


def _add_workload_bitwise_xor():
    OpArgMngr.add_workload('bitwise_xor', np.array([False, False, True, True], dtype=bool),
                           np.array([False, True, False, True], dtype=bool))
    for dtype in [np.int8, np.int32, np.int64]:
        zeros = np.array([0], dtype=dtype)
        ones = np.array([-1], dtype=dtype)
        OpArgMngr.add_workload('bitwise_xor', zeros, zeros)
        OpArgMngr.add_workload('bitwise_xor', ones, zeros)
        OpArgMngr.add_workload('bitwise_xor', zeros, ones)
        OpArgMngr.add_workload('bitwise_xor', ones, ones)


def _add_workload_bitwise_left_shift():
    for dtype in [np.int8, np.int32, np.int64]:
        twenty = np.array([20], dtype=dtype)
        three = np.array([3], dtype=dtype)
        OpArgMngr.add_workload('bitwise_left_shift', twenty, three)
        OpArgMngr.add_workload('bitwise_left_shift', twenty, three)
        OpArgMngr.add_workload('bitwise_left_shift', twenty, three)
        OpArgMngr.add_workload('bitwise_left_shift', twenty, three)
    OpArgMngr.add_workload('bitwise_left_shift', np.array([9223372036854775807], np.int64), np.array([1], np.int64))
    OpArgMngr.add_workload('bitwise_left_shift', np.array([-9223372036854775808], np.int64), np.array([1], np.int64))


def _add_workload_bitwise_right_shift():
    for dtype in [np.int8, np.int32, np.int64]:
        twenty = np.array([20], dtype=dtype)
        three = np.array([3], dtype=dtype)
        OpArgMngr.add_workload('bitwise_right_shift', twenty, three)
        OpArgMngr.add_workload('bitwise_right_shift', twenty, three)
        OpArgMngr.add_workload('bitwise_right_shift', twenty, three)
        OpArgMngr.add_workload('bitwise_right_shift', twenty, three)
    OpArgMngr.add_workload('bitwise_right_shift', np.array([9223372036854775807], np.int64), np.array([1], np.int64))
    OpArgMngr.add_workload('bitwise_right_shift', np.array([-9223372036854775808], np.int64), np.array([1], np.int64))


def _add_workload_ldexp():
    OpArgMngr.add_workload('ldexp', np.array(2., np.float32), np.array(3, np.int8))
    OpArgMngr.add_workload('ldexp', np.array(2., np.float64), np.array(3, np.int8))
    OpArgMngr.add_workload('ldexp', np.array(2., np.float32), np.array(3, np.int32))
    OpArgMngr.add_workload('ldexp', np.array(2., np.float64), np.array(3, np.int32))
    OpArgMngr.add_workload('ldexp', np.array(2., np.float32), np.array(3, np.int64))
    OpArgMngr.add_workload('ldexp', np.array(2., np.float64), np.array(3, np.int64))
    OpArgMngr.add_workload('ldexp', np.array(2., np.float64), np.array(9223372036854775807, np.int64))
    OpArgMngr.add_workload('ldexp', np.array(2., np.float64), np.array(-9223372036854775808, np.int64))


def _add_workload_logaddexp(array_pool):
    OpArgMngr.add_workload('logaddexp', array_pool['4x1'], array_pool['1x2'])
    OpArgMngr.add_workload('logaddexp', array_pool['4x1'], 2)
    OpArgMngr.add_workload('logaddexp', 2, array_pool['4x1'])
    OpArgMngr.add_workload('logaddexp', array_pool['4x1'], array_pool['1x1x0'])


def _add_workload_subtract(array_pool):
    OpArgMngr.add_workload('subtract', array_pool['4x1'], array_pool['1x2'])
    OpArgMngr.add_workload('subtract', array_pool['4x1'], 2)
    OpArgMngr.add_workload('subtract', 2, array_pool['4x1'])
    OpArgMngr.add_workload('subtract', array_pool['4x1'], array_pool['1x1x0'])


def _add_workload_multiply(array_pool):
    OpArgMngr.add_workload('multiply', array_pool['4x1'], array_pool['1x2'])
    OpArgMngr.add_workload('multiply', array_pool['4x1'], 2)
    OpArgMngr.add_workload('multiply', 2, array_pool['4x1'])
    OpArgMngr.add_workload('multiply', array_pool['4x1'], array_pool['1x1x0'])


def _add_workload_power(array_pool):
    OpArgMngr.add_workload('power', array_pool['4x1'], array_pool['1x2'])
    OpArgMngr.add_workload('power', array_pool['4x1'], 2)
    OpArgMngr.add_workload('power', 2, array_pool['4x1'])
    OpArgMngr.add_workload('power', array_pool['4x1'], array_pool['1x1x0'])
    OpArgMngr.add_workload('power', np.array([1, 2, 3], np.int32), 2.00001)
    OpArgMngr.add_workload('power', np.array([15, 15], np.int64), np.array([15, 15], np.int64))
    OpArgMngr.add_workload('power', 0, np.arange(1, 10))


def _add_workload_mod(array_pool):
    OpArgMngr.add_workload('mod', array_pool['4x1'], array_pool['1x2'])
    OpArgMngr.add_workload('mod', array_pool['4x1'], 2)
    OpArgMngr.add_workload('mod', 2, array_pool['4x1'])
    OpArgMngr.add_workload('mod', array_pool['4x1'], array_pool['1x1x0'])


def _add_workload_fmod(array_pool):
    OpArgMngr.add_workload('fmod', array_pool['4x1'], array_pool['1x2'])
    OpArgMngr.add_workload('fmod', array_pool['4x1'], 2)
    OpArgMngr.add_workload('fmod', 2, array_pool['4x1'])
    OpArgMngr.add_workload('fmod', array_pool['4x1'], array_pool['1x1x0'])


def _add_workload_floor_divide(array_pool):
    OpArgMngr.add_workload('floor_divide', array_pool['4x1'], array_pool['1x2'])
    OpArgMngr.add_workload('floor_divide', array_pool['4x1'], 2)
    OpArgMngr.add_workload('floor_divide', 2, array_pool['4x1'])
    OpArgMngr.add_workload('floor_divide', array_pool['4x1'], array_pool['1x1x0'])
    OpArgMngr.add_workload('floor_divide', np.array([-1, -2, -3], np.float32), 1.9999)
    OpArgMngr.add_workload('floor_divide', np.array([1000, -200, -3], np.int64), 3)
    OpArgMngr.add_workload('floor_divide', np.array([1, -2, -3, 4, -5], np.int32), 2.0001)
    OpArgMngr.add_workload('floor_divide', np.array([1, -50, -0.2, 40000, 0], np.float64), -7)


def _add_workload_remainder():
    # test remainder basic
    OpArgMngr.add_workload('remainder', np.array([0, 1, 2, 4, 2], dtype=np.float16),
                           np.array([-2, 5, 1, 4, 3], dtype=np.float16))

    def _signs(dt):
        if dt in [np.uint8]:
            return (+1,)
        else:
            return (+1, -1)

    for ct in _DTYPES:
        for sg1, sg2 in itertools.product(_signs(ct), _signs(ct)):
            a = np.array(sg1*71, dtype=ct)
            b = np.array(sg2*19, dtype=ct)
            OpArgMngr.add_workload('remainder', a, b)

    # test remainder exact
    nlst = list(range(-127, 0))
    plst = list(range(1, 128))
    dividend = nlst + [0] + plst
    divisor = nlst + plst
    arg = list(itertools.product(dividend, divisor))
    tgt = list(divmod(*t) for t in arg)
    a, b = np.array(arg, dtype=int).T
    # convert exact integer results from Python to float so that
    # signed zero can be used, it is checked.
    for dt in [np.float16, np.float32, np.float64]:
        fa = a.astype(dt)
        fb = b.astype(dt)
        OpArgMngr.add_workload('remainder', fa, fb)

    # test_float_remainder_roundoff
    for ct in _FLOAT_DTYPES:
        for sg1, sg2 in itertools.product((+1, -1), (+1, -1)):
            a = np.array(sg1*78*6e-8, dtype=ct)
            b = np.array(sg2*6e-8, dtype=ct)
            OpArgMngr.add_workload('remainder', a, b)

    # test_float_remainder_corner_cases
    # Check remainder magnitude.
    for ct in _FLOAT_DTYPES:
        b = _np.array(1.0, dtype=ct)
        a = np.array(_np.nextafter(_np.array(0.0, dtype=ct), -b), dtype=ct)
        b = np.array(b, dtype=ct)
        OpArgMngr.add_workload('remainder', a, b)
        OpArgMngr.add_workload('remainder', -a, -b)

    # Check nans, inf
    for ct in [np.float16, np.float32, np.float64]:
        fone = np.array(1.0, dtype=ct)
        fzer = np.array(0.0, dtype=ct)
        finf = np.array(_np.inf, dtype=ct)
        fnan = np.array(_np.nan, dtype=ct)
        # OpArgMngr.add_workload('remainder', fone, fzer)  # failed
        OpArgMngr.add_workload('remainder', fone, fnan)
        OpArgMngr.add_workload('remainder', finf, fone)


def _add_workload_maximum(array_pool):
    OpArgMngr.add_workload('maximum', array_pool['4x1'], array_pool['1x2'])
    OpArgMngr.add_workload('maximum', array_pool['4x1'], 2)
    OpArgMngr.add_workload('maximum', 2, array_pool['4x1'])
    OpArgMngr.add_workload('maximum', array_pool['4x1'], array_pool['1x1x0'])


def _add_workload_fmax(array_pool):
    OpArgMngr.add_workload('fmax', array_pool['4x1'], array_pool['1x2'])
    OpArgMngr.add_workload('fmax', array_pool['4x1'], 2)
    OpArgMngr.add_workload('fmax', 2, array_pool['4x1'])
    OpArgMngr.add_workload('fmax', array_pool['4x1'], array_pool['1x1x0'])


def _add_workload_minimum(array_pool):
    OpArgMngr.add_workload('minimum', array_pool['4x1'], array_pool['1x2'])
    OpArgMngr.add_workload('minimum', array_pool['4x1'], 2)
    OpArgMngr.add_workload('minimum', 2, array_pool['4x1'])
    OpArgMngr.add_workload('minimum', array_pool['4x1'], array_pool['1x1x0'])


def _add_workload_fmin(array_pool):
    OpArgMngr.add_workload('fmin', array_pool['4x1'], array_pool['1x2'])
    OpArgMngr.add_workload('fmin', array_pool['4x1'], 2)
    OpArgMngr.add_workload('fmin', 2, array_pool['4x1'])
    OpArgMngr.add_workload('fmin', array_pool['4x1'], array_pool['1x1x0'])


def _add_workload_negative(array_pool):
    OpArgMngr.add_workload('negative', array_pool['4x1'])


def _add_workload_absolute(array_pool):
    OpArgMngr.add_workload('absolute', array_pool['4x1'])


def _add_workload_sign(array_pool):
    OpArgMngr.add_workload('sign', array_pool['4x1'])
    OpArgMngr.add_workload('sign', np.array([-2, 5, 1, 4, 3], dtype=np.float16))
    OpArgMngr.add_workload('sign', np.array([-.1, 0, .1]))
    # OpArgMngr.add_workload('sign', np.array(_np.array([_np.nan]))) # failed


def _add_workload_exp(array_pool):
    OpArgMngr.add_workload('exp', array_pool['4x1'])


def _add_workload_log(array_pool):
    OpArgMngr.add_workload('log', array_pool['4x1'])


def _add_workload_log2(array_pool):
    OpArgMngr.add_workload('log2', array_pool['4x1'])
    OpArgMngr.add_workload('log2', np.array(2.**65))
    OpArgMngr.add_workload('log2', np.array(_np.inf))
    OpArgMngr.add_workload('log2', np.array(1.))


def _add_workload_log1p():
    OpArgMngr.add_workload('log1p', np.array(-1.))
    OpArgMngr.add_workload('log1p', np.array(_np.inf))
    OpArgMngr.add_workload('log1p', np.array(1e-6))


def _add_workload_log10(array_pool):
    OpArgMngr.add_workload('log10', array_pool['4x1'])


def _add_workload_sqrt():
    OpArgMngr.add_workload('sqrt', np.array([1, np.PZERO, np.NZERO, _np.inf, _np.nan]))


def _add_workload_square():
    OpArgMngr.add_workload('square', np.array([-2, 5, 1, 4, 3], dtype=np.float16))


def _add_workload_cbrt():
    OpArgMngr.add_workload('cbrt', np.array(-2.5**3, dtype=np.float32))
    OpArgMngr.add_workload('cbrt', np.array([1., 2., -3., _np.inf, -_np.inf])**3)
    OpArgMngr.add_workload('cbrt', np.array([_np.inf, -_np.inf, _np.nan]))


def _add_workload_reciprocal():
    for ctype in [np.float16, np.float32, np.float64]:
        OpArgMngr.add_workload('reciprocal', np.array([-2, 5, 1, 4, 3], dtype=ctype))
        OpArgMngr.add_workload('reciprocal', np.array([-2, 0, 1, 0, 3], dtype=ctype))
        OpArgMngr.add_workload('reciprocal', np.array([0], dtype=ctype))


def _add_workload_sin(array_pool):
    OpArgMngr.add_workload('sin', array_pool['4x1'])


def _add_workload_cos(array_pool):
    OpArgMngr.add_workload('cos', array_pool['4x1'])


def _add_workload_tan(array_pool):
    OpArgMngr.add_workload('tan', array_pool['4x1'])


def _add_workload_sinh(array_pool):
    OpArgMngr.add_workload('sinh', array_pool['4x1'])


def _add_workload_cosh(array_pool):
    OpArgMngr.add_workload('cosh', array_pool['4x1'])


def _add_workload_tanh(array_pool):
    OpArgMngr.add_workload('tanh', array_pool['4x1'])


def _add_workload_arcsin(array_pool):
    OpArgMngr.add_workload('arcsin', array_pool['4x1'] - 2)


def _add_workload_arccos(array_pool):
    OpArgMngr.add_workload('arccos', array_pool['4x1'] - 2)


def _add_workload_arctan(array_pool):
    OpArgMngr.add_workload('arctan', array_pool['4x1'])


def _add_workload_arcsinh(array_pool):
    OpArgMngr.add_workload('arcsinh', array_pool['4x1'])


def _add_workload_arccosh(array_pool):
    OpArgMngr.add_workload('arccosh', array_pool['4x1'])


def _add_workload_arctanh(array_pool):
    OpArgMngr.add_workload('arctanh', array_pool['4x1'] - 2)


def _add_workload_ceil(array_pool):
    OpArgMngr.add_workload('ceil', array_pool['4x1'])


def _add_workload_turnc(array_pool):
    OpArgMngr.add_workload('trunc', array_pool['4x1'])


def _add_workload_floor(array_pool):
    OpArgMngr.add_workload('floor', array_pool['4x1'])


def _add_workload_logical_not(array_pool):
    OpArgMngr.add_workload('logical_not', np.ones(10, dtype=np.int32))
    OpArgMngr.add_workload('logical_not', array_pool['4x1'])
    OpArgMngr.add_workload('logical_not', np.array([True, False, True, False], dtype=bool))


def _add_workload_bitwise_not():
    OpArgMngr.add_workload('bitwise_not', np.array([True, False, True, False], dtype=bool))
    for dtype in [np.int8, np.int32, np.int64]:
        zeros = np.array([0], dtype=dtype)
        ones = np.array([-1], dtype=dtype)
        OpArgMngr.add_workload('bitwise_not', zeros)
        OpArgMngr.add_workload('bitwise_not', ones)


def _add_workload_invert():
    OpArgMngr.add_workload('invert', np.array([True, False, True, False], dtype=bool))
    for dtype in [np.int8, np.int32, np.int64]:
        zeros = np.array([0], dtype=dtype)
        ones = np.array([-1], dtype=dtype)
        OpArgMngr.add_workload('invert', zeros)
        OpArgMngr.add_workload('invert', ones)


def _add_workload_vdot():
    OpArgMngr.add_workload('vdot', np.random.normal(size=(2, 4)), np.random.normal(size=(4, 2)))
    OpArgMngr.add_workload('vdot', np.random.normal(size=(2, 4)).astype(np.float64), np.random.normal(size=(2, 4)).astype(np.float64))


def _add_workload_matmul():
    OpArgMngr.add_workload('matmul', np.random.normal(size=(2, 4)), np.random.normal(size=(4, 2)))
    dtype = [np.float32, np.float64]
    def test_shapes():
        dims = [((1, 1), (2, 1, 1)),     # broadcast first argument
                ((2, 1, 1), (1, 1)),     # broadcast second argument
                ((2, 1, 1), (2, 1, 1)),  # matrix stack sizes match
                ]
        for dt, (dm1, dm2) in itertools.product(dtype, dims):
            a = np.ones(dm1, dtype=dt)
            b = np.ones(dm2, dtype=dt)
            OpArgMngr.add_workload('matmul', a, b)
        # vector vector returns scalars.
        for dt in dtype:
            a = np.ones((2,), dtype=dt)
            b = np.ones((2,), dtype=dt)
            OpArgMngr.add_workload('matmul', a, b)

    def test_result_types():
        mat = np.ones((1,1))
        vec = np.ones((1,))
        for dt in dtype:
            m = mat.astype(dt)
            v = vec.astype(dt)
            for arg in [(m, v), (v, m), (m, m)]:
                OpArgMngr.add_workload('matmul', *arg)

    def test_scalar_output():
        vec1 = np.array([2])
        vec2 = np.array([3, 4]).reshape(1, -1)
        for dt in dtype:
            v1 = vec1.astype(dt)
            v2 = vec2.astype(dt)
            OpArgMngr.add_workload('matmul', v1, v2)
            OpArgMngr.add_workload('matmul', v2.T, v1)

    def test_vector_vector_values():
        vec1 = np.array([1, 2])
        vec2 = np.array([3, 4]).reshape(-1, 1)
        for dt in dtype:
            v1 = vec1.astype(dt)
            v2 = vec2.astype(dt)
            OpArgMngr.add_workload('matmul', v1, v2)
            # no broadcast, we must make v1 into a 2d ndarray
            OpArgMngr.add_workload('matmul', v2, v1.reshape(1, -1))

    def test_vector_matrix_values():
        vec = np.array([1, 2])
        mat1 = np.array([[1, 2], [3, 4]])
        mat2 = np.stack([mat1]*2, axis=0)
        for dt in dtype:
            v = vec.astype(dt)
            m1 = mat1.astype(dt)
            m2 = mat2.astype(dt)
            OpArgMngr.add_workload('matmul', v, m1)
            OpArgMngr.add_workload('matmul', v, m2)

    def test_matrix_vector_values():
        vec = np.array([1, 2])
        mat1 = np.array([[1, 2], [3, 4]])
        mat2 = np.stack([mat1]*2, axis=0)
        for dt in dtype:
            v = vec.astype(dt)
            m1 = mat1.astype(dt)
            m2 = mat2.astype(dt)
            OpArgMngr.add_workload('matmul', m1, v)
            OpArgMngr.add_workload('matmul', m2, v)

    def test_matrix_matrix_values():
        mat1 = np.array([[1, 2], [3, 4]])
        mat2 = np.array([[1, 0], [1, 1]])
        mat12 = np.stack([mat1, mat2], axis=0)
        mat21 = np.stack([mat2, mat1], axis=0)
        for dt in dtype:
            m1 = mat1.astype(dt)
            m2 = mat2.astype(dt)
            m12 = mat12.astype(dt)
            m21 = mat21.astype(dt)
            # matrix @ matrix
            OpArgMngr.add_workload('matmul', m1, m2)
            OpArgMngr.add_workload('matmul', m2, m1)
            # stacked @ matrix
            OpArgMngr.add_workload('matmul', m12, m1)
            # matrix @ stacked
            OpArgMngr.add_workload('matmul', m1, m12)
            # stacked @ stacked
            OpArgMngr.add_workload('matmul', m12, m21)

    test_shapes()
    test_result_types()
    test_scalar_output()
    test_vector_vector_values()
    test_vector_matrix_values()
    test_matrix_vector_values()
    test_matrix_matrix_values()


def _add_workload_vstack(array_pool):
    OpArgMngr.add_workload('vstack', (array_pool['4x1'], np.random.uniform(size=(5, 1))))
    OpArgMngr.add_workload('vstack', array_pool['4x1'])
    OpArgMngr.add_workload('vstack', array_pool['1x1x0'])


def _add_workload_column_stack():
    OpArgMngr.add_workload('column_stack', (np.array([1, 2, 3]), np.array([2, 3, 4])))
    OpArgMngr.add_workload('column_stack', (np.array([[1], [2], [3]]), np.array([[2], [3], [4]])))
    OpArgMngr.add_workload('column_stack', [np.array(_np.arange(3)) for _ in range(2)])


def _add_workload_hstack(array_pool):
    OpArgMngr.add_workload('hstack', (np.random.uniform(size=(1, 4)), np.random.uniform(size=(1, 4))))
    OpArgMngr.add_workload('hstack', array_pool['4x1'])
    OpArgMngr.add_workload('hstack', array_pool['1x1x0'])


def _add_workload_dstack(array_pool):
    OpArgMngr.add_workload('dstack', (np.random.uniform(size=(5, 1, 2)), np.random.uniform(size=(5, 1, 3))))
    OpArgMngr.add_workload('dstack', array_pool['4x1'])
    OpArgMngr.add_workload('dstack', array_pool['1x1x0'])


def _add_workload_equal(array_pool):
    # TODO(junwu): fp16 does not work yet with TVM generated ops
    # OpArgMngr.add_workload('equal', np.array([0, 1, 2, 4, 2], dtype=np.float16), np.array([-2, 5, 1, 4, 3], dtype=np.float16))
    OpArgMngr.add_workload('equal', np.array([0, 1, 2, 4, 2], dtype=np.float32), np.array([-2, 5, 1, 4, 3], dtype=np.float32))
    # TODO(junwu): mxnet currently does not have a consistent behavior as NumPy in dealing with _np.nan
    # OpArgMngr.add_workload('equal', np.array([_np.nan]), np.array([_np.nan]))
    OpArgMngr.add_workload('equal', array_pool['4x1'], array_pool['1x2'])


def _add_workload_not_equal(array_pool):
    # TODO(junwu): fp16 does not work yet with TVM generated ops
    # OpArgMngr.add_workload('not_equal', np.array([0, 1, 2, 4, 2], dtype=np.float16), np.array([-2, 5, 1, 4, 3], dtype=np.float16))
    OpArgMngr.add_workload('not_equal', np.array([0, 1, 2, 4, 2], dtype=np.float32), np.array([-2, 5, 1, 4, 3], dtype=np.float32))
    # TODO(junwu): mxnet currently does not have a consistent behavior as NumPy in dealing with _np.nan
    # OpArgMngr.add_workload('not_equal', np.array([_np.nan]), np.array([_np.nan]))
    OpArgMngr.add_workload('not_equal', array_pool['4x1'], array_pool['1x2'])


def _add_workload_greater(array_pool):
    # TODO(junwu): fp16 does not work yet with TVM generated ops
    # OpArgMngr.add_workload('greater', np.array([0, 1, 2, 4, 2], dtype=np.float16), np.array([-2, 5, 1, 4, 3], dtype=np.float16))
    OpArgMngr.add_workload('greater', np.array([0, 1, 2, 4, 2], dtype=np.float32), np.array([-2, 5, 1, 4, 3], dtype=np.float32))
    OpArgMngr.add_workload('greater', array_pool['4x1'], array_pool['1x2'])
    OpArgMngr.add_workload('greater', array_pool['4x1'], 2)
    OpArgMngr.add_workload('greater', 2, array_pool['4x1'])
    # TODO(junwu): mxnet currently does not have a consistent behavior as NumPy in dealing with _np.nan
    # OpArgMngr.add_workload('greater', np.array([_np.nan]), np.array([_np.nan]))


def _add_workload_greater_equal(array_pool):
    # TODO(junwu): fp16 does not work yet with TVM generated ops
    # OpArgMngr.add_workload('greater_equal', np.array([0, 1, 2, 4, 2], dtype=np.float16), np.array([-2, 5, 1, 4, 3], dtype=np.float16))
    OpArgMngr.add_workload('greater_equal', np.array([0, 1, 2, 4, 2], dtype=np.float32), np.array([-2, 5, 1, 4, 3], dtype=np.float32))
    OpArgMngr.add_workload('greater_equal', array_pool['4x1'], array_pool['1x2'])
    OpArgMngr.add_workload('greater_equal', array_pool['4x1'], 2)
    OpArgMngr.add_workload('greater_equal', 2, array_pool['4x1'])
    # TODO(junwu): mxnet currently does not have a consistent behavior as NumPy in dealing with _np.nan
    # OpArgMngr.add_workload('greater_equal', np.array([_np.nan]), np.array([_np.nan]))


def _add_workload_less(array_pool):
    # TODO(junwu): fp16 does not work yet with TVM generated ops
    # OpArgMngr.add_workload('less', np.array([0, 1, 2, 4, 2], dtype=np.float16), np.array([-2, 5, 1, 4, 3], dtype=np.float16))
    OpArgMngr.add_workload('less', np.array([0, 1, 2, 4, 2], dtype=np.float32), np.array([-2, 5, 1, 4, 3], dtype=np.float32))
    OpArgMngr.add_workload('less', array_pool['4x1'], array_pool['1x2'])
    OpArgMngr.add_workload('less', array_pool['4x1'], 2)
    OpArgMngr.add_workload('less', 2, array_pool['4x1'])
    # TODO(junwu): mxnet currently does not have a consistent behavior as NumPy in dealing with _np.nan
    # OpArgMngr.add_workload('less', np.array([_np.nan]), np.array([_np.nan]))


def _add_workload_less_equal(array_pool):
    # TODO(junwu): fp16 does not work yet with TVM generated ops
    # OpArgMngr.add_workload('less_equal', np.array([0, 1, 2, 4, 2], dtype=np.float16), np.array([-2, 5, 1, 4, 3], dtype=np.float16))
    OpArgMngr.add_workload('less_equal', np.array([0, 1, 2, 4, 2], dtype=np.float32), np.array([-2, 5, 1, 4, 3], dtype=np.float32))
    OpArgMngr.add_workload('less_equal', array_pool['4x1'], array_pool['1x2'])
    OpArgMngr.add_workload('less_equal', array_pool['4x1'], 2)
    OpArgMngr.add_workload('less_equal', 2, array_pool['4x1'])
    # TODO(junwu): mxnet currently does not have a consistent behavior as NumPy in dealing with _np.nan
    # OpArgMngr.add_workload('less_equal', np.array([_np.nan]), np.array([_np.nan]))


def _add_workload_logical_and(array_pool):
    OpArgMngr.add_workload('logical_and', np.array([0, 1, 2, 4, 2], dtype=np.float32), np.array([-2, 5, 1, 4, 3], dtype=np.float32))
    OpArgMngr.add_workload('logical_and', np.array([False, False, True, True], dtype=bool),
                           np.array([False, True, False, True], dtype=bool))

def _add_workload_logical_or(array_pool):
    OpArgMngr.add_workload('logical_or', np.array([0, 1, 2, 4, 2], dtype=bool), np.array([-2, 5, 1, 4, 3], dtype=bool))
    OpArgMngr.add_workload('logical_or', np.array([False, False, True, True], dtype=bool),
                           np.array([False, True, False, True], dtype=bool))


def _add_workload_logical_xor(array_pool):
    OpArgMngr.add_workload('logical_xor', np.array([0, 1, 2, 4, 2], dtype=np.float32), np.array([-2, 5, 1, 4, 3], dtype=np.float32))
    OpArgMngr.add_workload('logical_xor', np.array([False, False, True, True], dtype=bool),
                           np.array([False, True, False, True], dtype=bool))


def _add_workload_where():
    c = np.ones(53).astype(bool)
    d = np.ones_like(c)
    e = np.zeros_like(c)
    OpArgMngr.add_workload('where', c, e, e)
    OpArgMngr.add_workload('where', c, d, e)
    OpArgMngr.add_workload('where', c, d, e[0])
    OpArgMngr.add_workload('where', c, d[0], e)
    # OpArgMngr.add_workload('where', c[::2], d[::2], e[::2])
    # OpArgMngr.add_workload('where', c[1::2], d[1::2], e[1::2])
    # OpArgMngr.add_workload('where', c[::3], d[::3], e[::3])
    # OpArgMngr.add_workload('where', c[1::3], d[1::3], e[1::3])
    # OpArgMngr.add_workload('where', c[::-2], d[::-2], e[::-2])
    # OpArgMngr.add_workload('where', c[::-3], d[::-3], e[::-3])
    # OpArgMngr.add_workload('where', c[1::-3], d[1::-3], e[1::-3])
    c = np.array([True, False])
    a = np.zeros((2, 25))
    b = np.ones((2, 25))
    OpArgMngr.add_workload('where', c.reshape((2, 1)), a, b)
    OpArgMngr.add_workload('where', c, a.T, b.T)


def _add_workload_pad():
    array = _np.array([[1, 2, 3], [1, 2, 3]])
    pad_width = ((5, 5), (5,5))
    array = np.array(array)
    OpArgMngr.add_workload('pad', array, pad_width, mode="constant", constant_values=0)
    OpArgMngr.add_workload('pad', array, pad_width, mode="edge")
    OpArgMngr.add_workload('pad', array, pad_width, mode="symmetric", reflect_type="even")
    OpArgMngr.add_workload('pad', array, pad_width, mode="reflect", reflect_type="even")
    OpArgMngr.add_workload('pad', array, pad_width, mode="maximum")
    OpArgMngr.add_workload('pad', array, pad_width, mode="minimum")


def _add_workload_nonzero():
    OpArgMngr.add_workload('nonzero', np.random.randint(0, 2))
    OpArgMngr.add_workload('nonzero', np.random.randint(0, 2, size=()))
    OpArgMngr.add_workload('nonzero', np.random.randint(0, 2, size=(0, 1, 2)))
    OpArgMngr.add_workload('nonzero', np.random.randint(0, 2, size=(0, 1, 0)))
    OpArgMngr.add_workload('nonzero', np.random.randint(0, 2, size=(2, 3, 4)))
    OpArgMngr.add_workload('nonzero', np.array([False, False, False], dtype=np.bool_))
    OpArgMngr.add_workload('nonzero', np.array([True, False, False], dtype=np.bool_))


def _add_workload_diagflat():
    def get_mat(n):
        data = _np.arange(n)
        data = _np.add.outer(data,data)
        return data

    A = np.array([[1,2],[3,4],[5,6]])
    vals = (100 * np.arange(5)).astype('l')
    vals_c = (100 * np.array(get_mat(5)) + 1).astype('l')
    vals_f = _np.array((100 * get_mat(5) + 1), order='F', dtype='l')
    vals_f = np.array(vals_f)

    OpArgMngr.add_workload('diagflat', A, k=2)
    OpArgMngr.add_workload('diagflat', A, k=1)
    OpArgMngr.add_workload('diagflat', A, k=0)
    OpArgMngr.add_workload('diagflat', A, k=-1)
    OpArgMngr.add_workload('diagflat', A, k=-2)
    OpArgMngr.add_workload('diagflat', A, k=-3)
    OpArgMngr.add_workload('diagflat', vals, k=0)
    OpArgMngr.add_workload('diagflat', vals, k=2)
    OpArgMngr.add_workload('diagflat', vals, k=-2)
    OpArgMngr.add_workload('diagflat', vals_c, k=0)
    OpArgMngr.add_workload('diagflat', vals_c, k=2)
    OpArgMngr.add_workload('diagflat', vals_c, k=-2)
    OpArgMngr.add_workload('diagflat', vals_f, k=0)
    OpArgMngr.add_workload('diagflat', vals_f, k=2)
    OpArgMngr.add_workload('diagflat', vals_f, k=-2)


def _add_workload_shape():
    OpArgMngr.add_workload('shape', np.random.uniform(size=()))
    OpArgMngr.add_workload('shape', np.random.uniform(size=(0, 1)))
    OpArgMngr.add_workload('shape', np.random.uniform(size=(2, 3)))


def _add_workload_diff():
    x = np.array([1, 4, 6, 7, 12])
    OpArgMngr.add_workload('diff', x)
    OpArgMngr.add_workload('diff', x, 2)
    OpArgMngr.add_workload('diff', x, 3)
    OpArgMngr.add_workload('diff', np.array([1.1, 2.2, 3.0, -0.2, -0.1]))
    x = np.zeros((10, 20, 30))
    x[:, 1::2, :] = 1
    OpArgMngr.add_workload('diff', x)
    OpArgMngr.add_workload('diff', x, axis=-1)
    OpArgMngr.add_workload('diff', x, axis=0)
    OpArgMngr.add_workload('diff', x, axis=1)
    OpArgMngr.add_workload('diff', x, axis=-2)
    x = 20 * np.random.uniform(size=(10,20,30))
    OpArgMngr.add_workload('diff', x)
    OpArgMngr.add_workload('diff', x, n=2)
    OpArgMngr.add_workload('diff', x, axis=0)
    OpArgMngr.add_workload('diff', x, n=2, axis=0)
    x = np.array([list(range(3))])
    for n in range(1, 5):
        OpArgMngr.add_workload('diff', x, n=n)


def _add_workload_ediff1d():
    x = np.array([1, 3, 6, 7, 1])
    OpArgMngr.add_workload('ediff1d', x)
    OpArgMngr.add_workload('ediff1d', x, 2, 4)
    OpArgMngr.add_workload('ediff1d', x, x, 3)
    OpArgMngr.add_workload('ediff1d', x, x, x)
    OpArgMngr.add_workload('ediff1d', np.array([1.1, 2.2, 3.0, -0.2, -0.1]))
    x = np.random.randint(5, size=(5, 0, 4))
    OpArgMngr.add_workload('ediff1d', x)
    OpArgMngr.add_workload('ediff1d', x, 2, 4)
    OpArgMngr.add_workload('ediff1d', x, x, 3)
    OpArgMngr.add_workload('ediff1d', x, x, x)

def _add_workload_resize():
    OpArgMngr.add_workload('resize', np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]], dtype=np.int32), (5, 1))
    OpArgMngr.add_workload('resize', np.eye(3), 3)
    OpArgMngr.add_workload('resize', np.ones(1), ())
    OpArgMngr.add_workload('resize', np.ones(()), (1,))
    OpArgMngr.add_workload('resize', np.eye(3), (3, 2, 1))
    OpArgMngr.add_workload('resize', np.eye(3), (2, 3, 3))
    OpArgMngr.add_workload('resize', np.ones(10), 15)
    OpArgMngr.add_workload('resize', np.zeros((10, 0)), (0, 10))
    OpArgMngr.add_workload('resize', np.zeros((10, 0)), (0, 100))


def _add_workload_empty_like():
    OpArgMngr.add_workload('empty_like', np.random.uniform(low=0, high=100, size=(1,3,4), dtype='float64'))
    OpArgMngr.add_workload('empty_like', np.random.uniform(low=0, high=100, size=(9,3,1)), np.int32)
    OpArgMngr.add_workload('empty_like', np.random.uniform(low=0, high=100, size=(9,3)), 'float32')
    OpArgMngr.add_workload('empty_like', np.random.uniform(low=0, high=100, size=(9,3,1)), np.bool_)
    OpArgMngr.add_workload('empty_like', np.random.uniform(low=0, high=100, size=(0,3)), np.float32)


def _add_workload_nan_to_num():
    array1 = np.array([[-433, 0, 456, _np.inf], [-1, -_np.inf, 0, 1]])
    array2 = np.array([_np.nan, _np.inf, -_np.inf, -574, 0, 23425, 24234,-5])
    array3 = np.array(-_np.inf)
    OpArgMngr.add_workload('nan_to_num', array1, True, 0, 100, -100)
    OpArgMngr.add_workload('nan_to_num', array1, True, 0.00)
    OpArgMngr.add_workload('nan_to_num', array2, True)
    OpArgMngr.add_workload('nan_to_num', array2, True, -2000, 10000, -10000)
    OpArgMngr.add_workload('nan_to_num', array3, True)


def _add_workload_isnan(array_pool):
    OpArgMngr.add_workload('isnan', array_pool['2x4'])


def _add_workload_isinf(array_pool):
    OpArgMngr.add_workload('isinf', array_pool['2x4'])


def _add_workload_isposinf(array_pool):
    OpArgMngr.add_workload('isposinf', array_pool['2x4'])


def _add_workload_isneginf(array_pool):
    OpArgMngr.add_workload('isneginf', array_pool['2x4'])


def _add_workload_isfinite(array_pool):
    OpArgMngr.add_workload('isfinite', array_pool['2x4'])


def _add_workload_polyval():
    p1 = np.arange(20)
    p2 = np.arange(1)
    x1 = np.arange(20)
    x2 = np.ones((3,3))
    x3 = np.array(2)
    OpArgMngr.add_workload('polyval', p1, x1)
    OpArgMngr.add_workload('polyval', p1, x2)
    OpArgMngr.add_workload('polyval', p1, x3)
    OpArgMngr.add_workload('polyval', p2, x1)
    OpArgMngr.add_workload('polyval', p2, x2)
    OpArgMngr.add_workload('polyval', p2, x3)


def _add_workload_linalg_cond():
    A = np.array([[1., 0, 1], [0, -2., 0], [0, 0, 3.]])
    OpArgMngr.add_workload('linalg.cond', A, _np.inf)
    OpArgMngr.add_workload('linalg.cond', A, -_np.inf)
    OpArgMngr.add_workload('linalg.cond', A, 1)
    OpArgMngr.add_workload('linalg.cond', A, -1)
    OpArgMngr.add_workload('linalg.cond', A, 'fro')


def _add_workload_linalg_matrix_power():
    i = np.array([[0, 1], [-1, 0]])
    OpArgMngr.add_workload('linalg.matrix_power', i, 3)


def _add_workload_linalg_matrix_rank():
    shapes = [
        ((4, 3), ()),
        ((4, 3), (1,)),
        ((4, 3), (2, 3,)),
        ((2, 1, 1), (1,)),
        ((2, 3, 3), (2,)),
        ((2, 3, 1, 1), ()),
        ((2, 3, 4, 4), (1, 3)),
        ((2, 3, 4, 5), (2, 3)),
        ((2, 3, 5, 4), (2, 3)),
    ]
    dtypes = (np.float32, np.float64)
    for dtype in dtypes:
        for a_shape, tol_shape in shapes:
            for tol_is_none in [True, False]:
                a_np = _np.asarray(_np.random.uniform(-10., 10., a_shape))
                a = np.array(a_np, dtype=dtype)
                if tol_is_none:
                    OpArgMngr.add_workload('linalg.matrix_rank', a, None, False)
                else:
                    tol_np = _np.random.uniform(10., 20., tol_shape)
                    tol = np.array(tol_np, dtype=dtype)
                    OpArgMngr.add_workload('linalg.matrix_rank', a, tol, False)


def _add_workload_linalg_multi_dot():
    E = np.ones((4,6,6))
    F = np.ones((6,6))
    OpArgMngr.add_workload('linalg.multi_dot', E)
    OpArgMngr.add_workload('linalg.multi_dot', [F,F])


def _add_workload_heaviside():
    x = np.array([[-30.0, -0.1, 0.0, 0.2], [7.5, _np.nan, _np.inf, -_np.inf]], dtype=np.float64)
    OpArgMngr.add_workload('heaviside', x, 0.5)
    OpArgMngr.add_workload('heaviside', x, 1.0)

    x = x.astype(np.float32)
    OpArgMngr.add_workload('heaviside', x, _np.float32(0.5))
    OpArgMngr.add_workload('heaviside', x, _np.float32(1.0))


def _add_workload_spacing():
    OpArgMngr.add_workload('spacing', _np.float64(1))
    OpArgMngr.add_workload('spacing', _np.float32(1))
    OpArgMngr.add_workload('spacing', _np.inf)
    OpArgMngr.add_workload('spacing', -_np.inf)
    OpArgMngr.add_workload('spacing', _np.float64(1e30))
    OpArgMngr.add_workload('spacing', _np.float32(1e30))


def _add_workload_allclose():
    a = np.random.randn(10)
    b = a + np.random.rand(10) * 1e-6
    c = [1e10,1e-7]
    d = [1.00001e10,1e10,1e-7]
    OpArgMngr.add_workload('allclose', a, b)
    # OpArgMngr.add_workload('allclose', c, d)


def _add_workload_alltrue():
    for i in range(256-7):
        e = np.array([True] * 256, dtype=bool)[7::]
        e[i] = False
        OpArgMngr.add_workload('alltrue', e)
    # big array test for blocked libc loops
    for i in list(range(9, 6000, 507)) + [7764, 90021, -10]:
        e = np.array([True] * 100043, dtype=bool)
        e[i] = False
        OpArgMngr.add_workload('alltrue', e)


def _add_workload_apply_along_axis():
    def double(row):
        return row * 2

    m = np.array([[0, 1], [2, 3]], dtype=np.int32)
    OpArgMngr.add_workload('apply_along_axis', double, 0, m)
    OpArgMngr.add_workload('apply_along_axis', double, 1, m)


def _add_workload_apply_over_axes():
    a = np.arange(24).reshape(2, 3, 4)
    OpArgMngr.add_workload('apply_over_axes', _np.sum, a, [0, 2])


def _add_workload_argpartition():
    # TODO: move more test cases from numpy to here
    OpArgMngr.add_workload('argpartition', np.array([]), 0, kind='introselect')
    OpArgMngr.add_workload('argpartition', np.ones(1), 0, kind='introselect')
    for r in ([2, 1], [1, 2], [1, 1], [3, 2, 1], [1, 2, 3], [2, 1, 3], [2, 3, 1],
              [1, 1, 1], [1, 2, 2], [2, 2, 1], [1, 2, 1]):
        d = np.array(r)
        OpArgMngr.add_workload('argpartition', d, 0, kind='introselect')


def _add_workload_argwhere():
    a = np.arange(6).reshape((2, 3))
    b = np.array([4, 0, 2, 1, 3])
    OpArgMngr.add_workload('argwhere', a>1)
    OpArgMngr.add_workload('argwhere', b)


def _add_workload_array_equal():
    a = np.array([1, 2])
    b = np.array([1, 2, 3])
    c = np.array([3, 4])
    d = np.array([1, 3])
    OpArgMngr.add_workload('array_equal', a, a)
    OpArgMngr.add_workload('array_equal', a, b)
    OpArgMngr.add_workload('array_equal', a, c)
    OpArgMngr.add_workload('array_equal', a, d)


def _add_workload_array_equiv():
    a = np.array([1, 2])
    b = np.array([1, 2, 3])
    c = np.array([3, 4])
    d = np.array([1, 3])
    e = np.array([2])
    f = np.array([[1], [2]])
    g = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
    OpArgMngr.add_workload('array_equiv', a, a)
    OpArgMngr.add_workload('array_equiv', a, b)
    OpArgMngr.add_workload('array_equiv', a, c)
    OpArgMngr.add_workload('array_equiv', a, d)
    OpArgMngr.add_workload('array_equiv', a, e)
    OpArgMngr.add_workload('array_equiv', a, f)
    OpArgMngr.add_workload('array_equiv', a, g)


def _add_workload_choose():
    a = np.array([[1, 0, 1], [0, 1, 0], [1, 0, 1]], dtype=np.int64)
    choices = np.array([-10, 10])
    OpArgMngr.add_workload('choose', a, choices)


def _add_workload_compress():
    a = np.array([[1, 2], [3, 4], [5, 6]])
    b = np.array([0, 1])
    c = np.array([False, True, True])
    d = np.array([False, True])
    OpArgMngr.add_workload('compress', b, a, axis=0)
    OpArgMngr.add_workload('compress', c, a, axis=0)
    OpArgMngr.add_workload('compress', d, a, axis=1)


def _add_workload_corrcoef():
    a = np.array([0, 1, 0])
    b = np.array([1, 0, 1])
    c = np.array(
        [[0.15391142, 0.18045767, 0.14197213],
         [0.70461506, 0.96474128, 0.27906989],
         [0.9297531, 0.32296769, 0.19267156]])
    OpArgMngr.add_workload('corrcoef', a, b)
    OpArgMngr.add_workload('corrcoef', c)


def _add_workload_correlate():
    x = np.array([1, 2, 3, 4, 5])
    xs = np.arange(1, 20)[::3]
    y = np.array([-1, -2, -3])
    OpArgMngr.add_workload('correlate', x, y)
    OpArgMngr.add_workload('correlate', x, y, 'full')
    OpArgMngr.add_workload('correlate', x, y[:-1], 'full')
    OpArgMngr.add_workload('correlate', x[::-1], y, 'full')
    OpArgMngr.add_workload('correlate', xs, y, 'full')
    OpArgMngr.add_workload('correlate', x, y,"same")


def _add_workload_count_nonzero():
    m = np.array([[0, 1, 7, 0, 0], [3, 0, 0, 2, 19]])
    a = np.array([])
    b = np.eye(3)
    OpArgMngr.add_workload('count_nonzero', m, axis=0)
    OpArgMngr.add_workload('count_nonzero', m, axis=1)
    OpArgMngr.add_workload('count_nonzero', a)
    OpArgMngr.add_workload('count_nonzero', b)


def _add_workload_cov():
    x = np.array(np.random.rand(12))
    y = x.reshape(3, 4)
    OpArgMngr.add_workload('cov', x)
    OpArgMngr.add_workload('cov', x, rowvar=False)
    OpArgMngr.add_workload('cov', x, rowvar=False, bias=True)
    OpArgMngr.add_workload('cov', y)
    OpArgMngr.add_workload('cov', y, y[::-1])
    OpArgMngr.add_workload('cov', y, rowvar=False)
    OpArgMngr.add_workload('cov', y, rowvar=False, bias=True)


def _add_workload_cumprod():
    a = np.array([[1, 2], [3, 5]])
    OpArgMngr.add_workload('cumprod', a)
    OpArgMngr.add_workload('cumprod', a, axis=0)
    OpArgMngr.add_workload('cumprod', a, axis=1)


def _add_workload_digitize():
    a = np.array([1, 2, 3, 4])
    b = np.array([1, 3])
    c = np.array([0, 1, 2, 3, 4])
    e = [1, 3]
    OpArgMngr.add_workload('digitize', a, b)
    OpArgMngr.add_workload('digitize', b, c)
    OpArgMngr.add_workload('digitize', a, e)


def _add_workload_divmod():
    a = [0., 1., 2., 3., 4.]
    OpArgMngr.add_workload('divmod', a, 3)


def _add_workload_extract():
    arr = np.arange(12).reshape((3, 4))
    condition = np.array([[ True, False, False,  True],  # np.mod(arr, 3)==0
                          [False, False,  True, False],
                          [False,  True, False, False]])
    OpArgMngr.add_workload('extract', condition, arr)


def _add_workload_flatnonzero(array_pool):
    x = np.array([-2, -1,  0,  1,  2])
    OpArgMngr.add_workload('flatnonzero', array_pool['4x1'])
    OpArgMngr.add_workload('flatnonzero', array_pool['1x2'])
    OpArgMngr.add_workload('flatnonzero', x)


def _add_workload_float_power():
    x1 = np.array([1, 2, 3, 4, 5, 6])
    x2 = np.array([1.0, 2.0, 3.0, 3.0, 2.0, 1.0])
    x3 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]])
    OpArgMngr.add_workload('float_power', x1, 3)
    OpArgMngr.add_workload('float_power', x1, x2)
    OpArgMngr.add_workload('float_power', x1, x3)


def _add_workload_frexp():
    x = np.arange(9)
    OpArgMngr.add_workload('frexp', x)


def _add_workload_histogram2d():
    x = np.array([0.41702200, 0.72032449, 1.1437481e-4, 0.302332573, 0.146755891])
    y = np.array([0.09233859, 0.18626021, 0.34556073, 0.39676747, 0.53881673])
    xedges = np.linspace(0, 1, 10)
    yedges = np.linspace(0, 1, 10)
    OpArgMngr.add_workload('histogram2d', x, y, (xedges, yedges))
    OpArgMngr.add_workload('histogram2d', x, y, xedges)
    OpArgMngr.add_workload('histogram2d', list(range(10)), list(range(10)))


def _add_workload_histogram_bin_edges():
    a = [1, 2, 3, 4]
    b = [1, 2]
    arr = np.array([0.,  0.,  0.,  1.,  2.,  3.,  3.,  4.,  5.])
    # OpArgMngr.add_workload('histogram_bin_edges', a, b)
    OpArgMngr.add_workload('histogram_bin_edges', arr, bins=30, range=(-0.5, 5))
    OpArgMngr.add_workload('histogram_bin_edges', arr, bins='auto', range=(0, 1))


def _add_workload_histogramdd():
    x = np.array([[-.5, .5, 1.5], [-.5, 1.5, 2.5], [-.5, 2.5, .5],
                      [.5,  .5, 1.5], [.5,  1.5, 2.5], [.5,  2.5, 2.5]])
    ed = [[-2, 0, 2], [0, 1, 2, 3], [0, 1, 2, 3]]
    z = [np.squeeze(y) for y in np.split(x, 3, axis=1)]
    OpArgMngr.add_workload('histogramdd', x, (2, 3, 3), range=[[-1, 1], [0, 3], [0, 3]])
    OpArgMngr.add_workload('histogramdd', x, bins=ed, density=True)
    OpArgMngr.add_workload('histogramdd', x, (2, 3, 4), range=[[-1, 1], [0, 3], [0, 4]],
                                          density=True)
    OpArgMngr.add_workload('histogramdd', z, bins=(4, 3, 2),
                                          range=[[-2, 2], [0, 3], [0, 2]])


def _add_workload_i0():
    a = 0
    b = np.array([2, 3, 4])
    # OpArgMngr.add_workload('i0', a)
    OpArgMngr.add_workload('i0', b)


def _add_workload_in1d():
    test = np.array([0, 1, 2, 5, 0])
    states = [0, 2]
    OpArgMngr.add_workload('in1d', test, states)
    OpArgMngr.add_workload('in1d', test, states, invert=True)


def _add_workload_interp():
    x = np.linspace(0, 1, 5)
    y = np.linspace(0, 1, 5)
    x0 = np.linspace(0, 1, 50)
    x1 = 0
    x2 = .3
    x3 = _np.float32(.3)
    OpArgMngr.add_workload('interp', x0, x, y)
    OpArgMngr.add_workload('interp', x1, x, y)
    OpArgMngr.add_workload('interp', x2, x, y)
    OpArgMngr.add_workload('interp', x3, x, y)
    x = np.array([1, 2, 2.5, 3, 4])
    xp = np.array([1, 2, 3, 4])
    fp = np.array([1, 2, _np.inf, 4])
    OpArgMngr.add_workload('interp', x, xp, fp)


def _add_workload_intersect1d():
    a = np.array([5, 7, 1, 2])
    b = np.array([2, 4, 3, 1, 5])
    c = np.array([[2, 4, 5, 6, 6], [4, 7, 8, 7, 2]])
    d = np.array([[3, 2, 7, 7], [10, 12, 8, 7]])
    OpArgMngr.add_workload('intersect1d', a, b, assume_unique=True)
    OpArgMngr.add_workload('intersect1d', a, b)
    OpArgMngr.add_workload('intersect1d', a, b, assume_unique=True,
                                                return_indices=True)
    OpArgMngr.add_workload('intersect1d', c, d)


def _add_workload_isclose():
    a = np.array([1e10,1e-7])
    b = np.array([1.00001e10,1e-8])
    c = np.array([1.0, _np.nan])
    d = np.array([0.0, 0.0])
    e = np.array([1e-100, 1e-7])
    OpArgMngr.add_workload('isclose', a, b)
    OpArgMngr.add_workload('isclose', c, c)
    OpArgMngr.add_workload('isclose', c, c, equal_nan=True)
    OpArgMngr.add_workload('isclose', d, e, atol=0.0)


def _add_workload_isin():
    element = 2*np.arange(4).reshape((2, 2))
    test_elements = [1, 2, 4, 8]
    test_set = {1, 2, 4, 8}
    OpArgMngr.add_workload('isin', element, test_elements)
    OpArgMngr.add_workload('isin', element, test_elements, invert=True)
    OpArgMngr.add_workload('isin', element, list(test_set))


def _add_workload_ix_():
    a = np.array([0, 1])
    b = np.array([True, True])
    c = np.array([2, 4])
    d = np.array([False, False, True, False, True])
    OpArgMngr.add_workload('ix_', a, c)
    OpArgMngr.add_workload('ix_', b, c)
    OpArgMngr.add_workload('ix_', b, d)


def _add_workload_lexsort():
    a = np.array([1,5,1,4,3,4,4])
    b = np.array([9,4,0,4,0,2,1])
    OpArgMngr.add_workload('lexsort', (a, b))


def _add_workload_min_scalar_type():
    a = 10
    OpArgMngr.add_workload('min_scalar_type', a)


def _add_workload_mirr():
    val = np.array([-4500, -800, 800, 800, 600, 600, 800, 800, 700, 3000])
    OpArgMngr.add_workload('mirr', val, 0.08, 0.055)


def _add_workload_modf():
    a = np.array([0, 3.5])
    b = -0.5
    OpArgMngr.add_workload('modf', a)
    OpArgMngr.add_workload('modf', b)


def _add_workload_msort():
    A = np.array([[0.44567325, 0.79115165, 0.54900530],
                  [0.36844147, 0.37325583, 0.96098397],
                  [0.64864341, 0.52929049, 0.39172155]])
    OpArgMngr.add_workload('msort', A)


def _add_workload_nanargmax():
    a = np.array([[_np.nan, 4], [2, 3]])
    OpArgMngr.add_workload('nanargmax', a)
    OpArgMngr.add_workload('nanargmax', a, axis=0)
    OpArgMngr.add_workload('nanargmax', a, axis=1)


def _add_workload_nanargmin():
    a = np.array([[_np.nan, 4], [2, 3]])
    OpArgMngr.add_workload('nanargmin', a)
    OpArgMngr.add_workload('nanargmin', a, axis=0)
    OpArgMngr.add_workload('nanargmin', a, axis=1)


def _add_workload_nancumprod():
    a = np.array([[1, 2], [3, _np.nan]])
    OpArgMngr.add_workload('nancumprod', a)
    OpArgMngr.add_workload('nancumprod', a, axis=0)
    OpArgMngr.add_workload('nancumprod', a, axis=1)


def _add_workload_nancumsum():
    a = np.array([[1, 2], [3, _np.nan]])
    OpArgMngr.add_workload('nancumsum', a)
    OpArgMngr.add_workload('nancumsum', a, axis=0)
    OpArgMngr.add_workload('nancumsum', a, axis=1)


def _add_workload_nanmax():
    a = np.array([[1, 2], [3, _np.nan]])
    OpArgMngr.add_workload('nanmax', a)
    OpArgMngr.add_workload('nanmax', a, axis=0)
    OpArgMngr.add_workload('nanmax', a, axis=1)


def _add_workload_nanmedian():
    a = np.array([[10.0, _np.nan, 4], [3, 2, 1]])
    OpArgMngr.add_workload('nanmedian', a)
    OpArgMngr.add_workload('nanmedian', a, axis=0)
    OpArgMngr.add_workload('nanmedian', a, axis=1)


def _add_workload_nanmin():
    a = np.array([[1, 2], [3, _np.nan]])
    OpArgMngr.add_workload('nanmin', a)
    OpArgMngr.add_workload('nanmin', a, axis=0)
    OpArgMngr.add_workload('nanmin', a, axis=1)


def _add_workload_nanpercentile():
    a = np.array([[10.0, _np.nan, 4], [3, 2, 1]])
    OpArgMngr.add_workload('nanpercentile', a, 50)
    OpArgMngr.add_workload('nanpercentile', a, 50, axis=0)
    OpArgMngr.add_workload('nanpercentile', a, 50, axis=1)
    OpArgMngr.add_workload('nanpercentile', a, 50, axis=1, keepdims=True)
    OpArgMngr.add_workload('nanpercentile', a, 50, interpolation='lower')
    OpArgMngr.add_workload('nanpercentile', a, 50, interpolation='higher')
    OpArgMngr.add_workload('nanpercentile', a, 50, interpolation='midpoint')
    OpArgMngr.add_workload('nanpercentile', a, 50, interpolation='nearest')


def _add_workload_nanprod():
    a = 1
    b = np.array([1, _np.nan])
    c = np.array([[1, 2], [3, _np.nan]])
    OpArgMngr.add_workload('nanprod', a)
    OpArgMngr.add_workload('nanprod', b)
    OpArgMngr.add_workload('nanprod', c)
    OpArgMngr.add_workload('nanprod', c, axis=0)


def _add_workload_nanquantile():
    a = np.array([[10.0, _np.nan, 4], [3, 2, 1]])
    OpArgMngr.add_workload('nanquantile', a, 0.4)
    OpArgMngr.add_workload('nanquantile', a, 0.4, axis=0)
    OpArgMngr.add_workload('nanquantile', a, 0.4, axis=1)
    OpArgMngr.add_workload('nanquantile', a, 0.4, axis=1, keepdims=True)
    OpArgMngr.add_workload('nanquantile', a, 0.4, interpolation='lower')
    OpArgMngr.add_workload('nanquantile', a, 0.4, interpolation='higher')
    OpArgMngr.add_workload('nanquantile', a, 0.4, interpolation='midpoint')
    OpArgMngr.add_workload('nanquantile', a, 0.4, interpolation='nearest')


def _add_workload_nanstd():
    OpArgMngr.add_workload('nanstd', np.random.uniform(size=(4, 1)))
    A = np.array([[1, 2, 3], [4, _np.nan, 6]])
    OpArgMngr.add_workload('nanstd', A)
    OpArgMngr.add_workload('nanstd', A, 0)
    OpArgMngr.add_workload('nanstd', A, 1)
    OpArgMngr.add_workload('nanstd', np.array([1, -1, 1, -1]))
    OpArgMngr.add_workload('nanstd', np.array([1, -1, 1, -1]), ddof=1)
    OpArgMngr.add_workload('nanstd', np.array([1, -1, 1, -1]), ddof=2)
    OpArgMngr.add_workload('nanstd', np.arange(10), out=np.array(0.))


def _add_workload_nansum():
    a = 1
    b = np.array([1, _np.nan])
    c = np.array([[1, 2], [3, _np.nan]])
    OpArgMngr.add_workload('nansum', a)
    OpArgMngr.add_workload('nansum', b)
    OpArgMngr.add_workload('nansum', c)
    OpArgMngr.add_workload('nansum', c, axis=0)


def _add_workload_nanvar():
    OpArgMngr.add_workload('nanvar', np.random.uniform(size=(4, 1)))
    A = np.array([[1, 2, 3], [4, _np.nan, 6]])
    OpArgMngr.add_workload('nanvar', A)
    OpArgMngr.add_workload('nanvar', A, 0)
    OpArgMngr.add_workload('nanvar', A, 1)
    OpArgMngr.add_workload('nanvar', np.array([1, -1, 1, -1]))
    OpArgMngr.add_workload('nanvar', np.array([1, -1, 1, -1]), ddof=1)
    OpArgMngr.add_workload('nanvar', np.array([1, -1, 1, -1]), ddof=2)
    OpArgMngr.add_workload('nanvar', np.arange(10), out=np.array(0.))


def _add_workload_ndim():
    a = 1
    b = np.array([[1,2,3],[4,5,6]])
    OpArgMngr.add_workload('ndim', a)
    OpArgMngr.add_workload('ndim', b)


def _add_workload_npv():
    rate, cashflows = 0.281, np.array([-100, 39, 59, 55, 20])
    OpArgMngr.add_workload('npv', rate, cashflows)


def _add_workload_partition():
    a = np.array([3, 4, 2, 1])
    OpArgMngr.add_workload('partition', a, 3)
    OpArgMngr.add_workload('partition', a, (2,3))  #


def _add_workload_piecewise():
    a = np.array([0, 0])
    b = np.array([1, 0])
    c = np.array([1])
    x = np.linspace(-2.5, 2.5, 6)
    y = np.array([[ True,  True,  True, False, False, False],
                  [False, False, False,  True,  True,  True]])
    z = np.array([-1, 1])
    OpArgMngr.add_workload('piecewise', a, b, c)
    OpArgMngr.add_workload('piecewise', x, y, z)


def _add_workload_packbits():
    a = np.array([[[1, 0, 1], [0, 1, 0]],
                  [[1, 1, 0], [0, 0, 1]]], dtype = np.int64)
    OpArgMngr.add_workload('packbits', a)
    OpArgMngr.add_workload('packbits', a, axis=-1)
    OpArgMngr.add_workload('packbits', a, bitorder='little')


def _add_workload_pmt():
    OpArgMngr.add_workload('pmt', 0.1 / 12, 1, 60, 55000)


def _add_workload_poly():
    a = np.array([3, -np.sqrt(2), np.sqrt(2)])
    b = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 0]])
    OpArgMngr.add_workload('poly', a)
    OpArgMngr.add_workload('poly', b)


def _add_workload_polyadd():
    a = np.array([1, 2])
    b = np.array([9, 5, 4])
    OpArgMngr.add_workload('polyadd', a, b)


def _add_workload_polydiv():
    x = np.array([3.0, 5.0, 2.0])
    y = np.array([2.0, 1.0])
    OpArgMngr.add_workload('polydiv', x, y)


def _add_workload_polyfit():
    x = np.array([0.0, 1.0, 2.0, 3.0,  4.0,  5.0])
    y = np.array([0.0, 0.8, 0.9, 0.1, -0.8, -1.0])
    OpArgMngr.add_workload('polyfit', x, y, 3)


def _add_workload_polyint():
    a = np.array([1,2,3])
    OpArgMngr.add_workload('polyint', a)
    OpArgMngr.add_workload('polyint', a, m=2)


def _add_workload_polymul():
    a = np.array([1, 2, 3])
    b = np.array([9, 5, 4])
    OpArgMngr.add_workload('polymul', a, b)


def _add_workload_polysub():
    a = np.array([1, 2, 3])
    b = np.array([9, 5, 4])
    OpArgMngr.add_workload('polysub', a, b)


def _add_workload_positive(array_pool):
    OpArgMngr.add_workload('positive', array_pool['4x1'])


def _add_workload_ppmt():
    OpArgMngr.add_workload('ppmt', 0.1 / 12, 1, 60, 55000)


def _add_workload_promote_types():
    OpArgMngr.add_workload('promote_types', np.float16, np.float64)


def _add_workload_ptp():
    x = np.arange(4).reshape((2,2))
    OpArgMngr.add_workload('ptp', x)
    OpArgMngr.add_workload('ptp', x, axis=0)
    OpArgMngr.add_workload('ptp', x, axis=1)
    OpArgMngr.add_workload('ptp', x, keepdims=True)


def _add_workload_pv():
    a = np.array((0.05, 0.04, 0.03))/12
    OpArgMngr.add_workload('pv', 0.05/12, 10*12, -100, 15692.93)
    OpArgMngr.add_workload('pv', a, 10*12, -100, 15692.93)


def _add_workload_rate():
    OpArgMngr.add_workload('rate', 10, 0, -3500, 10000)


def _add_workload_real():
    a = np.array([1, 3, 5])
    b = 2
    OpArgMngr.add_workload('real', a)
    OpArgMngr.add_workload('real', b)


def _add_workload_real_if_close():
    a = np.array([1, 3, 5])
    b = 2
    OpArgMngr.add_workload('real_if_close', a)
    OpArgMngr.add_workload('real_if_close', b)
    # OpArgMngr.add_workload('real_if_close', b, tol=1000)


def _add_workload_result_type():
    OpArgMngr.add_workload('result_type', 3.0, 2)


def _add_workload_rollaxis():
    a = np.ones((3,4,5,6))
    OpArgMngr.add_workload('rollaxis', a, 3, 1)
    OpArgMngr.add_workload('rollaxis', a, 2)
    OpArgMngr.add_workload('rollaxis', a, 1, 4)


def _add_workload_roots():
    a = np.array([1,2,1])
    OpArgMngr.add_workload('roots', a)


def _add_workload_searchsorted():
    a = np.array([1,2,3,4,5])
    b = np.array([-10, 10, 2, 3])
    OpArgMngr.add_workload('searchsorted', a, 3)
    OpArgMngr.add_workload('searchsorted', a, 3, side='right')
    OpArgMngr.add_workload('searchsorted', a, b)


def _add_workload_select():
    x = np.arange(10)
    condlist = np.array([[ True,  True,  True, False, False,
                           False, False, False, False, False],
                         [ False, False, False, False, False,
                           False,  True,  True,  True, True]], dtype=bool)
    choicelist = np.array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9],
                           [ 0,  1,  4,  9, 16, 25, 36, 49, 64, 81]])
    OpArgMngr.add_workload('select', condlist, choicelist)


def _add_workload_setdiff1d():
    a = np.array([1, 2, 3, 2, 4, 1])
    b = np.array([3, 4, 5, 6])
    OpArgMngr.add_workload('setdiff1d', a, b)


def _add_workload_setxor1d():
    a = np.array([1, 2, 3, 2, 4])
    b = np.array([2, 3, 5, 7, 5])
    OpArgMngr.add_workload('setxor1d', a, b)


def _add_workload_signbit():
    a = -1.2
    b = np.array([1, -2.3, 2.1])
    OpArgMngr.add_workload('signbit', a)
    OpArgMngr.add_workload('signbit', b)


def _add_workload_size():
    a = np.array([[1,2,3],[4,5,6]])
    OpArgMngr.add_workload('size', a)
    OpArgMngr.add_workload('size', a, 1)
    OpArgMngr.add_workload('size', a, 0)


def _add_workload_take_along_axis():
    a = np.array([[10, 30, 20], [60, 40, 50]])
    ai = np.argsort(a, axis=1)
    OpArgMngr.add_workload('take_along_axis', a, ai, axis=1)


def _add_workload_trapz():
    a = np.array([1,2,3])
    b = np.arange(6).reshape(2, 3)
    x = np.array([4,6,8])
    OpArgMngr.add_workload('trapz', a)
    OpArgMngr.add_workload('trapz', a, x=x)
    OpArgMngr.add_workload('trapz', a, dx=2)
    OpArgMngr.add_workload('trapz', b, axis=1)
    OpArgMngr.add_workload('trapz', b, axis=0)


def _add_workload_tril_indices_from():
    for dt in ['float16', 'float32', 'float64', 'int32', 'int64', 'int8', 'uint8']:
        OpArgMngr.add_workload('tril_indices_from', np.ones((2, 2), dtype=dt))
        arr = np.array([[1, 1, _np.inf],
                        [1, 1, 1],
                        [_np.inf, 1, 1]])
        OpArgMngr.add_workload('tril_indices_from', arr)
        OpArgMngr.add_workload('tril_indices_from', np.zeros((3, 3), dtype=dt))


def _add_workload_trim_zeros():
    a = np.array((0, 0, 0, 1, 2, 3, 0, 2, 1, 0))
    OpArgMngr.add_workload('trim_zeros', a)
    OpArgMngr.add_workload('trim_zeros', a, 'b')


def _add_workload_triu_indices_from():
    a  =np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
    OpArgMngr.add_workload('triu_indices_from', a, -1)


def _add_workload_union1d():
    a = np.array([5, 4, 7, 1, 2])
    b = np.array([2, 4, 3, 3, 2, 1, 5])
    x = np.array([[0, 1, 2], [3, 4, 5]])
    y = np.array([0, 1, 2, 3, 4])
    OpArgMngr.add_workload('union1d', a, b)
    OpArgMngr.add_workload('union1d', x, y)


def _add_workload_unpackbits():
    a = np.array([[2], [7], [23]], dtype=np.uint8)
    OpArgMngr.add_workload('unpackbits', a)
    OpArgMngr.add_workload('unpackbits', a, axis=1)


def _add_workload_unwrap():
    phase = np.linspace(0, np.pi, num=5)
    phase[3:] += np.pi
    phase_s = np.vstack((phase,phase))
    OpArgMngr.add_workload('unwrap', phase)
    OpArgMngr.add_workload('unwrap', phase_s, axis=1)


def _add_workload_vander():
    x = np.array([1, 2, 3, 5])
    OpArgMngr.add_workload('vander', x, 3)
    OpArgMngr.add_workload('vander', x, 3, increasing=True)


@use_np
def _prepare_workloads():
    array_pool = {
        '4x1': np.random.uniform(size=(4, 1)) + 2,
        '2x4': np.array([[    -433, float('inf'), 456, _np.inf, _np.nan],
                         [-_np.inf, float("nan"),  -1,       0, _np.inf]]),
        '1x2': np.random.uniform(size=(1, 2)) + 2,
        '1x1x0': np.array([[[]]])
    }

    _add_workload_all()
    _add_workload_any()
    _add_workload_sometrue()
    _add_workload_argmin()
    _add_workload_argmax()
    _add_workload_around()
    _add_workload_round()
    _add_workload_round_()
    _add_workload_argsort()
    _add_workload_sort()
    _add_workload_append()
    _add_workload_bincount()
    _add_workload_broadcast_arrays(array_pool)
    _add_workload_broadcast_to()
    _add_workload_clip()
    _add_workload_concatenate(array_pool)
    _add_workload_copy()
    _add_workload_cross()
    _add_workload_cumsum()
    _add_workload_ravel()
    _add_workload_unravel_index()
    _add_workload_diag_indices_from()
    _add_workload_diag()
    _add_workload_diagonal()
    _add_workload_diagflat()
    _add_workload_dot()
    _add_workload_matmul()
    _add_workload_expand_dims()
    _add_workload_fix()
    _add_workload_flip()
    _add_workload_flipud()
    _add_workload_fliplr()
    _add_workload_max(array_pool)
    _add_workload_amax(array_pool)
    _add_workload_min(array_pool)
    _add_workload_amin(array_pool)
    _add_workload_mean(array_pool)
    _add_workload_nonzero()
    _add_workload_ones_like(array_pool)
    _add_workload_atleast_nd()
    _add_workload_prod(array_pool)
    _add_workload_product(array_pool)
    _add_workload_repeat(array_pool)
    _add_workload_reshape()
    _add_workload_rint(array_pool)
    _add_workload_roll()
    _add_workload_split()
    _add_workload_array_split()
    _add_workload_hsplit()
    _add_workload_vsplit()
    _add_workload_dsplit()
    _add_workload_squeeze()
    _add_workload_stack(array_pool)
    _add_workload_std()
    _add_workload_sum()
    _add_workload_swapaxes()
    _add_workload_take()
    _add_workload_tensordot()
    _add_workload_tile()
    _add_workload_transpose()
    _add_workload_unique()
    _add_workload_delete()
    _add_workload_var(array_pool)
    _add_workload_zeros_like(array_pool)
    _add_workload_linalg_norm()
    _add_workload_linalg_cholesky()
    _add_workload_linalg_qr()
    _add_workload_linalg_inv()
    _add_workload_linalg_solve()
    _add_workload_linalg_det()
    _add_workload_linalg_tensorinv()
    _add_workload_linalg_tensorsolve()
    _add_workload_linalg_lstsq()
    _add_workload_linalg_pinv()
    _add_workload_linalg_eigvals()
    _add_workload_linalg_eig()
    _add_workload_linalg_eigvalsh()
    _add_workload_linalg_eigh()
    _add_workload_linalg_slogdet()
    _add_workload_linalg_cond()
    _add_workload_linalg_matrix_power()
    _add_workload_linalg_matrix_rank()
    _add_workload_linalg_multi_dot()
    _add_workload_trace()
    _add_workload_tril()
    _add_workload_triu()
    _add_workload_outer()
    _add_workload_kron()
    _add_workload_meshgrid()
    _add_workload_einsum()
    _add_workload_abs()
    _add_workload_fabs()
    _add_workload_add(array_pool)
    _add_workload_arctan2()
    _add_workload_copysign()
    _add_workload_degrees()
    _add_workload_true_divide()
    _add_workload_inner()
    _add_workload_insert()
    _add_workload_interp()
    _add_workload_hypot()
    _add_workload_lcm()
    _add_workload_gcd()
    _add_workload_bitwise_and()
    _add_workload_bitwise_xor()
    _add_workload_bitwise_or()
    _add_workload_bitwise_left_shift()
    _add_workload_bitwise_right_shift()
    _add_workload_ldexp()
    _add_workload_logaddexp(array_pool)
    _add_workload_subtract(array_pool)
    _add_workload_multiply(array_pool)
    _add_workload_power(array_pool)
    _add_workload_mod(array_pool)
    _add_workload_fmod(array_pool)
    _add_workload_floor_divide(array_pool)
    _add_workload_remainder()
    _add_workload_maximum(array_pool)
    _add_workload_fmax(array_pool)
    _add_workload_minimum(array_pool)
    _add_workload_fmin(array_pool)
    _add_workload_negative(array_pool)
    _add_workload_absolute(array_pool)
    _add_workload_sign(array_pool)
    _add_workload_exp(array_pool)
    _add_workload_log(array_pool)
    _add_workload_log2(array_pool)
    _add_workload_log1p()
    _add_workload_log10(array_pool)
    _add_workload_expm1()
    _add_workload_sqrt()
    _add_workload_square()
    _add_workload_cbrt()
    _add_workload_reciprocal()
    _add_workload_sin(array_pool)
    _add_workload_cos(array_pool)
    _add_workload_tan(array_pool)
    _add_workload_sinh(array_pool)
    _add_workload_cosh(array_pool)
    _add_workload_tanh(array_pool)
    _add_workload_arcsin(array_pool)
    _add_workload_arccos(array_pool)
    _add_workload_arctan(array_pool)
    _add_workload_arcsinh(array_pool)
    _add_workload_arccosh(array_pool)
    _add_workload_arctanh(array_pool)
    _add_workload_ceil(array_pool)
    _add_workload_turnc(array_pool)
    _add_workload_floor(array_pool)
    _add_workload_logical_not(array_pool)
    _add_workload_bitwise_not()
    _add_workload_invert()
    _add_workload_vdot()
    _add_workload_vstack(array_pool)
    _add_workload_column_stack()
    _add_workload_hstack(array_pool)
    _add_workload_dstack(array_pool)
    _add_workload_equal(array_pool)
    _add_workload_not_equal(array_pool)
    _add_workload_greater(array_pool)
    _add_workload_greater_equal(array_pool)
    _add_workload_less(array_pool)
    _add_workload_less_equal(array_pool)
    _add_workload_logical_and(array_pool)
    _add_workload_logical_or(array_pool)
    _add_workload_logical_xor(array_pool)
    _add_workload_where()
    _add_workload_shape()
    _add_workload_diff()
    _add_workload_ediff1d()
    _add_workload_quantile()
    _add_workload_median(array_pool)
    _add_workload_percentile()
    _add_workload_resize()
    _add_workload_full_like(array_pool)
    _add_workload_empty_like()
    _add_workload_nan_to_num()
    _add_workload_polyval()
    _add_workload_isnan(array_pool)
    _add_workload_isinf(array_pool)
    _add_workload_isposinf(array_pool)
    _add_workload_isneginf(array_pool)
    _add_workload_isfinite(array_pool)
    _add_workload_heaviside()
    _add_workload_spacing()
    _add_workload_allclose()
    _add_workload_alltrue()
    _add_workload_apply_along_axis()
    _add_workload_apply_over_axes()
    _add_workload_argpartition()
    _add_workload_argwhere()
    _add_workload_array_equal()
    _add_workload_array_equiv()
    _add_workload_choose()
    _add_workload_compress()
    _add_workload_corrcoef()
    _add_workload_correlate()
    _add_workload_count_nonzero()
    _add_workload_cov()
    _add_workload_cumprod()
    _add_workload_digitize()
    _add_workload_divmod()
    _add_workload_extract()
    _add_workload_flatnonzero(array_pool)
    _add_workload_float_power()
    _add_workload_frexp()
    _add_workload_histogram2d()
    _add_workload_histogram_bin_edges()
    _add_workload_histogramdd()
    _add_workload_i0()
    _add_workload_in1d()
    _add_workload_interp()
    _add_workload_intersect1d()
    _add_workload_isclose()
    _add_workload_isin()
    _add_workload_ix_()
    _add_workload_lexsort()
    _add_workload_min_scalar_type()
    _add_workload_mirr()
    _add_workload_modf()
    _add_workload_msort()
    _add_workload_nanargmax()
    _add_workload_nanargmin()
    _add_workload_nancumprod()
    _add_workload_nancumsum()
    _add_workload_nanmax()
    _add_workload_nanmedian()
    _add_workload_nanmin()
    _add_workload_nanpercentile()
    _add_workload_nanprod()
    _add_workload_nanquantile()
    _add_workload_nanstd()
    _add_workload_nansum()
    _add_workload_nanvar()
    _add_workload_ndim()
    _add_workload_npv()
    _add_workload_packbits()
    _add_workload_pad()
    _add_workload_partition()
    _add_workload_piecewise()
    _add_workload_pmt()
    _add_workload_poly()
    _add_workload_polyadd()
    _add_workload_polydiv()
    _add_workload_polyfit()
    _add_workload_polyint()
    _add_workload_polymul()
    _add_workload_polysub()
    _add_workload_positive(array_pool)
    _add_workload_ppmt()
    _add_workload_promote_types()
    _add_workload_ptp()
    _add_workload_pv()
    _add_workload_rate()
    _add_workload_real()
    _add_workload_real_if_close()
    _add_workload_result_type()
    _add_workload_rollaxis()
    _add_workload_roots()
    _add_workload_searchsorted()
    _add_workload_select()
    _add_workload_setdiff1d()
    _add_workload_setxor1d()
    _add_workload_signbit()
    _add_workload_size()
    _add_workload_take_along_axis()
    _add_workload_trapz()
    _add_workload_tril_indices_from()
    _add_workload_trim_zeros()
    _add_workload_triu_indices_from()
    _add_workload_union1d()
    _add_workload_unpackbits()
    _add_workload_unwrap()
    _add_workload_vander()


def _get_numpy_op_output(onp_op, *args, **kwargs):
    onp_args = [arg.asnumpy() if isinstance(arg, np.ndarray) else arg for arg in args]
    onp_kwargs = {k: v.asnumpy() if isinstance(v, np.ndarray) else v for k, v in kwargs.items()}
    for i, v in enumerate(onp_args):
        if isinstance(v, (list, tuple)):
            new_arrs = [a.asnumpy() if isinstance(a, np.ndarray) else a for a in v]
            onp_args[i] = new_arrs

    return onp_op(*onp_args, **onp_kwargs)


def _check_interoperability_helper(op_name, rel_tol, abs_tol, *args, **kwargs):
    strs = op_name.split('.')
    if len(strs) == 1:
        onp_op = getattr(_np, op_name)
        mxnp_op = getattr(np, op_name)
    elif len(strs) == 2:
        onp_op = getattr(getattr(_np, strs[0]), strs[1])
        mxnp_op = getattr(getattr(np, strs[0]), strs[1])
    else:
        assert False
    if not is_op_runnable():
        return
    out = mxnp_op(*args, **kwargs)
    expected_out = _get_numpy_op_output(onp_op, *args, **kwargs)
    if isinstance(out, (tuple, list)):
        assert type(out) == type(expected_out)
        for arr, expected_arr in zip(out, expected_out):
            if isinstance(arr, np.ndarray):
                assert_almost_equal(arr.asnumpy(), expected_arr, rtol=rel_tol, atol=abs_tol, use_broadcast=False, equal_nan=True)
            else:
                _np.testing.assert_equal(arr, expected_arr)
    elif isinstance(out, np.ndarray):
        assert_almost_equal(out.asnumpy(), expected_out, rtol=rel_tol, atol=abs_tol, use_broadcast=False, equal_nan=True)
    elif isinstance(out, _np.dtype):
        _np.testing.assert_equal(out, expected_out)
    else:
        assert _np.isscalar(out), "{} is not a scalar type".format(str(type(out)))
        if isinstance(out, _np.float):
            _np.testing.assert_almost_equal(out, expected_out)
        else:
            _np.testing.assert_equal(out, expected_out)


def check_interoperability(op_list):
    OpArgMngr.randomize_workloads()
    for name in op_list:
        if name in _TVM_OPS and not is_op_runnable():
            continue
        if name in ['shares_memory', 'may_share_memory', 'empty_like',
                    '__version__', 'dtype', '_NoValue']:  # skip list
            continue
        if name in ['full_like', 'zeros_like', 'ones_like'] and \
                StrictVersion(platform.python_version()) < StrictVersion('3.0.0'):
            continue
        default_tols = (1e-3, 1e-4)
        tols = {'linalg.tensorinv': (1e-2, 5e-3),
                'linalg.solve':     (1e-3, 5e-2)}
        (rel_tol, abs_tol) = tols.get(name, default_tols)
        print('Dispatch test:', name)
        workloads = OpArgMngr.get_workloads(name)
        assert workloads is not None, 'Workloads for operator `{}` has not been ' \
                                      'added for checking interoperability with ' \
                                      'the official NumPy.'.format(name)
        for workload in workloads:
            _check_interoperability_helper(name, rel_tol, abs_tol, *workload['args'], **workload['kwargs'])


@use_np
@with_array_function_protocol
@pytest.mark.serial
def test_np_memory_array_function():
    ops = [_np.shares_memory, _np.may_share_memory]
    for op in ops:
        data_mx = np.zeros([13, 21, 23, 22], dtype=np.float32)
        data_np = _np.zeros([13, 21, 23, 22], dtype=np.float32)
        assert op(data_mx[0,:,:,:], data_mx[1,:,:,:]) == op(data_np[0,:,:,:], data_np[1,:,:,:])
        assert op(data_mx[0,0,0,2:5], data_mx[0,0,0,4:7]) == op(data_np[0,0,0,2:5], data_np[0,0,0,4:7])
        assert op(data_mx, np.ones((5, 0))) == op(data_np, _np.ones((5, 0)))


@use_np
@with_array_function_protocol
@pytest.mark.serial
def test_np_array_function_protocol():
    check_interoperability(_NUMPY_ARRAY_FUNCTION_LIST)


@use_np
@with_array_ufunc_protocol
@pytest.mark.serial
def test_np_array_ufunc_protocol():
    prev_state = util.set_flush_denorms(False)
    try:
        check_interoperability(_NUMPY_ARRAY_UFUNC_LIST)
    finally:
        util.set_flush_denorms(prev_state)


@use_np
@pytest.mark.serial
def test_np_fallback_ops():
    op_list = np.fallback.__all__ + ['linalg.{}'.format(op_name) for op_name in np.fallback_linalg.__all__]
    check_interoperability(op_list)