Exponentials
Contents
Exponentials#
An exponential, generally speaking, is an expression of the form \(c^x\) for some constant \(c\), and should be read as “\(c\) to the \(x\)th power”. Note that this is different from powers \(x^n\), in that exponentials keep the base \(c\) fixed and vary \(x\), while powers do the opposite.
Example
\(2^x \neq x^2\).
Often, when we refer to an exponential, we really mean a specific base \(e = 2.71828\dots\), known alternately as “Euler’s number”, or “the base of the natural logarithm”.
Rules for working with exponentials#
The following rules (properties) are useful when manipulating expressions involving exponentials. All of these rules work for any base \(c \neq 0\), including the special case \(c=e\).
Any \(c\) raised to the 0 power is 1, and specifically:
(Exponentials turn negatives into inverses:)
(Exponentials turn sums into products:)
(Exponentials turn products into powers:)
The exponential function#
While it is convenient to regard \(e\) as the number \(2.71828\dots\), there is an alternative (and more general) definition for \(e\) given by the following infinite summation
where
is the factorial function: the product of numbers 1 through \(n\). (We define the special case \(0! = 1\).)
The exponential function \(e^x\), sometimes also written \(\exp(x)\), is equivalent to the number \(e\) raised to the \(x\)th power.
Note that summation in (1) depends on infinitely many terms, and is not something you could explicitly compute. While this could be a problem in some cases, it’s okay here because the terms diminish quite rapidly:
and the summation converges to Euler’s number. Proving this sort of thing is out of scope for us here, but we can simulate it computationally by printing out the first few partial sums with a bit of python code.
import numpy as np
from scipy.special import factorial
# Initialize the partial sum
e_partial = 0.0
for n in range(15):
# Add in 1/n!
e_partial += 1.0/factorial(n)
print('First {:2d} term(s): {:0.12f}'.format(n+1, e_partial))
# Print the actual constant to 12 decimals
print('---')
print("Euler's constant: {:0.12f}".format(np.e))
First 1 term(s): 1.000000000000
First 2 term(s): 2.000000000000
First 3 term(s): 2.500000000000
First 4 term(s): 2.666666666667
First 5 term(s): 2.708333333333
First 6 term(s): 2.716666666667
First 7 term(s): 2.718055555556
First 8 term(s): 2.718253968254
First 9 term(s): 2.718278769841
First 10 term(s): 2.718281525573
First 11 term(s): 2.718281801146
First 12 term(s): 2.718281826198
First 13 term(s): 2.718281828286
First 14 term(s): 2.718281828447
First 15 term(s): 2.718281828458
---
Euler's constant: 2.718281828459
After only 15 terms of the summation, we already have a quite good approximation to \(e\) (accurate to 11 decimal places).
This definition of \(e\) as an infinite summation can be generalized to depend on an arbitrary exponent \(x\):
where the first definition can be recovered by setting \(x=1\) in the second equation.
While we rarely work with this form directly, it is useful because it provides a way to generalize the exponential to support complex exponents \(e^z\) for \(z\in\mathbb{C}\).
Logarithms#
Logarithms are the inverse of exponentials, similar to how square-root is the inverse of squaring. In general, logarithms have a “base” \(b > 0\), and define the following relationship for input \(x > 0\):
Intuitively, \(\log_b x\) measures the power \(y\) we would need to raise \(b\) to produce \(x\).
When \(x = 0\), there is no finite number \(y\) such that \(b^y = 0\), and we say \(\log_b x = -\infty\).
The base can be any positive number, but among all logarithms, the natural logarithm (denoted \(\ln\)) uses \(e\) as the base:
Other common choices for the base are \(b=2\) and \(b=10\). In these cases, \(\log_2 x\) and \(\log_{10} x\) can be roughly thought of as measuring the “number” of bits (for \(b=2\)) or digits (for \(b=10\)) needed to represent a number \(x\).
Properties of logarithms#
For any base \(b > 0\), \(\log_b 1 = 0\).
This is just another way of writing \(b^0 = 1\).
For any base \(b>0\), \(\log_b b = 1\).
This is another way of saying that \(b^1 = b\).
\(\log_b x = \frac{\ln x}{\ln b}\)
This rule lets us convert between different logarithm bases.
For any \(x\) and \(y\), \(\log_b(x\cdot y) = \log_b(x) + \log_b(y)\).
This rule allows us to turn products into sums, which can often be computed more easily and with greater precision.
As a corollary, we also get the analogous rule for ratios: \(\log_b(x/y) = \log_b(x) - \log_b(y)\).
For any \(k\), \(\log_b(x^k) = k \cdot \log_b x\).
This is just a slight generalization of rule 4, allowing us to turn powers into products. Note that \(k\) need not be an integer, or positive: it works for any real number!
In particular, we have \(\log_b \frac{1}{x} = \log_b \left(x^{-1}\right) = -\log_b x\).
\(b^{\log_b x} = x\).
This is just notation that says \(b^x\) and \(\log_b x\) are mutual inverses.