Tiefe = %v

Geschwindigkeit = %v

Zurücksetzen

Abspielen

Pausieren

Schritt

Theoretischer Wert

scale_y = 1 (slider from 0.25 to 5, step 0.25)
scale_x = 1 (slider from 0.25 to 5, step 0.25)
depth = 10 (slider from 1 to 100, step 1)
Base: (0, 0)
E_{filter}: Base + (1 + (depth * scale_x), -1.5 - (depth * scale_y))
D_{filter}: Base - (1 + (depth * scale_x), 1.5 + (depth * scale_y))
A_{filter}: Base - (1, 0)
B_{filter}: Base - (1, 1)
F_{filter}: Base + (1 + (depth * scale_x), -1 - (depth * scale_y))
G_{filter}: Base + (1, -1)
C_{filter}: Base - (1 + (depth * scale_x), 1 + (depth * scale_y))
H_{filter}: Base + (1, 0)
FilterContent = Polygon({A_{filter}, B_{filter}, C_{filter}, D_{filter}, E_{filter}, F_{filter}, G_{filter}, H_{filter}})
PathPoints = Flatten(Sequence[Sequence[Base + ((((2 * i) - j) * scale_x), -1 - (j * scale_y)), i, 0, j], j, 0, depth - 1])
ColumnBackground(x, y) = x(C_{filter}) < x < x(F_{filter}) ∧ y < y(D_{filter})
speed = 7 (slider from 1 to 100, step 1)
t = 0 (slider from 0 to 1, step 0.01)
Path_{delta} = Sequence(((2 * scale_x) * (Random[0, 1] - 0.5)), i, 1, depth)
Path = Join({{Base - (0, 0.5), Base - (0, 1)}, Sequence[Base + (Sum[Path_{delta}, j], -1 - (j * scale_y)), j, 1, depth]})
PathLine = PolyLine(Path)
P = Point(PathLine, t)
n = 0
Results: {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
Filter = PolyLine({A_{filter}, B_{filter}, C_{filter}, D_{filter}, E_{filter}, F_{filter}, G_{filter}, H_{filter}})
EndIndex: (depth + Sum[Path_{delta} / scale_x]) / 2
L_x = Join({{x(D_{filter})}, Sequence[x(Base) + (scale_x * ((2 * i) - depth + 1)), i, 0, depth - 1], {x(E_{filter})}})
L_{columns} = Sequence(Ray[(Element[L_x, i + 1], y(D_{filter})), (Element[L_x, i + 1], y(D_{filter} - 1))], i, 0, depth + 1)
AnimationEnabled = false
Path_t = Take(Path, 1, 2 + (t * (depth + 1)))
PathLine_t = PolyLine(Path_t)
Pegs: PathPoints + (0, (-0.5 * scale_y))
ColumnBackground2(x, y) = x(C_{filter}) < x < x(F_{filter}) ∧ y > 0
L_{columns2} = Sequence(Ray[(Element[L_x, i + 1], 0), (Element[L_x, i + 1], 1)], i, 0, depth + 1)
a = false
Balken = Sequence(Polygon[(Element[L_x, i + 1], y(D_{filter}) - (2 * scale_y)), (Element[L_x, i + 2], y(D_{filter}) - (2 * scale_y)), (Element[L_x, i + 2], y(D_{filter}) - ((2 * scale_y) * (1 - Element[Results, i + 1] / n))), (Element[L_x, i + 1], y(D_{filter}) - ((2 * scale_y) * (1 - Element[Results, i + 1] / n)))], i, 0, depth)
Results_{theoretical} = Sequence(Polygon[(Element[L_x, i + 1], y(D_{filter}) - (2 * scale_y)), (Element[L_x, i + 2], y(D_{filter}) - (2 * scale_y)), (Element[L_x, i + 2], y(D_{filter}) - ((2 * scale_y) * (1 - ((2 * nCr[depth, i]) * 0.5^(depth + 1))))), (Element[L_x, i + 1], y(D_{filter}) - ((2 * scale_y) * (1 - ((2 * nCr[depth, i]) * 0.5^(depth + 1)))))], i, 0, depth)
Display: "n=" + (LaTeX[n]) + ""
f_{normal}(x, σ, μ) = (1 / ((sqrt((2 * π)) * σ)) * ℯ^(((-(x - μ)^(2))) / 2))