def _hinv(A00, A01, A11):
from numpy_sugar import is_all_finite
rcond = 1e-15
b = atleast_1d(A01)
d = atleast_1d(A11)
a = full_like(d, A00)
m = maximum(maximum(npy_abs(b), npy_abs(d)), abs(a))
a /= m
b = b / m
c = b
d = d / m
bc = b * c
ad = a * d
with errstate(invalid="ignore", divide="ignore"):
ai = a / (a * a - nan_to_num((bc * a) / d))
bi = b / (b * b - nan_to_num(ad))
di = d / (d * d - nan_to_num((bc * d) / a))
ai /= m
bi /= m
di /= m
ok = is_all_finite(ai) and is_all_finite(bi) and is_all_finite(di)
if not ok:
ok = logical_and.reduce([isfinite(ai), isfinite(bi), isfinite(di)])
nok = logical_not(ok)
U, S, VT = hsvd(a[nok], b[nok], d[nok])
maxi = maximum(npy_abs(S[0]), npy_abs(S[1]))
cutoff = rcond * maxi
large = S[0] > cutoff
S[0] = divide(1, S[0], where=large, out=S[0])
S[0][~large] = 0
large = S[1] > cutoff
S[1] = divide(1, S[1], where=large, out=S[1])
S[1][~large] = 0
SiVT = [[VT[0][0] * S[0], VT[0][1] * S[0]],
[VT[1][0] * S[1], VT[1][1] * S[1]]]
Ai = [
[
U[0][0] * SiVT[0][0] + U[0][1] * SiVT[1][0],
U[0][0] * SiVT[0][1] + U[0][1] * SiVT[1][1],
],
[
U[1][0] * SiVT[0][0] + U[1][1] * SiVT[1][0],
U[1][0] * SiVT[0][1] + U[1][1] * SiVT[1][1],
],
]
ai[nok] = Ai[0][0] / m
bi[nok] = Ai[0][1] / m
di[nok] = Ai[1][1] / m
return ai, bi, di
def effsizes_se(effsizes, pvalues):
r"""Standard errors of the effect sizes.
Parameters
----------
effsizes : array_like
Effect sizes.
pvalues : array_like
Association significance corresponding to those effect sizes.
Returns
-------
array_like
Standard errors of the effect sizes.
"""
from scipy.stats import chi2
from numpy import abs as npy_abs
from numpy import sqrt
return npy_abs(effsizes) / sqrt(chi2(1).isf(pvalues))
def _norm(x0, x1):
m = maximum(npy_abs(x0), npy_abs(x1))
with errstate(invalid="ignore"):
a = (x0 / m) * (x0 / m)
b = (x1 / m) * (x1 / m)
return nan_to_num(m * sqrt(a + b))
def hsolve(A00, A01, A11, y0, y1):
"""
Solver for the linear equations of two variables and equations only.
It uses Householder reductions to solve A𝐱 = 𝐲 in a robust manner.
Parameters
----------
A : array_like
Coefficient matrix.
y : array_like
Ordinate values.
Returns
-------
ndarray
Solution 𝐱.
"""
from numpy_sugar import epsilon
n = _norm(A00, A01)
u0 = A00 - n
u1 = A01
nu = _norm(u0, u1)
with errstate(invalid="ignore", divide="ignore"):
v0 = nan_to_num(u0 / nu)
v1 = nan_to_num(u1 / nu)
B00 = 1 - 2 * v0 * v0
B01 = 0 - 2 * v0 * v1
B11 = 1 - 2 * v1 * v1
D00 = B00 * A00 + B01 * A01
D01 = B00 * A01 + B01 * A11
D11 = B01 * A01 + B11 * A11
b0 = y0 - 2 * y0 * v0 * v0 - 2 * y1 * v0 * v1
b1 = y1 - 2 * y0 * v1 * v0 - 2 * y1 * v1 * v1
n = _norm(D00, D01)
u0 = D00 - n
u1 = D01
nu = _norm(u0, u1)
with errstate(invalid="ignore", divide="ignore"):
v0 = nan_to_num(u0 / nu)
v1 = nan_to_num(u1 / nu)
E00 = 1 - 2 * v0 * v0
E01 = 0 - 2 * v0 * v1
E11 = 1 - 2 * v1 * v1
F00 = E00 * D00 + E01 * D01
F01 = E01 * D11
F11 = E11 * D11
F11 = (npy_abs(F11) > epsilon.small) * F11
with errstate(divide="ignore", invalid="ignore"):
Fi00 = nan_to_num(F00 / F00 / F00)
Fi11 = nan_to_num(F11 / F11 / F11)
Fi10 = nan_to_num(-(F01 / F00) * Fi11)
c0 = Fi00 * b0
c1 = Fi10 * b0 + Fi11 * b1
x0 = E00 * c0 + E01 * c1
x1 = E01 * c0 + E11 * c1
return array([x0, x1])
def hsolve(A, y):
r"""Solver for the linear equations of two variables and equations only.
It uses Householder reductions to solve ``Ax = y`` in a robust manner.
Parameters
----------
A : array_like
Coefficient matrix.
y : array_like
Ordinate values.
Returns
-------
:class:`numpy.ndarray` Solution ``x``.
"""
n = _norm(A[0, 0], A[1, 0])
u0 = A[0, 0] - n
u1 = A[1, 0]
nu = _norm(u0, u1)
with errstate(invalid="ignore", divide="ignore"):
v0 = nan_to_num(u0 / nu)
v1 = nan_to_num(u1 / nu)
B00 = 1 - 2 * v0 * v0
B01 = 0 - 2 * v0 * v1
B11 = 1 - 2 * v1 * v1
D00 = B00 * A[0, 0] + B01 * A[1, 0]
D01 = B00 * A[0, 1] + B01 * A[1, 1]
D11 = B01 * A[0, 1] + B11 * A[1, 1]
b0 = y[0] - 2 * y[0] * v0 * v0 - 2 * y[1] * v0 * v1
b1 = y[1] - 2 * y[0] * v1 * v0 - 2 * y[1] * v1 * v1
n = _norm(D00, D01)
u0 = D00 - n
u1 = D01
nu = _norm(u0, u1)
with errstate(invalid="ignore", divide="ignore"):
v0 = nan_to_num(u0 / nu)
v1 = nan_to_num(u1 / nu)
E00 = 1 - 2 * v0 * v0
E01 = 0 - 2 * v0 * v1
E11 = 1 - 2 * v1 * v1
F00 = E00 * D00 + E01 * D01
F01 = E01 * D11
F11 = E11 * D11
F11 = (npy_abs(F11) > epsilon.small) * F11
with errstate(divide="ignore", invalid="ignore"):
Fi00 = nan_to_num(F00 / F00 / F00)
Fi11 = nan_to_num(F11 / F11 / F11)
Fi10 = nan_to_num(-(F01 / F00) * Fi11)
c0 = Fi00 * b0
c1 = Fi10 * b0 + Fi11 * b1
x0 = E00 * c0 + E01 * c1
x1 = E01 * c0 + E11 * c1
return array([x0, x1])