def _match_iter (self, col_iter, word, max_edits) :
"""Generate all words with a Levenshtein-distance <= max_edits to word."""
### http://en.wikipedia.org/wiki/Levenshtein_distance
### http://stevehanov.ca/blog/index.php?id=114
row_1 = pyk.range (len (word) + 1)
for char, node in pyk.iteritems (self.root.children) :
for m in self._match_iter_inner \
(col_iter, word, max_edits, char, node, row_1) :
yield m
d = Divisor_Dag (number)
table = _Divisor_Dag_.Table.copy ()
_Divisor_Dag_.Table = {}
t1 = time ()
table = {}
t2 = time ()
ignore = float (t2 - t1) * iterations
t1 = time ()
for i in range (iterations) :
d = Divisor_Dag (number)
_Divisor_Dag_.Table = {}
t2 = time ()
duration = float (t2 - t1 - ignore) / iterations
result = duration / len (d.divisors)
return (len (d.divisors), duration, result, number)
cases = ( ( 2, pyk.range (1, 16))
, (10, [10] * 16)
, ( 2, map (lambda i, p = primes : p [i], pyk.range (16)))
)
numbers = []
for number, factors in cases :
i = 1
while number <= limit :
numbers.append (number)
number = number * factors [i]
i = i + 1
results = []
for number in sorted (numbers) :
results.append (test_time (number, iterations))
for (divisors, duration, d, number) in sorted (results) :
print \
class Node(TFL.Meta.BaM(TFL.Meta.Object, metaclass=TFL.SDG.M_Node)):
"""Node of a structured document."""
children = property(lambda s: s._children_iter())
children_group_names = (Body, ) = pyk.range(1)
default_cgi = Body
body_children = property(lambda s: s.children_groups[s.Body])
base_indent = " "
NL = "\n"
init_arg_defaults = dict(name="", cgi=0)
_autoconvert = {}
front_args = ()
rest_args = None
_list_of_formats = ("repr_format", "str_format")
repr_format = """
%(__class__.__name__)s
>%(:front=( ¡front0=(¡rear=%(NL)s)¡rear0=)¡sep=, :\
>*children,>@_formatted_attrs:)s
"""
str_format = """
%(__class__.__name__)s %(name)s
>%(::*children:)s
"""
def __init__(self, *children, **kw):
self.parent = None
n = len(children)
for a in self.front_args:
if children:
if a in kw:
raise TypeError \
( "%s() got multiple values for keyword argument %s"
% (self.__class__.__name__, a)
)
kw[a] = children[0]
children = children[1:]
elif a not in kw:
raise TypeError \
( "%s() takes exactly %s arguments (%s given)"
% (self.__class__.__name__, len (self.front_args), n)
)
if self.rest_args and children:
kw[self.rest_args] = children
children = ()
self._init_kw(kw)
if not self.name:
self.name = "__%s_%d" % (self.__class__.__name__, self.id)
self._reset_children()
self.add(*children)
# end def __init__
def add(self, *children):
"""Append all `children' to `self.children'"""
for c in un_nested(children):
self.insert(c)
# end def add
def as_repr(self, base_indent=None):
return self.formatted("repr_format", base_indent)
# end def as_repr
def as_str(self, base_indent=None):
return self.formatted("str_format", base_indent)
# end def as_str
def destroy(self):
for c in self.children:
c.destroy()
self._reset_children()
self.parent = None
# end def destroy
def formatted(self,
format_name,
base_indent=None,
output_width=79,
indent_offset=0,
indent_anchor=None,
ht_width=0,
**kw):
if base_indent is None:
base_indent = self.base_indent
recurser = "formatted"
formatters = getattr(self, format_name)
recurse_kw = dict \
( format_name = format_name
, base_indent = base_indent
, output_width = output_width
, ** kw
)
context = TFL.Caller.Object_Scope(self)
for f in formatters:
indent = f.indent_level * base_indent
io = indent_offset + len(indent)
context.locals["indent_offset"] = io
if indent_anchor is None:
context.locals["indent_anchor"] = io
else:
context.locals["indent_anchor"] = indent_anchor + len(indent)
for l in f(self, context):
x = indent + l
yield x
# end def formatted
def has_child(self, child_name, transitive=True):
"""Checks if this node or one of this childs has a node named
`child_name'.
"""
child_name = self._child_name(child_name)
for children in pyk.itervalues(self.children_groups):
if child_name in children:
return children[child_name]
if transitive:
for c in self.children:
child = c.has_child(child_name, transitive=True)
if child is not None:
return child
# end def has_child
def insert(self, child, index=None, delta=0):
"""Insert `child' to `self.children' at position `index'
(None means append).
"""
if child is not None:
cgi = getattr(child, "cgi", None)
if cgi is None:
cgi = self.default_cgi
else:
self.default_cgi = min(cgi, self.default_cgi)
self._insert(child, index, self.children_groups[cgi], delta)
# end def insert
def _child_name(self, child_name):
if isinstance(child_name, Node):
child_name = child_name.name
return child_name
# end def _child_name
def _children_iter(self):
for group in pyk.itervalues(self.children_groups):
for c in group:
yield c
# end def _children_iter
def _convert(self, value, Class, *args, **kw):
if value and isinstance(value, pyk.string_types):
value = Class(value.strip(), *args, **kw)
return value
# end def _convert
def _formatted_attrs(self, *args, **kw):
for k, v in sorted(pyk.iteritems(self.init_arg_defaults)):
a = getattr(self, k)
if a != v:
if pyk.text_type != str and isinstance(a, pyk.text_type):
### Python2: encode unicode to avoid `u`-prefix
a = TFL.I18N.encode_o(a)
yield "%s = %r" % (k, a)
# end def _formatted_attrs
def _init_kw(self, kw):
kw_err = {}
for k, v in pyk.iteritems(self.init_arg_defaults):
if not hasattr(self, k):
setattr(self, k, v)
for k, v in pyk.iteritems(kw):
if k in self.init_arg_defaults:
### protect `%` characters hidden inside `v` to avoid
### ValueErrors during formatting
if isinstance(v, pyk.string_types):
v = v.replace("%", "%%")
elif isinstance(v, (tuple, list, TFL.NO_List)):
vin = v
v = []
for x in vin:
if isinstance(x, pyk.string_types):
x = x.replace("%", "%%")
v.append(x)
if k in self._autoconvert:
v = self._autoconvert[k](self, k, v)
setattr(self, k, v)
else:
kw_err[k] = v
if kw_err:
print(self.__class__, self.init_arg_defaults)
raise TypeError("unexpected keyword arguments: %s" % kw_err)
# end def _init_kw
def _insert(self, child, index, children, delta=0):
if child:
if index is None:
index = len(children)
child.parent = self
children.insert(index, child, delta)
# end def _insert
def _reset_children(self):
self.children_groups = dict \
((i, NO_List ()) for i in self.children_group_names)
# end def _reset_children
def _write_to_stream(self, gen, stream, gauge=None):
encoded = pyk.encoded
if stream is None:
encoded = lambda x: x
stream = sys.stdout
for x in gen:
stream.write(encoded(x))
stream.write(encoded("\n"))
if gauge is not None:
gauge.inc()
# end def _write_to_stream
def __iter__(self):
yield self
for c in self.children:
for n in iter(c):
yield n
# end def __iter__
def __repr__(self):
return "(%s)" % ("\n".join(self.as_repr()), )
# end def __repr__
def __str__(self):
return "\n".join(self.as_str())
table = _Divisor_Dag_.Table.copy()
_Divisor_Dag_.Table = {}
t1 = time()
table = {}
t2 = time()
ignore = float(t2 - t1) * iterations
t1 = time()
for i in range(iterations):
d = Divisor_Dag(number)
_Divisor_Dag_.Table = {}
t2 = time()
duration = float(t2 - t1 - ignore) / iterations
result = duration / len(d.divisors)
return (len(d.divisors), duration, result, number)
cases = ((2, pyk.range(1, 16)), (10, [10] * 16),
(2, map(lambda i, p=primes: p[i], pyk.range(16))))
numbers = []
for number, factors in cases:
i = 1
while number <= limit:
numbers.append(number)
number = number * factors[i]
i = i + 1
results = []
for number in sorted(numbers):
results.append(test_time(number, iterations))
for (divisors, duration, d, number) in sorted(results):
print \
( "Divisor_Dag (%8d) : %3d divisors %.6fs (%.6fs / divisor)"
% (number, divisors, duration, d)
class _C_Node_ (TFL.SDG.Node) :
"""Model a node of the code in a C file"""
_real_name = "Node"
base_indent = " "
description_level = 1
eol_desc_level = description_level + 4
star_level = 1
pass_scope = True
children_group_names = \
( Body
, Decl
, Head
, Tail
, Then
, Elseif
, Else
, Case
, Default
) = pyk.range (9)
body_children = property (lambda s : s.children_groups [s.Body])
decl_children = property (lambda s : s.children_groups [s.Decl])
head_children = property (lambda s : s.children_groups [s.Head])
tail_children = property (lambda s : s.children_groups [s.Tail])
then_children = property (lambda s : s.children_groups [s.Then])
elseif_children = property (lambda s : s.children_groups [s.Elseif])
else_children = property (lambda s : s.children_groups [s.Else])
case_children = property (lambda s : s.children_groups [s.Case])
default_children = property (lambda s : s.children_groups [s.Default])
init_arg_defaults = dict \
( description = None
, eol_desc = None
, scope = HC
)
_autoconvert = dict \
( description =
lambda s, k, v : s._convert_c_comment (k, v, eol = False)
, eol_desc =
lambda s, k, v : s._convert_c_comment (k, v, eol = True)
)
_list_of_formats = TFL.SDG.Node._list_of_formats + \
( "c_format", "h_format", "vaps_channel_format", "apidoc_tex_format")
_scope_filter = dict \
( c_format = C
, h_format = H
)
vaps_channel_format = "" ### not implemented for all types
apidoc_tex_format = "" ### not implemented for all types
def as_c_code (self, base_indent = None) :
return self.formatted ("c_format", base_indent = base_indent)
# end def as_c_code
def as_h_code (self, base_indent = None) :
return self.formatted ("h_format", base_indent = base_indent)
# end def as_h_code
def as_vaps_channel (self, base_indent = None) :
return self.formatted \
("vaps_channel_format", base_indent = base_indent)
# end def as_c_code
def as_apidoc (self, base_indent = None) :
return self.formatted \
("apidoc_tex_format", base_indent = base_indent)
# end def as_apidoc
def formatted (self, format_name, * args, ** kw) :
if self.scope & self._scope_filter.get (format_name, 0xFF) :
return self.__super.formatted (format_name, * args, ** kw)
else :
return ()
# end def formatted
def write_to_c_stream (self, cstream = None, gauge = None) :
"""Write `self' and all elements in `self.children' to `cstream'.
"""
self._write_to_stream (self.as_c_code (), cstream, gauge)
# end def write_to_c_stream
write_to_stream = write_to_c_stream
def write_to_h_stream (self, hstream = None, gauge = None) :
self._write_to_stream (self.as_h_code (), hstream, gauge)
# end def write_to_h_stream
def write_to_vaps_channel (self, stream = None, gauge = None) :
self._write_to_stream (self.as_vaps_channel (), stream, gauge)
# end def write_to_vaps_channel
def write_to_apidoc (self, stream = None, gauge = None) :
self._write_to_stream (self.as_apidoc (), stream, gauge)
# end def write_to_apidoc
def _convert_c_comment (self, name, value, eol = 0, new_line_col = 0) :
result = value
if result and isinstance (result, pyk.string_types) :
result = (result, )
if result and isinstance (result, (tuple, list)) :
result = TFL.SDG.C.Comment \
( * result
, ** dict
( level = getattr
( self, "%s_level" % (name, )
, self.description_level
)
, stars = self.star_level
, eol = eol
, new_line_col = new_line_col
)
)
return result
# end def _convert_c_comment
def _convert_c_stmt (self, value) :
if value and isinstance (value, pyk.string_types) :
result = []
for s in value.split (";") :
stmt = self._convert (s.strip (), TFL.SDG.C.Statement)
if stmt :
result.append (stmt)
else :
if isinstance (value, (list, tuple, NO_List)) :
result = value
else :
result = [value]
return result
# end def _convert_c_stmt
def _force (self, value, Class, * args, ** kw) :
"""Converts `value' to an instance of `Class'."""
value = self._convert (value, Class, * args, ** kw)
if not isinstance (value, Class) :
value = Class (value, * args, ** kw)
return value
# end def _force
def _insert (self, child, index, children, delta = 0) :
if child :
self._update_scope_child (child, self.scope)
self.__super._insert (child, index, children, delta)
# end def _insert
def _update_scope (self, scope) :
self.scope = self.scope & scope
# end def _update_scope
def _update_scope_child (self, child, scope) :
if self.pass_scope :
child._update_scope (self.scope)
