Kan iemand me uitleggen wat het doel is van de functie meshgridin Numpy? Ik weet dat het een soort raster van coördinaten creëert om te plotten, maar ik zie er niet echt het directe voordeel van in.
Ik studeer ‘Python Machine Learning’ van Sebastian Raschka en hij gebruikt het om de beslissingsgrenzen uit te stippelen. Zie input 11 hier.
Ik heb deze code ook geprobeerd uit officiële documentatie, maar nogmaals, de uitvoer is niet echt logisch voor mij.
x = np.arange(-5, 5, 1)
y = np.arange(-5, 5, 1)
xx, yy = np.meshgrid(x, y, sparse=True)
z = np.sin(xx**2 + yy**2) / (xx**2 + yy**2)
h = plt.contourf(x,y,z)
Laat me, indien mogelijk, ook veel voorbeelden uit de echte wereld zien.
Antwoord 1, autoriteit 100%
Het doel van meshgridis om een rechthoekig raster te maken uit een array van x-waarden en een array van y-waarden.
Dus, bijvoorbeeld, als we een raster willen maken waarin we een punt hebben op elk geheel getal tussen 0 en 4 in zowel de x- als de y-richting. Om een rechthoekig raster te maken, hebben we elke combinatie van de punten xen ynodig.
Dit worden 25 punten, toch? Dus als we een x- en y-array willen maken voor al deze punten, kunnenhet volgende doen.
x[0,0] = 0 y[0,0] = 0
x[0,1] = 1 y[0,1] = 0
x[0,2] = 2 y[0,2] = 0
x[0,3] = 3 y[0,3] = 0
x[0,4] = 4 y[0,4] = 0
x[1,0] = 0 y[1,0] = 1
x[1,1] = 1 y[1,1] = 1
...
x[4,3] = 3 y[4,3] = 4
x[4,4] = 4 y[4,4] = 4
Dit zou resulteren in de volgende x– en y-matrices, zodanig dat de koppeling van het corresponderende element in elke matrix de x- en y-coördinaten van een punt in de raster.
x = 0 1 2 3 4 y = 0 0 0 0 0
0 1 2 3 4 1 1 1 1 1
0 1 2 3 4 2 2 2 2 2
0 1 2 3 4 3 3 3 3 3
0 1 2 3 4 4 4 4 4 4
We kunnen deze dan plotten om te verifiëren dat het een raster is:
plt.plot(x,y, marker='.', color='k', linestyle='none')
Natuurlijk wordt dit erg vervelend, vooral voor grote reeksen van xen y. In plaats daarvan kan meshgriddit voor ons genereren: het enige dat we hoeven te specificeren zijn de unieke xen ywaarden.
xvalues = np.array([0, 1, 2, 3, 4]);
yvalues = np.array([0, 1, 2, 3, 4]);
Als we nu meshgridaanroepen, krijgen we automatisch de vorige uitvoer.
xx, yy = np.meshgrid(xvalues, yvalues)
plt.plot(xx, yy, marker='.', color='k', linestyle='none')
Het maken van deze rechthoekige rasters is nuttig voor een aantal taken. In het voorbeeld dat je in je bericht hebt gegeven, is het gewoon een manier om een functie te samplen (sin(x**2 + y**2) / (x**2 + y**2)) over een reeks waarden voor xen y.
Omdat deze functie is gesampled op een rechthoekig raster, kan de functie nu worden gevisualiseerd als een “afbeelding”.
Bovendien kan het resultaat nu worden doorgegeven aan functies die gegevens verwachten op een rechthoekig raster (d.w.z. contourf)
Antwoord 2, autoriteit 62%
Met dank aan Microsoft Excel:
Antwoord 3, autoriteit 22%
Eigenlijk wordt het doel van np.meshgridal genoemd in de documentatie:
Retourneer coördinaatmatrices van coördinaatvectoren.
Maak N-D-coördinatenreeksen voor gevectoriseerde evaluaties van N-D scalaire/vectorvelden over N-D-rasters, gegeven eendimensionale coördinatenreeksen x1, x2,…, xn.
Het belangrijkste doel is dus om coördinatenmatrices te maken.
Je hebt jezelf waarschijnlijk net afgevraagd:
Waarom moeten we coördinatenmatrices maken?
De reden dat je coördinatenmatrices nodig hebt met Python/NumPy is dat er geen directe relatie is tussen coördinaten en waarden, behalve wanneer je coördinaten met nul beginnen en puur positieve gehele getallen zijn. Dan kun je gewoon de indices van een array als index gebruiken.
Maar als dat niet het geval is, moet u op de een of andere manier coördinaten naast uw gegevens opslaan. Dat is waar rasters binnenkomen.
Stel dat uw gegevens zijn:
1 2 1
2 5 2
1 2 1
Elke waarde vertegenwoordigt echter een gebied van 3 x 2 kilometer (horizontaal x verticaal). Stel dat uw oorsprong de linkerbovenhoek is en u wilt arrays die de afstand vertegenwoordigen die u zou kunnen gebruiken:
import numpy as np
h, v = np.meshgrid(np.arange(3)*3, np.arange(3)*2)
waar v is:
array([[0, 0, 0],
[2, 2, 2],
[4, 4, 4]])
en h:
array([[0, 3, 6],
[0, 3, 6],
[0, 3, 6]])
Dus als je twee indices hebt, laten we zeggen xen y(daarom is de retourwaarde van meshgridmeestal xxof xsin plaats van xin dit geval heb ik hgekozen voor horizontaal!) dan kun je de x-coördinaat van het punt krijgen , de y-coördinaat van het punt en de waarde op dat punt met behulp van:
h[x, y] # horizontal coordinate
v[x, y] # vertical coordinate
data[x, y] # value
Dat maakt het veel gemakkelijker om coördinaten bij te houden en(nog belangrijker) je kunt ze doorgeven aan functies die de coördinaten moeten weten.
Een iets langere uitleg
Echter, np.meshgridzelf wordt niet vaak direct gebruikt, meestal gebruikt men gewoon een van vergelijkbareobjecten np.mgridof np.ogrid.
Hier vertegenwoordigt np.mgridhet sparse=Falseen np.ogridhet sparse=Truegeval (ik verwijs naar het argument sparsevan np.meshgrid). Merk op dat er een significant verschil is tussen
np.meshgriden np.ogriden np.mgrid: de eerste twee geretourneerde waarden (als er twee of meer zijn) worden omgekeerd. Vaak maakt dit niet uit, maar u moet zinvolle variabelenamen geven, afhankelijk van de context.
Bijvoorbeeld, in het geval van een 2D-raster en matplotlib.pyplot.imshowis het logisch om het eerste geretourneerde item van np.meshgridxen de tweede yterwijl het . is
andersom voor np.mgriden np.ogrid.
np.ogriden schaarse rasters
>>> import numpy as np
>>> yy, xx = np.ogrid[-5:6, -5:6]
>>> xx
array([[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]])
>>> yy
array([[-5],
[-4],
[-3],
[-2],
[-1],
[ 0],
[ 1],
[ 2],
[ 3],
[ 4],
[ 5]])
Zoals al gezegd is de uitvoer omgekeerd in vergelijking met np.meshgrid, daarom heb ik het uitgepakt als yy, xxin plaats van xx, yy:
>>> xx, yy = np.meshgrid(np.arange(-5, 6), np.arange(-5, 6), sparse=True)
>>> xx
array([[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]])
>>> yy
array([[-5],
[-4],
[-3],
[-2],
[-1],
[ 0],
[ 1],
[ 2],
[ 3],
[ 4],
[ 5]])
Dit lijkt al op coördinaten, met name de X- en Y-lijnen voor 2D-percelen.
visualized:
yy, xx = np.ogrid[-5:6, -5:6]
plt.figure()
plt.title('ogrid (sparse meshgrid)')
plt.grid()
plt.xticks(xx.ravel())
plt.yticks(yy.ravel())
plt.scatter(xx, np.zeros_like(xx), color="blue", marker="*")
plt.scatter(np.zeros_like(yy), yy, color="red", marker="x")
np.mgriden dichte / gevlekte roosters
>>> yy, xx = np.mgrid[-5:6, -5:6]
>>> xx
array([[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]])
>>> yy
array([[-5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5],
[-4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4],
[-3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3],
[-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2],
[-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
[ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3],
[ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4],
[ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5]])
Hier geldt hetzelfde: de uitvoer wordt omgekeerd vergeleken met np.meshgrid:
>>> xx, yy = np.meshgrid(np.arange(-5, 6), np.arange(-5, 6))
>>> xx
array([[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]])
>>> yy
array([[-5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5],
[-4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4],
[-3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3],
[-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2],
[-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
[ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3],
[ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4],
[ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5]])
In tegenstelling tot ogridbevatten deze arrays allexxen yycoördinaten in de -5 <= xx < ;= 5; -5 <= yy <= 5 raster.
yy, xx = np.mgrid[-5:6, -5:6]
plt.figure()
plt.title('mgrid (dense meshgrid)')
plt.grid()
plt.xticks(xx[0])
plt.yticks(yy[:, 0])
plt.scatter(xx, yy, color="red", marker="x")
Functionaliteit
Het is niet alleen beperkt tot 2D, deze functies werken voor willekeurige dimensies (nou, er is een maximum aantal argumenten gegeven om in Python te functioneren en een maximum aantal dimensies dat NumPy toestaat):
>>> x1, x2, x3, x4 = np.ogrid[:3, 1:4, 2:5, 3:6]
>>> for i, x in enumerate([x1, x2, x3, x4]):
... print('x{}'.format(i+1))
... print(repr(x))
x1
array([[[[0]]],
[[[1]]],
[[[2]]]])
x2
array([[[[1]],
[[2]],
[[3]]]])
x3
array([[[[2],
[3],
[4]]]])
x4
array([[[[3, 4, 5]]]])
>>> # equivalent meshgrid output, note how the first two arguments are reversed and the unpacking
>>> x2, x1, x3, x4 = np.meshgrid(np.arange(1,4), np.arange(3), np.arange(2, 5), np.arange(3, 6), sparse=True)
>>> for i, x in enumerate([x1, x2, x3, x4]):
... print('x{}'.format(i+1))
... print(repr(x))
# Identical output so it's omitted here.
Zelfs als deze ook voor 1D werken, zijn er twee (veel algemenere) functies voor het maken van 1D-raster:
Naast de starten stopARGUMENT Het ondersteunt ook de stepargument (zelfs complexe stappen die het aantal stappen vertegenwoordigen):
>>> x1, x2 = np.mgrid[1:10:2, 1:10:4j]
>>> x1 # The dimension with the explicit step width of 2
array([[1., 1., 1., 1.],
[3., 3., 3., 3.],
[5., 5., 5., 5.],
[7., 7., 7., 7.],
[9., 9., 9., 9.]])
>>> x2 # The dimension with the "number of steps"
array([[ 1., 4., 7., 10.],
[ 1., 4., 7., 10.],
[ 1., 4., 7., 10.],
[ 1., 4., 7., 10.],
[ 1., 4., 7., 10.]])
Toepassingen
U heeft specifiek gevraagd naar het doel en in feite zijn deze rasters uiterst handig als u een coördinatensysteem nodig heeft.
Bijvoorbeeld als u een numpy-functie hebt die de afstand in twee dimensies berekent:
def distance_2d(x_point, y_point, x, y):
return np.hypot(x-x_point, y-y_point)
en u wilt de afstand van elk punt weten:
>>> ys, xs = np.ogrid[-5:5, -5:5]
>>> distances = distance_2d(1, 2, xs, ys) # distance to point (1, 2)
>>> distances
array([[9.21954446, 8.60232527, 8.06225775, 7.61577311, 7.28010989,
7.07106781, 7. , 7.07106781, 7.28010989, 7.61577311],
[8.48528137, 7.81024968, 7.21110255, 6.70820393, 6.32455532,
6.08276253, 6. , 6.08276253, 6.32455532, 6.70820393],
[7.81024968, 7.07106781, 6.40312424, 5.83095189, 5.38516481,
5.09901951, 5. , 5.09901951, 5.38516481, 5.83095189],
[7.21110255, 6.40312424, 5.65685425, 5. , 4.47213595,
4.12310563, 4. , 4.12310563, 4.47213595, 5. ],
[6.70820393, 5.83095189, 5. , 4.24264069, 3.60555128,
3.16227766, 3. , 3.16227766, 3.60555128, 4.24264069],
[6.32455532, 5.38516481, 4.47213595, 3.60555128, 2.82842712,
2.23606798, 2. , 2.23606798, 2.82842712, 3.60555128],
[6.08276253, 5.09901951, 4.12310563, 3.16227766, 2.23606798,
1.41421356, 1. , 1.41421356, 2.23606798, 3.16227766],
[6. , 5. , 4. , 3. , 2. ,
1. , 0. , 1. , 2. , 3. ],
[6.08276253, 5.09901951, 4.12310563, 3.16227766, 2.23606798,
1.41421356, 1. , 1.41421356, 2.23606798, 3.16227766],
[6.32455532, 5.38516481, 4.47213595, 3.60555128, 2.82842712,
2.23606798, 2. , 2.23606798, 2.82842712, 3.60555128]])
De uitvoer zou identiek zijn als men zou passeren in een dicht raster in plaats van een open raster. NumPys broadcasting maakt het mogelijk!
Laten we het resultaat visualiseren:
plt.figure()
plt.title('distance to point (1, 2)')
plt.imshow(distances, origin='lower', interpolation="none")
plt.xticks(np.arange(xs.shape[1]), xs.ravel()) # need to set the ticks manually
plt.yticks(np.arange(ys.shape[0]), ys.ravel())
plt.colorbar()
En dit is ook wanneerumpys mgriden ogridWORDEN ZEER MAAKTEELD WORDEN GEWELDIG OMDAT JE MAKELE DE RESOLUTIE VAN JE NODINGEN WORDEN VERANDERD:
ys, xs = np.ogrid[-5:5:200j, -5:5:200j]
# otherwise same code as above
Echter, sinds imshowondersteunt niet xEN yINGRUIKEN MENAAR MOETEN DE TIKKELS MET DEEL VERANDEREN. Het zou echt handig zijn als het de xen ycoördinaten, toch?
accepteren
Het is gemakkelijk om functies met Numpy die van nature met roosters te schrijven. Bovendien zijn er verschillende functies in Numpy, Scipy, Matplotlib die verwacht dat je het raster in gaat.
Ik hou van afbeeldingen, dus laten we matplotlib.pyplot.contour:
ys, xs = np.mgrid[-5:5:200j, -5:5:200j]
density = np.sin(ys)-np.cos(xs)
plt.figure()
plt.contour(xs, ys, density)
Merk op hoe de coördinaten al correct zijn ingesteld! Dat zou niet het geval zijn als je net bent doorgegeven in de density.
Of om nog een leuk voorbeeld te geven met behulp van Astropy Models (deze keer dat ik niet ‘ Ik geef veel over de coördinaten, ik gebruik ze gewoon om sommige raster te maken):
from astropy.modeling import models
z = np.zeros((100, 100))
y, x = np.mgrid[0:100, 0:100]
for _ in range(10):
g2d = models.Gaussian2D(amplitude=100,
x_mean=np.random.randint(0, 100),
y_mean=np.random.randint(0, 100),
x_stddev=3,
y_stddev=3)
z += g2d(x, y)
a2d = models.AiryDisk2D(amplitude=70,
x_0=np.random.randint(0, 100),
y_0=np.random.randint(0, 100),
radius=5)
z += a2d(x, y)
Hoewel dat alleen “voor het uiterlijk” is, zijn er verschillende functies gerelateerd aan functionele modellen en aanpassing (bijvoorbeeld scipy.interpolate.interp2d,
scipy.interpolate.griddatatonen zelfs voorbeelden met behulp van np.mgrid) in Scipy, enz. vereisen rasters. De meeste van deze werken met open rasters en dichte rasters, maar sommige werken slechts met een van hen.
Antwoord 4, autoriteit 9%
Stel dat je een functie hebt:
def sinus2d(x, y):
return np.sin(x) + np.sin(y)
en u wilt bijvoorbeeld zien hoe het eruit ziet in het bereik van 0 tot 2*pi. Hoe zou je het doen? Daar komt np.meshgridbinnen:
xx, yy = np.meshgrid(np.linspace(0,2*np.pi,100), np.linspace(0,2*np.pi,100))
z = sinus2d(xx, yy) # Create the image on this grid
En zo’n perceel zou eruit zien:
import matplotlib.pyplot as plt
plt.imshow(z, origin='lower', interpolation='none')
plt.show()
Dus np.meshgridis slechts een gemak. In principe kan hetzelfde worden gedaan door:
z2 = sinus2d(np.linspace(0,2*np.pi,100)[:,None], np.linspace(0,2*np.pi,100)[None,:])
Maar daar moet u op de hoogte zijn van uw dimensies (stel dat u meer dan twee …) en de juiste uitzending hebt. np.meshgridDoet dit alles voor u.
MESHGRID stelt u in staat om samen met de gegevens coördinaten te verwijderen als u bijvoorbeeld een interpolatie wilt uitvoeren, maar bepaalde waarden uitsluit:
condition = z>0.6
z_new = z[condition] # This will make your array 1D
Dus hoe zou je nu de interpolatie doen? U kunt xen ygeven aan een interpolatiefunctie zoals scipy.interpolate.interp2d, dus u hebt een manier nodig om te weten welke coördinaten zijn verwijderd:
x_new = xx[condition]
y_new = yy[condition]
En dan kunt u nog steeds interpoleren met de coördinaten “Rechts” (probeer het zonder de MESHGRID en u zult veel extra code hebben):
from scipy.interpolate import interp2d
interpolated = interp2d(x_new, y_new, z_new)
en met de originele meshgrid kun je de interpolatie weer op de originele grid krijgen:
interpolated_grid = interpolated(xx[0], yy[:, 0]).reshape(xx.shape)
Dit zijn slechts enkele voorbeelden waarbij ik de meshgridheb gebruikt, er kunnen er nog veel meer zijn.
Antwoord 5
Kort antwoord
Het doel van meshgridis om python-loops te vervangen(langzaam geïnterpreteerde code) door gevectoriseerde bewerkingen binnen de C NumPy-bibliotheek.
Geleent van deze site.
x = np.arange(-4, 4, 0.25)
y = np.arange(-4, 4, 0.25)
X, Y = np.meshgrid(x, y)
R = np.sqrt(X**2 + Y**2)
Z = np.sin(R)
meshgridwordt gebruikt om coördinatenparen tussen -4 en +4 te maken met stappen van 0,25 in elke richting X en Y. Elk paar wordt vervolgens gebruikt om R en Z daaruit te vinden. Deze manier om een “raster” van coördinaten voor te bereiden, wordt vaak gebruikt bij het plotten van 3D-oppervlakken of het kleuren van 2D-oppervlakken.
Details: Python for-loop vs NumPy vectorbewerking
Om een eenvoudiger voorbeeld te nemen, laten we zeggen dat we twee reeksen waarden hebben,
a = [2,7,9,20]
b = [1,6,7,9]
en we willen een bewerking uitvoeren op elk mogelijk paar waarden, één uit de eerste lijst, één uit de tweede lijst. We willen het resultaat ook opslaan. Laten we bijvoorbeeld zeggen dat we de som van de waarden voor elk mogelijk paar willen krijgen.
Langzame en bewerkelijke methode
c = []
for i in range(len(b)):
row = []
for j in range(len(a)):
row.append (a[j] + b[i])
c.append (row)
print (c)
Resultaat:
[[3, 8, 10, 21],
[8, 13, 15, 26],
[9, 14, 16, 27],
[11, 16, 18, 29]]
Python wordt geïnterpreteerd, deze lussen zijn relatief traag om uit te voeren.
Snelle en gemakkelijke methode
meshgridis bedoeld om de lussen uit de code te verwijderen. Het geeft twee arrays terug (i en j hieronder) die kunnen worden gecombineerd om alle bestaande paren als volgt te scannen:
i,j = np.meshgrid (a,b)
c = i + j
print (c)
Resultaat:
[[ 3 8 10 21]
[ 8 13 15 26]
[ 9 14 16 27]
[11 16 18 29]]
Meshgrid onder de motorkap
De twee arrays die zijn gemaakt door meshgridzijn:
(array([[ 2, 7, 9, 20],
[ 2, 7, 9, 20],
[ 2, 7, 9, 20],
[ 2, 7, 9, 20]]),
array([[1, 1, 1, 1],
[6, 6, 6, 6],
[7, 7, 7, 7],
[9, 9, 9, 9]]))
Deze arrays worden gemaakt door de verstrekte waarden te herhalen. Men bevat de waarden in identieke rijen, de andere bevat de andere waarden in identieke kolommen. Het aantal rijen en kolom wordt bepaald door het aantal elementen in de andere sequentie.
De twee arrays gemaakt door meshgridzijn daarom vorm compatibel voor een vectorbewerking. Stel je voor x en y-sequenties in de code boven aan de pagina Pagina met een ander aantal elementen, X en Y resulterende arrays zullen hoe dan ook vorm compatibel zijn, geen broadcast .
oorsprong
numpy.meshgridKomt van Matlab , zoals vele andere numpe functies. U kunt dus ook de voorbeelden uit Matlab bestuderen om meshgridin gebruik te bekijken, de code voor de 3D-plotten ziet er hetzelfde in Matlab .
6
MESHGRID helpt bij het maken van een rechthoekig raster van twee 1-D-arrays van alle paren punten van de twee arrays.
x = np.array([0, 1, 2, 3, 4])
y = np.array([0, 1, 2, 3, 4])
Nu, als u een functie F (X, Y) hebt gedefinieerd en u deze functie wilt toepassen op alle mogelijke combinatie van punten van de arrays ‘x’ en ‘y’, dan kunt u dit doen:
f(*np.meshgrid(x, y))
Stel, als uw functie slechts het product van twee elementen produceert, dan is dit hoe een cartesiaans product kan worden bereikt, efficiënt voor grote arrays.
Verwezen vanaf hier