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)