speed=

A = (1.3146109885214032, 2.718656277021976)
α = 0.9599310885968813 rad (slider from 0 to 6.283185307179586, step 0.017453292519943295)
v_0 = 2
inputBox1 = Textfield(v_0)
g = 2.4 (slider from 0 to 15, step 0.1)
f = If(x ≥ x(A), y(A) + (x - x(A)) * tan(α) - g / 2 * ((x - x(A)) / (v_0 * sin(α)))^(2))
time = 2.8 (slider from 0 to 10, step 0.05)
a = CurveCartesian(x(A) + v_0 * cos(α) * t, y(A) + v_0 * sin(α) * t - g / 2 * t^(2), t, 0, time)
B: (x(A) + v_0 * cos(α) * time, y(A) + v_0 * sin(α) * time - g / 2 * time^(2))
list1 = Sequence((x(A) + v_0 * cos(α) * t, y(A) + v_0 * sin(α) * t - g / 2 * t^(2)), t, 0, time, 0.1)
drag = 0.32 (slider from 0 to 1, step 0.01)
power = 1.5 (slider from 0 to 3, step 0.1)
timeStep = 0.1 (slider from 0 to 0.1, step 0.0010)
B1: x(A)
C1: y(A)
D1: v_0 * cos(α)
E1: v_0 * sin(α)
F1: -sgn(D1) * drag * abs(D1)^(power)
G1: -g - sgn(E1) * drag * abs(E1)^(power)
A1 = 0
A2: A1 + timeStep
B2: B1 + D1 * timeStep
C2: C1 + E1 * timeStep
D2: D1 + F1 * timeStep
E2: E1 + G1 * timeStep
F2: -sgn(D2) * drag * abs(D2)^(power)
G2: -g - sgn(E2) * drag * abs(E2)^(power)
A3: A2 + timeStep
B3: B2 + D2 * timeStep
C3: C2 + E2 * timeStep
D3: D2 + F2 * timeStep
E3: E2 + G2 * timeStep
F3: -sgn(D3) * drag * abs(D3)^(power)
G3: -g - sgn(E3) * drag * abs(E3)^(power)
A4: A3 + timeStep
B4: B3 + D3 * timeStep
C4: C3 + E3 * timeStep
D4: D3 + F3 * timeStep
E4: E3 + G3 * timeStep
F4: -sgn(D4) * drag * abs(D4)^(power)
G4: -g - sgn(E4) * drag * abs(E4)^(power)
A5: A4 + timeStep
B5: B4 + D4 * timeStep
C5: C4 + E4 * timeStep
D5: D4 + F4 * timeStep
E5: E4 + G4 * timeStep
F5: -sgn(D5) * drag * abs(D5)^(power)
G5: -g - sgn(E5) * drag * abs(E5)^(power)
A6: A5 + timeStep
B6: B5 + D5 * timeStep
C6: C5 + E5 * timeStep
D6: D5 + F5 * timeStep
E6: E5 + G5 * timeStep
F6: -sgn(D6) * drag * abs(D6)^(power)
G6: -g - sgn(E6) * drag * abs(E6)^(power)
A7: A6 + timeStep
B7: B6 + D6 * timeStep
C7: C6 + E6 * timeStep
D7: D6 + F6 * timeStep
E7: E6 + G6 * timeStep
F7: -sgn(D7) * drag * abs(D7)^(power)
G7: -g - sgn(E7) * drag * abs(E7)^(power)
A8: A7 + timeStep
B8: B7 + D7 * timeStep
C8: C7 + E7 * timeStep
D8: D7 + F7 * timeStep
E8: E7 + G7 * timeStep
F8: -sgn(D8) * drag * abs(D8)^(power)
G8: -g - sgn(E8) * drag * abs(E8)^(power)
A9: A8 + timeStep
B9: B8 + D8 * timeStep
C9: C8 + E8 * timeStep
D9: D8 + F8 * timeStep
E9: E8 + G8 * timeStep
F9: -sgn(D9) * drag * abs(D9)^(power)
G9: -g - sgn(E9) * drag * abs(E9)^(power)
A10: A9 + timeStep
B10: B9 + D9 * timeStep
C10: C9 + E9 * timeStep
D10: D9 + F9 * timeStep
E10: E9 + G9 * timeStep
F10: -sgn(D10) * drag * abs(D10)^(power)
G10: -g - sgn(E10) * drag * abs(E10)^(power)
A11: A10 + timeStep
B11: B10 + D10 * timeStep
C11: C10 + E10 * timeStep
D11: D10 + F10 * timeStep
E11: E10 + G10 * timeStep
F11: -sgn(D11) * drag * abs(D11)^(power)
G11: -g - sgn(E11) * drag * abs(E11)^(power)
A12: A11 + timeStep
B12: B11 + D11 * timeStep
C12: C11 + E11 * timeStep
D12: D11 + F11 * timeStep
E12: E11 + G11 * timeStep
F12: -sgn(D12) * drag * abs(D12)^(power)
G12: -g - sgn(E12) * drag * abs(E12)^(power)
A13: A12 + timeStep
B13: B12 + D12 * timeStep
C13: C12 + E12 * timeStep
D13: D12 + F12 * timeStep
E13: E12 + G12 * timeStep
F13: -sgn(D13) * drag * abs(D13)^(power)
G13: -g - sgn(E13) * drag * abs(E13)^(power)
A14: A13 + timeStep
B14: B13 + D13 * timeStep
C14: C13 + E13 * timeStep
D14: D13 + F13 * timeStep
E14: E13 + G13 * timeStep
F14: -sgn(D14) * drag * abs(D14)^(power)
G14: -g - sgn(E14) * drag * abs(E14)^(power)
A15: A14 + timeStep
B15: B14 + D14 * timeStep
C15: C14 + E14 * timeStep
D15: D14 + F14 * timeStep
E15: E14 + G14 * timeStep
F15: -sgn(D15) * drag * abs(D15)^(power)
G15: -g - sgn(E15) * drag * abs(E15)^(power)
A16: A15 + timeStep
B16: B15 + D15 * timeStep
C16: C15 + E15 * timeStep
D16: D15 + F15 * timeStep
E16: E15 + G15 * timeStep
F16: -sgn(D16) * drag * abs(D16)^(power)
G16: -g - sgn(E16) * drag * abs(E16)^(power)
A17: A16 + timeStep
B17: B16 + D16 * timeStep
C17: C16 + E16 * timeStep
D17: D16 + F16 * timeStep
E17: E16 + G16 * timeStep
F17: -sgn(D17) * drag * abs(D17)^(power)
G17: -g - sgn(E17) * drag * abs(E17)^(power)
A18: A17 + timeStep
B18: B17 + D17 * timeStep
C18: C17 + E17 * timeStep
D18: D17 + F17 * timeStep
E18: E17 + G17 * timeStep
F18: -sgn(D18) * drag * abs(D18)^(power)
G18: -g - sgn(E18) * drag * abs(E18)^(power)
A19: A18 + timeStep
B19: B18 + D18 * timeStep
C19: C18 + E18 * timeStep
D19: D18 + F18 * timeStep
E19: E18 + G18 * timeStep
F19: -sgn(D19) * drag * abs(D19)^(power)
G19: -g - sgn(E19) * drag * abs(E19)^(power)
A20: A19 + timeStep
B20: B19 + D19 * timeStep
C20: C19 + E19 * timeStep
D20: D19 + F19 * timeStep
E20: E19 + G19 * timeStep
F20: -sgn(D20) * drag * abs(D20)^(power)
G20: -g - sgn(E20) * drag * abs(E20)^(power)
A21: A20 + timeStep
B21: B20 + D20 * timeStep
C21: C20 + E20 * timeStep
D21: D20 + F20 * timeStep
E21: E20 + G20 * timeStep
F21: -sgn(D21) * drag * abs(D21)^(power)
G21: -g - sgn(E21) * drag * abs(E21)^(power)
A22: A21 + timeStep
B22: B21 + D21 * timeStep
C22: C21 + E21 * timeStep
D22: D21 + F21 * timeStep
E22: E21 + G21 * timeStep
F22: -sgn(D22) * drag * abs(D22)^(power)
G22: -g - sgn(E22) * drag * abs(E22)^(power)
A23: A22 + timeStep
B23: B22 + D22 * timeStep
C23: C22 + E22 * timeStep
D23: D22 + F22 * timeStep
E23: E22 + G22 * timeStep
F23: -sgn(D23) * drag * abs(D23)^(power)
G23: -g - sgn(E23) * drag * abs(E23)^(power)
A24: A23 + timeStep
B24: B23 + D23 * timeStep
C24: C23 + E23 * timeStep
D24: D23 + F23 * timeStep
E24: E23 + G23 * timeStep
F24: -sgn(D24) * drag * abs(D24)^(power)
G24: -g - sgn(E24) * drag * abs(E24)^(power)
A25: A24 + timeStep
B25: B24 + D24 * timeStep
C25: C24 + E24 * timeStep
D25: D24 + F24 * timeStep
E25: E24 + G24 * timeStep
F25: -sgn(D25) * drag * abs(D25)^(power)
G25: -g - sgn(E25) * drag * abs(E25)^(power)
A26: A25 + timeStep
B26: B25 + D25 * timeStep
C26: C25 + E25 * timeStep
D26: D25 + F25 * timeStep
E26: E25 + G25 * timeStep
F26: -sgn(D26) * drag * abs(D26)^(power)
G26: -g - sgn(E26) * drag * abs(E26)^(power)
A27: A26 + timeStep
B27: B26 + D26 * timeStep
C27: C26 + E26 * timeStep
D27: D26 + F26 * timeStep
E27: E26 + G26 * timeStep
F27: -sgn(D27) * drag * abs(D27)^(power)
G27: -g - sgn(E27) * drag * abs(E27)^(power)
A28: A27 + timeStep
B28: B27 + D27 * timeStep
C28: C27 + E27 * timeStep
D28: D27 + F27 * timeStep
E28: E27 + G27 * timeStep
F28: -sgn(D28) * drag * abs(D28)^(power)
G28: -g - sgn(E28) * drag * abs(E28)^(power)
A29: A28 + timeStep
B29: B28 + D28 * timeStep
C29: C28 + E28 * timeStep
D29: D28 + F28 * timeStep
E29: E28 + G28 * timeStep
F29: -sgn(D29) * drag * abs(D29)^(power)
G29: -g - sgn(E29) * drag * abs(E29)^(power)
A30: A29 + timeStep
B30: B29 + D29 * timeStep
C30: C29 + E29 * timeStep
D30: D29 + F29 * timeStep
E30: E29 + G29 * timeStep
F30: -sgn(D30) * drag * abs(D30)^(power)
G30: -g - sgn(E30) * drag * abs(E30)^(power)
H1: (B1, C1)
H2: (B2, C2)
H3: (B3, C3)
H4: (B4, C4)
H5: (B5, C5)
H6: (B6, C6)
H7: (B7, C7)
H8: (B8, C8)
H9: (B9, C9)
H10: (B10, C10)
H11: (B11, C11)
H12: (B12, C12)
H13: (B13, C13)
H14: (B14, C14)
H15: (B15, C15)
H16: (B16, C16)
H17: (B17, C17)
H18: (B18, C18)
H19: (B19, C19)
H20: (B20, C20)
H21: (B21, C21)
H22: (B22, C22)
H23: (B23, C23)
H24: (B24, C24)
H25: (B25, C25)
H26: (B26, C26)
H27: (B27, C27)
H28: (B28, C28)
H29: (B29, C29)
H30: (B30, C30)

Tool: Func-tan-thru-Pt (command FuncTanThruPt)
select function and point
Input: f, F
Output: tangentLines, tangentPoints

f(x) = -2 * x^(3) + 2 * x^(2) - 4 * x + 7
g(x) = (x(F) - x) * f'(x) - (y(F) - f(x))
groots: {Root[g]}
xcoord: x(groots)
ycoord: f(xcoord)
tangentPoints = Sequence((Element[xcoord, j], Element[ycoord, j]), j, 1, Length[xcoord])
tangentLines = Sequence(Line[F, Element[tangentPoints, j]], j, 1, Length[xcoord])