# Python numpy.fromfunction() 使用实例

The following are code examples for showing how to use . They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don’t like. You can also save this page to your account.

Example 1

```def getArrayRegion(self, arr, img=None, axes=(0, 1), **kwds):
"""
Return the result of ROI.getArrayRegion() masked by the elliptical shape
of the ROI. Regions outside the ellipse are set to 0.
"""
# Note: we could use the same method as used by PolyLineROI, but this
# implementation produces a nicer mask.
arr = ROI.getArrayRegion(self, arr, img, axes, **kwds)
if arr is None or arr.shape[axes[0]] == 0 or arr.shape[axes[1]] == 0:
return arr
w = arr.shape[axes[0]]
h = arr.shape[axes[1]]
mask = np.fromfunction(lambda x,y: (((x+0.5)/(w/2.)-1)**2+ ((y+0.5)/(h/2.)-1)**2)**0.5 < 1, (w, h))

# reshape to match array axes
if axes[0] > axes[1]:
shape = [(n if i in axes else 1) for i,n in enumerate(arr.shape)]

Example 2

```def getArrayRegion(self, arr, img=None, axes=(0, 1), **kwds):
"""
Return the result of ROI.getArrayRegion() masked by the elliptical shape
of the ROI. Regions outside the ellipse are set to 0.
"""
# Note: we could use the same method as used by PolyLineROI, but this
# implementation produces a nicer mask.
arr = ROI.getArrayRegion(self, arr, img, axes, **kwds)
if arr is None or arr.shape[axes[0]] == 0 or arr.shape[axes[1]] == 0:
return arr
w = arr.shape[axes[0]]
h = arr.shape[axes[1]]
mask = np.fromfunction(lambda x,y: (((x+0.5)/(w/2.)-1)**2+ ((y+0.5)/(h/2.)-1)**2)**0.5 < 1, (w, h))

# reshape to match array axes
if axes[0] > axes[1]:
shape = [(n if i in axes else 1) for i,n in enumerate(arr.shape)]

Example 3

```def score(self, match):
"""
Return the one bond scoring matrix

Parameters:
-----------
match: array
match_matrix

Returns:
--------
score_matrix

"""

score_matrix = -settings.bond_weight * np.fromfunction(self.evaluate_score_matrix_vect, match.shape, match=match, dtype=int)

return score_matrix ```

Example 4

```def __call__(self, inputs,target):
applied_angle = random.uniform(-self.angle,self.angle)
diff = random.uniform(-self.diff_angle,self.diff_angle)
angle1 = applied_angle - diff/2
angle2 = applied_angle + diff/2

h, w, _ = target.shape

def rotate_flow(i,j,k):
return -k*(j-w/2)*(diff*np.pi/180) + (1-k)*(i-h/2)*(diff*np.pi/180)

rotate_flow_map = np.fromfunction(rotate_flow, target.shape)
target += rotate_flow_map

inputs[0] = ndimage.interpolation.rotate(inputs[0], angle1, reshape=self.reshape, order=self.order)
inputs[1] = ndimage.interpolation.rotate(inputs[1], angle2, reshape=self.reshape, order=self.order)
target = ndimage.interpolation.rotate(target, angle1, reshape=self.reshape, order=self.order)
# flow vectors must be rotated too! careful about Y flow which is upside down
target_ = np.copy(target)
return inputs,target ```

Example 5

```def depthMap(self, midpointdepth=None, pose=None):
shape = self.opts['shape']
if pose is None:
pose = self.pose()
t, r = pose

n = self.planeSfN(r)
# z component from plane-equation solved for z:
zpart = np.fromfunction(lambda y, x: (-n[0] * x
- n[1] * y) / (
-n[2]), shape)

ox, oy = self.objCenter()
v = zpart[int(oy), int(ox)]

if midpointdepth is None:
# TODO: review
midpointdepth = t[2, 0]

zpart += midpointdepth - v
return zpart ```

Example 6

```def getArrayRegion(self, arr, img=None):
"""
Return the result of ROI.getArrayRegion() masked by the elliptical shape
of the ROI. Regions outside the ellipse are set to 0.
"""
# TODO: get right area for pseudosquare
arr = pg.ROI.getArrayRegion(self, arr, img)
if arr is None or arr.shape[0] == 0 or arr.shape[1] == 0:
return None
w = arr.shape[0]
h = arr.shape[1]
mask = np.fromfunction(lambda x,y: ((((x+0.5)/((w/2.)))-1)**2+ (
((y+0.5)/((h/2.)))-1)**2)**0.5 < self._ratioEllispeRectangle, (w, h))

Example 7

```def _shape(self,img):
"""
??????????????
:param img:
:return: ????
"""

operator1 = np.fromfunction(self._gauss, (5, 5), sigma=self._sigma)
operator2 = np.array([[1, 1, 1],
[1,-8, 1],
[1, 1, 1]])
image_blur = signal.convolve2d(img, operator1, mode="same")
# ?????????????
image2 = signal.convolve2d(image_blur, operator2, mode="same")
if image2.max() != 0:
image2 = (image2 / float(image2.max())) * 255
else:
image2 = np.zeros(image2.shape)
# ??????????????255???????????
image2[image2>image2.mean()] = 255
# ?????????????
image2[image2 <=image2.mean()] =0
return image2 ```

Example 8

```def approx_state_value_eval(env, policy,
discount=0.999, learning_rate=0.01,
n_iter=1000, print_every=None):
state_values = LinearApproximator(lambda x: x, env.observation_space.shape[0])
for episode in range(n_iter):
visited_states, rewards = MonteCarlo._run_episode(env, policy, with_actions=False)
for i, state in enumerate(visited_states):
if i + 1 >= len(rewards):
break
discounted_return_from_state = \
np.dot(np.array(rewards[i + 1:]),
np.fromfunction(lambda i: discount ** i, (len(rewards) - i - 1, )))
update = (discounted_return_from_state
state_values.update_w(update, learning_rate)
if print_every is not None and episode % print_every == 0:
print('State-Value estimation:\n{}'.format(
[(s, state_values.state_value(s)) for s in visited_states[:10]]
))
return state_values ```

Example 9

```def action_value_eval(env, policy,
discount=0.999, learning_rate=0.01,
n_iter=1000, print_every=None):
action_values = [[0.0 for _ in range(env.action_space.n)] for _ in range(env.state_space.n)]

for episode in range(n_iter):
visited_state_action_pairs, rewards = MonteCarlo._run_episode(env, policy, with_actions=True)
for i, (state, action) in enumerate(visited_state_action_pairs):
if i + 1 >= len(rewards):
break
discounted_return_from_state = \
np.dot(np.array(rewards[i + 1:]),
np.fromfunction(lambda i: discount ** i, ((len(rewards) - i - 1),)))
action_values[state][action] += \
learning_rate * (discounted_return_from_state - action_values[state][action])
if print_every is not None and episode % print_every == 0:
print('Action-Value estimation:\n{}'.format(action_values))
return action_values ```

Example 10

```def __init__(self, table=None, filename=''):
"""
table:      the pandas DataFrame that records rankable objects competition
record
filename:   the hdf5 filename that stores the DataFrame. The DataFrame
must be indexed by 'item_pair_rate'.
"""
if table is None:
table = table[['primary','secondary','rate1','rate2','weight']]
self.table = table
# itemid to index table
idx = self._extract_list(self.table)
self.itemlist = idx
temptable = table.iloc[:,:2].values
pair = np.fromfunction(np.vectorize(lambda i, j: idx[temptable[i,j]]),
temptable.shape)
pair = np.require(pair, dtype=np.int32)
self.pair = pair ```

Example 11

```def add_gauss_noise(image,r=10):
suanzi = np.fromfunction(func, (r, r), sigma=5)
image = np.array(image)
image2 = signal.convolve2d(image, suanzi, mode="same")
image2 = (image2 / float(image2.max())) * 255
return np.array(image2) ```

Example 12

```def add_gauss_noise(image,r=10):
suanzi = np.fromfunction(func, (r, r), sigma=5)
image = np.array(image)
image2 = signal.convolve2d(image, suanzi, mode="same")
image2 = (image2 / float(image2.max())) * 255
return np.array(image2) ```

Example 13

```def initializeGL(self):

## Generate texture for rendering points
w = 64
def fn(x,y):
r = ((x-w/2.)**2 + (y-w/2.)**2) ** 0.5
return 255 * (w/2. - np.clip(r, w/2.-1.0, w/2.))
pData = np.empty((w, w, 4))
pData[:] = 255
pData[:,:,3] = np.fromfunction(fn, pData.shape[:2])
#print pData.shape, pData.min(), pData.max()
pData = pData.astype(np.ubyte)

if getattr(self, "pointTexture", None) is None:
self.pointTexture = glGenTextures(1)
glActiveTexture(GL_TEXTURE0)
glEnable(GL_TEXTURE_2D)
glBindTexture(GL_TEXTURE_2D, self.pointTexture)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, pData.shape[0], pData.shape[1], 0, GL_RGBA, GL_UNSIGNED_BYTE, pData)

#def getVBO(self, name):
#if name not in self.vbo:
#self.vbo[name] = vbo.VBO(getattr(self, name).astype('f'))
#return self.vbo[name]

#def setupGLState(self):
#"""Prepare OpenGL state for drawing. This function is called immediately before painting."""
##glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)  ## requires z-sorting to render properly.
#glBlendFunc(GL_SRC_ALPHA, GL_ONE)
#glEnable( GL_BLEND )
#glEnable( GL_ALPHA_TEST )
#glDisable( GL_DEPTH_TEST )

##glEnable( GL_POINT_SMOOTH )

##glHint(GL_POINT_SMOOTH_HINT, GL_NICEST)
##glPointParameterfv(GL_POINT_DISTANCE_ATTENUATION, (0, 0, -1e-3))
##glPointParameterfv(GL_POINT_SIZE_MAX, (65500,))
##glPointParameterfv(GL_POINT_SIZE_MIN, (0,)) ```

Example 14

```def initializeGL(self):

## Generate texture for rendering points
w = 64
def fn(x,y):
r = ((x-w/2.)**2 + (y-w/2.)**2) ** 0.5
return 255 * (w/2. - np.clip(r, w/2.-1.0, w/2.))
pData = np.empty((w, w, 4))
pData[:] = 255
pData[:,:,3] = np.fromfunction(fn, pData.shape[:2])
#print pData.shape, pData.min(), pData.max()
pData = pData.astype(np.ubyte)

if getattr(self, "pointTexture", None) is None:
self.pointTexture = glGenTextures(1)
glActiveTexture(GL_TEXTURE0)
glEnable(GL_TEXTURE_2D)
glBindTexture(GL_TEXTURE_2D, self.pointTexture)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, pData.shape[0], pData.shape[1], 0, GL_RGBA, GL_UNSIGNED_BYTE, pData)

#def getVBO(self, name):
#if name not in self.vbo:
#self.vbo[name] = vbo.VBO(getattr(self, name).astype('f'))
#return self.vbo[name]

#def setupGLState(self):
#"""Prepare OpenGL state for drawing. This function is called immediately before painting."""
##glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)  ## requires z-sorting to render properly.
#glBlendFunc(GL_SRC_ALPHA, GL_ONE)
#glEnable( GL_BLEND )
#glEnable( GL_ALPHA_TEST )
#glDisable( GL_DEPTH_TEST )

##glEnable( GL_POINT_SMOOTH )

##glHint(GL_POINT_SMOOTH_HINT, GL_NICEST)
##glPointParameterfv(GL_POINT_DISTANCE_ATTENUATION, (0, 0, -1e-3))
##glPointParameterfv(GL_POINT_SIZE_MAX, (65500,))
##glPointParameterfv(GL_POINT_SIZE_MIN, (0,)) ```

Example 15

```def test_save_prediction(self):
model = RandomForestClassifier()
model.id = get_model_id(model)
model.fit(self.iris.data, self.iris.target)
indexes = np.fromfunction(lambda x: x, (self.iris.data.shape[0], ), dtype=np.int32)
saving_predict_proba(model, self.iris.data, indexes)
os.remove('RandomForestClassifier_r0_N__m5_2__m4_1__m6_0p0__m1_auto__m0_N__m3_1e-07__m2_N__n0_10__b0_1__c1_gini__c0_N_190.csv') ```

Example 16

```def test_getitem_with_slice_from_2D_functional_array_2():
def test_function(i, j):
return i * i + 2 * i * j + 3
m = larray(test_function, shape=(3, 15))
assert_array_equal(m[:, 3:14:3],
numpy.fromfunction(test_function, shape=(3, 15))[:, 3:14:3]) ```

Example 17

```def test_getitem_from_array_with_operations():
a1 = numpy.array([[1, 3, 5], [7, 9, 11]])
m1 = larray(a1)
f = lambda i, j: numpy.sqrt(i * i + j * j)
a2 = numpy.fromfunction(f, shape=(2, 3))
m2 = larray(f, shape=(2, 3))
a3 = 3 * a1 + a2
m3 = 3 * m1 + m2
assert_array_equal(a3[:, (0, 2)],
m3[:, (0, 2)]) ```

Example 18

```def array_from_function_full(f, shape):
return np.fromfunction(f, shape) ```

Example 19

```def array_from_function_slice(f, shape):
return np.fromfunction(f, shape)[:, 0:-1:10] ```

Example 20

```def createpolygonmovie(coordfile, moviefile, background=None, xrange=(0,1), yrange=(0,1), shape=(500,500), rate=24):

# open the movie file
movie = MovieFile(moviefile, shape=shape, rate=rate)

# setup the figure and its background
figure = plt.figure(1, dpi=100, figsize=(shape[0]/100.,shape[1]/100.))
x0,x1 = xrange
y0,y1 = yrange
px,py = shape
if background != None:
# transpose and scale i,j indices to x,y values
backim = np.fromfunction(lambda i,j: background((j+0.5)/px*(x1-x0)+x0,(i+0.5)/py*(y1-y0)+y0), shape[::-1])
plt.imshow(backim, origin='lower', aspect='auto', interpolation='bicubic', extent=(x0,x1,y0,y1))
plt.grid(True)
plt.xlim(xrange[0], xrange[1])
plt.ylim(yrange[0], yrange[1])

# for each line in the file, draw the polygon and add a movie frame
for p in polygons:
plt.plot(np.concatenate((p[0::2],p[0:1])), np.concatenate((p[1::2],p[1:2])), 'w-')
plt.draw()                                  # flush the drawing
movie.add(figure.canvas.buffer_rgba(0,0))   # pass the pixel buffer on as movie frame
figure.axes[0].lines.pop()                  # remove the plotted line

# close things
plt.close()
movie.close()

# ----------------------------------------------------------------- ```

Example 21

```def createpolygonmovie(coordfile, moviefile, background=None, xrange=(0,1), yrange=(0,1), shape=(500,500), rate=24):

# open the movie file
movie = MovieFile(moviefile, shape=shape, rate=rate)

# setup the figure and its background
figure = plt.figure(1, dpi=100, figsize=(shape[0]/100.,shape[1]/100.))
x0,x1 = xrange
y0,y1 = yrange
px,py = shape
if background != None:
# transpose and scale i,j indices to x,y values
backim = np.fromfunction(lambda i,j: background((j+0.5)/px*(x1-x0)+x0,(i+0.5)/py*(y1-y0)+y0), shape[::-1])
plt.imshow(backim, origin='lower', aspect='auto', interpolation='bicubic', extent=(x0,x1,y0,y1))
plt.grid(True)
plt.xlim(xrange[0], xrange[1])
plt.ylim(yrange[0], yrange[1])

# for each line in the file, draw the polygon and add a movie frame
for p in polygons:
plt.plot(np.concatenate((p[0::2],p[0:1])), np.concatenate((p[1::2],p[1:2])), 'w-')
plt.draw()                                  # flush the drawing
movie.add(figure.canvas.buffer_rgba(0,0))   # pass the pixel buffer on as movie frame
figure.axes[0].lines.pop()                  # remove the plotted line

# close things
plt.close()
movie.close()

# ----------------------------------------------------------------- ```

Example 22

```def growPositions(ksize):
'''
return all positions around central point (0,0)
for a given kernel size
positions grow from smallest to biggest distances

returns [positions] and [distances] from central cell

'''
i = ksize*2+1
kk = np.ones( (i, i), dtype=bool)
x,y = np.where(kk)
pos = np.empty(shape=(i,i,2), dtype=int)
pos[:,:,0]=x.reshape(i,i)-ksize
pos[:,:,1]=y.reshape(i,i)-ksize

dist = np.fromfunction(lambda x,y: ((x-ksize)**2
+(y-ksize)**2)**0.5, (i,i))

pos = np.dstack(
np.unravel_index(
np.argsort(dist.ravel()), (i, i)))[0,1:]

pos0 = pos[:,0]
pos1 = pos[:,1]

return pos-ksize, dist[pos0, pos1] ```

Example 23

```def cam2PlaneVectorField(self, midpointdepth=None, **kwargs):
t, r = self.pose()
shape = self.opts['shape']

cam = self.opts['cameraMatrix']
# move reference point from top left quad corner to
# optical center:
q0 = self.objCenter()
#         dx,dy = cam[0,2]-q0[0], cam[1,2]-q0[1]
dx, dy = shape[1] // 2 - q0[0], shape[0] // 2 - q0[1]

# x,y component of undist plane:
rot0 = np.array([0, 0, 0], dtype=float)
worldCoord = np.fromfunction(lambda x, y:
imgPointToWorldCoord((y - dy, x - dx), rot0, t, cam
), shape).reshape(3, *shape)
# z component from plane-equation solved for z:
n = self.planeSfN(r)
x, y = worldCoord[:2]
zpart = (-n[0] * x - n[1] * y) / (-n[2])
ox, oy = self.objCenter()
v = zpart[int(oy), int(ox)]

if midpointdepth is None:
# TODO: review
midpointdepth = t[2, 0]
zpart += midpointdepth - v
worldCoord[2] = zpart
return worldCoord

# BEFORE REMOVING THINGS: MAKE EXTRA FN ```

Example 24

```def get_n_step_expected_rewards_mat(episode_rewards, estimates, discount=.99, n_step=1):
expected_reward = [0] * len(episode_rewards)
rewards_coef = np.fromfunction(lambda i,j: discount**(i-j) * (i >= j) * (i - j < n_step), (len(episode_rewards), len(episode_rewards)))
permut = np.fromfunction(lambda i,j: (i > j + n_step) * (i <= j + n_step), (len(episode_rewards), len(episode_rewards)))

return np.dot(episode_rewards, rewards_coef) + discount**(n_step) * np.dot(estimates, permut) ```

Example 25

```def bool_ops(self):
"""Allows the user to write mathmatical definitions for solids and use boolian operations on them."""
x = np.zeros((self.matrix_size, self.matrix_size, self.matrix_size))
v = np.fromfunction(self.test_solid, (self.matrix_size, self.matrix_size, self.matrix_size))
v = x + v
v = np.lib.pad(v, ((1,1),(1,1),(1,1)), 'constant') #This padds the z axis with zero's arrays so that a closed shape is produced by marching cubes.
return v ```

Example 26

```def parse_data(data):
"""
Transform ``data`` to a numpy ndarray. The parameter ``data`` may
contain data in various formats, e.g. nested lists, sympy ``Matrix``,
and so on.

Examples
========

>>> from sympy.tensor.tensor import _TensorDataLazyEvaluator
>>> _TensorDataLazyEvaluator.parse_data([1, 3, -6, 12])
[1 3 -6 12]

>>> _TensorDataLazyEvaluator.parse_data([[1, 2], [4, 7]])
[[1 2]
[4 7]]
"""
numpy = import_module('numpy')

if (numpy is not None) and (not isinstance(data, numpy.ndarray)):
if len(data) == 2 and hasattr(data[0], '__call__'):

def fromfunction_sympify(*x):
return sympify(data[0](*x))

data = numpy.fromfunction(fromfunction_sympify, data[1])
else:
vsympify = numpy.vectorize(sympify)
data = vsympify(numpy.array(data))
return data ```

Example 27

```def state_value_eval(env, policy,
discount=0.999,
learning_rate=0.01,
n_iter=1000,
print_every=None):
"""
This is EVERY-VISIT Monte-Carlo
:param env: An Environment that we can reset(), step() and get observations and
reward information.
:param policy: A strategy for behaving in an Environment. Should have a step()
method that returns an action given state information.
:param discount: Discount factor for the MDP
:param learning_rate: The amount we will shift towards an error direction.
:param n_iter: Number of episodes to run this algorithm for
:param print_every: Print the current estimate of values every X iterations
:return: The State-Value function that shows the average return we'll have starting
in each one of the states of this MDP
"""
state_values = [0.0 for _ in range(env.state_space.n)]

for episode in range(n_iter):
visited_states, rewards = MonteCarlo._run_episode(env, policy, with_actions=False)
for i, state in enumerate(visited_states):
if i + 1 >= len(rewards):
break
discounted_return_from_state = \
np.dot(np.array(rewards[i + 1:]),
np.fromfunction(lambda i: discount ** i, ((len(rewards) - i - 1),)))
state_values[state] += \
learning_rate * (discounted_return_from_state - state_values[state])
if print_every is not None and episode % print_every == 0:
print('State-Value estimation:\n{}'.format(state_values))
return state_values ```

Example 28

```def __call__(self, inputs,target):
applied_angle  = random.uniform(-self.angle,self.angle)
diff = random.uniform(-self.diff_angle,self.diff_angle)
angle1 = applied_angle - diff/2
angle2 = applied_angle + diff/2

h, w, _ = inputs[0].shape

def rotate_flow(i,j,k):
return -k*(j-w/2)*(diff*np.pi/180) + (1-k)*(i-h/2)*(diff*np.pi/180)

rotate_flow_map = np.fromfunction(rotate_flow, target.shape)
target += rotate_flow_map

inputs[0] = ndimage.interpolation.rotate(inputs[0], angle1, reshape=True, order=self.order)
inputs[1] = ndimage.interpolation.rotate(inputs[1], angle2, reshape=True, order=self.order)
target = ndimage.interpolation.rotate(target, angle1, reshape=True, order=self.order)

#flow vectors must be rotated too!
target_=np.array(target, copy=True)

c_diag = h/np.sqrt(h*h+w*w)
s_diag = w/np.sqrt(h*h+w*w)

ratio = c_diag/max(c1*c_diag+s1*s_diag,c2*c_diag+s2*s_diag)

crop = CenterCrop((int(h*ratio),int(w*ratio)))
scale = Scale(self.size)
inputs, target = crop(inputs, target)
return scale(inputs,target) ```

Example 29

```def asanyarray(a, dtype=None, order=None):
"""Convert the input to an ndarray, but pass ndarray subclasses through.

Parameters
----------
a : array_like
Input data, in any form that can be converted to an array.  This
includes scalars, lists, lists of tuples, tuples, tuples of tuples,
tuples of lists, and ndarrays.
dtype : data-type, optional
By default, the data-type is inferred from the input data.
order : {'C', 'F'}, optional
Whether to use row-major (C-style) or column-major
(Fortran-style) memory representation.  Defaults to 'C'.

Returns
-------
out : ndarray or an ndarray subclass
Array interpretation of `a`.  If `a` is an ndarray or a subclass
of ndarray, it is returned as-is and no copy is performed.

--------
asarray : Similar function which always returns ndarrays.
ascontiguousarray : Convert input to a contiguous array.
asfarray : Convert input to a floating point ndarray.
asfortranarray : Convert input to an ndarray with column-major
memory order.
asarray_chkfinite : Similar function which checks input for NaNs and
Infs.
fromiter : Create an array from an iterator.
fromfunction : Construct an array by executing a function on grid
positions.

Examples
--------
Convert a list into an array:

>>> a = [1, 2]
>>> np.asanyarray(a)
array([1, 2])

Instances of `ndarray` subclasses are passed through as-is:

>>> a = np.matrix([1, 2])
>>> np.asanyarray(a) is a
True

"""
return array(a, dtype, copy=False, order=order, subok=True) ```

Example 30

```def fromfunction(function, shape, **kwargs):
"""
Construct an array by executing a function over each coordinate.

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 in turn be (0, 0), (0, 1),
(1, 0), (1, 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.

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 match the `shape` parameter.

--------
indices, meshgrid

Notes
-----
Keywords other than `dtype` are passed to `function`.

Examples
--------
>>> np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int)
array([[ True, False, False],
[False,  True, False],
[False, False,  True]], dtype=bool)

>>> np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int)
array([[0, 1, 2],
[1, 2, 3],
[2, 3, 4]])

"""
dtype = kwargs.pop('dtype', float)
args = indices(shape, dtype=dtype)
return function(*args, **kwargs) ```