@lila_Erdmaennchen: Nun ja, der Gedanke ist dann offensichtlich falsch gewesen. Dann musst Du also herausfinden wo und warum das Programm anfängt (Zwischen)Ergebnisse zu produzieren die vom Typ und/oder Wert nicht Deinen Erwartungen entsprechen. Das geht ganz gut in einer interaktiven Python-Shell, denn da wirst Du sehr schnell auf folgendes stossen:
Code: Alles auswählen
In [20]: np.linspace(1, 3, 10)
Out[20]:
array([ 1. , 1.22222222, 1.44444444, 1.66666667, 1.88888889,
2.11111111, 2.33333333, 2.55555556, 2.77777778, 3. ])
In [21]: 42 / np.linspace(1, 3, 10)
Out[21]:
array([ 42. , 34.36363636, 29.07692308, 25.2 ,
22.23529412, 19.89473684, 18. , 16.43478261,
15.12 , 14. ])
In [22]: math.exp(42 / np.linspace(1, 3, 10))
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-22-00b5b9945336> in <module>()
----> 1 math.exp(42 / np.linspace(1, 3, 10))
TypeError: only length-1 arrays can be converted to Python scalars
Du benutzt Numpy-Arrays auch in den anderen Funktion nicht so wie sie gedacht sind, weil Du in Python-Schleifen über die einzelnen Elemente iterierst, statt mit dem ganzen Array zu rechnen.
Anmerkungen zum Quelltext: Vergiss bitte sofort das es ``global`` gibt. Das hat in sauberen Programmen nichts zu suchen und ist bei dem Quelltext sogar noch komplett sinnlos weil die Namen `s1` und `s2` jeweils nur innerhalb der Funktion verwendet werden. Ebenfalls sinnfrei ist es dort jeweils in der vorletzten Zeile den Namen an einen anderen zu binden der danach dann ausschliesslich für das ``return`` verwendet wird. Lokale Namen die den gleichen Namen wie die Funktion tragen sind auch nicht gerade gut für die Lesbarkeit. Falls Du von Pascal oder einem Basic-Dialekt kommst, der Rückgabewerte so zuweist: Lass das bitte bleiben und fang an in Python zu programmieren.
Funktionen sollten weder mit ``global`` Namen ausserhalb (neu) binden, noch auf Werte von ausserhalb zugreifen die keine Konstanten sind und nicht als Argument übergeben wurden. Das macht Programme sehr schwer nachvollziehbar und damit schwer testbar, wartbar, und erweiterbar. Eine Funktion sollte eine in sich geschlossene Einheit sein, die man nachvollziehen kann ohne das gesamte restliche Programm im Kopf zu haben. Deswegen schreibt man am besten auch das Hauptprogramm in eine Funktion, so dass auf Modulebene nur Konstanten, Funktionen, und Klassen definiert werden.
Ein paar Leerzeichen nach Kommas und um Operatoren erhöhen die Lesbarkeit.
``return`` ist keine Funktion, sollte also auch nicht so geschrieben werden als wäre es eine.
``for i in range(len(sequence)):`` um dann `i` als Indexwert für `sequence` zu verwenden ist in Python ein „anti pattern“. Man kann in Python direkt über die Werte von Sequenztypen iterieren, ohne den Umweg über einen Index. Wenn man über zwei (oder mehr) iterierbare Objekte ”parallel” iterieren muss, gibt es `zip()` oder `itertools.izip()`. Braucht man einen Indexwert *zusätzlich* zum Element, gibt es `enumerate()`.
Statt in einer Schleife selber aufzusummieren, gibt es die `sum()`-Funktion.
``sequence[len(sequence) - 1]`` ist als ``sequence[-1]`` kürzer geschrieben.
Die 2000 bei der Definition von `n` ist gewagt. Das soll ja wahrscheinlich immer so lang das wie die Eingabedaten, also sollte man das auch so schreiben.
Die erste Zuweisung an `chi` wird nirgends verwendet, kann also weg.
Die Berechnung von `chi` ist so gequetscht geschrieben sehr schwer zu durchschauen.
`Nnullfkt()` wird in der selben Rechnung zweimal mit den gleichen Argumenten aufgerufen.
Ein äquivalentes (also mit den gleichen Fehlern), „pythonischeres“ Programm könnte so aussehen:
Code: Alles auswählen
#!/usr/bin/env python
# coding: utf-8
import math
from itertools import izip
import numpy as np
from matplotlib import pyplot as plt
def Nnullfkt(Nges, x, t1, tk, dt):
return Nges / (math.exp(-t1 / x) - math.exp(-(tk - dt) / x))
def sum1(t, x, dt):
return sum(math.exp(-(t_i + 0.5 * dt) / x) for t_i in t)
def sum2(N, t, x, dt):
return sum(
(1 / N_i) * math.exp(-(2 * t_i + dt) / x) for N_i, t_i in izip(N, t)
)
def main():
N = np.loadtxt('Ni.dat')
t = np.loadtxt('ti.dat')
if len(N) != len(t):
raise ValueError('Length of data differs.')
t1 = t[0]
tk = t[-1]
dt = t[1] - t[0]
Nges = np.sum(N)
x = np.linspace(1, 3, len(t))
nnullfkt_result = Nnullfkt(Nges, x, t1, tk, dt)
chi = (
Nges
- 2 * nnullfkt_result * dt * (1 / x) * sum1(t, x, dt)
+ ((nnullfkt_result * dt) / x)**2 * sum2(N, t, x, dt)
)
plt.plot(x, chi)
plt.grid(True)
plt.xlim(1.5, 3.5)
plt.ylim(0, 50000)
plt.show()
if __name__ == '__main__':
main()
