time (s)

hor pos (m)

vert pos (m)

hor vel (m/s)

vert vel (m/s)

hor accel (m/s^2)

vert accel (m/s^2)

showpoint

hor pos (m)

vert pos (m)

hor vel (m/s)

vert vel (m/s)

hor accel (m/s^2)

vert accel (m/s^2)

showpoint

v_0 = 11 (slider from 0 to 25, step 1)
θ_0 = 50 (slider from 0 to 90, step 5)
y_0 = 0
g = -9.8
t_{step} = 0.02 (slider from 0 to 1, step 0.01)
drag = 0.1 (slider from 0 to 1, step 0.1)
time_{elapsed} = 3.12 (slider from 0 to 10, step t_{step})
A2 = 0
B2 = 0
C2: y_0
D2: v_0 * cos(θ_0 * π / 180)
E2: v_0 * sin(θ_0 * π / 180)
F2: -drag * D2
G2: g - drag * E2
A3: A2 + t_{step}
D3: D2 + F2 * t_{step}
B3: B2 + D2 * t_{step} + 1 / 2 * F2 * t_{step}^(2)
C3: C2 + E2 * t_{step} + 1 / 2 * G2 * t_{step}^(2)
E3: E2 + G2 * t_{step}
F3: -drag * D3
G3: g - drag * E3
H2 = If(A2 ≤ time_{elapsed}, (B2, C2))
H3 = If(A3 ≤ time_{elapsed}, (B3, C3))
A4: A3 + t_{step}
D4: D3 + F3 * t_{step}
B4: B3 + D3 * t_{step} + 1 / 2 * F3 * t_{step}^(2)
C4: C3 + E3 * t_{step} + 1 / 2 * G3 * t_{step}^(2)
E4: E3 + G3 * t_{step}
F4: -drag * D4
G4: g - drag * E4
H4 = If(A4 ≤ time_{elapsed}, (B4, C4))
A5: A4 + t_{step}
D5: D4 + F4 * t_{step}
B5: B4 + D4 * t_{step} + 1 / 2 * F4 * t_{step}^(2)
C5: C4 + E4 * t_{step} + 1 / 2 * G4 * t_{step}^(2)
E5: E4 + G4 * t_{step}
F5: -drag * D5
G5: g - drag * E5
H5 = If(A5 ≤ time_{elapsed}, (B5, C5))
A6: A5 + t_{step}
D6: D5 + F5 * t_{step}
B6: B5 + D5 * t_{step} + 1 / 2 * F5 * t_{step}^(2)
C6: C5 + E5 * t_{step} + 1 / 2 * G5 * t_{step}^(2)
E6: E5 + G5 * t_{step}
F6: -drag * D6
G6: g - drag * E6
H6 = If(A6 ≤ time_{elapsed}, (B6, C6))
A7: A6 + t_{step}
D7: D6 + F6 * t_{step}
B7: B6 + D6 * t_{step} + 1 / 2 * F6 * t_{step}^(2)
C7: C6 + E6 * t_{step} + 1 / 2 * G6 * t_{step}^(2)
E7: E6 + G6 * t_{step}
F7: -drag * D7
G7: g - drag * E7
H7 = If(A7 ≤ time_{elapsed}, (B7, C7))
A8: A7 + t_{step}
D8: D7 + F7 * t_{step}
B8: B7 + D7 * t_{step} + 1 / 2 * F7 * t_{step}^(2)
C8: C7 + E7 * t_{step} + 1 / 2 * G7 * t_{step}^(2)
E8: E7 + G7 * t_{step}
F8: -drag * D8
G8: g - drag * E8
H8 = If(A8 ≤ time_{elapsed}, (B8, C8))
A9: A8 + t_{step}
D9: D8 + F8 * t_{step}
B9: B8 + D8 * t_{step} + 1 / 2 * F8 * t_{step}^(2)
C9: C8 + E8 * t_{step} + 1 / 2 * G8 * t_{step}^(2)
E9: E8 + G8 * t_{step}
F9: -drag * D9
G9: g - drag * E9
H9 = If(A9 ≤ time_{elapsed}, (B9, C9))
A10: A9 + t_{step}
D10: D9 + F9 * t_{step}
B10: B9 + D9 * t_{step} + 1 / 2 * F9 * t_{step}^(2)
C10: C9 + E9 * t_{step} + 1 / 2 * G9 * t_{step}^(2)
E10: E9 + G9 * t_{step}
F10: -drag * D10
G10: g - drag * E10
H10 = If(A10 ≤ time_{elapsed}, (B10, C10))
A11: A10 + t_{step}
D11: D10 + F10 * t_{step}
B11: B10 + D10 * t_{step} + 1 / 2 * F10 * t_{step}^(2)
C11: C10 + E10 * t_{step} + 1 / 2 * G10 * t_{step}^(2)
E11: E10 + G10 * t_{step}
F11: -drag * D11
G11: g - drag * E11
H11 = If(A11 ≤ time_{elapsed}, (B11, C11))
A12: A11 + t_{step}
D12: D11 + F11 * t_{step}
B12: B11 + D11 * t_{step} + 1 / 2 * F11 * t_{step}^(2)
C12: C11 + E11 * t_{step} + 1 / 2 * G11 * t_{step}^(2)
E12: E11 + G11 * t_{step}
F12: -drag * D12
G12: g - drag * E12
H12 = If(A12 ≤ time_{elapsed}, (B12, C12))
A13: A12 + t_{step}
D13: D12 + F12 * t_{step}
B13: B12 + D12 * t_{step} + 1 / 2 * F12 * t_{step}^(2)
C13: C12 + E12 * t_{step} + 1 / 2 * G12 * t_{step}^(2)
E13: E12 + G12 * t_{step}
F13: -drag * D13
G13: g - drag * E13
H13 = If(A13 ≤ time_{elapsed}, (B13, C13))
A14: A13 + t_{step}
D14: D13 + F13 * t_{step}
B14: B13 + D13 * t_{step} + 1 / 2 * F13 * t_{step}^(2)
C14: C13 + E13 * t_{step} + 1 / 2 * G13 * t_{step}^(2)
E14: E13 + G13 * t_{step}
F14: -drag * D14
G14: g - drag * E14
H14 = If(A14 ≤ time_{elapsed}, (B14, C14))
A15: A14 + t_{step}
D15: D14 + F14 * t_{step}
B15: B14 + D14 * t_{step} + 1 / 2 * F14 * t_{step}^(2)
C15: C14 + E14 * t_{step} + 1 / 2 * G14 * t_{step}^(2)
E15: E14 + G14 * t_{step}
F15: -drag * D15
G15: g - drag * E15
H15 = If(A15 ≤ time_{elapsed}, (B15, C15))
A16: A15 + t_{step}
D16: D15 + F15 * t_{step}
B16: B15 + D15 * t_{step} + 1 / 2 * F15 * t_{step}^(2)
C16: C15 + E15 * t_{step} + 1 / 2 * G15 * t_{step}^(2)
E16: E15 + G15 * t_{step}
F16: -drag * D16
G16: g - drag * E16
H16 = If(A16 ≤ time_{elapsed}, (B16, C16))
A17: A16 + t_{step}
D17: D16 + F16 * t_{step}
B17: B16 + D16 * t_{step} + 1 / 2 * F16 * t_{step}^(2)
C17: C16 + E16 * t_{step} + 1 / 2 * G16 * t_{step}^(2)
E17: E16 + G16 * t_{step}
F17: -drag * D17
G17: g - drag * E17
H17 = If(A17 ≤ time_{elapsed}, (B17, C17))
A18: A17 + t_{step}
D18: D17 + F17 * t_{step}
B18: B17 + D17 * t_{step} + 1 / 2 * F17 * t_{step}^(2)
C18: C17 + E17 * t_{step} + 1 / 2 * G17 * t_{step}^(2)
E18: E17 + G17 * t_{step}
F18: -drag * D18
G18: g - drag * E18
H18 = If(A18 ≤ time_{elapsed}, (B18, C18))
A19: A18 + t_{step}
D19: D18 + F18 * t_{step}
B19: B18 + D18 * t_{step} + 1 / 2 * F18 * t_{step}^(2)
C19: C18 + E18 * t_{step} + 1 / 2 * G18 * t_{step}^(2)
E19: E18 + G18 * t_{step}
F19: -drag * D19
G19: g - drag * E19
H19 = If(A19 ≤ time_{elapsed}, (B19, C19))
A20: A19 + t_{step}
D20: D19 + F19 * t_{step}
B20: B19 + D19 * t_{step} + 1 / 2 * F19 * t_{step}^(2)
C20: C19 + E19 * t_{step} + 1 / 2 * G19 * t_{step}^(2)
E20: E19 + G19 * t_{step}
F20: -drag * D20
G20: g - drag * E20
H20 = If(A20 ≤ time_{elapsed}, (B20, C20))
A21: A20 + t_{step}
D21: D20 + F20 * t_{step}
B21: B20 + D20 * t_{step} + 1 / 2 * F20 * t_{step}^(2)
C21: C20 + E20 * t_{step} + 1 / 2 * G20 * t_{step}^(2)
E21: E20 + G20 * t_{step}
F21: -drag * D21
G21: g - drag * E21
H21 = If(A21 ≤ time_{elapsed}, (B21, C21))
A22: A21 + t_{step}
D22: D21 + F21 * t_{step}
B22: B21 + D21 * t_{step} + 1 / 2 * F21 * t_{step}^(2)
C22: C21 + E21 * t_{step} + 1 / 2 * G21 * t_{step}^(2)
E22: E21 + G21 * t_{step}
F22: -drag * D22
G22: g - drag * E22
H22 = If(A22 ≤ time_{elapsed}, (B22, C22))
A23: A22 + t_{step}
D23: D22 + F22 * t_{step}
B23: B22 + D22 * t_{step} + 1 / 2 * F22 * t_{step}^(2)
C23: C22 + E22 * t_{step} + 1 / 2 * G22 * t_{step}^(2)
E23: E22 + G22 * t_{step}
F23: -drag * D23
G23: g - drag * E23
H23 = If(A23 ≤ time_{elapsed}, (B23, C23))
A24: A23 + t_{step}
D24: D23 + F23 * t_{step}
B24: B23 + D23 * t_{step} + 1 / 2 * F23 * t_{step}^(2)
C24: C23 + E23 * t_{step} + 1 / 2 * G23 * t_{step}^(2)
E24: E23 + G23 * t_{step}
F24: -drag * D24
G24: g - drag * E24
H24 = If(A24 ≤ time_{elapsed}, (B24, C24))
A25: A24 + t_{step}
D25: D24 + F24 * t_{step}
B25: B24 + D24 * t_{step} + 1 / 2 * F24 * t_{step}^(2)
C25: C24 + E24 * t_{step} + 1 / 2 * G24 * t_{step}^(2)
E25: E24 + G24 * t_{step}
F25: -drag * D25
G25: g - drag * E25
H25 = If(A25 ≤ time_{elapsed}, (B25, C25))
A26: A25 + t_{step}
D26: D25 + F25 * t_{step}
B26: B25 + D25 * t_{step} + 1 / 2 * F25 * t_{step}^(2)
C26: C25 + E25 * t_{step} + 1 / 2 * G25 * t_{step}^(2)
E26: E25 + G25 * t_{step}
F26: -drag * D26
G26: g - drag * E26
H26 = If(A26 ≤ time_{elapsed}, (B26, C26))
A27: A26 + t_{step}
D27: D26 + F26 * t_{step}
B27: B26 + D26 * t_{step} + 1 / 2 * F26 * t_{step}^(2)
C27: C26 + E26 * t_{step} + 1 / 2 * G26 * t_{step}^(2)
E27: E26 + G26 * t_{step}
F27: -drag * D27
G27: g - drag * E27
H27 = If(A27 ≤ time_{elapsed}, (B27, C27))
A28: A27 + t_{step}
D28: D27 + F27 * t_{step}
B28: B27 + D27 * t_{step} + 1 / 2 * F27 * t_{step}^(2)
C28: C27 + E27 * t_{step} + 1 / 2 * G27 * t_{step}^(2)
E28: E27 + G27 * t_{step}
F28: -drag * D28
G28: g - drag * E28
H28 = If(A28 ≤ time_{elapsed}, (B28, C28))
A29: A28 + t_{step}
D29: D28 + F28 * t_{step}
B29: B28 + D28 * t_{step} + 1 / 2 * F28 * t_{step}^(2)
C29: C28 + E28 * t_{step} + 1 / 2 * G28 * t_{step}^(2)
E29: E28 + G28 * t_{step}
F29: -drag * D29
G29: g - drag * E29
H29 = If(A29 ≤ time_{elapsed}, (B29, C29))
A30: A29 + t_{step}
D30: D29 + F29 * t_{step}
B30: B29 + D29 * t_{step} + 1 / 2 * F29 * t_{step}^(2)
C30: C29 + E29 * t_{step} + 1 / 2 * G29 * t_{step}^(2)
E30: E29 + G29 * t_{step}
F30: -drag * D30
G30: g - drag * E30
H30 = If(A30 ≤ time_{elapsed}, (B30, C30))
A31: A30 + t_{step}
D31: D30 + F30 * t_{step}
B31: B30 + D30 * t_{step} + 1 / 2 * F30 * t_{step}^(2)
C31: C30 + E30 * t_{step} + 1 / 2 * G30 * t_{step}^(2)
E31: E30 + G30 * t_{step}
F31: -drag * D31
G31: g - drag * E31
H31 = If(A31 ≤ time_{elapsed}, (B31, C31))
A32: A31 + t_{step}
D32: D31 + F31 * t_{step}
B32: B31 + D31 * t_{step} + 1 / 2 * F31 * t_{step}^(2)
C32: C31 + E31 * t_{step} + 1 / 2 * G31 * t_{step}^(2)
E32: E31 + G31 * t_{step}
F32: -drag * D32
G32: g - drag * E32
H32 = If(A32 ≤ time_{elapsed}, (B32, C32))
A33: A32 + t_{step}
D33: D32 + F32 * t_{step}
B33: B32 + D32 * t_{step} + 1 / 2 * F32 * t_{step}^(2)
C33: C32 + E32 * t_{step} + 1 / 2 * G32 * t_{step}^(2)
E33: E32 + G32 * t_{step}
F33: -drag * D33
G33: g - drag * E33
H33 = If(A33 ≤ time_{elapsed}, (B33, C33))
A34: A33 + t_{step}
D34: D33 + F33 * t_{step}
B34: B33 + D33 * t_{step} + 1 / 2 * F33 * t_{step}^(2)
C34: C33 + E33 * t_{step} + 1 / 2 * G33 * t_{step}^(2)
E34: E33 + G33 * t_{step}
F34: -drag * D34
G34: g - drag * E34
H34 = If(A34 ≤ time_{elapsed}, (B34, C34))
A35: A34 + t_{step}
D35: D34 + F34 * t_{step}
B35: B34 + D34 * t_{step} + 1 / 2 * F34 * t_{step}^(2)
C35: C34 + E34 * t_{step} + 1 / 2 * G34 * t_{step}^(2)
E35: E34 + G34 * t_{step}
F35: -drag * D35
G35: g - drag * E35
H35 = If(A35 ≤ time_{elapsed}, (B35, C35))
A36: A35 + t_{step}
D36: D35 + F35 * t_{step}
B36: B35 + D35 * t_{step} + 1 / 2 * F35 * t_{step}^(2)
C36: C35 + E35 * t_{step} + 1 / 2 * G35 * t_{step}^(2)
E36: E35 + G35 * t_{step}
F36: -drag * D36
G36: g - drag * E36
H36 = If(A36 ≤ time_{elapsed}, (B36, C36))
A37: A36 + t_{step}
D37: D36 + F36 * t_{step}
B37: B36 + D36 * t_{step} + 1 / 2 * F36 * t_{step}^(2)
C37: C36 + E36 * t_{step} + 1 / 2 * G36 * t_{step}^(2)
E37: E36 + G36 * t_{step}
F37: -drag * D37
G37: g - drag * E37
H37 = If(A37 ≤ time_{elapsed}, (B37, C37))
A38: A37 + t_{step}
D38: D37 + F37 * t_{step}
B38: B37 + D37 * t_{step} + 1 / 2 * F37 * t_{step}^(2)
C38: C37 + E37 * t_{step} + 1 / 2 * G37 * t_{step}^(2)
E38: E37 + G37 * t_{step}
F38: -drag * D38
G38: g - drag * E38
H38 = If(A38 ≤ time_{elapsed}, (B38, C38))
A39: A38 + t_{step}
D39: D38 + F38 * t_{step}
B39: B38 + D38 * t_{step} + 1 / 2 * F38 * t_{step}^(2)
C39: C38 + E38 * t_{step} + 1 / 2 * G38 * t_{step}^(2)
E39: E38 + G38 * t_{step}
F39: -drag * D39
G39: g - drag * E39
H39 = If(A39 ≤ time_{elapsed}, (B39, C39))
A40: A39 + t_{step}
D40: D39 + F39 * t_{step}
B40: B39 + D39 * t_{step} + 1 / 2 * F39 * t_{step}^(2)
C40: C39 + E39 * t_{step} + 1 / 2 * G39 * t_{step}^(2)
E40: E39 + G39 * t_{step}
F40: -drag * D40
G40: g - drag * E40
H40 = If(A40 ≤ time_{elapsed}, (B40, C40))
A41: A40 + t_{step}
D41: D40 + F40 * t_{step}
B41: B40 + D40 * t_{step} + 1 / 2 * F40 * t_{step}^(2)
C41: C40 + E40 * t_{step} + 1 / 2 * G40 * t_{step}^(2)
E41: E40 + G40 * t_{step}
F41: -drag * D41
G41: g - drag * E41
H41 = If(A41 ≤ time_{elapsed}, (B41, C41))
A42: A41 + t_{step}
D42: D41 + F41 * t_{step}
B42: B41 + D41 * t_{step} + 1 / 2 * F41 * t_{step}^(2)
C42: C41 + E41 * t_{step} + 1 / 2 * G41 * t_{step}^(2)
E42: E41 + G41 * t_{step}
F42: -drag * D42
G42: g - drag * E42
H42 = If(A42 ≤ time_{elapsed}, (B42, C42))
A43: A42 + t_{step}
D43: D42 + F42 * t_{step}
B43: B42 + D42 * t_{step} + 1 / 2 * F42 * t_{step}^(2)
C43: C42 + E42 * t_{step} + 1 / 2 * G42 * t_{step}^(2)
E43: E42 + G42 * t_{step}
F43: -drag * D43
G43: g - drag * E43
H43 = If(A43 ≤ time_{elapsed}, (B43, C43))
A44: A43 + t_{step}
D44: D43 + F43 * t_{step}
B44: B43 + D43 * t_{step} + 1 / 2 * F43 * t_{step}^(2)
C44: C43 + E43 * t_{step} + 1 / 2 * G43 * t_{step}^(2)
E44: E43 + G43 * t_{step}
F44: -drag * D44
G44: g - drag * E44
H44 = If(A44 ≤ time_{elapsed}, (B44, C44))
A45: A44 + t_{step}
D45: D44 + F44 * t_{step}
B45: B44 + D44 * t_{step} + 1 / 2 * F44 * t_{step}^(2)
C45: C44 + E44 * t_{step} + 1 / 2 * G44 * t_{step}^(2)
E45: E44 + G44 * t_{step}
F45: -drag * D45
G45: g - drag * E45
H45 = If(A45 ≤ time_{elapsed}, (B45, C45))
A46: A45 + t_{step}
D46: D45 + F45 * t_{step}
B46: B45 + D45 * t_{step} + 1 / 2 * F45 * t_{step}^(2)
C46: C45 + E45 * t_{step} + 1 / 2 * G45 * t_{step}^(2)
E46: E45 + G45 * t_{step}
F46: -drag * D46
G46: g - drag * E46
H46 = If(A46 ≤ time_{elapsed}, (B46, C46))
A47: A46 + t_{step}
D47: D46 + F46 * t_{step}
B47: B46 + D46 * t_{step} + 1 / 2 * F46 * t_{step}^(2)
C47: C46 + E46 * t_{step} + 1 / 2 * G46 * t_{step}^(2)
E47: E46 + G46 * t_{step}
F47: -drag * D47
G47: g - drag * E47
H47 = If(A47 ≤ time_{elapsed}, (B47, C47))
A48: A47 + t_{step}
D48: D47 + F47 * t_{step}
B48: B47 + D47 * t_{step} + 1 / 2 * F47 * t_{step}^(2)
C48: C47 + E47 * t_{step} + 1 / 2 * G47 * t_{step}^(2)
E48: E47 + G47 * t_{step}
F48: -drag * D48
G48: g - drag * E48
H48 = If(A48 ≤ time_{elapsed}, (B48, C48))
A49: A48 + t_{step}
D49: D48 + F48 * t_{step}
B49: B48 + D48 * t_{step} + 1 / 2 * F48 * t_{step}^(2)
C49: C48 + E48 * t_{step} + 1 / 2 * G48 * t_{step}^(2)
E49: E48 + G48 * t_{step}
F49: -drag * D49
G49: g - drag * E49
H49 = If(A49 ≤ time_{elapsed}, (B49, C49))
A50: A49 + t_{step}
D50: D49 + F49 * t_{step}
B50: B49 + D49 * t_{step} + 1 / 2 * F49 * t_{step}^(2)
C50: C49 + E49 * t_{step} + 1 / 2 * G49 * t_{step}^(2)
E50: E49 + G49 * t_{step}
F50: -drag * D50
G50: g - drag * E50
H50 = If(A50 ≤ time_{elapsed}, (B50, C50))
A51: A50 + t_{step}
D51: D50 + F50 * t_{step}
B51: B50 + D50 * t_{step} + 1 / 2 * F50 * t_{step}^(2)
C51: C50 + E50 * t_{step} + 1 / 2 * G50 * t_{step}^(2)
E51: E50 + G50 * t_{step}
F51: -drag * D51
G51: g - drag * E51
H51 = If(A51 ≤ time_{elapsed}, (B51, C51))
A52: A51 + t_{step}
D52: D51 + F51 * t_{step}
B52: B51 + D51 * t_{step} + 1 / 2 * F51 * t_{step}^(2)
C52: C51 + E51 * t_{step} + 1 / 2 * G51 * t_{step}^(2)
E52: E51 + G51 * t_{step}
F52: -drag * D52
G52: g - drag * E52
H52 = If(A52 ≤ time_{elapsed}, (B52, C52))
A53: A52 + t_{step}
D53: D52 + F52 * t_{step}
B53: B52 + D52 * t_{step} + 1 / 2 * F52 * t_{step}^(2)
C53: C52 + E52 * t_{step} + 1 / 2 * G52 * t_{step}^(2)
E53: E52 + G52 * t_{step}
F53: -drag * D53
G53: g - drag * E53
H53 = If(A53 ≤ time_{elapsed}, (B53, C53))
A54: A53 + t_{step}
D54: D53 + F53 * t_{step}
B54: B53 + D53 * t_{step} + 1 / 2 * F53 * t_{step}^(2)
C54: C53 + E53 * t_{step} + 1 / 2 * G53 * t_{step}^(2)
E54: E53 + G53 * t_{step}
F54: -drag * D54
G54: g - drag * E54
H54 = If(A54 ≤ time_{elapsed}, (B54, C54))
A55: A54 + t_{step}
D55: D54 + F54 * t_{step}
B55: B54 + D54 * t_{step} + 1 / 2 * F54 * t_{step}^(2)
C55: C54 + E54 * t_{step} + 1 / 2 * G54 * t_{step}^(2)
E55: E54 + G54 * t_{step}
F55: -drag * D55
G55: g - drag * E55
H55 = If(A55 ≤ time_{elapsed}, (B55, C55))
A56: A55 + t_{step}
D56: D55 + F55 * t_{step}
B56: B55 + D55 * t_{step} + 1 / 2 * F55 * t_{step}^(2)
C56: C55 + E55 * t_{step} + 1 / 2 * G55 * t_{step}^(2)
E56: E55 + G55 * t_{step}
F56: -drag * D56
G56: g - drag * E56
H56 = If(A56 ≤ time_{elapsed}, (B56, C56))
A57: A56 + t_{step}
D57: D56 + F56 * t_{step}
B57: B56 + D56 * t_{step} + 1 / 2 * F56 * t_{step}^(2)
C57: C56 + E56 * t_{step} + 1 / 2 * G56 * t_{step}^(2)
E57: E56 + G56 * t_{step}
F57: -drag * D57
G57: g - drag * E57
H57 = If(A57 ≤ time_{elapsed}, (B57, C57))
A58: A57 + t_{step}
D58: D57 + F57 * t_{step}
B58: B57 + D57 * t_{step} + 1 / 2 * F57 * t_{step}^(2)
C58: C57 + E57 * t_{step} + 1 / 2 * G57 * t_{step}^(2)
E58: E57 + G57 * t_{step}
F58: -drag * D58
G58: g - drag * E58
H58 = If(A58 ≤ time_{elapsed}, (B58, C58))
A59: A58 + t_{step}
D59: D58 + F58 * t_{step}
B59: B58 + D58 * t_{step} + 1 / 2 * F58 * t_{step}^(2)
C59: C58 + E58 * t_{step} + 1 / 2 * G58 * t_{step}^(2)
E59: E58 + G58 * t_{step}
F59: -drag * D59
G59: g - drag * E59
H59 = If(A59 ≤ time_{elapsed}, (B59, C59))
A60: A59 + t_{step}
D60: D59 + F59 * t_{step}
B60: B59 + D59 * t_{step} + 1 / 2 * F59 * t_{step}^(2)
C60: C59 + E59 * t_{step} + 1 / 2 * G59 * t_{step}^(2)
E60: E59 + G59 * t_{step}
F60: -drag * D60
G60: g - drag * E60
H60 = If(A60 ≤ time_{elapsed}, (B60, C60))
A61: A60 + t_{step}
D61: D60 + F60 * t_{step}
B61: B60 + D60 * t_{step} + 1 / 2 * F60 * t_{step}^(2)
C61: C60 + E60 * t_{step} + 1 / 2 * G60 * t_{step}^(2)
E61: E60 + G60 * t_{step}
F61: -drag * D61
G61: g - drag * E61
H61 = If(A61 ≤ time_{elapsed}, (B61, C61))
A62: A61 + t_{step}
D62: D61 + F61 * t_{step}
B62: B61 + D61 * t_{step} + 1 / 2 * F61 * t_{step}^(2)
C62: C61 + E61 * t_{step} + 1 / 2 * G61 * t_{step}^(2)
E62: E61 + G61 * t_{step}
F62: -drag * D62
G62: g - drag * E62
H62 = If(A62 ≤ time_{elapsed}, (B62, C62))
A63: A62 + t_{step}
D63: D62 + F62 * t_{step}
B63: B62 + D62 * t_{step} + 1 / 2 * F62 * t_{step}^(2)
C63: C62 + E62 * t_{step} + 1 / 2 * G62 * t_{step}^(2)
E63: E62 + G62 * t_{step}
F63: -drag * D63
G63: g - drag * E63
H63 = If(A63 ≤ time_{elapsed}, (B63, C63))
A64: A63 + t_{step}
D64: D63 + F63 * t_{step}
B64: B63 + D63 * t_{step} + 1 / 2 * F63 * t_{step}^(2)
C64: C63 + E63 * t_{step} + 1 / 2 * G63 * t_{step}^(2)
E64: E63 + G63 * t_{step}
F64: -drag * D64
G64: g - drag * E64
H64 = If(A64 ≤ time_{elapsed}, (B64, C64))
A65: A64 + t_{step}
D65: D64 + F64 * t_{step}
B65: B64 + D64 * t_{step} + 1 / 2 * F64 * t_{step}^(2)
C65: C64 + E64 * t_{step} + 1 / 2 * G64 * t_{step}^(2)
E65: E64 + G64 * t_{step}
F65: -drag * D65
G65: g - drag * E65
H65 = If(A65 ≤ time_{elapsed}, (B65, C65))
A66: A65 + t_{step}
D66: D65 + F65 * t_{step}
B66: B65 + D65 * t_{step} + 1 / 2 * F65 * t_{step}^(2)
C66: C65 + E65 * t_{step} + 1 / 2 * G65 * t_{step}^(2)
E66: E65 + G65 * t_{step}
F66: -drag * D66
G66: g - drag * E66
H66 = If(A66 ≤ time_{elapsed}, (B66, C66))
A67: A66 + t_{step}
D67: D66 + F66 * t_{step}
B67: B66 + D66 * t_{step} + 1 / 2 * F66 * t_{step}^(2)
C67: C66 + E66 * t_{step} + 1 / 2 * G66 * t_{step}^(2)
E67: E66 + G66 * t_{step}
F67: -drag * D67
G67: g - drag * E67
H67 = If(A67 ≤ time_{elapsed}, (B67, C67))
A68: A67 + t_{step}
D68: D67 + F67 * t_{step}
B68: B67 + D67 * t_{step} + 1 / 2 * F67 * t_{step}^(2)
C68: C67 + E67 * t_{step} + 1 / 2 * G67 * t_{step}^(2)
E68: E67 + G67 * t_{step}
F68: -drag * D68
G68: g - drag * E68
H68 = If(A68 ≤ time_{elapsed}, (B68, C68))
A69: A68 + t_{step}
D69: D68 + F68 * t_{step}
B69: B68 + D68 * t_{step} + 1 / 2 * F68 * t_{step}^(2)
C69: C68 + E68 * t_{step} + 1 / 2 * G68 * t_{step}^(2)
E69: E68 + G68 * t_{step}
F69: -drag * D69
G69: g - drag * E69
H69 = If(A69 ≤ time_{elapsed}, (B69, C69))
A70: A69 + t_{step}
D70: D69 + F69 * t_{step}
B70: B69 + D69 * t_{step} + 1 / 2 * F69 * t_{step}^(2)
C70: C69 + E69 * t_{step} + 1 / 2 * G69 * t_{step}^(2)
E70: E69 + G69 * t_{step}
F70: -drag * D70
G70: g - drag * E70
H70 = If(A70 ≤ time_{elapsed}, (B70, C70))
A71: A70 + t_{step}
D71: D70 + F70 * t_{step}
B71: B70 + D70 * t_{step} + 1 / 2 * F70 * t_{step}^(2)
C71: C70 + E70 * t_{step} + 1 / 2 * G70 * t_{step}^(2)
E71: E70 + G70 * t_{step}
F71: -drag * D71
G71: g - drag * E71
H71 = If(A71 ≤ time_{elapsed}, (B71, C71))
A72: A71 + t_{step}
D72: D71 + F71 * t_{step}
B72: B71 + D71 * t_{step} + 1 / 2 * F71 * t_{step}^(2)
C72: C71 + E71 * t_{step} + 1 / 2 * G71 * t_{step}^(2)
E72: E71 + G71 * t_{step}
F72: -drag * D72
G72: g - drag * E72
H72 = If(A72 ≤ time_{elapsed}, (B72, C72))
A73: A72 + t_{step}
D73: D72 + F72 * t_{step}
B73: B72 + D72 * t_{step} + 1 / 2 * F72 * t_{step}^(2)
C73: C72 + E72 * t_{step} + 1 / 2 * G72 * t_{step}^(2)
E73: E72 + G72 * t_{step}
F73: -drag * D73
G73: g - drag * E73
H73 = If(A73 ≤ time_{elapsed}, (B73, C73))
A74: A73 + t_{step}
D74: D73 + F73 * t_{step}
B74: B73 + D73 * t_{step} + 1 / 2 * F73 * t_{step}^(2)
C74: C73 + E73 * t_{step} + 1 / 2 * G73 * t_{step}^(2)
E74: E73 + G73 * t_{step}
F74: -drag * D74
G74: g - drag * E74
H74 = If(A74 ≤ time_{elapsed}, (B74, C74))
A75: A74 + t_{step}
D75: D74 + F74 * t_{step}
B75: B74 + D74 * t_{step} + 1 / 2 * F74 * t_{step}^(2)
C75: C74 + E74 * t_{step} + 1 / 2 * G74 * t_{step}^(2)
E75: E74 + G74 * t_{step}
F75: -drag * D75
G75: g - drag * E75
H75 = If(A75 ≤ time_{elapsed}, (B75, C75))
A76: A75 + t_{step}
D76: D75 + F75 * t_{step}
B76: B75 + D75 * t_{step} + 1 / 2 * F75 * t_{step}^(2)
C76: C75 + E75 * t_{step} + 1 / 2 * G75 * t_{step}^(2)
E76: E75 + G75 * t_{step}
F76: -drag * D76
G76: g - drag * E76
H76 = If(A76 ≤ time_{elapsed}, (B76, C76))
A77: A76 + t_{step}
D77: D76 + F76 * t_{step}
B77: B76 + D76 * t_{step} + 1 / 2 * F76 * t_{step}^(2)
C77: C76 + E76 * t_{step} + 1 / 2 * G76 * t_{step}^(2)
E77: E76 + G76 * t_{step}
F77: -drag * D77
G77: g - drag * E77
H77 = If(A77 ≤ time_{elapsed}, (B77, C77))
A78: A77 + t_{step}
D78: D77 + F77 * t_{step}
B78: B77 + D77 * t_{step} + 1 / 2 * F77 * t_{step}^(2)
C78: C77 + E77 * t_{step} + 1 / 2 * G77 * t_{step}^(2)
E78: E77 + G77 * t_{step}
F78: -drag * D78
G78: g - drag * E78
H78 = If(A78 ≤ time_{elapsed}, (B78, C78))
A79: A78 + t_{step}
D79: D78 + F78 * t_{step}
B79: B78 + D78 * t_{step} + 1 / 2 * F78 * t_{step}^(2)
C79: C78 + E78 * t_{step} + 1 / 2 * G78 * t_{step}^(2)
E79: E78 + G78 * t_{step}
F79: -drag * D79
G79: g - drag * E79
H79 = If(A79 ≤ time_{elapsed}, (B79, C79))
A80: A79 + t_{step}
D80: D79 + F79 * t_{step}
B80: B79 + D79 * t_{step} + 1 / 2 * F79 * t_{step}^(2)
C80: C79 + E79 * t_{step} + 1 / 2 * G79 * t_{step}^(2)
E80: E79 + G79 * t_{step}
F80: -drag * D80
G80: g - drag * E80
H80 = If(A80 ≤ time_{elapsed}, (B80, C80))
A81: A80 + t_{step}
D81: D80 + F80 * t_{step}
B81: B80 + D80 * t_{step} + 1 / 2 * F80 * t_{step}^(2)
C81: C80 + E80 * t_{step} + 1 / 2 * G80 * t_{step}^(2)
E81: E80 + G80 * t_{step}
F81: -drag * D81
G81: g - drag * E81
H81 = If(A81 ≤ time_{elapsed}, (B81, C81))
A82: A81 + t_{step}
D82: D81 + F81 * t_{step}
B82: B81 + D81 * t_{step} + 1 / 2 * F81 * t_{step}^(2)
C82: C81 + E81 * t_{step} + 1 / 2 * G81 * t_{step}^(2)
E82: E81 + G81 * t_{step}
F82: -drag * D82
G82: g - drag * E82
H82 = If(A82 ≤ time_{elapsed}, (B82, C82))
A83: A82 + t_{step}
D83: D82 + F82 * t_{step}
B83: B82 + D82 * t_{step} + 1 / 2 * F82 * t_{step}^(2)
C83: C82 + E82 * t_{step} + 1 / 2 * G82 * t_{step}^(2)
E83: E82 + G82 * t_{step}
F83: -drag * D83
G83: g - drag * E83
H83 = If(A83 ≤ time_{elapsed}, (B83, C83))
A84: A83 + t_{step}
D84: D83 + F83 * t_{step}
B84: B83 + D83 * t_{step} + 1 / 2 * F83 * t_{step}^(2)
C84: C83 + E83 * t_{step} + 1 / 2 * G83 * t_{step}^(2)
E84: E83 + G83 * t_{step}
F84: -drag * D84
G84: g - drag * E84
H84 = If(A84 ≤ time_{elapsed}, (B84, C84))
A85: A84 + t_{step}
D85: D84 + F84 * t_{step}
B85: B84 + D84 * t_{step} + 1 / 2 * F84 * t_{step}^(2)
C85: C84 + E84 * t_{step} + 1 / 2 * G84 * t_{step}^(2)
E85: E84 + G84 * t_{step}
F85: -drag * D85
G85: g - drag * E85
H85 = If(A85 ≤ time_{elapsed}, (B85, C85))
A86: A85 + t_{step}
D86: D85 + F85 * t_{step}
B86: B85 + D85 * t_{step} + 1 / 2 * F85 * t_{step}^(2)
C86: C85 + E85 * t_{step} + 1 / 2 * G85 * t_{step}^(2)
E86: E85 + G85 * t_{step}
F86: -drag * D86
G86: g - drag * E86
H86 = If(A86 ≤ time_{elapsed}, (B86, C86))
A87: A86 + t_{step}
D87: D86 + F86 * t_{step}
B87: B86 + D86 * t_{step} + 1 / 2 * F86 * t_{step}^(2)
C87: C86 + E86 * t_{step} + 1 / 2 * G86 * t_{step}^(2)
E87: E86 + G86 * t_{step}
F87: -drag * D87
G87: g - drag * E87
H87 = If(A87 ≤ time_{elapsed}, (B87, C87))
A88: A87 + t_{step}
D88: D87 + F87 * t_{step}
B88: B87 + D87 * t_{step} + 1 / 2 * F87 * t_{step}^(2)
C88: C87 + E87 * t_{step} + 1 / 2 * G87 * t_{step}^(2)
E88: E87 + G87 * t_{step}
F88: -drag * D88
G88: g - drag * E88
H88 = If(A88 ≤ time_{elapsed}, (B88, C88))
A89: A88 + t_{step}
D89: D88 + F88 * t_{step}
B89: B88 + D88 * t_{step} + 1 / 2 * F88 * t_{step}^(2)
C89: C88 + E88 * t_{step} + 1 / 2 * G88 * t_{step}^(2)
E89: E88 + G88 * t_{step}
F89: -drag * D89
G89: g - drag * E89
H89 = If(A89 ≤ time_{elapsed}, (B89, C89))
A90: A89 + t_{step}
D90: D89 + F89 * t_{step}
B90: B89 + D89 * t_{step} + 1 / 2 * F89 * t_{step}^(2)
C90: C89 + E89 * t_{step} + 1 / 2 * G89 * t_{step}^(2)
E90: E89 + G89 * t_{step}
F90: -drag * D90
G90: g - drag * E90
H90 = If(A90 ≤ time_{elapsed}, (B90, C90))
A91: A90 + t_{step}
D91: D90 + F90 * t_{step}
B91: B90 + D90 * t_{step} + 1 / 2 * F90 * t_{step}^(2)
C91: C90 + E90 * t_{step} + 1 / 2 * G90 * t_{step}^(2)
E91: E90 + G90 * t_{step}
F91: -drag * D91
G91: g - drag * E91
H91 = If(A91 ≤ time_{elapsed}, (B91, C91))
A92: A91 + t_{step}
D92: D91 + F91 * t_{step}
B92: B91 + D91 * t_{step} + 1 / 2 * F91 * t_{step}^(2)
C92: C91 + E91 * t_{step} + 1 / 2 * G91 * t_{step}^(2)
E92: E91 + G91 * t_{step}
F92: -drag * D92
G92: g - drag * E92
H92 = If(A92 ≤ time_{elapsed}, (B92, C92))
A93: A92 + t_{step}
D93: D92 + F92 * t_{step}
B93: B92 + D92 * t_{step} + 1 / 2 * F92 * t_{step}^(2)
C93: C92 + E92 * t_{step} + 1 / 2 * G92 * t_{step}^(2)
E93: E92 + G92 * t_{step}
F93: -drag * D93
G93: g - drag * E93
H93 = If(A93 ≤ time_{elapsed}, (B93, C93))
A94: A93 + t_{step}
D94: D93 + F93 * t_{step}
B94: B93 + D93 * t_{step} + 1 / 2 * F93 * t_{step}^(2)
C94: C93 + E93 * t_{step} + 1 / 2 * G93 * t_{step}^(2)
E94: E93 + G93 * t_{step}
F94: -drag * D94
G94: g - drag * E94
H94 = If(A94 ≤ time_{elapsed}, (B94, C94))
A95: A94 + t_{step}
D95: D94 + F94 * t_{step}
B95: B94 + D94 * t_{step} + 1 / 2 * F94 * t_{step}^(2)
C95: C94 + E94 * t_{step} + 1 / 2 * G94 * t_{step}^(2)
E95: E94 + G94 * t_{step}
F95: -drag * D95
G95: g - drag * E95
H95 = If(A95 ≤ time_{elapsed}, (B95, C95))
A96: A95 + t_{step}
D96: D95 + F95 * t_{step}
B96: B95 + D95 * t_{step} + 1 / 2 * F95 * t_{step}^(2)
C96: C95 + E95 * t_{step} + 1 / 2 * G95 * t_{step}^(2)
E96: E95 + G95 * t_{step}
F96: -drag * D96
G96: g - drag * E96
H96 = If(A96 ≤ time_{elapsed}, (B96, C96))
A97: A96 + t_{step}
D97: D96 + F96 * t_{step}
B97: B96 + D96 * t_{step} + 1 / 2 * F96 * t_{step}^(2)
C97: C96 + E96 * t_{step} + 1 / 2 * G96 * t_{step}^(2)
E97: E96 + G96 * t_{step}
F97: -drag * D97
G97: g - drag * E97
H97 = If(A97 ≤ time_{elapsed}, (B97, C97))
A98: A97 + t_{step}
D98: D97 + F97 * t_{step}
B98: B97 + D97 * t_{step} + 1 / 2 * F97 * t_{step}^(2)
C98: C97 + E97 * t_{step} + 1 / 2 * G97 * t_{step}^(2)
E98: E97 + G97 * t_{step}
F98: -drag * D98
G98: g - drag * E98
H98 = If(A98 ≤ time_{elapsed}, (B98, C98))
A99: A98 + t_{step}
D99: D98 + F98 * t_{step}
B99: B98 + D98 * t_{step} + 1 / 2 * F98 * t_{step}^(2)
C99: C98 + E98 * t_{step} + 1 / 2 * G98 * t_{step}^(2)
E99: E98 + G98 * t_{step}
F99: -drag * D99
G99: g - drag * E99
H99 = If(A99 ≤ time_{elapsed}, (B99, C99))
A100: A99 + t_{step}
D100: D99 + F99 * t_{step}
B100: B99 + D99 * t_{step} + 1 / 2 * F99 * t_{step}^(2)
C100: C99 + E99 * t_{step} + 1 / 2 * G99 * t_{step}^(2)
E100: E99 + G99 * t_{step}
F100: -drag * D100
G100: g - drag * E100
H100 = If(A100 ≤ time_{elapsed}, (B100, C100))
NoDrag = CurveCartesian(v_0 * cos(θ_0 * π / 180) * t_{step} * n, v_0 * sin(θ_0 * π / 180) * t_{step} * n + 1 / 2 * g * (t_{step} * n)^(2), n, 0, 100)
I2 = 0
J2: y_0
K2: v_0 * cos(θ_0 * π / 180)
L2: v_0 * sin(θ_0 * π / 180)
M2: -sgn(K2) * drag * K2^(2)
N2: g - sgn(L2) * drag * L2^(2)
K3: K2 + M2 * t_{step}
I3: I2 + K2 * t_{step} + 1 / 2 * M2 * t_{step}^(2)
J3: J2 + L2 * t_{step} + 1 / 2 * N2 * t_{step}^(2)
L3: L2 + N2 * t_{step}
O2 = If(A2 ≤ time_{elapsed}, (I2, J2))
O3 = If(A3 ≤ time_{elapsed}, (I3, J3))
M3: -sgn(K3) * drag * K3^(2)
N3: g - sgn(L3) * drag * L3^(2)
K4: K3 + M3 * t_{step}
I4: I3 + K3 * t_{step} + 1 / 2 * M3 * t_{step}^(2)
J4: J3 + L3 * t_{step} + 1 / 2 * N3 * t_{step}^(2)
L4: L3 + N3 * t_{step}
O4 = If(A4 ≤ time_{elapsed}, (I4, J4))
M4: -sgn(K4) * drag * K4^(2)
N4: g - sgn(L4) * drag * L4^(2)
K5: K4 + M4 * t_{step}
I5: I4 + K4 * t_{step} + 1 / 2 * M4 * t_{step}^(2)
J5: J4 + L4 * t_{step} + 1 / 2 * N4 * t_{step}^(2)
L5: L4 + N4 * t_{step}
O5 = If(A5 ≤ time_{elapsed}, (I5, J5))
M5: -sgn(K5) * drag * K5^(2)
N5: g - sgn(L5) * drag * L5^(2)
K6: K5 + M5 * t_{step}
I6: I5 + K5 * t_{step} + 1 / 2 * M5 * t_{step}^(2)
J6: J5 + L5 * t_{step} + 1 / 2 * N5 * t_{step}^(2)
L6: L5 + N5 * t_{step}
O6 = If(A6 ≤ time_{elapsed}, (I6, J6))
M6: -sgn(K6) * drag * K6^(2)
N6: g - sgn(L6) * drag * L6^(2)
K7: K6 + M6 * t_{step}
I7: I6 + K6 * t_{step} + 1 / 2 * M6 * t_{step}^(2)
J7: J6 + L6 * t_{step} + 1 / 2 * N6 * t_{step}^(2)
L7: L6 + N6 * t_{step}
O7 = If(A7 ≤ time_{elapsed}, (I7, J7))
M7: -sgn(K7) * drag * K7^(2)
N7: g - sgn(L7) * drag * L7^(2)
K8: K7 + M7 * t_{step}
I8: I7 + K7 * t_{step} + 1 / 2 * M7 * t_{step}^(2)
J8: J7 + L7 * t_{step} + 1 / 2 * N7 * t_{step}^(2)
L8: L7 + N7 * t_{step}
O8 = If(A8 ≤ time_{elapsed}, (I8, J8))
M8: -sgn(K8) * drag * K8^(2)
N8: g - sgn(L8) * drag * L8^(2)
K9: K8 + M8 * t_{step}
I9: I8 + K8 * t_{step} + 1 / 2 * M8 * t_{step}^(2)
J9: J8 + L8 * t_{step} + 1 / 2 * N8 * t_{step}^(2)
L9: L8 + N8 * t_{step}
O9 = If(A9 ≤ time_{elapsed}, (I9, J9))
M9: -sgn(K9) * drag * K9^(2)
N9: g - sgn(L9) * drag * L9^(2)
K10: K9 + M9 * t_{step}
I10: I9 + K9 * t_{step} + 1 / 2 * M9 * t_{step}^(2)
J10: J9 + L9 * t_{step} + 1 / 2 * N9 * t_{step}^(2)
L10: L9 + N9 * t_{step}
O10 = If(A10 ≤ time_{elapsed}, (I10, J10))
M10: -sgn(K10) * drag * K10^(2)
N10: g - sgn(L10) * drag * L10^(2)
K11: K10 + M10 * t_{step}
I11: I10 + K10 * t_{step} + 1 / 2 * M10 * t_{step}^(2)
J11: J10 + L10 * t_{step} + 1 / 2 * N10 * t_{step}^(2)
L11: L10 + N10 * t_{step}
O11 = If(A11 ≤ time_{elapsed}, (I11, J11))
M11: -sgn(K11) * drag * K11^(2)
N11: g - sgn(L11) * drag * L11^(2)
K12: K11 + M11 * t_{step}
I12: I11 + K11 * t_{step} + 1 / 2 * M11 * t_{step}^(2)
J12: J11 + L11 * t_{step} + 1 / 2 * N11 * t_{step}^(2)
L12: L11 + N11 * t_{step}
O12 = If(A12 ≤ time_{elapsed}, (I12, J12))
M12: -sgn(K12) * drag * K12^(2)
N12: g - sgn(L12) * drag * L12^(2)
K13: K12 + M12 * t_{step}
I13: I12 + K12 * t_{step} + 1 / 2 * M12 * t_{step}^(2)
J13: J12 + L12 * t_{step} + 1 / 2 * N12 * t_{step}^(2)
L13: L12 + N12 * t_{step}
O13 = If(A13 ≤ time_{elapsed}, (I13, J13))
M13: -sgn(K13) * drag * K13^(2)
N13: g - sgn(L13) * drag * L13^(2)
K14: K13 + M13 * t_{step}
I14: I13 + K13 * t_{step} + 1 / 2 * M13 * t_{step}^(2)
J14: J13 + L13 * t_{step} + 1 / 2 * N13 * t_{step}^(2)
L14: L13 + N13 * t_{step}
O14 = If(A14 ≤ time_{elapsed}, (I14, J14))
M14: -sgn(K14) * drag * K14^(2)
N14: g - sgn(L14) * drag * L14^(2)
K15: K14 + M14 * t_{step}
I15: I14 + K14 * t_{step} + 1 / 2 * M14 * t_{step}^(2)
J15: J14 + L14 * t_{step} + 1 / 2 * N14 * t_{step}^(2)
L15: L14 + N14 * t_{step}
O15 = If(A15 ≤ time_{elapsed}, (I15, J15))
M15: -sgn(K15) * drag * K15^(2)
N15: g - sgn(L15) * drag * L15^(2)
K16: K15 + M15 * t_{step}
I16: I15 + K15 * t_{step} + 1 / 2 * M15 * t_{step}^(2)
J16: J15 + L15 * t_{step} + 1 / 2 * N15 * t_{step}^(2)
L16: L15 + N15 * t_{step}
O16 = If(A16 ≤ time_{elapsed}, (I16, J16))
M16: -sgn(K16) * drag * K16^(2)
N16: g - sgn(L16) * drag * L16^(2)
K17: K16 + M16 * t_{step}
I17: I16 + K16 * t_{step} + 1 / 2 * M16 * t_{step}^(2)
J17: J16 + L16 * t_{step} + 1 / 2 * N16 * t_{step}^(2)
L17: L16 + N16 * t_{step}
O17 = If(A17 ≤ time_{elapsed}, (I17, J17))
M17: -sgn(K17) * drag * K17^(2)
N17: g - sgn(L17) * drag * L17^(2)
K18: K17 + M17 * t_{step}
I18: I17 + K17 * t_{step} + 1 / 2 * M17 * t_{step}^(2)
J18: J17 + L17 * t_{step} + 1 / 2 * N17 * t_{step}^(2)
L18: L17 + N17 * t_{step}
O18 = If(A18 ≤ time_{elapsed}, (I18, J18))
M18: -sgn(K18) * drag * K18^(2)
N18: g - sgn(L18) * drag * L18^(2)
K19: K18 + M18 * t_{step}
I19: I18 + K18 * t_{step} + 1 / 2 * M18 * t_{step}^(2)
J19: J18 + L18 * t_{step} + 1 / 2 * N18 * t_{step}^(2)
L19: L18 + N18 * t_{step}
O19 = If(A19 ≤ time_{elapsed}, (I19, J19))
M19: -sgn(K19) * drag * K19^(2)
N19: g - sgn(L19) * drag * L19^(2)
K20: K19 + M19 * t_{step}
I20: I19 + K19 * t_{step} + 1 / 2 * M19 * t_{step}^(2)
J20: J19 + L19 * t_{step} + 1 / 2 * N19 * t_{step}^(2)
L20: L19 + N19 * t_{step}
O20 = If(A20 ≤ time_{elapsed}, (I20, J20))
M20: -sgn(K20) * drag * K20^(2)
N20: g - sgn(L20) * drag * L20^(2)
K21: K20 + M20 * t_{step}
I21: I20 + K20 * t_{step} + 1 / 2 * M20 * t_{step}^(2)
J21: J20 + L20 * t_{step} + 1 / 2 * N20 * t_{step}^(2)
L21: L20 + N20 * t_{step}
O21 = If(A21 ≤ time_{elapsed}, (I21, J21))
M21: -sgn(K21) * drag * K21^(2)
N21: g - sgn(L21) * drag * L21^(2)
K22: K21 + M21 * t_{step}
I22: I21 + K21 * t_{step} + 1 / 2 * M21 * t_{step}^(2)
J22: J21 + L21 * t_{step} + 1 / 2 * N21 * t_{step}^(2)
L22: L21 + N21 * t_{step}
O22 = If(A22 ≤ time_{elapsed}, (I22, J22))
M22: -sgn(K22) * drag * K22^(2)
N22: g - sgn(L22) * drag * L22^(2)
K23: K22 + M22 * t_{step}
I23: I22 + K22 * t_{step} + 1 / 2 * M22 * t_{step}^(2)
J23: J22 + L22 * t_{step} + 1 / 2 * N22 * t_{step}^(2)
L23: L22 + N22 * t_{step}
O23 = If(A23 ≤ time_{elapsed}, (I23, J23))
M23: -sgn(K23) * drag * K23^(2)
N23: g - sgn(L23) * drag * L23^(2)
K24: K23 + M23 * t_{step}
I24: I23 + K23 * t_{step} + 1 / 2 * M23 * t_{step}^(2)
J24: J23 + L23 * t_{step} + 1 / 2 * N23 * t_{step}^(2)
L24: L23 + N23 * t_{step}
O24 = If(A24 ≤ time_{elapsed}, (I24, J24))
M24: -sgn(K24) * drag * K24^(2)
N24: g - sgn(L24) * drag * L24^(2)
K25: K24 + M24 * t_{step}
I25: I24 + K24 * t_{step} + 1 / 2 * M24 * t_{step}^(2)
J25: J24 + L24 * t_{step} + 1 / 2 * N24 * t_{step}^(2)
L25: L24 + N24 * t_{step}
O25 = If(A25 ≤ time_{elapsed}, (I25, J25))
M25: -sgn(K25) * drag * K25^(2)
N25: g - sgn(L25) * drag * L25^(2)
K26: K25 + M25 * t_{step}
I26: I25 + K25 * t_{step} + 1 / 2 * M25 * t_{step}^(2)
J26: J25 + L25 * t_{step} + 1 / 2 * N25 * t_{step}^(2)
L26: L25 + N25 * t_{step}
O26 = If(A26 ≤ time_{elapsed}, (I26, J26))
M26: -sgn(K26) * drag * K26^(2)
N26: g - sgn(L26) * drag * L26^(2)
K27: K26 + M26 * t_{step}
I27: I26 + K26 * t_{step} + 1 / 2 * M26 * t_{step}^(2)
J27: J26 + L26 * t_{step} + 1 / 2 * N26 * t_{step}^(2)
L27: L26 + N26 * t_{step}
O27 = If(A27 ≤ time_{elapsed}, (I27, J27))
M27: -sgn(K27) * drag * K27^(2)
N27: g - sgn(L27) * drag * L27^(2)
K28: K27 + M27 * t_{step}
I28: I27 + K27 * t_{step} + 1 / 2 * M27 * t_{step}^(2)
J28: J27 + L27 * t_{step} + 1 / 2 * N27 * t_{step}^(2)
L28: L27 + N27 * t_{step}
O28 = If(A28 ≤ time_{elapsed}, (I28, J28))
M28: -sgn(K28) * drag * K28^(2)
N28: g - sgn(L28) * drag * L28^(2)
K29: K28 + M28 * t_{step}
I29: I28 + K28 * t_{step} + 1 / 2 * M28 * t_{step}^(2)
J29: J28 + L28 * t_{step} + 1 / 2 * N28 * t_{step}^(2)
L29: L28 + N28 * t_{step}
O29 = If(A29 ≤ time_{elapsed}, (I29, J29))
M29: -sgn(K29) * drag * K29^(2)
N29: g - sgn(L29) * drag * L29^(2)
K30: K29 + M29 * t_{step}
I30: I29 + K29 * t_{step} + 1 / 2 * M29 * t_{step}^(2)
J30: J29 + L29 * t_{step} + 1 / 2 * N29 * t_{step}^(2)
L30: L29 + N29 * t_{step}
O30 = If(A30 ≤ time_{elapsed}, (I30, J30))
M30: -sgn(K30) * drag * K30^(2)
N30: g - sgn(L30) * drag * L30^(2)
K31: K30 + M30 * t_{step}
I31: I30 + K30 * t_{step} + 1 / 2 * M30 * t_{step}^(2)
J31: J30 + L30 * t_{step} + 1 / 2 * N30 * t_{step}^(2)
L31: L30 + N30 * t_{step}
O31 = If(A31 ≤ time_{elapsed}, (I31, J31))
M31: -sgn(K31) * drag * K31^(2)
N31: g - sgn(L31) * drag * L31^(2)
K32: K31 + M31 * t_{step}
I32: I31 + K31 * t_{step} + 1 / 2 * M31 * t_{step}^(2)
J32: J31 + L31 * t_{step} + 1 / 2 * N31 * t_{step}^(2)
L32: L31 + N31 * t_{step}
O32 = If(A32 ≤ time_{elapsed}, (I32, J32))
M32: -sgn(K32) * drag * K32^(2)
N32: g - sgn(L32) * drag * L32^(2)
K33: K32 + M32 * t_{step}
I33: I32 + K32 * t_{step} + 1 / 2 * M32 * t_{step}^(2)
J33: J32 + L32 * t_{step} + 1 / 2 * N32 * t_{step}^(2)
L33: L32 + N32 * t_{step}
O33 = If(A33 ≤ time_{elapsed}, (I33, J33))
M33: -sgn(K33) * drag * K33^(2)
N33: g - sgn(L33) * drag * L33^(2)
K34: K33 + M33 * t_{step}
I34: I33 + K33 * t_{step} + 1 / 2 * M33 * t_{step}^(2)
J34: J33 + L33 * t_{step} + 1 / 2 * N33 * t_{step}^(2)
L34: L33 + N33 * t_{step}
O34 = If(A34 ≤ time_{elapsed}, (I34, J34))
M34: -sgn(K34) * drag * K34^(2)
N34: g - sgn(L34) * drag * L34^(2)
K35: K34 + M34 * t_{step}
I35: I34 + K34 * t_{step} + 1 / 2 * M34 * t_{step}^(2)
J35: J34 + L34 * t_{step} + 1 / 2 * N34 * t_{step}^(2)
L35: L34 + N34 * t_{step}
O35 = If(A35 ≤ time_{elapsed}, (I35, J35))
M35: -sgn(K35) * drag * K35^(2)
N35: g - sgn(L35) * drag * L35^(2)
K36: K35 + M35 * t_{step}
I36: I35 + K35 * t_{step} + 1 / 2 * M35 * t_{step}^(2)
J36: J35 + L35 * t_{step} + 1 / 2 * N35 * t_{step}^(2)
L36: L35 + N35 * t_{step}
O36 = If(A36 ≤ time_{elapsed}, (I36, J36))
M36: -sgn(K36) * drag * K36^(2)
N36: g - sgn(L36) * drag * L36^(2)
K37: K36 + M36 * t_{step}
I37: I36 + K36 * t_{step} + 1 / 2 * M36 * t_{step}^(2)
J37: J36 + L36 * t_{step} + 1 / 2 * N36 * t_{step}^(2)
L37: L36 + N36 * t_{step}
O37 = If(A37 ≤ time_{elapsed}, (I37, J37))
M37: -sgn(K37) * drag * K37^(2)
N37: g - sgn(L37) * drag * L37^(2)
K38: K37 + M37 * t_{step}
I38: I37 + K37 * t_{step} + 1 / 2 * M37 * t_{step}^(2)
J38: J37 + L37 * t_{step} + 1 / 2 * N37 * t_{step}^(2)
L38: L37 + N37 * t_{step}
O38 = If(A38 ≤ time_{elapsed}, (I38, J38))
M38: -sgn(K38) * drag * K38^(2)
N38: g - sgn(L38) * drag * L38^(2)
K39: K38 + M38 * t_{step}
I39: I38 + K38 * t_{step} + 1 / 2 * M38 * t_{step}^(2)
J39: J38 + L38 * t_{step} + 1 / 2 * N38 * t_{step}^(2)
L39: L38 + N38 * t_{step}
O39 = If(A39 ≤ time_{elapsed}, (I39, J39))
M39: -sgn(K39) * drag * K39^(2)
N39: g - sgn(L39) * drag * L39^(2)
K40: K39 + M39 * t_{step}
I40: I39 + K39 * t_{step} + 1 / 2 * M39 * t_{step}^(2)
J40: J39 + L39 * t_{step} + 1 / 2 * N39 * t_{step}^(2)
L40: L39 + N39 * t_{step}
O40 = If(A40 ≤ time_{elapsed}, (I40, J40))
M40: -sgn(K40) * drag * K40^(2)
N40: g - sgn(L40) * drag * L40^(2)
K41: K40 + M40 * t_{step}
I41: I40 + K40 * t_{step} + 1 / 2 * M40 * t_{step}^(2)
J41: J40 + L40 * t_{step} + 1 / 2 * N40 * t_{step}^(2)
L41: L40 + N40 * t_{step}
O41 = If(A41 ≤ time_{elapsed}, (I41, J41))
M41: -sgn(K41) * drag * K41^(2)
N41: g - sgn(L41) * drag * L41^(2)
K42: K41 + M41 * t_{step}
I42: I41 + K41 * t_{step} + 1 / 2 * M41 * t_{step}^(2)
J42: J41 + L41 * t_{step} + 1 / 2 * N41 * t_{step}^(2)
L42: L41 + N41 * t_{step}
O42 = If(A42 ≤ time_{elapsed}, (I42, J42))
M42: -sgn(K42) * drag * K42^(2)
N42: g - sgn(L42) * drag * L42^(2)
K43: K42 + M42 * t_{step}
I43: I42 + K42 * t_{step} + 1 / 2 * M42 * t_{step}^(2)
J43: J42 + L42 * t_{step} + 1 / 2 * N42 * t_{step}^(2)
L43: L42 + N42 * t_{step}
O43 = If(A43 ≤ time_{elapsed}, (I43, J43))
M43: -sgn(K43) * drag * K43^(2)
N43: g - sgn(L43) * drag * L43^(2)
K44: K43 + M43 * t_{step}
I44: I43 + K43 * t_{step} + 1 / 2 * M43 * t_{step}^(2)
J44: J43 + L43 * t_{step} + 1 / 2 * N43 * t_{step}^(2)
L44: L43 + N43 * t_{step}
O44 = If(A44 ≤ time_{elapsed}, (I44, J44))
M44: -sgn(K44) * drag * K44^(2)
N44: g - sgn(L44) * drag * L44^(2)
K45: K44 + M44 * t_{step}
I45: I44 + K44 * t_{step} + 1 / 2 * M44 * t_{step}^(2)
J45: J44 + L44 * t_{step} + 1 / 2 * N44 * t_{step}^(2)
L45: L44 + N44 * t_{step}
O45 = If(A45 ≤ time_{elapsed}, (I45, J45))
M45: -sgn(K45) * drag * K45^(2)
N45: g - sgn(L45) * drag * L45^(2)
K46: K45 + M45 * t_{step}
I46: I45 + K45 * t_{step} + 1 / 2 * M45 * t_{step}^(2)
J46: J45 + L45 * t_{step} + 1 / 2 * N45 * t_{step}^(2)
L46: L45 + N45 * t_{step}
O46 = If(A46 ≤ time_{elapsed}, (I46, J46))
M46: -sgn(K46) * drag * K46^(2)
N46: g - sgn(L46) * drag * L46^(2)
K47: K46 + M46 * t_{step}
I47: I46 + K46 * t_{step} + 1 / 2 * M46 * t_{step}^(2)
J47: J46 + L46 * t_{step} + 1 / 2 * N46 * t_{step}^(2)
L47: L46 + N46 * t_{step}
O47 = If(A47 ≤ time_{elapsed}, (I47, J47))
M47: -sgn(K47) * drag * K47^(2)
N47: g - sgn(L47) * drag * L47^(2)
K48: K47 + M47 * t_{step}
I48: I47 + K47 * t_{step} + 1 / 2 * M47 * t_{step}^(2)
J48: J47 + L47 * t_{step} + 1 / 2 * N47 * t_{step}^(2)
L48: L47 + N47 * t_{step}
O48 = If(A48 ≤ time_{elapsed}, (I48, J48))
M48: -sgn(K48) * drag * K48^(2)
N48: g - sgn(L48) * drag * L48^(2)
K49: K48 + M48 * t_{step}
I49: I48 + K48 * t_{step} + 1 / 2 * M48 * t_{step}^(2)
J49: J48 + L48 * t_{step} + 1 / 2 * N48 * t_{step}^(2)
L49: L48 + N48 * t_{step}
O49 = If(A49 ≤ time_{elapsed}, (I49, J49))
M49: -sgn(K49) * drag * K49^(2)
N49: g - sgn(L49) * drag * L49^(2)
K50: K49 + M49 * t_{step}
I50: I49 + K49 * t_{step} + 1 / 2 * M49 * t_{step}^(2)
J50: J49 + L49 * t_{step} + 1 / 2 * N49 * t_{step}^(2)
L50: L49 + N49 * t_{step}
O50 = If(A50 ≤ time_{elapsed}, (I50, J50))
M50: -sgn(K50) * drag * K50^(2)
N50: g - sgn(L50) * drag * L50^(2)
K51: K50 + M50 * t_{step}
I51: I50 + K50 * t_{step} + 1 / 2 * M50 * t_{step}^(2)
J51: J50 + L50 * t_{step} + 1 / 2 * N50 * t_{step}^(2)
L51: L50 + N50 * t_{step}
O51 = If(A51 ≤ time_{elapsed}, (I51, J51))
M51: -sgn(K51) * drag * K51^(2)
N51: g - sgn(L51) * drag * L51^(2)
K52: K51 + M51 * t_{step}
I52: I51 + K51 * t_{step} + 1 / 2 * M51 * t_{step}^(2)
J52: J51 + L51 * t_{step} + 1 / 2 * N51 * t_{step}^(2)
L52: L51 + N51 * t_{step}
O52 = If(A52 ≤ time_{elapsed}, (I52, J52))
M52: -sgn(K52) * drag * K52^(2)
N52: g - sgn(L52) * drag * L52^(2)
K53: K52 + M52 * t_{step}
I53: I52 + K52 * t_{step} + 1 / 2 * M52 * t_{step}^(2)
J53: J52 + L52 * t_{step} + 1 / 2 * N52 * t_{step}^(2)
L53: L52 + N52 * t_{step}
O53 = If(A53 ≤ time_{elapsed}, (I53, J53))
M53: -sgn(K53) * drag * K53^(2)
N53: g - sgn(L53) * drag * L53^(2)
K54: K53 + M53 * t_{step}
I54: I53 + K53 * t_{step} + 1 / 2 * M53 * t_{step}^(2)
J54: J53 + L53 * t_{step} + 1 / 2 * N53 * t_{step}^(2)
L54: L53 + N53 * t_{step}
O54 = If(A54 ≤ time_{elapsed}, (I54, J54))
M54: -sgn(K54) * drag * K54^(2)
N54: g - sgn(L54) * drag * L54^(2)
K55: K54 + M54 * t_{step}
I55: I54 + K54 * t_{step} + 1 / 2 * M54 * t_{step}^(2)
J55: J54 + L54 * t_{step} + 1 / 2 * N54 * t_{step}^(2)
L55: L54 + N54 * t_{step}
O55 = If(A55 ≤ time_{elapsed}, (I55, J55))
M55: -sgn(K55) * drag * K55^(2)
N55: g - sgn(L55) * drag * L55^(2)
K56: K55 + M55 * t_{step}
I56: I55 + K55 * t_{step} + 1 / 2 * M55 * t_{step}^(2)
J56: J55 + L55 * t_{step} + 1 / 2 * N55 * t_{step}^(2)
L56: L55 + N55 * t_{step}
O56 = If(A56 ≤ time_{elapsed}, (I56, J56))
M56: -sgn(K56) * drag * K56^(2)
N56: g - sgn(L56) * drag * L56^(2)
K57: K56 + M56 * t_{step}
I57: I56 + K56 * t_{step} + 1 / 2 * M56 * t_{step}^(2)
J57: J56 + L56 * t_{step} + 1 / 2 * N56 * t_{step}^(2)
L57: L56 + N56 * t_{step}
O57 = If(A57 ≤ time_{elapsed}, (I57, J57))
M57: -sgn(K57) * drag * K57^(2)
N57: g - sgn(L57) * drag * L57^(2)
K58: K57 + M57 * t_{step}
I58: I57 + K57 * t_{step} + 1 / 2 * M57 * t_{step}^(2)
J58: J57 + L57 * t_{step} + 1 / 2 * N57 * t_{step}^(2)
L58: L57 + N57 * t_{step}
O58 = If(A58 ≤ time_{elapsed}, (I58, J58))
M58: -sgn(K58) * drag * K58^(2)
N58: g - sgn(L58) * drag * L58^(2)
K59: K58 + M58 * t_{step}
I59: I58 + K58 * t_{step} + 1 / 2 * M58 * t_{step}^(2)
J59: J58 + L58 * t_{step} + 1 / 2 * N58 * t_{step}^(2)
L59: L58 + N58 * t_{step}
O59 = If(A59 ≤ time_{elapsed}, (I59, J59))
M59: -sgn(K59) * drag * K59^(2)
N59: g - sgn(L59) * drag * L59^(2)
K60: K59 + M59 * t_{step}
I60: I59 + K59 * t_{step} + 1 / 2 * M59 * t_{step}^(2)
J60: J59 + L59 * t_{step} + 1 / 2 * N59 * t_{step}^(2)
L60: L59 + N59 * t_{step}
O60 = If(A60 ≤ time_{elapsed}, (I60, J60))
M60: -sgn(K60) * drag * K60^(2)
N60: g - sgn(L60) * drag * L60^(2)
K61: K60 + M60 * t_{step}
I61: I60 + K60 * t_{step} + 1 / 2 * M60 * t_{step}^(2)
J61: J60 + L60 * t_{step} + 1 / 2 * N60 * t_{step}^(2)
L61: L60 + N60 * t_{step}
O61 = If(A61 ≤ time_{elapsed}, (I61, J61))
M61: -sgn(K61) * drag * K61^(2)
N61: g - sgn(L61) * drag * L61^(2)
K62: K61 + M61 * t_{step}
I62: I61 + K61 * t_{step} + 1 / 2 * M61 * t_{step}^(2)
J62: J61 + L61 * t_{step} + 1 / 2 * N61 * t_{step}^(2)
L62: L61 + N61 * t_{step}
O62 = If(A62 ≤ time_{elapsed}, (I62, J62))
M62: -sgn(K62) * drag * K62^(2)
N62: g - sgn(L62) * drag * L62^(2)
K63: K62 + M62 * t_{step}
I63: I62 + K62 * t_{step} + 1 / 2 * M62 * t_{step}^(2)
J63: J62 + L62 * t_{step} + 1 / 2 * N62 * t_{step}^(2)
L63: L62 + N62 * t_{step}
O63 = If(A63 ≤ time_{elapsed}, (I63, J63))
M63: -sgn(K63) * drag * K63^(2)
N63: g - sgn(L63) * drag * L63^(2)
K64: K63 + M63 * t_{step}
I64: I63 + K63 * t_{step} + 1 / 2 * M63 * t_{step}^(2)
J64: J63 + L63 * t_{step} + 1 / 2 * N63 * t_{step}^(2)
L64: L63 + N63 * t_{step}
O64 = If(A64 ≤ time_{elapsed}, (I64, J64))
M64: -sgn(K64) * drag * K64^(2)
N64: g - sgn(L64) * drag * L64^(2)
K65: K64 + M64 * t_{step}
I65: I64 + K64 * t_{step} + 1 / 2 * M64 * t_{step}^(2)
J65: J64 + L64 * t_{step} + 1 / 2 * N64 * t_{step}^(2)
L65: L64 + N64 * t_{step}
O65 = If(A65 ≤ time_{elapsed}, (I65, J65))
M65: -sgn(K65) * drag * K65^(2)
N65: g - sgn(L65) * drag * L65^(2)
K66: K65 + M65 * t_{step}
I66: I65 + K65 * t_{step} + 1 / 2 * M65 * t_{step}^(2)
J66: J65 + L65 * t_{step} + 1 / 2 * N65 * t_{step}^(2)
L66: L65 + N65 * t_{step}
O66 = If(A66 ≤ time_{elapsed}, (I66, J66))
M66: -sgn(K66) * drag * K66^(2)
N66: g - sgn(L66) * drag * L66^(2)
K67: K66 + M66 * t_{step}
I67: I66 + K66 * t_{step} + 1 / 2 * M66 * t_{step}^(2)
J67: J66 + L66 * t_{step} + 1 / 2 * N66 * t_{step}^(2)
L67: L66 + N66 * t_{step}
O67 = If(A67 ≤ time_{elapsed}, (I67, J67))
M67: -sgn(K67) * drag * K67^(2)
N67: g - sgn(L67) * drag * L67^(2)
K68: K67 + M67 * t_{step}
I68: I67 + K67 * t_{step} + 1 / 2 * M67 * t_{step}^(2)
J68: J67 + L67 * t_{step} + 1 / 2 * N67 * t_{step}^(2)
L68: L67 + N67 * t_{step}
O68 = If(A68 ≤ time_{elapsed}, (I68, J68))
M68: -sgn(K68) * drag * K68^(2)
N68: g - sgn(L68) * drag * L68^(2)
K69: K68 + M68 * t_{step}
I69: I68 + K68 * t_{step} + 1 / 2 * M68 * t_{step}^(2)
J69: J68 + L68 * t_{step} + 1 / 2 * N68 * t_{step}^(2)
L69: L68 + N68 * t_{step}
O69 = If(A69 ≤ time_{elapsed}, (I69, J69))
M69: -sgn(K69) * drag * K69^(2)
N69: g - sgn(L69) * drag * L69^(2)
K70: K69 + M69 * t_{step}
I70: I69 + K69 * t_{step} + 1 / 2 * M69 * t_{step}^(2)
J70: J69 + L69 * t_{step} + 1 / 2 * N69 * t_{step}^(2)
L70: L69 + N69 * t_{step}
O70 = If(A70 ≤ time_{elapsed}, (I70, J70))
M70: -sgn(K70) * drag * K70^(2)
N70: g - sgn(L70) * drag * L70^(2)
K71: K70 + M70 * t_{step}
I71: I70 + K70 * t_{step} + 1 / 2 * M70 * t_{step}^(2)
J71: J70 + L70 * t_{step} + 1 / 2 * N70 * t_{step}^(2)
L71: L70 + N70 * t_{step}
O71 = If(A71 ≤ time_{elapsed}, (I71, J71))
M71: -sgn(K71) * drag * K71^(2)
N71: g - sgn(L71) * drag * L71^(2)
K72: K71 + M71 * t_{step}
I72: I71 + K71 * t_{step} + 1 / 2 * M71 * t_{step}^(2)
J72: J71 + L71 * t_{step} + 1 / 2 * N71 * t_{step}^(2)
L72: L71 + N71 * t_{step}
O72 = If(A72 ≤ time_{elapsed}, (I72, J72))
M72: -sgn(K72) * drag * K72^(2)
N72: g - sgn(L72) * drag * L72^(2)
K73: K72 + M72 * t_{step}
I73: I72 + K72 * t_{step} + 1 / 2 * M72 * t_{step}^(2)
J73: J72 + L72 * t_{step} + 1 / 2 * N72 * t_{step}^(2)
L73: L72 + N72 * t_{step}
O73 = If(A73 ≤ time_{elapsed}, (I73, J73))
M73: -sgn(K73) * drag * K73^(2)
N73: g - sgn(L73) * drag * L73^(2)
K74: K73 + M73 * t_{step}
I74: I73 + K73 * t_{step} + 1 / 2 * M73 * t_{step}^(2)
J74: J73 + L73 * t_{step} + 1 / 2 * N73 * t_{step}^(2)
L74: L73 + N73 * t_{step}
O74 = If(A74 ≤ time_{elapsed}, (I74, J74))
M74: -sgn(K74) * drag * K74^(2)
N74: g - sgn(L74) * drag * L74^(2)
K75: K74 + M74 * t_{step}
I75: I74 + K74 * t_{step} + 1 / 2 * M74 * t_{step}^(2)
J75: J74 + L74 * t_{step} + 1 / 2 * N74 * t_{step}^(2)
L75: L74 + N74 * t_{step}
O75 = If(A75 ≤ time_{elapsed}, (I75, J75))
M75: -sgn(K75) * drag * K75^(2)
N75: g - sgn(L75) * drag * L75^(2)
K76: K75 + M75 * t_{step}
I76: I75 + K75 * t_{step} + 1 / 2 * M75 * t_{step}^(2)
J76: J75 + L75 * t_{step} + 1 / 2 * N75 * t_{step}^(2)
L76: L75 + N75 * t_{step}
O76 = If(A76 ≤ time_{elapsed}, (I76, J76))
M76: -sgn(K76) * drag * K76^(2)
N76: g - sgn(L76) * drag * L76^(2)
K77: K76 + M76 * t_{step}
I77: I76 + K76 * t_{step} + 1 / 2 * M76 * t_{step}^(2)
J77: J76 + L76 * t_{step} + 1 / 2 * N76 * t_{step}^(2)
L77: L76 + N76 * t_{step}
O77 = If(A77 ≤ time_{elapsed}, (I77, J77))
M77: -sgn(K77) * drag * K77^(2)
N77: g - sgn(L77) * drag * L77^(2)
K78: K77 + M77 * t_{step}
I78: I77 + K77 * t_{step} + 1 / 2 * M77 * t_{step}^(2)
J78: J77 + L77 * t_{step} + 1 / 2 * N77 * t_{step}^(2)
L78: L77 + N77 * t_{step}
O78 = If(A78 ≤ time_{elapsed}, (I78, J78))
M78: -sgn(K78) * drag * K78^(2)
N78: g - sgn(L78) * drag * L78^(2)
K79: K78 + M78 * t_{step}
I79: I78 + K78 * t_{step} + 1 / 2 * M78 * t_{step}^(2)
J79: J78 + L78 * t_{step} + 1 / 2 * N78 * t_{step}^(2)
L79: L78 + N78 * t_{step}
O79 = If(A79 ≤ time_{elapsed}, (I79, J79))
M79: -sgn(K79) * drag * K79^(2)
N79: g - sgn(L79) * drag * L79^(2)
K80: K79 + M79 * t_{step}
I80: I79 + K79 * t_{step} + 1 / 2 * M79 * t_{step}^(2)
J80: J79 + L79 * t_{step} + 1 / 2 * N79 * t_{step}^(2)
L80: L79 + N79 * t_{step}
O80 = If(A80 ≤ time_{elapsed}, (I80, J80))
M80: -sgn(K80) * drag * K80^(2)
N80: g - sgn(L80) * drag * L80^(2)
K81: K80 + M80 * t_{step}
I81: I80 + K80 * t_{step} + 1 / 2 * M80 * t_{step}^(2)
J81: J80 + L80 * t_{step} + 1 / 2 * N80 * t_{step}^(2)
L81: L80 + N80 * t_{step}
O81 = If(A81 ≤ time_{elapsed}, (I81, J81))
M81: -sgn(K81) * drag * K81^(2)
N81: g - sgn(L81) * drag * L81^(2)
K82: K81 + M81 * t_{step}
I82: I81 + K81 * t_{step} + 1 / 2 * M81 * t_{step}^(2)
J82: J81 + L81 * t_{step} + 1 / 2 * N81 * t_{step}^(2)
L82: L81 + N81 * t_{step}
O82 = If(A82 ≤ time_{elapsed}, (I82, J82))
M82: -sgn(K82) * drag * K82^(2)
N82: g - sgn(L82) * drag * L82^(2)
K83: K82 + M82 * t_{step}
I83: I82 + K82 * t_{step} + 1 / 2 * M82 * t_{step}^(2)
J83: J82 + L82 * t_{step} + 1 / 2 * N82 * t_{step}^(2)
L83: L82 + N82 * t_{step}
O83 = If(A83 ≤ time_{elapsed}, (I83, J83))
M83: -sgn(K83) * drag * K83^(2)
N83: g - sgn(L83) * drag * L83^(2)
K84: K83 + M83 * t_{step}
I84: I83 + K83 * t_{step} + 1 / 2 * M83 * t_{step}^(2)
J84: J83 + L83 * t_{step} + 1 / 2 * N83 * t_{step}^(2)
L84: L83 + N83 * t_{step}
O84 = If(A84 ≤ time_{elapsed}, (I84, J84))
M84: -sgn(K84) * drag * K84^(2)
N84: g - sgn(L84) * drag * L84^(2)
K85: K84 + M84 * t_{step}
I85: I84 + K84 * t_{step} + 1 / 2 * M84 * t_{step}^(2)
J85: J84 + L84 * t_{step} + 1 / 2 * N84 * t_{step}^(2)
L85: L84 + N84 * t_{step}
O85 = If(A85 ≤ time_{elapsed}, (I85, J85))
M85: -sgn(K85) * drag * K85^(2)
N85: g - sgn(L85) * drag * L85^(2)
K86: K85 + M85 * t_{step}
I86: I85 + K85 * t_{step} + 1 / 2 * M85 * t_{step}^(2)
J86: J85 + L85 * t_{step} + 1 / 2 * N85 * t_{step}^(2)
L86: L85 + N85 * t_{step}
O86 = If(A86 ≤ time_{elapsed}, (I86, J86))
M86: -sgn(K86) * drag * K86^(2)
N86: g - sgn(L86) * drag * L86^(2)
K87: K86 + M86 * t_{step}
I87: I86 + K86 * t_{step} + 1 / 2 * M86 * t_{step}^(2)
J87: J86 + L86 * t_{step} + 1 / 2 * N86 * t_{step}^(2)
L87: L86 + N86 * t_{step}
O87 = If(A87 ≤ time_{elapsed}, (I87, J87))
M87: -sgn(K87) * drag * K87^(2)
N87: g - sgn(L87) * drag * L87^(2)
K88: K87 + M87 * t_{step}
I88: I87 + K87 * t_{step} + 1 / 2 * M87 * t_{step}^(2)
J88: J87 + L87 * t_{step} + 1 / 2 * N87 * t_{step}^(2)
L88: L87 + N87 * t_{step}
O88 = If(A88 ≤ time_{elapsed}, (I88, J88))
M88: -sgn(K88) * drag * K88^(2)
N88: g - sgn(L88) * drag * L88^(2)
K89: K88 + M88 * t_{step}
I89: I88 + K88 * t_{step} + 1 / 2 * M88 * t_{step}^(2)
J89: J88 + L88 * t_{step} + 1 / 2 * N88 * t_{step}^(2)
L89: L88 + N88 * t_{step}
O89 = If(A89 ≤ time_{elapsed}, (I89, J89))
M89: -sgn(K89) * drag * K89^(2)
N89: g - sgn(L89) * drag * L89^(2)
K90: K89 + M89 * t_{step}
I90: I89 + K89 * t_{step} + 1 / 2 * M89 * t_{step}^(2)
J90: J89 + L89 * t_{step} + 1 / 2 * N89 * t_{step}^(2)
L90: L89 + N89 * t_{step}
O90 = If(A90 ≤ time_{elapsed}, (I90, J90))
M90: -sgn(K90) * drag * K90^(2)
N90: g - sgn(L90) * drag * L90^(2)
K91: K90 + M90 * t_{step}
I91: I90 + K90 * t_{step} + 1 / 2 * M90 * t_{step}^(2)
J91: J90 + L90 * t_{step} + 1 / 2 * N90 * t_{step}^(2)
L91: L90 + N90 * t_{step}
O91 = If(A91 ≤ time_{elapsed}, (I91, J91))
M91: -sgn(K91) * drag * K91^(2)
N91: g - sgn(L91) * drag * L91^(2)
K92: K91 + M91 * t_{step}
I92: I91 + K91 * t_{step} + 1 / 2 * M91 * t_{step}^(2)
J92: J91 + L91 * t_{step} + 1 / 2 * N91 * t_{step}^(2)
L92: L91 + N91 * t_{step}
O92 = If(A92 ≤ time_{elapsed}, (I92, J92))
M92: -sgn(K92) * drag * K92^(2)
N92: g - sgn(L92) * drag * L92^(2)
K93: K92 + M92 * t_{step}
I93: I92 + K92 * t_{step} + 1 / 2 * M92 * t_{step}^(2)
J93: J92 + L92 * t_{step} + 1 / 2 * N92 * t_{step}^(2)
L93: L92 + N92 * t_{step}
O93 = If(A93 ≤ time_{elapsed}, (I93, J93))
M93: -sgn(K93) * drag * K93^(2)
N93: g - sgn(L93) * drag * L93^(2)
K94: K93 + M93 * t_{step}
I94: I93 + K93 * t_{step} + 1 / 2 * M93 * t_{step}^(2)
J94: J93 + L93 * t_{step} + 1 / 2 * N93 * t_{step}^(2)
L94: L93 + N93 * t_{step}
O94 = If(A94 ≤ time_{elapsed}, (I94, J94))
M94: -sgn(K94) * drag * K94^(2)
N94: g - sgn(L94) * drag * L94^(2)
K95: K94 + M94 * t_{step}
I95: I94 + K94 * t_{step} + 1 / 2 * M94 * t_{step}^(2)
J95: J94 + L94 * t_{step} + 1 / 2 * N94 * t_{step}^(2)
L95: L94 + N94 * t_{step}
O95 = If(A95 ≤ time_{elapsed}, (I95, J95))
M95: -sgn(K95) * drag * K95^(2)
N95: g - sgn(L95) * drag * L95^(2)
K96: K95 + M95 * t_{step}
I96: I95 + K95 * t_{step} + 1 / 2 * M95 * t_{step}^(2)
J96: J95 + L95 * t_{step} + 1 / 2 * N95 * t_{step}^(2)
L96: L95 + N95 * t_{step}
O96 = If(A96 ≤ time_{elapsed}, (I96, J96))
M96: -sgn(K96) * drag * K96^(2)
N96: g - sgn(L96) * drag * L96^(2)
K97: K96 + M96 * t_{step}
I97: I96 + K96 * t_{step} + 1 / 2 * M96 * t_{step}^(2)
J97: J96 + L96 * t_{step} + 1 / 2 * N96 * t_{step}^(2)
L97: L96 + N96 * t_{step}
O97 = If(A97 ≤ time_{elapsed}, (I97, J97))
M97: -sgn(K97) * drag * K97^(2)
N97: g - sgn(L97) * drag * L97^(2)
K98: K97 + M97 * t_{step}
I98: I97 + K97 * t_{step} + 1 / 2 * M97 * t_{step}^(2)
J98: J97 + L97 * t_{step} + 1 / 2 * N97 * t_{step}^(2)
L98: L97 + N97 * t_{step}
O98 = If(A98 ≤ time_{elapsed}, (I98, J98))
M98: -sgn(K98) * drag * K98^(2)
N98: g - sgn(L98) * drag * L98^(2)
K99: K98 + M98 * t_{step}
I99: I98 + K98 * t_{step} + 1 / 2 * M98 * t_{step}^(2)
J99: J98 + L98 * t_{step} + 1 / 2 * N98 * t_{step}^(2)
L99: L98 + N98 * t_{step}
O99 = If(A99 ≤ time_{elapsed}, (I99, J99))
M99: -sgn(K99) * drag * K99^(2)
N99: g - sgn(L99) * drag * L99^(2)
K100: K99 + M99 * t_{step}
I100: I99 + K99 * t_{step} + 1 / 2 * M99 * t_{step}^(2)
J100: J99 + L99 * t_{step} + 1 / 2 * N99 * t_{step}^(2)
L100: L99 + N99 * t_{step}
O100 = If(A100 ≤ time_{elapsed}, (I100, J100))
M100: -sgn(K100) * drag * K100^(2)
N100: g - sgn(L100) * drag * L100^(2)

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])