def compile_rc_model_sia():
import cea.demand.rc_model_SIA
reload(cea.demand.rc_model_SIA)
cc = CC('rc_model_sia_cc')
# cc.export('calc_h_ec', "f8(f8)")(cea.demand.rc_model_SIA.calc_h_ec)
# cc.export('calc_h_ac', "f8(f8)")(cea.demand.rc_model_SIA.calc_h_ac)
# cc.export('calc_h_ea', "f8(f8, f8, f8)")(cea.demand.rc_model_SIA.calc_h_ea)
# cc.export('calc_f_sc', "f8(f8, f8, f8, f8)")(cea.demand.rc_model_SIA.calc_f_sc)
cc.export('calc_phi_m', "f8(f8, f8, f8, f8, f8, f8, f8)")(
cea.demand.rc_model_SIA.calc_phi_m)
cc.export('calc_phi_c', "f8(f8, f8, f8, f8, f8, f8, f8)")(
cea.demand.rc_model_SIA.calc_phi_c)
cc.export('calc_theta_c', "f8(f8, f8, f8, f8, f8, f8, f8, f8, f8)")(
cea.demand.rc_model_SIA.calc_theta_c)
cc.export('calc_phi_m_tot',
"f8(f8, f8, f8, f8, f8, f8, f8, f8, f8, f8, f8, f8)")(
cea.demand.rc_model_SIA.calc_phi_m_tot)
cc.export('calc_phi_a',
"f8(f8, f8, f8, f8, f8)")(cea.demand.rc_model_SIA.calc_phi_a)
cc.export('calc_theta_m',
"f8(f8, f8)")(cea.demand.rc_model_SIA.calc_theta_m)
cc.export('calc_h_ea', "f8(f8, f8, f8)")(cea.demand.rc_model_SIA.calc_h_ea)
cc.export('calc_theta_m_t',
"f8(f8, f8, f8, f8, f8)")(cea.demand.rc_model_SIA.calc_theta_m_t)
cc.export('calc_theta_ea',
"f8(f8, f8, f8, f8, f8)")(cea.demand.rc_model_SIA.calc_theta_ea)
cc.export('calc_h_em', "f8(f8, f8)")(cea.demand.rc_model_SIA.calc_h_em)
cc.export('calc_h_3', "f8(f8, f8)")(cea.demand.rc_model_SIA.calc_h_3)
cc.compile()
def compile_storagetank():
import cea.technologies.storage_tank
reload(cea.technologies.storage_tank)
cc = CC('storagetank_cc')
cc.export('ode', "f8(f8[:], f8, f8, f8, f8, f8, f8, f8)")(cea.technologies.storage_tank.ode_hot_water_tank)
cc.compile()
def compile_radiators():
import cea.technologies.radiators
reload(cea.technologies.radiators)
cc = CC('calc_radiator')
cc.export('fh', "f8(f8, f8, f8, f8, f8, f8, f8)")(cea.technologies.radiators.fh)
cc.export('lmrt', "f8(f8, f8, f8)")(cea.technologies.radiators.lmrt)
cc.compile()
def compile_modules():
from numba.pycc import CC
cc = CC("aot")
# collect AOT-compiled modules
directory = os.path.dirname(os.path.abspath(__file__))
for importer, module_name, _ in pkgutil.walk_packages([directory]):
if module_name not in {"cc", "aot"}:
module = importer.find_module(module_name).load_module(module_name)
for function_name, (function, signature) in module.exports.items():
cc.export(function_name, signature)(function)
cc.compile()
def aot_compile(file_name):
"""
:param file_name:
:return:
"""
cc = CC(config['module_name'])
func = []
signatures = []
if os.path.exists(config['example']):
f = os.open(config['example'], os.O_RDONLY)
stdin_bk = os.dup(0)
os.dup2(f, 0)
try:
module = runpy.run_module(file_name, run_name="__main__")
for k in module:
e = module[k]
if type(e) == numba.targets.registry.CPUDispatcher \
and e.nopython_signatures:
cc.export(k, e.nopython_signatures[0])(e)
func.append(k)
signatures.append(str(e.nopython_signatures[0]))
auto_jit = True
finally:
os.dup2(stdin_bk, 0)
os.close(f)
else:
module = importlib.import_module(file_name)
for dir_ in dir(module):
e = eval('module.' + dir_)
if type(e) == numba.targets.registry.CPUDispatcher \
and e.nopython_signatures:
cc.export(dir_, e.nopython_signatures[0])(e)
func.append(dir_)
signatures.append(str(e.nopython_signatures[0]))
auto_jit = False
cc.output_dir = os.curdir
if func:
cc.compile()
return cc, func, signatures, auto_jit
def numba_compile(numba_config):
import os, sys
if sys.argv[-1] == "ONLINE_JUDGE":
from numba import njit
from numba.pycc import CC
cc = CC("my_module")
for func, signature in numba_config:
globals()[func.__name__] = njit(signature)(func)
cc.export(func.__name__, signature)(func)
cc.compile()
exit()
elif os.name == "posix":
exec(
f"from my_module import {','.join(func.__name__ for func, _ in numba_config)}"
)
for func, _ in numba_config:
globals()[func.__name__] = vars()[func.__name__]
else:
from numba import njit
for func, signature in numba_config:
globals()[func.__name__] = njit(signature, cache=True)(func)
print("compiled!", file=sys.stderr)
def compile_sensible_loads():
import cea.demand.sensible_loads
reload(cea.demand.sensible_loads)
cc = CC('calc_tm')
cc.export('calc_tm', "UniTuple(f8, 2)(f8, f8, f8, f8, f8)")(
cea.demand.sensible_loads.calc_tm)
cc.export('calc_ts', "f8(f8, f8, f8, f8, i4, f8, f8, f8, f8)")(
cea.demand.sensible_loads.calc_ts)
cc.export('calc_ts_tabs', "f8(f8, f8, f8, f8, i4, f8, f8, f8, f8)")(
cea.demand.sensible_loads.calc_ts_tabs)
cc.export('calc_ta',
"f8(f8, f8, i4, f8, f8, f8)")(cea.demand.sensible_loads.calc_ta)
cc.export('calc_ta_tabs', "f8(f8, f8, i4, f8, f8, f8)")(
cea.demand.sensible_loads.calc_ta_tabs)
cc.export('calc_top', "f8(f8, f8)")(cea.demand.sensible_loads.calc_top)
cc.export('calc_Im_tot', "f8(f8, f8, f8, f8, f8, f8, f8, f8, i4, f8, f8)")(
cea.demand.sensible_loads.calc_Im_tot)
cc.export('calc_Im_tot_tabs',
"f8(f8, f8, f8, f8, f8, f8, f8, f8, i4, f8, f8)")(
cea.demand.sensible_loads.calc_Im_tot_tabs)
cc.compile()
import numpy as np
from numba.pycc import CC
import math
# constant
NUM_SECTOR = 9
FLT_EPSILON = 1e-07
cc = CC('fhog_utils')
@cc.export('func1',
'(f4[:,:,:], f4[:,:,:], f4[:], f4[:], f4[:,:], i8[:,:,:], i8,i8,i8)'
)
def func1(dx, dy, boundary_x, boundary_y, r, alfa, height, width, numChannels):
for j in xrange(1, height - 1):
for i in xrange(1, width - 1):
c = 0
x = dx[j, i, c]
y = dy[j, i, c]
r[j, i] = math.sqrt(x * x + y * y)
for ch in xrange(1, numChannels):
tx = dx[j, i, ch]
ty = dy[j, i, ch]
magnitude = math.sqrt(tx * tx + ty * ty)
if (magnitude > r[j, i]):
r[j, i] = magnitude
c = ch
x = tx
tx, ty, tz, tw = t
tt = tx ^ (tx << 11)
t[0] = ty
t[1] = tz
t[2] = tw
t[3] = tw = (tw ^ (tw >> 19)) ^ (tt ^ (tt >> 8))
return tw
if __name__ == "__main__":
import sys
if sys.argv[-1] == "-c":
# numba compile
print("compiling")
from numba.pycc import CC
cc = CC('numba_rbst')
cc.export('randInt', 'i8(i8[:])')(randInt)
cc.export("lower_bound",
"i8(i8[:],i8[:],i8[:],i8[:],i8,i8)")(lower_bound)
cc.export("update", "i8(i8[:],i8[:],i8[:],i8[:],i8[:],i8)")(update)
cc.export("split",
"void(i8[:],i8[:],i8[:],i8[:],i8[:],i8[:],i8,i8)")(split)
cc.export("merge",
"i8(i8[:],i8[:],i8[:],i8[:],i8[:],i8,i8,i8[:])")(merge)
cc.export("push", "void(i8)")(push)
# b1: bool, i4: int32, i8: int64, double: f8, [:], [:, :]
cc.compile()
exit()
if sys.argv[-1] != "-p": # mean: pure python mode
from numba_rbst import randInt, lower_bound, update, split, merge, push
from numba.pycc import CC
from base_filter import naive_filter
import numpy as np
cc = CC('filters_aot')
DTYPE = np.float32
# Normally, you would use cc.export as a decorator before function definition:
#@cc.export('numba_filter_aot', 'f4[:](f4[:], f4)')
# But I define the function only once this way
numba_filter_aot = cc.export('numba_filter_aot',
'f4[:](f4[:], f4)')(naive_filter)
def compile_aot():
cc.compile()
from numba.pycc import CC
from numpy import zeros
cc = CC('InitSnow_f_inner_compiled')
@cc.export('InitSnow_f_inner',
'(int64, int64[:,::1], int64, float64[:,:,::1], float64[:,:,::1])')
def InitSnow_f_inner(NYrs, DaysMonth, InitSnow_0, Temp, Prec):
result = zeros((NYrs, 12, 31))
yesterday = InitSnow_0
for Y in range(NYrs):
for i in range(12):
for j in range(DaysMonth[Y][i]):
if Temp[Y][i][j] <= 0:
result[Y][i][j] = yesterday + Prec[Y][i][j]
else:
if yesterday > 0.001:
result[Y][i][j] = max(yesterday - 0.45 * Temp[Y][i][j],
0)
else:
result[Y][i][j] = yesterday
yesterday = result[Y][i][j]
return result
def state_vectorize(function):
def vectorized_function(arg1, arg2, arg3):
output = np.empty((3, len(arg1)), dtype=np.float64)
for i in range(len(arg1)):
output[:, i] = function(arg1[i], arg2[i], arg3[i])
return output
return jit(nopython=True, fastmath=True)(vectorized_function)
out_type = typeof(np.empty((3, 9), dtype=np.float64))
arg_type = typeof(np.empty((9, ), dtype=np.float64))
if __name__ == "__main__":
cc = CC("drive_1d_distance")
cc.export("state_at_distance",
"UniTuple(f8, 3)(f8, f8, f8)")(state_at_distance)
cc.export("state_at_distance_vectorized",
out_type(arg_type, arg_type,
arg_type))(state_vectorize(state_at_distance))
cc.compile()
cc = CC("drive_1d_time")
cc.export("state_at_time", "UniTuple(f8, 3)(f8, f8, f8)")(state_at_time)
cc.export("state_at_time_vectorized",
out_type(arg_type, arg_type,
arg_type))(state_vectorize(state_at_time))
cc.compile()
cc.compile() can be used to compile after installing lstchain.
Functions pool:
-log_pdf_ll
-log_pdf_hl
-asygaussian2d
-linval
-template_interpolation
-log_pdf
Decorator @cc.export take the name to be used for the compiled function and the function signature.
Meaning of the symbols is defined here https://numba.pydata.org/numba-doc/dev/reference/types.html#numba-types
@njit decorator makes function available to other function compiled here.
"""
cc = CC('log_pdf_CC')
cc.verbose = True
@njit()
@cc.export('log_pdf_ll',
'f8(f8[:],f4[:,:],f4[:],f8[:],f8[:],f8[:,:],u8[:],i8,f8[:,:])')
def log_pdf_ll(mu, waveform, error, crosstalk, sig_s, templates, factorial,
n_peaks, weight):
"""
Performs the sum log likelihood for low luminosity pixels in TimeWaveformFitter.
The log likelihood is sum(pixels) sum(times) of the log single sample likelihood.
The single sample likelihood is the sum(possible number of pe) of a generalised
Poisson term times a Gaussian term.
Parameters:
import cmath
import numpy as np
from numba import float32
from numba.pycc import CC, exportmany, export
from numba.tests.matmul_usecase import has_blas
#
# New API
#
cc = CC('pycc_test_simple')
cc.use_nrt = False
@cc.export('multf', (float32, float32))
@cc.export('multi', 'i4(i4, i4)')
def mult(a, b):
return a * b
# Test imported C globals such as Py_None, PyExc_ZeroDivisionError
@cc.export('get_none', 'none()')
def get_none():
return None
@cc.export('div', 'f8(f8, f8)')
def div(x, y):
return x / y
import os
import numpy as np
from numba.pycc import CC
cc = CC('kernels')
output_dir = '{}/dist'.format(os.path.abspath('..'))
cc.output_dir = output_dir
@cc.export('square', 'f8(f8)')
def square(x):
return x**2
@cc.export('squarearr', 'f8[:](f8[:])')
def square_array(arr):
return np.square(arr)
cc.compile()
import numpy as np
from numba.pycc import CC
cc = CC('calculate_numba')
@cc.export('ldn_recode_traj', 'i2[:,:](i2[:,:])')
def recode_traj(x):
# Recode trajectory into deg, stable, imp. Capture trends that are at least
# 95% significant.
#
# Remember that traj is coded as:
# -3: 99% signif decline
# -2: 95% signif decline
# -1: 90% signif decline
# 0: stable
# 1: 90% signif increase
# 2: 95% signif increase
# 3: 99% signif increase
shp = x.shape
x = x.ravel()
x[(x >= -1) & (x <= 1)] = 0
x[(x >= -3) & (x < -1)] = -1
# -1 and 1 are not signif at 95%, so stable
x[(x > 1) & (x <= 3)] = 1
return (np.reshape(x, shp))
@cc.export('ldn_recode_state', 'i2[:,:](i2[:,:])')
def recode_state(x):
from numba.pycc import CC
from numpy import zeros
cc = CC('CNumPerv_inner_compiled')
@cc.export(
'CNumPerv_inner',
'(int64, int64[:,::1], float64[:,:,::1], int64, int64, float64[:,::1], float64[:,:,::1], float64[:,:,::1], float64[::1], float64[:,:,::1])'
)
def CNumPerv_inner(NYrs, DaysMonth, Temp, NRur, nlu, cnp, water, melt,
grow_factor, amc5):
result = zeros((NYrs, 12, 31, nlu))
for Y in range(NYrs):
for i in range(12):
for j in range(DaysMonth[Y][i]):
if Temp[Y][i][j] > 0 and water[Y][i][j] > 0.01:
if water[Y][i][j] < 0.05:
pass
else:
for l in range(NRur, nlu):
if cnp[1][l] > 0:
if melt[Y][i][j] <= 0:
if grow_factor[i] > 0:
# Growing season
if amc5[Y][i][j] >= 5.33:
result[Y][i][j][l] = cnp[2][l]
elif amc5[Y][i][j] < 3.56:
result[Y][i][j][l] = cnp[0][l] + (
cnp[1][l] - cnp[0][l]
) * amc5[Y][i][j] / 3.56
import numpy as np
import numba
from numba.pycc import CC
module = CC("numba_compilations")
@module.export("stats_variance_1d", "(f8[:],i8)")
def stats_variance_1d(data, ddof=0):
"""Pre compiled method to get 1d variance."""
a_a, b_b = 0, 0
for i in data:
a_a = a_a + i
b_b = b_b + i * i
var = b_b / (len(data)) - ((a_a / (len(data)))**2)
var = var * (len(data) / (len(data) - ddof))
return var
@numba.njit
def _stats_variance_1d_2d(data, ddof=0):
a_a, b_b = 0, 0
for i in data:
a_a = a_a + i
b_b = b_b + i * i
var = b_b / (len(data)) - ((a_a / (len(data)))**2)
var = var * (len(data) / (len(data) - ddof))
return var
@module.export("stats_variance_2d", "f8[:](f8[:,:],i8,i8)")
import numpy
from math import sqrt
from numba.pycc import CC
cc = CC('ppe')
@cc.export('pressure_poisson',
'f8[:,:](f8[:,:], f8[:,:], f8)')
def pressure_poisson(p, b, l2_target):
pn = p.copy()
I, J = b.shape
iter_diff = l2_target + 1
n = 0
while iter_diff > l2_target and n <= 500:
pn = p.copy()
for i in range(1, I - 1):
for j in range(1, J - 1):
p[i, j] = (.25 * (pn[i, j + 1] +
pn[i, j - 1] +
pn[i + 1, j] +
pn[i - 1, j]) -
b[i, j])
for i in range(I):
p[i, 0] = p[i, 1]
p[i, -1] = 0
for j in range(J):
p[0, j] = p[1, j]
#!/usr/bin/env python3
import numpy as np
from numba.pycc import CC
from numba import njit
from math import sqrt
cc = CC('basics')
@cc.export('distance', 'f8(f8[:], f8[:])')
@njit(fastmath=True)
def distance(x, y):
result = 0.
for i in range(x.shape[0]):
delta = x[i] - y[i]
result += delta * delta
return sqrt(result)
@cc.export('sqrdistance', 'f8(f8[:], f8[:])')
@njit(fastmath=True)
def sqrdistance(x, y):
result = 0.
for i in range(x.shape[0]):
delta = x[i] - y[i]
import numpy as np
import numpy.random as nrd
from numba import njit
from numba.pycc import CC
cc = CC("algebra")
@cc.export("_make_simplex", "f8[:](i8, f8[:])")
@njit
def _make_simplex(n, s):
m = n - 1
r = np.zeros(n)
r[0] = s[0]
r[n - 1] = 1 - s[-1]
for i in range(m - 1):
r[i + 1] = s[i + 1] - s[i]
return r
@cc.export("random_simplex", "f8[:](optional(i8), i8)")
@njit
def random_simplex(seed, n):
if not seed is None:
nrd.seed(seed)
return _make_simplex(n, np.sort(nrd.random(n - 1)))
def random_simplex_gen(n, f):
return _make_simplex(n, np.sort(f(n - 1)))
import numpy as np
from numba.pycc import CC
cc = CC('pycc_compiled_module')
_const = 42
# This ones references a global variable at compile time
@cc.export('get_const', 'i8()')
def get_const():
return _const
# This one needs NRT and an environment
@cc.export('ones', 'f8[:](i4)')
def ones(n):
return np.ones(n)
from numba.pycc import CC
import numpy as np
import math
cc = CC('shadowing')
#cc.verbose = True
#print(cc.target_cpu)
cc.target_cpu = "host"
@cc.export('shadows', "u1[:,:](f8[:,:],f8,f8,f8,u4,f8)")
# @cc.export('shadows', "u1[:,:](f4[:,:],f8,f8,f8,u4,f8)")
def shadows(in_array, az, alt, res, overlap, nodata):
# Rows = i = y values, cols = j = x values
rows = in_array.shape[0]
cols = in_array.shape[1]
shadow_array = np.ones(
in_array.shape,
dtype=np.uint8) # init to 1 (not shadowed), change to 0 if shadowed
max_elev = np.max(in_array)
az = 90. - az # convert from 0 = north, cw to 0 = east, ccw
azrad = az * np.pi / 180.
altrad = alt * np.pi / 180.
delta_j = math.cos(azrad)
delta_i = -1. * math.sin(azrad)
tanaltrad = math.tan(altrad)
mult_size = 1
max_steps = 600
import numpy as np
from numba.pycc import CC
cc = CC("native_fieldpacker")
cc.verbose = True
@cc.export("prePackField", "uint8[:](uint8[:,:])")
def prePackField(data):
result = np.zeros((50,), dtype=np.uint8)
index = 0
currentByte = 0
four_byte_counter = 0
for y in range(20):
for x in range(10):
currentByte += data[y, x]
four_byte_counter += 1
if four_byte_counter == 4:
result[index] = currentByte
four_byte_counter = 0
currentByte = 0
index += 1
currentByte = currentByte << 2
return result
if __name__ == "__main__":
cc.compile()
from typing import Tuple, Any, Set, List, Optional
import numpy as np
import math
import networkx as nx
import numpy.random as nrd
from enum import Enum
from numba.pycc import CC
from numba import njit
import numba
cc = CC("ic")
def independent_cascade(g, I0, ep_map, gen) -> List[Tuple[Set[int], Set[int]]]:
"""
Parameters
----------
g : networkx graph
I0 : seed node set
ep_map : propagation probability map
gen : numpy random generator
Returns
-------
The history of tuple of active node set and activated node set
"""
G = g if g.is_directed() else g.to_directed()
# gen = nrd.Generator(nrd.PCG64(nrd.SeedSequence(seed)))
I = I0
import math
from numba.pycc import CC
from numpy import exp
from numpy import zeros
cc = CC('WashImperv_inner_compiled')
@cc.export(
'WashImperv_inner',
'(int64, int64[:,::1], float64[:,:,::1], int64, int64, float64[:,:,::1], float64[:,:,:,::1])'
)
def WashImperv_inner(NYrs, DaysMonth, Temp, NRur, nlu, water, qruni):
result = zeros((NYrs, 12, 31, 16))
impervaccum = zeros(16)
carryover = zeros(16)
for Y in range(NYrs):
for i in range(12):
for j in range(DaysMonth[Y][i]):
for l in range(nlu):
impervaccum[l] = carryover[l]
impervaccum[l] = (impervaccum[l] * exp(-0.12) +
(1 / 0.12) * (1 - exp(-0.12)))
if Temp[Y][i][j] > 0 and water[Y][i][j] > 0.01:
if water[Y][i][j] < 0.05:
pass
else:
for l in range(NRur, nlu):
result[Y][i][j][l] = (1 - math.exp(
-1.81 * qruni[Y][i][j][l])) * impervaccum[l]
from numba.pycc import CC
cc = CC("my_module")
@cc.export('multf', 'f8(f8, f8)')
@cc.export('multi', 'i4(i4, i4)')
def mult(a, b):
return a * b
@cc.export('square', 'f8(f8)')
def square(a):
return a**2
if __name__ == "__main__":
cc.compile()
'''
This file is meant for generating ahead of time compiled functions that accelerate code performance by reducing constants for simple functions that
are invoked for roughly every letter in a document
For instance, some characters such as inverted commas are handled differently by docx files.
'''
from numba.pycc import CC
from numba import types
cc = CC('check_letter')
cc.verbose = True
@cc.export('check_inv', types.boolean(types.string))
def check_inv(letter):
if letter == '‘' or letter == '’':
return True
else:
return False
@cc.export('check_dinv', types.boolean(types.string))
def check_dinv(letter):
if letter == '“' or letter == '”':
return True
else:
return False
@cc.export('check_hyphen', types.boolean(types.string))
def check_hyphen(letter):
if letter == '-' or letter == '–':
heappush(q, B * dist_y + y)
# 止まって向きを変える権利を得る
y = 5 * v
dist_y = dist_x + (-dist_x) % K
if dist_y < dist[y]:
dist[y] = dist_y
heappush(q, B * dist_y + y)
x = dist[5 * T]
if x == INF:
return -1
return dist[5 * T] // K
if sys.argv[-1] == 'ONLINE_JUDGE':
from numba.pycc import CC
cc = CC('my_module')
cc.export('main', '(b1[:],i8,i8,i8,i8,i8)')(main)
cc.compile()
exit()
from my_module import main
H, W, K = map(int, readline().split())
x1, y1, x2, y2 = map(int, readline().split())
C = np.zeros((H + 2, W + 2), np.bool_)
C[1:-1, 1:-1] = np.frombuffer(read(), 'S1').reshape(H, -1)[:, :W] == b'.'
C = C.ravel()
H += 2
W += 2
S = W * x1 + y1
from numba.pycc import CC
from numpy import zeros
cc = CC('AMC5_yesterday_inner_compiled')
@cc.export('AMC5_yesterday_inner', '(int64, int64[:,::1], float64[::1], float64[:,:,::1])')
def AMC5_yesterday_inner(NYrs, DaysMonth, AntMoist_0, water):
result = zeros((NYrs, 12, 31))
AntMoist1 = zeros((5,))
AMC5 = 0
for k in range(5):
AMC5 += AntMoist_0[k]
AntMoist1[k] = AntMoist_0[k]
for Y in range(NYrs):
for i in range(12):
for j in range(DaysMonth[Y][i]):
result[Y][i][j] = AMC5
AMC5 = AMC5 - AntMoist1[4] + water[Y][i][j]
AntMoist1[4] = AntMoist1[3]
AntMoist1[3] = AntMoist1[2]
AntMoist1[2] = AntMoist1[1]
AntMoist1[1] = AntMoist1[0]
AntMoist1[0] = water[Y][i][j]
return result
