def test_vectorize_lambda_xfail(self):
functions = [lambda a, b: a + b, lambda a, b: a * b]
f = cupy.vectorize(functions[0])
x1 = testing.shaped_random((20, 30), cupy, numpy.int64, seed=1)
x2 = testing.shaped_random((20, 30), cupy, numpy.int64, seed=2)
with pytest.raises(ValueError, match='Multiple callables are found'):
return f(x1, x2)
def get_perlin_init(shape=(1000, 1000),
n=100000,
cutoff=None,
repetition=(1000, 1000),
scale=100,
octaves=20.0,
persistence=0.1,
lacunarity=2.0):
"""Returns a tuple of x,y-coordinates sampled from Perlin noise.
This can be used to initialize the starting positions of a physarum-
population, as well as to generate a cloudy feeding-pattern that will
have a natural feel to it. This function wraps the one from the noise-
library from Casey Duncan, and is in parts borrowed from here (see also this for a good explanation of the noise-parameters):
https://medium.com/@yvanscher/playing-with-perlin-noise-generating-realistic-archipelagos-b59f004d8401
The most relevant paramaters for our purposes are:
:param shape: The shape of the area in which the noise is to be generated. Defaults to (1000,1000)
:type shape: Tuple of integers with the form (width, height).
:param n: Number of particles to sample. When used as a feeeding trace,
this translates to the relative strength of the pattern. defaults to 100000.
:param cutoff: value below which noise should be set to zero. Default is None. Will lead to probabilities 'contains NaN-error, if to high'
:param scale: (python-noise parameter) The scale of the noise -- larger or smaller patterns, defaults to 100.
:param repetition: (python-noise parameter) Tuple that denotes the size of the area in which the noise should repeat itself. Defaults to (1000,1000)
"""
import numpy as np
import cupy as cp # vectorized not present in cupy, so for now to conversion at the end
shape = [i - 1 for i in shape]
# make coordinate grid on [0,1]^2
x_idx = np.linspace(0, shape[0], shape[0])
y_idx = np.linspace(0, shape[1], shape[1])
world_x, world_y = np.meshgrid(x_idx, y_idx)
# apply perlin noise, instead of np.vectorize, consider using itertools.starmap()
world = np.vectorize(noise.pnoise2)(
world_x / scale,
world_y / scale,
octaves=int(octaves),
persistence=persistence,
lacunarity=lacunarity,
repeatx=repetition[0],
repeaty=repetition[1],
base=np.random.randint(0, 100),
)
# world = world * 3
# Sample particle init from map:
world[world <= 0.0] = 0.0 # filter negative values
if cutoff is not None:
world[world <= cutoff] = 0.0
linear_idx = np.random.choice(world.size,
size=n,
p=world.ravel() / float(world.sum()))
x, y = np.unravel_index(linear_idx, shape)
x = x.reshape(-1, 1)
y = y.reshape(-1, 1)
return cp.asarray(np.hstack([x, y]))
def test_vectorize_const_typeerror(self):
def my_invalid_type(x):
x = numpy.dtype('f').type
return x
f = cupy.vectorize(my_invalid_type)
x = testing.shaped_random((20, 30), cupy, numpy.int32, seed=1)
with pytest.raises(TypeError):
f(x)
def test_vectorize_const_non_toplevel(self):
def my_invalid_type(x):
if x == 3:
typecast = numpy.dtype('f').type # NOQA
return x
f = cupy.vectorize(my_invalid_type)
x = cupy.array([1, 2, 3, 4, 5])
with pytest.raises(TypeError):
f(x)
def test_tuple_pattern_match_type_error(self):
def func_pattern_match(x, y):
x, y = y, x
z = x, y
(a, b), z = z, x
return a * a + b
f = cupy.vectorize(func_pattern_match)
x = cupy.array([0, 1, 2, 3, 4])
y = cupy.array([5, 6, 7, 8, 9])
with pytest.raises(TypeError, match='Data type mismatch of variable:'):
return f(x, y)
def collapse_last_dim(arr, keep_dim=True):
"""
Collapse the last dimension
:param arr: data array
:param keep_dim: keep the last dim as one or not
:return:
"""
def _collapse(x):
return x
fn = cupy.vectorize(_collapse, otypes=[object], signature='(m)->()')
t = fn(arr)
if keep_dim:
shape = arr.shape[:-1] + (1, )
t = t.reshape(shape)
return t
def test_relu_type_error(self):
f = cupy.vectorize(lambda x: x if x > 0.0 else cupy.float64(0.0))
a = cupy.array([0.4, -0.2, 1.8, -1.2], dtype=cupy.float32)
with pytest.raises(TypeError):
return f(a)
