def generate_suggestion(self): """Function is given a set of user points and generates a suggestion based on the algorithm Engage after user clicks box -- for now...""" self.phi = [sum(x) / len(x) for x in zip(*self.belief.states)] # Sample set of points to iterate over self.best_points_idx, self.best_points_phi = Main.find_similar_points(self.guess_beta, self.phi, self.p_sample, self.suggested) # print(list(self.best_points_phi)) # Generate new suggestion using Julia function call suggest = Main.find_next_action(list(self.user_points), self.best_points_phi, self.observe_beta, self.final_beta, self.user, self.num_guess) self.suggested.append(suggest) self.num_guess -= 1 # Decrement step counter print(suggest) # Find index that the algorithm suggested # If the algorithm chooses to wait, then don't publish anything if suggest != "wait": ans = self.guess_points[int(suggest)] print("The ans is ", ans) # Publish to ROS else: ans = "wait" # self.suggest_pub.publish(ans) return ans
def test_pandamodels_installation(): from julia import Main from julia import Pkg from julia import Base if Base.find_package("PandaModels"): # remove PandaModels to reinstall it Pkg.rm("PandaModels") Pkg.resolve() else: print("PandaModels is not installed yet!") Pkg.Registry.update() Pkg.add("PandaModels") Pkg.build() Pkg.resolve() print("PandaModels is added to julia packages") try: Main.using("PandaModels") print("using PandaModels in its base mode!") except ImportError: raise ImportError("cannot use PandaModels in its base mode")
def JuliaSimulation(sim, simulate=False, useBrownians=False, times=None, nPaths=None, seed=None, timeInterpolation=None): if not isinstance(sim, McSimulation): raise NotImplementedError( 'Implementation of JuliaSimulation for %s required.' % str(type(sim))) model = JuliaModel(sim.model) # check for manual parameters if times is None: times = sim.times if nPaths is None: nPaths = sim.nPaths if seed is None: seed = sim.seed if timeInterpolation is None: timeInterpolation = sim.timeInterpolation # if simulate: if useBrownians: # Julia is column-major layout return Main.McSimulationWithBrownians(model, times, sim.dW.transpose(2, 1, 0), timeInterpolation) else: return Main.McSimulation(model, times, nPaths, seed, timeInterpolation) else: # do not use this with manual inputs # Julia is column-major layout return Main.McSimulation(model, times, nPaths, seed, timeInterpolation, sim.dW.transpose(2, 1, 0), sim.X.transpose(2, 1, 0)) return None
def save_result(basic_prm, cities_data, target, filename): """Save the result of a run for further processing. """ cities_names = cities_data.index n_cities = len(cities_names) var_s = get_jump_variable('s') var_e = get_jump_variable('e') var_i = get_jump_variable('i') var_r = get_jump_variable('r') var_ei = get_jump_variable('ei') var_ir = get_jump_variable('ei') var_v = get_jump_variable('v') var_V = get_jump_variable('V') icupop = Julia.prm.icupop / Julia.prm.tinf mean_icu = (cities_data["rho_min"][0] + (cities_data["rho_max"][0] - cities_data["rho_min"][0]) * cities_data["intercept"][0]) Julia.eval("rt = reshape(expand(value.(m[:rt]), prm), (:,))") n = len(Julia.s[0, 0, :]) df = [] for p in range(var_s.shape[0]): for d in [0, 1, 2]: df.append(["s", p, d] + list(var_s[p, d, :])) df.append(["e", p, d] + list(var_e[p, d, :])) df.append(["i", p, d] + list(var_i[p, d, :])) df.append(["r", p, d] + list(var_r[p, d, :])) for d in [0, 1]: df.append(["ei", p, d] + list(var_ei[p, d, :])) df.append(["ir", p, d] + list(var_ir[p, d, :])) df.append(["v", p, d] + list(var_v[p, d, :])) df.append(["icu_demand", p, -1] + list(mean_icu / basic_prm["time_icu"] * var_V[0, p, :])) df.append(["rt", -1, -1] + list(Julia.rt)) # Information on ICU c = cities_names[0] icu_capacity = cities_data.loc[c, "population"] * cities_data.loc[ c, "icu_capacity"] df.append(["icu_capacity", -1, -1] + list(icu_capacity * np.ones(n))) icu_target = icu_capacity * target.loc[c, :] df.append(["target_icu", -1, -1] + list(icu_target)) rho_icu = SimpleTimeSeries(*cities_data.iloc[0, 7:-2]) confidence = cities_data.loc[c, "confidence"] mean_icu, upper_icu = rho_icu.get_upper_bound(n, confidence) df.append(["mean_rho_icu", -1, -1] + list(mean_icu)) df.append(["upper_rho_icu", -1, -1] + list(upper_icu)) # mean_icu = cities_data.loc[c, "time_icu"] / basic_prm["tinf"] * mean_icu * cities_data.loc[c, "population"] * Julia.i[i, :] # df.append(["mean_used_icu", -1] + list(mean_icu)) # upper_icu = cities_data.loc[c, "time_icu"] / basic_prm["tinf"] * upper_icu * cities_data.loc[c, "population"] * Julia.i[i, :] # df.append(["upper_used_icu"] + list(upper_icu)) df = pd.DataFrame(df, columns=["Variable", "Subpopulation", "Dose"] + list(range(len(Julia.s[0, 0, :])))) df.set_index(["Variable", "Subpopulation", "Dose"], inplace=True) df.to_csv(filename) return df
def spectral(data, name, embedding_dim=128): try: result = load_embedding(name, 'spectral') return result except FileNotFoundError: print( f'cache/feature/spectral_{name}.pt not found! Regenerating it now') from julia.api import Julia jl = Julia(compiled_modules=False) from julia import Main Main.include(f'{CWD}/norm_spec.jl') print('Setting up spectral embedding') if data.setting == 'inductive': N = data.num_train_nodes edge_index = to_undirected(data.train_edge_index, num_nodes=data.num_train_nodes) else: N = data.num_nodes edge_index = to_undirected(data.edge_index, num_nodes=data.num_nodes) np_edge_index = np.array(edge_index.T) row, col = edge_index adj = SparseTensor(row=row, col=col, sparse_sizes=(N, N)) adj = adj.to_scipy(layout='csr') result = torch.tensor(Main.main(adj, embedding_dim)).float() save_embedding(result, name, 'spectral') return result
def scenario_julia_call(scenario_info, start_index, end_index): """ Starts a Julia engine, runs the add_path file to load Julia code. Then, loads the data path and runs the scenario. :param dict scenario_info: scenario information. :param int start_index: start index. :param int end_index: end index. """ from julia.api import Julia jl = Julia(compiled_modules=False) from julia import Main from julia import REISE interval = int(scenario_info['interval'].split('H', 1)[0]) n_interval = int((end_index - start_index + 1) / interval) input_dir = os.path.join(const.EXECUTE_DIR, 'scenario_%s' % scenario_info['id']) output_dir = os.path.join(const.EXECUTE_DIR, 'scenario_%s/output/' % scenario_info['id']) REISE.run_scenario(interval=interval, n_interval=n_interval, start_index=start_index, inputfolder=input_dir, outputfolder=output_dir) Main.eval('exit()')
def find_minimum_production(self, coords, opt_param_dict): """ Find the minimum corresponding to the coords. Parameters ---------- coords : np.ndarray Coordinates for which we want to find the corrsponding minima """ nls = Main.NewtonLinesearch(self.interfaced_potential, coords, opt_param_dict["tol"]) mxd = Main.Mixed_Descent( self.interfaced_potential, Main.CVODE_BDF(), nls, coords, opt_param_dict["T"], opt_param_dict["rtol"], opt_param_dict["conv_tol"], opt_param_dict["tol"], ) try: mxd.run_b(mxd, opt_param_dict["n_steps"]) except: return None return ( mxd.optimizer.x0, mxd.converged, mxd.n_g_evals, mxd.iter_number, mxd.n_h_evals, )
def main(): Main.include("napier.jl") for _ in range(10): start = time.time() Main.count_upto_one() end = time.time() print(end - start)
def script(): print('in script') #############Load Vars############# #If we saved the vars in MATLAB then we load them here. a = np.load('a.npy') b = np.load('b.npy') #If you want a as ints or floats for your julia scripts use the conversions below, #(provided these inputs are single no's when defined and converted to numpy arrays in MATLAB e.g. "a=1") #a=int(a); #a=float(a); #############Python bit############# #Testing we can actually use python (not needed) c = np.add(a, b) print('NumPy Sum result') print(c) #############Julia bit############# #Compute something in Julia (from a module) from julia import Main print('Make sure you cd to correct dir here') Main.include(string(pwd(), "SumArrays.jl")) d = Main.SumArrays(a, b) print('Julia Sum result') print(d) #############Save bit############# #Now save as MATLAB matricies. scipy.io.savemat('PythonOutput.mat', dict(a=a, b=b, c=c, d=d))
def get_indiv_fitness(self, index): Main.ea_step = index[0] Main.pop_index = index[1] Main.eval( 'fitness = DataMod.get_indiv_fitness(data, ea_step, pop_index)') return Main.fitness
def test_pandamodels_dev_mode(): from julia import Main from julia import Pkg from julia import Base if Base.find_package("PandaModels"): # remove PandaModels to reinstall it Pkg.rm("PandaModels") Pkg.resolve() Pkg.Registry.update() Pkg.add("PandaModels") print("installing dev mode is a slow process!") Pkg.resolve() Pkg.develop("PandaModels") # add pandamodels dependencies: slow process Pkg.instantiate() Pkg.build() Pkg.resolve() print("dev mode of PandaModels is added to julia packages") try: Pkg.activate("PandaModels") Main.using("PandaModels") print("using PandaModels in its dev mode!") except ImportError: # assert False raise ImportError("cannot use PandaModels in its dev mode") # activate julia base mode Pkg.activate() Pkg.free("PandaModels") Pkg.resolve()
def fit(self, X, y): """ Fits the Local Discriminant Basis feature selection algorithm onto the input images X with labels y. """ # restructure data n = len(X) Xt = np.stack(X, axis=2) Xt = Xt.reshape(-1, n) Xt = Xt.astype("float") # wrapper function for fit! Main.eval(""" function fit(ldb, X, y) fit!(ldb, X, y) end """) # fit LDB Main.fit(self.ldb, Xt, y) # save attributes self.n = self.ldb.n self.Gamma = np.array(self.ldb.Γ) self.DM = np.array(self.ldb.DM) self.cost = np.array(self.ldb.cost) self.tree = np.array(self.ldb.tree) self.DP = np.array(self.ldb.DP) self.order = np.array( self.ldb.order) - 1 # python follows zero indexing return None
def TreeRep_no_recursion(d): """ This is a python wrapper to the TreeRep algorithm written in Julia. Input: d - Distance matrix, assumed to be symmetric with 0 on the diagonal Output: W - Adjacenct matrix of the tree. Note that W may have rows/cols full of zeros, and they should be ignored. Example Code: d = np.array([[0,2,3],[2,0,2],[3,2,0]]) W = TreeRep(d) print(W) """ Main.d = d Main.G, Main.dist = Main.eval( "TreeRep.metric_to_structure_no_recursion(d)") edges = Main.eval('collect(edges(G))') W = np.zeros_like(Main.dist) # Initializing the adjacency matrix for edge in edges: src = edge.src - 1 dst = edge.dst - 1 W[src, dst] = Main.dist[src, dst] W[dst, src] = Main.dist[dst, src] return W
def initialize_julia(): sysimage_path = get_MORBIT_SYS_IMG() if sysimage_path: if os.path.isfile( MORBIT_SYS_IMG ): tprint(f"\tUsing sysimage at {MORBIT_SYS_IMG}") else: tprint(f"\tGoing to compile a sysimage at {MORBIT_SYS_IMG}") sysimage_path = make_sysimage() if not sysimage_path: tprint("\tNo sysimage specified.") tprint("MOP: Initializing Julia runtime. First time might take a bit.") init_api(sysimage_path) from julia import Main # include "hack" to make symbols available on the python side Main.include( os.path.join( os.path.dirname( __file__ ) , "pycall_sym.jl" ) ) Main.include( os.path.join( os.path.dirname( __file__ ) , "prepare_path.jl" ) ) prepare_morbit( Main ) load_morbit( Main ) tprint("Julia runtime all set up!") set_JULIA_MAIN(Main) return Main
def _call_powermodels(pm, julia_file): #pragma: no cover buffer_file = os.path.join(tempfile.gettempdir(), "pp_pm.json") logger.debug("writing PowerModels data structure to %s" % buffer_file) with open(buffer_file, 'w') as outfile: json.dump(pm, outfile) try: import julia from julia import Main except ImportError: raise ImportError( "Please install pyjulia to run pandapower with PowerModels.jl") try: j = julia.Julia() except: raise UserWarning( "Could not connect to julia, please check that Julia is installed and pyjulia is correctly configured" ) Main.include(os.path.join(pp_dir, "opf", 'pp_2_pm.jl')) try: run_powermodels = Main.include(julia_file) except ImportError: raise UserWarning("File %s could not be imported" % julia_file) result_pm = run_powermodels(buffer_file) return result_pm
def part_d(): print "Running d" jcall.include("SIRS_MC_svar.jl") # Import Julia program # Keep following parameters constant S0 = 300 I0 = 100 R0 = 0 a0 = 4 b = 1 c = 0.5 # But change the following percent_diff = [1, 1, .5, .5] # maximum percent deviation from a0 # Amplitude of deviation from a0 Amp = [diff * a0 for diff in percent_diff] omega = [4, 0.25, 2, 0.25] # Frequency of deviation from a0 stop = [10, 70, 10, 70] # Simulation time trials = 100 # No. times to run MC simulation for i in range(len(percent_diff)): plt.figure(figsize=[5, 2.5]) # Get MC data from julia program (SIRS_MC.jl) command = "SIRS_svar(S0=%i, I0=%i, R0=%i, a0=%.2f, A=%.2f, omega=%.2f, b=%.2f, c=%.2f, stop_time=%i, trials=%i)"\ % (S0, I0, R0, a0, Amp[i], omega[i], b, c, stop[i], trials) t, S, I, R = jcall.eval(command) for j in range(trials): plt.plot(t, S[j], color=S_colour, alpha=SIR_alpha) plt.plot(t, I[j], color=I_colour, alpha=SIR_alpha) plt.plot(t, R[j], color=R_colour, alpha=SIR_alpha) # Plot ODE solution on top inst = SIRS_ODE.SIRS( S0=S0, I0=I0, R0=R0, N=int(1e3), tN=stop[i], a=a0, b=b, c=c, Amplitude=Amp[i], omega=omega[i]) inst.solve(inst.sirs_svar) t_ODE, S_ODE, I_ODE, R_ODE = inst.get() plt.plot(t_ODE, S_ODE, color="Black") plt.plot(t_ODE, I_ODE, color="Black") plt.plot(t_ODE, R_ODE, color="Black") # Mean MC on top of ODE plt.plot(t, np.mean(S, axis=0), linestyle="--", color=Mean_colour) plt.plot(t, np.mean(I, axis=0), linestyle="--", color=Mean_colour) plt.plot(t, np.mean(R, axis=0), linestyle="--", color=Mean_colour) plt.xlim(0, stop[i]) plt.ylim(-10, 410) plt.title("A=%.2f, $\\omega$=%.2f" % (Amp[i], omega[i])) plt.xlabel("Time") plt.ylabel("No. People") plt.savefig("../figs/prob_d_fig_%i.pdf" % i) plt.savefig("../figs/prob_d_fig_%i.png" % i) plt.close() return
def get_protein(self, cell, props): #get_fcn = Main.eval('ProteinStoreMod.get') #return get_fcn(cell.proteins, props) Main.proteins = cell.proteins Main.props = props Main.eval('protein = ProteinStoreMod.get(proteins, props)') return Main.protein
def save_all_interaction_graphs(self, index, cell, path): Main.ea_step = index[0] Main.pop_index = index[1] Main.cell = cell Main.path = path Main.eval( 'DataMod.save_all_graphs_for_cell(data, ea_step, pop_index, cell, path)' )
def part_e(): print "Running e" jcall.include("SIRS_MC_vax.jl") # Include Julia program # Keep following parameters constant S0 = 300 I0 = 100 R0 = 0 a = 4 b = 1 c = 0.5 # But change the following f = [50, 100, 200, 300] stop = [20, 20, 20, 20] # Simulation time trials = 100 # No. times to run MC simulation for i in range(len(f)): plt.figure(figsize=[5, 2.5]) command = "SIRS_vax(S0=%i, I0=%i, R0=%i, a=%.2f, b=%.2f, c=%.2f, f=%.2f, stop_time=%i, trials=%i)"\ % (S0, I0, R0, a, b, c, f[i], stop[i], trials) t_MC, S_MC, I_MC, R_MC = jcall.eval(command) # Firt plot individual MC-cycles for j in range(trials): plt.plot(t_MC, S_MC[j], color=S_colour, alpha=SIR_alpha) plt.plot(t_MC, I_MC[j], color=I_colour, alpha=SIR_alpha) plt.plot(t_MC, R_MC[j], color=R_colour, alpha=SIR_alpha) # Plot ODE solution on top inst = SIRS_ODE.SIRS( S0=S0, I0=I0, R0=R0, N=int(1e5), tN=stop[i], a=a, b=b, c=c, f=f[i]) inst.solve(inst.sirs_vax) t_ODE, S_ODE, I_ODE, R_ODE = inst.get() plt.plot(t_ODE, S_ODE, color=ODE_colour) plt.plot(t_ODE, I_ODE, color=ODE_colour) plt.plot(t_ODE, R_ODE, color=ODE_colour) # And finally MC mean on top of that. plt.plot(t_MC, np.mean(S_MC, axis=0), linestyle="--", color=Mean_colour) plt.plot(t_MC, np.mean(I_MC, axis=0), linestyle="--", color=Mean_colour) plt.plot(t_MC, np.mean(R_MC, axis=0), linestyle="--", color=Mean_colour) plt.xlim(0, stop[i]) plt.title("f=%.2f" % f[i]) plt.xlabel("Time") plt.ylabel("No. People") plt.savefig("../figs/prob_e_fig_%i.pdf" % i) plt.savefig("../figs/prob_e_fig_%i.png" % i) plt.close() return
def save_all_gs_table_data(self, cell, index, filename): if cell is not None: Main.cell = cell Main.ea_step = index[0] Main.indiv_index = index[1] Main.filename = filename Main.eval( 'DataMod.save_all_gs_table_data(data, cell, ea_step, indiv_index, filename)' )
def configure(self, params): super(JlPredictor, self).configure(params) logger.info(f"loading {JL_SCORE_PATH}") jl.eval(f'include("{JL_SCORE_PATH}")') logger.info(f"{JL_SCORE_PATH} loaded") from julia import Main Main.init(self._code_dir, self._target_type.value) self._model = Main.load_serialized_model(self._code_dir)
def get_neighbour_graph(self, index): Main.ea_step = index[0] Main.pop_index = index[1] Main.reg_step = index[2] Main.eval( 'pixmap_data = DataMod.build_neighbour_comm_graph(data, ea_step, pop_index, reg_step)' ) pixmap_data = Main.pixmap_data return pixmap_data
def _read_source(module_name: str, source_file: str) -> None: """Read source if module not attached to julia Main yet. Parameters ---------- module_name: Julia module name.^^ source_file: Qualified Julia source file. """ if not hasattr(Main, module_name): Main.include(source_file)
def _call_pandamodels(buffer_file, julia_file, dev_mode): # pragma: no cover try: import julia from julia import Main from julia import Pkg from julia import Base except ImportError: raise ImportError( "Please install pyjulia properly to run pandapower with PandaModels.jl." ) try: julia.Julia() except: raise UserWarning( "Could not connect to julia, please check that Julia is installed and pyjulia is correctly configured" ) if not Base.find_package("PandaModels"): logger.info( "PandaModels.jl is not installed in julia. It is added now!") Pkg.Registry.update() Pkg.add("PandaModels") if dev_mode: logger.info("installing dev mode is a slow process!") Pkg.resolve() Pkg.develop("PandaModels") # add pandamodels dependencies: slow process Pkg.instantiate() Pkg.build() Pkg.resolve() logger.info("Successfully added PandaModels") if dev_mode: Pkg.develop("PandaModels") Pkg.build() Pkg.resolve() Pkg.activate("PandaModels") try: Main.using("PandaModels") except ImportError: raise ImportError("cannot use PandaModels") Main.buffer_file = buffer_file result_pm = Main.eval(julia_file + "(buffer_file)") # if dev_mode: # Pkg.activate() # Pkg.free("PandaModels") # Pkg.resolve() return result_pm
def __init__(self, metric_str): self.metric_str = metric_str # check name and args name_args = metric_str.split("@metric")[1].strip().split( "\n")[0].split() self.name = name_args[0] self.args = name_args[1:] # run on julia Main.eval(metric_str)
def __init__(self, wt=Main.wavelet(Main.WT.haar), max_dec_level=Main.nothing, dm=Main.AsymmetricRelativeEntropy(), en=Main.TimeFrequency(), dp=Main.BasisDiscriminantMeasure(), top_k=Main.nothing, n_features=Main.nothing): """ Initialize LDB object. Arguments: - wt => Default is Main.wavelet(Main.WT.haar). Other acceptable wavelets are: * Main.wavelet(Main.WT.dbN) [replace N with any number between 1:Inf] * Main.wavelet(Main.WT.coifN) [replace N with any number from 2,4,6,8] * Main.wavelet(Main.WT.symN) [replace N with any number between 4:10 inclusive] * Main.wavelet(Main.battN) [replace N with any number from 2,4,6] - max_dec_level => Number of decomposition levels. Default of Main.nothing means signal decomposes to max level. - dm => Discriminant measure. Default is Main.AsymmetricRelativeEntropy(). Other acceptable values are: * Main.SymmetricRelativeEntropy() * Main.LpEntropy() * Main.HellingerDistance() - en => Energy map. Default is Main.TimeFrequency(). Other acceptable value is: * Main.ProbabilityDensity() - dp => Discriminant power measure. Default is Main.BasisDiscriminantMeasure(). Other acceptable values are: * Main.FishersClassSeparability() * Main.RobustFishersClassSeparability() - top_k => Number of coefficients used in each node to determine the discriminant measure. Default of Main.nothing means all coefficients are used. - n_features => Number of features to be returned in output. Default of Main.nothing means all features are returned. """ self.wt = wt self.max_dec_level = max_dec_level self.dm = dm self.en = en self.dp = dp self.top_k = top_k self.n_features = n_features self.ldb = Main.LocalDiscriminantBasis( wt=self.wt, max_dec_level=self.max_dec_level, dm=self.dm, en=self.en, dp=self.dp, top_k=self.top_k, n_features=self.n_features)
def JuliaModel(model): # if isinstance(model,HullWhiteModel): yc = JuliaYieldCurve(model.yieldCurve) return Main.HullWhiteModel(yc,model.meanReversion,model.volatilityTimes,model.volatilityValues) # if isinstance(model,QuasiGaussianModel): yc = JuliaYieldCurve(model.yieldCurve) return Main.QuasiGaussianModel(yc,model._d, model._times, model._sigma, model._slope, model._curve, model._delta, model._chi, model._Gamma) else: raise NotImplementedError('Implementation of JuliaModel for %s required.' % str(type(model))) return
def get_interaction_graph(self, index, cell): if cell is None: pixmap_data = [] else: Main.cell = cell Main.ea_step = index[0] Main.pop_index = index[1] Main.reg_step = index[2] Main.eval( 'pixmap_data = DataMod.build_graph_for_cell(data, ea_step, pop_index, reg_step, cell)' ) pixmap_data = Main.pixmap_data return pixmap_data
def get_gs_table_data(self, cell, index): if cell is None: table_data = [] else: Main.cell = cell Main.ea_step = index[0] Main.indiv_index = index[1] Main.reg_step = index[2] Main.eval( 'table_data = DataMod.get_gs_table_data(data, cell, ea_step, indiv_index, reg_step)' ) table_data = Main.table_data return table_data
def minres(A, b, **kwargs): ''' The function is a wrapper for the julia implementation of MINRES solver in IterativeSolver.jl package. \ MINRES is a short-recurrence version of GMRES for solving :math:`Ax=b` approximately \ for :math:`x` where :math:`A` is a symmetric, Hermitian, skew-symmetric or skew-Hermitian linear operator and :math:`b` the right-hand side vector. **Arguments** * A: linear operator. * b: right-hand side. **Keywords** * initially_zero::Bool = false: if true assumes that iszero(x) so that one matrix-vector product can be saved when computing the initial residual vector; * skew_hermitian::Bool = false: if true assumes that A is skew-symmetric or skew-Hermitian; * tol: tolerance for stopping condition :math:`|r_k| / |r_0| ≤ tol`. Note that the residual is computed only approximately; * maxiter::Int = size(A, 2): maximum number of iterations; * Pl: left preconditioner; * Pr: right preconditioner; * log::Bool = false: keep track of the residual norm in each iteration; * verbose::Bool = false: print convergence information during the iterations. **Output** **if log is false** * x: approximate solution. **if log is true** * x: approximate solution; * history: convergence history. ''' return Main.minres(A, b, **kwargs)