Seite 4 von 23
Re: kleine Mathe-Spielereien
Verfasst: Dienstag 14. Juni 2022, 16:56
von OSWALD
Code: Alles auswählen
[
Eine ganz simple Funktion in Python. Einfacher geht es nicht mehr.
#######################################
import math
from math import *
def versuch(x):
return (3*x +x**3 - 4*16 + sin(x) - exp(1/2) + 1/log(3 ) * 1000 )
def main():
ergebnis = versuch(3 )
print(ergebnis)
if __name__ == "__main__":
main()
########################################
Wie könnte man daraus eine App entwickeln ? Eine Exe.Datei , die in jeder Umgebung
läuft. Wo kann man eine brachbare Anleitung dazu finden ?
Gute Zeit OSWALD
/code]
Re: kleine Mathe-Spielereien
Verfasst: Dienstag 14. Juni 2022, 17:30
von __blackjack__
@OSWALD: Das will man gar nicht, denn je einfacher das Programm ist, um so weniger Sinn macht es das irgendwie plattformspezifisch zu verpacken, statt einfach die *.py-Datei weiter zu geben und zu sagen, das man dafür Python installieren muss.
Eine EXE-Datei die in jeder Umgebung läuft ist ja schon nicht wirklich möglich. Das ist ja in der Regel Windows. Also nicht Linux oder Mac beispielsweise.
Re: kleine Mathe-Spielereien
Verfasst: Mittwoch 15. Juni 2022, 10:19
von OSWALD
Code: Alles auswählen
[/
Hallo _Blackjack_ , volle Zustimmung. schließlich ist Python "opensource" und der Aufwand wäre unverhältnismäßig
groß.
Hier jetzt noch ein Beispiel , wie man die letztgenannte Funktion nützlich in der Praxis
anwenden kann.
Eine logarithmische Reihe für den natürlichen Logarithmus ist gegeben.
Die Reihe konvergiert gfegen 1.
das erste 'return' bearbeitet die Originalreihe
das zweite 'return beginnt mit dem ersten Glied und springt dann
auf einen Wert, der bereits auf den Grenzwert hindeutet.
mport math
from math import *
def versuch(x):
# return x - (x**2)/2 +(x**3)/3 - (x**4)/4+ (x**5)/5 -(x**6)/6 + (x**7)/7 - (x**8)/8 + (x**9)/9 - (x**20)/20
return x - (x**300) /300
def main():
ergebnis = versuch(1 )
print(ergebnis)
if __name__ == "__main__":
main()
########################################
code]
Re: kleine Mathe-Spielereien
Verfasst: Samstag 25. Juni 2022, 16:25
von OSWALD
Code: Alles auswählen
[/
25.05.2022
Über die Berechnung der Bogenlänge von Funktionen.
Im Internet ein viel diskutiertes und schwieriges Thema.
Hier mein Versuch, Probleme mit numerischen Mitteln zu lösen.
Aufgabe : Die Bogenlänge der Funktion - Wurzel aus x**3
Mit den Grenzen von 0 bis 4
Mein Ergebnis 9.0
def func_f(x):
return ( 1+ (x **3/2)**2)**1/2
def main():
unten=int(input("unten :", )) # Untergrenze =0
oben =int(input("oben ,",)) # Obergrenze = 4
partial_o =[]
for x in range(unten,oben):
x = 1+(oben**(3/2 ) )
x= x**2
x = x **(1/2)
print(x)
partial_o.append(x)
print((partial_o))
############################
Gute Zeit OSWALD
code]
Re: kleine Mathe-Spielereien
Verfasst: Samstag 25. Juni 2022, 16:59
von OSWALD
Code: Alles auswählen
[
f __name__ == "__main__":
main()
Entschuldigung ,das 'gute Stück ging offenbar verloren.
Bitte ganz am Ende einfügen
Oswald
]
Re: kleine Mathe-Spielereien
Verfasst: Dienstag 28. Juni 2022, 12:28
von OSWALD
Code: Alles auswählen
[
Mit der Berechnung der Bogenlänge
von Funktionen anhand der vorgegebenen Formel - ( 1+ (f' (x)**2)**(1/2) )
konnte mit Python eine gute Näherung der Ergebnisse erreicht
werden. Die Plausibilität der Ergebnisse konnte mit Hilfe eines
Funktionsplotters bestätigt werden.
Es geht hier nicht um eine mathematisch genaue Berechnung,
sondern um die Frage , wie weit die z.T. komplizierten
mathematischen Berechnungen der Bogenlänge mit Python
(ohne Bilbiothken) umgangen werden können.
Dazu hier einige Beispiele mit jeweils leichten Veränderungen.
Alles im Sinne von 'Mathe-Spielereien '.
######################
#######Bogenlänge
def func_f(x):
#
return 1+(4*x**2 ) **(1/2)
def main():
unten=int(input("unten :", ))
oben =int(input("oben :", ))
partial_o =[]
partial_u= []
for x in range(unten,oben):
x = (1+(4* oben **2 )) **(1/2)
partial_o.append(x)
print(sum(partial_o))
y = (1+(4* unten **2 )) **(1/2)
partial_u.append(y)
print(sum(partial_u))
if __name__ == "__main__":
main()
# mit Grenzwert 0/1 2.23606797749979
##################################
##########Bogenlänge mit cosh/sinh
import math
from math import sinh, cosh
def func_f(x):
return 1+(cosh(x/2)**3**(1/2))
def main():
unten=int(input("unten :", ))
oben =int(input("oben :", ))
partial_o =[]
for x in range(unten,oben):
x = 1+ (cosh(x/2))
x = x**2
x = x **(1/2)
partial_o.append(x)
print(sum(partial_o))
print(x)
if __name__ == "__main__":
main()
#Ergebnis Grenzen 0/2 = 3.120/3
# 0/3 = 4.12
# 0/4 = 6.67##########Bogenlänge Funktion
############## Bogenlänge mit 4*x** +6
import math
from math import *
def func_f():
return ( 1+ (4*x**2 +6)** 2 )** (1/2)
def main( ):
unten = float(input("unten : ",))
oben = float(input("oben : " ,))
partial_o =[]
partial_u =[]
x = (1+ (4*oben**2 + 6)**2)
x= x**(1/2)
y = (1+ (4*unten**2+ 6)**2)
y = y**(1/2)
partial_o.append(x)
partial_u.append(y)
print(sum(partial_o) )
print(sum(partial_u))
if __name__ == "__main__":
main()
#Ergebnis Genzen 0/1 = 10.04
Gute Zeit OSWALD 28,06.2022
/code]
Re: kleine Mathe-Spielereien
Verfasst: Freitag 1. Juli 2022, 16:41
von OSWALD
Code: Alles auswählen
[
###### Bogenlänge ermitteln , verbesserter Algorithmus
###### Grenzwerte als float-Variablen, beliebige Schrittweite
###### keine for-Schlefe Summenbildung über Listenimport ath
###### Änderung des Vorzeichens von e -->> neue Grafik u. Ergebnisse
from math import *
def func_f(x):
# f1 = 1+ x**e
return (1+ (x**e**2)**(1/2))
def main():
unten=float(input("unten :", )) #
oben =float(input("oben :",)) #
partial_o =[]
partial_u =[]
x= oben**e
x= x **2
x = (1+ x )**(1/2)
print(x)
partial_o.append(x)
print(sum(partial_o))
y= unten**e
y= y **2
y = (1+ y)**(1/2)
print(y)
partial_o.append(y)
print(sum(partial_u))
if __name__ == "__main__":
main()
### Grenzen 0.5 / 1.5 = 3.17 + 1.09
### 0.5/ 1.75 = 4.68 + 1.01
### 0 / 2 = 6.65
########## nächstes Beispiel
import math
def func_f(x):
f1 = (2*x +4)*(x -3)
return (1+ (5*x**2 +4*x -12)**2)**(1/2) # zuerst quadrieren
def main():
unten=float(input("unten :", ))
oben =float(input("oben :",))
partial_o =[]
partial_u =[]
x= ( 5*oben**2 + 4*oben -12)
x= x **2
x = (1+ x) **(1/2)
partial_o.append(x)
print(sum(partial_o))
y= ( 5*unten**2 + 4*unten -12)
y= x **2
x = (1+ x) **(1/2)
partial_o.append(y)
print(sum(partial_u))
if __name__ == "__main__":
main()
#########Grenzwerte -1 / 0.5 = 8.8
########### 1 / 0.5 =.3.16
Gute Z eit OSWALD
/code]
Re: kleine Mathe-Spielereien
Verfasst: Dienstag 5. Juli 2022, 11:11
von OSWALD
Der Versuch ,die Bogenlänge von Polynomen mit zwei oder mehr S ummanden
rein numerisch zu bestimmen, muss aufgegeben werden. Das scheint un möglich zu sein.
Im Internet werden kaum Beispiele mit der Berechnung v on Plynomen gezeigt.
Re: kleine Mathe-Spielereien
Verfasst: Sonntag 10. Juli 2022, 15:20
von OSWALD
Code: Alles auswählen
[/
Noch einmal für Interessierte am Thema "Berechnung der Bogenlänge".
Ich habe zufällig diese kleine aber kompakte Programm bei der Lektüre
eines Sympy -Tutorials gefunden, und natürlich nicht verstanden.
from sympy import *
x=symbols('x')
y=x**3 + 4* -5
a,b=0.9 ,2.4
z=sqrt(1+diff(y,x)**2)
s=integrate(z,(x,a,b))
print("Bogenlänge für y =",y)
print("Grenzen: a = %2.1f, b = %2.1f" %(a,b))
print("Bogenlänge s =",N(s,7))
Ich habe die Stammfunktion und die Grenzen mehrmals verändert.
Das Programm ist übermächtig. Olympisch. Demut und Respekt.
Gute Zeit OSWALD
code]
Re: kleine Mathe-Spielereien
Verfasst: Sonntag 10. Juli 2022, 22:31
von Dennis89
Hallo,
OSWALD hat geschrieben: ↑Sonntag 10. Juli 2022, 15:20
und natürlich nicht verstanden.
Was genau hast du denn nicht verstaden?
Ist es so verständlicher?
Code: Alles auswählen
import sympy
GRENZE_FUER_A = 0.9
GRENZE_FUER_B = 2.4
def main():
x = sympy.symbols('x')
bogenlänge_y = x**3 + 4 * -5
# sqrt ist die Wurzel
# diff ist die Ableitung
z = sympy.sqrt(1 + sympy.diff(bogenlänge_y, x) ** 2)
# integrate ist die Integration
s = sympy.integrate(z, (x, GRENZE_FUER_A, GRENZE_FUER_B))
# N wandelt das sympy-Objekt in eine Dezimalzahl
bogenlänge_s = sympy.N(s, 7)
print(f"Bogenlänge für y = {bogenlänge_y}")
print(f"Grenzen: a = {GRENZE_FUER_A}, b = {GRENZE_FUER_B}")
print(f"Bogenlänge s = {bogenlänge_s}")
if __name__ == '__main__':
main()
Grüße
Dennis
Re: kleine Mathe-Spielereien
Verfasst: Montag 11. Juli 2022, 15:29
von OSWALD
Code: Alles auswählen
[/
Hallo Dennis, vielen Dank für Dein aufklärendes Programm.
Jetzt glaube ich alles verstanden zu haben. Auch die
Bedeutung des 'N' kenne ich jetzt.
Ich will nun versuchen , durch ein Zusatzprogramm gleichzeitig
die untersuchte Funktion darzustellen, und eventuell auch die Bogenlänge
irgendwie zu optisch anzuzeigen. Mal sehen.
Gute Zeit OSWALD
ode]
Re: kleine Mathe-Spielereien
Verfasst: Freitag 15. Juli 2022, 09:35
von OSWALD
Code: Alles auswählen
[/c 15.07.2022
# Bogenlänge und visuelle Darstellung der untersuchten Funktion
# Die visuelle Darstellung der Bogenlänge kann nur 'symbolisch ' erfolgen,
# also wiederum "Spielerei".
import sympy
GRENZE_FUER_A = 0
GRENZE_FUER_B = 2
def main():
x = sympy.symbols('x')
bogenlänge_y = 3*x**2 + 3*x
# sqrt ist die Wurzel
# diff ist die Ableitung
z = sympy.sqrt(1 + sympy.diff(bogenlänge_y, x) ** 2)
# integrate ist die Integration
s = sympy.integrate(z, (x, GRENZE_FUER_A, GRENZE_FUER_B))
# N wandelt das sympy-Objekt in eine Dezimalzahl
bogenlänge_s = sympy.N(s, 7)
print(f"Bogenlänge für y = {bogenlänge_y}")
print(f"Grenzen: a = {GRENZE_FUER_A}, b = {GRENZE_FUER_B}")
print(f"Bogenlänge s = {bogenlänge_s}")
if __name__ == '__main__':
main()
import matplotlib.pyplot as plt
import numpy as np
from math import *
x = np.linspace(-2,2,100)
# Hier die Funktion - wie oben - noch einmal eintragen #
y = 3*x**2 + 3*x
# Hier optional die angezeigte Bogenlänge zwei mal in gleicher Form eintragen
vec= 1,18,18
#################
# Achsen zentrieren
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
ax.spines['left'].set_position('center')
ax.spines['bottom'].set_position('zero')
ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none')
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')
# Funktion plotten
plt.plot(x, y, vec, 'y',label = 'Bogenlänge' )
plt.legend(loc='upper left')
plt.show()
###############################
G ute Zeit OSWALD
ode]
Re: kleine Mathe-Spielereien
Verfasst: Montag 18. Juli 2022, 16:45
von OSWALD
Code: Alles auswählen
[
Die Parabel -
# Beliebige Darstellungen der Parabel , Ermittlung wichtiger Parameter
# und Lösungen.
# NB. Wenn eine quadratische Funktion in dieser Form vorliegt,
# kann man die Koordinaten des Scheitelpunktes sofort erkennen.
# y = 3·(x – 4)² + 6 S4 / 6)
# y = 4·(x – 2)² – 5 S2 / -5)
# y = 2·(x + 3)² + 1 S3 / 1)
import matplotlib.pyplot as plt
import math
import numpy as np
a = int(input("Bitte Koeffizient 'a' eingeben : " , ))
b = int(input("Bitte Koeffitient 'b' eingeben : " , ))
c = int(input("Bitte Koeffizient 'c' eingeben : " , ))
# calculate delta and zero points
delta = b**2 - 4*a*c
if delta > 0:
x_1 = (-b + math.sqrt(delta))/(2*a)
x_2 = (-b - math.sqrt(delta))/(2*a)
if delta == 0:
x_0 = -b/(2*a)
else:
pass
# calculate parabola extreme coordinates
p = -b/(2*a)
q = -delta/(4*a)
extreme = [p,q]
# define parabola function
def parabola(x,a,b,c):
y = a*x**2 + b*x + c
return y
# plot function
x = np.linspace(int(p)-5,int(p)+5,100)
y = parabola(x
,a,b,c)
plt.plot(x,y)
plt.axhline(y=0, color='black', linestyle='-')
plt.axvline(x=0, color='black', linestyle='-')
plt.text(p-0.5, q-3, '[' + str(round(p,2)) +',' + str(round(q,2)) + ']',color='red', fontsize=9)
plt.plot(p, q, marker="o")
if delta > 0:
plt.plot(x_1, 0, marker="o", color='green')
plt.text(x_1 - 0.5, 2, '[' + str(round(x_1,2)) + ']', color='green', fontsize=9)
plt.plot(x_2, 0, marker="o", color='green')
plt.text(x_2 - 0.5, 2, '[' + str(round(x_2,2)) + ']', color='green', fontsize=9)
print("p = ",- b/(2*a) )
print("q = ",-delta/(4*a))
print("Scheitelpunkt =", [p,q])
print("Leitlinienabstand von Scheitel", 1/2*p)
# print ("Gleichung 2.Grades mit den Koeffizienten a,b und c lösen")
if delta == 0:
plt.plot(x_0, 0, marker="o", color='green')
plt.text(x_0 - 0.5, 2, '[' + str(round(x_0,2)) + ']', color='green', fontsize=9)
plt.show()
###################
import math
from math import*
print("Bitte jetzt die gleichen Koeffizienten e r n e u t eingeben ")
print()
a = float(input("Bitte 'a ' eingeben:" ,))
b = float(input("Bitte 'b' eingeben:, "))
c = float(input("Bitte 'c ' eingeben: , "))
d = b*b-4*a*c
if d > 0:
x1 = (-b - sqrt(d))/(2*a)
x2 = (-b + sqrt(d))/(2*a)
print ("Die Gleichung hat die beiden Lösungen:")
print( 'x1 =',x1,'; x2 =',x2)
elif d == 0:
print ("Die Gleichung hat die Lösung:")
print('x =',x1)
else:
print( "Die Gleichung hat keine Lösung!")
# „Wer immer strebend sich bemüht, den können wir erlösen" (Faust II Goethe)
Gute Zeit OSWALD
/code]
Re: kleine Mathe-Spielereien
Verfasst: Mittwoch 27. Juli 2022, 17:33
von OSWALD
Code: Alles auswählen
[
#Ein erster Versuch zum EEinstieg
#in die Visualisation der Normalverteilung
#sowie in ScipY
import numpy as np
import matplotlib.pyplot as plt
import scipy
from scipy import stats
x = np.linspace(-3,3,100)
pdf_result = stats.norm.pdf(x,loc=0,scale=1)
plt.plot(x,pdf_result)
plt.xlabel('x-data')
plt.ylabel('pdf_value')
plt.title("PDF of a Normal Distribution with mean=0 and sigma=1")
#plt.show()
x = np.linspace(-3,3,100)
pdf_result = stats.norm.pdf(x,loc=0,scale=1)
plt.plot(x,pdf_result)
plt.xlabel('x-data')
plt.ylabel('pdf_value')
plt.title("PDF of a Normal Distribution with mean=0 and sigma=1")
#plt.show()
x = np.linspace(-3,3,100)
cdf_values = stats.norm.cdf(x,loc=0,scale=1)
plt.plot(x,cdf_values)
plt.xlabel('x-data')
plt.ylabel('pdf_value')
plt.title("CDF of a Normal Distribution with mean=0 and sigma=1")
plt.show()
#CDF einer Normalverteilung mit mean=3 und sigma=2
#Beispielcode: Berechnung des Werts der kumulativen Verteilungsfunktion (CDF) an einem Punkt mit scipy.stats.norm()
x = 2
cdf_value = stats.norm.cdf(x,loc=0,scale=1)
print("CDF Value of x=2 in normal distribution with mean 0 and standard deviation 1 is :"+str(cdf_value))
#+CDF Value of x=2 in normal distribution with mean 0 and standard deviation 1 is :0.9772498680518208.
#Es impliziert die Wahrscheinlichkeit des Auftretens eines Wertes kleiner oder gleich 2,
#während die Stichprobe aus einer Normalverteilung mit Mittelwert = 0 und Standardabweichung 1: 0,977 beträgt.
#Beispielcodes: Berechnung von Zufallsvariablen (rvs) der Verteilung mit scipy.stats.norm()
rvs_values = stats.norm.rvs(loc = 5, scale = 10, size = (5,2))
print("The random generated value are\n",rvs_values)
x = np.linspace(-3,3,100)
cdf_values = stats.norm.cdf(x,loc=0,scale=1)
plt.plot(x,cdf_values)
plt.xlabel('x-data')
plt.ylabel('pdf_value')
plt.title("CDF of a Normal Distribution with mean=0 and sigma=1")
plt.show()
#CDF einer Normalverteilung mit mean=3 und sigma=2
x = 2
cdf_value = stats.norm.cdf(x,loc=0,scale=1)
print("CDF Value of x=2 in normal distribution with mean 0 and standard deviation 1 is :"+str(cdf_value))
#Beispielcodes: Berechnung von Zufallsvariablen (rvs) der Verteilung mit scipy.stats.norm()
rvs_values = stats.norm.rvs(loc = 5, scale = 10, size = (5,2))
print("Zufallswerte",rvs_values)
print("mit My =5 und sigma = 2")
#Wahrscheinlichkeitsverteilungsfunktion (PDF) der gegebenen Beobachtungen zu generieren.
x = np.linspace(-3,3,100)
pdf_result = stats.norm.pdf(x,loc=0,scale=1)
plt.plot(x,pdf_result)
plt.xlabel('x-data')
plt.ylabel('pdf_value')
plt.title("PDF of a Normal Distribution with mean=0 and sigma=1")
plt.show()
x = 2
cdf_value = stats.norm.cdf(x,loc=0,scale=1)
print("CDF Value of x=2 in normal distribution with mean 0 and standard deviation 1 is :"+str(cdf_value))
#### „Wer immer strebend sich bemüht, den können wir erlösen" (Faust II Goethe)
# Gute Zeit Oswald
/code]
Re: kleine Mathe-Spielereien
Verfasst: Sonntag 31. Juli 2022, 16:45
von OSWALD
Code: Alles auswählen
[
Fehler weitestgehend beseitigt. Jedenfalls ein scbhönes Stück Arbeit.
Man muss sich hier schon etwas einlesen. Dann kann man sich mit den vorhandenen Paramtern
schon ' etwas spielen'. und auch an die eigentliche Arbeit gehen.
Code läuft auf Spyder X .
#Parameter
#x Zufallsvariable
#q .Wahrscheinlichkeiten
#loc Mittelwert der Verteilung .
#scal Standardabweichung der Verteilung Standard ist 1,0.
#size Zahl der Zufallsvariablen
########### 1. norm.pdf()
#Wahrscheinlichkeitsdichtefunktion (pdf) der Verteilung.
from scipy.stats import norm
import matplotlib.pyplot as plt
import numpy as np
from scipy import stats
x = np.arange(-10, 10, 0.1)
################
loc = 0 # loc 0: 0normal / loc < 1 : links. #Hier die kumulative Wahrscheinlichkeit ablesen
# von -x mit > 0 bis +x -> 1.0
scale = 1 # scale > 1 nach rechts, scale > 1 = breiter
###############
y = norm.pdf(x, loc, scale )
plt.title("PDF Dichtefunktion ")
plt.plot(x, y)
plt.show()
############## 2. norm.cdf()
# Kumulative Verteilungsfunktion (cdf) der Verteilung zurück.
import scipy
from scipy import stats
#############
loc = 0
scale = 1
############ # ##########
x = np.arange(-10, 10, 0.1)
y = norm.cdf(x, loc,scale)
plt.title("CDF Verteilungsfunktion F(x)")
plt.plot(x, y)
rvs_values = stats.norm.rvs(loc = 2, scale=1 , size= (2,5))
print("das sind die Zufallszahlen zur gegebenen Normalverteilung \n",rvs_values)
#Hier die kumulative Wahrscheinlichkeit ablesen
# von -x mit > 0 bis +x -> 1.0
x =- 1
cdf_value = stats.norm.cdf(x,loc,scale)
print("CDF Kum.Wahrscheinlichkeit= :"+str(cdf_value))
#zur Demonstration noch ein weiteres Beispiel
x = 1
cdf_value = stats.norm.cdf(x,loc=-1,scale=1)
print("CDF Kum.Wahrscheinlichkeit= :"+str(cdf_value))
plt.show()
# 3 norm.ppf()
# Kumulativer Wahrscheinlichkeitswert der Verteilung
#creating an array of probability from
#0 to 1 with a difference of 0.01
x = np.arange(0, 1, 0.01)
y= norm.ppf(x, loc , scale)
plt.title("Kumulative Wahrscheinlichkeitsfuznktion f(x) ")
plt.plot(x, y)
plt.show()
# 4. norm.ppf()
#
from scipy.stats import norm
import matplotlib.pyplot as plt
import numpy as np
# Zufallsdaten werden nun auf Balkendiagramm übertragen
y = (rvs_values)
from scipy import stats
#creating bin
bin = np.arange(-10,10,0.1)
plt.title("Kumulative Wahrscheinlichkeitsfuznktion f(x) ")
plt.hist(y, bins=bin, edgecolor='red')
plt.show()
###################### 5. Balken Normalverteilung
import numpy as np
import matplotlib.pyplot as plt
import scipy
from scipy import stats
x = np.linspace(-10,10,100)
cdf_values = stats.norm.pdf(x,loc=0,scale=1)
plt.plot(x,cdf_values)
plt.xlabel('x-data')
plt.ylabel('pdf_value')
plt.title("CDF of a Normal Distribution with mean=0 and sigma=1")
plt.show()
Gute Zeit OSWALD
code]/
Re: kleine Mathe-Spielereien
Verfasst: Mittwoch 3. August 2022, 16:09
von OSWALD
Code: Alles auswählen
[/
Es gibt neue Funktionen.
Dadurch kann die Laufzeit etwas erhöht werden.
1. Jetzt 2 Histogramme.(rot/blau)
Beide stellen Zufallszahlen dar.
rot: alle Zufallszahlen, die über 'size' erzeugt werden
blau : von den ausgewählten Zufallszahlen kann eine beliebige Anzahl
als array übernommen werden(Kommata nicht vergessen)
Damit kann der Standort einzelner oder mehrerer Werte im
Wahrscheinichkeitsraum kontrolliert und abgeschätzt werden.
(Modellauswahl )
2. eine Funktion zur Bestimmung von Konfidenzintervallen .
Diese Ansammlung v on Funktionen kann allenfalls bei der Auswahl
einer geeigneten Verteilung dienen, hat aber mit der konkreten Anwendung
von statistischen Berechnungen direkt nichts zu tun .
#####################################
#Parameter
#x Zufallsvariable x
#q .Wahrscheinlichkeiten
#loc Mittelwert der Verteilung .
#scal Standardabweichung der Verteilung Standard ist 1,0.
#size Zahl der Zufallsvariablen
# 1.Funktion PDF
############ Dichtefunktion
from scipy.stats import norm
import matplotlib.pyplot as plt
import numpy as np
from scipy import staber "Fsizes
#creating an array of values between
#-10 to 10 with a difference of 0.1
x = np.arange(-10, 10, 0.1)
my = 1
sigma = 2
y = norm.pdf(x, my, sigma)
plt.title("PDF Dichtefunktion mit my = 1, sigma =2 ")
plt.plot(x,y)
plt.show()
############## 2. F unktion norm.cdf()
# Kumulative Verteilungsfunktion (cdf) d.
import numpy as np
import matplotlib.pyplot as plt
import scipy
from scipy.stats import norm
#############
loc = 0
scale = 1
#############
# Hier wird die Zahl der ZUfallswerte eingegeben z.B.( 1,6) oder 2,20(array,Anzahl)
x = np.arange(-10, 10,0.01)
y = norm.cdf(x, loc, scale)
plt.title("CDF Verteilungsfunktion F(x)")
plt.plot(x, y)
rvs_values = stats.norm.rvs(loc, scale, size = (1,5))
print("Zufallswerte",rvs_values)
plt.show()
# 3.Funktion norm.ppf()
# Kumulativer Wahrscheinlichkeitswert der Verteilung
# für einen bestrimmten Zufallswert x
# zur Demonstration hier zwei Beispiel e
x = np.arange(-10, 10,0.01)
y= norm.ppf(x, loc , scale)
plt.title("Kumulative Wahrscheinlichkeitsfunktion f(x) ")
plt.plot(x, y)
plt.show()
################
x = 4
cdf_value = stats.norm.cdf(x,loc=-0,scale=1)
print("CDF Kum.Wahrscheinlichkeit= :"+str(cdf_value))
x = -3
cdf_value = stats.norm.cdf(x,loc=-0,scale=1)
print("CDF Kum.Wahrscheinlichkeit= :"+str(cdf_value))
plt.show()
################
# 4. Funktion norm.ppf()
# Zufallsdaten werden auf Histogramm übertragen
from scipy.stats import norm
import matplotlib.pyplot as plt
import numpy as np
from scipy import stats
# Daten werden als array übertragen .
#A c h t u n g Die Übertragung erfolgt als array ( rvs_values) automatisch
# Zwischen jeden Wert kommt ein Komma !
y = (rvs_values)
bin = np.arange(-10,10,0.01)
plt.title("Histogramm der mit 'size'(Anzahl) der generierten Zufallszahlen")
plt.hist(y, bins=bin, edgecolor='red')
plt.show()
###################### 5. Funktion Histogramm (Farbe rot)
import numpy as np
import matplotlib.pyplot as plt
import scipy
from scipy import stats
x = np.linspace(-10,10,100)
cdf_values = stats.norm.pdf(x,loc=0,scale=1)
plt.plot(x,cdf_values)
plt.xlabel('x-Werte')
plt.ylabel('Dichte')
plt.title("PDF D ichtefunktion mit loc = 0 , scales =1 ")
plt.show()
#
# 6. Funktion alternatives Histogramm(Farbe blau)
# Hier können einzelne oder beliebig viele der angezeigten Zufallswerte
# (händisch) kopiert und wieder als Array als blauer Balken gezeigt werden.
from scipy.stats import norm
import matplotlib.pyplot as pl
y = [-2.88737142, -0.39045885, -1.269408549]
bin = np.arange(-10,10,0.01)
plt.title("Balkendarstellung der übernommenen Zufallszahlen ")
plt.hist(y, bins=bin, edgecolor='blue' )
N = 165
a = np.random.normal(0, 1, N)
mean, sigma = a.mean(), a.std(ddof=1)
conf_int_a = stats.norm.interval(0.68, loc=mean, scale=sigma)
print('{:0.2%} der Zufallswerte in Konfidenzintervall A'
.format(((a >= conf_int_a[0]) & (a < conf_int_a[1])).sum() / float(N)))
M = 5
b = np.random.normal(0, 1, (N, M)).mean(axis=1)
conf_int_b = stats.norm.interval(0.68, loc=0, scale=1 / np.sqrt(M))
print('{:0.2%} der Mittelwerte in Konfidenzintervall B'
.format(((b >= conf_int_b[0]) & (b < conf_int_b[1])).sum() / float(N)))
####################################
Gute Zeit OSWALD
code]
Re: kleine Mathe-Spielereien
Verfasst: Donnerstag 4. August 2022, 09:57
von OSWALD
[codeNoch ein abschließendes Beispiel zum Thema Normalverteilung,
aber hier jdedoch zum Thema t-Verteilung
aber Der Code wurde aus der Bibliothek 'scipy' übernommen.
######### über die t-verteilung
from scipy.stats import t
import matplotlib.pyplot as plt
import numpy as np
fig, ax = plt.subplots(1, 1)
df = 2.74
mean, var, skew, kurt = t.stats(df, moments='mvsk')
x = np.linspace(t.ppf(0.01, df),
t.ppf(0.99, df), 100)
ax.plot(x, t.pdf(x, df),
'r-', lw=5, alpha=0.6, label='t pdf')
rv = t(df)
ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')
vals = t.ppf([0.001, 0.5, 0.999], df)
np.allclose([0.001, 0.5, 0.999], t.cdf(vals, df))
True
r = t.rvs(df, size=10)
print(r)
from scipy.stats import norm
import matplotlib.pyplot as pl
y =[ 0.36193524 ,-4.8711742 ,-1.4979113 , -0.24569763 , 0.06565832, -0.2912111,
0.32968241, -0.94427886 , 0.22379514 , 0.04694663]
bin = np.arange(-10,10,0.01)
plt.title("Histogramm der übernommenen Zufallszahlen ")
plt.hist(y, bins=bin, edgecolor='blue' )
ax.hist(r, density=True, histtype='stepfilled', alpha=0.2)
ax.legend(loc='best', frameon=False)
plt.show()
Gute Zeit OSWA LD
[/code]
Re: kleine Mathe-Spielereien
Verfasst: Donnerstag 4. August 2022, 10:29
von Sirius3
@OSWALD: vielleicht ist es Dir noch nicht aufgefallen, aber alle Deine Beiträge benutzen Code-Tags falsch. Für mich als Leser ist das sehr störend. `[ code ]` und `[ /code ]` dürfen nicht auseinander gerissen werden, und innerhalb der Tags darf auch nur Code stehen und nicht noch Fließtext.
Re: kleine Mathe-Spielereien
Verfasst: Donnerstag 4. August 2022, 16:52
von OSWALD
Hallo Sirius, es ist mir sehr peinlich, dass ich Dir solche Probleme bereitet habe.
Bisher hat sich niemand beschwert.
Ich versuche jetzt esmit einem Eintrag füre alle Zeit richtig zu machen.
Gute Zeit OSWALD.
Bitte um Nachricht, wenn es wieder falsch ist.
import numpy as np
np.random.seed(0)
x_data = np.linspace(-5, 5, num=50)
y_data = 2.9 * np.sin(1.5 * x_data) + np.random.normal(size=50)
import matplotlib.pyplot as plt
plt.figure(figsize=(6, 4))
plt.scatter(x_data, y_data)
from scipy import optimize
def test_func(x, a, b):
return a * np.sin(b * x)
params, params_covariance = optimize.curve_fit(test_func, x_data, y_data,
p0=[2, 2])
print(params)
plt.figure(figsize=(6, 4))
plt.scatter(x_data, y_data, label='Data')
plt.plot(x_data, test_func(x_data, params[0], params[1]),
label='Fitted function')
plt.legend(loc='best')
plt.show()
Re: kleine Mathe-Spielereien
Verfasst: Donnerstag 4. August 2022, 17:43
von Sirius3
Wenn Du auf den "Vorschau"-Knopf drückst, siehst Du schon vor dem Absenden, dass es falsch ist.