a

b

f(x) =

Integralfunktion anzeigen

a =

b =

Information

INTEGRATOR  IV
Man kann eine Funktion f, Intervallgrenzen a und b und die Schrittweite h eingeben.
1. Man kann an einem Punkt S (dem 'Stift') auf dem Graphen von f im Intervall [a, b] ziehen.
    Die x-Koordinate von S wird dabei als x angezeigt. 
    In der Modellierung gehen wir davon aus, dass wir dabei in n Schritten, mit der Schrittweite h=(x-a)/n,  
    von Punkt zu Punkt auf dem Graphen von f vorgehen. n ist die Anzahl der Unterteilungen des Intervalls [a; x].
2. Zur Funktion f kann man dann schrittweise und punktweise den Graphen einer Funktion F(x) aufbauen.
    Dabei wird schrittweise zum Wert F(x_0) der Wert f(x_0)*h addiert und damit F(x_0+h) erzeugt.
    Die Entwicklung von F hängt auch vom Wert von h ab. Für immer kleinere h stabilisiert sich das Verfahren.
    Wir bekommen so zunächst punktweise und näherungsweise einen Zugang zur Stammfunktion.
    ANMERKUNG: Ich habe der Einfachheit halber intern den vorgefertigten Befehl LinkeSumme benutzt, weil der genau mit den 
    gewünschten Termen arbeitet. Das sieht dadurch im Algebra-Fenster so aus, als würde ich integrieren. 
    Aber bei der LinkeSumme und beim Euler-Cauchy Verfahren habe ich die gleichen Terme (sofern ich das richtig verstanden habe).
    In der Sache baue ich die Punkte von F nach Euler-Cauchy auf!
    Dass es um die gleichen Summanden geht, ist natürlich kein Zufall, sondern hängt mit dem HDI zusammen.
3. Aus optischen Gründen werden hier die einzelnen Punkte durch einen Linienzug verbunden und dann ausgeblendet.
    Für einigermaßen großes n erhält man einen Graphen von F, der weitgehend 'glatt' aussieht (was aber eine Illusion ist).
    ACHTUNG: je nach Rechner kann das auch etwas 'zäh' werden!
4. Mit dem Kontrollkästchen Integralfunktion kann man sich auch den Graphen der Integralfunktion anzeigen lassen.
    Für größere n sind die Graphen der Stammfunktion(snäherung) und der Integralfunktion anschaulich nicht mehr unterscheidbar. 
    Aber im Vergleich wird hier deutlich, dass für kleine n die Stammfunktionsnäherung doch sichtbar vom Graphen der Integralfunktion abweicht.
    Für größere n (z.B. n=200) ist dieser Unterscheid anschaulich nicht mehr sichtbar.
    D.h. Stammfunktion bilden und Integralfunktion bilden läuft auf dasselbe hinaus (wenn man angemessen mit den Konstanten umgeht.
    Das Einblenden der Integralfunktion dient hier vorwiegend der Kontrolle. Würde ich schlussendlich ausblenden.
    Hinweis: für größere n (z.B: Erhöhung auf n = 1000) lässt je nach Rechner die Performance deutlich nach, es wird ziemlich 'ruckelig'.
5. Jetzt könnte man noch G(x) = Integral[f] erzeugen und G(x) - G(a) zeichnen lassen.

Hinweis 1: Dies trifft nur bei 'gutartigen' Funktionen f zu, z.B. bei schultypischen stetigen Funktionen.
Hinweis 2: Wir können so auch Stammfunktionen von Funktionen f zeichnen, von denen wir wissen, dass f integierbar ist, aber
keinen Funktionsterm in geschlossener Form hat.
Hinweis 3: Die Tangente an Z ist keine richtige Tangente, sondern auf der stückweise erzeugten Funktion F eine rechtsseitige Sekante.

 
                Integrator IV                                                                                                                                                                                                                                                                                                                                                                                                             
                                    

H.-J. Elschenbroich & G. Seebach (2015)

Integraph: Stammfunktion näherungsweise zeichnen

x

Aufgabe

Man kann einen Punkt S (wie einen Stift) auf dem Graphen von f im Intervall [a, b] ziehen.
Die x-Koordinate von S wird dabei als x angezeigt. 
Über den Schieberegler n kann man die Anzhal der Schritte steuern, mit der zur Funktion f 
punktweise der Graph einer Funktion F aufgebaut wird. Schrittweite ist h = (x-a)/n .
Start ist mit F(a) = 0 und dann wird schrittweise zum Wert F(x_0) der Wert f(x_0)*h addiert 
und damit F(x_0+h) erzeugt. Die Entwicklung von F hängt somit auch vom Wert von h bzw. n ab.
Die Punkte werden hier durch einen Linienzug verbunden und sind nicht einzeln sichtbar.
Mit dem Kontrollkästchen 'Integraph' kannst du dies anzeigen lassen.

a) Ziehe an S und beobachte Z und den roten Graphen.
    Was stellst du fest, wenn du n am Schieberegler verkleinerst/ vergrößerst?
b) Was stellst du für die Steigung des Graphen, für die Steigung der Tangente im Punkte Z, fest?

Zur 'Ableitung' von F oder Warum F eine Stammfunktion(snäherung) ist:

An der Stelle x_0+h hat F die linksseitige Sekantensteigung f(x_0).
Für h → 0 kommen wir dann für F an der Stelle x_0 auf die (linksseitige) Steigung f(x_0). 
 

Z

Steigung in Z

Wert f(x)

n = 200 (slider from 1 to 400, step 1)
a = -2 (slider from -50 to 40, step 0.1)
b = 4 (slider from a + 1 to 50, step 0.1)
f(x) = (0.4 * x^(2)) + 1
A: (a, 0)
B: (b, 0)
f1(x) = If[a ≤ x ≤ b, f(x)]
S = Point(f1)
dx: (x(S) - a) / n
ab = Segment(A, B)
Textfeld2 = Textfield(f)
Integral_x = Integral(f, a, x(S))
I_a: (x(S), Integral_x)
intfkt = false
Textfeld1 = Textfield(a)
Textfeld3 = Textfield(b)
info = false
integra = false
XS: (x(S), 0)
s = Segment(S, XS)
ax = Segment(A, XS)
Integralfunktion = Locus(I_a, S)
c = Segment(XS, I_a)
aufg = false
f2(x) = If[a ≤ x ≤ x(S), f(x)]
e = Segment(XS, S)
Punkte2_F = Sequence((a + (k * dx), LeftSum[f, a, a + (k * dx), k]), k, 1, n)
Punkte1_F: {(a, 0)}
Punkte_F = Union(Punkte1_F, Punkte2_F)
g = PolyLine(Punkte_F)
Letztes_F = Last(Punkte_F)
Z = Element(Letztes_F, 1)
d = Circle(XS, 1)
C, D = Intersect(d, xAxis)
h = Line(C, S)
tangente = Line(Z, h)
i = Slope(tangente)
steig = false
r = 1 (slider from 0 to 5, step 0.1)
k = Circle(Z, r)
E, F = Intersect(k, tangente)
l = Segment(Z, F)
m = OrthogonalLine(Z, tangente)
G, H = Intersect(k, m)
p = AngularBisector(G, Z, F)
q = AngularBisector(F, Z, H)
I, J = Intersect(k, q)
K, L = Intersect(k, p)
a_1 = AngularBisector(L, Z, F)
b_1 = AngularBisector(F, Z, J)
O, P = Intersect(k, a_1)
d_1 = Segment(S, XS)
wert = false
M = Midpoint(S, XS)
fx: f(x(S))
Text2: "" + fx + ""
N, Q = Intersect(k, b_1)