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]]
## generate an ellipsoidal mask
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]:
mask = mask.T
shape = [(n if i in axes else 1) for i,n in enumerate(arr.shape)]
mask = mask.reshape(shape)
return arr * mask 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]]
## generate an ellipsoidal mask
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]:
mask = mask.T
shape = [(n if i in axes else 1) for i,n in enumerate(arr.shape)]
mask = mask.reshape(shape)
return arr * mask 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
angle1_rad = angle1*np.pi/180
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)
target[:,:,0] = np.cos(angle1_rad)*target_[:,:,0] + np.sin(angle1_rad)*target_[:,:,1]
target[:,:,1] = -np.sin(angle1_rad)*target_[:,:,0] + np.cos(angle1_rad)*target_[:,:,1]
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]
# generate an ellipsoidal mask
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))
return arr * mask 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.state_value(state)) * state_values.grad(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 = pd.read_hdf(filename, "item_pair_rate")
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)
self.shader = shaders.getShaderProgram('pointSprite')
#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)
self.shader = shaders.getShaderProgram('pointSprite')
#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):
# read the coordinates
polygons = np.loadtxt(os.path.expanduser(coordfile))
# 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):
# read the coordinates
polygons = np.loadtxt(os.path.expanduser(coordfile))
# 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.quad[0]
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
angle1_rad = angle1*np.pi/180
angle2_rad = angle2*np.pi/180
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)
target[:,:,0] = np.cos(angle1_rad)*target_[:,:,0] - np.sin(angle1_rad)*target_[:,:,1]
target[:,:,1] = np.sin(angle1_rad)*target_[:,:,0] + np.cos(angle1_rad)*target_[:,:,1]
#keep angle1 and angle2 within [0,pi/2] with a reflection at pi/2: -1rad is 1rad, 2rad is pi - 2 rad
angle1_rad = np.pi/2 - np.abs(angle1_rad%np.pi - np.pi/2)
angle2_rad = np.pi/2 - np.abs(angle2_rad%np.pi - np.pi/2)
c1 = np.cos(angle1_rad)
s1 = np.sin(angle1_rad)
c2 = np.cos(angle2_rad)
s2 = np.sin(angle2_rad)
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.
See Also
--------
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.
See Also
--------
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) 