#5. Math: log, exp

Logarithms

import math
import numpy as np
# natural log (base e)
math.log(1)      # 0.0
math.log(math.e) # 1.0
math.log(10)     # 2.302

# log base 10
math.log10(100)  # 2.0
math.log10(1000) # 3.0
# log base 2
math.log2(8)     # 3.0
math.log2(1024)  # 10.0

# custom base
math.log(81, 3)  # 4.0 — log base 3 of 81

# on arrays
np.log(np.array([1, 10, 100]))    # [0., 2.30, 4.60]
np.log10(np.array([1, 10, 100]))  # [0., 1., 2.]
np.log2(np.array([1, 2, 4, 8]))   # [0., 1., 2., 3.]

Exponents

# e^x
math.exp(0)  # 1.0
math.exp(1)  # 2.718
math.exp(2)  # 7.389

# power operator
2 ** 8        # 256
2 ** 0.5      # 1.414 — square root
math.pow(3, 4) # 81.0

# on arrays
np.exp(np.array([0, 1, 2, 3]))
# [1., 2.718, 7.389, 20.08]

np.power(np.array([2, 3, 4]), 3)
# [8, 27, 64]

Square & cube roots

math.sqrt(25)   # 5.0
math.sqrt(2)    # 1.414
25 ** 0.5       # 5.0 — same thing
8  ** (1/3)     # 2.0 — cube root
np.sqrt(np.array([4, 9, 16, 25]))
# [2., 3., 4., 5.]

Absolute value

abs(-7)          # 7
math.fabs(-3.5)  # 3.5 — always returns float
np.abs(np.array([-3, -1, 0, 2, -5]))
# [3, 1, 0, 2, 5]

Rounding

round(3.567)     # 4
round(3.567, 2)  # 3.57
math.floor(3.9)  # 3 — always down
math.ceil(3.1)   # 4 — always up
math.trunc(3.9)  # 3 — toward zero

np.round(np.array([1.234, 5.678]), 2)
# [1.23, 5.68]
np.floor(np.array([1.9, 2.1, 3.5]))
# [1., 2., 3.]

Trigonometry

math.sin(math.pi / 2)   # 1.0
math.cos(0)             # 1.0
math.tan(math.pi / 4)   # 1.0

# convert degrees ↔ radians
math.radians(180)        # 3.14159
math.degrees(math.pi)   # 180.0

# on arrays — useful for signal processing, Fourier
angles = np.array([0, 30, 60, 90])
np.sin(np.radians(angles))
# [0., 0.5, 0.866, 1.]

Factorial & combinatorics

math.factorial(5)   # 120
math.factorial(10)  # 3628800
math.comb(10, 3)    # 120 — combinations (order doesn't matter)
math.perm(10, 3)    # 720 — permutations (order matters)

Basics with math module

import math
math.sqrt(16)    # 4.0
math.pow(2, 10)  # 1024.0
2 ** 10          # 1024 — same, more pythonic
math.exp(1)      # e^1 = 2.718...

math.log(math.e) # 1.0  — natural log (base e)
math.log(100, 10)# 2.0  — log base 10
math.log2(8)     # 3.0  — log base 2
math.log10(1000) # 3.0

Constants

math.pi    # 3.14159...
math.e     # 2.71828...
math.inf   # infinity
math.nan   # not a number
Rounding
math.floor(3.9)  # 3 — round down
math.ceil(3.1)   # 4 — round up
round(3.567, 2)  # 3.57
abs(-7)          # 7

Numpy math on arrays (the DS way)

import numpy as np
a = np.array([1, 2, 3, 4])
np.sqrt(a)       # [1., 1.41, 1.73, 2.]
np.exp(a)        # [e, e^2, e^3, e^4]
np.log(a)        # natural log element-wise
np.log2(a)
np.log10(a)
np.power(a, 3)   # [1, 8, 27, 64]
np.abs(a)

Clipping values

a = np.array([-3, 0, 5, 10, 99])
np.clip(a, 0, 10)  # [0, 0, 5, 10, 10]
# useful for capping outliers or keeping values in range

Sigmoid (used everywhere in ML)

def sigmoid(x):
    return 1 / (1 + np.exp(-x))
sigmoid(0)    # 0.5
sigmoid(2)    # 0.88
sigmoid(-2)   # 0.12
# squashes any value into (0, 1)

Softmax (multi-class probabilities)

def softmax(x):
    e = np.exp(x - np.max(x))  # subtract max for stability
    return e / e.sum()
softmax(np.array([1.0, 2.0, 3.0]))
# [0.09, 0.24, 0.67] — sums to 1.0

Log loss (cross-entropy)

y_true = np.array([1, 0, 1])
y_pred = np.array([0.9, 0.1, 0.8])
loss = -np.mean(y_true * np.log(y_pred) + (1 - y_true) * np.log(1 - y_pred))
# 0.164 — lower is better

Normalization

a = np.array([10, 20, 30, 40])
# min-max → [0, 1]
(a - a.min()) / (a.max() - a.min())
# [0., 0.33, 0.67, 1.]
# z-score → mean=0, std=1
(a - a.mean()) / a.std()
# [-1.34, -0.45, 0.45, 1.34]

Factorial & combinations

math.factorial(5)       # 120
math.comb(10, 3)        # 120 — "10 choose 3"
math.perm(10, 3)        # 720 — permutations

Working with infinity and NaN

math.isinf(math.inf)   # True
math.isnan(math.nan)   # True
np.isnan(np.array([1, np.nan, 3]))  # [False, True, False]