kleine Mathe-Spielereien

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

]1.3.2025
Als Schüler hatten wir die
Logarithmentafel .
Gute Zeit OSWALD

Heute geht es mit Python so:

Code: Alles auswählen



import numpy as np
from scipy.linalg import logm, expm
a = np.array([[1.0, 3.0], [1.0, 4.0]])
print("Array a  :"  ,a )
print()
a= logm(a)
print(" Logarithmus von lArray  a  ",a)
print()
c=expm(a)
print("c  = delogarithmieren  :", c)
 #############################     
print()
b = logm(a)
print("Logarithmus von  b :",     b)



OSWALD
User
Beiträge: 527
Registriert: Freitag 18. März 2022, 17:32

.3.2025
Nachdem die Logarithmisierung der
Matrix erfolgt ist, muss das erstellte
Tupel in die richtige Form gebracht werden,
Zwischen die Elemente des T,
müssen die Kommata gesetzt werden, so wie
im Code gezeigt
Das Programm zeigt das gleiche Bild wie
Matrix.
Der Zusammenhang zwischen Zahl und Logarithmus
ird jetzt offenschtlich. Ist nun damit bewiesen, dass
so gewonnene synthese-Daten brauchbar sind ?
Gute Zeit OSWALD

Code: Alles auswählen


import numpy  as np
from numpy import *
import matplotlib.pyplot as plt
in_array =   [[0.   ,      0.69314718, 1.09861229, 0.69314718, 1.09861229 ,1.38629436,
  1.60943791, 1.79175947, 1.94591015 ,2.07944154 ,2.19722458 ,2.30258509,
  2.39789527, 2.48490665, 2.56494936 ,2.63905733],
 [2.83321334, 2.89037176 ,2.94443898 ,2.99573227 , 3.04452244 ,3.09104245,
  3.13549422 ,3.17805383 ,3.21887582 ,3.25809654 ,3.29583687 ,3.33220451,
  3.36729583 ,3.40119738 ,3.4339872 , 3.4657359 ],
 [3.49650756, 3.52636052 ,3.55534806,3.58351894, 3.61091791 ,3.63758616,
  3.66356165, 3.68887945 ,3.71357207, 3.73766962, 3.76120012 ,3.78418963,
  3.80666249, 3.8286414  ,3.8501476 , 3.87120101],
 [3.8918203 , 3.91202301 ,3.93182563 ,3.95124372, 3.97029191, 3.98898405,
  4.00733319, 4.02535169, 4.04305127 ,4.06044301 ,4.07753744 ,4.09434456,
  4.11087386 ,4.12713439 ,4.14313473, 4.15888308],
 [4.17438727 ,4.18965474, 4.20469262, 4.21950771, 4.2341065 , 4.24849524,
  4.26267988, 4.27666612 ,4.29045944 ,4.30406509 ,4.31748811, 4.33073334,
  4.34380542 ,4.35670883, 4.36944785, 4.38202663],
 [4.39444915 ,4.40671925, 4.41884061, 4.4308168 , 4.44265126 ,4.4543473,
  4.46590812, 4.47733681, 4.48863637 ,4.49980967 ,4.51085951, 4.52178858,
  4.53259949, 4.54329478 ,4.55387689, 4.56434819]]
 
# Figure und Axes erstellen
leinwand ,diagramm = plt.subplots()

 
diagramm.imshow(in_array)   
plt.show()


OSWALD
User
Beiträge: 527
Registriert: Freitag 18. März 2022, 17:32

1.3.2025
Um den engen Zusammenhang zwischen
Radiand und Logarithmus zu demindtrieren
zeige ich hir zwei kleine private
Funktionen, mit denen ich beliebige Wurzeln ziehen kann.
Diese Funktionen kann man in Code einbauen.
Wie den Header in C++ die Funktion voran
und dann an beliebiger Stelle.
Gute Zeit OSWALD

Code: Alles auswählen


import math
from  math import log10 , log
Ergebnis =0
                           #gewählte Wurzel
def W10(Rad,Wp):
      mantisse =(1/Wp)*log10(Rad)
      
      Ergebnis =round(10** mantisse,4)
      print(Ergebnis)
W10(64 ,2)

###################
import  math
from math import log, e
Ergebnis =0.
def Wnat(R ,W ):
    mantisse =  (1/W)*log(R)
    Ergebnis =2.7183** mantisse
    print(Ergebnis)
Wnat(100 , 3 )
############################

 






OSWALD
User
Beiträge: 527
Registriert: Freitag 18. März 2022, 17:32

4.3.2025
Expotentialgleichungen vom Typ - Basis **Exponent = Wert-
sind in der Regel analytisch sehr schwer zu lösen
Mit Python und Logarithmen gelingt das viel besser.
Dafür zeige ich jetzt 2 Beispiele
Gute Zeit OSWALD

Code: Alles auswählen



                          Exponentialgleichungen und   Logarithmen
print("   Basis ** Exponent  =     Ergebnis   |   z.B.        2**3 =8    ")
print("   Basis ** x  =                  Ergebnis   |Exponentialgleichung ")
 
import numpy as np
from numpy import  log    # log.nat
#Aufgabe :    3 **x  = 2187
                           
#log(3**x)=log(2187)            
#x * log(3) =log(2187)

#print(log(3))              1.0986122886681098
#print(log(2187) )       7.690286020676768
 

print(log(2187)/(log(3)))
x   =(log(2187)/(log(3)))
print("Ergebnis (mantisse)   ", x)

print("Test  :",3**7)
print()

############################################
#                          Exponentialgleichungen und   Logarithmen
print("   Basis ** Exponent  =     Ergebnis   |   z.B.        2**3 =8    ")
print("   Basis ** x  =                  Ergebnis   |Exponentialgleichung ")
#Aufgabe :    4 **x  = 21

import numpy as np
from numpy import  log10
   
print(log10(4))                        
print(log10(21))                       
x= log10(21)/ log10(4)
print(x)
print("Ergebnis ((mantisse)   ", x)
print("Test   :",4**2.1961587113893803)


OSWALD
User
Beiträge: 527
Registriert: Freitag 18. März 2022, 17:32

5.3.2025
jetzt noch eine 'kleine Mathe-Spielerei'
1. Zur Lösung von Exponential-Gl. habe ich noch eine Python-Funktion'
entwickelt, die für kompliziertere Gleichungen erweitert werden kann.
2. das Integral der Funktion = log(x).
Gute Zeit OSWALD

Code: Alles auswählen

######################################
import numpy as np
from numpy import *

def EXPO(ergebnis,basis):
     mantisse  =   log(ergebnis) / log(basis) 
     print(mantisse )
EXPO(2187,3)
EXPO(100,3)
EXPO(2.5,0.5 )
EXPO((20),e)
#######################################





OSWALD
User
Beiträge: 527
Registriert: Freitag 18. März 2022, 17:32

5.3.2025
Korrektur
Integral der Funktion 1/x = log(x)
OSWALD
User
Beiträge: 527
Registriert: Freitag 18. März 2022, 17:32

5.3.2025
Natürlich funktioniert es auch mit der Basis 10
oder irrationalen Zahlen , Brüchen oder e, ,pi als Basis.
Logarithmen sind selbst irrationale und sogar transzendente Zahlen.
Gute Zeit OSWALD

Code: Alles auswählen


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

import numpy as np
from numpy import  log10
def EXPO(ergebnis,basis):
#   
#######################################     
     mantisse  =   log10(ergebnis) / log10(basis) 
     print(mantisse )
EXPO(2.718544  ,e)

OSWALD
User
Beiträge: 527
Registriert: Freitag 18. März 2022, 17:32

6.3.2025
Abschließend noch ein komplizierteres
Beispiel auf Basis 10.
Zuerst die Umrechnung.
Gute Zeit OSWALD

Code: Alles auswählen


import numpy as np
from numpy import  log10
def EXPO(ergebnis,basis):

#   Aufgabe    : 3**2*x =  4 * 5**x 
#   Umrechnung:
#   #3**2*x  =5**x*4
#   (3**2)**x = 4*5**x
#    9**x  / 5**x      =4
#    1.8**x  =4
#x*log(1,8) = log(4)
#x=log(4)/log(1.8)
#######################################     
     mantisse  =   log10(ergebnis) / log10(basis) 
     print(mantisse )

EXPO(4,1.8)

OSWALD
User
Beiträge: 527
Registriert: Freitag 18. März 2022, 17:32

8.3.2025
Nun habe ich in meinen privaten Rechner
auch noch log10() und og( integriert .
Gleichzeitig habe ich einen Fehler korrigiert.
Fehler bei der 'Division'
Gute Zeit OSWALD

Code: Alles auswählen


# importing Tkinter and math 
import math  
from math import  *
import numpy as np


import tkinter
from tkinter import *
 

 

class calc:
    def getandreplace(self): 

      
        self.expression = self.e.get() 
        self.newtext=self.expression.replace('/','/') 
        self.newtext=self.newtext.replace('x','*') 


    def equals(self): 
        """when the equal button is pressed"""
        self.getandreplace() 
        try: 
            # evaluate the expression using the eval function 
            self.value= eval(self.newtext) 
           
        except SyntaxError or NameError: 
            self.e.delete(0,END) 
            self.e.insert(0,'Eingabe falsch') 
        else: 
            self.e.delete(0,END) 
            self.e.insert(0,self.value) 

    def squareroot(self): 
        """squareroot method"""
        self.getandreplace() 
        try: 
            # evaluate the expression using the eval function 
            self.value= eval(self.newtext) 
        except SyntaxError or NameError: 
            self.e.delete(0,END) 
            self.e.insert(0,'Invalid Input!') 
        else: 
            self.sqrtval=math.sqrt(self.value) 
            self.e.delete(0,END) 
            self.e.insert(0,self.sqrtval) 

    def square(self): 
        """square method"""
        self.getandreplace() 
        try: 
            #evaluate the expression using the eval function 
            self.value= eval(self.newtext) 
        except SyntaxError or NameError: 
            self.e.delete(0,END) 
            self.e.insert(0,'Falsche Eingabe') 
        else: 
            self.sqval=math.pow(self.value,2) 
            self.e.delete(0,END) 
            self.e.insert(0,self.sqval) 

    def clearall(self): 
            """when clear button is pressed,clears the text input area"""
            self.e.delete(0,END) 

    def clear1(self): 
            self.txt=self.e.get()[:-1] 
            self.e.delete(0,END) 
            self.e.insert(0,self.txt) 

    def action(self,arge): 
            """pressed button's value is inserted into the end of the text area"""
            self.e.insert(END,arge) 

    def __init__(self,master): 
            """Constructor method"""
            master.title("                     M A T H E A S S                           ")
             
            self.e = Entry(master) 
            self.e.grid(row=0,column=0,columnspan=6,pady=6) 
            self.e.focus_set() #Sets focus on the input text area 

            # Generating Buttons 
            Button(master,text="=",width=15,height=5 ,fg="white", 
                bg="blue",command=lambda:self.equals()).grid( 
                                    row=4, column=4,columnspan=2) 

            Button(master,text='CLEARALL',width=7,height=5, 
                        fg="red", bg="light blue", ###########
            command=lambda:self.clearall()).grid(row=1, column=4) 

            Button(master,text='Clear',width=7,height=5, 
                fg="white",bg="green",                  ############ light green
                command=lambda:self.clear1()).grid(row=1, column=5) 

            Button(master,text="+",width=7,height=5, 
                fg="white",bg="green", 
                command=lambda:self.action('+')).grid(row=4, column=3) 

            Button(master,text="X",width=7,height=5, 
                    fg="blue",bg="orange", 
                    command=lambda:self.action('x')).grid(row=2, column=3) 

            Button(master,text="minus",width=7,height=5, 
                    fg="red",bg="light green", 
                    command=lambda:self.action('-')).grid(row=3, column=3) 

            Button(master,text="Divide",width=7,height=5, 
                fg="blue",bg="orange", 
                command=lambda:self.action('/')).grid(row=1, column=3) 

            Button(master,text="%",width=7,height=5, 
                fg="red",bg="light green", 
                command=lambda:self.action('%')).grid(row=4, column=2) 

            Button(master,text="7",width=7,height=5, 
                fg="white",bg="blue", 
                command=lambda:self.action('7')).grid(row=1, column=0) 

            Button(master,text="8",width=7,height=5, 
                fg="white",bg="blue", 
                command=lambda:self.action(8)).grid(row=1, column=1) 

            Button(master,text="9",width=7,height=5, 
                fg="white",bg="blue", 
                command=lambda:self.action(9)).grid(row=1, column=2) 

            Button(master,text="4",width=7,height=5, 
                fg="white",bg="blue", 
                command=lambda:self.action(4)).grid(row=2, column=0) 

            Button(master,text="5",width=7,height=5, 
                fg="white",bg="blue", 
                command=lambda:self.action(5)).grid(row=2, column=1) 

            Button(master,text="6",width=7,height=5, 
                fg="white",bg="blue", 
                command=lambda:self.action(6)).grid(row=2, column=2) 

            Button(master,text="1",width=7,height=5, 
                fg="white",bg="blue", 
                command=lambda:self.action(1)).grid(row=3, column=0) 

            Button(master,text="2",width=7,height=5, 
                fg="white",bg="blue", 
                command=lambda:self.action(2)).grid(row=3, column=1) 

            Button(master,text="3",width=7,height=5, 
                fg="white",bg="blue", 
                command=lambda:self.action(3)).grid(row=3, column=2) 

            Button(master,text="0",width=7,height=5, 
                fg="white",bg="blue", 
                command=lambda:self.action(0)).grid(row=4, column=0) 

            Button(master,text="Point",width=7,height=5, 
                fg="black",bg="white", 
                command=lambda:self.action('.')).grid(row=4, column=1) 

            Button(master,text="(",width=7,height=5, 
                fg="blue",bg="orange", 
                command=lambda:self.action('(')).grid(row=2, column=4) 

            Button(master,text=")",width=7,height=5, 
                fg="blue",bg="orange", 
                command=lambda:self.action(')')).grid(row=2, column=5) 
            Button(master,text="1/**",width=7,height=5, 
                fg="white",bg="blue", 
                command=lambda:self.squareroot()).grid(row=3, column=4) 

            Button(master,text="**",width=7,height=5, 
                fg="white",bg="black", 
                command=lambda:self.square()).grid(row=3, column=5) 
             
             

            Button(master,text="log10",width=7,height=5, 
                fg="white",bg="blue",  
                command=lambda:self.action("log10")).grid(row=1, column=6) 


            Button(master,text="log.nat",width=7,height=5, 
                fg="white",bg="blue",  
                command=lambda:self.action("log")).grid(row=2, column=6) 

             

root=Tk() 
obj=calc(root)
root.mainloop()






OSWALD
User
Beiträge: 527
Registriert: Freitag 18. März 2022, 17:32

10.3.2025
-- synthetische Daten bearbeiten -

Eine große Matrix wurde logarithmiert.
Ergebnis : Liste mit Logarithmen ohne Komma,
also Leerraum zwischen jeder Zahl
Zur Weiterverarbeitung ist jedoch ein Komma notwendig
Dazu Liste -- > Strings.
siehe folgendes Programm
Es funktioniert.
Nächster Versuch : zurück Matrix,
aber jetzt mit Logarithmen,
Versuch mit imshow ,wie gehabt
Hoffentlich klappt alles
Gute Zeit OSWALD

Code: Alles auswählen


original_string =''' -2.30258509 -1.60943791 -1.2039728  -0.91629073 -0.69314718 -0.5108256
 -0.35667494 -0.22314355 -0.10536052  0.0.09531018  0.18232156
  0.26236426  0.33647224  0.40546511  0.47000363  0.53062825  0.58778666
  0.64185389  0.69314718  0.74193734  0.78845736  0.83290912  0.87546874
  0.91629073  0.95551145  0.99325177  1.02961942  1.06471074  1.09861229
  1.13140211  1.16315081  1.19392247  1.22377543  1.25276297  1.28093385
  1.30833282  1.33500107  1.36097655  1.38629436  1.41098697  1.43508453
  1.45861502  1.48160454  1.5040774   1.5260563   1.54756251  1.56861592
  1.58923521  1.60943791  1.62924054  1.64865863  1.66770682  1.68639895
  1.70474809  1.7227666   1.74046617  1.75785792  1.77495235  1.79175947
  1.80828877  1.82454929  1.84054963  1.85629799  1.87180218  1.88706965
  1.90210753  1.91692261  1.93152141  1.94591015  1.96009478  1.97408103
  1.98787435  2.00148456   2.01490302  2.02814825  2.04122033  2.05412373
  2.06686276  2.07944154  2.09186406  2.10413415  2.11625551  2.12823171
  2.14006616  2.1517622   2.16332303  2.17475172  2.18605128  2.19722458
  2.20827441  2.21920348  2.2300144   2.24070969  2.2512918   2.2617631
  2.27212589  2.28238239  2.29253476  2.30258509  2.31253542  2.32238772
  2.3321439   2.34180581  2.35137526  2.360854    2.37024374  2.37954613
  2.38876279  2.39789527  2.40694511  2.41591378  2.42480273  2.43361336
  2.44234704  2.4510051   2.45958884  2.46809953  2.4765384   2.48490665
  2.49320545  2.50143595  2.50959926  2.51769647  2.52572864  2.53369681
  2.54160199  2.54944517  2.55722731  2.56494936  2.57261223  2.58021683
  2.58776404  2.59525471  2.60268969  2.61006979  2.61739583  2.62466859
  2.63188884  2.63905733  2.6461748   2.65324196  2.66025954  2.66722821
  2.67414865  2.68102153  2.68784749  2.69462718  2.70136121  2.7080502
  2.71469474  2.72129543  2.72785283  2.73436751  2.74084002  2.74727091
  2.75366071  2.76000994  2.76631911  2.77258872  2.77881927  2.78501124
  2.79116511  2.79728133  2.80336038  2.8094027   2.81540872  2.82137889
  2.82731362  2.83321334  2.83907846  2.84490938  2.8507065   2.85647021
  2.86220088  2.8678989   2.87356464  2.87919846  2.88480071  2.89037176
  2.89591194  2.90142159  2.90690106  2.91235066  2.91777073  2.92316158
  2.92852352  2.93385687  2.93916192  2.94443898  2.94968834  2.95491028
  2.9601051   2.96527307  2.97041447  2.97552957  2.98061864  2.98568194
  2.99071973  2.99573227  3.00071982  3.0056826   3.01062089  3.0155349
  3.02042489  3.02529108  3.0301337   3.03495299  3.03974916  3.04452244
  3.04927304  3.05400118  3.05870707  3.06339092  3.06805294  3.07269331
  3.07731226  3.08190997  3.08648664  3.09104245  3.09557761  3.10009229
  3.10458668  3.10906096  3.11351531  3.11794991  3.12236492  3.12676054
  3.13113691  3.13549422  3.13983262  3.14415228  3.14845336  3.15273602
  3.15700042  3.16124671  3.16547505  3.16968558  3.17387846  3.17805383
  3.18221184  3.18635263  3.19047635  3.19458313  3.19867312  3.20274644
  3.20680324  3.21084365  3.2148678   3.21887582  3.22286785  3.22684399
  3.2308044   3.23474917  3.23867845  3.24259235  3.24649099  3.25037449
  3.25424297  3.25809654  3.26193531  3.26575941  3.26956894  3.27336401
  3.27714473  3.28091122  3.28466357  3.28840189  3.29212629  3.29583687
  3.29953373  3.30321697  3.3068867   3.31054301  3.314186    3.31781577
  3.32143241  3.32503602  3.32862669  3.33220451  3.33576958  3.33932198
  3.3428618   3.34638915  3.34990409  3.35340672  3.35689712  3.36037539
  3.3638416   3.36729583  3.37073817  3.37416871  3.37758752  3.38099467
  3.38439026  3.38777436  3.39114705  3.39450839  3.39785848  3.40119738
  3.40452517  3.40784192  3.41114771  3.41444261  3.41772668  3.42100001
  3.42426265  3.42751469  3.43075618  3.4339872   3.43720782  3.44041809
  3.4436181   3.44680789  3.44998755  3.45315712  3.45631668  3.45946629
  3.46260601  3.4657359   3.46885603  3.47196645  3.47506723  3.47815842
  3.48124009  3.48431229  3.48737508  3.49042852  3.49347266  3.49650756
  3.49953328  3.50254988  3.5055574   3.5085559   3.51154544  3.51452607
  3.51749784  3.5204608   3.52341501  3.52636052  3.52929738  3.53222564
  3.53514535  3.53805656  3.54095932  3.54385368  3.54673969  3.54961739
   30271283  4.30406509  4.30541553  4.30676415  4.30811095  4.30945594
   .48751214  4.48863637  4.48975933  4.49088104  4.49200149  4.49312068
   .56538932  4.56642936  4.56746832  4.5685062   4.56954301  4.57057874
  4.5716134   4.57264699  4.57367952   4.57471098  4.57574138  4.57677071
  4.57779899  4.57882621  4.57985238  4.58087749  4.58190156  4.58292458
  4.58394655  4.58496748  4.58598737  4.58700622  4.58802403  4.5890408
  4.59005655  4.59107126  4.59208495  4.5930976   4.59410924  4.59511985
  4.59612944  4.59713801  4.59814557  4.59915211  4.60015764  4.60116216
  4.60216568  4.60316818  4.60416969'''

#   Vor der Auaführung des Codes, zuächst  immer Originalzustand herstellen.
#   Dann Komma einsetzen u,     print(modified_string)  aktivieren
modified_string = original_string.replace(" "  , " ")           # ((" "  , ", ")      
#print(original_string )                                 
print(modified_string)  




OSWALD
User
Beiträge: 527
Registriert: Freitag 18. März 2022, 17:32

16.3.2025
Beim letzten Beispiel ergeben sich große Probleme .
Zwar kann ich die zur Darstellung der Daten
notwendigen Kommata einfügen, gleichzeitig aber
ein auch v o r jeder Zeile entstehendes Komma nicht mehr entfernen.
Noch nicht. ?
Die Lösung von einfachen Logarithmische Gleichungen
zeige ich in folgendem Beispiel.
NB: Sonderfall log5 usw.

Gute Zeit OSWALD

Code: Alles auswählen



#                                 Einfache       Logarithmische Gleichungen      lösen
#                                                                                                                                                                                                                                                                               ipy import *
import numpy as np
from numpy import  *  
#                                  Allgemeine  Formel  :      log(Basis)    =    Numerus
#                                  Beispiele           mit unterschiedlicher Basis       

##########                        log(x) = 2

x=e**1
print(x)
x=e**2
print(x)
x=e**2.718
print(x)
x=e**exp(-2)
print(x)

print()

     
##########                        log10(x) = 3
x= log10(1)
print(x)
x= log10(10)
print(x)
x= log10(3.4)
print(x)
x= log10(log(10))
print(x)


print()
##########                       log2(x)  =2
x= log2(1)
print(x)
x=log2(10)
print(x)
x=log2(10)
print(x)
x=log2(sin(3))
print(x)

print()
##########                       log5(x)  =2    
x= log((1,5) )
print(x)
x= log((3.27,5))
print(x)
x=log((0.4,5))
print(x)
x=log((log10(19),5))
print(x)
x=log((exp(3),5))
print(x)




OSWALD
User
Beiträge: 527
Registriert: Freitag 18. März 2022, 17:32

17.3.2025
Hier der Versuch eine weitere Version von Log.Gleichungen
mit Python zu lösen.
Als Basis kann hier der Logarithmus jeder positiven Zahl > 0 eingesetzt werden.
Die Beispiele sollten selbsterklärend sein
Gute Zeit OSWALD

Code: Alles auswählen



#Logarithmische Gleichungen   :Bestimmung des  Logarithmanden  als " Basis "                                                                                                                                                                                                                                                                          ipy import *
import numpy as np
from numpy import *

#:formal  :        logarithmand  *  x  = numerus  

#log3  *x  =100
print(3**10)
#####################################


#  beispiel                         
#  log(.e**1/2 * x  =  7
                                      
x= e**1/2   ** 7
print(e **7)

#log4*x**2 =6 
#x**2 =  4**6
x= 4**6  *1/2
print(4**6  *1/2)

#log3*x - log3*5*x            = 5
# log3*4*x =12
x= 4**5**1/4
print(4**5**1/4)

#log2*x   =  2.7184
x= 2**2.718
print(e**2.7184)

#log1.7 *x     = 10
x=1.7
1.7**5
print(x)

#loge *x  =100
x=  e**100
print(e**10)

#log(pi/e) x = 35 
x=pi/e**35





OSWALD
User
Beiträge: 527
Registriert: Freitag 18. März 2022, 17:32

17.3.2025
Als Basis kann man auch Logarithmanden < 1
für die Behandlung von sehr kleinen und beliebigen Numerus-Werten
einsetzen.
Im Grunde halt wieder eine Spielerei.
Gute Zeit OSWALD

Code: Alles auswählen


#Logarithmus mit  sehr kleiner Basis
import  numpy as np
from numpy import *

# log0.5(*x) = 25    gilt formal für weitere   Ergebnisse)

print(0.5 **pi)
print(0.1 **e)
print(0.03**e )
print(0.1 ** pi)
print(log(pi)** 0.0000000001)
print(log(e)**e)

Antworten