def case_state_solution_based(rng: np.random.Generator, ): """State of a solution-based linear solver.""" initial_state = linalg.solvers.LinearSolverState(problem=linsys, prior=prior) initial_state.action = rng.standard_normal( size=initial_state.problem.A.shape[1]) initial_state.observation = rng.standard_normal() return initial_state
def block(gen: np.random.Generator, statistic: str, num: int, trend: str) -> NDArray: max_sample = max(SAMPLE_SIZES) e = gen.standard_normal((num, max_sample, MAX_STOCHASTIC_TRENDS)) z = e.cumsum(axis=1) columns = DF_Z_COLUMNS if statistic == "a" else DF_P_COLUMNS results = np.empty((num, len(columns))) loc = 0 for ss in SAMPLE_SIZES: for ns in range(1, MAX_STOCHASTIC_TRENDS + 1): omega_dof = ss - 2 * ns - len(trend) z_a = z_t = p_u = p_z = np.full(z.shape[0], np.nan) if omega_dof >= 20: if statistic == "z": z_a, z_t = z_tests_vec(z[:, :ss, :ns], 0, trend=trend) elif statistic == "p": p_u, p_z = p_tests_vec(z[:, :ss, :ns], 0, trend=trend) else: raise ValueError(f"statistic must be a or p, saw {statistic}") if statistic == "z": stats = np.column_stack([z_a, z_t]) else: # p stats = np.column_stack([p_u, p_z]) stride = stats.shape[1] results[:, loc : loc + stride] = stats loc += stride return results
def test_real_forward_adjoint(rng: np.random.Generator, method, order): shape = ssht.sample_shape(order, Method=method) f = rng.standard_normal(shape, dtype="float64") flm = ssht.forward(f, order, Reality=True, Method=method) f = ssht.inverse(flm, order, Reality=True, Method=method) f_prime = rng.standard_normal(shape, dtype="float64") flm_prime = ssht.forward(f_prime, order, Reality=True, Method=method) f_prime = ssht.forward_adjoint(flm_prime, order, Reality=True, Method=method, backend="ducc") assert flm_prime.conj() @ flm == approx( f_prime.flatten().conj() @ f.flatten())
def case_state( rng: np.random.Generator, ): """State of a linear solver.""" state = linalg.solvers.LinearSolverState(problem=linsys, prior=prior, rng=rng) state.action = rng.standard_normal(size=state.problem.A.shape[1]) return state
def test_forward_adjoint(rng: np.random.Generator, spin, method, order): flm = rng.standard_normal( (order * order, 2), dtype="float64") @ np.array([1, 1j]) flm[0:spin * spin] = 0.0 f = ssht.inverse(flm, order, Spin=spin, Method=method, backend="ducc") flm_prime = rng.standard_normal( (order * order, 2), dtype="float64") @ np.array([1, 1j]) flm_prime[0:spin * spin] = 0.0 f_prime = ssht.forward_adjoint(flm_prime, order, Spin=spin, Method=method, backend="ducc") assert flm_prime.conj() @ flm == approx( f_prime.flatten().conj() @ f.flatten())
def case_state_symmetric_matrix_based(rng: np.random.Generator, ): """State of a symmetric matrix-based linear solver.""" prior = linalg.solvers.beliefs.LinearSystemBelief( A=randvars.Normal( mean=linops.Matrix(linsys.A), cov=linops.SymmetricKronecker(A=linops.Identity(n)), ), x=(Ainv @ b[:, None]).reshape((n, )), Ainv=randvars.Normal( mean=linops.Identity(n), cov=linops.SymmetricKronecker(A=linops.Identity(n)), ), b=b, ) state = linalg.solvers.LinearSolverState(problem=linsys, prior=prior) state.action = rng.standard_normal(size=state.problem.A.shape[1]) state.observation = rng.standard_normal(size=state.problem.A.shape[1]) return state
def add_noise_column(X: pd.DataFrame, rng: np.random.Generator, noise_columns: List[str] = None, count: int = 1) -> Tuple[pd.DataFrame, List[str]]: """ Create a copy of dataset X with extra synthetic columns generated from standard normal distribution. """ X = X.copy() if noise_columns is None: noise_columns = [str(uuid.uuid4()) for _ in range(1, count + 1)] for col_name in noise_columns: noise = rng.standard_normal(len(X)) X[col_name] = noise return X, noise_columns
def sample_wiener( t: np.ndarray, init_x: np.ndarray, mu: np.ndarray = None, ome: np.random.Generator = np.random.default_rng() ) -> np.ndarray: """Sample from a multivariate Wiener process at given times. :param t: :param init_x: :param mu: :param ome: :return: >>> # generate fixture >>> n = int(1e5) >>> init_x = np.random.normal(n) >>> mu = np.random.normal(n) >>> t = np.sort(np.random.uniform(size=10)) >>> # draw iid samples >>> xt = sample_wiener(t, np.repeat(init_x, n), np.repeat(mu, n)) >>> # test mahalanobis distance sampling distribution >>> from scipy.stats import kstest, norm >>> alpha = 1e-2 >>> true_mean, true_cov = moments.moments_wiener(t, init_x, mu) >>> sample = np.linalg.solve(np.linalg.cholesky(true_cov), xt - true_mean[:, np.newaxis]).flatten() >>> alpha < kstest(sample, norm().cdf)[1] True """ assert 0 < np.min(t) dt = np.ediff1d(t, to_begin=(t[0], )) dxt = np.sqrt(dt)[:, np.newaxis] * ome.standard_normal( (len(t), len(init_x))) if mu is not None: dxt += np.outer(dt, mu) xt = np.cumsum(dxt, axis=0) + init_x return xt
def euler_simulate( ndraws: int, fin_t: float = 1, init_x: float = 0, dfunc: Callable[[float], float] = (lambda x: 0), vfunc: Callable[[float], float] = (lambda x: 1), res: float = 1e-3, ome: np.random.Generator = np.random.default_rng() ) -> (np.ndarray, np.ndarray): """Simulate from a diffusion with given mu and volatility function by way of discrete approximation. :param ndraws: :param fin_t: :param init_x: :param dfunc: :param vfunc: :param res: :param ome: :return: >>> # simulate Bessel-3 on [0, 1] from x0=1 >>> nsamples = int(1e4) >>> t, y = euler_simulate(nsamples, 1, 1, lambda x: 1 / x, lambda x: 1) >>> # test >>> from scipy.stats import kstest, ncx2 >>> alpha = 1e-2 >>> alpha < kstest(y[:, -1] ** 2 / t[-1], ncx2(3, 1 / t[-1]).cdf)[1] True """ noise = np.sqrt(res) * ome.standard_normal((int(fin_t / res), ndraws)) trajectory = [np.array(ndraws * [init_x])] for e in noise: trajectory.append(trajectory[-1] + dfunc(trajectory[-1]) * res + vfunc(trajectory[-1]) * e) return np.arange(0, fin_t, res), np.array(trajectory).T