Das deutsche Python-Forum

19.10.2025
Nichts als 'mathe-Spelereien':

Das Prinzip der Gleichung und das Ergebnis ist hier in jedem Fall identisch.
Nur der Fehler vergrößert sich wegen der trigon. Funktionen.
OSWALD

Code: Alles auswählen



from sympy import Equality, solve, sympify
from sympy.abc import x

solve(Equality(sympify("1/7 + 1/3"), 1 / x), x)
[21/10]
print(21/10)
print()


                            #import math                        ! #kann weg
#1/7 +1/3 =1/x
print(1/7 + 1/3)
print(1/ 0.47619047619047616    )  
print()


#sin(1/7) + cos(1/3) = 1/sin(x)    

from math import  sin ,cos
print(sin(1/7) +cos(1/3) )
print(1/0.47005183965329506)

17-10.2025
Schon eher unheimlich wird mir da schon, wenn
ich die Lösung von kubischenGleichungen mit der neueren
Funktion "numpy.root* betrachte. 2 Beispiele
Über Jahrhunderte haben sich die besten Mathmeatiker daran abgearbeitet,

Das ist KI per se.
Gute Zeit OSWALD

Code: Alles auswählen


#Die Funktion numpy.roots() aus der numpy-Bibliothek,
#die eine Polynomgleichung in einer Liste von Koeffizienten entgegennimmt
#und alle Wurzeln zurückgibt. 

import numpy as np

# Beispiel: Löse x^3 - 6x^2 + 11x - 6 = 0
# Koeffizienten: a=1, b=-6, c=11, d=-6
koeffizienten = [1, -6, 11, -6] 
koeffizienten2 = [3,  2 ,5 , +2]
# Die Wurzeln finden
wurzeln = np.roots(koeffizienten)
wurzeln2 = np.roots(koeffizienten2)
print("Die Lösungen sind:", wurzeln)  
print("Die Lösungen sind:", wurzeln2)

OSWALD hat geschrieben: Sonntag 19. Oktober 2025, 11:54

Das Prinzip der Gleichung und das Ergebnis ist hier in jedem Fall identisch.
Nur der Fehler vergrößert sich wegen der trigon. Funktionen.
Code: Alles auswählen
#1/7 +1/3 =1/x
#sin(1/7) + cos(1/3) = 1/sin(x)    

@OSWALD: Wie kommst Du darauf, dass das identisch ist?! Du vergleichst hier eine lineare Funktion mit einer nichtlinearen Funktion. Das eine hat mit dem anderen absolut nichts zu tun, da gibt es nichts Identisches. Und der "Fehler" kommt nicht von den trigon. Funktionen, sondern ist ein Resultat Deiner falschen Annahme.

Ein Vergleich zwischen Äpfeln und Birnen ist im Gegensatz zu dem Beispiel hier eine harmlose Sache...

@ Mechanical Store

In der Mathematik heißt eine reelle oder komplexe Zahl transzendent, wenn sie nicht Nullstelle eines (vom Nullpolynom verschiedenen) Polynoms mit ganzzahligen
Koeffizienten ist. Andernfalls handelt es sich um eine algebraische Zahl. Jede reelle transzendente Zahl ist überdies irrational.

Also, wenn ich das richtig verstanden habe, dann ist die Ursache des fwehlers nicht die Funktion, sondern die transzendemte Zahl der Funktion.

Gute Zeit OSWALD

OSWALD hat geschrieben: Sonntag 19. Oktober 2025, 12:14 17-10.2025
Schon eher unheimlich wird mir da schon, wenn
ich die Lösung von kubischenGleichungen mit der neueren
Funktion "numpy.root* betrachte. 2 Beispiele
Über Jahrhunderte haben sich die besten Mathmeatiker daran abgearbeitet,

Das ist KI per se.

Das ist keine KI per se, dass ist die Anwendung der numerischen Verfahren zur Nullstellenberechnung, die über die Jahrhunderte von den besten Mathematiker entwickelt wurden...

@Grubenfox
100% Zustimmung. Da lag ich 100%ig falsch. Python beruht auf der klassischen Mathematik.
.Hilbert und Gödel fehlen in der KI.

Soeben habe ich im Imternet gelesen:
"OpenAI: Mathe-Blamage offenbart Achillesferse der KI-Branche"

OSWALD

22.10.2022
#Problem Nr 7 von Hilbert (nicht gelöst) lautet
+######################################
# Ist die Potenz α**β
# immer transzendent,
# wenn α
# algebraisch α≠0,α≠1
# und β irrational u n d algebraisch ist?
#
#Hierzu ein Beispiel: 3.3 ** 2.5 mit PYTHON
print( 3.3 ** 2.6)
#ist diese Zahl abgerundet ??
22.29134347284058

Meine Frage dazu lauet : ist diese Zahl abgerundet ??
Ich kann ddiese Frage nicht lösen.

Gute Zeit OSWALD

@OSWALD: Definiere abgerundet. Es ist auf jeden Fall kleiner als das Ergebnis, welches man bekommt, wenn man mit Decimal und 100 signifikanten Stellen rechnet:

Code: Alles auswählen

Decimal: 22.29134347284058271176619816187990316405865240923635806354074592953027146157374891987792534905750081
  float: 22.29134347284058037530485307797789573669433593750000000000000000000000000000000000000000000000000000

22.10.
Ergänzendes Beispiel zu den diskutierten Gleichungen
OSWALD

Code: Alles auswählen


from math import  sin  , cos   , pi

#zunächst der Einheitskreis    r=1
#(sin(1) **2)+ (cos(1)**2 ) =1/x
print(1/ (sin(1) **2+ (cos(1)**2 )))

#  Beispiele zum Einheitskreis   mit   unterschidlichem Radius
#1/((sin(5.4) **2)+ (cos(5.4) **2 ))) = 1/x

print(1/((sin(5.4) **2)+ (cos(5.4) **2 )))
 

#'Kreis-Fläche  r**2* pi
print  ("Kreisfläche"  ,  5.4*5.4 *pi)

23.10.2025
Zum Abschluß noch etwas Graphik.

Der EWeg von der Geraden über Dreieck , Polygone zum Einheitskreis .
Näherung an Pi mal anders.
Gute Zeit OSWALD

Code: Alles auswählen




import numpy as np
import matplotlib.pyplot as plt

# NumPy-Arrays für die x- und y-Koordinaten des Kreises
#Ausgangs-Figur = Gerade, schrittweise über Polygone bis zum Kreis  
theta = np.linspace(0, 2 * np.pi,9)         # 1. 2........ 200 
 
#Schrittweise erhöhen bis zum Einheitskreis
#theta = np.linspace(0, 2 * np.pi,200)


x = np.cos(theta)
y = np.sin(theta)

# Plot erstellen
fig, ax = plt.subplots(1, figsize=(6, 6))
ax.plot(x, y, label='Gerade -> Poygone >- Einheitskreis', color='blue')

# Achsen einzeichnen
ax.axhline(0, color='gray', linewidth=0.5)
ax.axvline(0, color='gray', linewidth=0.5)

# Achsen limitieren
ax.set_xlim([-1.1, 1.1])
ax.set_ylim([-1.1, 1.1])
ax.set_aspect('equal', adjustable='box')

# Legende und Gitter hinzufügen
ax.legend()
ax.grid(True)
plt.title('von der Geraden , über   Polygone    zum   Einheitskreis ')
plt.show()

23.10.2025
jetzt interessieren mich noch die Daten.
bei 500 Einzelschritten finde ich etwa inmitten der ca. 165 Zeilen
die Zahl 3.1473739
und nach 1000 Schritten die Zahl 3.1478813 .

PI = 3.14159265359 also könnte stimmen
Mehr als 1000 Schritte schafft die Kiste nicht .

Theoretisch könnte man jetzt noch mit imshow die Daten als 'Bild' darstellen

Gute Zeit OSWALD

23.10.2025
Nut ein kleiner Schritt zur Ellipse,
OSWALD

25.10.2025

Wie kann ich bestimmte Datenbereiche aus einer Liste entfernen?
Dazu habe ich ein kleines Programm ausgedacxht.
Ich zeige es zur Beurteilung. ???
OSWALD

Code: Alles auswählen


#####Ausreisser aus zufallsdaten  heraus   schneiden

import numpy as np
######################################################################

ausreisser = 0
schwellenwert =   0.02
 
testliste    =   [ 0.01259155 ,0.02518311 ,0.037774660, 0.5036621 ,0.06295777,
 0.07554932, 0.08814088 ,0.10073243 ,0.11332398, 0.12591554 ,0.13850709,
 0.15109864, 0.1636902 , 0.17 ,0.18887331 ,0.176, 0.21405641,
 0.22664797, 0.23923952 ,0.25183107 ,0.26442263 ,0.27701418 ,0.28960574]
   
for x   in  ( testliste):
            if  x  >=   schwellenwert  and  x  < schwellenwert  +0.12 :
                                      
                print(x)
                
           # else:
                print(ausreisser)

Die `If`-Bedingung kann man auch noch ein wenig hübscher schreiben, sieht dann (meiner Meinung nach) etwas mathematischer aus.
Ein wenig überflüssiges habe ich auch noch entfernt...

Code: Alles auswählen

#####Ausreisser aus zufallsdaten  heraus   schneiden

######################################################################

SCHWELLENWERT =   0.02
 
testliste = [0.01259155, 0.02518311, 0.037774660, 0.5036621, 0.06295777,
 0.07554932, 0.08814088, 0.10073243, 0.11332398, 0.12591554, 0.13850709,
 0.15109864, 0.1636902, 0.17, 0.18887331, 0.176, 0.21405641,
 0.22664797, 0.23923952, 0.25183107, 0.26442263, 0.27701418, 0.28960574]
   
for x in testliste:
    if SCHWELLENWERT < x < SCHWELLENWERT + 0.12:
        print(x)
                
        print(0)

25.10.2025
Auch hiermit kann mam Ausreisser ganz gut feststellen.
OSWALD

Code: Alles auswählen


  #AUSREISSERLISTERKENNEN

import numpy as np

def calc_mad(data, median):
  medians = []

  for x in data:
      medians.append(np.abs(x - median))

  return np.median(medians)

def iglewicz_hoaglin(threshold, data):
    median = np.median(data)
    mad = calc_mad(data, median)
    outliers = []

    for x in data:
      score = 0.6745 * (x - median) / mad
      print(str(x) + ':\t' + str(score))

      if(score > threshold):
          outliers.append(x)

    return outliers

threshold = 3.5
data = [10.6, 22.6, 30.5, 100,9, 15,5, 80.3, 8.4, 9.9]

modified_z_scores = iglewicz_hoaglin(threshold,data)
print('\nresult: '+ str(modified_z_scores))

25.10.25
Gleiche Daten wie vorher, erneut untersucht
OSWALD

Code: Alles auswählen

#AUSREISSERLISTERKENNEN

import numpy as np

def calc_mad(data, median):
  medians = []

  for x in data:
      medians.append(np.abs(x - median))

  return np.median(medians)

def iglewicz_hoaglin(threshold, data):
    median = np.median(data)
    mad = calc_mad(data, median)
    outliers = []

    for x in data:
      score = 0.6745 * (x - median) / mad
      print(str(x) + ':\t' + str(score))

      if(score > threshold):
          outliers.append(x)

    return outliers

threshold = 2.5
data = [0.01259155, 0.02518311, 0.037774660, 0.5036621, 0.06295777,
 0.07554932, 0.08814088, 3.10073243, 0.11332398, 0.12591554, 0.13850709,
 0.15109864, 0.1636902, 0.17, 0.18887331, 4.176, 9.21405641,
 0.22664797, 0.23923952, 0.25183107, 0.26442263, 0.27701418, 0.28960574]
    

modified_z_scores = iglewicz_hoaglin(threshold,data)
print('\nresult: '+ str(modified_z_scores))

26.10.2025
Jetzt kommt noch die Liste der Ausreisser hinzu.
Sollt eigentlich funktionieren.
Gute Zeit OSWALD

Code: Alles auswählen


import numpy as np
######################################################################

ausreisser = 0
schwellenwert =   3
 
testliste    =   [ 0.01259155 ,0.02518311 ,0.037774660, 0.5036621 ,0.06295777,
 0.07554932, 0.08814088 ,3.10073243 ,0.11332398, 0.12591554 ,0.13850709,
 0.15109864, 0.1636902 , 0.17 ,0.18887331 ,0.176, 0.21405641,
 0.22664797, 0.23923952 ,0.25183107 ,3.26442263 ,0.27701418 ,0.28960574]
liste_ausreisser = []  
for x   in  ( testliste):
            if  x   <=   schwellenwert  and  x  < schwellenwert   +4 :
                                 
                 print(x)
                  
            else:
                 print(ausreisser)
                 liste_ausreisser.append(x) 

print("Liste der ausreisser :",     liste_ausreisser)

26.1#Ich zeige hier, dass dieser Algorithmus auch trigonometrische Funktionen verarbeiten kann, aber nur wenn diese gleichzeitig
#mit rationalen Zahlen verarbeitet werden. Schwellenwerte müssen immer rationale Zahlen sein.
Die Ergebnisse aus trig.Funktionen erkennt man an den langen Nachkommastellen.
OSWALD

Code: Alles auswählen

import numpy as np
from numpy import sin ,pi ,e
ausreisser = 0
schwellenwert = 3
ausreisser_liste =[]
testliste = [ 0.01259155 ,sin(4.02518311) ,(0.037774660), (0.5036621) ,0.06295777,
0.07554932, 0.08814088 ,sin(0.10073243) ,0.11332398, 0.12591554 ,sin(0.13850709),
0.15109864, 0.1636902 , sin(0.17) ,0.1888733 ,sin(0.176), 3.21405641,
0.22664797, 0.23923952 ,5.25183107 ,0.26442263 ,0.27701418 ,0.28960574]

for x in ( testliste):
if x >= schwellenwert and schwellenwert + 5.25 :

print(x)

# else:
#print(ausreisser)
ausreisser_liste.append(x)
print("Liste der Ausreisser " , ausreisser_liste)
0.2025

][/code]

siehe oben
if x >= schwellenwert and schwellenwert + 5.25 :

bessere Zeile wäre
if x <= schwellenwert and schwellenwert + 5.25 :
OSWALDda durch mehr Information

14.11.2025
Es war an der Zeit zu erfahren, was mein PC
noch zu leisten vermag.
Ich habe mir also ein kleines Progrmm zusammen gebastelt
- Laufzeitbestimmung für die Approximation von e oder pi. -
Ergebnis für e oder pi sind gleich
für 16 stellen nach dem Komma 332.8 sec.

Damit stehe ich vor der Frage, welche Lseitung würde ich brauchen,
um wenigstens annähernd an das heute notwende Mindest- Niveau aufschliessen zu können.
Wäre also eine Neuanschaffung sinnvoll?
Gute Zeit

Code: Alles auswählen

#import numpy as np
 
def approximate_dauer (num_terms):
    e_approximation = 0.0
    for i in range(num_terms):
        term = ((-1)**i) / (2 * i + 1)
        e_approximation += term
    return e_approximation

# Beispiel: Annäherung mit 100000 Termen
num_terms = 1000000001


e_estimate = approximate_dauer(num_terms)
print(e_estimate)
#
print(f"Annäherung mit {num_terms} Termen: {e_estimate}")
 
# --- Ihr zu messender Code endet hier ---

end_zeit = time.time()
laufzeit = end_zeit - start_zeit

print(f"Die Laufzeit beträgt: {laufzeit} Sekunden")

Das deutsche Python-Forum

kleine Mathe-Spielereien

Re: kleine Mathe-Spielereien

Re: kleine Mathe-Spielereien

Re: kleine Mathe-Spielereien

Re: kleine Mathe-Spielereien

Re: kleine Mathe-Spielereien

Re: kleine Mathe-Spielereien

Re: kleine Mathe-Spielereien

Re: kleine Mathe-Spielereien

Re: kleine Mathe-Spielereien

Re: kleine Mathe-Spielereien

Re: kleine Mathe-Spielereien

Re: kleine Mathe-Spielereien

Re: kleine Mathe-Spielereien

Re: kleine Mathe-Spielereien

Re: kleine Mathe-Spielereien

Re: kleine Mathe-Spielereien

Re: kleine Mathe-Spielereien

Re: kleine Mathe-Spielereien

Re: kleine Mathe-Spielereien

Re: kleine Mathe-Spielereien