def __init__(self, parameters, code, render_kwds=None, connectors=None):
for param in parameters:
if param.annotation.input and param.annotation.output:
raise ValueError(
"Transformation cannot have 'io' parameters ('" +
param.name + "')")
self.signature = Signature(parameters)
for param in self.signature.parameters.values():
setattr(
self, param.name,
TransformationParameter(self, param.name,
param.annotation.type))
if connectors is not None:
self.connectors = connectors
else:
self.connectors = [
param.name for param in parameters if param.annotation.array
]
tr_param_names = ['idxs'] + [
param.name for param in self.signature.parameters.values()
]
self.snippet = Snippet(template_def(tr_param_names, code),
render_kwds=render_kwds)
def _build_plan(
self, plan_factory, device_params,
ks_a, ks_b, ks_cv, in_key, out_key, noises_a, noises_b):
plan = plan_factory()
extracted_n, t, base, inner_n = ks_a.shape
mul_key = MatrixMulVector(noises_a)
b_term = plan.temp_array_like(mul_key.parameter.output)
build_keyswitch = PureParallel([
Parameter('ks_a', Annotation(ks_a, 'o')),
Parameter('ks_b', Annotation(ks_b, 'o')),
Parameter('ks_cv', Annotation(ks_cv, 'o')),
Parameter('in_key', Annotation(in_key, 'i')),
Parameter('b_term', Annotation(b_term, 'i')),
Parameter('noises_a', Annotation(noises_a, 'i')),
Parameter('noises_b', Annotation(noises_b, 'i'))],
Snippet(
TEMPLATE.get_def("make_lwe_keyswitch_key"),
render_kwds=dict(
log2_base=self._log2_base, output_size=self._output_size,
noise=self._noise)),
guiding_array="ks_b")
plan.computation_call(mul_key, b_term, noises_a, out_key)
plan.computation_call(
build_keyswitch,
ks_a, ks_b, ks_cv, in_key, b_term, noises_a, noises_b)
return plan
def __init__(self, parameters, code, guiding_array=None, render_kwds=None):
Computation.__init__(self, parameters)
self._root_parameters = list(self.signature.parameters.keys())
if isinstance(code, Snippet):
self._snippet = code
else:
self._snippet = Snippet(helpers.template_def(
['idxs'] + self._root_parameters, code),
render_kwds=render_kwds)
if guiding_array is None:
guiding_array = self._root_parameters[0]
if isinstance(guiding_array, str):
self._guiding_shape = self.signature.parameters[
guiding_array].annotation.type.shape
else:
self._guiding_shape = guiding_array
def _build_plan(
self, plan_factory, device_params,
ks_a, ks_b, ks_cv, in_key, out_key, noises_a, noises_b):
plan = plan_factory()
extracted_n, t, base, inner_n = ks_a.shape
mean = Reduce(noises_b, predicate_sum(noises_b.dtype))
norm = transformations.div_const(mean.parameter.output, numpy.prod(noises_b.shape))
mean.parameter.output.connect(norm, norm.input, mean=norm.output)
noises_b_mean = plan.temp_array_like(mean.parameter.mean)
mul_key = MatrixMulVector(noises_a)
b_term = plan.temp_array_like(mul_key.parameter.output)
build_keyswitch = PureParallel([
Parameter('ks_a', Annotation(ks_a, 'o')),
Parameter('ks_b', Annotation(ks_b, 'o')),
Parameter('ks_cv', Annotation(ks_cv, 'o')),
Parameter('in_key', Annotation(in_key, 'i')),
Parameter('b_term', Annotation(b_term, 'i')),
Parameter('noises_a', Annotation(noises_a, 'i')),
Parameter('noises_b', Annotation(noises_b, 'i')),
Parameter('noises_b_mean', Annotation(noises_b_mean, 'i'))],
Snippet(
TEMPLATE.get_def("make_lwe_keyswitch_key"),
render_kwds=dict(
log2_base=self._log2_base, output_size=self._output_size,
double_to_t32=double_to_t32_module, noise=self._noise)),
guiding_array="ks_b")
plan.computation_call(mean, noises_b_mean, noises_b)
plan.computation_call(mul_key, b_term, noises_a, out_key)
plan.computation_call(
build_keyswitch,
ks_a, ks_b, ks_cv, in_key, b_term, noises_a, noises_b, noises_b_mean)
return plan
def kernel_declaration(kernel_name, parameters):
return Snippet(_snippet_kernel_declaration,
render_kwds=dict(param_cnames_seq=param_cnames_seq,
kernel_name=kernel_name,
parameters=parameters))
def combinator_call(dtype, m1num=1, m2num=1, snum=1):
c = combinator(dtype, m1num=m1num, m2num=m2num, snum=snum)
return Snippet(TEMPLATE.get_def('snippet'), render_kwds=dict(c=c))
