def direct_gls(eqns, scale):
y = []
x = []
for key in eqns:
y.append(eqns[key]["dependent"])
x.append(eqns[key]["exog"])
y = scale * np.vstack(y)
from scipy.sparse import csc_matrix, lil_matrix
n, k = x[0].shape
_x = lil_matrix((len(x) * n, len(x) * k))
for i, val in enumerate(x):
_x[i * n:(i + 1) * n, i * k:(i + 1) * k] = val
from scipy.sparse.linalg import inv as spinv
b = spinv(csc_matrix(_x.T @ _x)) @ (_x.T @ y)
e = y - _x @ b
e = e.reshape((-1, n)).T
sigma = e.T @ e / n
omega_inv = np.kron(np.linalg.inv(sigma), np.eye(n))
b_gls = np.linalg.inv(_x.T @ omega_inv @ _x) @ (_x.T @ omega_inv @ y)
xpx = _x.T @ omega_inv @ _x / n
xpxi = np.linalg.inv(xpx)
e = y - _x @ b_gls
xe = (_x.T @ omega_inv).T * e
_xe = np.zeros((n, len(x) * k))
for i in range(len(x)):
_xe += xe[i * n:(i + 1) * n]
xeex = _xe.T @ _xe / n
cov = xpxi @ xeex @ xpxi / n
return b_gls, cov, xpx, xeex, _xe
def compute_fundamental_matrix(P, fast=True, drop_tol=1e-5, fill_factor=1000):
"""Computes the fundamental matrix for an absorbing random walk.
Parameters
----------
P : scipy.sparse matrix
The transition probability matrix of the absorbing random walk. To
construct this matrix, you start from the original transition matrix
and delete the rows that correspond to the absorbing nodes.
fast : bool, optional
If True (default), use the iterative SuperLU solver from
scipy.sparse.linalg.
drop_tol : float, optional
If `fast` is True, the `drop_tol` parameter of the SuperLU solver is
set to this value (default is 1e-5).
fill_factor: int, optional
If `If `fast` is True, the `fill_factor` parameter of the SuperLU
solver is set to this value (default is 1000).
Returns
-------
F : scipy.sparse matrix
The fundamental matrix of the random walk. Element (i,j) holds the
expected number of times the random walk will be in state j before
absorption, when it starts from state i. For more information, check
[1]_.
References
----------
.. [1] Doyle, Peter G., and J. Laurie Snell.
Random walks and electric networks.
Carus mathematical monographs 22 (2000).
https://math.dartmouth.edu/~doyle/docs/walks/walks.pdf
"""
n = P.shape[0]
F_inv = speye(n, format='csc') - P.tocsc()
if fast:
solver = spilu(F_inv, drop_tol=drop_tol, fill_factor=fill_factor)
F = matrix(solver.solve(eye(n)))
else:
F = spinv(F_inv).todense()
return F
def compute_fundamental_matrix(P, fast=True, drop_tol=1e-5, fill_factor=1000):
"""Computes the fundamental matrix for an absorbing random walk.
Parameters
----------
P : scipy.sparse matrix
The transition probability matrix of the absorbing random walk. To
construct this matrix, you start from the original transition matrix
and delete the rows that correspond to the absorbing nodes.
fast : bool, optional
If True (default), use the iterative SuperLU solver from
scipy.sparse.linalg.
drop_tol : float, optional
If `fast` is True, the `drop_tol` parameter of the SuperLU solver is
set to this value (default is 1e-5).
fill_factor: int, optional
If `If `fast` is True, the `fill_factor` parameter of the SuperLU
solver is set to this value (default is 1000).
Returns
-------
F : scipy.sparse matrix
The fundamental matrix of the random walk. Element (i,j) holds the
expected number of times the random walk will be in state j before
absorption, when it starts from state i. For more information, check
[1]_.
References
----------
.. [1] Doyle, Peter G., and J. Laurie Snell.
Random walks and electric networks.
Carus mathematical monographs 22 (2000).
https://math.dartmouth.edu/~doyle/docs/walks/walks.pdf
"""
n = P.shape[0]
F_inv = speye(n, format='csc') - P.tocsc()
if fast:
solver = spilu(F_inv, drop_tol=drop_tol, fill_factor=fill_factor)
F = matrix(solver.solve(eye(n)))
else:
F = spinv(F_inv).todense()
return F
def create_inv_susceptance_matrix(branches, nodes, slack_node):
t1 = time.clock()
B = np.zeros((len(nodes), len(nodes)))
for branch in branches:
i = branch.node_from.index
j = branch.node_to.index
B[i, i] += -1 / branch.impedance
B[j, j] += -1 / branch.impedance
B[i, j] += 1 / branch.impedance
B[j, i] += 1 / branch.impedance
B = np.delete(B, slack_node.index, axis=0)
B = np.delete(B, slack_node.index, axis=1)
logging.info(f"Susceptance matrix B built in {round(time.clock() - t1, 2)} seconds.")
t1 = time.clock()
B2 = csr_matrix(B)
invB2 = spinv(B2)
inverseB = invB2.toarray()
logging.info(f"Susceptance matrix B inverted in {round(time.clock() - t1, 2)} seconds.")
return inverseB
def inv_vcov_matrix(self, incidence_matrices, covariance_matrices, variance_components):
V = vcov_matrix(
incidence_matrices, covariance_matrices, variance_components)
return spinv(V) if issparse(V) else inv(V)