DuckieDai Final Velocity Python Program

physics · MIT License

Overview

Find final velocity from initial velocity, constant acceleration, and elapsed time using vf = vi + a*t.

Tested on a TI calculator
Downloaded 38 times
Version 1.0.0
2664 bytes
No imports

Download duckiedai_final_velocity.py Read the source How to install

Before you run it

TI-84 Plus CE Python · tested on OS 5.8.3, Python App 5.8.3.0048
Sent through TI Connect CE to the Python App; the calculator name can be changed during transfer
Acceleration is constant over the entered time.
Signed values describe direction along one chosen axis.
Elapsed time cannot be negative.

Try the DuckieDai calculator screen

See the DuckieDai opening, enter initial velocity, acceleration, and elapsed time, then follow the result.

JavaScript is required for the optional browser simulation. Source viewing and downloading remain available without it.

Simulation boundary: This preview uses a reviewed browser adapter. It does not execute the downloaded Python and does not prove TI-Python or calculator compatibility.

Learn the math

How to find final velocity

The idea

When acceleration is constant, velocity changes by the same amount every second. The final velocity is the starting velocity plus acceleration multiplied by time.

This is the first of the constant-acceleration (kinematics) equations and the one to reach for when a problem gives you a time.

The formula

vf = vi + a*t

vf: final velocity (m/s)
vi: initial velocity (m/s)
a: acceleration (m/s^2)
t: elapsed time (s)

Using the program

Enter the initial velocity, the acceleration, and the time, in that order.
The program shows the substitution and the final velocity in m/s.

Worked example

A bike moving at 2 m/s accelerates at 3 m/s^2 for 4 s. Enter 2, 3, and 4.

vf = 2.0 + (3.0 x 4.0)

The program shows Final velocity = 14.0 m/s.

Tips and common mistakes

Slowing down is a negative acceleration: type -3, not 3.
An object starting from rest has an initial velocity of 0.
If the problem gives a distance and no time, use the Smart Kinematics program instead.

Where this comes up

It appears in the one-dimensional motion unit of high school physics and physical science, usually as the first kinematics equation taught. Free-fall problems use it with an acceleration of 9.8 m/s^2 downward.

Exact reviewed bytes

Source code

Download .py

View source below, copy it when JavaScript is available, or download the exact .py bytes.

"""DuckieDai Final Velocity prototype for TI-84 Plus CE Python.

Standalone source. Not yet verified on a physical calculator.
"""


def duckiedai_intro(program_name, wait=True):
    """Show the same small opening as the Rectangle Area program."""
    title = program_name[:16]
    empty = 16 - len(title)
    left = empty // 2
    right = empty - left
    print("+----------------------+")
    print("|   " + " " * left + title + " " * right + "   |")
    print("|                      |")
    print("|       __             |")
    print("|   ___(o )>  quack!   |")
    print("|   \\ <_. )           |")
    print("|    `---'             |")
    print("|     by DuckieDai     |")
    print("+----------------------+")
    print("Loading...")
    if wait:
        input("Press enter to start ")
        print("\n" * 6)


def is_finite_input(value):
    """Reject NaN, infinity, and magnitudes impractical for the calculator."""
    return value > -1e100 and value < 1e100


def number(prompt):
    """Allow positive, negative, or zero velocity and acceleration."""
    while True:
        try:
            value = float(input(prompt))
            if is_finite_input(value):
                return value
        except ValueError:
            pass
        print("Enter a valid number.")


def nonnegative_number(prompt):
    """Elapsed time can be zero, but not negative."""
    while True:
        value = number(prompt)
        if value >= 0:
            return value
        print("Enter 0 or above.")


def final_velocity(initial_velocity, acceleration, time):
    """Return vf = vi + a*t for constant acceleration in SI units."""
    if not is_finite_input(initial_velocity) or not is_finite_input(acceleration):
        raise ValueError("velocity and acceleration must be finite")
    if not is_finite_input(time) or time < 0:
        raise ValueError("time must be nonnegative and finite")
    velocity = initial_velocity + acceleration * time
    if not is_finite_input(velocity):
        raise ValueError("final velocity is too large")
    return velocity


def main():
    duckiedai_intro("FINAL VELOCITY")
    print("FINAL VELOCITY")
    print("Formula: vf = vi + a*t")
    print()
    vi = number("Initial v (m/s): ")
    acceleration = number("Accel (m/s^2): ")
    time = nonnegative_number("Time (s): ")
    vf = final_velocity(vi, acceleration, time)
    print()
    print("vf = " + str(vi) + " +")
    print("(" + str(acceleration) + " x " + str(time) + ")")
    print("Final velocity =")
    print(str(vf) + " m/s")
    print()
    print("DuckieDai says: done!")


# TI-Python imports a selected AppVar instead of setting __name__ to main.
main()

"""DuckieDai Final Velocity prototype for TI-84 Plus CE Python.
Standalone source. Not yet verified on a physical calculator.
"""
def duckiedai_intro(program_name, wait=True):
"""Show the same small opening as the Rectangle Area program."""
title = program_name[:16]
empty = 16 - len(title)
left = empty // 2
right = empty - left
print("+----------------------+")
print("| " + " " * left + title + " " * right + " |")
print("| |")
print("| __ |")
print("| ___(o )> quack! |")
print("| \\ <_. ) |")
print("| `---' |")
print("| by DuckieDai |")
print("+----------------------+")
print("Loading...")
if wait:
input("Press enter to start ")
print("\n" * 6)
def is_finite_input(value):
"""Reject NaN, infinity, and magnitudes impractical for the calculator."""
return value > -1e100 and value < 1e100
def number(prompt):
"""Allow positive, negative, or zero velocity and acceleration."""
while True:
try:
value = float(input(prompt))
if is_finite_input(value):
return value
except ValueError:
pass
print("Enter a valid number.")
def nonnegative_number(prompt):
"""Elapsed time can be zero, but not negative."""
while True:
value = number(prompt)
if value >= 0:
return value
print("Enter 0 or above.")
def final_velocity(initial_velocity, acceleration, time):
"""Return vf = vi + a*t for constant acceleration in SI units."""
if not is_finite_input(initial_velocity) or not is_finite_input(acceleration):
raise ValueError("velocity and acceleration must be finite")
if not is_finite_input(time) or time < 0:
raise ValueError("time must be nonnegative and finite")
velocity = initial_velocity + acceleration * time
if not is_finite_input(velocity):
raise ValueError("final velocity is too large")
return velocity
def main():
duckiedai_intro("FINAL VELOCITY")
print("FINAL VELOCITY")
print("Formula: vf = vi + a*t")
print()
vi = number("Initial v (m/s): ")
acceleration = number("Accel (m/s^2): ")
time = nonnegative_number("Time (s): ")
vf = final_velocity(vi, acceleration, time)
print()
print("vf = " + str(vi) + " +")
print("(" + str(acceleration) + " x " + str(time) + ")")
print("Final velocity =")
print(str(vf) + " m/s")
print()
print("DuckieDai says: done!")
# TI-Python imports a selected AppVar instead of setting __name__ to main.
main()

Filename: duckiedai_final_velocity.py
Size: 2664 bytes
SHA-256: 82f7574b4ab96769f6b83867c3a9ce41d9c849f5f3f1065853d1f42febf49dcb

Usage

Inputs

Initial velocity in m/s: any signed number with magnitude below 1e100
Constant acceleration in m/s^2: any signed number with magnitude below 1e100
Elapsed time in seconds: 0 or more, below 1e100

Outputs

Final velocity in m/s, using vf = vi + a*t

Units: Use m/s for initial velocity, m/s^2 for acceleration, and seconds for time; the result is m/s.

Assumptions and limitations

Assumptions

Acceleration is constant over the entered time.
Signed values describe direction along one chosen axis.

Constraints

Elapsed time cannot be negative.
Inputs and result must remain within the program's finite numeric range.

Known failures

Non-numeric, NaN, infinite, or out-of-range input is requested again.
A negative time is requested again; an excessively large final result stops with an error.
The answer is not automatically rounded to significant figures.

Compatibility and review

Review status: Tested on a TI calculator
Tested on: TI-84 Plus CE Python; OS 5.8.3; Python App 5.8.3.0048; transferred through TI Connect CE as PTEST
What happened: The program ran successfully on the calculator: the duck opening appeared, Enter started the prompts, and the final velocity answer displayed. Edge cases were checked on desktop only.
Dependencies: No imports
Suggested calculator name: FINALVEL — you can give it another valid, unique name when you transfer it
Desktop test cases: 5 cases

The desktop tests cover calculations and error handling. The calculator review above records what was actually checked on the device.

Transfer and launch

Download the .py file, send it to your calculator with TI Connect CE as FINALVEL or another name, then open the Python App and try the worked example on this page first.

Full installation and troubleshooting guide. Check your teacher's or exam's rules before using any program.

Version history

1.0.0 — current version, published 2026-09-22. Download this reviewed version

Did a DuckieDai program help with your homework? Every program here is free. If you would like to say thanks, you can leave a tip on Cash App ($duckiedai214) or read what tips pay for.

Independent compatibility resource: Hidden Word Scanner is independent and is not affiliated with or endorsed by Texas Instruments. TI product names describe compatibility only.

Action-count privacy: Successful downloads, preview starts, and preview completions increment same-origin aggregate counters, and so does a Yes or No answer about whether the program worked. Your browser notes that you answered; that note is never sent to the site. No entered values, source text, IP address, account, cookie, device identifier, or fingerprint is stored with these counts.