def ImpEulerStep(sys_func: Callable[[Vec_t, Vec_t, float], Vec_t], x_n: Vec_t, t_n: float, h: float, atol: float = 1.e-8, rtol: float = 1.0e-5, maxit: int = 20, use_scipy: Optional[Union[bool, str]] = None, use_cycADa: Optional[bool] = False, *args, **kwargs): dim_x: int = len(x_n) t_n1 = t_n + h def inner_step_func(x_n1): return sys_func((x_n1 - x_n) / h, x_n1, t_n1) if use_cycADa: _inner_step_func, _inner_step_Dfunc = cycADa_wrapper( inner_step_func, dim_x) else: _inner_step_func, _inner_step_Dfunc = inner_step_func, None ''' solve nonlinear root problem ''' if (isinstance(use_scipy, bool) and (not use_scipy)) or (use_scipy is None): options_sn_inst = sparse_newton_options(atol_range=atol, atol_dom=atol, rtol_range=rtol, rtol_dom=rtol, atol_root=atol, max_it=maxit) report = sparse_nl_solve(_inner_step_func, jac=_inner_step_Dfunc, x0=x_n, options=options_sn_inst, linsolver=spsolve_simple_wrapper()) #, # callback = callback_matrix_spy()) #, # callback = callback_print_progress()) elif (isinstance(use_scipy, bool) and use_scipy) or (isinstance(use_scipy, str) and (use_scipy == 'least_squares')): report = least_squares(inner_step_func, x0=x_n, ftol=1.0e-12, xtol=1.0e-12, gtol=1.0e-12) elif isinstance(use_scipy, str) and (use_scipy == 'root'): report = root(inner_step_func, x0=x_n) else: raise Exception('?') success = report.success x_n1 = report.x return t_n1, x_n1, success, inner_step_func
nopts = sparse_newton_options() nopts.max_times_J_n_constant = 10 nopts.max_it = 10000 nopts.no_convergence_is_Error = False ''' try out all possible callbacks available so far ''' callback_print = callback_print_progress() # print out progress to console callback_log = callback_print_progress( file_path_and_name='ex1__Newton_fullstep.log') # print out progress to log callback_iter = callback_store_all_iterates( ) # not only get the root but any iterate before callback_spy = callback_matrix_spy( stop_at_each_fig=False) # get a plot of the matrix sprsity pattern callback = callback_of_callbacks(callback_print, callback_log, callback_iter, callback_spy) # call all other callbacks report = sparse_nl_solve(fun=fun, x0=x0, jac=jac, linsolver=spilu_simple_wrapper(), callback=callback, options=nopts) print('') print(report) print('') print(callback_iter.Xs) callback_spy.conclude() print('script finished!')
x0 = 5.0 * np.ones(shape=(2, )) option = sparse_newton_options() option.atol_dom = 1.0e-12 option.atol_range = None option.rtol_dom = None option.rtol_range = None option.apply_row_scaling = False # <- better turn this off! This changes the 'weights' of the row equations and therefore alters the position of the optimum # option.max_times_J_n_constant = 0 cb2 = callback_store_all_iterates() callback = callback_of_callbacks(callback_print_progress(), cb2) #, callback_matrix_spy()) report = sparse_nl_solve(fun=fun, x0=x0, linsolver=lsqr_simple_wrapper(), callback=callback, options=option) print(report) print('') print(cb2.Xs) print('\n') print(least_squares(fun, report.x)) print('script finished!')
from paso.systems_of_euqations.nlin.generic_nlin_nr1.generic_nlin_nr1 import f_and_jac_f, f_df as fun, x0 from paso.solvers.nlin.sparse_nl_solver.newton.core import sparse_nl_solve report = sparse_nl_solve(fun=fun, x0=x0) print(report) print('script finished!')
def nlinsolver(*args, **kwargs): return sparse_nl_solve(*args, options = options, **kwargs) ''' will fail, due to no root! '''
def nlinsolver_instance(*args, **kwargs): return sparse_nl_solve(*args, options=options_newton, **kwargs)