def empty(cls, key_type, value_type): """Create a new empty Dict with *key_type* and *value_type* as the types for the keys and values of the dictionary respectively. """ if config.DISABLE_JIT: return dict() else: return cls(dcttype=DictType(key_type, value_type))
def empty(cls, key_type, value_type): """Create a new empty Dict with *key_type* and *value_type* as the types for the keys and values of the dictionary respectively. """ return cls(dcttype=DictType(key_type, value_type))
duration = 1000 # milliseconds freq = 300 # Hz sys.path[0] = os.getcwd() import BaseFDTD11 import Environment_Setup as envDef from Tests.Validation_Physics import VideoMaker import TransformHandler as transH import Solver_Engine as SE #import JuliaHandler as JH """ Below, specify typings of jclass members, as numba doesn't use dynamic typing like base python. """ specR = [('dict1', DictType(string, string))] @jclass(specR) class Reporter(object): def __init__(self): self.dict1 = {"": ""} def printer(self, item="", name="", show=False): self.dict1[name] = item # write this to file in organised manner, module for this? if show == True: print(item) #take in some string from a print to console and save to output file with
(pterm_list_list_type, pterm_list_list_type, i8[:, :])) distr_dnf_type = ListType(distr_ab_conjunct_type) conditions_fields_dict = { ### Fields that are filled on in instantiation ### # The variables used by the condition 'vars': ListType(GenericVarType), # The Disjunctive Normal Form of the condition but organized # so that every conjunct has a seperate lists for alpha and # beta terms. 'dnf': dnf_type, # A mapping from Var pointers to their associated index 'var_map': DictType(i8, i8), # Wether or not the conditions object has been initialized 'is_initialized': u1, # Wether or not the conditions object has been linked to a knowledge base 'is_linked': u1, ### Fields that are filled in after initialization ### "distr_dnf": distr_dnf_type # # The alpha parts of '.dnf' organized by which Var in 'vars' they use # 'alpha_dnfs': ListType(dnf_type), # # The beta parts of '.dnf' organized by which left Var in 'vars' they use # 'beta_dnfs': ListType(dnf_type),
from numba.types import string, ListType, DictType from numba.typed import List as numba_list from numba.typed import Dict as numba_dict from tqdm import tqdm import numpy as np def simple_cost_function(size: float, frequency: float, num_files: float, exp: float = 2.0): return size / (frequency / num_files)**exp spec = [ ('_cache', DictType(string, float32)), ('_hit', int32), ('_miss', int32), ('size_history', ListType(float32)), ('hit_rate_history', ListType(float32)), ('_max_size', float32), ('_counters_list', ListType(int32)), ('_counters', DictType(int32, string)), ('_rev_counters', DictType(string, int32)), ('__counter', int32), ] @jitclass(spec) class LRUCache(object): def __init__(self, max_size: float):
return apply_and_concat_func(param_list[0].shape[0], select_params_func, apply_func, ts_list, param_list, *args, *more_args, **kwargs) return cls.from_custom_func(custom_func, output_names=output_names, pass_lists=True, **kwargs) # ############# MA ############# # @njit(DictType(UniTuple(i8, 2), f8[:, :])(f8[:, :], i8[:], b1[:]), cache=True) def ma_caching_nb(ts, windows, ewms): cache_dict = dict() for i in range(windows.shape[0]): if (windows[i], int(ewms[i])) not in cache_dict: if ewms[i]: ma = ewm_mean_nb(ts, windows[i]) else: ma = rolling_mean_nb(ts, windows[i]) cache_dict[(windows[i], int(ewms[i]))] = ma return cache_dict @njit(f8[:, :](f8[:, :], i8, b1, DictType(UniTuple(i8, 2), f8[:, :])), cache=True) def ma_apply_func_nb(ts, window, ewm, cache_dict):