def evaluate(self, context):
entity = context['__entity__']
baseperiod = entity.base_period
period = context['period'] - 1
expr = self.expr
typemap = {bool: int, int: int, float: float}
res_type = typemap[dtype(expr, context)]
res_size = len(entity.array)
sum_values = np.zeros(res_size, dtype=res_type)
id_to_rownum = context.id_to_rownum
while period >= baseperiod:
ids, values = entity.value_for_period(expr, period, context,
fill=None)
# filter out lines which are present because there was a value for
# that individual at that period but not for that column
acceptable_rows = hasvalue(values)
acceptable_ids = ids[acceptable_rows]
if len(acceptable_ids):
acceptable_values = values[acceptable_rows]
value_rows = id_to_rownum[acceptable_ids]
period_value = np.zeros(res_size, dtype=np.float)
safe_put(period_value, value_rows, acceptable_values)
sum_values += period_value
period -= 1
return sum_values
def evaluate(self, context):
if self.filter is None:
return context_length(context)
else:
# TODO: check this at "compile" time (in __init__), though for
# that we need to know the type of all temporary variables
# first
if dtype(self.filter, context) is not bool:
raise Exception("grpcount filter must be a boolean expression")
return np.sum(expr_eval(self.filter, context))
def _getfilter(self, context):
ctx_filter = context.get('__filter__')
if self.filter is not None and ctx_filter is not None:
filter_expr = ctx_filter & self.filter
elif self.filter is not None:
filter_expr = self.filter
elif ctx_filter is not None:
filter_expr = ctx_filter
else:
filter_expr = None
if filter_expr is not None and dtype(filter_expr, context) is not bool:
raise Exception("filter must be a boolean expression")
return filter_expr
def evaluate(self, context):
expr = self.expr
# FIXME: either take "contextual filter" into account here (by using
# self._getfilter), or don't do it in grpsum & grpgini
if self.filter is not None:
filter_values = expr_eval(self.filter, context)
tmp_varname = get_tmp_varname()
context = context.copy()
context[tmp_varname] = filter_values
if dtype(expr, context) is bool:
# convert expr to int because mul_bbb is not implemented in
# numexpr
expr *= 1
expr *= Variable(tmp_varname)
else:
filter_values = True
values = expr_eval(expr, context)
values = np.asarray(values)
if self.skip_na:
# we should *not* use an inplace operation because filter_values
# can be a simple variable
filter_values = filter_values & ispresent(values)
if filter_values is True:
numrows = len(values)
else:
numrows = np.sum(filter_values)
if numrows:
if self.skip_na:
return na_sum(values) / float(numrows)
else:
return np.sum(values) / float(numrows)
else:
return float("nan")
def evaluate(self, context):
expr = self.expr
#FIXME: either take "contextual filter" into account here (by using
# self._getfilter), or don't do it in grpsum (& grpgini?)
if self.filter is not None:
filter_values = expr_eval(self.filter, context)
tmp_varname = get_tmp_varname()
context = context.copy()
context[tmp_varname] = filter_values
if dtype(expr, context) is bool:
# convert expr to int because mul_bbb is not implemented in
# numexpr
expr *= 1
expr *= Variable(tmp_varname)
else:
filter_values = True
values = expr_eval(expr, context)
filter_values &= np.isfinite(values)
numrows = np.sum(filter_values)
if numrows:
return np.nansum(values) / float(numrows)
else:
return float('nan')
def dtype(self, context):
assert dtype(self.cond, context) == bool
return coerce_types(context, self.iftrue, self.iffalse)
def dtype(self, context):
assert dtype(self.expr, context) == float
return int
def dtype(self, context):
# result dtype is the same as the input dtype
res = dtype(self.args[0], context)
assert res == float
return res
def dtype(self, context):
return dtype(self.expr1, context)
def dtype(self, context):
assert dtype(self.expr, context) == bool
return int
def dtype(self, context):
target_context = self.target_context(context)
return dtype(self.target_expr, target_context)
def dtype(self, context):
target_context = self.target_context(context)
expr_dype = dtype(self.target_expr, target_context)
#TODO: merge this typemap with tsum's
typemap = {bool: int, int: int, float: float}
return typemap[expr_dype]
def add_filter(self, expr, context):
if self.filter is not None:
missing_value = missing_values[dtype(expr, context)]
return Where(self.filter, expr, missing_value)
else:
return expr
def dtype(self, context):
return dtype(self.args[0], context)
def dtype(self, context):
# TODO: merge this typemap with tsum's
typemap = {bool: int, int: int, float: float}
return typemap[dtype(self.args[0], context)]
