def __init__(self, name='', cs={}):
self.name = name
if self.name == '': self.name = gensym('T')
self.comps = Rec(cs)
self.witness_cache = []
self.supertype_cache = []
self.witness_conditions = []
def _cps_lambda(lambda_ast: LambdaAst, k: Callable[[Ast], Ast]) -> Ast:
continuation = gensym("K")
body = to_cps(
lambda_ast.body,
lambda lambda_body: CallAst(VarAst(continuation), [lambda_body]))
return k(
LambdaAst(lambda_ast.name, [continuation] + lambda_ast.params, body))
def __init__(self,name='',d=None):
self.name = name
if self.name == '': self.name = gensym('M')
if d is None:
self.model={}
else:
self.model = d
def _cps_if(if_ast: IfAst, k: Callable[[Ast], Ast]) -> CallAst:
"""
The previous version of cps_if passed the k on compiling both branches,
resulting in massive code growth for consecutive if-s.
The (quite expensive) fix is to wrap the rest of the program
in a continuation, and we'll transform the "if" node into an IIFE
which receives that continuation as an argument.
The body of this IIFE will just call the continuation
with the result of the if expression.
The following is a sample transformation:
a = if foo then 1 else 2;
print(a);
(λ (ifcont){
if foo then ifcont(1) else ifcont(2);
})(λ (ifret){
a = ifret;
print(a);
});
"""
def cps_cond(cond_ast: Ast) -> Ast:
def cps_then_and_else(result: Ast) -> Ast:
return CallAst(VarAst(if_continuation), [result])
return IfAst(cond_ast, to_cps(if_ast.then, cps_then_and_else),
to_cps(if_ast.else_, cps_then_and_else))
if_continuation = gensym("I")
return CallAst(
LambdaAst('', [if_continuation], to_cps(if_ast.cond, cps_cond)),
[_make_continuation(k)])
def __init__(self, name='', d=None):
self.name = name
if self.name == '': self.name = gensym('M')
if d is None:
self.model = {}
else:
self.model = d
def __init__(self,name=gensym('BT')):
self.name=name
self.comps = Rec({})
self.witness_cache = []
self.supertype_cache = []
self.witness_conditions = []
self.witness_types = []
self.poss = ''
def __init__(self, name=gensym('BT')):
self.name = name
self.comps = Rec({})
self.witness_cache = []
self.supertype_cache = []
self.witness_conditions = []
self.witness_types = []
self.poss = ''
def combine_dep_types(f1,f2):
if isinstance(f1,Type) and isinstance(f2,Type):
return f1.merge(f2)
elif isinstance(f1,Fun) and isinstance(f2,Type):
var = gensym('v')
return Fun(var, f1.domain_type, combine_dep_types(f1.body.subst(f1.var,var),f2))
elif isinstance(f1,Type) and isinstance(f2,Fun):
var = gensym('v')
return Fun(var, f2.domain_type, combine_dep_types(f1,f2.body.subst(f2.var,var)))
elif isinstance(f1,Fun) and isinstance(f2,Fun):
var1 = gensym('v')
var2 = gensym('v')
return Fun(var1, f1.domain_type,
Fun(var2, f2.domain_type, combine_dep_types(f1.body.subst(f1.var,var1),f2.body.subst(f2.var,var2))))
else:
if ttracing('combine_dep_types'):
print(show(f1)+' and '+show(f2)+' cannot be combined.')
return None
def __init__(self,name='',cs={}):
self.name = name
if self.name == '': self.name = gensym('T')
self.comps = Rec(cs)
self.witness_cache = []
self.supertype_cache = []
self.witness_conditions = []
self.witness_types = []
self.poss = ''
def __init__(self, name=gensym('BT')):
ttrtypes.BTypeClass.__init__(self, name)
self.witness_cache = ([], [])
self.prob_nonspec = None
self._query_methods = [
'_query_witness_cache', '_query_hypobj', '_query_lazyobj',
'_query_conditions', '_query_oracle', '_query_witness_types',
'_query_witness_conditions'
]
def combine_dep_types(f1,f2):
if isinstance(f1,Type) and isinstance(f2,Type):
return f1.merge(f2)
elif isinstance(f1,Fun) and isinstance(f2,Type):
var = gensym('v')
return Fun(var, f1.domain_type, combine_dep_types(f1.body.subst(f1.var,var),f2))
elif isinstance(f1,Type) and isinstance(f2,Fun):
var = gensym('v')
return Fun(var, f2.domain_type, combine_dep_types(f1,f2.body.subst(f2.var,var)))
elif isinstance(f1,Fun) and isinstance(f2,Fun):
var1 = gensym('v')
var2 = gensym('v')
return Fun(var1, f1.domain_type,
Fun(var2, f2.domain_type, combine_dep_types(f1.body.subst(f1.var,var1),f2.body.subst(f2.var,var2))))
else:
if ttracing('combine_dep_types'):
print(show(f1)+' and '+show(f2)+' cannot be combined.')
return None
def merge_dep_types(f1,f2):
if isinstance(f1,Type) and isinstance(f1,Type):
return f1.merge(f2)
elif isinstance(f1,Fun) and isinstance(f2,Fun):
var = gensym('v')
return Fun(var, f1.domain_type.merge(f2.domain_type),
merge_dep_types(f1.body.subst(f1.var,var),f2.body.subst(f2.var,var)))
else:
if ttracing('merge_dep_types'):
print(show(f1)+' and '+show(f2)+' cannot be merged.')
return None
def merge_dep_types(f1,f2):
if isinstance(f1,Type) and isinstance(f1,Type):
return f1.merge(f2)
elif isinstance(f1,Fun) and isinstance(f2,Fun):
var = gensym('v')
return Fun(var, f1.domain_type.merge(f2.domain_type),
merge_dep_types(f1.body.subst(f1.var,var),f2.body.subst(f2.var,var)))
else:
if ttracing('merge_dep_types'):
print(show(f1)+' and '+show(f2)+' cannot be merged.')
return None
def rename_iife_param(param: str) -> str:
"""
If iife param collides with closure, rename it.
:param param:
:return:
"""
self.closure = cast(LambdaAst, self.closure)
env: Environment = self.closure.env
var_define: VarDefine = iife_func.env.get(param)
if param in env.vars:
param = gensym(param + '$')
self.closure.iife_params.append(param)
env.define(param, True)
# change all references to iife params since we may change param names
for ref in var_define.refs:
ref.name = param
return param
def parser() -> Ast:
ast = self._maybe_binary(self._parse_atom(), 0)
# relational operator short-circuit implementation
if isinstance(ast, BinaryAst):
# left || right -> (lambda (left) {
# if left then left else right})(left)
binary_ast = cast(BinaryAst, ast)
if binary_ast.operator == '||':
iife_param = gensym('left')
ast = CallAst(
LambdaAst(
'',
[iife_param],
IfAst(
VarAst(iife_param),
VarAst(iife_param),
binary_ast.right)),
[binary_ast.left])
elif binary_ast.operator == '&&':
ast = IfAst(binary_ast.left, binary_ast.right, LiteralAst(False))
return ast
def load_img(self, imgf, reorient2std=False, image_name=None):
self._finished_plotting = False
img = nib.load(imgf)
aff = np.dot(
get_orig2std(imgf) if reorient2std else np.eye(4),
img.get_affine())
tkr_aff = np.dot(
reorient_orig2std_tkr_mat if reorient2std else np.eye(4),
get_vox2rasxfm(imgf, stem='vox2ras-tkr'))
#from nilearn.image.resampling import reorder_img
#img = reorder_img(uimg, resample='continuous')
xsz, ysz, zsz = img.shape
#print 'image coordinate transform', img.get_affine()
imgd = img.get_data()
if reorient2std:
imgd = np.swapaxes(imgd, 1, 2)[:,:,::-1]
#print 'image size', imgd.shape
if image_name is None:
from utils import gensym
image_name = 'image%s'%gensym()
self.images[image_name] = (imgd, aff, tkr_aff)
self.currently_showing_list.append(
NullInstanceHolder(name=image_name))
self.currently_showing = self.currently_showing_list[-1]
self.pins[image_name] = {}
#self.current_pin = image_name
self.show_image(image_name)
def create(self):
a = gensym('_a')
self.judge(a)
return a
def create_method_rec(self):
a = gensym('_r')
self.judge(a)
return a
def create_method_type(self):
a = gensym('_T')
self.judge(a)
return a
def create(self):
a = gensym('_sigma')
self.judge(a)
return(a)
def create(self):
e = gensym('_e')
self.judge(e)
return e
def BType(name=gensym('BT'), poss=_M):
T = BTypeClass(name)
return add_to_model(T, poss)
def __init__(self, types):
self.types = types
#self.depends_on = []
self.name = gensym('h')
def _make_continuation(k: Callable[[Ast], Ast]) -> LambdaAst:
continuation = gensym("R")
return LambdaAst('', [continuation], k(VarAst(continuation)))
def userjs(file):
return "userjs/" + utils.gensym(file) + ".js"
def __init__(self,name=gensym('BT'),nu=None):
ttr.BType.__init__(self,name)
self.fixed_nu = nu
def create(self):
a = gensym('_sigma')
self.judge(a)
return (a)
def create_method_type(self):
a = gensym('_T')
self.judge(a)
return a
def create_method_rec(self):
a = gensym('_r')
self.judge(a)
return a
def __init__(self,types):
self.types = types
#self.depends_on = []
self.name = gensym('h')
def create(self):
a = gensym('_a')
self.judge(a)
return a
def __init__(self, name=gensym('BT'), nu=None):
ttr.BType.__init__(self, name)
self.fixed_nu = nu
def create(self):
e = gensym('_e')
self.judge(e)
return e
