def test_wide_sense_distr(self): std_wide_sense_1d = distrs.WideSenseDistr(dim=1) npt.assert_almost_equal(std_wide_sense_1d.mean, 0.) npt.assert_almost_equal(std_wide_sense_1d.cov, 1.) npt.assert_almost_equal(std_wide_sense_1d.vol, 1.) with self.assertRaises(NotImplementedError): std_wide_sense_1d.sample() std_wide_sense_2d = distrs.WideSenseDistr(dim=2) npt.assert_almost_equal(std_wide_sense_2d.mean, npu.col_of(2, 0.)) npt.assert_almost_equal(std_wide_sense_2d.cov, np.eye(2)) npt.assert_almost_equal(std_wide_sense_2d.vol, np.eye(2)) with self.assertRaises(NotImplementedError): std_wide_sense_2d.sample() sd1=3.; sd2=4.; cor=-.5 wide_sense_2d = distrs.WideSenseDistr(mean=[1., 2.], cov=stats.make_cov_2d(sd1=sd1, sd2=sd2, cor=cor)) npt.assert_almost_equal(wide_sense_2d.mean, npu.col(1., 2.)) npt.assert_almost_equal(wide_sense_2d.cov, [[sd1*sd1, cor*sd1*sd2], [cor*sd1*sd2, sd2*sd2]]) npt.assert_almost_equal(wide_sense_2d.vol, [[sd1, 0.], [cor*sd2, np.sqrt(1.-cor*cor)*sd2]]) with self.assertRaises(NotImplementedError): wide_sense_2d.sample() wide_sense_2d = distrs.WideSenseDistr(mean=[1., 2.], vol=stats.make_vol_2d(sd1=sd1, sd2=sd2, cor=cor)) npt.assert_almost_equal(wide_sense_2d.mean, npu.col(1., 2.)) npt.assert_almost_equal(wide_sense_2d.cov, [[sd1*sd1, cor*sd1*sd2], [cor*sd1*sd2, sd2*sd2]]) npt.assert_almost_equal(wide_sense_2d.vol, [[sd1, 0.], [cor*sd2, np.sqrt(1.-cor*cor)*sd2]]) with self.assertRaises(NotImplementedError): wide_sense_2d.sample()
def test_euler_maruyama(self): rnd.random_state(np.random.RandomState(seed=42), force=True) W = proc.WienerProcess.create_2d(mean1=-.5, mean2=3., sd1=3., sd2=4., cor=.5) em = sim.EulerMaruyama(process=W) t, v = next(em) npt.assert_almost_equal(t, 0.) npt.assert_almost_equal(v, npu.col(0.0, 0.0)) t, v = next(em) npt.assert_almost_equal(t, 1.) npt.assert_almost_equal(v, npu.col(0.9901425, 3.5144667))
def testnrow(self): r = npu.row(429., 5., 2., 14.) self.assertEqual(npu.nrow(r), 1) c = npu.col(429., 5., 2., 14.) self.assertEqual(npu.nrow(c), 4) m = npu.matrixof(3, 5, 0.) self.assertEqual(npu.nrow(m), 3)
def test_ncol(self): r = npu.row(429., 5., 2., 14.) self.assertEqual(npu.ncol(r), 4) c = npu.col(429., 5., 2., 14.) self.assertEqual(npu.ncol(c), 1) m = npu.matrix_of(3, 5, 0.) self.assertEqual(npu.ncol(m), 5)
def _propagate_distr_impl(self, distr0, time_delta, assume_distr=False): if not isinstance(distr0, distrs.LogNormalDistr) and not assume_distr: raise ValueError('Do not know how to propagate a distribution that is not log-normal') # Note: the sum of two independent log-normal distributions is only approximately log-normal mean = np.log(distr0.mean) + (self._pct_drift - .5 * npu.col([self._pct_cov[i, i] for i in range(self.process_dim)])) * time_delta cov = distr0.cov + time_delta * self._pct_cov return distrs.LogNormalDistr(mean_of_log=mean, cov_of_log=cov)
def test_vec_and_unvec(self): a = np.array([[ 5., 1., 14., 2., 42.], [132., 2., 429., 1., 1.], [ 1., 2., 1430., 2., 2.]]) b = npu.col(5., 132., 1., 1., 2., 2., 14., 429., 1430., 2., 1., 2., 42., 1., 2.) npt.assert_almost_equal(npu.vec(a), b) npt.assert_almost_equal(npu.unvec(b, 3), a)
def propagate(self, time, variate, time0, value0, state0=None): if time == time0: return npu.to_ndim_2(value0, ndim_1_to_col=True, copy=True) value0 = npu.to_ndim_2(value0, ndim_1_to_col=True, copy=False) variate = npu.to_ndim_2(variate, ndim_1_to_col=True, copy=False) time_delta = time - time0 return value0 * np.exp( (self._pct_drift - .5 * npu.col(*np.sum(self._pct_vol**2, axis=1))) * time_delta + \ np.dot(self._pct_vol, np.sqrt(time_delta) * variate))
def __init__(self, mean_of_log=None, cov_of_log=None, vol_of_log=None, dim=None, copy=True): if mean_of_log is not None and dim is not None and np.size(mean_of_log) == 1: mean_of_log = npu.col_of(dim, npu.to_scalar(mean_of_log)) if mean_of_log is None and vol_of_log is None and cov_of_log is None: self._dim = 1 if dim is None else dim mean_of_log = npu.col_of(self._dim, 0.) cov_of_log = np.eye(self._dim) vol_of_log = np.eye(self._dim) self._dim, self._mean_of_log, self._vol_of_log, self._cov_of_log = None, None, None, None # TODO We don't currently check whether cov_of_log and vol_of_log are consistent, i.e. that cov_of_log = np.dot(vol_of_log, vol_of_log.T) -- should we? if mean_of_log is not None: self._mean_of_log = npu.to_ndim_2(mean_of_log, ndim_1_to_col=True, copy=copy) self._dim = npu.nrow(self._mean_of_log) if cov_of_log is not None: self._cov_of_log = npu.to_ndim_2(cov_of_log, ndim_1_to_col=True, copy=copy) self._dim = npu.nrow(self._cov_of_log) if vol_of_log is not None: self._vol_of_log = npu.to_ndim_2(vol_of_log, ndim_1_to_col=True, copy=copy) self._dim = npu.nrow(self._vol_of_log) if self._mean_of_log is None: self._mean_of_log = npu.col_of(self._dim, 0.) if self._cov_of_log is None and self._vol_of_log is None: self._cov_of_log = np.eye(self._dim) self._vol_of_log = np.eye(self._dim) npc.check_col(self._mean_of_log) npc.check_nrow(self._mean_of_log, self._dim) if self._cov_of_log is not None: npc.check_nrow(self._cov_of_log, self._dim) npc.check_square(self._cov_of_log) if self._vol_of_log is not None: npc.check_nrow(self._vol_of_log, self._dim) if self._cov_of_log is None: self._cov_of_log = stats.vol_to_cov(self._vol_of_log) if self._vol_of_log is None: self._vol_of_log = stats.cov_to_vol(self._cov_of_log) npu.make_immutable(self._mean_of_log) npu.make_immutable(self._cov_of_log) npu.make_immutable(self._vol_of_log) mean = np.exp(self._mean_of_log + .5 * npu.col(*[self._cov_of_log[i,i] for i in range(self._dim)])) cov = np.array([[np.exp(self._mean_of_log[i,0] + self._mean_of_log[j,0] + .5 * (self._cov_of_log[i,i] + self._cov_of_log[j,j])) * (np.exp(self._cov_of_log[i,j]) - 1.) for j in range(self._dim)] for i in range(self._dim)]) vol = stats.cov_to_vol(cov) self._to_string_helper_LogNormalDistr = None self._str_LogNormalDistr = None super().__init__(mean, cov, vol, self._dim, copy)
def testMultivariateNormalDistr(self): stdnormal1d = distrs.NormalDistr(dim=1) npt.assert_almost_equal(stdnormal1d.mean, 0.) npt.assert_almost_equal(stdnormal1d.cov, 1.) npt.assert_almost_equal(stdnormal1d.vol, 1.) stdnormal1d = distrs.NormalDistr(dim=2) npt.assert_almost_equal(stdnormal1d.mean, npu.colof(2, 0.)) npt.assert_almost_equal(stdnormal1d.cov, np.eye(2)) npt.assert_almost_equal(stdnormal1d.vol, np.eye(2)) sd1 = 3. sd2 = 4. cor = -.5 normal2d = distrs.NormalDistr(mean=[1., 2.], cov=distrs.NormalDistr.makecov2d( sd1=sd1, sd2=sd2, cor=cor)) npt.assert_almost_equal(normal2d.mean, npu.col(1., 2.)) npt.assert_almost_equal( normal2d.cov, [[sd1 * sd1, cor * sd1 * sd2], [cor * sd1 * sd2, sd2 * sd2]]) npt.assert_almost_equal( normal2d.vol, [[sd1, 0.], [cor * sd2, np.sqrt(1. - cor * cor) * sd2]]) normal2d = distrs.NormalDistr(mean=[1., 2.], vol=distrs.NormalDistr.makevol2d( sd1=sd1, sd2=sd2, cor=cor)) npt.assert_almost_equal(normal2d.mean, npu.col(1., 2.)) npt.assert_almost_equal( normal2d.cov, [[sd1 * sd1, cor * sd1 * sd2], [cor * sd1 * sd2, sd2 * sd2]]) npt.assert_almost_equal( normal2d.vol, [[sd1, 0.], [cor * sd2, np.sqrt(1. - cor * cor) * sd2]])
def propagate(self, time0, value0, time, variate=None, state0=None, random_state=None): if time == time0: return npu.to_ndim_2(value0, ndim_1_to_col=True, copy=True) value0 = npu.to_ndim_2(value0, ndim_1_to_col=True, copy=False) if variate is None: if random_state is None: random_state = rnd.random_state() variate = random_state.normal(size=self.noise_dim) variate = npu.to_ndim_2(variate, ndim_1_to_col=True, copy=False) time_delta = time - time0 if isinstance(time_delta, np.timedelta64): time_delta = time_delta.item() if isinstance(time_delta, dt.timedelta): time_delta = time_delta.total_seconds() / self._time_unit.total_seconds() return value0 * np.exp( (self._pct_drift - .5 * npu.col(*np.sum(self._pct_vol**2, axis=1))) * time_delta + \ np.dot(self._pct_vol, np.sqrt(time_delta) * variate))
def test_vectorized(self): func_call_count = 0 def func(a, b): nonlocal func_call_count func_call_count += 1 return a + b funcv_call_count = 0 @vectorized def funcv(a, b): nonlocal funcv_call_count funcv_call_count += 1 return a + b def solver(a, b, f): if npu.is_vectorized(f): return f(a, b) else: rc = np.shape(a)[0] r = np.empty((rc, 1)) for i in range(rc): r[i] = f(a[i], b[i]) return r self.assertFalse(npu.is_vectorized(func)) self.assertTrue(npu.is_vectorized(funcv)) a = npu.col(14., 2., 429.) b = npu.col(42., 1., 5.) r = solver(a, b, func) npt.assert_almost_equal(r, np.array([[56.], [3.], [434.]])) self.assertEqual(func_call_count, 3) r = solver(a, b, funcv) npt.assert_almost_equal(r, np.array([[56.], [3.], [434.]])) self.assertEqual(funcv_call_count, 1)
def test_multinomial_resample(self): rnd.random_state(np.random.RandomState(seed=42), force=True) normal_distr = distrs.NormalDistr(mean=[10., 100.], cov=[[4., -3.], [-3., 9.]]) particles = normal_distr.sample(size=100000) approx_normal_empirical_2d = distrs.EmpiricalDistr(particles=particles, weights=np.ones((100000,))) self.assertEqual(approx_normal_empirical_2d.particle_count, 100000) npt.assert_almost_equal(approx_normal_empirical_2d.effective_particle_count, 100000.) self.assertEqual(approx_normal_empirical_2d.dim, 2) npt.assert_almost_equal(approx_normal_empirical_2d.particles, particles) npt.assert_almost_equal(approx_normal_empirical_2d.particle(0), npu.col(*particles[0])) npt.assert_almost_equal(approx_normal_empirical_2d.weights, npu.col(*np.ones((100000,)))) npt.assert_almost_equal(approx_normal_empirical_2d.weight(0), 1.) npt.assert_almost_equal(approx_normal_empirical_2d.normalised_weights, npu.col(*np.ones((100000,))) / 100000.) npt.assert_almost_equal(approx_normal_empirical_2d.normalised_weight(0), .00001) self.assertEqual(approx_normal_empirical_2d.weight_sum, 100000.) npt.assert_almost_equal(approx_normal_empirical_2d.mean, [[ 9.9866994], [ 100.0141095]]) npt.assert_almost_equal(approx_normal_empirical_2d.var_n, [[ 3.9902435], [ 9.0362717]]) npt.assert_almost_equal(approx_normal_empirical_2d.var_n_minus_1, [[ 3.9902834], [ 9.036362 ]]) npt.assert_almost_equal(approx_normal_empirical_2d.cov_n, [[ 3.9902435, -3.011222 ], [-3.011222 , 9.0362717]]) npt.assert_almost_equal(approx_normal_empirical_2d.cov_n_minus_1, [[ 3.9902834, -3.0112521], [-3.0112521, 9.036362 ]]) npt.assert_almost_equal(approx_normal_empirical_2d.cov, [[ 3.9902435, -3.011222 ], [-3.011222 , 9.0362717]]) npt.assert_almost_equal(approx_normal_empirical_2d.vol_n, [[ 1.9975594, 0. ], [-1.5074505, 2.6007431]]) npt.assert_almost_equal(approx_normal_empirical_2d.vol_n_minus_1, [[ 1.9975694, 0. ], [-1.5074581, 2.6007561]]) npt.assert_almost_equal(approx_normal_empirical_2d.vol, [[ 1.9975594, 0. ], [-1.5074505, 2.6007431]]) rnd.random_state(np.random.RandomState(seed=43), force=True) resampled_approx_normal_empirical_2d = distrs.multinomial_resample(approx_normal_empirical_2d) self.assertEqual(resampled_approx_normal_empirical_2d.particle_count, 100000) npt.assert_almost_equal(resampled_approx_normal_empirical_2d.effective_particle_count, 100000.) self.assertEqual(resampled_approx_normal_empirical_2d.dim, 2) # The resampled particles should ("almost certainly") be different from the original ones: self.assertFalse(np.sum(resampled_approx_normal_empirical_2d.particles) == np.sum(particles)) npt.assert_almost_equal(resampled_approx_normal_empirical_2d.particle(0), npu.col(*particles[1])) npt.assert_almost_equal(resampled_approx_normal_empirical_2d.weights, npu.col(*np.ones((100000,)))) npt.assert_almost_equal(resampled_approx_normal_empirical_2d.weight(0), 1.) npt.assert_almost_equal(resampled_approx_normal_empirical_2d.normalised_weights, npu.col(*np.ones((100000,))) / 100000.) npt.assert_almost_equal(resampled_approx_normal_empirical_2d.normalised_weight(0), .00001) self.assertEqual(resampled_approx_normal_empirical_2d.weight_sum, 100000.) # But the stats should be pretty close to those of the original empirical distribution, though not to seven # decimal places: npt.assert_almost_equal(resampled_approx_normal_empirical_2d.mean, [[ 9.9866994], [ 100.0141095]], decimal=1) npt.assert_almost_equal(resampled_approx_normal_empirical_2d.var_n, [[ 3.9902435], [ 9.0362717]], decimal=1) npt.assert_almost_equal(resampled_approx_normal_empirical_2d.var_n_minus_1, [[ 3.9902834], [ 9.036362 ]], decimal=1) npt.assert_almost_equal(resampled_approx_normal_empirical_2d.cov_n, [[ 3.9902435, -3.011222 ], [-3.011222 , 9.0362717]], decimal=1) npt.assert_almost_equal(resampled_approx_normal_empirical_2d.cov_n_minus_1, [[ 3.9902834, -3.0112521], [-3.0112521, 9.036362 ]], decimal=1) npt.assert_almost_equal(resampled_approx_normal_empirical_2d.cov, [[ 3.9902435, -3.011222 ], [-3.011222 , 9.0362717]], decimal=1) npt.assert_almost_equal(resampled_approx_normal_empirical_2d.vol_n, [[ 1.9975594, 0. ], [-1.5074505, 2.6007431]], decimal=1) npt.assert_almost_equal(resampled_approx_normal_empirical_2d.vol_n_minus_1, [[ 1.9975694, 0. ], [-1.5074581, 2.6007561]], decimal=1) npt.assert_almost_equal(resampled_approx_normal_empirical_2d.vol, [[ 1.9975594, 0. ], [-1.5074505, 2.6007431]], decimal=1) rnd.random_state(np.random.RandomState(seed=43), force=True) resampled_approx_normal_empirical_2d_particles = approx_normal_empirical_2d.sample(size=100000) npt.assert_almost_equal(resampled_approx_normal_empirical_2d_particles, resampled_approx_normal_empirical_2d.particles) subsampled_approx_normal_empirical_2d = distrs.multinomial_resample(approx_normal_empirical_2d, target_particle_count=40000) self.assertEqual(subsampled_approx_normal_empirical_2d.particle_count, 40000) npt.assert_almost_equal(subsampled_approx_normal_empirical_2d.effective_particle_count, 40000.) self.assertEqual(subsampled_approx_normal_empirical_2d.dim, 2) # The resampled particles should ("almost certainly") be different from the original ones: self.assertFalse(np.sum(subsampled_approx_normal_empirical_2d.particles) == np.sum(particles)) npt.assert_almost_equal(subsampled_approx_normal_empirical_2d.particle(0), npu.col(*particles[1])) npt.assert_almost_equal(subsampled_approx_normal_empirical_2d.weights, npu.col(*np.ones((40000,)))) npt.assert_almost_equal(subsampled_approx_normal_empirical_2d.weight(0), 1.) npt.assert_almost_equal(subsampled_approx_normal_empirical_2d.normalised_weights, npu.col(*np.ones((40000,))) / 40000.) npt.assert_almost_equal(subsampled_approx_normal_empirical_2d.normalised_weight(0), .000025) self.assertEqual(subsampled_approx_normal_empirical_2d.weight_sum, 40000.) # But the stats should be pretty close to those of the original empirical distribution, though not to seven # decimal places: npt.assert_almost_equal(subsampled_approx_normal_empirical_2d.mean, [[ 9.9866994], [ 100.0141095]], decimal=1) npt.assert_almost_equal(subsampled_approx_normal_empirical_2d.var_n, [[ 3.9902435], [ 9.0362717]], decimal=1) npt.assert_almost_equal(subsampled_approx_normal_empirical_2d.var_n_minus_1, [[ 3.9902834], [ 9.036362 ]], decimal=1) npt.assert_almost_equal(subsampled_approx_normal_empirical_2d.cov_n, [[ 3.9902435, -3.011222 ], [-3.011222 , 9.0362717]], decimal=1) npt.assert_almost_equal(subsampled_approx_normal_empirical_2d.cov_n_minus_1, [[ 3.9902834, -3.0112521], [-3.0112521, 9.036362 ]], decimal=1) npt.assert_almost_equal(subsampled_approx_normal_empirical_2d.cov, [[ 3.9902435, -3.011222 ], [-3.011222 , 9.0362717]], decimal=1) npt.assert_almost_equal(subsampled_approx_normal_empirical_2d.vol_n, [[ 1.9975594, 0. ], [-1.5074505, 2.6007431]], decimal=1) npt.assert_almost_equal(subsampled_approx_normal_empirical_2d.vol_n_minus_1, [[ 1.9975694, 0. ], [-1.5074581, 2.6007561]], decimal=1) npt.assert_almost_equal(subsampled_approx_normal_empirical_2d.vol, [[ 1.9975594, 0. ], [-1.5074505, 2.6007431]], decimal=1) supersampled_approx_normal_empirical_2d = distrs.multinomial_resample(approx_normal_empirical_2d, target_particle_count=300000) self.assertEqual(supersampled_approx_normal_empirical_2d.particle_count, 300000) npt.assert_almost_equal(supersampled_approx_normal_empirical_2d.effective_particle_count, 300000.) self.assertEqual(supersampled_approx_normal_empirical_2d.dim, 2) # The resampled particles should ("almost certainly") be different from the original ones: self.assertFalse(np.sum(supersampled_approx_normal_empirical_2d.particles) == np.sum(particles)) npt.assert_almost_equal(supersampled_approx_normal_empirical_2d.particle(0), npu.col(*particles[0])) npt.assert_almost_equal(supersampled_approx_normal_empirical_2d.weights, npu.col(*np.ones((300000,)))) npt.assert_almost_equal(supersampled_approx_normal_empirical_2d.weight(0), 1.) npt.assert_almost_equal(supersampled_approx_normal_empirical_2d.normalised_weights, npu.col(*np.ones((300000,))) / 300000.) npt.assert_almost_equal(supersampled_approx_normal_empirical_2d.normalised_weight(0), 3.3333333333333333e-06) self.assertEqual(supersampled_approx_normal_empirical_2d.weight_sum, 300000.) # But the stats should be pretty close to those of the original empirical distribution, though not to seven # decimal places: npt.assert_almost_equal(supersampled_approx_normal_empirical_2d.mean, [[ 9.9866994], [ 100.0141095]], decimal=1) npt.assert_almost_equal(supersampled_approx_normal_empirical_2d.var_n, [[ 3.9902435], [ 9.0362717]], decimal=1) npt.assert_almost_equal(supersampled_approx_normal_empirical_2d.var_n_minus_1, [[ 3.9902834], [ 9.036362 ]], decimal=1) npt.assert_almost_equal(supersampled_approx_normal_empirical_2d.cov_n, [[ 3.9902435, -3.011222 ], [-3.011222 , 9.0362717]], decimal=1) npt.assert_almost_equal(supersampled_approx_normal_empirical_2d.cov_n_minus_1, [[ 3.9902834, -3.0112521], [-3.0112521, 9.036362 ]], decimal=1) npt.assert_almost_equal(supersampled_approx_normal_empirical_2d.cov, [[ 3.9902435, -3.011222 ], [-3.011222 , 9.0362717]], decimal=1) npt.assert_almost_equal(supersampled_approx_normal_empirical_2d.vol_n, [[ 1.9975594, 0. ], [-1.5074505, 2.6007431]], decimal=1) npt.assert_almost_equal(supersampled_approx_normal_empirical_2d.vol_n_minus_1, [[ 1.9975694, 0. ], [-1.5074581, 2.6007561]], decimal=1) npt.assert_almost_equal(supersampled_approx_normal_empirical_2d.vol, [[ 1.9975594, 0. ], [-1.5074505, 2.6007431]], decimal=1)
def test_normal_distr(self): rnd.random_state(np.random.RandomState(seed=42), force=True) std_normal_1d = distrs.NormalDistr(dim=1) npt.assert_almost_equal(std_normal_1d.mean, 0.) npt.assert_almost_equal(std_normal_1d.cov, 1.) npt.assert_almost_equal(std_normal_1d.vol, 1.) sample = std_normal_1d.sample() self.assertEqual(np.shape(sample), (1, 1)) npt.assert_almost_equal(sample, [[ 0.49671415]]) sample = std_normal_1d.sample(size=10) self.assertEqual(np.shape(sample), (10, 1)) npt.assert_almost_equal(sample, [ [-0.1382643 ], [ 0.64768854], [ 1.52302986], [-0.23415337], [-0.23413696], [ 1.57921282], [ 0.76743473], [-0.46947439], [ 0.54256004], [-0.46341769]]) std_normal_2d = distrs.NormalDistr(dim=2) npt.assert_almost_equal(std_normal_2d.mean, npu.col_of(2, 0.)) npt.assert_almost_equal(std_normal_2d.cov, np.eye(2)) npt.assert_almost_equal(std_normal_2d.vol, np.eye(2)) sample = std_normal_2d.sample(size=10) self.assertEqual(np.shape(sample), (10, 2)) npt.assert_almost_equal(sample, [ [-0.46572975, 0.24196227], [-1.91328024, -1.72491783], [-0.56228753, -1.01283112], [ 0.31424733, -0.90802408], [-1.4123037 , 1.46564877], [-0.2257763 , 0.0675282 ], [-1.42474819, -0.54438272], [ 0.11092259, -1.15099358], [ 0.37569802, -0.60063869], [-0.29169375, -0.60170661]]) sd1=3.; sd2=4.; cor=-.5 normal_2d = distrs.NormalDistr(mean=[1., 2.], cov=stats.make_cov_2d(sd1=sd1, sd2=sd2, cor=cor)) npt.assert_almost_equal(normal_2d.mean, npu.col(1., 2.)) npt.assert_almost_equal(normal_2d.cov, [[sd1*sd1, cor*sd1*sd2], [cor*sd1*sd2, sd2*sd2]]) npt.assert_almost_equal(normal_2d.vol, [[sd1, 0.], [cor*sd2, np.sqrt(1.-cor*cor)*sd2]]) sample = normal_2d.sample(size=10) self.assertEqual(np.shape(sample), (10, 2)) npt.assert_almost_equal(sample, [ [-3.09581812, 9.06710684], [ 5.00400357, -1.07912958], [ 4.10821238, -2.42324481], [ 2.58989516, -7.05256838], [ 2.07671635, 3.61955714], [ 0.38728403, 2.5195548 ], [-1.36010204, -0.88681309], [ 1.63968707, -1.29329703], [-0.61960168, 6.44566548], [ 5.53451941, -4.36131646]]) normal_2d = distrs.NormalDistr(mean=[1., 2.], vol=stats.make_vol_2d(sd1=sd1, sd2=sd2, cor=cor)) npt.assert_almost_equal(normal_2d.mean, npu.col(1., 2.)) npt.assert_almost_equal(normal_2d.cov, [[sd1*sd1, cor*sd1*sd2], [cor*sd1*sd2, sd2*sd2]]) npt.assert_almost_equal(normal_2d.vol, [[sd1, 0.], [cor*sd2, np.sqrt(1.-cor*cor)*sd2]]) sample = normal_2d.sample(size=10) self.assertEqual(np.shape(sample), (10, 2)) npt.assert_almost_equal(sample, [ [ 0.4624506 , -0.26705979], [ 1.76344545, 5.54913479], [-2.76038957, 4.57609973], [ 2.35608833, 1.20642031], [-2.1218454 , 5.16796697], [-0.85307657, -0.00850715], [ 5.28771297, -1.62048489], [-2.12592264, 7.1016208 ], [-0.46508111, 6.26189296], [ 3.15543223, -0.04269231]])
def test_empirical_distr(self): rnd.random_state(np.random.RandomState(seed=42), force=True) trivial_empirical_1d = distrs.EmpiricalDistr(particles=[[0.]], weights=[1.]) self.assertEqual(trivial_empirical_1d.particle_count, 1) npt.assert_almost_equal(trivial_empirical_1d.effective_particle_count, 1.) self.assertEqual(trivial_empirical_1d.dim, 1) npt.assert_almost_equal(trivial_empirical_1d.particles, np.array([[0.]])) npt.assert_almost_equal(trivial_empirical_1d.particle(0), np.array([[0.]])) npt.assert_almost_equal(trivial_empirical_1d.weights, np.array([[1.]])) npt.assert_almost_equal(trivial_empirical_1d.weight(0), 1.) npt.assert_almost_equal(trivial_empirical_1d.normalised_weights, np.array([[1.]])) npt.assert_almost_equal(trivial_empirical_1d.normalised_weight(0), 1.) self.assertEqual(trivial_empirical_1d.weight_sum, 1.) self.assertEqual(trivial_empirical_1d.mean, 0.) self.assertEqual(trivial_empirical_1d.var_n, 0.) npt.assert_almost_equal(trivial_empirical_1d.var_n_minus_1, np.nan) self.assertEqual(trivial_empirical_1d.var, 0.) self.assertEqual(trivial_empirical_1d.cov_n, 0.) npt.assert_almost_equal(trivial_empirical_1d.cov_n_minus_1, np.nan) self.assertEqual(trivial_empirical_1d.cov, 0.) with self.assertRaises(np.linalg.LinAlgError): # Matrix is not positive definite trivial_empirical_1d.vol_n with self.assertRaises(np.linalg.LinAlgError): # Matrix is not positive definite trivial_empirical_1d.vol_n_minus_1 with self.assertRaises(np.linalg.LinAlgError): # Matrix is not positive definite trivial_empirical_1d.vol simple_empirical_1d = distrs.EmpiricalDistr(particles=[[-1.], [1.]], weights=[.5, .5]) self.assertEqual(simple_empirical_1d.particle_count, 2) npt.assert_almost_equal(simple_empirical_1d.effective_particle_count, 2.) self.assertEqual(simple_empirical_1d.dim, 1) npt.assert_almost_equal(simple_empirical_1d.particles, np.array([[-1.], [1.]])) npt.assert_almost_equal(simple_empirical_1d.particle(0), np.array([[-1.]])) npt.assert_almost_equal(simple_empirical_1d.weights, np.array([[.5], [.5]])) npt.assert_almost_equal(simple_empirical_1d.weight(0), .5) npt.assert_almost_equal(simple_empirical_1d.normalised_weights, np.array([[.5], [.5]])) npt.assert_almost_equal(simple_empirical_1d.normalised_weight(0), .5) self.assertEqual(simple_empirical_1d.weight_sum, 1.) self.assertEqual(simple_empirical_1d.mean, 0.) self.assertEqual(simple_empirical_1d.var_n, 1.) # "n minus 1" (unbiased) stats don't make sense as we are not using "repeat"-type weights, meaning that each # weight represents the number of occurrences of one observation: npt.assert_almost_equal(simple_empirical_1d.var_n_minus_1, np.inf) self.assertEqual(simple_empirical_1d.cov_n, 1.) # "n minus 1" (unbiased) stats don't make sense as we are not using "repeat"-type weights, meaning that each # weight represents the number of occurrences of one observation: npt.assert_almost_equal(simple_empirical_1d.cov_n_minus_1, np.inf) self.assertEqual(simple_empirical_1d.cov, 1.) self.assertEqual(simple_empirical_1d.vol_n, 1.) # "n minus 1" (unbiased) stats don't make sense as we are not using "repeat"-type weights, meaning that each # weight represents the number of occurrences of one observation: self.assertEqual(simple_empirical_1d.vol_n_minus_1, np.inf) self.assertEqual(simple_empirical_1d.vol, 1.) # The weights can be specified as a one-dimensional array... simple_empirical_1d = distrs.EmpiricalDistr(particles=[[-1.], [1.]], weights=[.5, .5]) self.assertEqual(simple_empirical_1d.particle_count, 2) npt.assert_almost_equal(simple_empirical_1d.effective_particle_count, 2.) self.assertEqual(simple_empirical_1d.dim, 1) npt.assert_almost_equal(simple_empirical_1d.particles, np.array([[-1.], [1.]])) # ...but they come back as a (two-dimensional) column vector: npt.assert_almost_equal(simple_empirical_1d.weights, np.array([[.5], [.5]])) # ...alternatively, the weights can be specified as a (two-dimensional) column vector: simple_empirical_1d = distrs.EmpiricalDistr(particles=[[-1.], [1.]], weights=[[.5], [.5]]) self.assertEqual(simple_empirical_1d.particle_count, 2) npt.assert_almost_equal(simple_empirical_1d.effective_particle_count, 2.) self.assertEqual(simple_empirical_1d.dim, 1) npt.assert_almost_equal(simple_empirical_1d.particles, np.array([[-1.], [1.]])) # ...they always come back as a (two-dimensional) column vector: npt.assert_almost_equal(simple_empirical_1d.weights, np.array([[.5], [.5]])) # If the particles are specified as a one-dimensional array, they are interpreted as... simple_empirical_1d = distrs.EmpiricalDistr(particles=[-1., 1.], weights=[.5, .5]) self.assertEqual(simple_empirical_1d.particle_count, 2) npt.assert_almost_equal(simple_empirical_1d.effective_particle_count, 2.) self.assertEqual(simple_empirical_1d.dim, 1) # ...multiple one-dimensional particles (each row corresponds to a particle, each column to a dimension): npt.assert_almost_equal(simple_empirical_1d.particles, np.array([[-1.], [1.]])) npt.assert_almost_equal(simple_empirical_1d.weights, np.array([[.5], [.5]])) # Now we shall be using "repeat"-type weights: repeat_empirical_1d = distrs.EmpiricalDistr(particles=[[-1.], [1.]], weights=[2., 1.]) self.assertEqual(repeat_empirical_1d.particle_count, 2) npt.assert_almost_equal(repeat_empirical_1d.effective_particle_count, 1.7999999999999998) self.assertEqual(repeat_empirical_1d.dim, 1) npt.assert_almost_equal(repeat_empirical_1d.particles, np.array([[-1.], [1.]])) npt.assert_almost_equal(repeat_empirical_1d.particle(0), np.array([[-1.]])) npt.assert_almost_equal(repeat_empirical_1d.weights, np.array([[2.], [1.]])) npt.assert_almost_equal(repeat_empirical_1d.weight(0), 2.) npt.assert_almost_equal(repeat_empirical_1d.normalised_weights, np.array([[ 0.6666667], [ 0.3333333]])) npt.assert_almost_equal(repeat_empirical_1d.normalised_weight(0), 0.6666667) self.assertEqual(repeat_empirical_1d.weight_sum, 3.) npt.assert_almost_equal(repeat_empirical_1d.mean, -0.33333333) npt.assert_almost_equal(repeat_empirical_1d.var_n, 0.88888889) npt.assert_almost_equal(repeat_empirical_1d.var_n_minus_1, 1.3333333) npt.assert_almost_equal(repeat_empirical_1d.cov_n, 0.88888889) npt.assert_almost_equal(repeat_empirical_1d.cov_n_minus_1, 1.3333333) npt.assert_almost_equal(repeat_empirical_1d.cov, 0.88888889) npt.assert_almost_equal(repeat_empirical_1d.vol_n, 0.94280904) npt.assert_almost_equal(repeat_empirical_1d.vol_n_minus_1, 1.15470054) npt.assert_almost_equal(repeat_empirical_1d.vol, 0.94280904) # Now we shall be using "repeat"-type weights. There are three two-dimensional particles: repeat_empirical_2d = distrs.EmpiricalDistr(particles=[[-2., 2.], [0., 0.], [1., -1.]], weights=[2., 1., 1.]) self.assertEqual(repeat_empirical_2d.particle_count, 3) npt.assert_almost_equal(repeat_empirical_2d.effective_particle_count, 2.6666666666666665) self.assertEqual(repeat_empirical_2d.dim, 2) npt.assert_almost_equal(repeat_empirical_2d.particles, np.array([[-2., 2.], [0., 0.], [1., -1.]])) npt.assert_almost_equal(repeat_empirical_2d.particle(0), np.array([[-2.], [2.]])) npt.assert_almost_equal(repeat_empirical_2d.weights, np.array([[2.], [1.], [1.]])) npt.assert_almost_equal(repeat_empirical_2d.weight(0), 2.) npt.assert_almost_equal(repeat_empirical_2d.normalised_weights, np.array([[ 0.5 ], [ 0.25], [ 0.25]])) npt.assert_almost_equal(repeat_empirical_2d.normalised_weight(0), .5) self.assertEqual(repeat_empirical_2d.weight_sum, 4.) npt.assert_almost_equal(repeat_empirical_2d.mean, [[-0.75], [ 0.75]]) npt.assert_almost_equal(repeat_empirical_2d.var_n, [[ 1.6875], [ 1.6875]]) npt.assert_almost_equal(repeat_empirical_2d.var_n_minus_1, [[ 2.25], [ 2.25]]) npt.assert_almost_equal(repeat_empirical_2d.cov_n, [[ 1.6875, -1.6875], [-1.6875, 1.6875]]) npt.assert_almost_equal(repeat_empirical_2d.cov_n_minus_1, [[ 2.25, -2.25], [-2.25, 2.25]]) npt.assert_almost_equal(repeat_empirical_2d.cov, [[ 1.6875, -1.6875], [-1.6875, 1.6875]]) with self.assertRaises(np.linalg.LinAlgError): # Matrix is not positive definite repeat_empirical_2d.vol_n with self.assertRaises(np.linalg.LinAlgError): # Matrix is not positive definite repeat_empirical_2d.vol_n_minus_1 with self.assertRaises(np.linalg.LinAlgError): # Matrix is not positive definite repeat_empirical_2d.vol normal_distr = distrs.NormalDistr(mean=[10., 100.], cov=[[4., -3.], [-3., 9.]]) particles = normal_distr.sample(size=100) approx_normal_empirical_2d = distrs.EmpiricalDistr(particles=particles, weights=np.ones((100,))) self.assertEqual(approx_normal_empirical_2d.particle_count, 100) npt.assert_almost_equal(approx_normal_empirical_2d.effective_particle_count, 100.) self.assertEqual(approx_normal_empirical_2d.dim, 2) npt.assert_almost_equal(approx_normal_empirical_2d.particles, particles) npt.assert_almost_equal(approx_normal_empirical_2d.particle(0), npu.col(*particles[0])) npt.assert_almost_equal(approx_normal_empirical_2d.weights, npu.col(*np.ones((100,)))) npt.assert_almost_equal(approx_normal_empirical_2d.weight(0), 1.) npt.assert_almost_equal(approx_normal_empirical_2d.normalised_weights, npu.col(*np.ones((100,))) / 100.) npt.assert_almost_equal(approx_normal_empirical_2d.normalised_weight(0), .01) self.assertEqual(approx_normal_empirical_2d.weight_sum, 100.) npt.assert_almost_equal(approx_normal_empirical_2d.mean, [[ 10.2077457], [ 99.6856645]]) npt.assert_almost_equal(approx_normal_empirical_2d.var_n, [[ 3.3516275], [ 6.7649298]]) npt.assert_almost_equal(approx_normal_empirical_2d.var_n_minus_1, [[ 3.3854823], [ 6.8332624]]) npt.assert_almost_equal(approx_normal_empirical_2d.cov_n, [[ 3.3516275, -1.8258307], [-1.8258307, 6.7649298]]) npt.assert_almost_equal(approx_normal_empirical_2d.cov_n_minus_1, [[ 3.3854823, -1.8442735], [-1.8442735, 6.8332624]]) npt.assert_almost_equal(approx_normal_empirical_2d.cov, [[ 3.3516275, -1.8258307], [-1.8258307, 6.7649298]]) npt.assert_almost_equal(approx_normal_empirical_2d.vol_n, [[ 1.8307451, 0. ], [-0.9973157, 2.4021431]]) npt.assert_almost_equal(approx_normal_empirical_2d.vol_n_minus_1, [[ 1.839968 , 0. ], [-1.00234 , 2.4142446]]) npt.assert_almost_equal(approx_normal_empirical_2d.vol, [[ 1.8307451, 0. ], [-0.9973157, 2.4021431]]) # Using more particles more faithfully approximates the mean and covariance of the normal distribution: normal_distr = distrs.NormalDistr(mean=[10., 100.], cov=[[4., -3.], [-3., 9.]]) particles = normal_distr.sample(size=100000) approx_normal_empirical_2d = distrs.EmpiricalDistr(particles=particles, weights=np.ones((100000,))) self.assertEqual(approx_normal_empirical_2d.particle_count, 100000) npt.assert_almost_equal(approx_normal_empirical_2d.effective_particle_count, 100000.) self.assertEqual(approx_normal_empirical_2d.dim, 2) npt.assert_almost_equal(approx_normal_empirical_2d.particles, particles) npt.assert_almost_equal(approx_normal_empirical_2d.particle(0), npu.col(*particles[0])) npt.assert_almost_equal(approx_normal_empirical_2d.weights, npu.col(*np.ones((100000,)))) npt.assert_almost_equal(approx_normal_empirical_2d.weight(0), 1.) npt.assert_almost_equal(approx_normal_empirical_2d.normalised_weights, npu.col(*np.ones((100000,))) / 100000.) npt.assert_almost_equal(approx_normal_empirical_2d.normalised_weight(0), .00001) self.assertEqual(approx_normal_empirical_2d.weight_sum, 100000.) npt.assert_almost_equal(approx_normal_empirical_2d.mean, [[ 9.9863195], [ 100.0145412]]) npt.assert_almost_equal(approx_normal_empirical_2d.var_n, [[ 3.9901799], [ 9.0390325]]) npt.assert_almost_equal(approx_normal_empirical_2d.var_n_minus_1, [[ 3.9902198], [ 9.0391229]]) npt.assert_almost_equal(approx_normal_empirical_2d.cov_n, [[ 3.9901799, -3.0120428], [-3.0120428, 9.0390325]]) npt.assert_almost_equal(approx_normal_empirical_2d.cov_n_minus_1, [[ 3.9902198, -3.0120729], [-3.0120729, 9.0391229]]) npt.assert_almost_equal(approx_normal_empirical_2d.cov, [[ 3.9901799, -3.0120428], [-3.0120428, 9.0390325]]) npt.assert_almost_equal(approx_normal_empirical_2d.vol_n, [[ 1.9975435, 0. ], [-1.5078735, 2.6010287]]) npt.assert_almost_equal(approx_normal_empirical_2d.vol_n_minus_1, [[ 1.9975535, 0. ], [-1.507881 , 2.6010417]]) npt.assert_almost_equal(approx_normal_empirical_2d.vol, [[ 1.9975435, 0. ], [-1.5078735, 2.6010287]])
def test_log_normal_distr(self): rnd.random_state(np.random.RandomState(seed=42), force=True) std_log_normal_1d = distrs.LogNormalDistr(dim=1) npt.assert_almost_equal(std_log_normal_1d.mean, [[ 1.6487213]]) npt.assert_almost_equal(std_log_normal_1d.cov, [[ 4.6707743]]) npt.assert_almost_equal(std_log_normal_1d.vol, [[ 2.1611974]]) sample = std_log_normal_1d.sample(size=1) self.assertEqual(np.shape(sample), (1, 1)) npt.assert_almost_equal(sample, [[ 1.6433127]]) sample = std_log_normal_1d.sample(size=10) self.assertEqual(np.shape(sample), (10, 1)) npt.assert_almost_equal(sample, [ [ 0.87086849], [ 1.91111824], [ 4.58609939], [ 0.79124045], [ 0.79125344], [ 4.85113557], [ 2.15423297], [ 0.62533086], [ 1.72040554], [ 0.62912979]]) std_log_normal_2d = distrs.LogNormalDistr(dim=2) npt.assert_almost_equal(std_log_normal_2d.mean, [ [ 1.6487213], [ 1.6487213]]) npt.assert_almost_equal(std_log_normal_2d.cov, [ [ 4.6707743, 0. ], [ 0. , 4.6707743]]) npt.assert_almost_equal(std_log_normal_2d.vol, [ [ 2.1611974, 0. ], [ 0. , 2.1611974]]) sample = std_log_normal_2d.sample(size=10) self.assertEqual(np.shape(sample), (10, 2)) npt.assert_almost_equal(sample, [ [ 0.62767689, 1.27374614], [ 0.14759544, 0.17818769], [ 0.5699039 , 0.36318929], [ 1.36922835, 0.40332037], [ 0.2435815 , 4.33035173], [ 0.79789657, 1.06986043], [ 0.24056903, 0.58019982], [ 1.11730841, 0.31632232], [ 1.45600738, 0.54846123], [ 0.74699727, 0.54787583]]) sd1=.4; sd2=.4; cor=-.5 log_normal_2d = distrs.LogNormalDistr(mean_of_log=[1., 1.3], cov_of_log=stats.make_cov_2d(sd1=sd1, sd2=sd2, cor=cor)) npt.assert_almost_equal(log_normal_2d.mean_of_log, npu.col(1., 1.3)) npt.assert_almost_equal(log_normal_2d.cov_of_log, [[sd1*sd1, cor*sd1*sd2], [cor*sd1*sd2, sd2*sd2]]) npt.assert_almost_equal(log_normal_2d.vol_of_log, [[sd1, 0.], [cor*sd2, np.sqrt(1.-cor*cor)*sd2]]) npt.assert_almost_equal(log_normal_2d.mean, [[ 2.9446796], [ 3.9749016]]) npt.assert_almost_equal(log_normal_2d.cov, [[ 1.5045366, -0.8999087], [-0.8999087, 2.7414445]]) npt.assert_almost_equal(log_normal_2d.vol, [[ 1.2265956, 0. ], [-0.7336637, 1.484312 ]]) sample = log_normal_2d.sample(size=10) self.assertEqual(np.shape(sample), (10, 2)) npt.assert_almost_equal(sample, [ [ 1.42711164, 6.95143797], [ 4.62238496, 2.99848502], [ 4.32618186, 2.50643161], [ 4.10913455, 1.42691268], [ 2.94320341, 4.55346303], [ 2.50304159, 3.80468825], [ 2.24476532, 2.45957906], [ 3.18112082, 2.60781028], [ 2.01884543, 5.66848303], [ 5.34174201, 2.12565878]]) log_normal_2d = distrs.LogNormalDistr(mean_of_log=[1., 1.3], vol_of_log=stats.make_vol_2d(sd1=sd1, sd2=sd2, cor=cor)) npt.assert_almost_equal(log_normal_2d.mean_of_log, npu.col(1., 1.3)) npt.assert_almost_equal(log_normal_2d.cov_of_log, [[sd1*sd1, cor*sd1*sd2], [cor*sd1*sd2, sd2*sd2]]) npt.assert_almost_equal(log_normal_2d.vol_of_log, [[sd1, 0.], [cor*sd2, np.sqrt(1.-cor*cor)*sd2]]) npt.assert_almost_equal(log_normal_2d.mean, npu.col(2.9446796, 3.9749016)) npt.assert_almost_equal(log_normal_2d.cov, [[ 1.5045366, -0.8999087], [-0.8999087, 2.7414445]]) npt.assert_almost_equal(log_normal_2d.vol, [[ 1.2265956, 0. ], [-0.7336637, 1.484312 ]]) sample = log_normal_2d.sample(size=10) self.assertEqual(np.shape(sample), (10, 2)) npt.assert_almost_equal(sample, [ [ 2.71288329, 2.80448293], [ 2.70285608, 5.57387658], [ 1.66454464, 4.28346127], [ 3.23285936, 3.52238521], [ 1.76160691, 4.67441442], [ 2.32343609, 2.75776026], [ 4.8398479 , 2.85230385], [ 1.67494888, 5.78583855], [ 2.06409776, 5.58431178], [ 3.6537541 , 3.15441508]])
def test_col(self): col = npu.col(1., 1., 2., 5., 14.) npt.assert_almost_equal(col, np.array(([[1.], [1.], [2.], [5.], [14.]])))
def create_2d(mean1, mean2, sd1, sd2, cor): return WienerProcess(npu.col(mean1, mean2), stats.make_vol_2d(sd1, sd2, cor))
def testkalmanfiltermultid(self): t0 = dt.datetime(2017, 5, 12, 16, 18, 25, 204000) process1 = proc.WienerProcess.create_from_cov(mean=3., cov=25.) process2 = proc.WienerProcess.create_from_cov(mean=[1., 4.], cov=[[36.0, -9.0], [-9.0, 25.0]]) kf = kalman.KalmanFilter(t0, state_distr=N(mean=[100.0, 120.0, 130.0], cov=[[250.0, 0.0, 0.0], [0.0, 360.0, 0.0], [0.0, 0.0, 250.0]]), process=(process1, process2)) state_observable = kf.create_observable( kalman.KalmanFilterObsModel.create(1.0, np.eye(2)), process1, process2) coord0_observable = kf.create_observable( kalman.KalmanFilterObsModel.create(1.), process1) coord1_observable = kf.create_observable( kalman.KalmanFilterObsModel.create(npu.row(1., 0.)), process2) coord2_observable = kf.create_observable( kalman.KalmanFilterObsModel.create(npu.row(0., 1.)), process2) sum_observable = kf.create_observable( kalman.KalmanFilterObsModel.create(npu.row(1., 1., 1.)), process1, process2) lin_comb_observable = kf.create_observable( kalman.KalmanFilterObsModel.create(npu.row(2., 0., -3.)), process1, process2) t1 = t0 + dt.timedelta(hours=1) predicted_obs1_prior = state_observable.predict(t1) npt.assert_almost_equal( predicted_obs1_prior.distr.mean, npu.col(100.0 + 3.0 / 24.0, 120.0 + 1.0 / 24.0, 130.0 + 4.0 / 24.0)) npt.assert_almost_equal(predicted_obs1_prior.distr.cov, [[250.0 + 25.0 / 24.0, 0.0, 0.0], [0.0, 360.0 + 36.0 / 24.0, -9.0 / 24.0], [0.0, -9.0 / 24.0, 250 + 25.0 / 24.0]]) npt.assert_almost_equal(predicted_obs1_prior.cross_cov, predicted_obs1_prior.distr.cov) state_observable.observe(time=t1, obs=N(mean=[100.35, 121.0, 135.0], cov=[[100.0, 0.0, 0.0], [0.0, 400.0, 0.0], [0.0, 0.0, 100.0]])) predicted_obs1_posterior = state_observable.predict(t1) npt.assert_almost_equal( predicted_obs1_posterior.distr.mean, npu.col(100.285905044, 120.493895183, 133.623010239)) npt.assert_almost_equal( predicted_obs1_posterior.distr.cov, [[71.513353115, 0.0, 0.0], [0.0, 189.888267669, -0.056112925], [0.0, -0.056112925, 71.513338130]]) npt.assert_almost_equal(predicted_obs1_posterior.cross_cov, predicted_obs1_posterior.distr.cov) predicted_obs1_0 = coord0_observable.predict(t1) npt.assert_almost_equal(predicted_obs1_0.distr.mean, 100.285905044) npt.assert_almost_equal(predicted_obs1_0.distr.cov, 71.513353115) npt.assert_almost_equal(predicted_obs1_0.cross_cov, npu.row(71.513353115, 0.0, 0.0)) predicted_obs1_1 = coord1_observable.predict(t1) npt.assert_almost_equal(predicted_obs1_1.distr.mean, 120.493895183) npt.assert_almost_equal(predicted_obs1_1.distr.cov, 189.888267669) npt.assert_almost_equal(predicted_obs1_1.cross_cov, npu.row(0.0, 189.888267669, -0.056112925)) predicted_obs1_2 = coord2_observable.predict(t1) npt.assert_almost_equal(predicted_obs1_2.distr.mean, 133.623010239) npt.assert_almost_equal(predicted_obs1_2.distr.cov, 71.513338130) npt.assert_almost_equal(predicted_obs1_2.cross_cov, npu.row(0.0, -0.056112925, 71.513338130)) predicted_obs1_sum = sum_observable.predict(t1) npt.assert_almost_equal(predicted_obs1_sum.distr.mean, 354.402810466) npt.assert_almost_equal(predicted_obs1_sum.distr.cov, 332.802733064) npt.assert_almost_equal( predicted_obs1_sum.cross_cov, npu.row(71.513353115, 189.832154744, 71.457225204)) predicted_obs1_lin_comb = lin_comb_observable.predict(t1) npt.assert_almost_equal(predicted_obs1_lin_comb.distr.mean, -200.297220628) npt.assert_almost_equal(predicted_obs1_lin_comb.distr.cov, 929.673455633) npt.assert_almost_equal( predicted_obs1_lin_comb.cross_cov, npu.row(143.026706231, 0.168338776, -214.540014390)) t2 = t1 + dt.timedelta(minutes=30) coord1_observable.observe(time=t2, obs=N(mean=125.25, cov=4.)) predicted_obs2_1 = coord1_observable.predict(t2) npt.assert_almost_equal(predicted_obs2_1.distr.mean, 125.152685704) npt.assert_almost_equal(predicted_obs2_1.distr.cov, 3.917796226) npt.assert_almost_equal(predicted_obs2_1.cross_cov, npu.row(0.0, 3.917796226, -0.005006475)) t3 = t2 + dt.timedelta(minutes=30) predicted_obs3_prior_sum = sum_observable.predict(t3) npt.assert_almost_equal(predicted_obs3_prior_sum.distr.mean, 359.368174232) npt.assert_almost_equal(predicted_obs3_prior_sum.distr.cov, 149.392502944) npt.assert_almost_equal( predicted_obs3_prior_sum.cross_cov, npu.row(72.555019782, 4.475289751, 72.36219341)) predicted_obs3_prior0 = coord0_observable.predict(t3) npt.assert_almost_equal(predicted_obs3_prior0.distr.mean, 100.410905044) npt.assert_almost_equal(predicted_obs3_prior0.distr.cov, 72.555019782) npt.assert_almost_equal(predicted_obs3_prior0.cross_cov, npu.row(72.555019782, 0.0, 0.0)) predicted_obs3_prior1 = coord1_observable.predict(t3) npt.assert_almost_equal(predicted_obs3_prior1.distr.mean, 125.173519037) npt.assert_almost_equal(predicted_obs3_prior1.distr.cov, 4.667796226) npt.assert_almost_equal(predicted_obs3_prior1.cross_cov, npu.row(0.0, 4.667796226, -0.192506475)) predicted_obs3_prior2 = coord2_observable.predict(t3) npt.assert_almost_equal(predicted_obs3_prior2.distr.mean, 133.783750150) npt.assert_almost_equal(predicted_obs3_prior2.distr.cov, 72.554699886) npt.assert_almost_equal(predicted_obs3_prior2.cross_cov, npu.row(0.0, -0.192506475, 72.554699886)) sum_observable.observe(time=t3, obs=N(mean=365.00, cov=9.)) predicted_obs3_posterior_sum = sum_observable.predict(t3) npt.assert_almost_equal(predicted_obs3_posterior_sum.distr.mean, 364.679994753) npt.assert_almost_equal(predicted_obs3_posterior_sum.distr.cov, 8.488612159) npt.assert_almost_equal(predicted_obs3_posterior_sum.cross_cov, npu.row(4.122639429, 0.254289862, 4.111682867)) predicted_obs3_posterior0 = coord0_observable.predict(t3) npt.assert_almost_equal(predicted_obs3_posterior0.distr.mean, 102.990681374) npt.assert_almost_equal(predicted_obs3_posterior0.distr.cov, 39.319665849) npt.assert_almost_equal(predicted_obs3_posterior0.cross_cov, npu.row(39.319665849, 0.0, 0.0)) predicted_obs3_posterior1 = coord1_observable.predict(t3) npt.assert_almost_equal(predicted_obs3_posterior1.distr.mean, 125.332643059) npt.assert_almost_equal(predicted_obs3_posterior1.distr.cov, 4.541349469) npt.assert_almost_equal(predicted_obs3_posterior1.cross_cov, npu.row(0.0, 4.541349469, -2.237058941)) predicted_obs3_posterior2 = coord2_observable.predict(t3) npt.assert_almost_equal(predicted_obs3_posterior2.distr.mean, 136.356670319) npt.assert_almost_equal(predicted_obs3_posterior2.distr.cov, 39.495767563) npt.assert_almost_equal(predicted_obs3_posterior2.cross_cov, npu.row(0.0, -2.237058941, 39.495767563))
def create_2d(pct_drift1, pct_drift2, pct_sd1, pct_sd2, pct_cor): return GeometricBrownianMotion( npu.col(pct_drift1, pct_drift2), stats.make_vol_2d(pct_sd1, pct_sd2, pct_cor))
def create2d(mean1, mean2, sd1, sd2, cor): return WienerProcess(npu.col(mean1, mean2), distrs.NormalDistr.makevol2d(sd1, sd2, cor))