Пример #1
0
from dcprogs.likelihood import eig
from dcprogs.likelihood import find_upper_bound_for_roots, find_lower_bound_for_roots,        \
                               find_root_intervals, brentq, find_roots, QMatrix, DeterminantEq

qmatrix = QMatrix([ [-3050,        50,  3000,      0,    0], 
                    [2./3., -1502./3.,     0,    500,    0], 
                    [   15,         0, -2065,     50, 2000], 
                    [    0,     15000,  4000, -19000,    0], 
                    [    0,         0,    10,      0,  -10] ], 2)
det = DeterminantEq(qmatrix, 1e-4);


upper_bound = find_upper_bound_for_roots(det);
lower_bound = find_lower_bound_for_roots(det);

get_eigenvalues = lambda s: eig(det.H(s))[0].T
assert all(get_eigenvalues(lower_bound) > lower_bound) 
assert all(get_eigenvalues(upper_bound) < upper_bound) 


print("Root Determination\n"                                         \
      "==================\n\n"                                       \
      "  * Interval containing roots: {lower}, {upper}\n"            \
      "  * Eigenvalues of H at lower bound: {eiglow}\n"              \
      "  * Eigenvalues of H at upper bound: {eigup}\n"               \
      .format( lower=lower_bound, upper=upper_bound,
               eiglow = get_eigenvalues(lower_bound),
               eigup  = get_eigenvalues(upper_bound) ))

intervals = find_root_intervals(det, lower_bound, upper_bound)
for (start, end), multiplicity in intervals:
Пример #2
0
from dcprogs.likelihood import DeterminantEq, QMatrix

# Define parameters.
matrix = [[-3050, 50, 3000, 0, 0], [2. / 3., -1502. / 3., 0, 500, 0],
          [15, 0, -2065, 50, 2000], [0, 15000, 4000, -19000, 0],
          [0, 0, 10, 0, -10]]
qmatrix = QMatrix(matrix, 2)
tau = 1e-4

det0 = DeterminantEq(qmatrix, 1e-4)
det1 = DeterminantEq(matrix, 2, 1e-4)

print("{0!s}\n\n{1!s}".format(det0, det1))

x = [0, -1, -1e2]
assert all(abs(det0(x) - det1(x)) < 1e-8)

roots = array([-3045.285776037674, -162.92946543451328])
assert all(abs(det0(roots)) < 1e-6 * abs(roots))

transpose = det0.transpose()
roots = array([-17090.192769236815, -2058.0812921673496, -0.24356535498785126],
              dtype=internal_dtype)
assert all(abs(transpose(roots)) < 1e-6 * abs(roots))

print("  * H({0}):\n{1}\n".format(0, det0.H(0)))
print("  * H({0}):\n{1}\n".format(-1e2, det0.H(-1e2)))
print("  * d[sI-H(s)]/ds for s={0}:\n{1}\n".format(0, det0.s_derivative(0)))
print("  * d[sI-H(s)]/ds for s={0}:\n{1}\n".format(-1e2,
                                                   det0.s_derivative(-1e2)))