def fit_finite_diff_target_gradients(gfit, power, use_sigmas, eps=1.e-2):
assert gfit.table_x().size() == 1
weight = 1 / gfit.table_sigmas()[0]**2
gr = flex.double()
c = gfit.c()
use_c = gfit.use_c()
for i in range(gfit.n_terms()):
t = []
for seps in (eps, -eps):
a = list(gfit.array_of_a())
a[i] += seps
gf = gaussian.fit(gfit.table_x(), gfit.table_y(),
gfit.table_sigmas(),
gaussian.sum(a, gfit.array_of_b(), c, use_c))
t.append(gf.target_function(power, use_sigmas, gf.differences()))
gr.append((t[0] - t[1]) / (2 * eps))
t = []
for seps in (eps, -eps):
b = list(gfit.array_of_b())
b[i] += seps
gf = gaussian.fit(gfit.table_x(), gfit.table_y(),
gfit.table_sigmas(),
gaussian.sum(gfit.array_of_a(), b, c, use_c))
t.append(gf.target_function(power, use_sigmas, gf.differences()))
gr.append((t[0] - t[1]) / (2 * eps))
if (use_c):
t = []
for seps in (eps, -eps):
gf = gaussian.fit(
gfit.table_x(), gfit.table_y(), gfit.table_sigmas(),
gaussian.sum(gfit.array_of_a(), gfit.array_of_b(), c + seps,
use_c))
t.append(gf.target_function(power, use_sigmas, gf.differences()))
gr.append((t[0] - t[1]) / (2 * eps))
return gr
def fit_finite_diff_gradients(gfit, x, eps=1.e-2):
gr = flex.double()
c = gfit.c()
use_c = gfit.use_c()
for i in xrange(gfit.n_terms()):
t = []
for seps in (eps, -eps):
a = list(gfit.array_of_a())
a[i] += seps
t.append(
gaussian.sum(a, gfit.array_of_b(), c, use_c).at_x(x))
gr.append((t[0]-t[1])/(2*eps))
t = []
for seps in (eps, -eps):
b = list(gfit.array_of_b())
b[i] += seps
t.append(
gaussian.sum(gfit.array_of_a(), b, c, use_c).at_x(x))
gr.append((t[0]-t[1])/(2*eps))
if (use_c):
t = []
for seps in (eps, -eps):
t.append(
gaussian.sum(
gfit.array_of_a(), gfit.array_of_b(), c+seps, use_c).at_x(x))
gr.append((t[0]-t[1])/(2*eps))
return gr
def fit_finite_diff_gradients(gfit, x, eps=1.e-2):
gr = flex.double()
c = gfit.c()
use_c = gfit.use_c()
for i in range(gfit.n_terms()):
t = []
for seps in (eps, -eps):
a = list(gfit.array_of_a())
a[i] += seps
t.append(gaussian.sum(a, gfit.array_of_b(), c, use_c).at_x(x))
gr.append((t[0] - t[1]) / (2 * eps))
t = []
for seps in (eps, -eps):
b = list(gfit.array_of_b())
b[i] += seps
t.append(gaussian.sum(gfit.array_of_a(), b, c, use_c).at_x(x))
gr.append((t[0] - t[1]) / (2 * eps))
if (use_c):
t = []
for seps in (eps, -eps):
t.append(
gaussian.sum(gfit.array_of_a(), gfit.array_of_b(), c + seps,
use_c).at_x(x))
gr.append((t[0] - t[1]) / (2 * eps))
return gr
def hessian_analytical(self, x):
j = self.jacobian_analytical(x=x)
fit = gaussian.fit(
self.fit.table_x(), self.fit.table_y(), self.fit.table_sigmas(),
gaussian.sum(x))
return fit.least_squares_hessian_abc_as_packed_u() \
.matrix_packed_u_as_symmetric()
def fit_finite_diff_target_gradients(gfit, power, use_sigmas, eps=1.e-2):
assert gfit.table_x().size() == 1
weight = 1/gfit.table_sigmas()[0]**2
gr = flex.double()
c = gfit.c()
use_c = gfit.use_c()
for i in xrange(gfit.n_terms()):
t = []
for seps in (eps, -eps):
a = list(gfit.array_of_a())
a[i] += seps
gf = gaussian.fit(
gfit.table_x(),
gfit.table_y(),
gfit.table_sigmas(),
gaussian.sum(a, gfit.array_of_b(), c, use_c))
t.append(gf.target_function(power, use_sigmas, gf.differences()))
gr.append((t[0]-t[1])/(2*eps))
t = []
for seps in (eps, -eps):
b = list(gfit.array_of_b())
b[i] += seps
gf = gaussian.fit(
gfit.table_x(),
gfit.table_y(),
gfit.table_sigmas(),
gaussian.sum(gfit.array_of_a(), b, c, use_c))
t.append(gf.target_function(power, use_sigmas, gf.differences()))
gr.append((t[0]-t[1])/(2*eps))
if (use_c):
t = []
for seps in (eps, -eps):
gf = gaussian.fit(
gfit.table_x(),
gfit.table_y(),
gfit.table_sigmas(),
gaussian.sum(gfit.array_of_a(), gfit.array_of_b(), c+seps, use_c))
t.append(gf.target_function(power, use_sigmas, gf.differences()))
gr.append((t[0]-t[1])/(2*eps))
return gr
def __init__(self, tab_fit, perturb, verbose):
self.tab_fit = tab_fit
self.perturb = perturb
self.verbose = verbose
carbon_ss = flex.double(carbon_s_y_table)[0::2]
carbon_ys = flex.double(carbon_s_y_table)[1::2]
selection = carbon_ss <= tab_fit.limit + 1.e-3
self.fit = gaussian.fit(
carbon_ss.select(selection),
carbon_ys.select(selection),
flex.double(selection.count(True), 1),
gaussian.sum(flex.double(tab_fit.coefficients)))
n = self.fit.n_parameters()
immoptibox_ports.test_function.__init__(self,
m=self.fit.table_x().size(),
n=n,
check_with_finite_differences=(n <= 6 or n == 9),
verbose=verbose)
def __init__(self, tab_fit, perturb, verbose):
self.tab_fit = tab_fit
self.perturb = perturb
self.verbose = verbose
carbon_ss = flex.double(carbon_s_y_table)[0::2]
carbon_ys = flex.double(carbon_s_y_table)[1::2]
selection = carbon_ss <= tab_fit.limit + 1.e-3
self.fit = gaussian.fit(
carbon_ss.select(selection), carbon_ys.select(selection),
flex.double(selection.count(True), 1),
gaussian.sum(flex.double(tab_fit.coefficients)))
n = self.fit.n_parameters()
immoptibox_ports.test_function.__init__(
self,
m=self.fit.table_x().size(),
n=n,
check_with_finite_differences=(n <= 6 or n == 9),
verbose=verbose)
def exercise_sum():
g = gaussian.sum(0)
assert g.n_terms() == 0
assert g.array_of_a() == ()
assert g.array_of_b() == ()
assert approx_equal(g.c(), 0)
assert g.use_c()
assert g.n_parameters() == 1
assert approx_equal(g.parameters(), [0])
g = gaussian.sum(0, True)
assert g.use_c()
g = gaussian.sum(0, False)
assert not g.use_c()
g = gaussian.sum(1)
assert g.n_terms() == 0
assert g.array_of_a() == ()
assert g.array_of_b() == ()
assert approx_equal(g.c(), 1)
assert g.use_c()
assert g.n_parameters() == 1
assert approx_equal(g.parameters(), [1])
g = gaussian.sum((), ())
assert g.n_terms() == 0
assert g.array_of_a() == ()
assert g.array_of_b() == ()
assert g.c() == 0
assert not g.use_c()
assert g.n_parameters() == 0
assert g.parameters().size() == 0
g = gaussian.sum((), (), -2)
assert g.n_terms() == 0
assert g.array_of_a() == ()
assert g.array_of_b() == ()
assert approx_equal(g.c(), -2)
g = gaussian.sum(flex.double((1,2,3,4)))
assert approx_equal(g.array_of_a(), (1,3))
assert approx_equal(g.array_of_b(), (2,4))
assert approx_equal(g.c(), 0)
assert not g.use_c()
assert approx_equal(g.parameters(), [1,2,3,4])
g = gaussian.sum(flex.double((1,2,3,4)), 0, True)
assert approx_equal(g.c(), 0)
assert g.use_c()
g = gaussian.sum(flex.double((1,2,3,4)), 5)
assert approx_equal(g.c(), 5)
assert g.use_c()
assert approx_equal(g.parameters(), [1,2,3,4,5])
g = gaussian.sum(flex.double((1,2,3,4,5)))
assert approx_equal(g.c(), 5)
assert g.use_c()
assert approx_equal(g.parameters(), [1,2,3,4,5])
g = gaussian.sum((1,-2,3,-4,5), (-.1,.2,-.3,.4,-.5), 6)
assert g.n_terms() == 5
assert approx_equal(g.array_of_a(),(1,-2,3,-4,5))
assert approx_equal(g.array_of_b(),(-.1,.2,-.3,.4,-.5))
assert approx_equal(g.c(), 6)
assert approx_equal(g.at_x_sq(3/4.), 13.4251206)
assert approx_equal(g.at_x_sq(flex.double([2/4.,3/4.])),
[11.8723031, 13.4251206])
assert approx_equal(g.at_x(math.sqrt(3/4.)), 13.4251206)
assert approx_equal(g.at_x(flex.sqrt(flex.double([2/4.,3/4.]))),
[11.8723031, 13.4251206])
s = pickle.dumps(g)
l = pickle.loads(s)
assert l.n_terms() == g.n_terms()
assert approx_equal(l.array_of_a(), g.array_of_a())
assert approx_equal(l.array_of_b(), g.array_of_b())
assert approx_equal(l.c(), g.c())
assert l.use_c()
s = pickle.dumps(gaussian.sum((),()))
l = pickle.loads(s)
assert not l.use_c()
exercise_gradient_dx(gaussian.sum(
[5.5480], [10.4241], 0))
exercise_gradient_dx(gaussian.sum(
[2.657506,1.078079,1.490909,-4.241070,0.713791],
[14.780758,0.776775,42.086842,-0.000294,0.239535],
4.297983))
exercise_integral_dx(gaussian.sum([5.5480], [10.4241]))
exercise_integral_dx(gaussian.sum([5.5480], [10.4241], 3))
exercise_integral_dx(gaussian.sum([5.5480], [0], 0))
exercise_integral_dx(gaussian.sum([5.5480], [-0.01]))
exercise_integral_dx(gaussian.sum(
[2.657506,1.078079,1.490909,-4.241070,0.713791],
[14.780758,0.776775,42.086842,-0.000294,0.239535],
4.297983))
g = gaussian.sum((1,-2,3,-4,5), (-.1,.2,-.3,.4,-.5), 6)
s = StringIO()
g.show(s)
assert len(s.getvalue().split()) == 14
g = gaussian.sum((3,-2,1,-4,5), (-.3,.2,-.1,.4,-.5))
s = StringIO()
g.show(s)
assert len(s.getvalue().split()) == 12
assert isinstance(g.sort(), gaussian.sum)
assert approx_equal(g.sort().array_of_a(), (5,-4,3,-2,1))
assert approx_equal(g.sort().array_of_b(), (-.5,.4,-.3,.2,-.1))
assert not g.sort().use_c()
g = gaussian.sum((1,2),(3,4),5)
assert approx_equal(g.sort().array_of_a(), (2,1))
assert approx_equal(g.sort().array_of_b(), (4,3))
assert approx_equal(g.sort().c(), 5)
assert g.sort().use_c()
def jacobian_analytical(self, x):
fit = gaussian.fit(
self.fit.table_x(), self.fit.table_y(), self.fit.table_sigmas(),
gaussian.sum(x))
return fit.least_squares_jacobian_abc()
def f(self, x):
fit = gaussian.fit(
self.fit.table_x(), self.fit.table_y(), self.fit.table_sigmas(),
gaussian.sum(x))
return fit.differences()
def exercise_fit():
x = flex.double((0.1, 0.2, 0.5))
y = flex.double((3,2,1))
sigmas = flex.double((0.04,0.02,0.01))
gf = gaussian.fit(
x, y, sigmas,
gaussian.sum((1,2), (4,5)))
assert approx_equal(gf.array_of_a(), (1,2))
assert approx_equal(gf.array_of_b(), (4,5))
assert approx_equal(gf.c(), 0)
assert not gf.use_c()
assert approx_equal(gf.table_x(), x)
assert approx_equal(gf.table_y(), y)
assert approx_equal(gf.table_sigmas(), sigmas)
assert approx_equal(gf.fitted_values(),
[2.8632482881537511, 2.4896052951221748, 0.94088903489182252])
reference_gaussian = gaussian.sum((1,2,3), (4,5,6))
gf = gaussian.fit(
x, reference_gaussian, sigmas,
gaussian.sum((1,2), (4,5)))
assert approx_equal(gf.array_of_a(), (1,2))
assert approx_equal(gf.array_of_b(), (4,5))
assert approx_equal(gf.c(), 0)
assert approx_equal(gf.table_x(), x)
assert approx_equal(gf.table_y(), reference_gaussian.at_x(x))
assert approx_equal(gf.table_sigmas(), sigmas)
assert isinstance(gf.sort(), gaussian.fit)
assert gf.sort().table_x() == gf.table_x()
assert gf.sort().table_y() == gf.table_y()
assert gf.sort().table_sigmas() == gf.table_sigmas()
assert approx_equal(gf.differences(), gf.at_x(x)-reference_gaussian.at_x(x))
c_fit = gaussian.fit(
flex.double([0.0, 0.066666666666666666, 0.13333333333333333,
0.2, 0.26666666666666666]),
gaussian.sum(
(2.657506, 1.078079, 1.490909, -4.2410698, 0.71379101),
(14.780758, 0.776775, 42.086842, -0.000294, 0.239535),
4.2979832),
flex.double(5, 0.0005),
gaussian.sum(
(1.1423916, 4.1728425, 0.61716694),
(0.50733125, 14.002512, 41.978928)))
differences = flex.double([-0.064797341823577881, 0.003608505180995536,
0.098159179757290715, 0.060724224581695019, -0.10766283796372011])
assert approx_equal(c_fit.differences(), differences)
assert approx_equal(c_fit.significant_relative_errors(),
[0.0107212, 0.0005581, 0.0213236, 0.0169304, 0.0385142])
gf = gaussian.fit(
x, reference_gaussian, flex.double(x.size(), 1),
gaussian.sum((1,2), (4,5)))
assert list(gf.bound_flags(False, False)) == [False,False,False,False]
assert list(gf.bound_flags(True, False)) == [True,False,True,False]
assert list(gf.bound_flags(False, True)) == [False,True,False,True]
sgf = gf.apply_shifts(flex.double((3,-3,4,6)), True)
assert approx_equal(sgf.array_of_a(), (1+3,2+4))
assert approx_equal(sgf.array_of_b(),
((math.sqrt(4)-3)**2,(math.sqrt(5)+6)**2))
assert approx_equal(sgf.c(), 0)
assert not sgf.use_c()
sgf = gf.apply_shifts(flex.double((3,-3,4,6)), False)
assert approx_equal(sgf.array_of_a(), (1+3,2+4))
assert approx_equal(sgf.array_of_b(), (4-3,5+6))
assert approx_equal(sgf.c(), 0)
assert not sgf.use_c()
differences = sgf.differences()
for use_sigmas in [False, True]:
assert approx_equal(sgf.target_function(2, use_sigmas, differences),
25.0320634)
assert approx_equal(sgf.target_function(4, use_sigmas, differences),
256.2682575)
assert approx_equal(
sgf.gradients_d_abc(2, use_sigmas, differences),
[15.6539271, -4.1090114, 10.4562306, -1.6376781])
gfc = gaussian.fit(
x, reference_gaussian, flex.double(x.size(), 1),
gaussian.sum((1,2), (4,5), 6))
assert list(gfc.bound_flags(False, False)) == [False,False,False,False,False]
assert list(gfc.bound_flags(True, False)) == [True,False,True,False,True]
assert list(gfc.bound_flags(False, True)) == [False,True,False,True,False]
sgfc = gfc.apply_shifts(flex.double((3,-3,4,6,-5)), True)
assert approx_equal(sgfc.array_of_a(), (1+3,2+4))
assert approx_equal(sgfc.array_of_b(),
((math.sqrt(4)-3)**2,(math.sqrt(5)+6)**2))
assert approx_equal(sgfc.c(), 6-5)
assert sgfc.use_c()
sgfc = gfc.apply_shifts(flex.double((3,-3,4,6,-5)), False)
assert approx_equal(sgfc.array_of_a(), (1+3,2+4))
assert approx_equal(sgfc.array_of_b(), (4-3,5+6))
assert approx_equal(sgfc.c(), 6-5)
assert sgfc.use_c()
differences = sgfc.differences()
for use_sigmas in [False, True]:
assert approx_equal(sgfc.target_function(2, use_sigmas, differences),
44.8181444)
assert approx_equal(sgfc.target_function(4, use_sigmas, differences),
757.3160329)
assert approx_equal(
sgfc.gradients_d_abc(2, use_sigmas, differences),
[21.1132071, -6.0532695, 13.6638274, -2.2460994, 22.7860809])
differences = c_fit.differences()
gabc = c_fit.gradients_d_abc(2, False, differences)
assert approx_equal(
gabc,
[-0.016525391425206391, 0.0074465239375589107, 0.020055876723667564,
0.00054794635257838251, -0.018754011379726425, -0.0011194004809549143])
assert approx_equal(
c_fit.gradients_d_shifts(flex.double((0.1,0.4,0.2,0.5,0.3,0.6)), gabc),
[-0.0165254, 0.01656512, 0.0200559, 0.0046488, -0.0187540, -0.0158487])
g5c = gaussian.sum(
(2.657505989074707, 1.0780789852142334, 1.4909089803695679,
-4.2410697937011719, 0.71379101276397705),
(14.780757904052734, 0.77677500247955322, 42.086841583251953,
-0.00029399999766610563, 0.23953500390052795),
4.2979831695556641)
for include_constant_term in (False, True):
a = flex.double(g5c.array_of_a())
b = flex.double(g5c.array_of_b())
permutation = flex.sort_permutation(data=flex.abs(a), reverse=True)[:4]
gf = gaussian.fit(
flex.double([0]),
g5c,
flex.double(1, 1),
gaussian.sum(
iter(a.select(permutation)),
iter(b.select(permutation)), 0, include_constant_term))
assert approx_equal(gf.differences(), [-5.01177418232])
shifts = flex.double(8,-1)
if (include_constant_term): shifts.append(-.2)
sgf = gf.apply_shifts(shifts, False)
assert approx_equal(sgf.array_of_a(),
[-5.2410698, 1.657506, 0.49090898, 0.078078985])
assert approx_equal(sgf.array_of_b(),
[-1.0002940, 13.780758, 41.086842, -0.223225])
if (include_constant_term):
assert approx_equal(sgf.c(), -.2)
expected_gradients = [1,0,1,0,1,0,1,0]
if (include_constant_term): expected_gradients.append(1)
assert approx_equal(
fit_finite_diff_gradients(sgf, 0),
expected_gradients,
eps=1.e-4)
for i in xrange(10):
gf = gaussian.fit(
flex.double([i / 10.]),
g5c,
flex.double(1, 1),
sgf)
differences = flex.double([0.5])
assert approx_equal(
gf.gradients_d_abc(2, False, differences),
fit_finite_diff_gradients(gf, gf.table_x()[0]),
eps=1.e-3)
for sigma in [0.04,0.02,0.01]:
gf = gaussian.fit(
flex.double([i / 20.]),
g5c,
flex.double([sigma]),
sgf)
for power in [2,4]:
for use_sigmas in [False, True]:
differences = gf.differences()
an=gf.gradients_d_abc(power, use_sigmas, differences)
fi=fit_finite_diff_target_gradients(gf, power, use_sigmas)
assert eps_eq(an, fi, eps=1.e-3)
def exercise_sum():
g = gaussian.sum(0)
assert g.n_terms() == 0
assert g.array_of_a() == ()
assert g.array_of_b() == ()
assert approx_equal(g.c(), 0)
assert g.use_c()
assert g.n_parameters() == 1
assert approx_equal(g.parameters(), [0])
g = gaussian.sum(0, True)
assert g.use_c()
g = gaussian.sum(0, False)
assert not g.use_c()
g = gaussian.sum(1)
assert g.n_terms() == 0
assert g.array_of_a() == ()
assert g.array_of_b() == ()
assert approx_equal(g.c(), 1)
assert g.use_c()
assert g.n_parameters() == 1
assert approx_equal(g.parameters(), [1])
g = gaussian.sum((), ())
assert g.n_terms() == 0
assert g.array_of_a() == ()
assert g.array_of_b() == ()
assert g.c() == 0
assert not g.use_c()
assert g.n_parameters() == 0
assert g.parameters().size() == 0
g = gaussian.sum((), (), -2)
assert g.n_terms() == 0
assert g.array_of_a() == ()
assert g.array_of_b() == ()
assert approx_equal(g.c(), -2)
g = gaussian.sum(flex.double((1, 2, 3, 4)))
assert approx_equal(g.array_of_a(), (1, 3))
assert approx_equal(g.array_of_b(), (2, 4))
assert approx_equal(g.c(), 0)
assert not g.use_c()
assert approx_equal(g.parameters(), [1, 2, 3, 4])
g = gaussian.sum(flex.double((1, 2, 3, 4)), 0, True)
assert approx_equal(g.c(), 0)
assert g.use_c()
g = gaussian.sum(flex.double((1, 2, 3, 4)), 5)
assert approx_equal(g.c(), 5)
assert g.use_c()
assert approx_equal(g.parameters(), [1, 2, 3, 4, 5])
g = gaussian.sum(flex.double((1, 2, 3, 4, 5)))
assert approx_equal(g.c(), 5)
assert g.use_c()
assert approx_equal(g.parameters(), [1, 2, 3, 4, 5])
g = gaussian.sum((1, -2, 3, -4, 5), (-.1, .2, -.3, .4, -.5), 6)
assert g.n_terms() == 5
assert approx_equal(g.array_of_a(), (1, -2, 3, -4, 5))
assert approx_equal(g.array_of_b(), (-.1, .2, -.3, .4, -.5))
assert approx_equal(g.c(), 6)
assert approx_equal(g.at_x_sq(3 / 4.), 13.4251206)
assert approx_equal(g.at_x_sq(flex.double([2 / 4., 3 / 4.])),
[11.8723031, 13.4251206])
assert approx_equal(g.at_x(math.sqrt(3 / 4.)), 13.4251206)
assert approx_equal(g.at_x(flex.sqrt(flex.double([2 / 4., 3 / 4.]))),
[11.8723031, 13.4251206])
s = pickle.dumps(g)
l = pickle.loads(s)
assert l.n_terms() == g.n_terms()
assert approx_equal(l.array_of_a(), g.array_of_a())
assert approx_equal(l.array_of_b(), g.array_of_b())
assert approx_equal(l.c(), g.c())
assert l.use_c()
s = pickle.dumps(gaussian.sum((), ()))
l = pickle.loads(s)
assert not l.use_c()
exercise_gradient_dx(gaussian.sum([5.5480], [10.4241], 0))
exercise_gradient_dx(
gaussian.sum([2.657506, 1.078079, 1.490909, -4.241070, 0.713791],
[14.780758, 0.776775, 42.086842, -0.000294, 0.239535],
4.297983))
exercise_integral_dx(gaussian.sum([5.5480], [10.4241]))
exercise_integral_dx(gaussian.sum([5.5480], [10.4241], 3))
exercise_integral_dx(gaussian.sum([5.5480], [0], 0))
exercise_integral_dx(gaussian.sum([5.5480], [-0.01]))
exercise_integral_dx(
gaussian.sum([2.657506, 1.078079, 1.490909, -4.241070, 0.713791],
[14.780758, 0.776775, 42.086842, -0.000294, 0.239535],
4.297983))
g = gaussian.sum((1, -2, 3, -4, 5), (-.1, .2, -.3, .4, -.5), 6)
s = StringIO()
g.show(s)
assert len(s.getvalue().split()) == 14
g = gaussian.sum((3, -2, 1, -4, 5), (-.3, .2, -.1, .4, -.5))
s = StringIO()
g.show(s)
assert len(s.getvalue().split()) == 12
assert isinstance(g.sort(), gaussian.sum)
assert approx_equal(g.sort().array_of_a(), (5, -4, 3, -2, 1))
assert approx_equal(g.sort().array_of_b(), (-.5, .4, -.3, .2, -.1))
assert not g.sort().use_c()
g = gaussian.sum((1, 2), (3, 4), 5)
assert approx_equal(g.sort().array_of_a(), (2, 1))
assert approx_equal(g.sort().array_of_b(), (4, 3))
assert approx_equal(g.sort().c(), 5)
assert g.sort().use_c()
def hessian_analytical(self, x):
j = self.jacobian_analytical(x=x)
fit = gaussian.fit(self.fit.table_x(), self.fit.table_y(),
self.fit.table_sigmas(), gaussian.sum(x))
return fit.least_squares_hessian_abc_as_packed_u() \
.matrix_packed_u_as_symmetric()
def jacobian_analytical(self, x):
fit = gaussian.fit(self.fit.table_x(), self.fit.table_y(),
self.fit.table_sigmas(), gaussian.sum(x))
return fit.least_squares_jacobian_abc()
def f(self, x):
fit = gaussian.fit(self.fit.table_x(), self.fit.table_y(),
self.fit.table_sigmas(), gaussian.sum(x))
return fit.differences()
def exercise_fit():
x = flex.double((0.1, 0.2, 0.5))
y = flex.double((3, 2, 1))
sigmas = flex.double((0.04, 0.02, 0.01))
gf = gaussian.fit(x, y, sigmas, gaussian.sum((1, 2), (4, 5)))
assert approx_equal(gf.array_of_a(), (1, 2))
assert approx_equal(gf.array_of_b(), (4, 5))
assert approx_equal(gf.c(), 0)
assert not gf.use_c()
assert approx_equal(gf.table_x(), x)
assert approx_equal(gf.table_y(), y)
assert approx_equal(gf.table_sigmas(), sigmas)
assert approx_equal(
gf.fitted_values(),
[2.8632482881537511, 2.4896052951221748, 0.94088903489182252])
reference_gaussian = gaussian.sum((1, 2, 3), (4, 5, 6))
gf = gaussian.fit(x, reference_gaussian, sigmas,
gaussian.sum((1, 2), (4, 5)))
assert approx_equal(gf.array_of_a(), (1, 2))
assert approx_equal(gf.array_of_b(), (4, 5))
assert approx_equal(gf.c(), 0)
assert approx_equal(gf.table_x(), x)
assert approx_equal(gf.table_y(), reference_gaussian.at_x(x))
assert approx_equal(gf.table_sigmas(), sigmas)
assert isinstance(gf.sort(), gaussian.fit)
assert gf.sort().table_x() == gf.table_x()
assert gf.sort().table_y() == gf.table_y()
assert gf.sort().table_sigmas() == gf.table_sigmas()
assert approx_equal(gf.differences(),
gf.at_x(x) - reference_gaussian.at_x(x))
c_fit = gaussian.fit(
flex.double([
0.0, 0.066666666666666666, 0.13333333333333333, 0.2,
0.26666666666666666
]),
gaussian.sum((2.657506, 1.078079, 1.490909, -4.2410698, 0.71379101),
(14.780758, 0.776775, 42.086842, -0.000294, 0.239535),
4.2979832), flex.double(5, 0.0005),
gaussian.sum((1.1423916, 4.1728425, 0.61716694),
(0.50733125, 14.002512, 41.978928)))
differences = flex.double([
-0.064797341823577881, 0.003608505180995536, 0.098159179757290715,
0.060724224581695019, -0.10766283796372011
])
assert approx_equal(c_fit.differences(), differences)
assert approx_equal(
c_fit.significant_relative_errors(),
[0.0107212, 0.0005581, 0.0213236, 0.0169304, 0.0385142])
gf = gaussian.fit(x, reference_gaussian, flex.double(x.size(), 1),
gaussian.sum((1, 2), (4, 5)))
assert list(gf.bound_flags(False, False)) == [False, False, False, False]
assert list(gf.bound_flags(True, False)) == [True, False, True, False]
assert list(gf.bound_flags(False, True)) == [False, True, False, True]
sgf = gf.apply_shifts(flex.double((3, -3, 4, 6)), True)
assert approx_equal(sgf.array_of_a(), (1 + 3, 2 + 4))
assert approx_equal(sgf.array_of_b(),
((math.sqrt(4) - 3)**2, (math.sqrt(5) + 6)**2))
assert approx_equal(sgf.c(), 0)
assert not sgf.use_c()
sgf = gf.apply_shifts(flex.double((3, -3, 4, 6)), False)
assert approx_equal(sgf.array_of_a(), (1 + 3, 2 + 4))
assert approx_equal(sgf.array_of_b(), (4 - 3, 5 + 6))
assert approx_equal(sgf.c(), 0)
assert not sgf.use_c()
differences = sgf.differences()
for use_sigmas in [False, True]:
assert approx_equal(sgf.target_function(2, use_sigmas, differences),
25.0320634)
assert approx_equal(sgf.target_function(4, use_sigmas, differences),
256.2682575)
assert approx_equal(sgf.gradients_d_abc(2, use_sigmas, differences),
[15.6539271, -4.1090114, 10.4562306, -1.6376781])
gfc = gaussian.fit(x, reference_gaussian, flex.double(x.size(), 1),
gaussian.sum((1, 2), (4, 5), 6))
assert list(gfc.bound_flags(False,
False)) == [False, False, False, False, False]
assert list(gfc.bound_flags(True,
False)) == [True, False, True, False, True]
assert list(gfc.bound_flags(False,
True)) == [False, True, False, True, False]
sgfc = gfc.apply_shifts(flex.double((3, -3, 4, 6, -5)), True)
assert approx_equal(sgfc.array_of_a(), (1 + 3, 2 + 4))
assert approx_equal(sgfc.array_of_b(),
((math.sqrt(4) - 3)**2, (math.sqrt(5) + 6)**2))
assert approx_equal(sgfc.c(), 6 - 5)
assert sgfc.use_c()
sgfc = gfc.apply_shifts(flex.double((3, -3, 4, 6, -5)), False)
assert approx_equal(sgfc.array_of_a(), (1 + 3, 2 + 4))
assert approx_equal(sgfc.array_of_b(), (4 - 3, 5 + 6))
assert approx_equal(sgfc.c(), 6 - 5)
assert sgfc.use_c()
differences = sgfc.differences()
for use_sigmas in [False, True]:
assert approx_equal(sgfc.target_function(2, use_sigmas, differences),
44.8181444)
assert approx_equal(sgfc.target_function(4, use_sigmas, differences),
757.3160329)
assert approx_equal(
sgfc.gradients_d_abc(2, use_sigmas, differences),
[21.1132071, -6.0532695, 13.6638274, -2.2460994, 22.7860809])
differences = c_fit.differences()
gabc = c_fit.gradients_d_abc(2, False, differences)
assert approx_equal(gabc, [
-0.016525391425206391, 0.0074465239375589107, 0.020055876723667564,
0.00054794635257838251, -0.018754011379726425, -0.0011194004809549143
])
assert approx_equal(
c_fit.gradients_d_shifts(flex.double((0.1, 0.4, 0.2, 0.5, 0.3, 0.6)),
gabc),
[-0.0165254, 0.01656512, 0.0200559, 0.0046488, -0.0187540, -0.0158487])
g5c = gaussian.sum(
(2.657505989074707, 1.0780789852142334, 1.4909089803695679,
-4.2410697937011719, 0.71379101276397705),
(14.780757904052734, 0.77677500247955322, 42.086841583251953,
-0.00029399999766610563, 0.23953500390052795), 4.2979831695556641)
for include_constant_term in (False, True):
a = flex.double(g5c.array_of_a())
b = flex.double(g5c.array_of_b())
permutation = flex.sort_permutation(data=flex.abs(a), reverse=True)[:4]
gf = gaussian.fit(
flex.double([0]), g5c, flex.double(1, 1),
gaussian.sum(iter(a.select(permutation)),
iter(b.select(permutation)), 0,
include_constant_term))
assert approx_equal(gf.differences(), [-5.01177418232])
shifts = flex.double(8, -1)
if (include_constant_term): shifts.append(-.2)
sgf = gf.apply_shifts(shifts, False)
assert approx_equal(sgf.array_of_a(),
[-5.2410698, 1.657506, 0.49090898, 0.078078985])
assert approx_equal(sgf.array_of_b(),
[-1.0002940, 13.780758, 41.086842, -0.223225])
if (include_constant_term):
assert approx_equal(sgf.c(), -.2)
expected_gradients = [1, 0, 1, 0, 1, 0, 1, 0]
if (include_constant_term): expected_gradients.append(1)
assert approx_equal(fit_finite_diff_gradients(sgf, 0),
expected_gradients,
eps=1.e-4)
for i in range(10):
gf = gaussian.fit(flex.double([i / 10.]), g5c, flex.double(1, 1),
sgf)
differences = flex.double([0.5])
assert approx_equal(gf.gradients_d_abc(2, False, differences),
fit_finite_diff_gradients(gf,
gf.table_x()[0]),
eps=1.e-3)
for sigma in [0.04, 0.02, 0.01]:
gf = gaussian.fit(flex.double([i / 20.]), g5c,
flex.double([sigma]), sgf)
for power in [2, 4]:
for use_sigmas in [False, True]:
differences = gf.differences()
an = gf.gradients_d_abc(power, use_sigmas, differences)
fi = fit_finite_diff_target_gradients(
gf, power, use_sigmas)
assert eps_eq(an, fi, eps=1.e-3)
