def __init__(self, *expr_factor_tuples, **keywords):
# set intercept / main_effect behaviour
add_main_effects = False
if "add_main_effects" in keywords:
add_main_effects = keywords['add_main_effects']
add_intercept = True
if "add_intercept" in keywords:
add_intercept = keywords['add_intercept']
self.default_contrast = 'drop_reference'
if "default_contrast" in keywords:
self.default_contrast = keywords['default_contrast']
self.graded_dict = {}
# create a copy of graded_dict
# removing duplicate tuples of factors in the values
for expr_factors in expr_factor_tuples:
# each element of the sequence should have the form
# (sympy, [factors]) or sympy or (sympy, factor)
if is_factor(expr_factors):
expr_factors = (1, expr_factors)
try:
expr, factors = tuple(expr_factors)
except TypeError: # not a sequence
expr, factors = expr_factors, ()
if is_factor(factors):
factors = [factors]
factors = tuple(factors)
l = self.graded_dict.setdefault(sympy.sympify(expr),
{}).setdefault(len(factors), [])
# ensure uniqueness
if factors not in l:
l.append(factors)
# aliases for the intercept
aliases_for_intercept = [1, 'constant', '(Intercept)']
for s in aliases_for_intercept:
if s in self.graded_dict:
for k in self.graded_dict[s].keys():
self.graded_dict.setdefault(sympy.Number(1),
{}).setdefault(k, []).extend(
self.graded_dict[s][k])
del (self.graded_dict[s])
if add_intercept:
self.graded_dict.setdefault(sympy.Number(1), {})[0] = [()]
if add_main_effects:
for expr in self.graded_dict:
self.graded_dict[expr][0] = [()]
def __init__(self, *expr_factor_tuples, **keywords):
# set intercept / main_effect behaviour
add_main_effects = False
if "add_main_effects" in keywords:
add_main_effects = keywords['add_main_effects']
add_intercept=True
if "add_intercept" in keywords:
add_intercept = keywords['add_intercept']
self.default_contrast='drop_reference'
if "default_contrast" in keywords:
self.default_contrast = keywords['default_contrast']
self.graded_dict = {}
# create a copy of graded_dict
# removing duplicate tuples of factors in the values
for expr_factors in expr_factor_tuples:
# each element of the sequence should have the form
# (sympy, [factors]) or sympy or (sympy, factor)
if is_factor(expr_factors):
expr_factors = (1, expr_factors)
try:
expr, factors = tuple(expr_factors)
except TypeError: # not a sequence
expr, factors = expr_factors, ()
if is_factor(factors):
factors = [factors]
factors = tuple(factors)
l = self.graded_dict.setdefault(sympy.sympify(expr), {}).setdefault(len(factors), [])
# ensure uniqueness
if factors not in l:
l.append(factors)
# aliases for the intercept
aliases_for_intercept=[1, 'constant', '(Intercept)']
for s in aliases_for_intercept:
if s in self.graded_dict:
for k in self.graded_dict[s].keys():
self.graded_dict.setdefault(sympy.Number(1), {}).setdefault(k, []).extend(self.graded_dict[s][k])
del(self.graded_dict[s])
if add_intercept:
self.graded_dict.setdefault(sympy.Number(1), {})[0] = [()]
if add_main_effects:
for expr in self.graded_dict:
self.graded_dict[expr][0] = [()]
def __init__(self, *expr_factor_tuples):
self.graded_dict = {}
# create a copy of graded_dict
# removing duplicate tuples of factors in the values
for expr_factors in expr_factor_tuples:
# each element of the sequence should have the form
# (sympy, [factors]) or sympy or (sympy, factor)
try:
expr, factors = tuple(expr_factors)
except TypeError: # not a sequence
expr, factors = expr_factors, ()
if is_factor(factors):
factors = [factors]
factors = tuple(factors)
self.graded_dict.setdefault(expr, {}).setdefault(len(factors), []).append(factors)
# aliases for the intercept
for s in ANCOVA.aliases_for_intercept:
if s in self.graded_dict:
for k in self.graded_dict[s].keys():
self.graded_dict.setdefault(sympy.Number(1), {}).setdefault(k, []).extend(self.graded_dict[s][k])
del(self.graded_dict[s])
if ANCOVA.add_intercept:
self.graded_dict.setdefault(sympy.Number(1), {})[0] = [[]]
if ANCOVA.add_main_effects:
for expr in self.graded_dict:
self.graded_dict[expr][0] = [[]]
def __mul__(self, other):
if is_factor(other):
return self.multiply_by_factor(other)
elif is_ancova(other):
result = []
oseq = other.sequence
sseq = self.sequence
for se, sf in self.sequence():
for oe, of in other.sequence():
result.append((se * oe, sf + of))
return ANCOVA(*result)
else:
return self.multiply_by_expression(other)
def __mul__(self, other):
if is_factor(other):
return self.multiply_by_factor(other)
elif is_ancova(other):
result = []
oseq = other.sequence
sseq = self.sequence
for se, sf in self.sequence():
for oe, of in other.sequence():
result.append((se*oe, sf+of))
return ANCOVA(*result)
else:
return self.multiply_by_expression(other)
def sorted_factors(self):
"""
Take every factor appearing in the formula
and sort its levels. The sort matters because
this is the column that is dropped when
constructing a design in which this factor
is to be coded as "contrast".
>>> x = Term('x'); f = Factor('f', [2,1,3]) ; h =Factor('h', range(2))
>>> a = ANCOVA((x,f), (x,(f,h)))
>>> a.sorted_factors
{'h': Factor('h', [0, 1]), 'f': Factor('f', [1, 2, 3])}
>>>
The ordering of the levels of the factors
changes which columns are produced when
a factor is coded as a contrast.
>> x = Term('x'); f = Factor('f', [2,1,3]) ; h =Factor('h', range(2))
>>> a = ANCOVA((x,h), (x,(f,h)))
In this example, in the "x:f:h" term, "f" is coded
as a contrast and its "first" level is dropped. This
is the "first" of the sorted levels of "f".
"""
if not hasattr(self, "_sorted_factors"):
self._sorted_factors = {}
for expr in self.graded_dict:
for order in self.graded_dict[expr]:
for factors in self.graded_dict[expr][order]:
for factor in factors:
if is_factor(
factor
) and factor.name not in self._sorted_factors:
self._sorted_factors[factor.name] = Factor(
factor.name, sorted(factor.levels))
return self._sorted_factors
def sorted_factors(self):
"""
Take every factor appearing in the formula
and sort its levels. The sort matters because
this is the column that is dropped when
constructing a design in which this factor
is to be coded as "contrast".
>>> x = Term('x'); f = Factor('f', [2,1,3]) ; h =Factor('h', range(2))
>>> a = ANCOVA((x,f), (x,(f,h)))
>>> a.sorted_factors
{'h': Factor('h', [0, 1]), 'f': Factor('f', [1, 2, 3])}
>>>
The ordering of the levels of the factors
changes which columns are produced when
a factor is coded as a contrast.
>> x = Term('x'); f = Factor('f', [2,1,3]) ; h =Factor('h', range(2))
>>> a = ANCOVA((x,h), (x,(f,h)))
In this example, in the "x:f:h" term, "f" is coded
as a contrast and its "first" level is dropped. This
is the "first" of the sorted levels of "f".
"""
if not hasattr(self, "_sorted_factors"):
self._sorted_factors = {}
for expr in self.graded_dict:
for order in self.graded_dict[expr]:
for factors in self.graded_dict[expr][order]:
for factor in factors:
if is_factor(factor) and factor.name not in self._sorted_factors:
self._sorted_factors[factor.name] = Factor(factor.name, sorted(factor.levels))
return self._sorted_factors
def __mul__(self, other):
if is_factor(other):
return self.multiply_by_factor(other)
else:
return self.multiply_by_expression(other)