In [2]: # Wir wollen eine Funktion f: R -> R, x -> 3x modellieren

In [3]: def f(x):
   ...:     return 3*x
   ...: 

In [4]: # Schauen wir uns mal ein paar Funktionsauswertungen an

In [5]: f(-1)
Out[5]: -3

In [6]: f(3)
Out[6]: 9

In [7]: f(100)
Out[7]: 300

In [8]: # Ist f eigentlich eine lineare Funktion? Also gilt f(alpha x) = alpha f(x)?

In [9]: f(2*6)
Out[9]: 36

In [10]: 2*f(6)
Out[10]: 36

In [11]: f(2*6) == 2*f(6)
Out[11]: True

In [12]: # Zumindest für alpha = 2 und x = 6

In [13]: # Testen wir noch einmal ein paar andere Zahlen mit einer Hilfsfunktion

In [14]: def ist_diese_funktion_linear(func):
    ...:     from random import uniform           # Um "zufällige" Zahlen zu erhalten
    ...:     for counter in range(100):           # Wir wollen 100 mal testen
    ...:         x = uniform(-100, 100)           # Ein zufälliges x \in [-100, 100)
    ...:         alpha = uniform(-5, 5)           # Ein zufälliges alpha \in [-5, 5)
    ...:         # Da Rundungsfehler auftreten können, können wir nicht mit == testen,
    ...:         # sondern müssen die Differenz betrachten
    ...:         if func(alpha * x) - alpha * func(x) > 1e-10:
    ...:             print('nicht linear!')
    ...:             return                       # Wir müssen nicht weiter testen
    ...:     # Wenn wir hier angekommen sind ...
    ...:     print('möglicherweise linear')
    ...:     

In [15]: ist_diese_funktion_linear(f)
möglicherweise linear

In [16]: # Einverstanden!

In [17]: # Schauen wir uns noch eine affine Funktion g: R -> R, x -> 2x + 2 an

In [18]: def g(x):
    ...:     return 2*x + 2
    ...: 

In [19]: # Zuerst wieder ein paar Funktionsauswertungen

In [20]: g(0)
Out[20]: 2

In [21]: g(1)
Out[21]: 4

In [22]: # Wir können auf Linearität testen, indem wir unsere Hilfsfunktion wieder verwenden

In [23]: ist_diese_funktion_linear(g)
nicht linear!

In [24]: # Einverstanden

In [25]: # Schauen wir uns mal die Steigung von g im Punkt 2 an

In [26]: # Mit Hilfe des Differentienquotienten

In [27]: (g(2.1) - g(2.0)) / (2.1 - 2.0)
Out[27]: 2.0

In [28]: # Um noch mehr Punkte zu testen schreiben wir uns wieder eine Hilfs-Funktion

In [29]: def diffquot(func, x):
    ...:     return (func(x + 0.1) - func(x)) / 0.1
    ...: 

In [30]: diffquot(g, 2)
Out[30]: 2.0000000000000018

In [31]: # Einverstanden (bis auf Rundungsfehler)

In [32]: # Und noch einmal die Steigung von g in einem anderen Punkt, weil es so schön konstant ist

In [33]: diffquot(g, -1)
Out[33]: 1.9999999999999996

In [34]: # Ähnlich konstan verhält es sich für f

In [35]: diffquot(f, -1)
Out[35]: 2.9999999999999982

In [36]: diffquot(f, 3)
Out[36]: 3.000000000000007

In [37]: # Betrachten wir noch einmal eine Parabel h: R -> R, x -> x^2

In [38]: def h(x):
    ...:     return x**2
    ...: 

In [39]: # Jetzt können wir wieder einfach auf Linearität testen

In [40]: ist_diese_funktion_linear(h)
nicht linear!

In [41]: # Und die Steigung in ein paar Punkten approximativ bestimmen

In [42]: diffquot(h, 0)
Out[42]: 0.10000000000000002

In [43]: diffquot(h, 1)
Out[43]: 2.100000000000002

In [44]: diffquot(h, 2)
Out[44]: 4.100000000000001

In [45]: diffquot(h, 3)
Out[45]: 6.100000000000012

In [46]: # Als nächstes schauen wir uns mal eine Wertetabelle an

In [47]: import numpy as np

In [48]: punkte = np.linspace(-1, 3, 10)

In [49]: punkte
Out[49]: 
array([-1.        , -0.55555556, -0.11111111,  0.33333333,  0.77777778,
        1.22222222,  1.66666667,  2.11111111,  2.55555556,  3.        ])

In [50]: # Zuerst von h

In [51]: werte_von_h = []

In [52]: for x in punkte:
    ...:     werte_von_h.append(h(x))
    ...:     

In [53]: werte_von_h
Out[53]: 
[1.0,
 0.30864197530864201,
 0.01234567901234569,
 0.11111111111111106,
 0.60493827160493807,
 1.4938271604938274,
 2.7777777777777772,
 4.4567901234567886,
 6.530864197530863,
 9.0]

In [54]: # Und plotten einen Funktionsgrafen von h

In [55]: import matplotlib.pyplot as plt

In [56]: plt.plot(punkte, werte_von_h)
Out[56]: [<matplotlib.lines.Line2D at 0x7f0730053128>]

In [57]: plt.show()

In [58]: # Wir können auch die Art des Plots anpassen, z.B. nur die Punkte (x, h(x)) zeigen

In [59]: plt.plot(punkte, werte_von_h, 'o')
Out[59]: [<matplotlib.lines.Line2D at 0x7f07217562e8>]

In [60]: plt.show()

In [61]: # Und mit Linien verbinden

In [62]: plt.plot(punkte, werte_von_h, '-o')
Out[62]: [<matplotlib.lines.Line2D at 0x7f0721664c18>]

In [63]: plt.show()

In [64]: # Und rot einfärben

In [65]: plt.plot(punkte, werte_von_h, '-or')
Out[65]: [<matplotlib.lines.Line2D at 0x7f07212dca90>]

In [66]: plt.show()

In [67]: # Zusätzlich können wir die Ableitung von h darstellen

In [68]: # Das machen wir mit einer List-comprehension

In [69]: werte_von_h_strich = [diffquot(h, x) for x in punkte]

In [70]: werte_von_h_strich
Out[70]: 
[-1.8999999999999995,
 -1.0111111111111108,
 -0.12222222222222233,
 0.76666666666666616,
 1.6555555555555557,
 2.544444444444447,
 3.4333333333333371,
 4.3222222222222229,
 5.2111111111111175,
 6.1000000000000121]

In [71]: plt.plot(punkte, werte_von_h, '-or')
Out[71]: [<matplotlib.lines.Line2D at 0x7f07208beda0>]

In [72]: plt.plot(punkte, werte_von_h_strich, '-xb')
Out[72]: [<matplotlib.lines.Line2D at 0x7f07208d2b70>]

In [73]: plt.legend(['h', 'Ableitung von h'])
Out[73]: <matplotlib.legend.Legend at 0x7f07208df828>

In [74]: plt.show()

In [75]: # Und noch einmal alle Funktionen in einem Plot

In [76]: plt.plot(punkte, [f(x) for x in punkte], '-')
Out[76]: [<matplotlib.lines.Line2D at 0x7f073ce9f400>]

In [77]: plt.plot(punkte, [g(x) for x in punkte], '-')
Out[77]: [<matplotlib.lines.Line2D at 0x7f07212f8780>]

In [78]: plt.plot(punkte, [h(x) for x in punkte], '-o')
Out[78]: [<matplotlib.lines.Line2D at 0x7f07212afc18>]

In [79]: plt.plot(punkte, [diffquot(h, x) for x in punkte], '-x')
Out[79]: [<matplotlib.lines.Line2D at 0x7f0720877518>]

In [80]: plt.legend(['f', 'g', 'h', 'h\''])
Out[80]: <matplotlib.legend.Legend at 0x7f0723dc2cc0>

In [81]: plt.show()