python-calculator – COMP 536: Computational Modeling for Scientists (Spring 2026)

Author

Anna Rosen

title: “Chapter 2: Python as Your Scientific Calculator” subtitle: “COMP 536 | Python Fundamentals” author: “Anna Rosen” draft: false execute: echo: true warning: true error: false freeze: auto format: html: toc: true code-fold: true code-summary: “Show code” —

Prerequisites Check

Before Starting This Chapter

You can launch IPython and use basic magic commands (Chapter 1)
You understand the difference between scripts and interactive sessions (Chapter 1)
You can navigate your file system and activate your conda environment (Chapter 1)
Your comp536 environment is activated and IPython is ready

If any boxes are unchecked, review Chapter 1 first.

Chapter Overview

Now that you’ve mastered setting up your computational environment and understand how Python finds and loads code, it’s time to transform IPython into your personal calculator. But this chapter goes far beyond simple arithmetic - you’re about to discover the hidden complexity of numerical computation that can make the difference between correct results and completely wrong ones due to rounding errors.

You’ll learn why spacecraft have crashed, why some calculations fail catastrophically, and how to write code that handles extreme scales — from the quantum level at $10^{-35}$ meters to the cosmological scale at $10^{26}$ meters. The floating-point precision issues we explore here aren’t academic exercises; they’re the source of real bugs that have corrupted simulations, invalidated published results, and caused navigation errors costing hundreds of millions of dollars.

By mastering these fundamentals now, you’ll develop the numerical intuition that separates computational scientists from programmers who just happen to work with scientific data. Every simulation you build, every dataset you analyze, and every statistical test you run will rely on the concepts in this chapter. Let’s begin your journey from calculator user to numerical computing expert.

Numerical Thinking Checklist (use this all semester)

Before trusting a numerical result, quickly ask:

Scale: What order(s) of magnitude are the inputs and outputs?
Representation: Should this be int, float64, float32, Decimal, or complex?
Stability: Am I subtracting nearly equal numbers? Summing many terms? Repeating an update many times?
Propagation: Will small errors accumulate (iterations, long integrations, long time series)?
Comparison: Should I compare with absolute tolerance, relative tolerance, or both?
Diagnostics: What are the dtypes? Are values finite (math.isfinite, np.isfinite)? Any nan/inf?

2.1 Python as Your Scientific Calculator

Fire up ipython (remember from Chapter 1 — not the basic python interpreter, we want the enhanced features) and let’s start with the basics. Python handles arithmetic operations naturally, but there are subtleties that matter for scientific work:

2 + 2 = 4
10 / 3 = 3.3333333333333335
2 ** 10 = 1024

Notice that 10 / 3 gives us 3.3333333333333335 — not exactly 1/3! This tiny imprecision at the end might seem trivial, but it’s your first glimpse into a fundamental challenge of computational science.

Operator Precedence: A Source of Real Bugs

Python follows PEMDAS (Parentheses, Exponents, Multiplication/Division, Addition/Subtraction), but relying on memorized rules causes expensive errors. Let’s see this with a real calculation:

Wrong velocity: 3.43e+14 m/s
Correct velocity: 2.98e+04 m/s
That's 29.8 km/s - Earth's orbital speed!
Wrong answer is 11518085778x too large!

The wrong version calculated $(GM/\sqrt{r})$ instead of $\sqrt{(GM/r)}$ — a huge error!

One more precedence pitfall worth memorizing: exponentiation is right-associative.

2**3**2 = 512  (this is 2**(3**2), not (2**3)**2)
(2**3)**2 = 64

Check Your Understanding

Before running this code, predict the result of: -2**2 + 3*4//2

Work through it step by step:

First, identify the operations: negation, exponentiation, multiplication, floor division, addition
Apply PEMDAS rules (remember: exponentiation before negation!)
Write your predicted answer

Solution:

Let’s work through -2**2 + 3*4//2 step by step:

Exponentiation first: 2**2 = 4
Then negation: -4 (the negative applies after exponentiation!)
Multiplication: 3*4 = 12
Floor division: 12//2 = 6
Finally addition: -4 + 6 = 2

The result is 2. The tricky part is that -2**2 equals -4, not 4! Python interprets this as -(2**2), not (-2)**2. This subtle precedence rule has caused real bugs in calculations.

Complete Arithmetic Operators

Python provides operators beyond basic arithmetic that prove essential for scientific calculations:

17 days = 2 weeks and 3 days
17 // 3 = 5
-17 // 3 = -6

Be careful with negative values:
int(-17/3) = -5 (truncates toward zero)
-17 // 3 = -6 (floors toward -infinity)

Common Bug Alert: Negative Floor Division

Floor division with negative numbers often surprises programmers calculating phases or time intervals before an epoch. When working with values that can be negative, always test your edge cases or use int(a/b) for truncation toward zero.

2.2 How Python Stores Numbers: Critical for Scientific Computing

Here’s where your journey gets interesting! You’re about to peek behind the curtain and see how computers really think about numbers. This knowledge is your superpower — it’s what lets you calculate trajectories with precision.

Integers: Arbitrary Precision Power

Unlike many languages, Python integers have unlimited precision — a huge advantage when dealing with enormous numbers:

Atoms in universe: 100000000000000000000000000000000000000000000000000000000000000000000000000000000
Can even square it: 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

Memory usage comparison:
Small integer (42) uses: 28 bytes
Universe atoms uses: 60 bytes
Atoms squared uses: 96 bytes

This arbitrary precision is wonderful but comes with a cost — Python integers use more memory (and can be slower) than fixed-size integers in compiled languages. This is why specialized numerical libraries become essential for large datasets.

Floating-Point Numbers: The Heart of Numerical Computing

This is it — the concept that separates casual programmers from computational scientists! Don’t worry if this seems complex at first; every professional scientist had to learn these same lessons.

Floating-point numbers use IEEE 754 representation: 64 bits split into sign (1 bit), exponent (11 bits), and a fraction field (52 stored bits). For normal (non-subnormal) numbers there is an implicit leading 1, so you get about 53 bits of significand precision (roughly 15–16 decimal digits). This creates fundamental limitations that every computational scientist must understand.

Understanding Bits and Precision

Before diving into floating-point challenges, let’s understand the fundamental unit of computer memory: the bit. A bit (binary digit) can store exactly one of two values: 0 or 1. Think of it as a light switch—either on or off. Everything your computer does ultimately reduces to manipulating billions of these tiny switches.

Groups of bits form larger units:

8 bits = 1 byte (can represent 256 different values: $2^{8}$)
32 bits = 4 bytes (can represent ~4.3 billion values: $2^{32}$)
64 bits = 8 bytes (can represent ~18 quintillion values: $2^{64}$)

Single vs Double Precision: The 32-bit vs 64-bit Choice

Floating-point numbers come in two main flavors:

Python float: 24 bytes
Precision: 3.141592653589793

32-bit representation: 3.1415927410125732
64-bit representation: 3.141592653589793
Lost digits in 32-bit: -8.7422780126e-08

IEEE 754 Standard bit allocation:
32-bit: 1 sign + 8 exponent + 23 fraction bits
64-bit: 1 sign + 11 exponent + 52 fraction bits

The trade-offs are crucial for scientific computing:

Aspect	32-bit (float32)	64-bit (float64)
Precision	~7 decimal digits	~15 decimal digits
Range	$\pm$$10^{-38}$ to $10^{38}$	$\pm$$10^{-308}$ to $10^{308}$
Memory	4 bytes	8 bytes
Speed	Faster on GPU	Standard on CPU
Use case	Graphics, ML training	Scientific computing

If you want the actual limits (min/max/eps) instead of memorizing them, use numpy.finfo:

Machine parameters for float32
---------------------------------------------------------------
precision =   6   resolution = 1.0000000e-06
machep =    -23   eps =        1.1920929e-07
negep =     -24   epsneg =     5.9604645e-08
minexp =   -126   tiny =       1.1754944e-38
maxexp =    128   max =        3.4028235e+38
nexp =        8   min =        -max
smallest_normal = 1.1754944e-38   smallest_subnormal = 1.4012985e-45
---------------------------------------------------------------

Machine parameters for float64
---------------------------------------------------------------
precision =  15   resolution = 1.0000000000000001e-15
machep =    -52   eps =        2.2204460492503131e-16
negep =     -53   epsneg =     1.1102230246251565e-16
minexp =  -1022   tiny =       2.2250738585072014e-308
maxexp =   1024   max =        1.7976931348623157e+308
nexp =       11   min =        -max
smallest_normal = 2.2250738585072014e-308   smallest_subnormal = 4.9406564584124654e-324
---------------------------------------------------------------

Python defaults to 64-bit because scientific computing needs that precision. But libraries like JAX default to 32-bit for machine learning where speed matters more than precision. For numerical computing with JAX, you can configure it to use 64-bit precision by setting jax.config.update('jax_enable_x64', True) at the start of your program. Always know which precision you’re using!

Why 0.1 + 0.2 $\neq$ 0.3

Now that you understand bits and precision, let’s see why even 64-bit floats can’t exactly represent simple decimals.

0.1 + 0.2 = 0.30000000000000004
0.1 + 0.2 == 0.3? False
Actual stored value: 0.30000000000000004

What Python actually stores:
As exact decimals (from strings): 0.1, 0.2, 0.3
From floats (captures float approximation): 0.1000000000000000055511151231257827021181583404541015625
0.1 as float hex: 0x1.999999999999ap-4

Why does this happen? Just as 1/3 can’t be exactly represented in decimal (0.33333…), 1/10 can’t be exactly represented in binary. This has crashed spacecraft and corrupted years of simulations!

Check Your Understanding

Will this return True or False? Think carefully before testing:

result = 0.1 * 3 == 0.3

Make your prediction, then test it. What do you think causes the result?

Solution:

This returns False! Here’s why:

0.1 * 3 = 0.30000000000000004
0.3 =     0.29999999999999999

You’ll see that 0.1 * 3 gives approximately 0.30000000000000004, while 0.3 is approximately 0.29999999999999999. They’re different by about $5.5$\[10^{-17}\] - tiny but not zero!

This isn’t a quirk — it’s fundamental to how every computer on Earth handles decimals. This is why we use math.isclose() (see Section Section 5.7) for floating-point comparisons.

Computational Thinking: Representation Limits

Every number system has values it cannot represent exactly. In base 10, we can’t write 1/3 exactly. In base 2 (binary), we can’t write 1/10 exactly. This isn’t a flaw — it’s a fundamental property of finite representation.

This pattern appears everywhere in computing:

JPEG images lose information through compression
MP3s approximate sound waves
Floating-point approximates real numbers
Neural networks approximate functions

Understanding representation limits helps you choose the right tool for each task. The key insight: always assume floating-point arithmetic is approximate, never exact.

Machine Epsilon: The Smallest Distinguishable Difference

Ready for something mind-blowing? Your computer literally cannot tell the difference between some numbers that are mathematically different! This isn’t a flaw — it’s a fundamental property of finite systems.

Machine epsilon: 2.220446049250313e-16
That's about 2.22e-16

Can Python tell these apart from 1.0?
1.0 + epsilon/2 = 1.0, equals 1.0? True
1.0 + epsilon   = 1.0000000000000002, equals 1.0? False

At 1 AU distance (1.50e+11 m):
We cannot detect changes smaller than 3.32e-05 m
That's about 33.2 mum (~0.033 mm)

Why This Matters: The Patriot Missile Timing Disaster

On February 25, 1991, an American Patriot missile battery in Dhahran, Saudi Arabia, failed to intercept an incoming Iraqi Scud missile. The Scud struck an Army barracks, killing 28 soldiers and injuring 98 others. The cause? A tiny numerical error that accumulated over time.

The Patriot’s targeting system tracked time using a 24-bit fixed point register, counting in tenths of seconds. However, 1/10 has no exact binary representation—in 24-bit precision, the stored value was actually 0.099999904632568359375, creating an error of approximately 0.000000095 seconds per tenth of a second.

After running continuously for 100 hours (360,000 tenth-second increments), this microscopic error had grown to:

Timing error: 0.34 seconds
Range gate error: ~687 meters (Scud velocity $\approx$ 2,000 m/s)

The Patriot radar system looked in the wrong section of sky and never detected the incoming missile.

The lesson for scientific computing: Even “negligible” rounding errors become significant when accumulated over many iterations. Whether you’re integrating orbits over millions of timesteps or tracking particles in a simulation, always consider:

How errors propagate through iterations
Whether your precision is adequate for the timescales involved
The difference between relative and absolute error tolerances

[Source: GAO Report IMTEC-92-26]

Safe Floating-Point Comparisons

Never use == with floating-point numbers! Here’s how to compare them safely:

Stage 1: Understanding the Problem

Velocity: 299792458.0
Calculated: 299792458.0
Difference: 0.00e+00
Are they equal? True
Even tiny differences fail equality test!

Stage 2: Basic Solution

True

Stage 3: Professional Solution

True
True

Debug This! Distance Calculator

A programmer’s distance calculation code produces inconsistent results:

def calculate_distance(parallax_mas):
    """
    Calculate distance from parallax.
    Parallax in milliarcseconds, returns parsecs.
    """
    # Distance in parsecs = 1000 / parallax_in_mas
    distance_pc = 1000.0 / parallax_mas

    return distance_pc

# Test with known value
parallax = 768.5  # milliarcseconds
d_pc = calculate_distance(parallax)

print(f"Distance: {d_pc} pc")

# Verify with known value
known_distance = 1.301  # parsecs
if d_pc == known_distance:
    print("✓ Calculation verified!")
else:
    print("✗ Calculation mismatch!")

# Why does verification always fail even when values look identical?

Find and fix the three bugs! Think about:

The verification method
The reference value (rounding / significant digits)
Error propagation

Solution:

Three bugs found:

Bug 1: Float comparison with ==

# WRONG: Never use == with floats
if d_pc == known_distance:

# CORRECT: Use tolerance-based comparison
if abs(d_pc - known_distance) < 0.001:

Bug 2: The reference value is rounded

# The "known" value is rounded (insufficient significant digits)
print(f"Actual value: {d_pc:.12f}")  # 1000/768.5 approx 1.301236174365

Bug 3: No error handling for zero/negative parallax

def calculate_distance_safe(parallax_mas):
    """Safe version with validation."""
    if parallax_mas <= 0:
        raise ValueError(f"Parallax must be positive: {parallax_mas}")

    if parallax_mas < 0.1:  # Less than 0.1 mas
        raise ValueError(f"Parallax {parallax_mas} mas too small")

    distance_pc = 1000.0 / parallax_mas

    return distance_pc

Complete fix:

import math

def verify_distance(calculated, expected, tolerance=0.001):
    """Properly compare floating-point distances."""
    return math.isclose(calculated, expected, rel_tol=0.0, abs_tol=tolerance)

# Now verification works correctly
if verify_distance(d_pc, known_distance):
    print("✓ Calculation verified within tolerance!")

Key lesson: Floating-point equality is an illusion. Always use tolerance-based comparisons in scientific computing!

2.3 Numerical Hazards in Scientific Computing

You’ve mastered how Python stores numbers — now let’s see these concepts in action with real scientific calculations! This is where things get exciting: you’re about to learn the techniques that enable precision in spacecraft navigation, sensitive instruments, and scientific simulations.

Catastrophic Cancellation: When Subtraction Destroys Precision

Catastrophic cancellation happens when you subtract nearly equal numbers, eliminating most significant digits and leaving only a few unreliable digits behind.

Stage 1: The Problem

Direct: 1 - cos(1e-08) = 0.0
This result is completely wrong!

Stage 2: Understanding Why

cos(1e-08) = 1.00000000000000000000
1.0 =      1.00000000000000000000
At this scale, float64 cannot represent the difference between cos(x) and 1.0,
so cos(x) rounds to exactly 1.0 and 1 - cos(x) becomes 0.0.

True value: 5.000000e-17
Our result: 0.000000e+00
Relative error: 100.0%

Stage 3: The Solution

Using identity: 5.000000e-17
True value:     5.000000e-17
Much better! Error: 0.00e+00

Two stability power tools: expm1 and log1p

When you see patterns like “something very close to 1” or “exp(x) - 1 for tiny x”, look for functions designed to preserve precision:

math.expm1(x) computes exp(x) - 1 accurately when x is near 0
math.log1p(x) computes log(1 + x) accurately when x is near 0

Another cancellation “greatest hit”: the quadratic formula

When b^2 >> 4ac, the naive quadratic formula can lose many digits in -b $\pm$ sqrt(b^2 - 4ac).

import math

def quadratic_roots_stable(a, b, c):
    disc = math.sqrt(b*b - 4*a*c)
    q = -0.5 * (b + math.copysign(disc, b))
    x1 = q / a
    x2 = c / q
    return x1, x2

The take-home: if you see subtraction of nearly equal numbers, look for a mathematically equivalent form that avoids it.

Overflow and Underflow in Extreme Scales

Get ready to work with numbers that break normal intuition! Science deals with scales that push Python to its limits.

Stage 1: The Overflow Problem

float64 max: 1.7976931348623157e+308
Overflow from math.exp(1000): math range error
10.0**400 raised OverflowError: (34, 'Result too large')
This platform raises instead of returning inf

Stage 2: The Solution - Working in Log Space

exp(1000) approx 10^434.3
Universe luminosity: 10^49.9 W
That's 10^49.9 watts every second!

Computational Thinking: Working in Transformed Space

When direct calculation fails, transform your problem into a space where it succeeds. This universal pattern appears throughout computational science:

Log space: Avoid overflow/underflow in products
Fourier space: Turn convolution into multiplication
Spherical coordinates: Simplify radially symmetric problems
Standardized variables: Compare different scales

The key insight: the same problem can be easy or impossible depending on your representation. When you hit numerical limits, ask yourself whether there’s a transformation that makes the problem tractable.

Remember: transforming to a different space isn’t cheating — it’s often the mathematically correct approach that reveals the true structure of your problem.

Common Bug Alert: Silent Underflow

Unlike overflow, underflow to zero is silent — no error is raised!

tiny = 1e-200
tinier = tiny * tiny  # Underflows to 0.0 silently!
if tinier == 0:
    print("Warning: Underflow detected!")

For probability calculations, always work in log space to avoid underflow.

Defensive Programming with Numerical Checks

You’ve seen the challenges — now here’s your toolkit for conquering them! Defensive programming protects every major scientific data pipeline.

Stage 1: Basic Validation

Valid mass: 1.99e+30 kg

Stage 2: Safe Division

Gravitational acceleration: 5.93e-03 m/s^2

Stage 3: Complete Validation

Validated luminosity: 3.83e+26 W

2.4 Complex Numbers for Wave Physics

Welcome to one of the most elegant corners of mathematics! Complex numbers might sound intimidating, but they’re actually your gateway to understanding wave physics, signal processing, and Fourier analysis. Python handles complex numbers as naturally as integers.

Complex number: (3+4j)
Real part: 3.0
Imaginary part: 4.0
Magnitude: 5.0

e^(ipi) = -1
Tiny imaginary part 1.22e-16 is just rounding error

Phase of (3+4j): 0.927 radians
That's 53.1 degrees

Guardrail: most functions in math do not accept complex numbers. If you might have complex values, use cmath (or NumPy’s complex-aware functions).

Complex numbers aren’t just mathematical abstractions — they’re essential for:

Fourier transforms (spectral analysis)
Quantum mechanics (wave functions)
Signal processing (interferometry)

Computational Thinking: Complex Numbers as 2D Vectors

Think of complex numbers as 2D vectors that know how to multiply:

Addition: vector addition
Multiplication: rotation and scaling
Magnitude: vector length
Phase: angle from positive real axis

This pattern — representing compound data as single objects with rich behavior — appears throughout scientific computing. Master this concept here, and you’ll recognize it everywhere!

Why This Matters: Fourier Transforms Reveal Hidden Periods

Complex numbers aren’t just mathematical elegance—they’re essential for discovering patterns in data! The Fourier transform, which relies entirely on complex exponentials, transforms time-series measurements into frequency space, revealing hidden periodicities.

Real Research Application:

Finding periodic signals in noisy data requires Fourier analysis:

# Simplified signal detection
import numpy as np

# Time series: signal over time
time = np.linspace(0, 100, 10000)  # 100 units
# Hidden signal: 3.5 unit period, small amplitude
signal = 1.0 - 0.0001 * np.cos(2*np.pi*time/3.5)
# Add noise
rng = np.random.default_rng(42)
noise = rng.normal(0, 0.0005, len(time))
data = signal + noise

# Fourier transform uses complex exponentials
frequencies = np.fft.fftfreq(len(time), time[1]-time[0])
fft = np.fft.fft(data - np.mean(data))
power = np.abs(fft)**2  # Complex magnitude squared

# Peak in power spectrum reveals hidden period!
peak_idx = np.argmax(power[1:len(power)//2]) + 1
detected_period = 1/frequencies[peak_idx]
print(f"Detected period: {detected_period:.2f}")

Every periodogram you’ll ever compute—whether finding oscillation modes, orbital periods, or rotation rates—depends on complex arithmetic.

The bottom line: Master complex numbers now, because every time-series analysis technique you’ll learn builds on them!

2.5 Variables and Dynamic Typing

Now that you understand how Python represents numbers, let’s see how it manages them! Variables in Python are names that refer to objects, not containers that hold values. This distinction matters:

stellar_mass: 1.99e+30 kg
solar_mass: 1.99e+30 kg
Same object? True
Numerically equal? True

After doubling stellar_mass:
stellar_mass: 3.98e+30 kg
solar_mass (unchanged): 1.99e+30 kg

Python is dynamically typed — variables can refer to any type of object:

Type: int, Value: 42
Type: float, Value: 42.0
Type: str, Value: 42 measurements

2.6 Strings and Scientific Output Formatting

Time to make your results shine! Clear output formatting isn’t just about aesthetics — it’s about scientific communication. The formatting skills you learn here will help you create publication-quality output.

Betelgeuse is 400 light-years away
Luminosity: 1.20e+05 Lsun

Format Specifications for Scientific Data

F-strings support sophisticated formatting perfect for scientific output:

Fixed-point (2 decimals): 1234.57
Scientific notation: 1.23e+03
Width 10, 2 decimals:    1234.57
Thousands separator: 1,235

Star        Magnitude   Distance (ly)
-------------------------------------
Sirius          -1.46             8.6
Canopus         -0.74           310.0
Arcturus        -0.05            37.0

Check Your Understanding

What will this print?

redshift = 0.00123456
print(f"z = {redshift:.2e}")

Predict the format before running it.

Solution:

This prints: z = 1.23e-03

The .2e format specifier means:

Use scientific notation (e)
Show 2 digits after the decimal point
Python automatically handles the exponent

So 0.00123456 becomes 1.23 $\times$ $10^{-3}$, displayed as 1.23e-03.

2.7 Type System and Conversions

Python’s type system strikes a perfect balance — flexible enough for rapid exploration but strong enough to catch errors. Understanding types and conversions is crucial for handling data from any source.

Type of 3.14159: float
Is it a float? True

Converted '2.718' to 2.718

int(3.9) = 3
round(3.9) = 4

Check Your Understanding

What happens when you convert -3.7 to an integer? Predict the result:

-4 (rounds to nearest integer)
-3 (truncates toward zero)
-3 (floors toward negative infinity)
Error

Solution:

The answer is b) -3 (truncates toward zero).

Python’s int() truncates toward zero, not toward negative infinity like floor division!

int(-3.7) = -3
-3.7 // 1 = -4.0

This inconsistency has caused numerous bugs in calculations where negative values represent positions before an epoch.

2.8 The Math Module: Your Scientific Calculator

Here comes the fun part — Python’s math module transforms your computer into a scientific calculator more powerful than anything that existed when we sent humans to the Moon!

pi = 3.141592653589793
e = 2.718281828459045
tau = 6.283185307179586

sin(30 deg) = 0.5000
cos(30 deg) = 0.8660

Flux ratio 100 = 5.0 magnitudes

Gamma(5) = 24.0 = 4!
Error function: erf(1) = 0.8427

exp(x)-1 naive: 1.000e-10
expm1(x) stable: 1.000e-10
log(1+y) naive: 1.000e-10
log1p(y) stable: 1.000e-10

hypot(3,4) = 5.0
sum(vals) = 0.0
math.fsum(vals) = 1.0

Remember: trigonometric functions use radians, not degrees! This is a constant source of bugs in scientific code.

2.9 From Interactive to Script

Congratulations! You’ve been exploring Python interactively, testing ideas and learning how numbers behave. Now let’s transform your interactive explorations into a reusable script:

#!/usr/bin/env python
"""
schwarzschild_radius.py
Calculate Schwarzschild radius with proper numerical handling.

Constants below are rounded for pedagogy. For high-precision work, use a
consistent constants set (e.g., CODATA via astropy.constants).
"""

import math

def schwarzschild_radius_simple(mass_kg):
    """Calculate Schwarzschild radius in m."""
    G = 6.67e-11   # m^3/kg/s^2
    c = 2.998e8    # m/s

    rs = 2 * G * mass_kg / c**2
    return rs

def schwarzschild_radius_validated(mass_kg):
    """Calculate with input validation."""
    G = 6.67e-11
    c = 2.998e8

    if mass_kg <= 0:
        raise ValueError(f"Mass must be positive: {mass_kg}")

    rs = 2 * G * mass_kg / c**2
    return rs

def schwarzschild_radius_robust(mass_kg):
    """Handle extreme masses using log space."""
    G = 6.67e-11
    c = 2.998e8

    if mass_kg <= 0:
        raise ValueError(f"Mass must be positive")

    # Use log space for extreme masses
    if mass_kg > 1e45:  # Galaxy cluster scale
        log_rs = math.log10(2*G) + math.log10(mass_kg) - 2*math.log10(c)
        return 10**log_rs

    return 2 * G * mass_kg / c**2

# Test our functions
if __name__ == "__main__":
    test_masses = {
        "Earth": 5.972e24,
        "Sun": 1.989e30,
        "Sgr A*": 8.2e36,
    }

    for name, mass in test_masses.items():
        rs = schwarzschild_radius_robust(mass)
        print(f"{name}: Rs = {rs:.2e} m ({rs/1e3:.2f} km)")

Main Takeaways

You’ve just built the foundation for all numerical computing you’ll ever do. The seemingly simple act of adding two numbers opens a universe of complexity that affects every calculation from simulations to data analysis. The key insight isn’t that floating-point arithmetic is broken — it’s that it’s approximate by design, and understanding these approximations separates successful computational scientists from those who publish retracted papers due to numerical errors.

The defensive programming techniques you learned here might seem overcautious at first, but they’re battle-tested practices from real scientific software. That safe_divide function has prevented countless divide-by-zero errors in production code. The validation checks have caught bugs that would have wasted weeks of supercomputer time. Working in log space isn’t just a clever trick — for many calculations spanning extreme scales, it’s the only way to get meaningful answers.

Perhaps most importantly, you’ve learned to think about numbers the way computers do. When you see 0.1 + 0.2, you now know it’s not exactly 0.3, and more crucially, you know why. When you calculate values over many orders of magnitude, you instinctively think about whether the number might overflow. When you subtract two nearly-equal values, alarm bells ring about catastrophic cancellation. This numerical awareness will serve you throughout your career.

Key Takeaways

✓ Floating-point arithmetic is approximate by design — never use == to compare floats

✓ Machine epsilon (~2.2e-16) sets the fundamental precision limit for calculations

✓ Catastrophic cancellation occurs when subtracting nearly equal numbers — use mathematical identities

✓ Work in log space to handle extreme scales without overflow/underflow

✓ Python integers have unlimited precision but use more memory than floats

✓ Variables are references to objects, not containers holding values

✓ Defensive programming with validation prevents numerical disasters

✓ F-strings provide powerful formatting for scientific output

✓ Complex numbers are essential for wave physics and spectral analysis

✓ Always use radians with trigonometric functions

✓ Type conversion can lose information — always validate

Quick Reference Tables

Math Module Functions

Mathematical Constants

import math

math.pi - $\pi$ (3.14159…)
math.e - Euler’s number (2.71828…)
math.tau - $\tau$ = 2$\pi$ (6.28318…)

Arithmetic Functions

math.sqrt(x) - Square root
math.log(x) - Natural logarithm
math.log1p(x) - log(1+x) accurate for small x
math.log10(x) - Base-10 logarithm
math.exp(x) - Exponential (e^x)
math.expm1(x) - exp(x)-1 accurate for small x
math.hypot(x, y) - Stable sqrt(x^2 + y^2)
math.fsum(iterable) - Stable summation of many floats

Trigonometric Functions (use radians!)

math.sin(x), math.cos(x), math.tan(x) - Basic trig
math.radians(degrees) - Convert degrees to radians
math.degrees(radians) - Convert radians to degrees

Special Functions

math.gamma(x) - Gamma function
math.erf(x) - Error function
math.isclose(a, b, rel_tol=1e-9) - Safe float comparison
math.isfinite(x) - Check if finite (not inf or nan)
math.isnan(x) - Check if Not-a-Number

F-String Format Specifiers

Format	Meaning	Example	Result
`:.2f`	Fixed decimal	`f"{3.14159:.2f}"`	`3.14`
`:.2e`	Scientific notation	`f"{1234:.2e}"`	`1.23e+03`
`:10.2f`	Width and decimals	`f"{3.14:10.2f}"`	`3.14`
`:,.0f`	Thousands separator	`f"{1234567:,.0f}"`	`1,234,567`
`:<10`	Left align	`f"{'test':<10}"`	`test`
`:>10`	Right align	`f"{'test':>10}"`	`test`
`:^10`	Center align	`f"{'test':^10}"`	`test`

Type Checking and Conversion

Function	Purpose	Example
`type(x)`	Get object type	`type(3.14)` $\to$ `<class 'float'>`
`isinstance(x, type)`	Check type	`isinstance(3.14, float)` $\to$ `True`
`float(x)`	Convert to float	`float("3.14")` $\to$ `3.14`
`int(x)`	Convert to int (truncates!)	`int(3.9)` $\to$ `3`
`complex(r, i)`	Create complex	`complex(3, 4)` $\to$ `(3+4j)`
`round(x, n)`	Round to n decimals	`round(3.14159, 2)` $\to$ `3.14`

Next Chapter Preview

Armed with a deep understanding of Python’s numeric types and the perils of floating-point arithmetic, you’re ready for Chapter 3: Control Flow & Logic. You’ll learn to make your code dynamic with if-statements and loops, building algorithms that can adapt to data and iterate until convergence. The numerical foundations from this chapter become essential when you’re checking whether a calculation has converged, comparing values within tolerance, or detecting numerical instabilities in your simulations. Get ready to transform static calculations into intelligent algorithms that can make decisions and repeat tasks — the essence of computational thinking.

Learning Objectives

Prerequisites Check

Chapter Overview

2.1 Python as Your Scientific Calculator

Operator Precedence: A Source of Real Bugs

Complete Arithmetic Operators

2.2 How Python Stores Numbers: Critical for Scientific Computing

Integers: Arbitrary Precision Power

Floating-Point Numbers: The Heart of Numerical Computing

Understanding Bits and Precision

Single vs Double Precision: The 32-bit vs 64-bit Choice

Why 0.1 + 0.2 \(\neq\) 0.3

Machine Epsilon: The Smallest Distinguishable Difference

Safe Floating-Point Comparisons

2.3 Numerical Hazards in Scientific Computing

Catastrophic Cancellation: When Subtraction Destroys Precision

Overflow and Underflow in Extreme Scales

Defensive Programming with Numerical Checks

2.4 Complex Numbers for Wave Physics

2.5 Variables and Dynamic Typing

2.6 Strings and Scientific Output Formatting

Format Specifications for Scientific Data

2.7 Type System and Conversions

2.8 The Math Module: Your Scientific Calculator

2.9 From Interactive to Script

Main Takeaways

Key Takeaways

Quick Reference Tables

Math Module Functions

F-String Format Specifiers

Type Checking and Conversion

Next Chapter Preview