Phenquestions
Net zo SciPy is open source, het heeft een zeer actieve en levendige gemeenschap van ontwikkelaars waardoor er een enorm aantal modules aanwezig zijn voor een enorme hoeveelheid wetenschappelijke toepassingen en berekeningen die beschikbaar zijn met SciPy. Enkele van de complexe wiskundige bewerkingen die met SciPy kunnen worden uitgevoerd zijn:
- Interpolatie
- integratie
- Optimalisatie
- Afbeelding verwerken
- Statistieken
- Speciale functieberekeningen etc.
SciPy kan worden vergeleken met de meeste commando- en standaardbibliotheken zoals de GSL-bibliotheek voor C++ en Matlab. Omdat SciPy bovenop het NumPy-pakket is gebouwd, kunnen deze twee pakketten ook volledig worden geïntegreerd. Als u een wiskundige bewerking kunt bedenken die moet worden uitgevoerd, controleer dan de SciPy-bibliotheek voordat u die module zelf implementeert, want in de meeste gevallen heeft SciPy alle bewerkingen voor u al volledig geïmplementeerd.
Installeer SciPy-bibliotheek
Laten we de SciPy-bibliotheek installeren voordat we naar de daadwerkelijke voorbeelden en concepten gaan. Er zijn twee manieren om dit pakket te installeren:. De eerste omvat het gebruik van de Python-pakketbeheerder, pip:
pip installeer scipyDe tweede manier heeft betrekking op Anaconda, we kunnen het pakket installeren als:
conda install -c anaconda scipyNadat de bibliotheek is geïnstalleerd, kunnen we deze importeren als:
importeer scipyTen slotte, omdat we NumPy ook zullen gebruiken (het wordt aanbevolen dat we voor alle NumPy-bewerkingen NumPy rechtstreeks gebruiken in plaats van door het SciPy-pakket te gaan):
import numpyHet is mogelijk dat we in sommige gevallen ook onze resultaten willen plotten waarvoor we de Matplotlib-bibliotheek zullen gebruiken. Voer de volgende import voor die bibliotheek uit:
matplotlib importerenIk zal de Anaconda-manager gebruiken voor alle voorbeelden in deze les. Ik zal hiervoor een Jupyter Notebook starten:
Nu we klaar zijn met alle importinstructies om wat code te schrijven, laten we beginnen met een duik in het SciPy-pakket met enkele praktische voorbeelden.
Werken met veeltermvergelijkingen
We beginnen met te kijken naar eenvoudige veeltermvergelijkingen. Er zijn twee manieren waarop we Polynomiale functies in ons programma kunnen integreren. We kunnen gebruik maken van poly1d klasse die gebruik maakt van coëfficiënten of de wortels van een polynoom voor het initialiseren van een polynoom. Laten we een voorbeeld bekijken:
van numpy import poly1dfirst_polynoom = poly1d([3, 4, 7])
print(first_polynoom)
Wanneer we dit voorbeeld uitvoeren, zien we de volgende uitvoer:
Het is duidelijk dat de polynomiale weergave van de vergelijking wordt afgedrukt als de uitvoer, zodat het resultaat vrij gemakkelijk te begrijpen is. We kunnen ook verschillende bewerkingen op deze polynoom uitvoeren, zoals het kwadraat ervan, de afgeleide ervan vinden of zelfs oplossen voor een waarde van x. Laten we proberen dit allemaal te doen in het volgende voorbeeld:
print("Polynoomvierkant: \n")print(eerste_polynoom * eerste_polynoom)
print("Afgeleide van Polynoom: \n")
print(first_polynoom.deriv())
print("De veelterm oplossen: \n")
print(first_polynoom(3))
Wanneer we dit voorbeeld uitvoeren, zien we de volgende uitvoer:
Net toen ik dacht dat dit alles was wat we konden doen met SciPy, herinnerde ik me dat we ook een polynoom kunnen integreren. Laten we een laatste voorbeeld uitvoeren met Polynomen:
print("De polynoom integreren: \n")print(first_polynoom.geheel (1)
Het gehele getal dat we doorgeven, vertelt het pakket hoe vaak de polynoom moet worden geïntegreerd:
We kunnen eenvoudig een ander geheel getal doorgeven dat het pakket vertelt hoe vaak deze polynoom moet worden geïntegreerd.
Lineaire vergelijkingen oplossen
Het is zelfs mogelijk om lineaire vergelijkingen op te lossen met SciPy en hun wortels te vinden, als ze bestaan. Om lineaire vergelijkingen op te lossen, stellen we de reeks vergelijkingen voor als NumPy-arrays en hun oplossing als afzonderlijke NumPy-arrays. Laten we het visualiseren met een voorbeeld waarin we hetzelfde doen en gebruik maken van linalg pakket om de wortels van de vergelijkingen te vinden, hier zijn de vergelijkingen die we gaan oplossen:
1x + 5j = 63x + 7y = 9
Laten we de bovenstaande vergelijkingen oplossen:
van scipy import linalgvergelijking = np.reeks([[1, 5], [3, 7]])
oplossing = np.reeks([[6], [9]])
wortels = linalg.oplossen (vergelijking, oplossing)
print("De wortels gevonden:")
afdrukken (wortels)
print("\n Puntproduct moet nul zijn als de oplossingen correct zijn:")
print(vergelijking).punt (wortels) - oplossing)
Wanneer we het bovenstaande programma uitvoeren, zullen we zien dat de puntproductvergelijking nul resultaat geeft, wat betekent dat de wortels die het programma vond correct waren:
Fourier-transformaties met SciPy
Fourier-transformaties helpt ons een functie uit te drukken als afzonderlijke componenten waaruit die functie bestaat en begeleidt ons over de manier waarop we die componenten kunnen recombineren om de oorspronkelijke functie terug te krijgen.
Laten we eens kijken naar een eenvoudig voorbeeld van Fourier-transformaties waarbij we de som van twee cosinuslijnen plotten met behulp van de Matplotlib-bibliotheek:
van scipy.fftpack import fft# Aantal monsterpunten
N = 500
# steekproefafstand
T = 1.0 / 800.0
x = np.linspace (0.0, N*T, N)
y = np.cos(50.0 * 2.0* np.pi * x) + 0.5 * np.cos(80.0 * 2.0 * np.pi * x)
yf = fft(y)
xf = np.linspace (0.0, 1.0/(2.0 * T), N//2)
# matplotlib voor plotdoeleinden
matplotlib importeren.pyplot als plt
plt.plot (xf, 2.0/N * np.abs(yf[0:N//2]))
plt.titel('Info')
plt.ylabel('Y-as')
plt.xlabel('X-as')
plt.raster()
plt.tonen()
Hier zijn we begonnen met het construeren van een steekproefruimte en cosinusvergelijking die we vervolgens hebben getransformeerd en geplot. Hier is de output van het bovenstaande programma:
Dit is een van de goede voorbeelden waarin we zien dat SciPy wordt gebruikt in een complexe wiskundige vergelijking om dingen gemakkelijk te visualiseren.
Vectoren en Matrix met SciPy
Nu we veel weten waartoe SciPy in staat is, kunnen we er zeker van zijn dat SciPy ook kan werken met vectoren en matrix. De matrices zijn een belangrijk onderdeel van lineaire algebra, aangezien matrices ook iets zijn dat we gebruiken om vectorafbeeldingen weer te geven.
Net zoals we keken naar het oplossen van lineaire vergelijkingen met SciPy, kunnen we vectoren voorstellen met np.reeks() functies. Laten we beginnen met het construeren van een matrix:
mijn_matrix = np.matrix(np.willekeurig.willekeurig((3, 3)))print(mijn_matrix)
Hier is de uitvoer van het bovenstaande fragment:
Wanneer we het over matrices hebben, hebben we het altijd over eigenwaarden en eigenvectoren. Simpel gezegd, Eigenvectoren zijn de vectoren die, wanneer ze worden vermenigvuldigd met een matrix, hun richting niet veranderen, in tegenstelling tot de meeste vectoren. Dit betekent dat zelfs als je een eigenvector vermenigvuldigt met een matrix, er een waarde (of eigenwaarde) bestaat die een van de factor van de vermenigvuldiging is. Dit betekent:
Ax = λx.In bovenstaande vergelijking is A de matrix, λ is de eigenwaarde en x is de vector. Laten we een eenvoudig codefragment schrijven om de eigenwaarden voor een bepaalde vector te vinden:
la, vector = linalg.eig(mijn_matrix)afdrukken(vector[:, 0])
afdrukken(vector[:, 1])
print(linalg).eigvals(mijn_matrix))
Wanneer we dit voorbeeld uitvoeren, zien we de volgende uitvoer:
Berekeningsmatrixdeterminant
De volgende bewerking die we met SciPy zullen uitvoeren, is het berekenen van de determinant van een 2-dimensionale matrix. We zullen de matrix die we in het laatste codefragment hebben gebruikt hier opnieuw gebruiken:
linalg.det( mijn_matrix )Wanneer we dit voorbeeld uitvoeren, zien we de volgende uitvoer:
Conclusie
In deze les hebben we veel goede voorbeelden bekeken waar SciPy ons kan helpen door complexe wiskundige berekeningen voor ons uit te voeren met een gebruiksvriendelijke API en pakketten.
