def _test_eigen_tensor(k, m, max_err, max_itr, n_test): def sphere_func(x): return np.dot(x.T, x) - 1 def sphere_jacobian(x): return 2 * x.reshape(1, -1) def sphere_retraction(x, u): return (x + u) / np.linalg.norm(x + u) sphere = base_constraints(shape_in=(k, ), shape_constraint=(1, ), equality=sphere_func) sphere.set_analytics(J_C=sphere_jacobian, retraction=sphere_retraction) A = utils.generate_symmetric_tensor(k, m) e = eigen_tensor_lagrange(A) e.constraints = sphere o_ncm_cnt = np.zeros(n_test, dtype=int) schur_cnt = np.zeros(n_test, dtype=int) ray_cnt = np.zeros(n_test, dtype=int) schur_cheb_cnt = np.zeros(n_test, dtype=int) o_ncm_err = np.zeros(n_test) schur_err = np.zeros(n_test) ray_err = np.zeros(n_test) schur_cheb_err = np.zeros(n_test) o_ncm_lbd = np.zeros(n_test) schur_lbd = np.zeros(n_test) ray_lbd = np.zeros(n_test) schur_cheb_lbd = np.zeros(n_test) o_ncm_time = np.zeros(n_test) schur_time = np.zeros(n_test) ray_time = np.zeros(n_test) schur_cheb_time = np.zeros(n_test) for jj in range(n_test): x0 = np.random.randn(k) x0 = x0 / np.linalg.norm(x0) # do orthogonal t_start = time.time() o_x, o_lbd, o_ctr, converge = orthogonal_newton_correction_method( A, max_itr, max_err, x_init=x0) t_end = time.time() o_ncm_cnt[jj] = o_ctr o_ncm_lbd[jj] = o_lbd o_ncm_err[jj] = np.linalg.norm( symmetric_tv_mode_product(A, o_x, m - 1) - o_lbd * o_x) o_ncm_time[jj] = t_end - t_start # do schur_form_rayleigh t_start = time.time() if False: s_x, s_lbd, ctr, converge = schur_form_rayleigh(A, max_itr, max_err, x_init=x0) else: # s_x, s_lbd, ctr, converge = schur_form_rayleigh_chebyshev_linear( # A, max_itr, max_err, x_init=x0, do_chebyshev=True) s_x, s_lbd, ctr, converge, err = schur_form_rayleigh_chebyshev( A, max_itr, max_err, x_init=x0, do_chebyshev=False) t_end = time.time() schur_cnt[jj] = ctr schur_lbd[jj] = s_lbd schur_err[jj] = np.linalg.norm( symmetric_tv_mode_product(A, s_x, m - 1) - s_lbd * s_x) schur_time[jj] = t_end - t_start # now do rayleigh t_start = time.time() res_ray = rayleigh_quotient_iteration(e, x0, max_err=max_err, max_iter=max_itr, verbose=False, exit_by_diff=True) t_end = time.time() ray_time[jj] = t_end - t_start ray_cnt[jj] = res_ray['n_iter'] ray_lbd[jj] = res_ray['lbd'] ray_err[jj] = np.linalg.norm(res_ray['err']) # print("doing rayleigh") # print(res_ray) # print(e.L(res_ray['x'], res_ray['lbd'])) # now do rayleigh chebyshev t_start = time.time() if True: sch_x, sch_lbd, ctr, converge, err = schur_form_rayleigh_chebyshev( A, max_itr, max_err, x_init=x0, do_chebyshev=True) else: sch_x, sch_lbd, ctr, converge = schur_form_rayleigh_linear( A, max_itr, max_err, x_init=x0, u=None) t_end = time.time() """ res_ray_cheb = rayleigh_chebyshev( e, x0, max_err=max_err, max_iter=max_itr, verbose=False, exit_by_diff=True) """ schur_cheb_time[jj] = t_end - t_start schur_cheb_cnt[jj] = ctr schur_cheb_lbd[jj] = sch_lbd schur_cheb_err[jj] = np.linalg.norm( symmetric_tv_mode_product(A, sch_x, m - 1) - sch_lbd * sch_x) schur_cheb_time[jj] = t_end - t_start # print("doing raychev") # print(res_ray_cheb) # print(e.L(res_ray_cheb['x'], res_ray_cheb['lbd'])) summ = pd.DataFrame( { 'o_ncm_iter': o_ncm_cnt, 'schur_iter': schur_cnt, 'ray_iter': ray_cnt, 'schur_cheb_iter': schur_cheb_cnt, 'o_ncm_err': o_ncm_err, 'schur_err': schur_err, 'ray_err': ray_err, 'schur_cheb_err': schur_cheb_err, 'o_ncm_lbd': o_ncm_lbd, 'schur_lbd': schur_lbd, 'ray_lbd': ray_lbd, 'schur_cheb_lbd': schur_cheb_lbd, 'o_ncm_time': o_ncm_time, 'schur_time': schur_time, 'ray_time': ray_time, 'schur_cheb_time': schur_cheb_time }, columns=[ 'o_ncm_iter', 'o_ncm_lbd', 'o_ncm_err', 'o_ncm_time', 'schur_iter', 'schur_lbd', 'schur_err', 'schur_time', 'ray_iter', 'ray_lbd', 'ray_err', 'ray_time', 'schur_cheb_iter', 'schur_cheb_lbd', 'schur_cheb_err', 'schur_cheb_time' ]) return summ
def _test_eigen_linear(): """ with linear constraint we try two ways to do Rayleigh / Rayleigh Chebysev with HT = H.T and HT = z.T """ np.random.seed(0) k = 5 x0 = np.random.randint(-5, 5, k) / 10. x0 = x0 / np.linalg.norm(x0) # need ||z|| = 1 z = x0.copy() def hyperplan_func(x): return np.dot(z.T, x) - 1 def hyperplan_jacobian(x): return z.reshape(1, -1) def hyperplan_retraction(x, u): # return x + u x0 = x + u return x0 + (1 - np.dot(z, x0)) * z hyperplan = base_constraints( shape_in=(k,), shape_constraint=(1,), equality=hyperplan_func) hyperplan.set_analytics( J_C=hyperplan_jacobian, retraction=hyperplan_retraction) A = utils.gen_random_symmetric(k) def HT(x): return z.T e = eigen_ht_lagrange(A, z, HT) e.constraints = hyperplan res_e = explicit_newton_raphson( e, x0, np.array([1.]), feasible=False) print(res_e) ei, v = np.linalg.eigh(A) print(ei) print(v) # now do retraction: res_f = explicit_newton_raphson( e, x0, np.array([1.]), feasible=True) print(res_f) res_cheb = explicit_chebyshev( e, x0, np.array([1.]), feasible=False, verbose=True) print(res_cheb) res_cheb = explicit_chebyshev( e, x0, np.array([1.]), feasible=True, verbose=True) print(e.L(res_cheb['x'], res_cheb['lbd'])) print(res_cheb) for i in range(10): x0 = np.random.randint(-5, 5, k) / 10. x0 = x0 / np.linalg.norm(x0) res_ray = rayleigh_quotient_iteration(e, x0, verbose=False) print(res_ray) # print(e.L(res_ray['x'], res_ray['lbd'])) # now do rayleigh chebyshev res_ray_cheb = rayleigh_chebyshev(e, x0, verbose=False, cutoff=3e-1) # print(e.L(res_ray_cheb['x'], res_ray_cheb['lbd'])) print(res_ray_cheb) n_test = 1000 tbl = np.full((n_test, 6), np.nan) for i in range(n_test): x0 = np.random.randint(-5, 5, k) / 10. x0 = x0 / np.linalg.norm(x0) try: res_ray = rayleigh_quotient_iteration(e, x0, verbose=False) tbl[i, 0] = res_ray['n_iter'] tbl[i, 1] = res_ray['lbd'] tbl[i, 2] = np.linalg.norm(res_ray['err']) except Exception: pass # now do rayleigh chebyshev try: res_ray_cheb = rayleigh_chebyshev(e, x0, verbose=False, cutoff=3e-1) tbl[i, 3] = res_ray_cheb['n_iter'] tbl[i, 4] = res_ray_cheb['lbd'] tbl[i, 5] = np.linalg.norm(res_ray_cheb['err']) except Exception: pass print(np.nanmean(tbl, axis=0)) # example 2 non symmetric B = utils.gen_random_real_eigen(k) en = eigen_ht_lagrange(B, z, HT) en.constraints = hyperplan res_e = explicit_newton_raphson( en, x0, np.array([1.]), feasible=False) print(res_e) print(en.L(res_e['x'], res_e['lbd'])) print(en.constraints.equality(res_e['x'])) ei, v = np.linalg.eig(B) print(ei) print(v) # now do retraction: res_f = explicit_newton_raphson( en, x0, np.array([1.]), feasible=True, verbose=True) print(res_f) print(en.L(res_f['x'], res_f['lbd'])) print(en.constraints.equality(res_f['x'])) res_chev = explicit_chebyshev( en, x0, np.array([1.]), feasible=False, verbose=True) print(res_chev) print(en.L(res_chev['x'], res_chev['lbd'])) print(en.constraints.equality(res_chev['x'])) res_chev = explicit_chebyshev( en, x0, np.array([1.]), feasible=True, verbose=True) print(res_chev) print(en.L(res_chev['x'], res_chev['lbd'])) print(en.constraints.equality(res_chev['x'])) for i in range(10): x0 = np.random.randint(-5, 5, k) / 10. x0 = x0 / np.linalg.norm(x0) print("Do rayleigh") res_ray = rayleigh_quotient_iteration(en, x0, verbose=False) print(res_ray) # print(en.L(res_ray['x'], res_ray['lbd'])) # now do rayleigh chebyshev print("Do rayleigh chebyshev") res_ray_cheb = rayleigh_chebyshev(en, x0, verbose=False, cutoff=1.e-1) print(en.L(res_ray_cheb['x'], res_ray_cheb['lbd'])) print(res_ray_cheb) n_test = 1000 tbl2 = np.full((n_test, 6), np.nan) for i in range(n_test): x0 = np.random.randint(-5, 5, k) / 10. x0 = x0 / np.linalg.norm(x0) try: res_ray = rayleigh_quotient_iteration(en, x0, verbose=False) tbl2[i, 0] = res_ray['n_iter'] tbl2[i, 1] = res_ray['lbd'] tbl2[i, 2] = np.linalg.norm(res_ray['err']) except Exception: pass try: res_ray_cheb = rayleigh_chebyshev(en, x0, verbose=False, cutoff=2.e-1) tbl2[i, 3] = res_ray_cheb['n_iter'] tbl2[i, 4] = res_ray_cheb['lbd'] tbl2[i, 5] = np.linalg.norm(res_ray_cheb['err']) except Exception: pass print(np.nanmean(tbl2, axis=0)) # now change method dont use HT def calc_J_RAYLEIGH(self, x): xsq = np.sum(x * x) return (- 2. / (xsq * xsq) * self['RAYLEIGH'] * x.T + np.dot( x.T / xsq, self._args['A'] + self._args['A'].T)).reshape(1, -1) eigen_ht_lagrange.calc_J_RAYLEIGH = calc_J_RAYLEIGH en1 = eigen_ht_lagrange(B, z) en1.constraints = hyperplan for i in range(10): x0 = np.random.randint(-5, 5, k) / 10. x0 = x0 / np.linalg.norm(x0) res_ray1 = rayleigh_quotient_iteration(en1, x0, verbose=False) print(res_ray1) # print(en1.L(res_ray1['x'], res_ray1['lbd'])) res_ray_cheb1 = rayleigh_chebyshev( en1, x0, verbose=False, cutoff=5e-1) print(en1.L(res_ray_cheb1['x'], res_ray_cheb1['lbd'])) print(res_ray_cheb1)
def _test_nonlinear_parametrized_constraints(): """ Allow for multiple constraints F(X) is of simple form A X + sin(Bx) more complex H May not converge if see bad results try a different initial point """ nonlinear_constraint = True if nonlinear_constraint: def func1(x): return np.sum(-2 * x + np.sin(x)) def func2(x): return np.sum(x + np.cos(x)) def deriv1(x): return -2 + np.cos(x) def deriv2(x): return 1 - np.sin(x) def second_deriv1(x): return np.diag(-np.sin(x)) def second_deriv2(x): return np.diag(-np.cos(x)) def H(x): ret = np.zeros((x.shape[0], 2)) ret[:, 0] = (x * x)[:] ret[:, 1] = x[:] return ret def calc_J_H(x): ret = np.zeros((x.shape[0], 2, x.shape[0])) ret[:, 0, :] = np.diag(2 * x) ret[:, 1, :] = np.eye(x.shape[0]) return ret def calc_J_H2(x): ret = np.zeros((x.shape[0], 2, x.shape[0], x.shape[0])) for i in range(x.shape[0]): ret[i, 0, i, i] = 2 return ret else: def func1(x): return np.sum(x) - 1 def func2(x): return np.sum(x * np.arange(x.shape[0])) - 1 def deriv1(x): return x def deriv2(x): return np.arange(x.shape[0]) def second_deriv1(x): return np.eye(x.shape[0]) def second_deriv2(x): return np.zeros((x.shape[0], x.shape[0]), dtype=float) def H(x): ret = np.zeros((x.shape[0], 2)) ret[:-1, 0] = 1 ret[:-2, 1] = np.arange(x.shape[0] - 2) ret[-2, 0] = -1 ret[-1, 1] = -1 return ret def calc_J_H(x): ret = np.zeros((x.shape[0], 2, x.shape[0])) return ret def calc_J_H2(x): return np.zeros((x.shape[0], 2, x.shape[0], x.shape[0])) n_var = 3 funcs = [func1, func2] derivs = [deriv1, deriv2] n_func = len(funcs) n = n_func + n_var V = np.random.randint(-10, 10, (n, n)) D = np.diag(np.random.randint(-10, 10, n)) A = np.dot(np.dot(V, D), np.linalg.inv(V)) B = np.random.randint(-10, 10, (n, n)).astype(float) * 1e-4 def gen_start_point(): x1a = np.random.randint(-5, 5, n_var) / 10. x1 = np.zeros((n_var + len(funcs))) x1[:n_var] = x1a x1[n_var:] = np.array([funcs[ix](x1a) for ix in range(n_func)]) return x1 x0 = gen_start_point() lbd0 = np.array([1., 1.]) e = vector_nonlinear_lagrange(A, B, H, calc_J_H) misc_constr = parametrized_constraints((n, ), funcs, derivs) e.constraints = misc_constr x0 = gen_start_point() res_e = explicit_newton_raphson(e, x0, lbd0, feasible=False) print(res_e) """ ei, v = np.linalg.eig(A) print ei print v """ # now do retraction: x1 = gen_start_point() res_f = explicit_newton_raphson(e, x1, res_e['lbd'] + .3, max_err=1e-3, feasible=True, verbose=True) print(res_f) # res_ray = rayleigh_quotient_iteration( # e, x0) for i in range(10): x1 = gen_start_point() try: res_ray = rayleigh_quotient_iteration(e, x1) print('x1= %s ' % str(x1)) print(res_ray) except Exception: pass for i in range(10): # now try chebyshev try: second_derivs = [second_deriv1, second_deriv2] echeb = vector_nonlinear_lagrange(A, B, H, calc_J_H, calc_J_H2) cheb_constr = parametrized_constraints((n, ), funcs, derivs, second_derivs) echeb.constraints = cheb_constr x0 = res_ray['x'] + .3 lbd0 = res_ray['lbd'] + .3 res_cheb = explicit_chebyshev(echeb, x0, lbd0, feasible=False) print(res_cheb) break except Exception: pass # rayleigh_chebyshev for i in range(10): x1 = gen_start_point() try: res_ray_chev = rayleigh_chebyshev(echeb, x1) print(res_ray_chev) except Exception: pass
def _test_eigenvector(): np.random.seed(0) k = 5 x0 = np.random.randint(-5, 5, k) / 10. x0 = x0 / np.linalg.norm(x0) def sphere_func(x): return np.dot(x.T, x) - 1 def sphere_jacobian(x): return 2 * x.reshape(1, -1) def sphere_retraction(x, u): return (x + u) / np.linalg.norm(x + u) sphere = base_constraints( shape_in=(k,), shape_constraint=(1,), equality=sphere_func) sphere.set_analytics( J_C=sphere_jacobian, retraction=sphere_retraction) A = utils.gen_random_symmetric(k) e = eigen_vector_lagrange(A) e.constraints = sphere res_e = explicit_newton_raphson( e, x0, np.array([1.]), feasible=False, verbose=True) print(res_e) ei, v = np.linalg.eigh(A) print(ei) print(v) # now do retraction: for i in range(10): x1 = np.random.randint(-5, 5, k) / 10. x1 = x1 / np.linalg.norm(x1) res_f = explicit_newton_raphson( e, x1, np.array([1.]), feasible=True, verbose=False) print(res_f) print(e.L(res_f['x'], res_f['lbd'])) # now do explicit_chebyshev res_chev = explicit_chebyshev( e, x0, np.array([1.]), feasible=False, verbose=True) print(res_chev) res_chev_f = explicit_chebyshev( e, x0, np.array([1.]), feasible=True, verbose=True) print(res_chev_f) for i in range(10): x0 = np.random.randint(-5, 5, k) / 10. x0 = x0 / np.linalg.norm(x0) # now do rayleigh res_ray = rayleigh_quotient_iteration(e, x0, verbose=False) print(res_ray) # print(e.L(res_ray['x'], res_ray['lbd'])) # now do rayleigh chebyshev res_ray_cheb = rayleigh_chebyshev(e, x0, verbose=False) print(res_ray_cheb) n_test = 1000 tbl = np.zeros((n_test, 6)) for i in range(n_test): x0 = np.random.randint(-5, 5, k) / 10. x0 = x0 / np.linalg.norm(x0) # now do rayleigh res_ray = rayleigh_quotient_iteration(e, x0, verbose=False) tbl[i, 0] = res_ray['n_iter'] tbl[i, 1] = res_ray['lbd'] tbl[i, 2] = np.linalg.norm(res_ray['err']) # print(res_ray) # print(e.L(res_ray['x'], res_ray['lbd'])) # now do rayleigh chebyshev res_ray_cheb = rayleigh_chebyshev(e, x0, verbose=False) # print(res_ray_cheb) tbl[i, 3] = res_ray_cheb['n_iter'] tbl[i, 4] = res_ray_cheb['lbd'] tbl[i, 5] = np.linalg.norm(res_ray_cheb['err']) print(np.mean(tbl, axis=0)) # now do the non symmetric case B = utils.gen_random_real_eigen(k) e = eigen_vector_lagrange(B) e.constraints = sphere res_e = explicit_newton_raphson( e, x0, np.array([1.]), feasible=False, verbose=True) print(res_e) ei, v = np.linalg.eig(B) print(ei) print(v) # now do retraction: res_f = explicit_newton_raphson( e, x0, np.array([1.]), feasible=True, verbose=True) print(res_f) res_chev = explicit_chebyshev( e, x0, np.array([1.]), feasible=False, verbose=True) print(res_chev) res_chev = explicit_chebyshev( e, x0, np.array([1.]), feasible=True, verbose=True) print(res_chev) n_test = 10 for i in range(n_test): x0 = np.random.randint(-5, 5, k) / 10. x0 = x0 / np.linalg.norm(x0) print("Doing Rayleigh") res_ray = rayleigh_quotient_iteration(e, x0, verbose=False) print(res_ray) # print(e.L(res_ray['x'], res_ray['lbd'])) # now do rayleigh chebyshev print("Doing Rayleigh Chebysev") res_ray_cheb = rayleigh_chebyshev(e, x0, verbose=False, cutoff=1e-1) print(res_ray_cheb) n_test = 1000 tbl2 = np.full((n_test, 6), np.nan) from lagrange_rayleigh.core import solver solver._MAX_ERR = 1e-10 solver._MAX_ITER = 200 for i in range(n_test): x0 = np.random.randint(-5, 5, k) / 10. x0 = x0 / np.linalg.norm(x0) B = utils.gen_random_real_eigen(k) e = eigen_vector_lagrange(B) e.constraints = sphere res_ray = rayleigh_quotient_iteration( e, x0, max_err=1e-8, verbose=False) if np.linalg.norm(res_ray['err']) < .01: tbl2[i, 0] = res_ray['n_iter'] tbl2[i, 1] = res_ray['lbd'] tbl2[i, 2] = np.linalg.norm(res_ray['err']) # print("Doing Rayleigh Chebysev") try: res_ray_cheb = rayleigh_chebyshev( e, x0, max_err=1e-8, verbose=False, cutoff=2e-1) if np.linalg.norm(res_ray_cheb['err']) < .01: tbl2[i, 3] = res_ray_cheb['n_iter'] tbl2[i, 4] = res_ray_cheb['lbd'] tbl2[i, 5] = np.linalg.norm(res_ray_cheb['err']) except Exception: pass print(np.nanmean(tbl2, axis=0))
def _test_invariance_subspace(): from lagrange_rayleigh.core.utils import gen_random_symmetric from lagrange_rayleigh.core.solver import explicit_newton_raphson from lagrange_rayleigh.core.solver import rayleigh_quotient_iteration # from lagrange_rayleigh.core.solver import explicit_chebyshev, rayleigh_chebyshev np.random.seed(0) n = 7 p = 2 A = gen_random_symmetric(n) sc = stiefel(n, p) ei, v = np.linalg.eigh(A) x0a = np.random.randint(-5, 5, (n, p)) / 10. x0 = sc.retraction(x0a, 0) iv = invariant_subspace(A) iv.constraints = sc lbd0 = np.dot(x0.T, np.dot(A, x0)) res_e = explicit_newton_raphson( iv, x0, lbd0, feasible=False, verbose=True) print(res_e) x0a = np.random.randint(-5, 5, (n, p)) / 10. x0 = sc.retraction(x0a, 0) lbd0 = np.dot(x0.T, np.dot(A, x0)) res_f = explicit_newton_raphson( iv, x0, lbd0, max_err=1e-3, feasible=True, verbose=True) print(res_f) x0a = np.random.randint(-5, 5, (n, p)) / 10. x0 = sc.retraction(x0a, 0) lbd0 = np.dot(x0.T, np.dot(A, x0)) res_ray = rayleigh_quotient_iteration(iv, x0, verbose=True) print(res_ray) print(iv.L(res_ray['x'], res_ray['lbd'])) def make_y(x, lbd): y = np.zeros(n*p + (p * (p+1)) // 2) y[:n*p] = x.T.reshape(-1) y[n*p:] = flatten_symmetric(lbd) return y def LL(y): """ y[:n*p] is x y[n:] is lbd """ x = y[:n*p].reshape(p, n).T ret = np.zeros_like(y) L = np.dot(A, x) - np.dot(x, make_symmetric(y[n*p:])) ret[:n*p] = L.T.reshape(-1) ret[n*p:] = flatten_symmetric(np.dot(x.T, x) - np.eye(p)) return ret def parse_y(y): x = y[:n*p].reshape(p, n).T lbd = make_symmetric(y[n*p:]) return x, lbd def check_y(y): x, lbd = parse_y(y) return np.dot(A, x) - np.dot(x, lbd), np.dot(x.T, x) - np.eye(p) def J_LL(y): x, lbd = parse_y(y) jac = np.zeros((y.shape[0], y.shape[0])) for i in range(p): jac[i*n:(i+1)*n, i*n:(i+1)*n] = A for i1 in range(p): for i2 in range(p): for i_n in range(n): jac[i1*n+i_n, i2*n+i_n] -= lbd[i1, i2] # derivatives with respect to lbd: for i1 in range(p): si1 = (i1*(i1+1)) // 2 for i2 in range(i1): jac[i2*n:i2*n+n, n*p+si1+i2] = -x[:, i1] jac[i1*n:i1*n+n, n*p+si1+i2] = -x[:, i2] jac[i1*n:i1*n+n, n*p+si1+i1] = -x[:, i1] # derivatives of constraints for i1 in range(p): si = (i1 * (i1 + 1)) // 2 jac[n*p+si+i1, i1*n:i1*n+n] = 2 * x[:, i1] for i2 in range(i1): jac[n*p + si + i2, i1*n:i1*n+n] = x[:, i2] jac[n*p + si + i2, i2*n:i2*n+n] = x[:, i1] return jac from scipy.optimize import fsolve y0 = np.zeros(n*p + (p * (p+1)) // 2) y0[:n*p] = x0.T.reshape(-1) y0[n*p:] = flatten_symmetric(lbd0) ee = 1e-4 jl1 = np.zeros((y0.shape[0], y0.shape[0])) for ix in range(y0.shape[0]): # v = np.arange(1, y0.shape[0]+1) * 1e-4 v = np.zeros_like(y0) v[ix] = ee jl1[:, ix] = (LL(y0 + v) - LL(y0)) / ee ijl1 = np.linalg.inv(jl1) res = fsolve(LL, y0) res1 = fsolve(LL, y0, fprime=J_LL) yy = y0.copy() i = 0 l1 = np.array([100.]) while np.linalg.norm(l1) > 1e-4: l1 = LL(yy) j1 = J_LL(yy) diff = np.linalg.solve(j1, l1) yy = yy - diff print('i=%d l1=%s' % (i, l1)) i += 1 xres, lbdres = parse_y(yy) print(res) print(res1)