ruby-sfst 0.4.3 → 0.4.4

data/ext/sfst_machine/operators.cc

@@ -1,1131 +0,0 @@
-
-/*******************************************************************/
-/*                                                                 */
-/*  FILE     operators.C                                           */
-/*  MODULE   operators                                             */
-/*  PROGRAM  SFST                                                  */
-/*  AUTHOR   Helmut Schmid, IMS, University of Stuttgart           */
-/*                                                                 */
-/*******************************************************************/
-
-
-#include "fst.h"
-
-using std::pair;
-using std::cerr;
-
-static void compose_nodes( Node*, Node*, Node*, Transducer*, PairMapping& );
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  check_cyclicity                                                */
-/*                                                                 */
-/*******************************************************************/
-
-static bool check_cyclicity( Node *node, NodeHashSet &visited, 
-			     const Alphabet &alphabet)
-{ 
- 
-  if (!visited.insert(node).second)
-    return true; // node was visited before
-
-  for( ArcsIter p(node->arcs()); p; p++ ) {
-    Arc *arc=p;
-    if (arc->label().upper_is_epsilon())
-      if (check_cyclicity(arc->target_node(), visited, alphabet)) {
-	cerr << alphabet.write_label(arc->label()) << "\n";
-	return true;
-      }
-  }
-  visited.erase(node);
-  return false;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::infinitely_ambiguous_node                          */
-/*                                                                 */
-/*******************************************************************/
-
-bool Transducer::infinitely_ambiguous_node( Node *node )
-
-{
-  if (!node->was_visited( vmark )) {
-    NodeHashSet visited;
-    if (check_cyclicity(node, visited, alphabet))
-      return true;
-
-    // iterate over all outgoing arcs
-    for( ArcsIter p(node->arcs()); p; p++ ) {
-      Arc *arc=p;
-      if (infinitely_ambiguous_node( arc->target_node() ))
-	return true;
-    }
-  }
-  return false;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::is_infinitely_ambiguous                            */
-/*                                                                 */
-/*******************************************************************/
-
-bool Transducer::is_infinitely_ambiguous()
-
-{
-  incr_vmark();
-  return infinitely_ambiguous_node(root_node());
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::is_cyclic_node                                     */
-/*                                                                 */
-/*******************************************************************/
-
-bool Transducer::is_cyclic_node( Node *node, NodeHashSet &previous )
-
-{
-  if (!node->was_visited( vmark )) {
-    NodeHashSet visited;
-    
-    NodeHashSet::iterator it=previous.insert(node).first;
-
-    // iterate over all outgoing arcs
-    for( ArcsIter p(node->arcs()); p; p++ ) {
-      Arc *arc=p;
-      if (previous.find(arc->target_node()) != previous.end() || 
-	  is_cyclic_node( arc->target_node(), previous ))
-	return true;
-    }
-
-    previous.erase(it);
-  }
-  return false;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::is_cyclic                                          */
-/*                                                                 */
-/*******************************************************************/
-
-bool Transducer::is_cyclic()
-
-{
-  incr_vmark();
-  NodeHashSet previous;
-  return is_cyclic_node(root_node(), previous);
-}
-
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::is_automaton_node                                  */
-/*                                                                 */
-/*******************************************************************/
-
-bool Transducer::is_automaton_node( Node *node )
-
-{
-  if (!node->was_visited( vmark )) {
-    // iterate over all outgoing arcs
-    for( ArcsIter p(node->arcs()); p; p++ ) {
-      Arc *arc=p;
-      Label l=arc->label();
-      if (l.upper_char() != l.lower_char())
-	return false;
-      if (!is_automaton_node( arc->target_node()))
-	return false;
-    }
-  }
-  return true;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::is_automaton                                       */
-/*                                                                 */
-/*******************************************************************/
-
-bool Transducer::is_automaton()
-
-{
-  incr_vmark();
-  return is_automaton_node(root_node());
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::is_empty                                           */
-/*                                                                 */
-/*******************************************************************/
-
-bool Transducer::is_empty()
-
-{
-  if (!minimised) {
-    Transducer *tmp=&minimise();
-    bool result=tmp->is_empty();
-    delete tmp;
-    return result;
-  }
-  if (root_node()->is_final())
-    return false;
-  return root_node()->arcs()->is_empty();
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::generates_empty_string                             */
-/*                                                                 */
-/*******************************************************************/
-
-bool Transducer::generates_empty_string()
-
-{
-  if (!minimised) {
-    Transducer *tmp=&minimise();
-    bool result=tmp->root_node()->is_final();
-    delete tmp;
-    return result;
-  }
-  return root_node()->is_final();
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::reverse_node                                       */
-/*                                                                 */
-/*******************************************************************/
-
-void Transducer::reverse_node( Node *node, Transducer *na )
-
-{
-  if (!node->was_visited( vmark )) {
-
-    // create a new node
-    node->set_forward( na->new_node() );
-
-    if (node->is_final())
-      // add epsilon transition from new root to this node
-      na->root_node()->add_arc( Label(), node->forward(), na );
-    
-    // iterate over all outgoing arcs
-    for( ArcsIter p(node->arcs()); p; p++ ) {
-      Arc *arc=p;
-      
-      // reverse the subgraph headed by the target node
-      reverse_node( arc->target_node(), na );
-      Node *n = arc->target_node()->forward();
-
-      // create the reverse arc
-      n->add_arc( arc->label(), node->forward(), na );
-    }
-  }
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::reverse                                            */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer &Transducer::reverse()
-
-{
-  Transducer *na = new Transducer();
-  na->alphabet.copy(alphabet);
-
-  incr_vmark();
-  reverse_node(root_node(), na);
-  root_node()->forward()->set_final(1);
-  return *na;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::recode_label                                       */
-/*                                                                 */
-/*******************************************************************/
-
-Label Transducer::recode_label( Label l, bool lswitch, bool recode, 
-			       Alphabet &al )
-{
-  if (lswitch)
-    l = Label(l.upper_char(), l.lower_char());
-
-  if (recode) {
-    Character lc = al.add_symbol(alphabet.code2symbol(l.lower_char()));
-    Character uc = al.add_symbol(alphabet.code2symbol(l.upper_char()));
-    l = Label(lc, uc);
-    al.insert(l);
-  }
-
-  return l;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::copy_nodes                                         */
-/*                                                                 */
-/*******************************************************************/
-
-Node *Transducer::copy_nodes( Node *node, Transducer *a, 
-			     bool lswitch, bool recode )
-{
-  if (!node->was_visited(vmark)) {
-
-    node->set_forward(a->new_node());
-
-    // define final nodes
-    if (node->is_final())
-      node->forward()->set_final(1);
-
-    // iterate over all outgoing arcs of node
-    for( ArcsIter p(node->arcs()); p; p++ ) {
-      Arc *arc=p;
-      Node *tn = copy_nodes( arc->target_node(), a, lswitch, recode );
-
-      // Add a link to the new node
-      Label l=recode_label(arc->label(), lswitch, recode, a->alphabet);
-      node->forward()->add_arc( l, tn, a );
-    }
-  }
-
-  return node->forward();
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::copy                                               */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer &Transducer::copy( bool lswitch, const Alphabet *al )
-
-{
-  bool recode = false;
-  Transducer *na = new Transducer();
-  if (al == NULL)
-    al = &alphabet;
-  else
-    recode = true;
-
-  na->alphabet.utf8 = al->utf8;
-  if (lswitch) {
-    na->alphabet.insert_symbols(*al);
-    for( Alphabet::iterator it=al->begin(); it!=al->end(); it++ ) {
-      Character lc=it->lower_char();
-      Character uc=it->upper_char();
-      na->alphabet.insert(Label(uc,lc));
-    }
-  }
-  else
-    na->alphabet.copy(*al);
-
-  na->deterministic = deterministic;
-  na->minimised = minimised;
-  na->root_node()->set_final(root_node()->is_final());
-  incr_vmark();
-
-  root_node()->set_forward(na->root_node());
-  root_node()->was_visited(vmark);
-
-  for( ArcsIter p(root_node()->arcs()); p; p++ ) {
-    Arc *arc=p;
-    Node *target_node=copy_nodes(arc->target_node(), na, lswitch, recode);
-    Label l = recode_label(arc->label(), lswitch, recode, na->alphabet);
-    na->root_node()->add_arc( l, target_node, na);
-  }
-
-  return *na;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::operator |                                         */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer &Transducer::operator|( Transducer &a )
-
-{
-  Transducer *na = new Transducer();
-  na->alphabet.copy(alphabet);
-  na->alphabet.copy(a.alphabet);
-
-  incr_vmark();
-  na->root_node()->add_arc( Label(), copy_nodes(root_node(), na), na);
-  a.incr_vmark();
-  na->root_node()->add_arc( Label(), a.copy_nodes(a.root_node(), na), na);
-
-  return *na;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::rec_cat_nodes                                      */
-/*                                                                 */
-/*******************************************************************/
-
-void Transducer::rec_cat_nodes( Node *node, Node *node2 )
-
-{
-  if (!node->was_visited( vmark )) {
-
-    // iterate over all outgoing arcs of node
-    for( ArcsIter p(node->arcs()); p; p++ ) {
-      Arc *arc=p;
-      rec_cat_nodes( arc->target_node(), node2 );
-    }
-    
-    if (node->is_final()) {
-      // link this node to node2
-      node->set_final(0);
-      node->add_arc( Label(), node2, this );
-    }
-  }
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::operator+                                          */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer &Transducer::operator+( Transducer &a )
-
-{
-  Transducer *na = new Transducer();
-  na->alphabet.copy(alphabet);
-  na->alphabet.copy(a.alphabet);
-
-  // copy Transducer1 to the new Transducer
-  incr_vmark();
-  Node *node=copy_nodes(root_node(), na);
-  na->root_node()->add_arc( Label(), node, na);
-
-  // copy Transducer2 to the new Transducer
-  a.incr_vmark();
-  node=a.copy_nodes(a.root_node(), na);
-
-  // catenate the two automata
-  na->incr_vmark();
-  na->rec_cat_nodes(na->root_node(), node);
-
-  return *na;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::kleene_star                                        */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer &Transducer::kleene_star()
-
-{
-  Transducer *na = &copy();
-  na->alphabet.copy(alphabet);
-
-  // link back to the start node
-  na->incr_vmark();
-  na->rec_cat_nodes(na->root_node(), na->root_node());
-  na->root_node()->set_final(1);
-
-  na->deterministic = na->minimised = false;
-
-  return *na;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::negate_nodes                                       */
-/*                                                                 */
-/*******************************************************************/
-
-void Transducer::negate_nodes( Node *node, Node *accept )
-
-{
-  if (!node->was_visited(vmark)) {
-    node->set_final( !node->is_final() );
-
-    for( ArcsIter p(node->arcs()); p; p++ ) {
-      Arc *arc=p;
-      negate_nodes( arc->target_node(), accept );
-    }
-
-    for( Alphabet::iterator it=alphabet.begin(); it!=alphabet.end(); it++)
-      if (!node->target_node(*it))
-	node->add_arc( *it, accept, this );
-  }
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::productive_node                                    */
-/*                                                                 */
-/*******************************************************************/
-
-bool Transducer::productive_node( Node *node )
-
-{
-  if (node->was_visited(vmark))
-    return (node->forward() != NULL);
-
-  bool productive;
-  if (node->is_final()) {
-    productive = true;
-    node->set_forward( node );
-  }
-  else {
-    productive = false;
-    node->set_forward( NULL );
-  }
-
-  for( ArcsIter p(node->arcs()); p; p++ ) {
-    Arc *arc=p;
-    if (productive_node( arc->target_node() ))
-      productive = true;
-  }
-
-  if (productive)
-    // use forwardp to indicate whether the node is productive
-    node->set_forward(node);
-  return productive;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::prune_nodes                                        */
-/*                                                                 */
-/*******************************************************************/
-
-bool Transducer::prune_nodes( Node *node )
-
-{
-  if (!node->was_visited(vmark)) {
-    for( ArcsIter p(node->arcs()); p; p++ ) {
-      Arc *arc=p;
-      if (prune_nodes( arc->target_node() ))
-	node->arcs()->remove_arc(arc);
-    }
-    if (!node->arcs()->is_empty())
-      node->set_forward(node);
-  }
-  return (node->forward() == NULL);
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::prune                                              */
-/*                                                                 */
-/*******************************************************************/
-
-void Transducer::prune()
-
-{
-  incr_vmark();
-  productive_node( root_node() );
-  incr_vmark();
-  prune_nodes( root_node() );
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::operator!                                          */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer &Transducer::operator!()
-
-{
-  Transducer *na;
-
-  if (alphabet.size() == 0)
-    throw "Negation of Transducer with undefined alphabet attempted!";
-
-  if (minimised)
-    na = &copy();
-  else
-    na = &minimise();
-  na->alphabet.copy(alphabet);
-
-  Node *accept_node=na->new_node();
-  accept_node->set_final(1);
-  for( Alphabet::iterator it=alphabet.begin(); it!=alphabet.end(); it++)
-    accept_node->add_arc( *it, accept_node, na );
-
-  na->incr_vmark();
-  na->negate_nodes( na->root_node(), accept_node );
-  //na->prune();
-  na->minimised = na->deterministic = false;
-
-  return *na;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  conjoin_nodes                                                  */
-/*                                                                 */
-/*******************************************************************/
-
-static void conjoin_nodes( Node *n1, Node *n2, Node *node, 
-			   Transducer *a, PairMapping &map )
-  
-{
-  // if both input nodes are final, so is the new one
-  if (n1->is_final() && n2->is_final())
-    node->set_final(1);
-
-  // iterate over all outgoing arcs of the first node
-  for( ArcsIter i(n1->arcs()); i; i++ ) {
-    Arc *arc=i;
-    Label l=arc->label();
-    Node *t1 = arc->target_node();
-    Node *t2 = n2->target_node(l);
-
-    // Does the second node have an outgoing arc with the same label?
-    if (t2) {
-      // Check whether this node pair has been encountered before
-      PairMapping::iterator it=map.find(t1, t2);
-      
-      if (it == map.end()) {
-	// new node pair
-	// create a new node in the conjunction Transducer
-	Node *target_node = a->new_node();
-	// map the target node pair to the new node
-	map[pair<Node*,Node*>(t1,t2)] = target_node;
-	// add an arc to the new node
-	node->add_arc( l, target_node, a );
-	// recursion
-	conjoin_nodes( t1, t2, target_node, a, map );
-      }
-      else {
-	// add an arc to the already existing target node 
-	node->add_arc( l, it->second, a );
-      }
-    }
-  }
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::operator &                                         */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer &Transducer::operator&( Transducer &a )
-
-{
-  Transducer *tmp1=NULL;
-  Transducer *tmp2=NULL;
-  Node *r1, *r2;
-
-  if (deterministic)
-    r1 = root_node();
-  else {
-    tmp1 = &determinise();
-    r1 = tmp1->root_node();
-  }
-
-  if (a.deterministic)
-    r2 = a.root_node();
-  else {
-    tmp2 = &a.determinise();
-    r2 = tmp2->root_node();
-  }
-
-  PairMapping map;
-
-  Transducer *na = new Transducer();
-  na->alphabet.copy(alphabet);
-  na->alphabet.copy(a.alphabet);
-
-  // map the two root nodes to the new root node
-  map[pair<Node*,Node*>(r1, r2)] = na->root_node();
-
-  // recursively conjoin the two automata
-  conjoin_nodes( r1, r2, na->root_node(), na, map);
-
-  na->deterministic = 1;
-  delete tmp1;
-  delete tmp2;
-
-  return *na;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  add_composed_node                                              */
-/*                                                                 */
-/*******************************************************************/
-
-static void add_composed_node( Label l, Node *n1, Node *n2, Node *node, 
-			       Transducer *a, PairMapping &map )
-  
-{
-  // Check whether this node pair has been encountered before
-  PairMapping::iterator it=map.find(n1, n2);
-  
-  if (it != map.end()) {
-    // add an arc to the already existing target node 
-    node->add_arc( l, it->second, a );
-    return;
-  }
-
-  // create a new node in the composed Transducer
-  Node *target_node = a->new_node();
-  
-  // map the target node pair to the new node
-  map[pair<Node*,Node*>(n1,n2)] = target_node;
-  
-  // add an arc to the new node
-  node->add_arc( l, target_node, a );
-  
-  // recursion
-  compose_nodes( n1, n2, target_node, a, map );
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  compose_nodes                                                  */
-/*                                                                 */
-/*******************************************************************/
-
-static void compose_nodes( Node *n1, Node *n2, Node *node, 
-			   Transducer *a, PairMapping &map )
-{
-  // if both input nodes are final, so is the new one
-  if (n1->is_final() && n2->is_final())
-    node->set_final(1);
-
-  // iterate over all outgoing arcs of the first node
-  for( ArcsIter i(n1->arcs()); i; i++ ) {
-    Arc *arc1=i;
-    Node *t1 = arc1->target_node();
-    Label l1=arc1->label();
-    Character uc1=l1.upper_char();
-    Character lc1=l1.lower_char();
-
-    if (uc1 == Label::epsilon)
-      add_composed_node( l1, t1, n2, node, a, map );
-
-    else {
-      for( ArcsIter k(n2->arcs()); k; k++ ) {
-	Arc *arc2=k;
-	Node *t2 = arc2->target_node();
-	Label l2=arc2->label();
-	Character lc2=l2.lower_char();
-	Character uc2=l2.upper_char();
-	
-	if (uc1 == lc2)
-	  add_composed_node( Label(lc1,uc2), t1, t2, node, a, map );
-      }
-    }
-  }
-
-  // epsilon input characters of the second Transducer
-  for( ArcsIter i(n2->arcs()); i; i++ ) {
-    Arc *arc=i;
-    Node *t = arc->target_node();
-    Label l=arc->label();
-    Character lc=l.lower_char();
-	
-    if (lc == Label::epsilon)
-      add_composed_node( l, n1, t, node, a, map );
-  }
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::operator ||                                        */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer &Transducer::operator||( Transducer &a )
-
-{
-  PairMapping map;
-
-  Transducer *na = new Transducer();
-  na->alphabet.compose(alphabet, a.alphabet);
-
-  // map the two root nodes to the new root node
-  map[pair<Node*,Node*>(root_node(), a.root_node())] = na->root_node();
-
-  // recursively compose the two automata
-  compose_nodes( root_node(), a.root_node(), na->root_node(), na, map );
-
-  return *na;
-}
-
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::operator /                                         */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer &Transducer::operator/( Transducer &a )
-
-{
-  complete_alphabet();
-  a.alphabet.copy(alphabet);
-  Transducer *a1 = &(!a);
-  Transducer *a2 = &(*this & *a1);
-  delete a1;
-  return *a2;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::compare_nodes                                      */
-/*                                                                 */
-/*******************************************************************/
-
-bool Transducer::compare_nodes( Node *node, Node *node2, Transducer &a2 )
-
-{
-  if (node->was_visited( vmark )) {
-    if (node2->was_visited( a2.vmark ))
-      return (node->forward() == node2 && node2->forward() == node);
-    else
-      return false;
-  }
-  else if (node2->was_visited( a2.vmark ))
-    return false;
-
-  node->set_forward( node2 );
-  node2->set_forward( node );
-    
-  if (node->is_final() != node2->is_final())
-    return false;
-
-  // iterate over all outgoing arcs
-  for( ArcsIter p(node->arcs()); p; p++ ) {
-    Arc *arc=p;
-    Node *t2=node2->target_node(arc->label());
-
-    if (t2 == NULL)
-      return false;
-    else if (!compare_nodes(arc->target_node(), t2, a2))
-      return false;
-  }
-  for( ArcsIter p(node2->arcs()); p; p++ ) {
-    Arc *arc=p;
-    if (node->target_node(arc->label()) == NULL)
-      return false;
-  }
-
-  return true;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::operator ==                                        */
-/*                                                                 */
-/*******************************************************************/
-
-bool Transducer::operator==( Transducer &a )
-
-{
-  Transducer *p1 = (minimised)? this: &minimise();
-  Transducer *p2 = (a.minimised)? &a: &a.minimise();
-
-  p1->incr_vmark();
-  p2->incr_vmark();
-  bool result = p1->compare_nodes(p1->root_node(), p2->root_node(), *p2 );
-
-  if (p1 != this)  delete p1;
-  if (p2 != &a)    delete p2;
-
-  return result;
-}
-
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::map_nodes                                          */
-/*                                                                 */
-/*******************************************************************/
-
-void Transducer::map_nodes( Node *node, Node *node2, Transducer *a, Level level)
-
-{
-  if (!node->was_visited(vmark)) {
-
-    node->set_forward(node2);
-
-    // define final nodes
-    if (node->is_final())
-      node2->set_final(1);
-
-    // iterate over all outgoing arcs of node
-    for( ArcsIter p(node->arcs()); p; p++ ) {
-      Arc *arc=p;
-      Label l(arc->label().get_char(level));
-      Node *t2=NULL, *t=arc->target_node();
-
-      if (t->check_visited(vmark))
-	t2 = t->forward();
-      else
-	t2 = a->new_node(); // create a new node
-      
-      node2->add_arc(l, t2, a); // add a link to the node
-
-      map_nodes( t, t2, a, level );
-    }
-  }
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::level                                              */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer &Transducer::level( Level level )
-
-{
-  Transducer *na = new Transducer();
-
-  for( Alphabet::iterator it=alphabet.begin(); it!=alphabet.end(); it++ ) {
-    Character c = it->get_char(level);
-    if (alphabet.code2symbol(c) != NULL)
-      na->alphabet.add_symbol( alphabet.code2symbol(c), c );
-    na->alphabet.insert(Label(c));
-  }
-
-  incr_vmark();
-  map_nodes(root_node(), na->root_node(), na, level );
-
-  return *na;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::freely_insert_at_node                              */
-/*                                                                 */
-/*******************************************************************/
-
-void Transducer::freely_insert_at_node( Node *node, Label l )
-
-{
-  if (!node->was_visited(vmark)) {
-    node->add_arc(l, node, this); // add a recursive link labelled with l
-
-    // iterate over all outgoing arcs of node
-    for( ArcsIter p(node->arcs()); p; p++ ) {
-      Arc *arc=p;
-      freely_insert_at_node(arc->target_node(), l );
-    }
-  }
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::freely_insert                                      */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer &Transducer::freely_insert( Label l )
-
-{
-  Transducer *na = &copy();
-
-  na->incr_vmark();
-  na->freely_insert_at_node(na->root_node(), l );
-
-  return *na;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::splice_arc                                         */
-/*                                                                 */
-/*******************************************************************/
-
-void Transducer::splice_arc( Node *node, Node *node2, Node *next_node,
-			    Transducer *a )
-{
-  if (node->is_final()) {
-    // link final node to the next node
-    node2->add_arc( Label(), next_node, a );
-    return;
-  }
-
-  // iterate over the outgoing arcs
-  for( ArcsIter p(node->arcs()); p; p++ ) {
-    Arc *arc=p;
-    Node *tn=a->new_node();
-
-    node2->add_arc( arc->label(), tn, a );
-    splice_arc( arc->target_node(), tn, next_node, a );
-  }
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::splice_nodes                                       */
-/*                                                                 */
-/*******************************************************************/
-
-void Transducer::splice_nodes(Node *node, Node *node2, Label sl, 
-			     Transducer *sa, Transducer *a)
-{
-  if (!node->was_visited(vmark)) {
-
-    node->set_forward(node2);
-
-    // define final nodes
-    if (node->is_final())
-      node2->set_final(1);
-
-    // iterate over all outgoing arcs of node
-    for( ArcsIter p(node->arcs()); p; p++ ) {
-      Arc *arc=p;
-      Node *t2=NULL, *t=arc->target_node();
-
-      if (t->check_visited(vmark))
-	t2 = t->forward();
-      else
-	t2 = a->new_node(); // create a new node
-
-      if (arc->label() == sl)
-	// insert the transducer
-	splice_arc(sa->root_node(), node2, t2, a);
-      else
-	// add a link to the node
-	node2->add_arc(arc->label(), t2, a);
-
-      splice_nodes( t, t2, sl, sa, a );
-    }
-  }
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::splice                                             */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer &Transducer::splice( Label sl, Transducer *sa )
-
-{
-  Alphabet::iterator it;
-
-  Transducer *na = new Transducer();
-
-  for( it=alphabet.begin(); it!=alphabet.end(); it++ ) {
-    Label l = *it;
-    if (l != sl)
-      na->alphabet.insert(l);
-  }
-  for( it=sa->alphabet.begin(); it!=sa->alphabet.end(); it++ )
-    na->alphabet.insert(*it);
-
-  incr_vmark();
-  splice_nodes(root_node(), na->root_node(), sl, sa, na );
-
-  return *na;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::replace_char                                       */
-/*                                                                 */
-/*******************************************************************/
-
-Transducer &Transducer::replace_char( Character c, Character nc )
-
-{
-  Alphabet::iterator it;
-
-  Transducer *na = new Transducer();
-
-  for( it=alphabet.begin(); it!=alphabet.end(); it++ ) {
-    Label l = *it;
-    na->alphabet.insert(l.replace_char(c,nc));
-  }
-
-  incr_vmark();
-  replace_char2(root_node(), na->root_node(), c, nc, na );
-
-  return *na;
-}
-
-
-/*******************************************************************/
-/*                                                                 */
-/*  Transducer::replace_char2                                      */
-/*                                                                 */
-/*******************************************************************/
-
-void Transducer::replace_char2(Node *node, Node *node2, Character c, 
-			     Character nc, Transducer *a)
-{
-  if (!node->was_visited(vmark)) {
-
-    node->set_forward(node2);
-
-    // define final nodes
-    if (node->is_final())
-      node2->set_final(1);
-
-    // iterate over all outgoing arcs of node
-    for( ArcsIter p(node->arcs()); p; p++ ) {
-      Arc *arc=p;
-      Node *t2=NULL, *t=arc->target_node();
-
-      if (t->check_visited(vmark))
-	t2 = t->forward();
-      else
-	t2 = a->new_node(); // create a new node
-
-      node2->add_arc(arc->label().replace_char(c, nc), t2, a);
-      replace_char2( t, t2, c, nc, a );
-    }
-  }
-}