flopscope.

flopscope.numpy.fromfunction

fnp.fromfunction(function, shape, *, dtype=<class 'float'>, like=None, **kwargs)[flopscope source][numpy source]

Construct an array by executing a function over each coordinate.

Adapted from NumPy docs np.fromfunction

Areacore
Typecustom
NumPy Refnp.fromfunction
Cost
per-operation
Flopscope Context

Construct array by executing function over each coordinate. Cost: numel(output).

The resulting array therefore has a value fn(x, y, z) at coordinate (x, y, z).

Parameters

function:callable

The function is called with N parameters, where N is the rank of shape. Each parameter represents the coordinates of the array varying along a specific axis. For example, if shape were (2, 2), then the parameters would be array([[0, 0], [1, 1]]) and array([[0, 1], [0, 1]])

shape:(N,) tuple of ints

Shape of the output array, which also determines the shape of the coordinate arrays passed to function.

dtype:data-type, optional

Data-type of the coordinate arrays passed to function. By default, dtype is float.

like:array_like, optional

Reference object to allow the creation of arrays which are not NumPy arrays. If an array-like passed in as like supports the __array_function__ protocol, the result will be defined by it. In this case, it ensures the creation of an array object compatible with that passed in via this argument.

Added in version 1.20.0.

Returns

fromfunction:any

The result of the call to function is passed back directly. Therefore the shape of fromfunction is completely determined by function. If function returns a scalar value, the shape of fromfunction would not match the shape parameter.

See also

Notes

Keywords other than dtype and like are passed to function.

Examples

>>> import flopscope.numpy as fnp
>>> flops.fromfunction(lambda i, j: i, (2, 2), dtype=float)
array([[0., 0.],
       [1., 1.]])
>>> flops.fromfunction(lambda i, j: j, (2, 2), dtype=float)
array([[0., 1.],
       [0., 1.]])
>>> flops.fromfunction(lambda i, j: i == j, (3, 3), dtype=int)
array([[ True, False, False],
       [False,  True, False],
       [False, False,  True]])
>>> flops.fromfunction(lambda i, j: i + j, (3, 3), dtype=int)
array([[0, 1, 2],
       [1, 2, 3],
       [2, 3, 4]])