Numpy på tvers av metoden

I dag lærer vi om ARCCOS () -metoden og hvordan vi implementerer ARCCOS () -metoden i Python ved å bruke et av de viktige bibliotekene i Python som er Numpy. Numpy brukes til å beregne de numeriske verdiene. Vi implementerer en av de inverse trigonometriske funksjonene som er ARCCOS () -metoden.

I matematikk er Arccos () -funksjonen den inverse av COS () -funksjonen, og den kan skrives som COS-1. Når vi bruker ARCCOS () -funksjonen til Numpy Array, utfører den funksjonselementet-for-element.

Syntaks:

La oss nå diskutere skrivestilen og implementeringen av Arccos () -funksjonen i Numpy Python. Først skriver vi biblioteknavnet som vi bruker i hele artikkelen som er numpy fordi det brukes til å beregne de numeriske verdiene. Deretter sammenkobler vi funksjonsnavnet vi bruker “Arccos () -funksjonen” med Numpy -pakken. Deretter passerer vi parametrene for å beregne det inverse av COS i den.

Parametere:

x: Inngangsarrayen som vi implementerer Arccos () -funksjonen for å få ønsket utgang.

ute: Formen på matrisen som vi får til gjengjeld. Den forteller oss også på hvilket sted som resultatet av Arccos () -funksjonen er lagret i Python.

Returverdi:

Til gjengjeld får vi inverse av cos () -funksjonen ved å bruke arccos () -funksjonen på den.

Eksempel 1:

La oss begynne å skrive det aller første og enkleste eksemplet på Numpy, slik at det lett kan være forståelig for brukeren på hva vi gjør i dette eksemplet. Derfor må vi ta det enkle eksemplet på Arccos () -funksjonen. Først må vi åpne en hvilken som helst Python -kompilator slik at vi kan implementere koden. Her bruker vi Jupyter Notebook for sammenstilling og utførelse av programkoden vår.

Deretter installerer vi Numpy -pakken fordi vi implementerer en av de viktige funksjonene til Numpy som er Arccos (). Etter installasjonen av Numpy -pakken importerer vi pakken til kompilatoren vår. Først skriver vi alltid nøkkelordet "import" som forteller kompilatoren at vi importerer pakken. Deretter skriver vi pakketavnet som vi bruker i programmet som er "numpy". Deretter kan vi også skrive Numpy Package Alias ​​som er "NP".

Importer numpy som NP
print ("Implementering av enkelt eksempel på arccos () -funksjon: \ n")
Array = NP.Arange (-1, 1)
Print ("Inngangsarrayen er:", ARR)
arccos_array = np.Arccos (ARR)
print ("\ n the inverse of cos verdier er:", arccos_array)

Etter å ha importert pakken, begynner vi å skrive den faktiske kodelinjen som vi ønsker å implementere i programmet. Vi skriver ut meldingen ved hjelp av Print () -metoden. Det er den forhåndsdefinerte metoden, som brukes til å vise dataene vi ønsker å vise. Etter dette oppretter vi inngangsarray. Deretter passerer vi argumentene i det. Deretter viser vi inngangsarrayen ved å kalle metoden Print () igjen.

Etter opprettelsen av inngangsarrayen tar vi inverse av inngangsfunksjonen. For det skriver vi først Numpy Alias ​​“NP” og deretter sammenkobler det med Arccos () -funksjonen. Deretter passerer vi argumentet som er inngangsarrayen i den. Og så viser vi matrisen ved å kalle metoden Print () igjen. La oss se utdataene fra dette eksemplet og sjekke om vi får ønsket utgang eller ikke:

Som du ser, fikk vi den ønskede utgangen av det tidligere forklarte eksemplet.

Eksempel 2:

La oss begynne å implementere vårt andre eksempel på Arccos () -funksjonen. For å begynne å skrive vårt neste eksempel, importerer vi først biblioteket som vi bruker i programmet vårt som er numpy. Her bruker vi bare dette biblioteket fordi vi beregner det inverse av COS. Først skriver vi nøkkelordet "import" som brukes til å importere bibliotekene i Python -programmering. Deretter skriver vi biblioteknavnet som vi bruker her som er "numpy". Vi kan også skrive det alternative navnet på Numpy som er "NP" som vi bruker. Å bruke "NP" i stedet for å skrive hele biblioteknavnet er en god programmeringstilnærming og programmerere bruker vanligvis denne tilnærmingen.

Etter å ha importert pakken bruker vi en utskrift () -uttalelse for å vise meldingen slik at brukeren lett kan forstå koden. Deretter oppretter vi matrisen ved hjelp av en av matrisefunksjonene som er Linspace () -funksjonen som brukes til å plassere elementene i inngangsarrayen jevnt. Vi bruker først "NP" og deretter sammenkobler Linspace () -funksjonen med den og passerer argumentene i den. Det første argumentet er “0” som er startverdien. Avslutningsverdien er “Pi” som vi skriver ved å kalle Pi () -funksjonen til Numpy. Da er “10” antall elementer i matrisen. Vi lagrer hele denne funksjonen i en annen matrise som heter “Array”, så vi trenger ikke å skrive denne funksjonen igjen i programmet.

Deretter kaller vi en annen funksjon av numpy som er cos () -funksjonen. Her beregner vi COS for inngangsarrayen. Først skriver vi “NP”. Deretter kaller vi COS () -funksjonen og passerer inngangsarrayen i den, og lagrer den i en annen matrise som heter “COS_ARR”. Deretter kaller vi den faktiske funksjonen som vi ønsker å implementere, som er Arccos () -funksjonen. Først skriver vi “NP” og sammenkobler Arccos () -funksjonen med den og passerer inngangsarrayen i den. Vi lagrer denne funksjonen i en annen matrise som heter “Arcos_arr”.

Importer numpy som NP
Print ("Implementering av Arccos -metoden i Numpy Python: \ n")
Array = NP.Linspace (-3, 3, 10)
Print ("Inngangsarrayen er: \ n", Array)
cos_arr = np.cos (matrise)
print ("\ n the cos array er: \ n", cos_arr)
arccos_arr = np.Arccos (Array)
Print ("\ n the Arccos Array er: \ n", arccos_arr, "\ n")

Etter å ha ringt denne forrige funksjonen, får vi følgende utdata:

Nå må vi plotte disse resulterende matriser i en graf ved hjelp av en annen pakke med Python -programmering som er "matplotlib". Den brukes til å vise den visuelle grafen. Først skriver vi nøkkelordet "import". Deretter skriver vi pakketavnet “Matplotlib” og sammenkobler det med “Pyplot” som er modulen “Matplotlib” som betyr “Python Plot”. Deretter skriver vi aliaset “PLT”.

Importer matplotlib.Pyplot som Plt
plt.plot (matrise, cos_arr, color = "svart", markør = "*")
plt.plot (matrise, arccos_arr, color = "gul", markør = "o")
plt.Tittel ("Black: Numpy.cos () \ n gul: numpy.Arccos () ")
plt.Xlabel ("X-Axis")
plt.Ylabel ("Y-Axis")
plt.forestilling()

Deretter kaller vi plottet () -funksjonen med "PLT" aliaset og passerer parametrene i den som er inngangsarrayen, cos_arr og fargen og markøren til x-aksen. Deretter kaller vi plottet () -funksjonen igjen for y-aksen. Deretter skriver vi tittelen på grafen, x-aksen og y-aksen og viser grafen ved hjelp av matplotlibs forskjellige funksjoner.

Her er den visuelle representasjonen av ARCCOS () -funksjonen ved hjelp av Matplotlib -pakken:

Konklusjon

I denne artikkelen lærte vi om Arccos () -funksjonen og hvordan vi implementerer denne funksjonen i Python. Vi lærte et annet bibliotek med Python som er matplotlib -pakken for å plotte grafen. Vi implementerte også flere eksempler på Arccos () -funksjonen med en detaljert forklaring av hver kodeinje.