def initial_conditions(basic_prm, city_data, min_days, Julia, correction=1.0): """Fits data and define initial contidions of the SEIR model. """ population = city_data["estimated_population_2019"].iloc[0] confirmed = city_data["confirmed"] # Compute the new cases from the confirmed sum new_cases = confirmed.values[1:] - confirmed.values[:-1] # Use a mean in a week to smooth the data (specially to deal with weekends) observed_I = np.convolve(new_cases, np.ones(7, dtype=int), 'valid') / 7.0 # Now accumulate in the inf_window inf_window = int(round(basic_prm["tinf"])) observed_I = np.convolve(observed_I, np.ones(inf_window, dtype=int), 'valid') ndays = len(observed_I) if ndays >= min_days and sum(observed_I) > 0: observed_I /= population Julia.observed_I = correction*observed_I Julia.tinc = basic_prm["tinc"] Julia.tinf = basic_prm["tinf"] Julia.rep = basic_prm["rep"] Julia.eval('initialc = fit_initial(tinc, tinf, rep, observed_I)') S1 = Julia.initialc[0] E1 = Julia.initialc[1] I1 = Julia.initialc[2] R1 = Julia.initialc[3] return (S1, E1, I1, R1, ndays), observed_I, population else: raise ValueError("Not enough data for %s only %d days available" % (city_data["city"].iloc[0], len(observed_I)))
def import_julia_and_robot_dance(): # To use PyJulia print('Loading Julia library...') from julia.api import Julia jl = Julia(compiled_modules=False) from julia import Main as Julia print('Loading Julia library... Ok!') print('Loading Robot-dance Julia module...') Julia.eval('include("robot_dance.jl")') print('Loading Robot-dance Julia module... Ok!')
def train_oct(X_train, y_train, X_test, y_test, output_path, seed=1): from julia.api import Julia jl = Julia(compiled_modules=False) from interpretableai import iai X_train = impute_missing(X_train) X_test = impute_missing(X_test) oct_grid = iai.GridSearch( iai.OptimalTreeClassifier(random_seed=seed, ), max_depth=range(1, 10), # minbucket=[5, 10, 15, 20, 25, 30, 35], criterion=['gini', 'entropy', 'misclassification'], ls_num_tree_restarts=200, ) oct_grid.fit_cv(X_train, y_train, n_folds=5, validation_criterion='auc') best_learner = oct_grid.get_learner() best_learner.write_json('%s/learner.json' % output_path) best_learner.write_questionnaire('%s/app.html' % output_path) best_learner.write_html('%s/tree.html' % output_path) best_learner.write_png('%s/tree.png' % output_path) in_auc = oct_grid.score(X_train, y_train, criterion='auc') out_auc = oct_grid.score(X_test, y_test, criterion='auc') in_mis = oct_grid.score(X_train, y_train, criterion='misclassification') out_mis = oct_grid.score(X_test, y_test, criterion='misclassification') print('In Sample AUC', in_auc) print('Out of Sample AUC', out_auc) print('In Sample Misclassification', in_mis) print('Out of Sample Misclassification', out_mis) return best_learner, in_auc, out_auc, in_mis, out_mis
def objective(**params): if name_algo != 'oct': model = algorithm() model.set_params(**params) score = np.mean( cross_val_score(model, X, y, cv=cv, n_jobs=-1, scoring="roc_auc")) else: from julia.api import Julia jl = Julia(compiled_modules=False) from interpretableai import iai params["max_depth"] = int(params["max_depth"]) grid = iai.GridSearch(iai.OptimalTreeClassifier(random_seed=1), **params) grid.fit_cv(X, y, n_folds=cv, validation_criterion='auc') score = float(grid.get_grid_results()[[ 'split' + str(i) + '_valid_score' for i in range(1, cv + 1) ]].T.mean()) return -score
def initialize( runtime = default_runtime, project = default_project, compiled_modules = default_compiled_modules, **kwargs, ): """ Initialize julia runtime and import DECAES """ if project is not None: os.environ["JULIA_PROJECT"] = project # Initialize Julia runtime. Precompilation of Julia modules is not supported on Debian-based # Linux distributions such as Ubuntu, or python on installations via Conda. # See: https://pyjulia.readthedocs.io/en/stable/troubleshooting.html#your-python-interpreter-is-statically-linked-to-libpython global julia_runtime julia_runtime = Julia( runtime = runtime, compiled_modules = compiled_modules, **kwargs, ) # Import DECAES global DECAES from julia import DECAES
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 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 setup(compiled_modules=True): julia.install() jl = Julia(compiled_modules=compiled_modules) from julia import Pkg Pkg.add("[email protected]") # Lock to specific version for stability Pkg.add("Distributions") # Install Distributions after Bigsimr
def prepare_optimization(large_cities, population, initial_values, M, out, target, window=14, ndays=400, min_level=1.0, hammer_duration=14, hammer_level=0.89, force_dif=1): # Infected upper bound, it is larger in São Paulo. ncities = len(large_cities) if force_dif is 1: force_dif = np.ones((ncities, ndays)) Julia.s1 = initial_values.loc[large_cities, "S0"].values Julia.e1 = initial_values.loc[large_cities, "E0"].values Julia.i1 = initial_values.loc[large_cities, "I0"].values Julia.r1 = initial_values.loc[large_cities, "R0"].values Julia.out = out.values Julia.M = M.values.copy() Julia.population = population.values.copy() Julia.ndays = ndays Julia.target = target Julia.hammer_duration = hammer_duration Julia.hammer_level = hammer_level Julia.min_level = min_level Julia.force_dif = force_dif if window == 1: Julia.eval(""" prm = SEIR_Parameters(ndays, s1, e1, i1, r1, out, sparse(M), sparse(M')) m = control_multcities(prm, population, target, force_dif, hammer_duration, hammer_level, min_level) """) else: Julia.window = window Julia.eval(""" prm = SEIR_Parameters(ndays, s1, e1, i1, r1, out, sparse(M), sparse(M')) m = window_control_multcities(prm, population, target, window, force_dif, hammer_duration, hammer_level, min_level); """)
def save_result(cities_names, filename): """Save the result of a run for further processing. """ Julia.eval( "s = value.(m[:s]); e = value.(m[:e]); i = value.(m[:i]); r = value.(m[:r])" ) Julia.eval("rt = expand(value.(m[:rt]), prm)") df = [] for i in range(len(cities_names)): c = cities_names[i] df.append([c, "s"] + list(Julia.s[i, :])) df.append([c, "e"] + list(Julia.e[i, :])) df.append([c, "i"] + list(Julia.i[i, :])) df.append([c, "r"] + list(Julia.r[i, :])) df.append([c, "rt"] + list(Julia.rt[i, :])) df = pd.DataFrame(df, columns=["City", "Variable"] + list(range(len(Julia.s[0, :])))) df.set_index(["City", "Variable"], inplace=True) return df.to_csv(filename)
def prepare_optimization(basic_prm, cities_data, mob_matrix, target, force_dif=1): ncities, ndays = len(cities_data.index), int(basic_prm["ndays"]) if force_dif is 1: force_dif = np.ones((ncities, ndays)) Julia.tinc = basic_prm["tinc"] Julia.tinf = basic_prm["tinf"] Julia.rep = basic_prm["rep"] Julia.s1 = cities_data["S1"].values Julia.e1 = cities_data["E1"].values Julia.i1 = cities_data["I1"].values Julia.r1 = cities_data["R1"].values Julia.population = cities_data["population"].values Julia.out = mob_matrix["out"].values Julia.M = mob_matrix.values[:, :-1] Julia.ndays = ndays Julia.target = target.values Julia.hammer_duration = int(basic_prm["hammer_duration"]) Julia.hammer_level = basic_prm["hammer_level"] Julia.min_level = basic_prm["min_level"] Julia.force_dif = force_dif if basic_prm["window"] == 1: Julia.eval(""" prm = SEIR_Parameters(tinc, tinf, rep, ndays, s1, e1, i1, r1, 1, out, sparse(M), sparse(M')) m = control_multcities(prm, population, target, force_dif, hammer_duration, hammer_level, min_level) """) else: Julia.window = basic_prm["window"] Julia.eval(""" prm = SEIR_Parameters(tinc, tinf, rep, ndays, s1, e1, i1, r1, window, out, sparse(M), sparse(M')) m = window_control_multcities(prm, population, target, force_dif, hammer_duration, hammer_level, min_level); """)
def initialize_worker(params, proc_num): global my_number my_number = proc_num #make new random seed, as seed+Process_number local_seed = int(params.seed)+my_number random.seed(local_seed) global jl from julia.api import Julia from julia import Base, Main from julia.Main import println, redirect_stdout #establish connection to julia print("Worker",proc_num,"connecting to Julia...\n") if params.sys_image is not None: jl = Julia(init_julia=False, sysimage=params.sys_image, julia=params.julia, compiled_modules=params.compiled_modules) else: jl = Julia(init_julia=False, julia=params.julia, compiled_modules=params.compiled_modules) if my_number == 0: print("Loading Circuitscape in Julia...\n") #jl.eval("using Pkg;") jl.eval("using Circuitscape; using Suppressor;") #Main.eval("stdout") load_data(params, my_number) return(local_seed)
def run_julia(self): print("Loading Julia....") from julia.api import Julia jl = Julia(compiled_modules=False) from julia import Main as j I = np.genfromtxt(self.us_exchanges_filename, delimiter=" ") age_fracs_orig = np.genfromtxt(self.age_fracs_filename, delimiter=",") # first column is age_fracs = np.delete(age_fracs_orig, 0, 1) employed = pd.read_csv(self.employment_filename, dtype={ "Sector": str, "Feb": np.int64 }) print( f"Employed dataframe from {self.employment_filename}:\n {employed}" ) # if np.isnan(I).any() or np.isnan(age_fracs).any() or np.isnan(employed).any(): if np.isnan(I).any(): raise ValueError( f"NAN found in US_EXCHANGES file {self.us_exchanges_filename}; skipping" ) if np.isnan(age_fracs).any(): raise ValueError( f"NAN found in age_fracs file {self.age_fracs_filename}; skipping" ) j.eval("using DataFrames") julia_formatted_employed = j.DataFrame(employed.to_dict(orient='list')) if employed.isnull().values.any(): raise ValueError( f"NAN found in employment data {self.employment_filename}; skipping" ) print(f"Starting Julia run for SES {self.employment_filename}...") j.include("CASES.jl") returned_result = j.main(I, age_fracs, julia_formatted_employed, self.employment_percentage) print("Julia run complete.") self.cases_surfaces = returned_result[1] self.cases_complete = returned_result[0] self.write_binary_dump(self.binary_dump_filename_surfaces, self.cases_surfaces) self.write_binary_dump(self.binary_dump_filename_complete, self.cases_complete)
def optimize_and_show_results(i_fig, rt_fig, data_file, large_cities): """Optimize and save figures and data for further processing. """ Julia.eval(""" optimize!(m) rt = value.(m[:rt]); i = value.(m[:i]) """) for i in range(len(large_cities)): plt.plot(Julia.rt[i, :], label=large_cities[i], lw=5, alpha=0.5) plt.legend() plt.title("Target reproduction rate") plt.savefig(rt_fig) plt.clf() for i in range(len(large_cities)): plt.plot(Julia.i[i, :], label=large_cities[i]) plt.legend() plt.title("Infection level") plt.savefig(i_fig) save_result(large_cities, data_file)
def initial_conditions(city, covid_data, covid_window, min_days, Julia, correction=1.0): """Fits data and define initial contidions of the SEIR model. """ # Gets the city data city_data = covid_data[covid_data["city"] == city].copy() city_data.reset_index(inplace=True) city_data.sort_values(by=["date"], inplace=True) population = city_data["estimated_population_2019"].iloc[0] confirmed = city_data["confirmed"] # I am computing the new cases instead of using the new_confirmed column because # there is error at least in the first element for São Paulo. It should be 1. new_cases = confirmed.values[1:] - confirmed.values[:-1] new_cases = np.append(confirmed[0], new_cases) city_data["new_cases"] = new_cases observed_I = city_data["new_cases"].rolling(covid_window).sum() observed_I[:covid_window] = confirmed[:covid_window] ndays = len(observed_I) if ndays >= min_days: observed_I /= population Julia.observed_I = correction * observed_I.values Julia.eval('initialc = fit_initial(observed_I)') S0 = Julia.initialc[0] E0 = Julia.initialc[1] I0 = Julia.initialc[2] R0 = Julia.initialc[3] return (S0, E0, I0, R0, ndays), observed_I else: raise ValueError("Not enough data for %s only %d days available" % (city, len(observed_I)))
def spectral(data, post_fix): from julia.api import Julia jl = Julia(compiled_modules=False) from julia import Main Main.include("./norm_spec.jl") print('Setting up spectral embedding') data.edge_index = to_undirected(data.edge_index) np_edge_index = np.array(data.edge_index.T) N = data.num_nodes row, col = data.edge_index adj = SparseTensor(row=row, col=col, sparse_sizes=(N, N)) adj = adj.to_scipy(layout='csr') result = torch.tensor(Main.main(adj, 128)).float() torch.save(result, f'embeddings/spectral{post_fix}.pt') return result
def prepare_optimization(basic_prm, cities_data, mob_matrix, target, hammer_data, force_dif=1, verbosity=0): ncities, ndays = len(cities_data.index), int(basic_prm["ndays"]) if force_dif is 1: force_dif = np.ones((ncities, ndays)) Julia.tinc = basic_prm["tinc"] Julia.tinf = basic_prm["tinf"] Julia.rep = basic_prm["rep"] Julia.s1 = cities_data["S1"].values Julia.e1 = cities_data["E1"].values Julia.i1 = cities_data["I1"].values Julia.r1 = cities_data["R1"].values Julia.population = cities_data["population"].values Julia.out = mob_matrix["out"].values Julia.M = mob_matrix.values[:, :-1] Julia.ndays = ndays Julia.target = target.values Julia.min_level = basic_prm["min_level"] Julia.force_dif = force_dif Julia.hammer_duration = hammer_data["duration"].values Julia.hammer_level = hammer_data["level"].values Julia.verbosity = verbosity if basic_prm["window"] == 1: Julia.eval(""" prm = SEIR_Parameters(tinc, tinf, rep, ndays, s1, e1, i1, r1, 1, out, sparse(M), sparse(M')) m = control_multcities(prm, population, target, force_dif, hammer_duration, hammer_level, min_level, verbosity) """) else: Julia.window = basic_prm["window"] Julia.eval(""" prm = SEIR_Parameters(tinc, tinf, rep, ndays, s1, e1, i1, r1, window, out, sparse(M), sparse(M')) m = window_control_multcities(prm, population, target, force_dif, hammer_duration, hammer_level, min_level, verbosity); """) # Check if there is a ramp parameter (delta_rt_max) # If so, add ramp constraints to the model if 'delta_rt_max' in basic_prm: Julia.delta_rt_max = basic_prm["delta_rt_max"] Julia.verbosity = verbosity Julia.eval(""" m = add_ramp(m, prm, hammer_duration, delta_rt_max, verbosity) """)
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) Julia.eval( "s = value.(m[:s]); e = value.(m[:e]); i = value.(m[:i]); r = value.(m[:r])" ) Julia.eval("rt = expand(value.(m[:rt]), prm)") n = len(Julia.s[0, :]) Julia.eval("test = value.(m[:test])") df = [] for i in range(n_cities): c = cities_names[i] df.append([c, "s"] + list(Julia.s[i, :])) df.append([c, "e"] + list(Julia.e[i, :])) df.append([c, "i"] + list(Julia.i[i, :])) df.append([c, "r"] + list(Julia.r[i, :])) df.append([c, "rt"] + list(Julia.rt[i, :])) df.append([c, "rel. test"] + list(Julia.test[i, :])) df.append([c, "test"] + list(Julia.test[i, :] * cities_data.loc[c, "population"])) # Information on ICU icu_capacity = cities_data.loc[c, "population"] * cities_data.loc[ c, "icu_capacity"] df.append([c, "icu_capacity"] + list(icu_capacity * np.ones(n))) icu_target = icu_capacity * target.loc[c, :] df.append([c, "target_icu"] + list(icu_target)) rho_icu = SimpleTimeSeries(*cities_data.iloc[i, 7:-2]) confidence = cities_data.loc[c, "confidence"] mean_icu, upper_icu = rho_icu.get_upper_bound(n, confidence) df.append([c, "mean_rho_icu"] + list(mean_icu)) df.append([c, "upper_rho_icu"] + 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([c, "mean_used_icu"] + 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([c, "upper_used_icu"] + list(upper_icu)) df = pd.DataFrame(df, columns=["City", "Variable"] + list(range(len(Julia.s[0, :])))) df.set_index(["City", "Variable"], inplace=True) df.to_csv(filename) return df
def OptimalRoute(request): with connection.cursor() as cursor: cursor.execute( "SELECT id, location, amount, instance, ST_AsText(geolocation) FROM nodes_garbagenodes;" ) row = cursor.fetchall() columns = ["id", "Location", "amount", "instance", "Geolocation"] df = pd.DataFrame(row, columns=columns) NonOptDict = df.to_dict('records') """ Julia Api backend for genetic algorithm, which will input the dictionnary to be optimised. """ from julia.api import Julia jl = Julia(compiled_modules=False) from julia import Main Main.include('./nodes/Genetic.jl') res, des = Main.initialMatrix(NonOptDict) return Response(res)
def NearestPlaces(request): with connection.cursor() as cursor: cursor.execute( "SELECT id, location, amount, instance, ST_AsText(geolocation) FROM nodes_garbagenodes;" ) row = cursor.fetchall() columns = ["id", "Location", "amount", "instance", "Geolocation"] df = pd.DataFrame(row, columns=columns) NonOptDict = df.to_dict('records') """ Julia Api backend for genetic algorithm, which will input the dictionnary to be optimised. """ from julia.api import Julia jl = Julia(compiled_modules=False) from julia import Main # data = request.data Main.include('./nodes/Genetic.jl') data = (57.48358652376267, -20.260487410613507) res = Main.binsearch(NonOptDict, data) return Response(res)
def launch_scenario(self, execute_dir=None, threads=None, solver_kwargs=None): """Launches the scenario. :param None/str execute_dir: directory for execute data. None defaults to an execute folder that will be created in the input directory :param None/int threads: number of threads to use. :param None/dict solver_kwargs: keyword arguments to pass to solver (if any). :return: (*int*) runtime of scenario in seconds """ self.execute_dir = execute_dir self.threads = threads self._print_settings() # Import these within function because there is a lengthy compilation step from julia.api import Julia Julia(compiled_modules=False) from julia import Gurobi # noqa: F401 from julia import REISE start = time() REISE.run_scenario_gurobi( interval=self.interval, n_interval=self.n_interval, start_index=self.start_index, inputfolder=self.input_dir, outputfolder=self.execute_dir, threads=self.threads, ) end = time() runtime = round(end - start) hours, minutes, seconds = sec2hms(runtime) print(f"Run time: {hours}:{minutes:02d}:{seconds:02d}") return runtime
import numpy, ctypes import julia from julia.api import Julia jl = Julia() from julia import Main jl.eval('include("alter_array.jl")') a = numpy.array([1, 2, 3, 4, 5], 'uint32') print(a) addr = a.ctypes.data length = a.shape[0] Main.fn(a) print(a) Main.fn(addr, length) print(a)
# # Make sure a mesh object to be subdivided is selected before running this script # import bpy, time import numpy scene = bpy.context.scene from julia.api import Julia print('Initializing Julia (this might take a moment the first time)...') # The compiled_modules option is to work around the fact that libpython # is linked statically in Blender. # https://pyjulia.readthedocs.io/en/latest/troubleshooting.html#your-python-interpreter-is-statically-linked-to-libpython jl = Julia(compiled_modules=False) print('Done!') # Needs to come after the creation of the Julia instance above from julia import Main jl.eval('include("catmull-clark.jl")') # Delete previous output mesh if 'subdivided' in bpy.data.objects: bpy.ops.object.select_all(action='DESELECT') bpy.data.objects['subdivided'].select_set(True) bpy.ops.object.delete() #
How long to wait for a transition in the L96 EBM? In this notebook we run the stochastic L96 EBM for different noise strengths and see how long we must wait for a transition to occur. We save the corresponding results in pickle dictionaries. """ from transition_time_test_utilities import * import numpy as np import sys import time as tm from pathlib import Path print('Starting Julia Import') # !! Julia import can take a few minutes from julia.api import Julia jl = Julia(compiled_modules=False) from diffeqpy import de import numba print('Julia Imported') #################################### ### Experiment Set Up #################################### # Noise Parameters deltas = [1.0, 0.1] epsilons = [8, 4, 2, 1, 0.5] epislon_delta_pairs = [] for d in deltas: epislon_delta_pairs += [(e, d) for e in epsilons] epsilon, delta = epislon_delta_pairs[int(sys.argv[1]) - 1]
# pip install julia si_prefix import sys import time from functools import wraps import numpy as np from si_prefix import si_format scale = 6 iterations = 1000 # Initializes PyJulia print('Initializing Julia. Takes ~30 sec.') from julia.api import Julia jl = Julia(compiled_modules=False) # See https://pyjulia.readthedocs.io/en/latest/troubleshooting.html#your-python-interpreter-is-statically-linked-to-libpython from julia import Main # Loads main Julia interface Main.eval(f'scale = {scale}') Main.include('benchmark_tools.jl') # Run file to add functions to namespace def timethis(n): def decorate(func): @wraps(func) def wrapper(*args, **kwargs): t = np.zeros(n, dtype=np.float64) for i in range(n): start = time.time() func(*args, **kwargs) t[i] = time.time() - start return t
from skopt.utils import use_named_args import json import shutil from multiprocessing import Pool checkmethod = "DINCAE" #checkmethod = "DIVAnd" if len(sys.argv) > 1: checkmethod = sys.argv[1] print("checkmethod ", checkmethod) if checkmethod == "DIVAnd": from julia.api import Julia jl = Julia(compiled_modules=False) jl.eval('push!(LOAD_PATH,joinpath(ENV["HOME"],"projects/Julia/share"))') jl.eval('push!(LOAD_PATH,joinpath(ENV["HOME"],"src","CAE"))') from julia import dincae_insitu epochs = 5000 * 2 epochs = 300 #epochs = 50 #epochs = 5 #epochs = 1 reconstruct_params = { #"epochs": 1, #"epochs": 1_000 * 5 * 2, "epochs": epochs, #"epochs": 5,
try: from julia.api import Julia from julia import Main julia = Julia() Main.eval("using IterativeSolvers") except: print("Installing Julia is Required") def cg(A, b, **kwargs): ''' The function is a wrapper for the julia implementation of Conjugate Gradients solver in IterativeSolver.jl package. \ Conjugate Gradients solves :math:`Ax = b` approximately for :math:`x` where :math:`A` is a symmetric, positive-definite linear operator and :math:`b` the right-hand side vector. The method uses short recurrences and therefore has fixed memory costs and fixed computational costs per iteration. **Arguments** * A: linear operator * b: right-hand side. **Keywords** * statevars::CGStateVariables: Has 3 arrays similar to x to hold intermediate results. * initially_zero::Bool: If true assumes that iszero(x) so that one matrix-vector product can be saved when computing the initial residual vector * Pl = Identity(): left preconditioner of the method. Should be symmetric, positive-definite like A * tol::Real = sqrt(eps(real(eltype(b)))): tolerance for stopping condition :math:`|r_k| / |r_0| ≤ tol` * maxiter::Int = size(A,2): maximum number of iterations * verbose::Bool = false: print method information * log::Bool = false: keep track of the residual norm in each iteration. **Output**
# workaround static linked python from julia.api import Julia __julia__ = Julia(compiled_modules=False) import os import sys import subprocess from .wrappers import apply script_dir = os.path.dirname(os.path.realpath(__file__)) def install(): """ Install Julia packages required for yao-framework. """ subprocess.check_call(['julia', os.path.join(script_dir, 'install.jl')])
''' import os import os.path as path from optparse import OptionParser import pandas as pd import numpy as np import pylab as plt from pylab import rcParams rcParams['figure.figsize'] = 14, 7 import prepare_data # To use PyJulia from julia.api import Julia jl = Julia(compiled_modules=False) from julia import Main as Julia Julia.eval('ENV["OMP_NUM_THREADS"] = 8') Julia.eval('include("robot_dance.jl")') def get_options(): '''Get options with file locations from command line. ''' parser = OptionParser() parser.add_option( "--basic_parameters", dest="basic_prm", default=path.join("data", "basic_parameters.csv"), help="Basic parameters of the SEIR model [default: %default]") parser.add_option(
#!/usr/bin/env python3 from julia.api import Julia julia_file = 'calc_PR.jl' jl = Julia(compiled_modules=False) jl.eval('include("' + julia_file + '")')