DuckieDai Molarity Python Program

← Back to Calculator Program Library

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. No entered values, source text, IP address, account, cookie, device identifier, or fingerprint is stored with these counts.

chemistry · MIT License

Overview

Find molarity by dividing moles of solute by liters of final solution: M = mol / L.

Usage

Inputs

Moles of solute: 0 or more, below 1e100
Liters of final solution: greater than 0, below 1e100

Outputs

Molarity in mol/L, using M = moles / liters

Units: Enter moles of solute and liters of final solution; the result is mol/L. Convert milliliters to liters before entering.

Assumptions and limitations

Assumptions

The volume entered is the total final solution volume, not the amount of solvent poured in.

Constraints

Moles cannot be negative, and solution volume must be greater than zero.
Inputs and result must remain within the program's finite numeric range.

Known failures

Negative, non-numeric, NaN, infinite, or out-of-range moles are requested again.
Zero, negative, or invalid solution volume is requested again; an excessively large result stops with an error.
The answer is not automatically rounded to significant figures or converted from grams or milliliters.

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 CTEST
What happened: The program ran successfully on the calculator: the duck opening appeared, Enter started the prompts, and the molarity answer displayed. Edge cases were checked on desktop only.
Dependencies: No imports
Suggested calculator name: MOLARITY — 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.

Browser preview

Try the DuckieDai calculator screen

See the DuckieDai opening, enter moles and liters of final solution, then follow the molarity result.

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.

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

Exact reviewed bytes

Source code

Download .py

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

"""DuckieDai Molarity 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_nonnegative_finite(value):
    return value >= 0 and value < 1e100


def nonnegative_number(prompt):
    """Zero moles is valid; negative amount is not."""
    while True:
        try:
            value = float(input(prompt))
            if is_nonnegative_finite(value):
                return value
        except ValueError:
            pass
        print("Enter 0 or above.")


def positive_number(prompt):
    """Solution volume in liters must be greater than zero."""
    while True:
        try:
            value = float(input(prompt))
            if value > 0 and value < 1e100:
                return value
        except ValueError:
            pass
        print("Enter a number above 0.")


def molarity(moles, liters):
    """Return amount of solute divided by total solution volume."""
    if not is_nonnegative_finite(moles):
        raise ValueError("moles must be nonnegative and finite")
    if not liters > 0 or not liters < 1e100:
        raise ValueError("liters must be positive and finite")
    result = moles / liters
    if not is_nonnegative_finite(result):
        raise ValueError("molarity is too large")
    return result


def main():
    duckiedai_intro("MOLARITY")
    print("MOLARITY")
    print("Formula: M = mol / L")
    print("Use solution volume, not")
    print("solvent volume.")
    print()
    moles = nonnegative_number("Moles solute: ")
    liters = positive_number("Solution L: ")
    result = molarity(moles, liters)
    print()
    print("M = " + str(moles) + " / " + str(liters))
    print("Molarity =")
    print(str(result) + " mol/L")
    print()
    print("DuckieDai says: done!")


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

"""DuckieDai Molarity 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_nonnegative_finite(value):
return value >= 0 and value < 1e100
def nonnegative_number(prompt):
"""Zero moles is valid; negative amount is not."""
while True:
try:
value = float(input(prompt))
if is_nonnegative_finite(value):
return value
except ValueError:
pass
print("Enter 0 or above.")
def positive_number(prompt):
"""Solution volume in liters must be greater than zero."""
while True:
try:
value = float(input(prompt))
if value > 0 and value < 1e100:
return value
except ValueError:
pass
print("Enter a number above 0.")
def molarity(moles, liters):
"""Return amount of solute divided by total solution volume."""
if not is_nonnegative_finite(moles):
raise ValueError("moles must be nonnegative and finite")
if not liters > 0 or not liters < 1e100:
raise ValueError("liters must be positive and finite")
result = moles / liters
if not is_nonnegative_finite(result):
raise ValueError("molarity is too large")
return result
def main():
duckiedai_intro("MOLARITY")
print("MOLARITY")
print("Formula: M = mol / L")
print("Use solution volume, not")
print("solvent volume.")
print()
moles = nonnegative_number("Moles solute: ")
liters = positive_number("Solution L: ")
result = molarity(moles, liters)
print()
print("M = " + str(moles) + " / " + str(liters))
print("Molarity =")
print(str(result) + " mol/L")
print()
print("DuckieDai says: done!")
# TI-Python imports a selected AppVar instead of setting __name__ to main.
main()

Filename: duckiedai_molarity.py
Size: 2540 bytes
SHA-256: fc97f2e47224144e300d273fb015f815d741a8c9f3788f40710cdc71495ba70f

Transfer and launch

Confirm that your calculator is the Python-capable model named above. Check that its OS and Python App versions match the reviewed record.
Download the .py source above and verify its SHA-256 digest if your computer provides that option.
Use TI Connect CE to send the Python file to a compatible calculator. MOLARITY is a suggested name; you may choose another valid, unique calculator name.
Open the Python App, select the program, and check sample inputs before relying on other results.

Read the complete installation, launch, troubleshooting, and removal guide.

Availability does not mean a teacher, school, or exam permits this program. Follow the applicable rules.

Version history

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

Any source change requires a new immutable version and digest. Historical downloads remain available only while their review records remain valid.