  C RUBY-ON-RAILS MYSQL ASP.NET DEVELOPMENT RUBY .NET LINUX SQL-SERVER REGEX WINDOWS ALGORITHM ECLIPSE VISUAL-STUDIO STRING SVN PERFORMANCE APACHE-FLEX UNIT-TESTING SECURITY LINQ UNIX MATH EMAIL OOP LANGUAGE-AGNOSTIC VB6 MSBUILD # Speed up Numpy Meshgrid Command ## Speed up Numpy Meshgrid Command Tag : python , By : Gerhard Miller Date : November 27 2020, 01:01 AM Boards Message : You Must Login Or Sign Up to Add Your Comments .

## Numpy meshgrid in 3D

Tag : python , By : Tigre
Date : March 29 2020, 07:55 AM
around this issue Numpy's meshgrid is very useful for converting two vectors to a coordinate grid. What is the easiest way to extend this to three dimensions? So given three vectors x, y, and z, construct 3x3D arrays (instead of 2x2D arrays) which can be used as coordinates. , Here is the source code of meshgrid:
``````def meshgrid(x,y):
"""
Return coordinate matrices from two coordinate vectors.

Parameters
----------
x, y : ndarray
Two 1-D arrays representing the x and y coordinates of a grid.

Returns
-------
X, Y : ndarray
For vectors `x`, `y` with lengths ``Nx=len(x)`` and ``Ny=len(y)``,
return `X`, `Y` where `X` and `Y` are ``(Ny, Nx)`` shaped arrays
with the elements of `x` and y repeated to fill the matrix along
the first dimension for `x`, the second for `y`.

--------
index_tricks.mgrid : Construct a multi-dimensional "meshgrid"
using indexing notation.
index_tricks.ogrid : Construct an open multi-dimensional "meshgrid"
using indexing notation.

Examples
--------
>>> X, Y = np.meshgrid([1,2,3], [4,5,6,7])
>>> X
array([[1, 2, 3],
[1, 2, 3],
[1, 2, 3],
[1, 2, 3]])
>>> Y
array([[4, 4, 4],
[5, 5, 5],
[6, 6, 6],
[7, 7, 7]])

`meshgrid` is very useful to evaluate functions on a grid.

>>> x = np.arange(-5, 5, 0.1)
>>> y = np.arange(-5, 5, 0.1)
>>> xx, yy = np.meshgrid(x, y)
>>> z = np.sin(xx**2+yy**2)/(xx**2+yy**2)

"""
x = asarray(x)
y = asarray(y)
numRows, numCols = len(y), len(x)  # yes, reversed
x = x.reshape(1,numCols)
X = x.repeat(numRows, axis=0)

y = y.reshape(numRows,1)
Y = y.repeat(numCols, axis=1)
return X, Y
``````
``````def meshgrid2(*arrs):
arrs = tuple(reversed(arrs))  #edit
lens = map(len, arrs)
dim = len(arrs)

sz = 1
for s in lens:
sz*=s

ans = []
for i, arr in enumerate(arrs):
slc = *dim
slc[i] = lens[i]
arr2 = asarray(arr).reshape(slc)
for j, sz in enumerate(lens):
if j!=i:
arr2 = arr2.repeat(sz, axis=j)
ans.append(arr2)

return tuple(ans)
``````

## Numpy: Meshgrid vs ix_

Tag : development , By : Brian Cupps
Date : March 29 2020, 07:55 AM
Any of those help From the look of it, both numpy.meshgrid and numpy.ix_ seem to do pretty much the same. Is there a significant difference between them, or is the other just a convenient shortcut? , numpy.meshgrid is 2-Dimensional.
numpy.ix_ is n-dimensional.

## numpy 3D meshgrid only as a view

Tag : python , By : nobodyzzz
Date : March 29 2020, 07:55 AM
wish helps you I have a cubic grid defined by the spacing xi,yi,zi:
``````>>> xi, yi, zi = [np.arange(3) for i in range(3)]
>>> xx, yy, zz = np.broadcast_arrays(xi,yi[:,np.newaxis],zi[:,np.newaxis,np.newaxis])
>>> xx.shape
(3, 3, 3)
>>> xx.strides
(0, 0, 8)
``````
``````def ndmesh(*args):
args = map(np.asarray,args)
return np.broadcast_arrays(*[x[(slice(None),)+(None,)*i] for i, x in enumerate(args)])
``````

## Numpy meshgrid points

Tag : python , By : Robin Buitenhuis
Date : March 29 2020, 07:55 AM
this one helps. I just noticed that the documentation in numpy provides an even faster way to do this:
``````X, Y = np.mgrid[xmin:xmax:100j, ymin:ymax:100j]
positions = np.vstack([X.ravel(), Y.ravel()])
``````
``````g = meshgrid2(x, y, z)
positions = np.vstack(map(np.ravel, g))
``````
``````In : import numpy as np

In : from numpy import asarray

In : x = np.random.rand(100,1)

In : y = np.random.rand(100,1)

In : z = np.random.rand(100,1)
``````
``````In : def meshgrid2(*arrs):
....:     arrs = tuple(reversed(arrs))
....:     lens = map(len, arrs)
....:     dim = len(arrs)
....:     sz = 1
....:     for s in lens:
....:        sz *= s
....:     ans = []
....:     for i, arr in enumerate(arrs):
....:         slc = *dim
....:         slc[i] = lens[i]
....:         arr2 = asarray(arr).reshape(slc)
....:         for j, sz in enumerate(lens):
....:             if j != i:
....:                 arr2 = arr2.repeat(sz, axis=j)
....:         ans.append(arr2)
....:     return tuple(ans)
``````
``````In : g = meshgrid2(x, y, z)

In : %timeit pos = np.vstack(map(np.ravel, g)).T
100 loops, best of 3: 7.26 ms per loop

In : %timeit zip(*(x.flat for x in g))
1 loops, best of 3: 264 ms per loop
``````

## Generalize the use of numpy.meshgrid

Tag : python , By : fstender
Date : March 29 2020, 07:55 AM
To fix this issue Here is how you can transform your call to have it working for any 2D input:
``````from numpy import array, meshgrid

def mesh(foo):
return array(meshgrid(*foo)).T.reshape(-1, foo.shape)

print(mesh(array(([1, 2, 3], [4, 5]))))
print(mesh(array(([1, 2, 3], [4, 5], [6, 7]))))
`````` 