def __init__(
self,
groupObj=None,
base=None,
minimum=0,
maximum=0,
step=0,
):
assert is_scalar(minimum)
assert is_scalar(maximum)
assert isinstance(step, int)
assert not step < 0
self.group = groupObj
self.base = base
self.minimum = math.floor(minimum / step) * (step)
self.maximum = math.ceil(maximum // step) * (step)
self.step = step
self.table = f'dlogs{hash(self.base)}'
conn = self.get_conn()
cursor = conn.cursor()
try:
cursor.execute('create table {} (hash bigint,'
' log bigint, UNIQUE(hash, log));'.format(
self.table))
conn.commit()
except Exception as e:
print(e)
cursor.execute('rollback;')
conn.commit()
def param_list2str(p_list, prefix=None, keep_empty=False):
if is_scalar(p_list):
p_list = param_str2list(p_list, keep_empty)
u_p_list = [unicode(p) for p in p_list]
ret = "|".join(
[prefixed(t, prefix) for t in u_p_list if (t or keep_empty)])
return unicode(ret)
def __init__(self, matrix=None, source=''):
if source:
self.fromFile(source)
return
if matrix is None:
return
assert is_array(matrix)
k = len(matrix)
assert k
assert (is_array(matrix[i]) for i in range(k))
classes = len(matrix[0])
assert classes
assert (len(matrix[i]) == classes for i in range(k))
assert (is_scalar(matrix[i][j]) for i in range(k)
for j in range(classes))
self.classes = classes
self.k = k
self.content = [[int(matrix[i][j]) for j in range(classes)]
for i in range(k)]
self.nbits = []
for j in range(k):
m = 1
for x in self.content[j]:
if abs(x) > m:
m = abs(x)
self.nbits.append(int(log2(m)) + 1)
def __init__(self, matrix=None, source=''):
if source:
self.fromFile(source)
return
if matrix is None:
return
assert is_array(matrix)
n = len(matrix)
assert n > 0
assert (is_array(matrix[i]) for i in range(n))
k = len(matrix[0])
assert k > 0
assert (len(matrix[i]) == k for i in range(n))
assert (is_scalar(matrix[i][j]) for i in range(n) for j in range(k))
self.n = n
self.k = k
self.columns = [[int(matrix[i][j]) for j in range(k)]
for i in range(n)]
self.nbits = []
for j in range(n):
m = 1
for x in self.columns[j]:
if abs(x) > m:
m = abs(x)
self.nbits.append(int(log2(m)) + 1)
def param_list2str(p_list, prefix=None, keep_empty=False):
if is_scalar(p_list):
p_list = param_str2list(p_list, keep_empty)
u_p_list = [unicode(p) for p in p_list]
ret = "|".join([prefixed(t, prefix)
for t in u_p_list if (t or keep_empty)])
return unicode(ret)
def param_str2list(p, keep_empty=False):
p = p or ''
if is_scalar(p):
p = unicode(p)
else:
p = param_list2str(p)
p_list = p.split('|')
if not keep_empty:
p_list = [sp for sp in p_list if sp]
return p_list
def param_str2list(p, keep_empty=False):
p = p or ''
if is_scalar(p):
p = unicode(p)
else:
p = param_list2str(p)
p_list = p.split('|')
if not keep_empty:
p_list = [sp for sp in p_list if sp]
return p_list
def __init__(self, array=None, source=''):
if source:
self.fromFile(source)
return
if is_array(array):
assert len(
array) > 0, 'Trying to generate an image from an empty vector.'
self.n = len(array)
self.content = []
for s in array:
assert is_scalar(s), "Input doesn't contain valid scalars."
self.content.append(int(s))
else:
WrongInputError(array)
def _coerce_value(self, value):
# TODO: it's real late and this is a bit of a sty
# also, in some cases the bar-split normalization
# should not occur (e.g., on a URL)
if value is None:
return value
try:
return self.coerce_func(value)
except AttributeError:
pass
if is_scalar(value):
if isinstance(value, basestring):
return value
else:
# some models are iterable, but none are sequences/sets (yet)
coerced = []
for v in value:
if isinstance(v, basestring):
coerced.append(v)
else:
coerced.append(self.coerce_func(v))
return coerced
raise TypeError('could not coerce value %r to %r' % (value, self.key))
def _coerce_value(self, value):
# TODO: it's real late and this is a bit of a sty
# also, in some cases the bar-split normalization
# should not occur (e.g., on a URL)
if value is None:
return value
try:
return self.coerce_func(value)
except AttributeError:
pass
if is_scalar(value):
if isinstance(value, basestring):
return value
else:
# some models are iterable, but none are sequences/sets (yet)
coerced = []
for v in value:
if isinstance(v, basestring):
coerced.append(v)
else:
coerced.append(self.coerce_func(v))
return coerced
raise TypeError('could not coerce value %r to %r' % (value, self.key))
def get_value_list(self, value, prefix=None):
if is_scalar(value):
return [value]
return value
def get_value_list(self, value, prefix=None):
if is_scalar(value):
return [value]
return value
