Chapter 36 — Scientific Notation

# --- Visualization: Scale of the universe on a logarithmic axis ---
import numpy as np
import matplotlib.pyplot as plt

plt.style.use('seaborn-v0_8-whitegrid')

# Physical quantities with their approximate scales (in meters or kg or seconds)
objects = {
    'Proton radius':     1e-15,
    'Hydrogen atom':     1e-10,
    'DNA helix width':   2e-9,
    'Virus':             1e-7,
    'Red blood cell':    8e-6,
    'Human hair':        1e-4,
    'Ant':               1e-3,
    'Human':             1.8,
    'Mount Everest':     8.8e3,
    'Earth radius':      6.4e6,
    'Earth-Moon':        3.8e8,
    'Earth-Sun':         1.5e11,
    'Light-year':        9.5e15,
    'Milky Way':         1e21,
    'Observable universe': 8.8e26,
}

names = list(objects.keys())
values = list(objects.values())
log_values = np.log10(values)

fig, ax = plt.subplots(figsize=(14, 6))
colors = plt.cm.plasma(np.linspace(0.1, 0.9, len(names)))

for i, (name, lv, color) in enumerate(zip(names, log_values, colors)):
    ax.scatter(lv, 0, s=120, color=color, zorder=3)
    ax.annotate(name, (lv, 0),
                textcoords='offset points',
                xytext=(0, 15 if i % 2 == 0 else -25),
                ha='center', fontsize=7.5, rotation=30,
                arrowprops=dict(arrowstyle='-', color='gray', lw=0.5))

ax.axhline(0, color='k', linewidth=0.8)
ax.set_xlabel('log₁₀(size in meters)', fontsize=11)
ax.set_title('Scale of the Universe — 42 orders of magnitude on one axis', fontsize=12)
ax.set_yticks([])
ax.set_xlim(-16, 28)

# Add scale labels at every 5 orders
for exp in range(-15, 28, 5):
    ax.axvline(exp, color='lightgray', linewidth=0.5, linestyle='--')
    ax.text(exp, -0.03, f'10^{exp}', ha='center', va='top', fontsize=8, color='gray')

plt.tight_layout()
plt.show()

# --- Implementation: Scientific notation tools ---
import math
import struct

def to_scientific(x, sig_figs=4):
    """
    Convert x to (mantissa, exponent) in base 10.

    Args:
        x: nonzero float
        sig_figs: significant figures to keep

    Returns:
        (mantissa, exponent) such that x ≈ mantissa × 10^exponent
    """
    if x == 0:
        return 0.0, 0
    e = math.floor(math.log10(abs(x)))
    m = x / 10**e
    m = round(m, sig_figs - 1)  # round to sig_figs significant figures
    return m, e


def order_of_magnitude(x):
    """Return floor(log_10(|x|)) for x > 0."""
    return math.floor(math.log10(abs(x)))


def float64_bits(x):
    """
    Decompose float64 x into (sign, biased_exponent, mantissa_bits).
    Returns the actual exponent (unbiased) and mantissa value (including implicit 1).
    """
    bits = struct.unpack('Q', struct.pack('d', x))[0]  # 64-bit integer
    sign     = (bits >> 63) & 1
    exp_bits = (bits >> 52) & 0x7FF
    mant_bits = bits & ((1 << 52) - 1)

    exponent = exp_bits - 1023  # remove bias
    mantissa = 1 + mant_bits / (1 << 52)  # implicit leading 1
    return sign, exponent, mantissa, mant_bits


# Demonstrations
test_values = [1.0, 0.1, 3.14159, 6.022e23, 1.6e-19, -42.0]

print("Scientific notation:")
for x in test_values:
    m, e = to_scientific(x)
    print(f"  {x:>15g}  →  {m} × 10^{e}")

print("\nIEEE 754 decomposition:")
for x in [1.0, 0.1, 0.5, 1/3]:
    sign, exp, mant, mant_bits = float64_bits(x)
    reconstructed = (-1)**sign * mant * 2**exp
    print(f"  {x}:  sign={sign}, exp={exp}, mant={mant:.10f}")
    print(f"    → (-1)^{sign} × {mant:.6f} × 2^{exp} = {reconstructed}")
    print(f"    mantissa bits (hex): 0x{mant_bits:013X}")

# --- Experiment 1: Arithmetic with extreme-scale numbers ---
# Hypothesis: When adding two numbers of very different scales, the smaller
#             contribution is lost due to finite mantissa precision.
# Try changing: LARGE and SMALL to see when the small number disappears.

LARGE = 1e16   # <-- modify
SMALL = 1.0    # <-- modify

result = LARGE + SMALL
recovered_small = result - LARGE

print(f"LARGE = {LARGE:.2e}")
print(f"SMALL = {SMALL:.2e}")
print(f"LARGE + SMALL = {result:.2e}")
print(f"(LARGE + SMALL) - LARGE = {recovered_small}  (should be {SMALL})")
print(f"SMALL is {'lost' if recovered_small != SMALL else 'preserved'}")

print(f"\nOrders of magnitude difference: {order_of_magnitude(LARGE) - order_of_magnitude(SMALL)}")
print("Float64 has ~15-16 significant digits — difference > 15 OOM loses the smaller number.")

# --- Experiment 2: Counting significant figures ---
# Hypothesis: multiplication and division preserve relative precision,
#             while addition/subtraction can destroy it (catastrophic cancellation).

# Near-equal subtraction: catastrophic cancellation
a = 1.0000000123456789
b = 1.0000000000000000

diff = a - b
print(f"a = {a:.16f}")
print(f"b = {b:.16f}")
print(f"a - b = {diff}")

# The true difference is ~1.23456789e-8
# But we only have ~8 significant figures left after subtraction
# because the first 8 digits cancelled out

print("\n--- Relative errors ---")
x = 1.23456789
print(f"x = {x}")
print(f"x * 2 / 2 = {x * 2 / 2}  (multiplication then division — exact)")
print(f"(x + 1e15) - 1e15 = {(x + 1e15) - 1e15}  (add then subtract large — LOSES precision)")

# --- Mini Project: Physical Constants Calculator ---
import math
import numpy as np
import matplotlib.pyplot as plt

# Physical constants (SI units)
CONSTANTS = {
    'c':   2.998e8,    # speed of light (m/s)
    'G':   6.674e-11,  # gravitational constant (N m^2 / kg^2)
    'h':   6.626e-34,  # Planck constant (J s)
    'k_B': 1.380e-23,  # Boltzmann constant (J/K)
    'e':   1.602e-19,  # elementary charge (C)
    'N_A': 6.022e23,   # Avogadro constant (mol^-1)
    'm_e': 9.109e-31,  # electron mass (kg)
    'm_p': 1.673e-27,  # proton mass (kg)
}

def with_oom(x, name=''):
    """Print value with order-of-magnitude annotation."""
    oom = math.floor(math.log10(abs(x))) if x != 0 else 0
    m = x / 10**oom
    label = f"{name}: " if name else ""
    print(f"  {label}{m:.4f} × 10^{oom}")
    return x


# Formula 1: kinetic energy of a baseball at 100 km/h
# E = 0.5 * m * v^2
m_baseball = 0.145   # kg
v_baseball  = 100 / 3.6  # m/s
E_baseball  = 0.5 * m_baseball * v_baseball**2
print("Kinetic energy of baseball at 100 km/h:")
with_oom(E_baseball, 'E')

# Formula 2: gravitational force between Earth and Moon
# F = G * M * m / r^2
M_earth = 5.972e24   # kg
M_moon  = 7.342e22   # kg
r_em    = 3.844e8    # m
F_grav  = CONSTANTS['G'] * M_earth * M_moon / r_em**2
print("\nGravitational force Earth-Moon:")
with_oom(F_grav, 'F')

# Formula 3: de Broglie wavelength of an electron at thermal velocity
# λ = h / (m_e * v), where v = sqrt(3 k_B T / m_e)
T = 300  # K (room temperature)
v_thermal = math.sqrt(3 * CONSTANTS['k_B'] * T / CONSTANTS['m_e'])
lambda_dB  = CONSTANTS['h'] / (CONSTANTS['m_e'] * v_thermal)
print("\nde Broglie wavelength of thermal electron at 300 K:")
with_oom(lambda_dB, 'λ')
print(f"  (compare: hydrogen atom size ~1e-10 m = 1 Ångström)")

# Visualization: energy scales
energy_scales = {
    'Thermal energy (300K)': CONSTANTS['k_B'] * 300,
    'Photon (visible light)': CONSTANTS['h'] * 5e14,
    'Baseball at 100 km/h':  E_baseball,
    'Chemical bond':         4e-19,
    'Food calorie':          4184,
    'TNT (1 ton)':           4.2e9,
    'Hiroshima bomb':        6.3e13,
    'Sun annual output':     1.2e34,
}

fig, ax = plt.subplots(figsize=(12, 5))
names = list(energy_scales.keys())
log_vals = [math.log10(v) for v in energy_scales.values()]
colors = plt.cm.RdYlGn(np.linspace(0.1, 0.9, len(names)))

ax.barh(range(len(names)), log_vals, color=colors, edgecolor='white')
ax.set_yticks(range(len(names)))
ax.set_yticklabels(names, fontsize=9)
ax.set_xlabel('log₁₀(Energy in Joules)', fontsize=11)
ax.set_title('Energy Scales (45 orders of magnitude)', fontsize=12)

for i, (name, lv) in enumerate(zip(names, log_vals)):
    ax.text(lv + 0.3, i, f'10^{lv:.0f} J', va='center', fontsize=8)

plt.tight_layout()
plt.show()