In [1]:
import numpy as np
import matplotlib.pyplot as plt
from sympy import *
%matplotlib inline
init_printing()
In [2]:
def f(x):
return np.exp(np.sin(x))
def df(x):
return f(x) * np.cos(x)
def absolute_err(f, df, h):
g = (f(h) - f(0)) / h
return np.abs(df(0) - g)
hs = 10. ** -np.arange(15)
epsilons = np.empty(15)
for i, h in enumerate(hs):
epsilons[i] = absolute_err(f, df, h)
In [3]:
plt.plot(hs, epsilons, 'o')
plt.yscale('log')
plt.xscale('log')
plt.xlabel(r'h')
plt.ylabel(r'$\epsilon(h)$')
plt.grid(linestyle='dotted')
We can see that until $h = 10^7$ the trend is that the absolute error diminishes, but after that it goes back up. This is due to the fact that when we compute $f(h) - f(0)$ we are using an ill-conditioned operation. In fact these two values are really close to each other.
In [4]:
x_1 = symbols('x_1')
fun1 = 1 / (1 + 2*x_1) - (1 - x_1) / (1 + x_1)
fun1
Out[4]:
We can modify the previous expression for being well conditioned around 0. This is well conditoned.
In [5]:
fun2 = simplify(fun1)
fun2
Out[5]:
A comparison between the two ways of computing this value. we can clearly see that if we are far from 1 the methods are nearly identical, but the closer you get to 0 the two methods diverge
In [6]:
def f1(x):
return 1 / (1 + 2*x) - (1 - x) / (1 + x)
def f2(x):
return 2*x**2/((1 + 2*x)*(1 + x))
hs = 2. ** - np.arange(64)
plt.plot(hs, np.abs(f1(hs) - f2(hs)))
plt.yscale('log')
plt.xscale('log')
plt.xlabel(r'h')
plt.ylabel('differences')
plt.grid(linestyle='dotted')
As before we have the subtraction of two really close values, so it is going to be ill conditioned for $x$ really big.
$ \sqrt{x + \frac{1}{x}} - \sqrt{x - \frac{1}{x}} = \sqrt{x + \frac{1}{x}} - \sqrt{x - \frac{1}{x}} \frac{\sqrt{x + \frac{1}{x}} + \sqrt{x - \frac{1}{x}} }{\sqrt{x + \frac{1}{x}} + \sqrt{x - \frac{1}{x}}} = \frac{2}{x(\sqrt{x + \frac{1}{x}} + \sqrt{x - \frac{1}{x}})}$
In [7]:
def f3(x):
return np.sqrt(x + 1/x) - np.sqrt(x - 1 / x)
def f4(x):
return 2 / (np.sqrt(x + 1/x) + np.sqrt(x - 1 / x)) / x
hs = 2 ** np.arange(64)
plt.plot(hs, np.abs(f3(hs) - f4(hs)), 'o')
#plt.plot(hs, , 'o')
plt.yscale('log')
plt.xscale('log')
plt.xlabel(r'h')
plt.ylabel('differences$')
plt.grid(linestyle='dotted')
If we assume we posess a 6 faced dice, we have at each throw three possible outcome. So we have to take all the combination of 6 numbers repeating 3 times. It is intuitive that our $\Omega$ will be composed by $6^3 = 216$ samples, and will be of type: $(1, 1, 1), (1, 1, 2), (1, 1, 3), ... (6, 6, 5), (6, 6, 6)$
In [8]:
import itertools
x = [1, 2, 3, 4, 5, 6]
omega = set([p for p in itertools.product(x, repeat=3)])
print(r'Omega has', len(omega), 'elements and they are:')
print(omega)
Concerning the $\sigma$-algebra we need to state that there does not exist only a $\sigma$-algebra for a given $\Omega$, but it this case a reasonable choice would be the powerset of $\Omega$.
In [9]:
1/(6**3)
Out[9]:
If we want to determine the set $A$ we can take in consideration its complementary $A^c = \{\text{Not even one throw is 6}\}$. This event is analogous the sample space of a 5-faced dice. So it's dimension will be $5^3$. For computing the size of $A$ we can simply compute $6^3 - 5^3$ and for the event its self we just need to $\Omega \setminus A^c = A$
In [10]:
print('Size of A^c:', 5**3)
print('Size of A: ', 6 ** 3 - 5 ** 3)
In [11]:
36 + 5 * 6 + 5 * 5
Out[11]:
In [12]:
x = [1, 2, 3, 4, 5]
A_c = set([p for p in itertools.product(x, repeat=3)])
print('A^c has ', len(A_c), 'elements.\nA^c =', A_c)
print('A has ', len(omega - A_c), 'elements.\nA^c =', omega - A_c)
P(A) will be $\frac{91}{216}$
In [13]:
91 / 216
Out[13]:
In [ ]: