kleine Mathe-Spielereien

mit matplotlib, NumPy, pandas, SciPy, SymPy und weiteren mathematischen Programmbibliotheken.
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

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]
Benutzeravatar
__blackjack__
User
Beiträge: 13004
Registriert: Samstag 2. Juni 2018, 10:21
Wohnort: 127.0.0.1
Kontaktdaten:

@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.
“Most people find the concept of programming obvious, but the doing impossible.” — Alan J. Perlis
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

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]
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

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]
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Code: Alles auswählen

[

f __name__ == "__main__":
    main()

Entschuldigung  ,das 'gute Stück ging offenbar verloren.
Bitte ganz am Ende einfügen
Oswald
]
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

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]
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

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]
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

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.
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

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]
Benutzeravatar
Dennis89
User
Beiträge: 1123
Registriert: Freitag 11. Dezember 2020, 15:13

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
"When I got the music, I got a place to go" [Rancid, 1993]
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

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]
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

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]
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

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]
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

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]
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

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]/
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

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]
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

[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]
Sirius3
User
Beiträge: 17711
Registriert: Sonntag 21. Oktober 2012, 17:20

@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.
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

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()
Sirius3
User
Beiträge: 17711
Registriert: Sonntag 21. Oktober 2012, 17:20

Wenn Du auf den "Vorschau"-Knopf drückst, siehst Du schon vor dem Absenden, dass es falsch ist.
Antworten