Kurvenintegral_Wegabhängigkeit
Author: Werner Knobloch 2011

Vektorfeld:

A_{Kurve} muss links von B_{Kurve} liegen !

Werner Knobloch 2011

\text{Kurvenintegral:wegunabhängig oder nicht ?

\scalebox{1.1} {\text{konservatives Feld}}

Skalierung = 0.2 (slider from 0 to 2, step 0.1)
u25(x, y) = (Skalierung * x)
u23(x, y) = (Skalierung * (x - (2 * y)))
u22(x, y) = (Skalierung * (x - y))
u21(x, y) = (Skalierung * y^(2))
u24(x, y) = (Skalierung * (-y))
u15(x, y) = (Skalierung * (-y))
u13(x, y) = (Skalierung * y)
u12(x, y) = ((Skalierung * x) * y)
u11(x, y) = (Skalierung * (-y))
u14(x, y) = (Skalierung * x)
Feldtyp = 2 (slider from 1 to 5, step 1)
r_2 = 1.5 (slider from 0.1 to 3, step 0.1)
Δ_{Kurve} = 0.11
a_{Grenze} = 0 (slider from 0 to Länge, step 0.1)
b_{Grenze} = 6.283 (slider from 0 to Länge, step 0.1)
Δ_{Bereich} = 0.3
en_{Kurvenpunkte}: round((b_{Grenze} - a_{Grenze}) / Δ_{Kurve})
r_1 = 2.8 (slider from 0.1 to 3, step 0.1)
ey(x) = (r_2 * sin(x))
ex(x) = (r_1 * cos(x))
Komponentenliste1: {u11, u12, u13, u14, u15}
v1 = Element(Komponentenliste1, Feldtyp)
Länge = 6.283 (slider from 0 to 6.283, step 0.1)
Komponentenliste2: {u21, u22, u23, u24, u25}
v2 = Element(Komponentenliste2, Feldtyp)
Ellipse = CurveCartesian(ex(t), ey(t), t, 0, Länge)
xmax = 3.3 (slider from -5 to 10, step 0.1)
xmin: (-xmax)
ymax = 2.3 (slider from -5 to 10, step 0.1)
ymin: (-ymax)
ex' = Derivative(ex)
ey' = Derivative(ey)
e_{Bogenintegrand}(x) = sqrt(ex'(x)^(2) + ey'(x)^(2))
e_{Bogenlänge} = Integral(e_{Bogenintegrand}, 0, b_{Grenze})
Teilkurve = CurveCartesian(ex(t), ey(t), t, a_{Grenze}, b_{Grenze})
n_x: round((2 * xmax / Δ_{Bereich}))
n_y: round((2 * ymax / Δ_{Bereich}))
Punkte_{Bereich} = Join(Sequence[Sequence[(xmin + (j * Δ_{Bereich}), ymin + (k * Δ_{Bereich})), j, 0, n_x], k, 0, n_y])
Vektorfeld0_{Bereich} = Sequence((v1(x(Element[Punkte_{Bereich}, j]), y(Element[Punkte_{Bereich}, j])), v2(x(Element[Punkte_{Bereich}, j]), y(Element[Punkte_{Bereich}, j]))), j, 1, ((n_x + 1) * (n_y + 1)))
Endpunkte_{Bereich}: Punkte_{Bereich} + Vektorfeld0_{Bereich}
Feldvektoren_{Bereich} = true
ePunkte_{Kurve} = Sequence({ex((j * Δ_{Kurve})), ey((j * Δ_{Kurve}))}, j, 0, en_{Kurvenpunkte})
eVektorfeld0_{Kurve} = Sequence({v1(Element[Element[ePunkte_{Kurve}, j], 1], Element[Element[ePunkte_{Kurve}, j], 2]), v2(Element[Element[ePunkte_{Kurve}, j], 1], Element[Element[ePunkte_{Kurve}, j], 2])}, j, 1, en_{Kurvenpunkte} + 1)
eEndpunkte_{Kurve}: ePunkte_{Kurve} + eVektorfeld0_{Kurve}
eVektorfeld_{Kurve} = Sequence(Vector[(Element[Element[ePunkte_{Kurve}, j], 1], Element[Element[ePunkte_{Kurve}, j], 2]), (Element[Element[eEndpunkte_{Kurve}, j], 1], Element[Element[eEndpunkte_{Kurve}, j], 2])], j, 1, en_{Kurvenpunkte} + 1)
A: x(Element[Punkte_{Bereich}, 1])
Vektorfeld_{Bereich} = Sequence(Vector[Element[Punkte_{Bereich}, j], Element[Endpunkte_{Bereich}, j]], j, 1, ((n_x + 1) * (n_y + 1)))
e_{Kurvenintegrand}(x) = (v1(ex(x), ey(x)) * ex'(x)) + (v2(ex(x), ey(x)) * ey'(x))
eArbeit = Integral(e_{Kurvenintegrand}, a_{Grenze}, b_{Grenze})
Feldvektoren_{Kurve} = true
Text3 = TableText({{LaTeX[v1, true, true]}, {LaTeX[v2, true, true]}})
rotTester = (-0.9991805607944068, -0.4671470954196898)
zeigeRot_{und}Div = true
v1_y = Derivative(v1, y)
v2_x = Derivative(v2, x)
rot(x, y) = v2_x(x, y) - v1_y(x, y)
rot_{rotTest}: rot(x(rotTester), y(rotTester))
DrehsternAnimation = 1.04 (slider from 0 to 3.141592653589793, step 0.26)
DrehsternTempo = If(abs(rot_{rotTest})  <  5, (10 * rot_{rotTest}), 50)
Drehkreuz = Sequence(Segment[Rotate[rotTester - (0.3, 0), k + DrehsternAnimation, rotTester], Rotate[rotTester + (0.3, 0), k + DrehsternAnimation, rotTester]], k, 0, 2.0944, 1.0472)
v1_x = Derivative(v1, x)
v2_y = Derivative(v2, y)
div_v(x, y) = v1_x(x, y) + v2_y(x, y)
divTest = (0.9828567803832086, -0.3470236201968042)
a: div_v(x(divTest), y(divTest))
Text5: "div = " + a + ""
t = 0.9 (slider from 0 to Länge, step 0.1)
P: (ex(t), ey(t))
p = Vector((0, 0), P)
C: (ex'(t), ey'(t))
B' = Translate(P, Vector[(0, 0), C])
p'_t = Vector(P, B')
Potential3(x, y) = (Skalierung * ((x * y) - y^(2)))
eArbeit_{gerundet} = If(eArbeit  <  0, (-abs(floor((eArbeit * 100) + 0.5) / 100)), floor((eArbeit * 100) + 0.5) / 100)
A_{Kurve} = (-3.6418970156978934, -1.348052580387518)
B_{Kurve} = (0.23208506024017245, 2.656063260375336)
a_x: x(A_{Kurve})
a_y: y(A_{Kurve})
b_y: y(B_{Kurve})
b_x: x(B_{Kurve})
AB: sqrt((b_x - a_x)^(2) + (b_y - a_y)^(2))
gx(x) = a_x + x
gy(x) = a_y + ((b_y - a_y) / (b_x - a_x) * x)
p_{Parabel}: (b_y - a_y)^(2) / ((2 * (b_x - a_x)))
px(x) = (p_{Parabel} * x^(2) / 2) + x(A_{Kurve})
py(x) = (p_{Parabel} * x) + y(A_{Kurve})
α: asin((b_y - a_y) / AB)
Mittelpunkt: (A_{Kurve} + B_{Kurve}) / 2
radius: AB / 2
kx(x) = (radius * (-cos(x - α))) + x(Mittelpunkt)
ky(x) = (radius * sin(x - α)) + y(Mittelpunkt)
Gerade = CurveCartesian(gx(t), gy(t), t, 0, b_x - a_x)
Halbkreis = CurveCartesian(kx(t), ky(t), t, 0, 3.14159)
t_BParabel: (b_y - a_y) / p_{Parabel}
Parabel = CurveCartesian(px(t), py(t), t, 0, t_BParabel)
gx' = Derivative(gx)
ky' = Derivative(ky)
kx' = Derivative(kx)
gy' = Derivative(gy)
px' = Derivative(px)
py' = Derivative(py)
p_{Kurvenintegrand}(x) = (v1(px(x), py(x)) * px'(x)) + (v2(px(x), py(x)) * py'(x))
k_{Kurvenintegrand}(x) = (v1(kx(x), ky(x)) * kx'(x)) + (v2(kx(x), ky(x)) * ky'(x))
g_{Kurvenintegrand}(x) = (v1(gx(x), gy(x)) * gx'(x)) + (v2(gx(x), gy(x)) * gy'(x))
pArbeit = Integral(p_{Kurvenintegrand}, 0, t_BParabel)
pArbeit_{gerundet} = If(pArbeit  <  0, (-abs(floor((pArbeit * 100) + 0.5) / 100)), floor((pArbeit * 100) + 0.5) / 100)
kArbeit = Integral(k_{Kurvenintegrand}, 0, 3.141592653589793)
kArbeit_{gerundet} = If(kArbeit  <  0, (-abs(floor((kArbeit * 100) + 0.5) / 100)), floor((kArbeit * 100) + 0.5) / 100)
gArbeit = Integral(g_{Kurvenintegrand}, 0, b_x - a_x)
gArbeit_{gerundet} = If(gArbeit  <  0, (-abs(floor((gArbeit * 100) + 0.5) / 100)), floor((gArbeit * 100) + 0.5) / 100)
g_{Bogenintegrand}(x) = sqrt(gx'(x)^(2) + gy'(x)^(2))
p_{Bogenintegrand}(x) = sqrt(px'(x)^(2) + py'(x)^(2))
k_{Bogenintegrand}(x) = sqrt(kx'(x)^(2) + ky'(x)^(2))
k_{Bogenlänge} = IntegralBetween(k_{Bogenintegrand}, 0, 0, 3.14159)
g_{Bogenlänge} = Integral(g_{Bogenintegrand}, 0, b_x - a_x)
p_{Bogenlänge} = Integral(p_{Bogenintegrand}, 0, t_BParabel)
pn_{Kurvenpunkte}: round(t_BParabel / Δ_{Kurve})
pPunkte_{Kurve} = Sequence({px((j * Δ_{Kurve})), py((j * Δ_{Kurve}))}, j, 0, pn_{Kurvenpunkte})
pVektorfeld0_{Kurve} = Sequence({v1(Element[Element[pPunkte_{Kurve}, j], 1], Element[Element[pPunkte_{Kurve}, j], 2]), v2(Element[Element[pPunkte_{Kurve}, j], 1], Element[Element[pPunkte_{Kurve}, j], 2])}, j, 1, pn_{Kurvenpunkte} + 1)
pEndpunkte_{Kurve}: pPunkte_{Kurve} + pVektorfeld0_{Kurve}
pVektorfeld_{Kurve} = Sequence(Vector[(Element[Element[pPunkte_{Kurve}, j], 1], Element[Element[pPunkte_{Kurve}, j], 2]), (Element[Element[pEndpunkte_{Kurve}, j], 1], Element[Element[pEndpunkte_{Kurve}, j], 2])], j, 1, pn_{Kurvenpunkte} + 1)
kn_{Kurvenpunkte}: round(π / Δ_{Kurve})
kPunkte_{Kurve} = Sequence({kx((j * Δ_{Kurve})), ky((j * Δ_{Kurve}))}, j, 0, kn_{Kurvenpunkte})
kVektorfeld0_{Kurve} = Sequence({v1(Element[Element[kPunkte_{Kurve}, j], 1], Element[Element[kPunkte_{Kurve}, j], 2]), v2(Element[Element[kPunkte_{Kurve}, j], 1], Element[Element[kPunkte_{Kurve}, j], 2])}, j, 1, kn_{Kurvenpunkte} + 1)
kEndpunkte_{Kurve}: kPunkte_{Kurve} + kVektorfeld0_{Kurve}
kVektorfeld_{Kurve} = Sequence(Vector[(Element[Element[kPunkte_{Kurve}, j], 1], Element[Element[kPunkte_{Kurve}, j], 2]), (Element[Element[kEndpunkte_{Kurve}, j], 1], Element[Element[kEndpunkte_{Kurve}, j], 2])], j, 1, kn_{Kurvenpunkte} + 1)
gn_{Kurvenpunkte}: round(abs(b_x - a_x) / Δ_{Kurve})
gPunkte_{Kurve} = Sequence({gx((j * Δ_{Kurve})), gy((j * Δ_{Kurve}))}, j, 0, gn_{Kurvenpunkte})
gVektorfeld0_{Kurve} = Sequence({v1(Element[Element[gPunkte_{Kurve}, j], 1], Element[Element[gPunkte_{Kurve}, j], 2]), v2(Element[Element[gPunkte_{Kurve}, j], 1], Element[Element[gPunkte_{Kurve}, j], 2])}, j, 1, gn_{Kurvenpunkte} + 1)
gEndpunkte_{Kurve}: gPunkte_{Kurve} + gVektorfeld0_{Kurve}
gVektorfeld_{Kurve} = Sequence(Vector[(Element[Element[gPunkte_{Kurve}, j], 1], Element[Element[gPunkte_{Kurve}, j], 2]), (Element[Element[gEndpunkte_{Kurve}, j], 1], Element[Element[gEndpunkte_{Kurve}, j], 2])], j, 1, gn_{Kurvenpunkte} + 1)
u31(x, y) = y^(2)
Text14: "\scalebox{1.1}" + (LaTeX[Text3]) + ""
Potential1(x, y) = 0
Potential2(x, y) = 0
Potential5(x, y) = 0
Potential4(x, y) = (Skalierung * ((1 / 2 * x^(2)) - (1 / 2 * y^(2))))
Potentialliste: {Potential1, Potential2, Potential3, Potential4, Potential5}
Potential = Element(Potentialliste, Feldtyp)
Potential_x = Derivative(Potential, x)
Potential_y = Derivative(Potential, y)
Text15 = LaTeX(Potential, true, true)
Potentialindex: {0, 0, 1, 1, 0}
Text16: "\scalebox{1.1} " + (LaTeX[Text15]) + ""
Text11: "Bogenlänge_{Ellipse} = \int_{" + (LaTeX[a_{Grenze}]) + " }^{" + (LaTeX[b_{Grenze}]) + " } \sqrt{ex'(t)^2 +ey'(t)^2 }\text{ }dt\text{ } = " + (LaTeX[e_{Bogenlänge}]) + ""
Text10: "Bogenlänge_{Parabel} = \int_{0 }^{" + (LaTeX[t_BParabel]) + " } \sqrt{px'(t)^2 +py'(t)^2}\text{ }dt\text{ } = " + (LaTeX[p_{Bogenlänge}]) + ""
Text2: "\scalebox{0.8}{\int_{Ellipse}^{} { F \cdot dr } \text{ }=\text{ } " + (LaTeX[eArbeit_{gerundet}]) + "}"
Text4: "Bogenlänge_{Kreis} = \int_{0 }^{" + (LaTeX[3.141592653589793]) + " } \sqrt{kx'(t)^2 +ky'(t)^2}\text{ }dt\text{ }= " + (LaTeX[k_{Bogenlänge}]) + ""
Text9: "Bogenlänge_{Gerade} = \int_{0 }^{" + (LaTeX[b_x - a_x]) + " } \sqrt{gx'(t)^2 +gy'(t)^2}\text{ }dt\text{ }= " + (LaTeX[g_{Bogenlänge}]) + ""
Text7: "\scalebox{0.8}{\int_{Gerade}{ F \cdot dr } \;=\;  " + (LaTeX[gArbeit_{gerundet}]) + "}"
Text8: "\scalebox{0.8}{\int_{Halbkreis}{ F \cdot dr } \;=\;  " + (LaTeX[kArbeit_{gerundet}]) + "}"
Text1: "\scalebox{0.8}{\int_{Parabel}{ F \cdot dr } \text{ }=\text{ } " + (LaTeX[pArbeit_{gerundet}]) + "}"
text6: "\scalebox{0.8}{\oint_{Ellipse}{ F \cdot dr } \;=\; " + (LaTeX[eArbeit_{gerundet}]) + "}"