Vcsn  2.4
Be Rational
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
algos.cc
Go to the documentation of this file.
1 // Generated, do not edit by hand.
2 
4 #include <vcsn/dyn/algos.hh>
5 #include <vcsn/dyn/automaton.hh>
6 #include <vcsn/dyn/context.hh>
7 #include <vcsn/dyn/registries.hh>
8 #include <vcsn/dyn/value.hh>
9 
10 namespace vcsn { namespace dyn {
11 
12  // accessible (accessible.hh).
13  REGISTRY_DEFINE(accessible);
14  automaton
15  accessible(const automaton& aut)
16  {
17  return detail::accessible_registry().call(aut);
18  }
19 
20 
21  // add (add.hh).
22  REGISTRY_DEFINE(add);
23  automaton
24  add(const automaton& lhs, const automaton& rhs, const std::string& algo)
25  {
26  return detail::add_registry().call(lhs, rhs, algo);
27  }
28 
29 
30  // add_expansion (add.hh).
31  REGISTRY_DEFINE(add_expansion);
32  expansion
33  add(const expansion& lhs, const expansion& rhs)
34  {
35  return detail::add_expansion_registry().call(lhs, rhs);
36  }
37 
38 
39  // add_expression (add.hh).
40  REGISTRY_DEFINE(add_expression);
42  add(const expression& lhs, const expression& rhs)
43  {
44  return detail::add_expression_registry().call(lhs, rhs);
45  }
46 
47 
48  // add_polynomial (add.hh).
49  REGISTRY_DEFINE(add_polynomial);
51  add(const polynomial& lhs, const polynomial& rhs)
52  {
53  return detail::add_polynomial_registry().call(lhs, rhs);
54  }
55 
56 
57  // add_weight (add.hh).
58  REGISTRY_DEFINE(add_weight);
59  weight
60  add(const weight& lhs, const weight& rhs)
61  {
62  return detail::add_weight_registry().call(lhs, rhs);
63  }
64 
65 
66  // ambiguous_word (is-ambiguous.hh).
67  REGISTRY_DEFINE(ambiguous_word);
68  label
70  {
71  return detail::ambiguous_word_registry().call(aut);
72  }
73 
74 
75  // are_equivalent (are-equivalent.hh).
76  REGISTRY_DEFINE(are_equivalent);
77  bool
78  are_equivalent(const automaton& aut1, const automaton& aut2)
79  {
80  return detail::are_equivalent_registry().call(aut1, aut2);
81  }
82 
83 
84  // are_equivalent_expression (are-equivalent.hh).
85  REGISTRY_DEFINE(are_equivalent_expression);
86  bool
87  are_equivalent(const expression& r1, const expression& r2)
88  {
89  return detail::are_equivalent_expression_registry().call(r1, r2);
90  }
91 
92 
93  // are_isomorphic (are-isomorphic.hh).
94  REGISTRY_DEFINE(are_isomorphic);
95  bool
96  are_isomorphic(const automaton& aut1, const automaton& aut2)
97  {
98  return detail::are_isomorphic_registry().call(aut1, aut2);
99  }
100 
101 
102  // cerny (cerny.hh).
103  REGISTRY_DEFINE(cerny);
104  automaton
105  cerny(const context& ctx, unsigned num_states)
106  {
107  return detail::cerny_registry().call(ctx, num_states);
108  }
109 
110 
111  // coaccessible (accessible.hh).
112  REGISTRY_DEFINE(coaccessible);
113  automaton
115  {
116  return detail::coaccessible_registry().call(aut);
117  }
118 
119 
120  // codeterminize (determinize.hh).
121  REGISTRY_DEFINE(codeterminize);
122  automaton
123  codeterminize(const automaton& aut, const std::string& algo)
124  {
125  return detail::codeterminize_registry().call(aut, algo);
126  }
127 
128 
129  // cominimize (minimize.hh).
130  REGISTRY_DEFINE(cominimize);
131  automaton
132  cominimize(const automaton& aut, const std::string& algo)
133  {
134  return detail::cominimize_registry().call(aut, algo);
135  }
136 
137 
138  // complement (complement.hh).
139  REGISTRY_DEFINE(complement);
140  automaton
141  complement(const automaton& aut)
142  {
143  return detail::complement_registry().call(aut);
144  }
145 
146 
147  // complement_expansion (complement.hh).
148  REGISTRY_DEFINE(complement_expansion);
149  expansion
150  complement(const expansion& xpn)
151  {
152  return detail::complement_expansion_registry().call(xpn);
153  }
154 
155 
156  // complement_expression (complement.hh).
157  REGISTRY_DEFINE(complement_expression);
158  expression
159  complement(const expression& exp)
160  {
161  return detail::complement_expression_registry().call(exp);
162  }
163 
164 
165  // complete (complete.hh).
166  REGISTRY_DEFINE(complete);
167  automaton
168  complete(const automaton& aut)
169  {
170  return detail::complete_registry().call(aut);
171  }
172 
173 
174  // component (scc.hh).
175  REGISTRY_DEFINE(component);
176  automaton
177  component(const automaton& aut, unsigned num)
178  {
179  return detail::component_registry().call(aut, num);
180  }
181 
182 
183  // compose (compose.hh).
184  REGISTRY_DEFINE(compose);
185  automaton
186  compose(const automaton& lhs, const automaton& rhs, bool lazy)
187  {
188  return detail::compose_registry().call(lhs, rhs, lazy);
189  }
190 
191 
192  // compose_expansion (compose-expression.hh).
193  REGISTRY_DEFINE(compose_expansion);
194  expansion
195  compose(const expansion& lhs, const expansion& rhs)
196  {
197  return detail::compose_expansion_registry().call(lhs, rhs);
198  }
199 
200 
201  // compose_expression (compose-expression.hh).
202  REGISTRY_DEFINE(compose_expression);
203  expression
204  compose(const expression& lhs, const expression& rhs)
205  {
206  return detail::compose_expression_registry().call(lhs, rhs);
207  }
208 
209 
210  // compose_polynomial (compose-expression.hh).
211  REGISTRY_DEFINE(compose_polynomial);
212  polynomial
213  compose(const polynomial& lhs, const polynomial& rhs)
214  {
215  return detail::compose_polynomial_registry().call(lhs, rhs);
216  }
217 
218 
219  // concatenate_expression (multiply.hh).
220  REGISTRY_DEFINE(concatenate_expression);
221  expression
222  concatenate(const expression& lhs, const expression& rhs)
223  {
224  return detail::concatenate_expression_registry().call(lhs, rhs);
225  }
226 
227 
228  // condense (scc.hh).
229  REGISTRY_DEFINE(condense);
230  automaton
231  condense(const automaton& aut)
232  {
233  return detail::condense_registry().call(aut);
234  }
235 
236 
237  // conjugate (conjugate.hh).
238  REGISTRY_DEFINE(conjugate);
239  automaton
241  {
242  return detail::conjugate_registry().call(a);
243  }
244 
245 
246  // conjunction (conjunction.hh).
247  REGISTRY_DEFINE(conjunction);
248  automaton
249  conjunction(const std::vector<automaton>& as, bool lazy)
250  {
251  return detail::conjunction_registry().call(as, lazy);
252  }
253 
254 
255  // conjunction_expansion (conjunction.hh).
256  REGISTRY_DEFINE(conjunction_expansion);
257  expansion
258  conjunction(const expansion& lhs, const expansion& rhs)
259  {
260  return detail::conjunction_expansion_registry().call(lhs, rhs);
261  }
262 
263 
264  // conjunction_expression (conjunction.hh).
265  REGISTRY_DEFINE(conjunction_expression);
266  expression
267  conjunction(const expression& lhs, const expression& rhs)
268  {
269  return detail::conjunction_expression_registry().call(lhs, rhs);
270  }
271 
272 
273  // conjunction_polynomial (conjunction.hh).
274  REGISTRY_DEFINE(conjunction_polynomial);
275  polynomial
276  conjunction(const polynomial& lhs, const polynomial& rhs)
277  {
278  return detail::conjunction_polynomial_registry().call(lhs, rhs);
279  }
280 
281 
282  // conjunction_repeated (conjunction.hh).
283  REGISTRY_DEFINE(conjunction_repeated);
284  automaton
285  conjunction(const automaton& aut, unsigned n)
286  {
287  return detail::conjunction_repeated_registry().call(aut, n);
288  }
289 
290 
291  // constant_term (constant-term.hh).
292  REGISTRY_DEFINE(constant_term);
293  weight
295  {
296  return detail::constant_term_registry().call(exp);
297  }
298 
299 
300  // context_of (make-context.hh).
301  REGISTRY_DEFINE(context_of);
302  context
303  context_of(const automaton& aut)
304  {
305  return detail::context_of_registry().call(aut);
306  }
307 
308 
309  // context_of_expansion (make-context.hh).
310  REGISTRY_DEFINE(context_of_expansion);
311  context
312  context_of(const expansion& exp)
313  {
314  return detail::context_of_expansion_registry().call(exp);
315  }
316 
317 
318  // context_of_expression (make-context.hh).
319  REGISTRY_DEFINE(context_of_expression);
320  context
321  context_of(const expression& exp)
322  {
323  return detail::context_of_expression_registry().call(exp);
324  }
325 
326 
327  // context_of_polynomial (make-context.hh).
328  REGISTRY_DEFINE(context_of_polynomial);
329  context
330  context_of(const polynomial& poly)
331  {
332  return detail::context_of_polynomial_registry().call(poly);
333  }
334 
335 
336  // copy (copy.hh).
337  REGISTRY_DEFINE(copy);
338  automaton
339  copy(const automaton& aut)
340  {
341  return detail::copy_registry().call(aut);
342  }
343 
344 
345  // copy_convert (copy.hh).
346  REGISTRY_DEFINE(copy_convert);
347  automaton
348  copy(const automaton& aut, const context& ctx)
349  {
350  return detail::copy_convert_registry().call(aut, ctx);
351  }
352 
353 
354  // copy_expression (copy.hh).
355  REGISTRY_DEFINE(copy_expression);
356  expression
357  copy(const expression& exp, const context& ctx, identities ids)
358  {
359  return detail::copy_expression_registry().call(exp, ctx, ids);
360  }
361 
362 
363  // costandard (standard.hh).
364  REGISTRY_DEFINE(costandard);
365  automaton
366  costandard(const automaton& aut)
367  {
368  return detail::costandard_registry().call(aut);
369  }
370 
371 
372  // cotrie (trie.hh).
373  REGISTRY_DEFINE(cotrie);
374  automaton
375  cotrie(const polynomial& poly)
376  {
377  return detail::cotrie_registry().call(poly);
378  }
379 
380 
381  // cotrie_stream (trie.hh).
382  REGISTRY_DEFINE(cotrie_stream);
383  automaton
384  cotrie(const context& ctx, std::istream& is, const std::string& format)
385  {
386  return detail::cotrie_stream_registry().call(ctx, is, format);
387  }
388 
389 
390  // de_bruijn (de-bruijn.hh).
391  REGISTRY_DEFINE(de_bruijn);
392  automaton
393  de_bruijn(const dyn::context& ctx, unsigned n)
394  {
395  return detail::de_bruijn_registry().call(ctx, n);
396  }
397 
398 
399  // delay_automaton (is-synchronized.hh).
400  REGISTRY_DEFINE(delay_automaton);
401  automaton
403  {
404  return detail::delay_automaton_registry().call(aut);
405  }
406 
407 
408  // derivation (derivation.hh).
409  REGISTRY_DEFINE(derivation);
410  polynomial
411  derivation(const expression& exp, const label& lbl, bool breaking)
412  {
413  return detail::derivation_registry().call(exp, lbl, breaking);
414  }
415 
416 
417  // derived_term (derived-term.hh).
418  REGISTRY_DEFINE(derived_term);
419  automaton
420  derived_term(const expression& exp, const std::string& algo)
421  {
422  return detail::derived_term_registry().call(exp, algo);
423  }
424 
425 
426  // determinize (determinize.hh).
427  REGISTRY_DEFINE(determinize);
428  automaton
429  determinize(const automaton& aut, const std::string& algo)
430  {
431  return detail::determinize_registry().call(aut, algo);
432  }
433 
434 
435  // difference (are-equivalent.hh).
436  REGISTRY_DEFINE(difference);
437  automaton
438  difference(const automaton& lhs, const automaton& rhs)
439  {
440  return detail::difference_registry().call(lhs, rhs);
441  }
442 
443 
444  // difference_expression (are-equivalent.hh).
445  REGISTRY_DEFINE(difference_expression);
446  expression
447  difference(const expression& lhs, const expression& rhs)
448  {
449  return detail::difference_expression_registry().call(lhs, rhs);
450  }
451 
452 
453  // divkbaseb (divkbaseb.hh).
454  REGISTRY_DEFINE(divkbaseb);
455  automaton
456  divkbaseb(const context& ctx, unsigned divisor, unsigned base)
457  {
458  return detail::divkbaseb_registry().call(ctx, divisor, base);
459  }
460 
461 
462  // double_ring (double-ring.hh).
463  REGISTRY_DEFINE(double_ring);
464  automaton
465  double_ring(const context& ctx, unsigned n, const std::vector<unsigned>& finals)
466  {
467  return detail::double_ring_registry().call(ctx, n, finals);
468  }
469 
470 
471  // eliminate_state (to-expression.hh).
472  REGISTRY_DEFINE(eliminate_state);
473  automaton
474  eliminate_state(const automaton& aut, int state)
475  {
476  return detail::eliminate_state_registry().call(aut, state);
477  }
478 
479 
480  // eval_polynomial (evaluate.hh).
481  REGISTRY_DEFINE(eval_polynomial);
482  weight
483  evaluate(const automaton& aut, const polynomial& poly)
484  {
485  return detail::eval_polynomial_registry().call(aut, poly);
486  }
487 
488 
489  // evaluate (evaluate.hh).
490  REGISTRY_DEFINE(evaluate);
491  weight
492  evaluate(const automaton& aut, const label& lbl)
493  {
494  return detail::evaluate_registry().call(aut, lbl);
495  }
496 
497 
498  // expand (expand.hh).
499  REGISTRY_DEFINE(expand);
500  expression
501  expand(const expression& exp)
502  {
503  return detail::expand_registry().call(exp);
504  }
505 
506 
507  // expression_one (constant.hh).
508  REGISTRY_DEFINE(expression_one);
509  expression
510  expression_one(const context& ctx, identities ids)
511  {
512  return detail::expression_one_registry().call(ctx, ids);
513  }
514 
515 
516  // expression_zero (constant.hh).
517  REGISTRY_DEFINE(expression_zero);
518  expression
519  expression_zero(const context& ctx, identities ids)
520  {
521  return detail::expression_zero_registry().call(ctx, ids);
522  }
523 
524 
525  // factor (prefix.hh).
526  REGISTRY_DEFINE(factor);
527  automaton
528  factor(const automaton& aut)
529  {
530  return detail::factor_registry().call(aut);
531  }
532 
533 
534  // filter (filter.hh).
535  REGISTRY_DEFINE(filter);
536  automaton
537  filter(const automaton& aut, const std::vector<unsigned>& states)
538  {
539  return detail::filter_registry().call(aut, states);
540  }
541 
542 
543  // has_bounded_lag (has-bounded-lag.hh).
544  REGISTRY_DEFINE(has_bounded_lag);
545  bool
547  {
548  return detail::has_bounded_lag_registry().call(aut);
549  }
550 
551 
552  // has_lightening_cycle (has-lightening-cycle.hh).
553  REGISTRY_DEFINE(has_lightening_cycle);
554  bool
556  {
557  return detail::has_lightening_cycle_registry().call(aut);
558  }
559 
560 
561  // has_twins_property (has-twins-property.hh).
562  REGISTRY_DEFINE(has_twins_property);
563  bool
565  {
566  return detail::has_twins_property_registry().call(aut);
567  }
568 
569 
570  // identities_of (identities-of.hh).
571  REGISTRY_DEFINE(identities_of);
572  identities
574  {
575  return detail::identities_of_registry().call(exp);
576  }
577 
578 
579  // inductive (inductive.hh).
580  REGISTRY_DEFINE(inductive);
581  automaton
582  inductive(const expression& exp, const std::string& algo)
583  {
584  return detail::inductive_registry().call(exp, algo);
585  }
586 
587 
588  // infiltrate (conjunction.hh).
589  REGISTRY_DEFINE(infiltrate);
590  automaton
591  infiltrate(const std::vector<automaton>& as)
592  {
593  return detail::infiltrate_registry().call(as);
594  }
595 
596 
597  // infiltrate_expression (conjunction.hh).
598  REGISTRY_DEFINE(infiltrate_expression);
599  expression
600  infiltrate(const expression& lhs, const expression& rhs)
601  {
602  return detail::infiltrate_expression_registry().call(lhs, rhs);
603  }
604 
605 
606  // info (info.hh).
607  REGISTRY_DEFINE(info);
608  std::ostream&
609  info(const automaton& aut, std::ostream& out, unsigned details)
610  {
611  return detail::info_registry().call(aut, out, details);
612  }
613 
614 
615  // info_expression (info.hh).
616  REGISTRY_DEFINE(info_expression);
617  std::ostream&
618  info(const expression& exp, std::ostream& o)
619  {
620  return detail::info_expression_registry().call(exp, o);
621  }
622 
623 
624  // insplit (insplit.hh).
625  REGISTRY_DEFINE(insplit);
626  automaton
627  insplit(const automaton& aut, bool lazy)
628  {
629  return detail::insplit_registry().call(aut, lazy);
630  }
631 
632 
633  // is_accessible (accessible.hh).
634  REGISTRY_DEFINE(is_accessible);
635  bool
637  {
638  return detail::is_accessible_registry().call(aut);
639  }
640 
641 
642  // is_ambiguous (is-ambiguous.hh).
643  REGISTRY_DEFINE(is_ambiguous);
644  bool
646  {
647  return detail::is_ambiguous_registry().call(aut);
648  }
649 
650 
651  // is_coaccessible (accessible.hh).
652  REGISTRY_DEFINE(is_coaccessible);
653  bool
655  {
656  return detail::is_coaccessible_registry().call(aut);
657  }
658 
659 
660  // is_codeterministic (is-deterministic.hh).
661  REGISTRY_DEFINE(is_codeterministic);
662  bool
664  {
665  return detail::is_codeterministic_registry().call(aut);
666  }
667 
668 
669  // is_complete (is-complete.hh).
670  REGISTRY_DEFINE(is_complete);
671  bool
672  is_complete(const automaton& aut)
673  {
674  return detail::is_complete_registry().call(aut);
675  }
676 
677 
678  // is_costandard (standard.hh).
679  REGISTRY_DEFINE(is_costandard);
680  bool
682  {
683  return detail::is_costandard_registry().call(aut);
684  }
685 
686 
687  // is_cycle_ambiguous (is-ambiguous.hh).
688  REGISTRY_DEFINE(is_cycle_ambiguous);
689  bool
691  {
692  return detail::is_cycle_ambiguous_registry().call(aut);
693  }
694 
695 
696  // is_deterministic (is-deterministic.hh).
697  REGISTRY_DEFINE(is_deterministic);
698  bool
700  {
701  return detail::is_deterministic_registry().call(aut);
702  }
703 
704 
705  // is_empty (accessible.hh).
706  REGISTRY_DEFINE(is_empty);
707  bool
708  is_empty(const automaton& aut)
709  {
710  return detail::is_empty_registry().call(aut);
711  }
712 
713 
714  // is_eps_acyclic (is-acyclic.hh).
715  REGISTRY_DEFINE(is_eps_acyclic);
716  bool
718  {
719  return detail::is_eps_acyclic_registry().call(aut);
720  }
721 
722 
723  // is_functional (is-functional.hh).
724  REGISTRY_DEFINE(is_functional);
725  bool
727  {
728  return detail::is_functional_registry().call(aut);
729  }
730 
731 
732  // is_letterized (letterize.hh).
733  REGISTRY_DEFINE(is_letterized);
734  bool
736  {
737  return detail::is_letterized_registry().call(aut);
738  }
739 
740 
741  // is_normalized (normalize.hh).
742  REGISTRY_DEFINE(is_normalized);
743  bool
745  {
746  return detail::is_normalized_registry().call(aut);
747  }
748 
749 
750  // is_out_sorted (sort.hh).
751  REGISTRY_DEFINE(is_out_sorted);
752  bool
754  {
755  return detail::is_out_sorted_registry().call(aut);
756  }
757 
758 
759  // is_partial_identity (is-partial-identity.hh).
760  REGISTRY_DEFINE(is_partial_identity);
761  bool
763  {
764  return detail::is_partial_identity_registry().call(aut);
765  }
766 
767 
768  // is_proper (is-proper.hh).
769  REGISTRY_DEFINE(is_proper);
770  bool
771  is_proper(const automaton& aut)
772  {
773  return detail::is_proper_registry().call(aut);
774  }
775 
776 
777  // is_realtime (letterize.hh).
778  REGISTRY_DEFINE(is_realtime);
779  bool
780  is_realtime(const automaton& aut)
781  {
782  return detail::is_realtime_registry().call(aut);
783  }
784 
785 
786  // is_standard (standard.hh).
787  REGISTRY_DEFINE(is_standard);
788  bool
789  is_standard(const automaton& aut)
790  {
791  return detail::is_standard_registry().call(aut);
792  }
793 
794 
795  // is_synchronized (is-synchronized.hh).
796  REGISTRY_DEFINE(is_synchronized);
797  bool
799  {
800  return detail::is_synchronized_registry().call(aut);
801  }
802 
803 
804  // is_synchronized_by (synchronizing-word.hh).
805  REGISTRY_DEFINE(is_synchronized_by);
806  bool
808  {
809  return detail::is_synchronized_by_registry().call(aut, word);
810  }
811 
812 
813  // is_synchronizing (synchronizing-word.hh).
814  REGISTRY_DEFINE(is_synchronizing);
815  bool
817  {
818  return detail::is_synchronizing_registry().call(aut);
819  }
820 
821 
822  // is_trim (accessible.hh).
823  REGISTRY_DEFINE(is_trim);
824  bool
825  is_trim(const automaton& aut)
826  {
827  return detail::is_trim_registry().call(aut);
828  }
829 
830 
831  // is_useless (accessible.hh).
832  REGISTRY_DEFINE(is_useless);
833  bool
834  is_useless(const automaton& aut)
835  {
836  return detail::is_useless_registry().call(aut);
837  }
838 
839 
840  // is_valid (is-valid.hh).
841  REGISTRY_DEFINE(is_valid);
842  bool
843  is_valid(const automaton& aut)
844  {
845  return detail::is_valid_registry().call(aut);
846  }
847 
848 
849  // is_valid_expression (is-valid-expression.hh).
850  REGISTRY_DEFINE(is_valid_expression);
851  bool
852  is_valid(const expression& exp)
853  {
854  return detail::is_valid_expression_registry().call(exp);
855  }
856 
857 
858  // join (make-context.hh).
859  REGISTRY_DEFINE(join);
860  context
861  join(const context& c1, const context& c2)
862  {
863  return detail::join_registry().call(c1, c2);
864  }
865 
866 
867  // ladybird (ladybird.hh).
868  REGISTRY_DEFINE(ladybird);
869  automaton
870  ladybird(const dyn::context& ctx, unsigned n)
871  {
872  return detail::ladybird_registry().call(ctx, n);
873  }
874 
875 
876  // ldivide (conjunction.hh).
877  REGISTRY_DEFINE(ldivide);
878  automaton
879  ldivide(const automaton& aut1, const automaton& aut2)
880  {
881  return detail::ldivide_registry().call(aut1, aut2);
882  }
883 
884 
885  // ldivide_expansion (divide.hh).
886  REGISTRY_DEFINE(ldivide_expansion);
887  expansion
888  ldivide(const expansion& lhs, const expansion& rhs)
889  {
890  return detail::ldivide_expansion_registry().call(lhs, rhs);
891  }
892 
893 
894  // ldivide_expression (divide.hh).
895  REGISTRY_DEFINE(ldivide_expression);
896  expression
897  ldivide(const expression& lhs, const expression& rhs)
898  {
899  return detail::ldivide_expression_registry().call(lhs, rhs);
900  }
901 
902 
903  // ldivide_label (divide.hh).
904  REGISTRY_DEFINE(ldivide_label);
905  label
906  ldivide(const label& lhs, const label& rhs)
907  {
908  return detail::ldivide_label_registry().call(lhs, rhs);
909  }
910 
911 
912  // ldivide_polynomial (divide.hh).
913  REGISTRY_DEFINE(ldivide_polynomial);
914  polynomial
915  ldivide(const polynomial& lhs, const polynomial& rhs)
916  {
917  return detail::ldivide_polynomial_registry().call(lhs, rhs);
918  }
919 
920 
921  // ldivide_weight (divide.hh).
922  REGISTRY_DEFINE(ldivide_weight);
923  weight
924  ldivide(const weight& lhs, const weight& rhs)
925  {
926  return detail::ldivide_weight_registry().call(lhs, rhs);
927  }
928 
929 
930  // less_than_expression (less-than.hh).
931  REGISTRY_DEFINE(less_than_expression);
932  bool
933  less_than(const expression& lhs, const expression& rhs)
934  {
935  return detail::less_than_expression_registry().call(lhs, rhs);
936  }
937 
938 
939  // letterize (letterize.hh).
940  REGISTRY_DEFINE(letterize);
941  automaton
942  letterize(const automaton& aut)
943  {
944  return detail::letterize_registry().call(aut);
945  }
946 
947 
948  // levenshtein (levenshtein.hh).
949  REGISTRY_DEFINE(levenshtein);
950  automaton
952  {
953  return detail::levenshtein_registry().call(ctx);
954  }
955 
956 
957  // lgcd_polynomial (divide.hh).
958  REGISTRY_DEFINE(lgcd_polynomial);
959  polynomial
960  lgcd(const polynomial& lhs, const polynomial& rhs)
961  {
962  return detail::lgcd_polynomial_registry().call(lhs, rhs);
963  }
964 
965 
966  // lift_expression (lift.hh).
967  REGISTRY_DEFINE(lift_expression);
968  expression
969  lift(const expression& exp)
970  {
971  return detail::lift_expression_registry().call(exp);
972  }
973 
974 
975  // lightest (lightest.hh).
976  REGISTRY_DEFINE(lightest);
977  polynomial
978  lightest(const automaton& aut, unsigned num, const std::string& algo)
979  {
980  return detail::lightest_registry().call(aut, num, algo);
981  }
982 
983 
984  // lightest_automaton (lightest-automaton.hh).
985  REGISTRY_DEFINE(lightest_automaton);
986  automaton
987  lightest_automaton(const automaton& aut, unsigned k, const std::string& algo)
988  {
989  return detail::lightest_automaton_registry().call(aut, k, algo);
990  }
991 
992 
993  // lweight (weight.hh).
994  REGISTRY_DEFINE(lweight);
995  automaton
996  lweight(const weight& weight, const automaton& aut, const std::string& algo)
997  {
998  return detail::lweight_registry().call(weight, aut, algo);
999  }
1000 
1001 
1002  // lweight_expansion (weight.hh).
1003  REGISTRY_DEFINE(lweight_expansion);
1004  expansion
1005  lweight(const weight& weight, const expansion& exp)
1006  {
1007  return detail::lweight_expansion_registry().call(weight, exp);
1008  }
1009 
1010 
1011  // lweight_expression (weight.hh).
1012  REGISTRY_DEFINE(lweight_expression);
1013  expression
1014  lweight(const weight& weight, const expression& exp)
1015  {
1016  return detail::lweight_expression_registry().call(weight, exp);
1017  }
1018 
1019 
1020  // lweight_polynomial (weight.hh).
1021  REGISTRY_DEFINE(lweight_polynomial);
1022  polynomial
1023  lweight(const weight& weight, const polynomial& poly)
1024  {
1025  return detail::lweight_polynomial_registry().call(weight, poly);
1026  }
1027 
1028 
1029  // make_automaton_editor (edit-automaton.hh).
1030  REGISTRY_DEFINE(make_automaton_editor);
1033  {
1034  return detail::make_automaton_editor_registry().call(ctx);
1035  }
1036 
1037 
1038  // make_word_context (make-context.hh).
1039  REGISTRY_DEFINE(make_word_context);
1040  context
1042  {
1043  return detail::make_word_context_registry().call(ctx);
1044  }
1045 
1046 
1047  // minimize (minimize.hh).
1048  REGISTRY_DEFINE(minimize);
1049  automaton
1050  minimize(const automaton& aut, const std::string& algo)
1051  {
1052  return detail::minimize_registry().call(aut, algo);
1053  }
1054 
1055 
1056  // multiply (multiply.hh).
1057  REGISTRY_DEFINE(multiply);
1058  automaton
1059  multiply(const automaton& lhs, const automaton& rhs, const std::string& algo)
1060  {
1061  return detail::multiply_registry().call(lhs, rhs, algo);
1062  }
1063 
1064 
1065  // multiply_expression (multiply.hh).
1066  REGISTRY_DEFINE(multiply_expression);
1067  expression
1068  multiply(const expression& lhs, const expression& rhs)
1069  {
1070  return detail::multiply_expression_registry().call(lhs, rhs);
1071  }
1072 
1073 
1074  // multiply_expression_repeated (multiply.hh).
1076  expression
1077  multiply(const expression& re, int min, int max)
1078  {
1079  return detail::multiply_expression_repeated_registry().call(re, min, max);
1080  }
1081 
1082 
1083  // multiply_label (multiply.hh).
1084  REGISTRY_DEFINE(multiply_label);
1085  label
1086  multiply(const label& lhs, const label& rhs)
1087  {
1088  return detail::multiply_label_registry().call(lhs, rhs);
1089  }
1090 
1091 
1092  // multiply_label_repeated (multiply.hh).
1093  REGISTRY_DEFINE(multiply_label_repeated);
1094  label
1095  multiply(const label& re, int exp)
1096  {
1097  return detail::multiply_label_repeated_registry().call(re, exp);
1098  }
1099 
1100 
1101  // multiply_polynomial (multiply.hh).
1102  REGISTRY_DEFINE(multiply_polynomial);
1103  polynomial
1104  multiply(const polynomial& lhs, const polynomial& rhs)
1105  {
1106  return detail::multiply_polynomial_registry().call(lhs, rhs);
1107  }
1108 
1109 
1110  // multiply_repeated (multiply.hh).
1111  REGISTRY_DEFINE(multiply_repeated);
1112  automaton
1113  multiply(const automaton& a, int min, int max, const std::string& algo)
1114  {
1115  return detail::multiply_repeated_registry().call(a, min, max, algo);
1116  }
1117 
1118 
1119  // multiply_weight (multiply.hh).
1120  REGISTRY_DEFINE(multiply_weight);
1121  weight
1122  multiply(const weight& lhs, const weight& rhs)
1123  {
1124  return detail::multiply_weight_registry().call(lhs, rhs);
1125  }
1126 
1127 
1128  // multiply_weight_repeated (multiply.hh).
1129  REGISTRY_DEFINE(multiply_weight_repeated);
1130  weight
1131  multiply(const weight& wgt, int min, int max)
1132  {
1133  return detail::multiply_weight_repeated_registry().call(wgt, min, max);
1134  }
1135 
1136 
1137  // normalize (normalize.hh).
1138  REGISTRY_DEFINE(normalize);
1139  automaton
1140  normalize(const automaton& aut)
1141  {
1142  return detail::normalize_registry().call(aut);
1143  }
1144 
1145 
1146  // num_components (scc.hh).
1147  REGISTRY_DEFINE(num_components);
1148  std::size_t
1150  {
1151  return detail::num_components_registry().call(aut);
1152  }
1153 
1154 
1155  // num_tapes (make-context.hh).
1156  REGISTRY_DEFINE(num_tapes);
1157  size_t
1159  {
1160  return detail::num_tapes_registry().call(ctx);
1161  }
1162 
1163 
1164  // pair (pair.hh).
1165  REGISTRY_DEFINE(pair);
1166  automaton
1167  pair(const automaton& aut, bool keep_initials)
1168  {
1169  return detail::pair_registry().call(aut, keep_initials);
1170  }
1171 
1172 
1173  // partial_identity (partial-identity.hh).
1174  REGISTRY_DEFINE(partial_identity);
1175  automaton
1177  {
1178  return detail::partial_identity_registry().call(aut);
1179  }
1180 
1181 
1182  // partial_identity_expression (partial-identity-expression.hh).
1184  expression
1186  {
1188  }
1189 
1190 
1191  // prefix (prefix.hh).
1192  REGISTRY_DEFINE(prefix);
1193  automaton
1194  prefix(const automaton& aut)
1195  {
1196  return detail::prefix_registry().call(aut);
1197  }
1198 
1199 
1200  // print (print.hh).
1201  REGISTRY_DEFINE(print);
1202  std::ostream&
1203  print(const automaton& aut, std::ostream& o, const std::string& fmt)
1204  {
1205  return detail::print_registry().call(aut, o, fmt);
1206  }
1207 
1208 
1209  // print_context (print.hh).
1210  REGISTRY_DEFINE(print_context);
1211  std::ostream&
1212  print(const context& ctx, std::ostream& o, const std::string& fmt)
1213  {
1214  return detail::print_context_registry().call(ctx, o, fmt);
1215  }
1216 
1217 
1218  // proper (proper.hh).
1219  REGISTRY_DEFINE(proper);
1220  automaton
1221  proper(const automaton& aut, direction dir, bool prune, const std::string& algo)
1222  {
1223  return detail::proper_registry().call(aut, dir, prune, algo);
1224  }
1225 
1226 
1227  // push_weights (push-weights.hh).
1228  REGISTRY_DEFINE(push_weights);
1229  automaton
1231  {
1232  return detail::push_weights_registry().call(aut);
1233  }
1234 
1235 
1236  // quotkbaseb (quotkbaseb.hh).
1237  REGISTRY_DEFINE(quotkbaseb);
1238  automaton
1239  quotkbaseb(const context& ctx, unsigned divisor, unsigned base)
1240  {
1241  return detail::quotkbaseb_registry().call(ctx, divisor, base);
1242  }
1243 
1244 
1245  // random_automaton (random-automaton.hh).
1246  REGISTRY_DEFINE(random_automaton);
1247  automaton
1248  random_automaton(const context& ctx, unsigned num_states, float density, unsigned num_initial, unsigned num_final, boost::optional<unsigned> max_labels, float loop_chance, const std::string& weights)
1249  {
1250  return detail::random_automaton_registry().call(ctx, num_states, density, num_initial, num_final, max_labels, loop_chance, weights);
1251  }
1252 
1253 
1254  // random_automaton_deterministic (random-automaton.hh).
1256  automaton
1257  random_automaton_deterministic(const context& ctx, unsigned num_states)
1258  {
1259  return detail::random_automaton_deterministic_registry().call(ctx, num_states);
1260  }
1261 
1262 
1263  // random_expression (random-expression.hh).
1264  REGISTRY_DEFINE(random_expression);
1265  expression
1266  random_expression(const context& ctx, const std::string& param, identities ids)
1267  {
1268  return detail::random_expression_registry().call(ctx, param, ids);
1269  }
1270 
1271 
1272  // random_weight (random-weight.hh).
1273  REGISTRY_DEFINE(random_weight);
1274  weight
1275  random_weight(const context& ctx, const std::string& param)
1276  {
1277  return detail::random_weight_registry().call(ctx, param);
1278  }
1279 
1280 
1281  // rdivide (conjunction.hh).
1282  REGISTRY_DEFINE(rdivide);
1283  automaton
1284  rdivide(const automaton& aut1, const automaton& aut2)
1285  {
1286  return detail::rdivide_registry().call(aut1, aut2);
1287  }
1288 
1289 
1290  // rdivide_expression (divide.hh).
1291  REGISTRY_DEFINE(rdivide_expression);
1292  expression
1293  rdivide(const expression& lhs, const expression& rhs)
1294  {
1295  return detail::rdivide_expression_registry().call(lhs, rhs);
1296  }
1297 
1298 
1299  // rdivide_label (divide.hh).
1300  REGISTRY_DEFINE(rdivide_label);
1301  label
1302  rdivide(const label& lhs, const label& rhs)
1303  {
1304  return detail::rdivide_label_registry().call(lhs, rhs);
1305  }
1306 
1307 
1308  // rdivide_weight (divide.hh).
1309  REGISTRY_DEFINE(rdivide_weight);
1310  weight
1311  rdivide(const weight& lhs, const weight& rhs)
1312  {
1313  return detail::rdivide_weight_registry().call(lhs, rhs);
1314  }
1315 
1316 
1317  // read_polynomial (read.hh).
1318  REGISTRY_DEFINE(read_polynomial);
1319  polynomial
1320  read_polynomial(const context& ctx, std::istream& is)
1321  {
1322  return detail::read_polynomial_registry().call(ctx, is);
1323  }
1324 
1325 
1326  // read_weight (read.hh).
1327  REGISTRY_DEFINE(read_weight);
1328  weight
1329  read_weight(const context& ctx, std::istream& is)
1330  {
1331  return detail::read_weight_registry().call(ctx, is);
1332  }
1333 
1334 
1335  // realtime (letterize.hh).
1336  REGISTRY_DEFINE(realtime);
1337  automaton
1338  realtime(const automaton& aut)
1339  {
1340  return detail::realtime_registry().call(aut);
1341  }
1342 
1343 
1344  // reduce (reduce.hh).
1345  REGISTRY_DEFINE(reduce);
1346  automaton
1347  reduce(const automaton& aut)
1348  {
1349  return detail::reduce_registry().call(aut);
1350  }
1351 
1352 
1353  // rweight (weight.hh).
1354  REGISTRY_DEFINE(rweight);
1355  automaton
1356  rweight(const automaton& aut, const weight& weight, const std::string& algo)
1357  {
1358  return detail::rweight_registry().call(aut, weight, algo);
1359  }
1360 
1361 
1362  // rweight_expansion (weight.hh).
1363  REGISTRY_DEFINE(rweight_expansion);
1364  expansion
1365  rweight(const expansion& exp, const weight& weight)
1366  {
1367  return detail::rweight_expansion_registry().call(exp, weight);
1368  }
1369 
1370 
1371  // rweight_expression (weight.hh).
1372  REGISTRY_DEFINE(rweight_expression);
1373  expression
1374  rweight(const expression& exp, const weight& weight)
1375  {
1376  return detail::rweight_expression_registry().call(exp, weight);
1377  }
1378 
1379 
1380  // rweight_polynomial (weight.hh).
1381  REGISTRY_DEFINE(rweight_polynomial);
1382  polynomial
1383  rweight(const polynomial& poly, const weight& weight)
1384  {
1385  return detail::rweight_polynomial_registry().call(poly, weight);
1386  }
1387 
1388 
1389  // scc (scc.hh).
1390  REGISTRY_DEFINE(scc);
1391  automaton
1392  scc(const automaton& aut, const std::string& algo)
1393  {
1394  return detail::scc_registry().call(aut, algo);
1395  }
1396 
1397 
1398  // shortest (shortest.hh).
1399  REGISTRY_DEFINE(shortest);
1400  polynomial
1401  shortest(const automaton& aut, boost::optional<unsigned> num, boost::optional<unsigned> len)
1402  {
1403  return detail::shortest_registry().call(aut, num, len);
1404  }
1405 
1406 
1407  // shuffle (conjunction.hh).
1408  REGISTRY_DEFINE(shuffle);
1409  automaton
1410  shuffle(const std::vector<automaton>& as)
1411  {
1412  return detail::shuffle_registry().call(as);
1413  }
1414 
1415 
1416  // shuffle_expression (conjunction.hh).
1417  REGISTRY_DEFINE(shuffle_expression);
1418  expression
1419  shuffle(const expression& lhs, const expression& rhs)
1420  {
1421  return detail::shuffle_expression_registry().call(lhs, rhs);
1422  }
1423 
1424 
1425  // sort (sort.hh).
1426  REGISTRY_DEFINE(sort);
1427  automaton
1428  sort(const automaton& aut)
1429  {
1430  return detail::sort_registry().call(aut);
1431  }
1432 
1433 
1434  // split (split.hh).
1435  REGISTRY_DEFINE(split);
1436  polynomial
1437  split(const expression& exp)
1438  {
1439  return detail::split_registry().call(exp);
1440  }
1441 
1442 
1443  // split_polynomial (split.hh).
1444  REGISTRY_DEFINE(split_polynomial);
1445  polynomial
1446  split(const polynomial& poly)
1447  {
1448  return detail::split_polynomial_registry().call(poly);
1449  }
1450 
1451 
1452  // standard (standard.hh).
1453  REGISTRY_DEFINE(standard);
1454  automaton
1455  standard(const automaton& aut)
1456  {
1457  return detail::standard_registry().call(aut);
1458  }
1459 
1460 
1461  // standard_expression (standard.hh).
1462  REGISTRY_DEFINE(standard_expression);
1463  automaton
1464  standard(const expression& exp)
1465  {
1466  return detail::standard_expression_registry().call(exp);
1467  }
1468 
1469 
1470  // star (star.hh).
1471  REGISTRY_DEFINE(star);
1472  automaton
1473  star(const automaton& a, const std::string& algo)
1474  {
1475  return detail::star_registry().call(a, algo);
1476  }
1477 
1478 
1479  // star_height (star-height.hh).
1480  REGISTRY_DEFINE(star_height);
1481  unsigned
1483  {
1484  return detail::star_height_registry().call(exp);
1485  }
1486 
1487 
1488  // star_normal_form (star-normal-form.hh).
1489  REGISTRY_DEFINE(star_normal_form);
1490  expression
1492  {
1493  return detail::star_normal_form_registry().call(exp);
1494  }
1495 
1496 
1497  // strip (strip.hh).
1498  REGISTRY_DEFINE(strip);
1499  automaton
1500  strip(const automaton& aut)
1501  {
1502  return detail::strip_registry().call(aut);
1503  }
1504 
1505 
1506  // subword (prefix.hh).
1507  REGISTRY_DEFINE(subword);
1508  automaton
1509  subword(const automaton& aut)
1510  {
1511  return detail::subword_registry().call(aut);
1512  }
1513 
1514 
1515  // suffix (prefix.hh).
1516  REGISTRY_DEFINE(suffix);
1517  automaton
1518  suffix(const automaton& aut)
1519  {
1520  return detail::suffix_registry().call(aut);
1521  }
1522 
1523 
1524  // synchronize (synchronize.hh).
1525  REGISTRY_DEFINE(synchronize);
1526  automaton
1528  {
1529  return detail::synchronize_registry().call(aut);
1530  }
1531 
1532 
1533  // synchronizing_word (synchronizing-word.hh).
1534  REGISTRY_DEFINE(synchronizing_word);
1535  label
1536  synchronizing_word(const automaton& aut, const std::string& algo)
1537  {
1538  return detail::synchronizing_word_registry().call(aut, algo);
1539  }
1540 
1541 
1542  // thompson (thompson.hh).
1543  REGISTRY_DEFINE(thompson);
1544  automaton
1545  thompson(const expression& exp)
1546  {
1547  return detail::thompson_registry().call(exp);
1548  }
1549 
1550 
1551  // to_expansion (to-expansion.hh).
1552  REGISTRY_DEFINE(to_expansion);
1553  expansion
1555  {
1556  return detail::to_expansion_registry().call(exp);
1557  }
1558 
1559 
1560  // to_expression (to-expression.hh).
1561  REGISTRY_DEFINE(to_expression);
1562  expression
1563  to_expression(const automaton& aut, identities ids, const std::string& algo)
1564  {
1565  return detail::to_expression_registry().call(aut, ids, algo);
1566  }
1567 
1568 
1569  // to_expression_class (to-expression.hh).
1570  REGISTRY_DEFINE(to_expression_class);
1571  expression
1572  to_expression(const context& ctx, identities ids, const letter_class_t& letters, bool accept)
1573  {
1574  return detail::to_expression_class_registry().call(ctx, ids, letters, accept);
1575  }
1576 
1577 
1578  // to_expression_label (to-expression.hh).
1579  REGISTRY_DEFINE(to_expression_label);
1580  expression
1581  to_expression(const context& ctx, identities ids, const label& lbl)
1582  {
1583  return detail::to_expression_label_registry().call(ctx, ids, lbl);
1584  }
1585 
1586 
1587  // transpose (transpose.hh).
1588  REGISTRY_DEFINE(transpose);
1589  automaton
1591  {
1592  return detail::transpose_registry().call(aut);
1593  }
1594 
1595 
1596  // transpose_expression (transpose.hh).
1597  REGISTRY_DEFINE(transpose_expression);
1598  expression
1599  transpose(const expression& exp)
1600  {
1601  return detail::transpose_expression_registry().call(exp);
1602  }
1603 
1604 
1605  // transposition_expression (transpose.hh).
1606  REGISTRY_DEFINE(transposition_expression);
1607  expression
1609  {
1610  return detail::transposition_expression_registry().call(exp);
1611  }
1612 
1613 
1614  // trie (trie.hh).
1615  REGISTRY_DEFINE(trie);
1616  automaton
1617  trie(const polynomial& poly)
1618  {
1619  return detail::trie_registry().call(poly);
1620  }
1621 
1622 
1623  // trie_stream (trie.hh).
1624  REGISTRY_DEFINE(trie_stream);
1625  automaton
1626  trie(const context& ctx, std::istream& is, const std::string& format)
1627  {
1628  return detail::trie_stream_registry().call(ctx, is, format);
1629  }
1630 
1631 
1632  // trim (accessible.hh).
1633  REGISTRY_DEFINE(trim);
1634  automaton
1635  trim(const automaton& aut)
1636  {
1637  return detail::trim_registry().call(aut);
1638  }
1639 
1640 
1641  // tuple (tuple-automaton.hh).
1642  REGISTRY_DEFINE(tuple);
1643  automaton
1644  tuple(const std::vector<automaton>& as)
1645  {
1646  return detail::tuple_registry().call(as);
1647  }
1648 
1649 
1650  // tuple_context (tuple.hh).
1651  REGISTRY_DEFINE(tuple_context);
1652  context
1653  tuple(const std::vector<context>& cs)
1654  {
1655  return detail::tuple_context_registry().call(cs);
1656  }
1657 
1658 
1659  // tuple_expansion (tuple.hh).
1660  REGISTRY_DEFINE(tuple_expansion);
1661  expansion
1662  tuple(const std::vector<expansion>& es)
1663  {
1664  return detail::tuple_expansion_registry().call(es);
1665  }
1666 
1667 
1668  // tuple_expression (tuple.hh).
1669  REGISTRY_DEFINE(tuple_expression);
1670  expression
1671  tuple(const std::vector<expression>& es)
1672  {
1673  return detail::tuple_expression_registry().call(es);
1674  }
1675 
1676 
1677  // tuple_polynomial (tuple.hh).
1678  REGISTRY_DEFINE(tuple_polynomial);
1679  polynomial
1680  tuple(const std::vector<polynomial>& ps)
1681  {
1682  return detail::tuple_polynomial_registry().call(ps);
1683  }
1684 
1685 
1686  // u (u.hh).
1687  REGISTRY_DEFINE(u);
1688  automaton
1689  u(const context& ctx, unsigned n)
1690  {
1691  return detail::u_registry().call(ctx, n);
1692  }
1693 
1694 
1695  // universal (universal.hh).
1696  REGISTRY_DEFINE(universal);
1697  automaton
1698  universal(const automaton& aut)
1699  {
1700  return detail::universal_registry().call(aut);
1701  }
1702 
1703 
1704  // weight_one (constant.hh).
1705  REGISTRY_DEFINE(weight_one);
1706  weight
1708  {
1709  return detail::weight_one_registry().call(ctx);
1710  }
1711 
1712 
1713  // weight_series (weight-series.hh).
1714  REGISTRY_DEFINE(weight_series);
1715  weight
1717  {
1718  return detail::weight_series_registry().call(aut);
1719  }
1720 
1721 
1722  // weight_zero (constant.hh).
1723  REGISTRY_DEFINE(weight_zero);
1724  weight
1726  {
1727  return detail::weight_zero_registry().call(ctx);
1728  }
1729 
1730 
1731  // zpc (zpc.hh).
1732  REGISTRY_DEFINE(zpc);
1733  automaton
1734  zpc(const expression& exp, const std::string& algo)
1735  {
1736  return detail::zpc_registry().call(exp, algo);
1737  }
1738 
1739 
1740 }}
weight evaluate(const automaton &aut, const word &l)
Evaluate l on aut.
Definition: algos.cc:483
polynomial split(const expression &exp)
Break exp.
Definition: algos.cc:1437
static Registry< ldivide_label_t > & ldivide_label_registry()
Definition: algos.cc:904
static Registry< concatenate_expression_t > & concatenate_expression_registry()
Definition: algos.cc:220
static Registry< is_costandard_t > & is_costandard_registry()
Definition: algos.cc:679
automaton derived_term(const expression &exp, const std::string &algo="auto")
The derived-term automaton of exp.
Definition: algos.cc:420
automaton lightest_automaton(const automaton &aut, unsigned num=1, const std::string &algo="auto")
The shortest path automaton using the given algorithm.
Definition: algos.cc:987
automaton prefix(const automaton &aut)
Create a prefix automaton from aut.
Definition: algos.cc:1194
automaton determinize(const automaton &aut, const std::string &algo="auto")
The determinized automaton.
Definition: algos.cc:429
label multiply_label(const label &lhs, const label &rhs)
Bridge (multiply).
Definition: multiply.hh:429
Abstract Builder (the design pattern) for automata.
std::set< std::pair< std::string, std::string >> letter_class_t
A set of letter ranges.
Definition: fwd.hh:111
static Registry< subword_t > & subword_registry()
Definition: algos.cc:1507
polynomial read_polynomial(const context &ctx, std::istream &is)
Read a polynomial from a stream.
Definition: algos.cc:1320
bool is_functional(const automaton &aut)
Whether aut is functional.
Definition: algos.cc:726
weight random_weight(const context &ctx, const std::string &param)
A random weight.
Definition: algos.cc:1275
automaton transpose(automaton &aut)
Transpose aut.
Definition: algos.cc:1590
static Registry< multiply_expression_t > & multiply_expression_registry()
Definition: algos.cc:1066
static Registry< rdivide_label_t > & rdivide_label_registry()
Definition: algos.cc:1300
bool is_coaccessible(const automaton &aut)
Whether aut is coaccessible.
Definition: algos.cc:654
automaton_editor * make_automaton_editor(const context &ctx)
Build an automatonset from its context.
Definition: algos.cc:1032
static Registry< multiply_expression_repeated_t > & multiply_expression_repeated_registry()
Definition: algos.cc:1075
expression transpose_expression(const expression &exp)
Bridge (transpose).
Definition: transpose.hh:292
static Registry< num_tapes_t > & num_tapes_registry()
Definition: algos.cc:1156
static Registry< compose_expansion_t > & compose_expansion_registry()
Definition: algos.cc:193
static Registry< is_trim_t > & is_trim_registry()
Definition: algos.cc:823
expression expression_one(const context &c, identities ids)
The expression for \\e.
Definition: algos.cc:510
expression expand(const expression &e)
Distribute product over addition recursively under the starred subexpressions and group the equal mon...
Definition: algos.cc:501
polynomial derivation(const expression &exp, const label &lbl, bool breaking=false)
Derive exp with respect to s.
Definition: algos.cc:411
label ldivide_label(const label &lhs, const label &rhs)
Bridge (ldivide).
Definition: divide.hh:52
std::size_t num_tapes(const context &ctx)
The number of input tapes.
Definition: algos.cc:1158
expression concatenate_expression(const expression &lhs, const expression &rhs)
Bridge (concatenate).
Definition: multiply.hh:312
static Registry< standard_expression_t > & standard_expression_registry()
Definition: algos.cc:1462
static Registry< synchronizing_word_t > & synchronizing_word_registry()
Definition: algos.cc:1534
static Registry< cotrie_t > & cotrie_registry()
Definition: algos.cc:373
automaton compose(const automaton &lhs, const automaton &rhs, bool lazy=false)
The composition of transducers lhs and rhs.
Definition: algos.cc:186
context context_of(const automaton &a)
The context of this automaton.
Definition: algos.cc:303
expression shuffle_expression(const expression &lhs, const expression &rhs)
Bridge (shuffle).
Definition: conjunction.hh:842
static Registry< complement_expression_t > & complement_expression_registry()
Definition: algos.cc:157
auto out(const Aut &aut, state_t_of< Aut > s)
Indexes of visible transitions leaving state s.
Definition: automaton.hh:85
static Registry< transpose_expression_t > & transpose_expression_registry()
Definition: algos.cc:1597
static Registry< is_coaccessible_t > & is_coaccessible_registry()
Definition: algos.cc:652
static Registry< multiply_weight_t > & multiply_weight_registry()
Definition: algos.cc:1120
automaton partial_identity(const automaton &aut)
Create a partial identity transducer from aut.
Definition: algos.cc:1176
expression difference_expression(const expression &lhs, const expression &rhs)
Bridge (difference).
static Registry< complement_t > & complement_registry()
Definition: algos.cc:139
static Registry< has_twins_property_t > & has_twins_property_registry()
Definition: algos.cc:562
static Registry< sort_t > & sort_registry()
Definition: algos.cc:1426
expansion conjunction_expansion(const expansion &lhs, const expansion &rhs)
Bridge (conjunction).
static Registry< shuffle_t > & shuffle_registry()
Definition: algos.cc:1408
static Registry< is_realtime_t > & is_realtime_registry()
Definition: algos.cc:778
static Registry< is_synchronizing_t > & is_synchronizing_registry()
Definition: algos.cc:814
bool is_standard(const automaton &aut)
Whether is standard (unique initial state, with weight one, no incoming transition).
Definition: algos.cc:789
static Registry< difference_expression_t > & difference_expression_registry()
Definition: algos.cc:445
expression compose_expression(const expression &lhs, const expression &rhs)
Bridge (compose).
unsigned star_height(const expression &rs)
Star height of an expression.
Definition: algos.cc:1482
static Registry< insplit_t > & insplit_registry()
Definition: algos.cc:625
static Registry< is_complete_t > & is_complete_registry()
Definition: algos.cc:670
Definition: a-star.hh:8
context make_word_context(const context &ctx)
The context for words.
Definition: algos.cc:1041
automaton conjugate(const automaton &aut)
The conjugate of aut.
Definition: algos.cc:240
static Registry< letterize_t > & letterize_registry()
Definition: algos.cc:940
automaton factor(const automaton &aut)
Create a factor automaton from aut.
Definition: algos.cc:528
static Registry< constant_term_t > & constant_term_registry()
Definition: algos.cc:292
expansion compose_expansion(const expansion &lhs, const expansion &rhs)
Bridge (compose).
static Registry< weight_zero_t > & weight_zero_registry()
Definition: algos.cc:1723
bool is_ambiguous(const automaton &aut)
Whether aut is ambiguous.
Definition: algos.cc:645
static Registry< info_expression_t > & info_expression_registry()
Definition: algos.cc:616
automaton tuple(const automaton &lhs, const automaton &rhs)
Build a two-tape automaton from two automata.
Definition: others.cc:219
static Registry< random_automaton_t > & random_automaton_registry()
Definition: algos.cc:1246
static Registry< is_standard_t > & is_standard_registry()
Definition: algos.cc:787
polynomial rweight_polynomial(const polynomial &poly, const weight &weight)
Bridge (rweight).
Definition: weight.hh:453
polynomial lightest(const automaton &aut, unsigned num=1, const std::string &algo="auto")
The approximated behavior of an automaton with smallest weights.
Definition: algos.cc:978
static Registry< is_valid_t > & is_valid_registry()
Definition: algos.cc:841
static Registry< add_t > & add_registry()
Definition: algos.cc:22
auto tuple_context(Ctx &&...ctx) -> context< tupleset< labelset_t_of< Ctx >...>, join_t< weightset_t_of< Ctx >...>>
Definition: tuple.hh:16
std::ostream & print_context(const context &ctx, std::ostream &o, const std::string &fmt)
Bridge (print).
Definition: print.hh:140
return exp min
Definition: multiply.hh:361
std::ostream & print(const automaton &aut, std::ostream &out=std::cout, const std::string &format="default")
Print automaton a on out using format format.
Definition: algos.cc:1203
bool is_useless(const automaton &aut)
Whether has no useful state.
Definition: algos.cc:834
static Registry< is_empty_t > & is_empty_registry()
Definition: algos.cc:706
weight rdivide_weight(const weight &lhs, const weight &rhs)
Bridge (rdivide).
Definition: divide.hh:159
std::size_t num_components(const automaton &aut)
The number of strongly connected components.
Definition: algos.cc:1149
static Registry< conjunction_polynomial_t > & conjunction_polynomial_registry()
Definition: algos.cc:274
bool is_empty(const automaton &aut)
Whether has no state.
Definition: algos.cc:708
static Registry< scc_t > & scc_registry()
Definition: algos.cc:1390
automaton delay_automaton(const automaton &a)
The automaton with the delay of each state.
Definition: algos.cc:402
static Registry< lweight_t > & lweight_registry()
Definition: algos.cc:994
word ambiguous_word(const automaton &aut)
An ambiguous word, or raise if there is none.
Definition: algos.cc:69
static Registry< strip_t > & strip_registry()
Definition: algos.cc:1498
static Registry< lweight_polynomial_t > & lweight_polynomial_registry()
Definition: algos.cc:1021
static Registry< info_t > & info_registry()
Definition: algos.cc:607
automaton accessible(const automaton &aut)
The accessible subautomaton of aut.
Definition: algos.cc:15
static Registry< thompson_t > & thompson_registry()
Definition: algos.cc:1543
static Registry< expand_t > & expand_registry()
Definition: algos.cc:499
automaton random_automaton_deterministic(const context &ctx, unsigned num_states)
A random deterministic automaton.
Definition: algos.cc:1257
automaton quotkbaseb(const context &ctx, unsigned divisor, unsigned base)
A transducer that computes the quotient of the division of a word n by k in base b iff k|n...
Definition: algos.cc:1239
static Registry< factor_t > & factor_registry()
Definition: algos.cc:526
bool has_lightening_cycle(const automaton &aut)
Whether the automaton has a cycle with lightening weight.
Definition: algos.cc:555
automaton universal(const automaton &aut)
The universal automaton of aut.
Definition: algos.cc:1698
static Registry< quotkbaseb_t > & quotkbaseb_registry()
Definition: algos.cc:1237
static Registry< lift_expression_t > & lift_expression_registry()
Definition: algos.cc:967
An input/output format for valuesets.
Definition: format.hh:13
bool is_partial_identity(const automaton &aut)
Whether aut realizes a partial identity.
Definition: algos.cc:762
automaton conjunction(const automaton &lhs, const automaton &rhs, bool lazy=false)
The conjunction (aka synchronized product) of automata.
Definition: others.cc:24
static Registry< cerny_t > & cerny_registry()
Definition: algos.cc:103
bool are_isomorphic(const automaton &lhs, const automaton &rhs)
Whether there exists an isomorphism between the states of lhs and those of rhs.
Definition: algos.cc:96
static Registry< conjunction_expansion_t > & conjunction_expansion_registry()
Definition: algos.cc:256
static Registry< star_height_t > & star_height_registry()
Definition: algos.cc:1480
static Registry< copy_convert_t > & copy_convert_registry()
Definition: algos.cc:346
static Registry< rdivide_weight_t > & rdivide_weight_registry()
Definition: algos.cc:1309
static Registry< transposition_expression_t > & transposition_expression_registry()
Definition: algos.cc:1606
weight ldivide_weight(const weight &lhs, const weight &rhs)
Bridge (ldivide).
Definition: divide.hh:74
automaton rweight(const automaton &aut, const weight &w, const std::string &algo="auto")
The right-mult automaton with w as weight.
Definition: algos.cc:1356
expression random_expression(const context &ctx, const std::string &param="+, ., *=.2, w., .w, length=10", identities ids={})
A random expression.
Definition: algos.cc:1266
automaton trim(const automaton &aut)
The trim subautomaton of aut.
Definition: algos.cc:1635
weight constant_term(const expression &e)
The weight associated to the empty word in e.
Definition: algos.cc:294
bool is_trim(const automaton &aut)
Whether has no useless state.
Definition: algos.cc:825
automaton inductive(const expression &e, const std::string &algo="auto")
The inductive translation of e in an automaton.
Definition: algos.cc:582
automaton condense(const automaton &aut)
The condensation of aut such that each state is a strongly connected component.
Definition: algos.cc:231
static Registry< read_weight_t > & read_weight_registry()
Definition: algos.cc:1327
static Registry< synchronize_t > & synchronize_registry()
Definition: algos.cc:1525
static Registry< multiply_t > & multiply_registry()
Definition: algos.cc:1057
automaton lift(const automaton &aut, const std::vector< unsigned > &tapes={}, identities ids={})
Lift some tapes of the transducer, or turn an automaton into a spontaneous automaton.
static Registry< is_useless_t > & is_useless_registry()
Definition: algos.cc:832
static Registry< trie_t > & trie_registry()
Definition: algos.cc:1615
automaton conjunction_repeated(const automaton &aut, unsigned n)
Bridge (conjunction).
expression ldivide_expression(const expression &lhs, const expression &rhs)
Bridge (ldivide).
Definition: divide.hh:41
static Registry< are_equivalent_expression_t > & are_equivalent_expression_registry()
Definition: algos.cc:85
static Registry< rweight_expression_t > & rweight_expression_registry()
Definition: algos.cc:1372
static Registry< tuple_t > & tuple_registry()
Definition: algos.cc:1642
static Registry< compose_expression_t > & compose_expression_registry()
Definition: algos.cc:202
static Registry< standard_t > & standard_registry()
Definition: algos.cc:1453
bool has_twins_property(const automaton &aut)
Whether the automaton has the twins property.
Definition: algos.cc:564
static Registry< to_expression_class_t > & to_expression_class_registry()
Definition: algos.cc:1570
automaton thompson(const expression &e)
The Thompson automaton of e.
Definition: algos.cc:1545
static Registry< divkbaseb_t > & divkbaseb_registry()
Definition: algos.cc:454
static Registry< is_normalized_t > & is_normalized_registry()
Definition: algos.cc:742
expression star_normal_form(const expression &e)
A normalized form where star is applied only to proper expressions.
Definition: algos.cc:1491
static Registry< is_accessible_t > & is_accessible_registry()
Definition: algos.cc:634
automaton complete(const automaton &aut)
A completed copy of aut.
Definition: algos.cc:168
expression infiltrate_expression(const expression &lhs, const expression &rhs)
Bridge (infiltrate).
Definition: conjunction.hh:927
static Registry< prefix_t > & prefix_registry()
Definition: algos.cc:1192
expansion complement_expansion(const expansion &xpn)
Bridge (complement).
Definition: complement.hh:82
static Registry< complement_expansion_t > & complement_expansion_registry()
Definition: algos.cc:148
polynomial lgcd(const polynomial &lhs, const polynomial &rhs)
Left greatest common divisor of two polynomials (lhs \ rhs).
Definition: algos.cc:960
automaton zpc(const expression &exp, const std::string &algo="auto")
The ZPC automaton of exp.
Definition: algos.cc:1734
bool is_synchronizing(const automaton &aut)
Whether is synchronizing.
Definition: algos.cc:816
automaton infiltrate(const automaton &lhs, const automaton &rhs)
The infiltration of automata lhs and rhs.
Definition: others.cc:56
static Registry< coaccessible_t > & coaccessible_registry()
Definition: algos.cc:112
automaton codeterminize(const automaton &aut, const std::string &algo="auto")
The codeterminized automaton.
Definition: algos.cc:123
context context_of_expansion(const expansion &exp)
Bridge (context_of).
Definition: make-context.hh:81
static Registry< ldivide_polynomial_t > & ldivide_polynomial_registry()
Definition: algos.cc:913
static Registry< transpose_t > & transpose_registry()
Definition: algos.cc:1588
automaton coaccessible(const automaton &aut)
The coaccessible subautomaton of aut.
Definition: algos.cc:114
static Registry< star_normal_form_t > & star_normal_form_registry()
Definition: algos.cc:1489
polynomial shortest(const automaton &aut, boost::optional< unsigned > num={}, boost::optional< unsigned > len={})
The approximated behavior of an automaton.
Definition: algos.cc:1401
static Registry< compose_t > & compose_registry()
Definition: algos.cc:184
static Registry< de_bruijn_t > & de_bruijn_registry()
Definition: algos.cc:391
bool is_synchronized_by(const automaton &aut, const word &word)
Whether the word synchronizes aut.
Definition: algos.cc:807
static Registry< lweight_expansion_t > & lweight_expansion_registry()
Definition: algos.cc:1003
static Registry< are_isomorphic_t > & are_isomorphic_registry()
Definition: algos.cc:94
automaton trie_stream(const context &ctx, std::istream &is, const std::string &format)
Bridge (trie).
Definition: trie.hh:302
expression complement_expression(const expression &exp)
Bridge (complement).
Definition: complement.hh:102
static Registry< universal_t > & universal_registry()
Definition: algos.cc:1696
automaton subword(const automaton &aut)
Create a subword automaton from aut.
Definition: algos.cc:1509
expansion to_expansion(const expression &exp)
First order development of a exp.
Definition: algos.cc:1554
static Registry< tuple_context_t > & tuple_context_registry()
Definition: algos.cc:1651
polynomial multiply_polynomial(const polynomial &lhs, const polynomial &rhs)
Bridge (multiply).
Definition: multiply.hh:463
static Registry< conjunction_repeated_t > & conjunction_repeated_registry()
Definition: algos.cc:283
automaton minimize(const automaton &aut, const std::string &algo="auto")
The minimized automaton.
Definition: algos.cc:1050
automaton filter(const automaton &aut, const std::vector< unsigned > &ss)
The subautomaton based on aut, with only states in ss visible.
Definition: algos.cc:537
static Registry< cotrie_stream_t > & cotrie_stream_registry()
Definition: algos.cc:382
static Registry< compose_polynomial_t > & compose_polynomial_registry()
Definition: algos.cc:211
automaton double_ring(const context &ctx, unsigned n, const std::vector< unsigned > &f)
The double_ring automaton with n states and f the list of finals.
Definition: algos.cc:465
static Registry< shortest_t > & shortest_registry()
Definition: algos.cc:1399
expression copy_expression(const expression &exp, const context &ctx, identities ids)
Bridge (copy).
Definition: copy.hh:454
static Registry< lweight_expression_t > & lweight_expression_registry()
Definition: algos.cc:1012
bool is_accessible(const automaton &aut)
Whether aut is accessible.
Definition: algos.cc:636
static Registry< partial_identity_expression_t > & partial_identity_expression_registry()
Definition: algos.cc:1183
expression expression_zero(const context &c, identities ids)
The expression for \\z.
Definition: algos.cc:519
label multiply_label_repeated(const label &re, int exp)
Bridge (multiply).
Definition: multiply.hh:442
static Registry< random_expression_t > & random_expression_registry()
Definition: algos.cc:1264
static Registry< tuple_polynomial_t > & tuple_polynomial_registry()
Definition: algos.cc:1678
expression concatenate(const expression &lhs, const expression &rhs)
Concatenate two expressions.
Definition: algos.cc:222
automaton de_bruijn(const context &ctx, unsigned n)
A simple NFA for (a+b)*a(a+b)^n.
Definition: algos.cc:393
automaton add(const automaton &lhs, const automaton &rhs, const std::string &algo="auto")
Sum of two automata.
Definition: algos.cc:24
word synchronizing_word(const automaton &aut, const std::string &algo="greedy")
A synchronizing word, or raise if there is none.
Definition: algos.cc:1536
static Registry< print_context_t > & print_context_registry()
Definition: algos.cc:1210
bool is_cycle_ambiguous(const automaton &aut)
Whether the automaton is cycle-ambiguous.
Definition: algos.cc:690
automaton pair(const automaton &aut, bool keep_initials=false)
Build the pair automaton of the given automaton.
Definition: algos.cc:1167
static Registry< ldivide_weight_t > & ldivide_weight_registry()
Definition: algos.cc:922
expansion lweight_expansion(const weight &weight, const expansion &exp)
Bridge (lweight).
Definition: weight.hh:215
automaton multiply(const automaton &lhs, const automaton &rhs, const std::string &algo="auto")
Multiply (concatenate) two automata.
Definition: algos.cc:1059
static Registry< expression_one_t > & expression_one_registry()
Definition: algos.cc:508
automaton cominimize(const automaton &aut, const std::string &algo="auto")
The cominimized automaton.
Definition: algos.cc:132
static Registry< is_functional_t > & is_functional_registry()
Definition: algos.cc:724
static Registry< conjunction_expression_t > & conjunction_expression_registry()
Definition: algos.cc:265
bool is_valid(const automaton &e)
Whether automaton is valid (epsilon-cycles converge).
Definition: algos.cc:843
static Registry< is_out_sorted_t > & is_out_sorted_registry()
Definition: algos.cc:751
static Registry< derived_term_t > & derived_term_registry()
Definition: algos.cc:418
static Registry< context_of_polynomial_t > & context_of_polynomial_registry()
Definition: algos.cc:328
bool is_out_sorted(const automaton &aut)
Whether the outgoing transitions of each state have increasing labels.
Definition: algos.cc:753
Template-less root for contexts.
Definition: context.hh:16
automaton costandard(const automaton &a)
A co-standardized a.
Definition: algos.cc:366
static Registry< is_cycle_ambiguous_t > & is_cycle_ambiguous_registry()
Definition: algos.cc:688
expression multiply_expression_repeated(const expression &re, int min, int max)
Bridge (multiply).
Definition: multiply.hh:408
static Registry< partial_identity_t > & partial_identity_registry()
Definition: algos.cc:1174
static Registry< lgcd_polynomial_t > & lgcd_polynomial_registry()
Definition: algos.cc:958
automaton ldivide(const automaton &lhs, const automaton &rhs)
Left-division of two automata (lhs \ rhs).
Definition: algos.cc:879
polynomial tuple_polynomial(const std::vector< polynomial > &ps)
Bridge (tuple).
Definition: tuple.hh:212
expression lift_expression(const expression &exp)
Bridge (lift).
Definition: lift.hh:307
static Registry< rdivide_expression_t > & rdivide_expression_registry()
Definition: algos.cc:1291
automaton sort(const automaton &a)
A copy of a with normalized state numbers.
Definition: algos.cc:1428
expression to_expression_label(const context &ctx, identities ids, const label &lbl)
Bridge (to_expression).
static Registry< delay_automaton_t > & delay_automaton_registry()
Definition: algos.cc:400
static Registry< pair_t > & pair_registry()
Definition: algos.cc:1165
static Registry< make_word_context_t > & make_word_context_registry()
Definition: algos.cc:1039
automaton suffix(const automaton &aut)
Create a suffix automaton from aut.
Definition: algos.cc:1518
automaton strip(const automaton &a)
The automaton in a with its metadata layers removed.
Definition: algos.cc:1500
bool is_deterministic(const automaton &aut)
Whether aut is deterministic.
Definition: algos.cc:699
static Registry< copy_t > & copy_registry()
Definition: algos.cc:337
static Registry< is_valid_expression_t > & is_valid_expression_registry()
Definition: algos.cc:850
static Registry< to_expansion_t > & to_expansion_registry()
Definition: algos.cc:1552
expression partial_identity_expression(const expression &exp)
Bridge (partial_identity).
expression rweight_expression(const expression &exp, const weight &weight)
Bridge (rweight).
Definition: weight.hh:430
automaton multiply_repeated(const automaton &a, int min, int max, const std::string &algo)
Bridge (multiply).
Definition: multiply.hh:258
context context_of_expression(const expression &exp)
Bridge (context_of).
Definition: make-context.hh:72
automaton standard_expression(const expression &exp)
Bridge (standard).
Definition: standard.hh:400
bool is_letterized(const automaton &aut)
Whether aut is letterized.
Definition: algos.cc:735
automaton complement(const automaton &aut)
The complement of aut.
Definition: algos.cc:141
static Registry< ambiguous_word_t > & ambiguous_word_registry()
Definition: algos.cc:67
std::ostream & info_expression(const expression &exp, std::ostream &o)
Bridge (info).
Definition: info.hh:195
bool are_equivalent_expression(const expression &r1, const expression &r2)
Bridge (are_equivalent).
weight read_weight(const context &ctx, std::istream &is)
Read a weight from a stream.
Definition: algos.cc:1329
static Registry< infiltrate_t > & infiltrate_registry()
Definition: algos.cc:589
static Registry< codeterminize_t > & codeterminize_registry()
Definition: algos.cc:121
static Registry< cominimize_t > & cominimize_registry()
Definition: algos.cc:130
static Registry< is_partial_identity_t > & is_partial_identity_registry()
Definition: algos.cc:760
expression lweight_expression(const weight &weight, const expression &exp)
Bridge (lweight).
Definition: weight.hh:269
static Registry< add_expression_t > & add_expression_registry()
Definition: algos.cc:40
static Registry< infiltrate_expression_t > & infiltrate_expression_registry()
Definition: algos.cc:598
static Registry< suffix_t > & suffix_registry()
Definition: algos.cc:1516
A dyn automaton.
Definition: automaton.hh:17
context context_of_polynomial(const polynomial &poly)
Bridge (context_of).
Definition: make-context.hh:90
bool is_complete(const automaton &aut)
Whether aut is complete.
Definition: algos.cc:672
static Registry< trim_t > & trim_registry()
Definition: algos.cc:1633
bool is_synchronized(const automaton &aut)
Whether is synchronized.
Definition: algos.cc:798
static Registry< realtime_t > & realtime_registry()
Definition: algos.cc:1336
static Registry< make_automaton_editor_t > & make_automaton_editor_registry()
Definition: algos.cc:1030
static Registry< double_ring_t > & double_ring_registry()
Definition: algos.cc:463
static Registry< conjugate_t > & conjugate_registry()
Definition: algos.cc:238
bool less_than(const expression &lhs, const expression &rhs)
Ordering between expressions.
Definition: algos.cc:933
polynomial lgcd_polynomial(const polynomial &lhs, const polynomial &rhs)
Bridge (lgcd).
Definition: divide.hh:106
static Registry< proper_t > & proper_registry()
Definition: algos.cc:1219
automaton eliminate_state(const automaton &aut, int s=-1)
The LAO automaton aut with state s removed.
Definition: algos.cc:474
weight add_weight(const weight &lhs, const weight &rhs)
Bridge (add).
Definition: add.hh:230
expression multiply_expression(const expression &lhs, const expression &rhs)
Bridge (multiply).
Definition: multiply.hh:294
expansion tuple_expansion(const std::vector< expansion > &es)
Bridge (tuple).
Definition: tuple.hh:123
polynomial compose_polynomial(const polynomial &lhs, const polynomial &rhs)
Bridge (compose).
static Registry< is_deterministic_t > & is_deterministic_registry()
Definition: algos.cc:697
static Registry< levenshtein_t > & levenshtein_registry()
Definition: algos.cc:949
automaton standard(const automaton &a)
A standardized a.
Definition: algos.cc:1455
static Registry< multiply_polynomial_t > & multiply_polynomial_registry()
Definition: algos.cc:1102
expansion rweight_expansion(const expansion &exp, const weight &weight)
Bridge (rweight).
Definition: weight.hh:406
static Registry< has_lightening_cycle_t > & has_lightening_cycle_registry()
Definition: algos.cc:553
static Registry< expression_zero_t > & expression_zero_registry()
Definition: algos.cc:517
bool has_bounded_lag(const automaton &aut)
Whether the transducer has bounded lag.
Definition: algos.cc:546
automaton ladybird(const context &ctx, unsigned n)
The ladybird automaton with n states.
Definition: algos.cc:870
expression to_expression(const automaton &aut, identities ids={}, const std::string &algo="auto")
An expression denoting the language of aut.
Definition: algos.cc:1563
bool is_valid_expression(const expression &exp)
Bridge (is_valid).
PolynomialSet::value_t split_polynomial(const PolynomialSet &ps, const typename PolynomialSet::value_t &p)
Split a polynomial of expressions, given the polynomialset.
Definition: split.hh:288
static Registry< ldivide_expansion_t > & ldivide_expansion_registry()
Definition: algos.cc:886
static Registry< difference_t > & difference_registry()
Definition: algos.cc:436
weight multiply_weight_repeated(const weight &wgt, int min, int max)
Bridge (multiply).
Definition: multiply.hh:497
weight multiply_weight(const weight &lhs, const weight &rhs)
Bridge (multiply).
Definition: multiply.hh:484
static Registry< complete_t > & complete_registry()
Definition: algos.cc:166
static Registry< is_synchronized_by_t > & is_synchronized_by_registry()
Definition: algos.cc:805
std::ostream & info(const automaton &aut, std::ostream &out=std::cout, unsigned details=2)
Output various facts about an automaton.
Definition: algos.cc:609
automaton star(const automaton &aut, const std::string &algo="auto")
Star of an automaton.
Definition: algos.cc:1473
expression transposition_expression(const expression &exp)
Bridge (transposition).
Definition: transpose.hh:310
automaton u(const context &ctx, unsigned n)
The Brzozowski universal witness.
Definition: algos.cc:1689
static Registry< is_eps_acyclic_t > & is_eps_acyclic_registry()
Definition: algos.cc:715
static Registry< split_polynomial_t > & split_polynomial_registry()
Definition: algos.cc:1444
static Registry< rweight_polynomial_t > & rweight_polynomial_registry()
Definition: algos.cc:1381
automaton shuffle(const automaton &lhs, const automaton &rhs)
The shuffle product of automata lhs and rhs.
Definition: others.cc:164
static Registry< eliminate_state_t > & eliminate_state_registry()
Definition: algos.cc:472
automaton copy_convert(const automaton &aut, const context &ctx)
Bridge (copy).
Definition: copy.hh:423
static Registry< are_equivalent_t > & are_equivalent_registry()
Definition: algos.cc:76
automaton realtime(const automaton &aut)
Create the realtime automaton (letterized and proper).
Definition: algos.cc:1338
static Registry< costandard_t > & costandard_registry()
Definition: algos.cc:364
static Registry< read_polynomial_t > & read_polynomial_registry()
Definition: algos.cc:1318
static Registry< random_automaton_deterministic_t > & random_automaton_deterministic_registry()
Definition: algos.cc:1255
automaton component(const automaton &aut, unsigned num)
The automaton of a strongly connected component.
Definition: algos.cc:177
static Registry< to_expression_t > & to_expression_registry()
Definition: algos.cc:1561
static Registry< num_components_t > & num_components_registry()
Definition: algos.cc:1147
expression rdivide_expression(const expression &lhs, const expression &rhs)
Bridge (rdivide).
Definition: divide.hh:148
static Registry< join_t > & join_registry()
Definition: algos.cc:859
static Registry< reduce_t > & reduce_registry()
Definition: algos.cc:1345
std::shared_ptr< detail::delay_automaton_impl< Aut >> delay_automaton
An automaton wrapper that presents the delay automaton.
Definition: fwd.hh:27
automaton trie(const polynomial &p)
A trie-like automaton (single initial state, multiple final states) to accept p.
Definition: algos.cc:1617
bool is_proper(const automaton &aut)
Whether has no spontaneous transition.
Definition: algos.cc:771
automaton lweight(const weight &w, const automaton &aut, const std::string &algo="auto")
The left-multiplication of an automaton with w as weight.
Definition: algos.cc:996
static Registry< derivation_t > & derivation_registry()
Definition: algos.cc:409
automaton synchronize(const automaton &aut)
Create a synchronized transducer from aut.
Definition: algos.cc:1527
automaton scc(const automaton &aut, const std::string &algo="auto")
Build the SCC automaton whose states are labeled with number of the strongly-connected component they...
Definition: algos.cc:1392
static Registry< normalize_t > & normalize_registry()
Definition: algos.cc:1138
static Registry< add_expansion_t > & add_expansion_registry()
Definition: algos.cc:31
static identities ids(const driver &d)
Get the identities of the driver.
Definition: parse.cc:89
bool is_costandard(const automaton &aut)
Whether is costandard (unique final state, with weight one, no outcoming transition).
Definition: algos.cc:681
automaton reduce(const automaton &aut)
Reduce aut.
Definition: algos.cc:1347
automaton insplit(const automaton &aut, bool lazy=false)
Split automaton on the incoming transition.
Definition: algos.cc:627
expansion ldivide_expansion(const expansion &lhs, const expansion &rhs)
Bridge (ldivide).
Definition: divide.hh:30
polynomial add_polynomial(const polynomial &lhs, const polynomial &rhs)
Bridge (add).
Definition: add.hh:208
static Registry< rweight_expansion_t > & rweight_expansion_registry()
Definition: algos.cc:1363
static Registry< context_of_expansion_t > & context_of_expansion_registry()
Definition: algos.cc:310
automaton cotrie(const polynomial &p)
A reversed trie-like automaton (multiple initial states, single final state) automaton to accept p...
Definition: algos.cc:375
static Registry< tuple_expression_t > & tuple_expression_registry()
Definition: algos.cc:1669
automaton normalize(const automaton &aut)
Normalize automaton aut.
Definition: algos.cc:1140
static Registry< lightest_t > & lightest_registry()
Definition: algos.cc:976
automaton proper(const automaton &aut, direction dir=direction::backward, bool prune=true, const std::string &algo="auto")
An equivalent automaton without spontaneous transitions.
Definition: algos.cc:1221
automaton divkbaseb(const context &ctx, unsigned divisor, unsigned base)
An automaton which accepts a word n representing a number in base b iff k|n.
Definition: algos.cc:456
static Registry< add_polynomial_t > & add_polynomial_registry()
Definition: algos.cc:49
static Registry< multiply_label_repeated_t > & multiply_label_repeated_registry()
Definition: algos.cc:1093
static Registry< is_codeterministic_t > & is_codeterministic_registry()
Definition: algos.cc:661
static Registry< to_expression_label_t > & to_expression_label_registry()
Definition: algos.cc:1579
static Registry< context_of_t > & context_of_registry()
Definition: algos.cc:301
weight weight_one(const context &c)
The weight one.
Definition: algos.cc:1707
static Registry< context_of_expression_t > & context_of_expression_registry()
Definition: algos.cc:319
bool is_normalized(const automaton &aut)
Whether is normalized (in the Thompson sense), i.e., standard and co-standard.
Definition: algos.cc:744
static Registry< shuffle_expression_t > & shuffle_expression_registry()
Definition: algos.cc:1417
static Registry< minimize_t > & minimize_registry()
Definition: algos.cc:1048
static Registry< zpc_t > & zpc_registry()
Definition: algos.cc:1732
static Registry< component_t > & component_registry()
Definition: algos.cc:175
automaton levenshtein(const context &ls)
The transducer representing the Levenshtein distance.
Definition: algos.cc:951
automaton cotrie_stream(const context &ctx, std::istream &is, const std::string &format)
Bridge (cotrie).
Definition: trie.hh:313
static Registry< copy_expression_t > & copy_expression_registry()
Definition: algos.cc:355
expression conjunction_expression(const expression &lhs, const expression &rhs)
Bridge (conjunction).
automaton copy(const automaton &aut)
A copy of aut.
Definition: algos.cc:339
static Registry< ldivide_t > & ldivide_registry()
Definition: algos.cc:877
label rdivide_label(const label &lhs, const label &rhs)
Bridge (rdivide).
Definition: divide.hh:137
polynomial conjunction_polynomial(const polynomial &lhs, const polynomial &rhs)
Bridge (conjunction).
static Registry< push_weights_t > & push_weights_registry()
Definition: algos.cc:1228
bool less_than_expression(const expression &lhs, const expression &rhs)
Bridge (less_than).
Definition: less-than.hh:31
static Registry< inductive_t > & inductive_registry()
Definition: algos.cc:580
static Registry< weight_one_t > & weight_one_registry()
Definition: algos.cc:1705
direction
Orientation.
Definition: direction.hh:11
bool are_equivalent(const automaton &lhs, const automaton &rhs)
Whether compute the same series.
Definition: algos.cc:78
static Registry< rdivide_t > & rdivide_registry()
Definition: algos.cc:1282
automaton rdivide(const automaton &lhs, const automaton &rhs)
Right-division of two automata (lhs / rhs).
Definition: algos.cc:1284
weight weight_series(const automaton &aut)
Compute weight of the series.
Definition: algos.cc:1716
polynomial lweight_polynomial(const weight &weight, const polynomial &poly)
Bridge (lweight).
Definition: weight.hh:301
bool is_realtime(const automaton &aut)
Whether has no spontaneous transition, and is letterized.
Definition: algos.cc:780
static Registry< ldivide_expression_t > & ldivide_expression_registry()
Definition: algos.cc:895
static Registry< add_weight_t > & add_weight_registry()
Definition: algos.cc:58
automaton random_automaton(const context &ctx, unsigned num_states, float density=0.1, unsigned num_initial=1, unsigned num_final=1, boost::optional< unsigned > max_labels={}, float loop_chance=0.0, const std::string &weights="")
A random automaton.
Definition: algos.cc:1248
static Registry< trie_stream_t > & trie_stream_registry()
Definition: algos.cc:1624
static Registry< accessible_t > & accessible_registry()
Definition: algos.cc:13
static Registry< u_t > & u_registry()
Definition: algos.cc:1687
expression to_expression_class(const context &ctx, identities ids, const letter_class_t &letters, bool accept)
Bridge (to_expression).
static Registry< random_weight_t > & random_weight_registry()
Definition: algos.cc:1273
expression transposition(const expression &r)
Add the transposition operator to r.
Definition: algos.cc:1608
static Registry< evaluate_t > & evaluate_registry()
Definition: algos.cc:490
static Registry< is_synchronized_t > & is_synchronized_registry()
Definition: algos.cc:796
automaton letterize(const automaton &aut)
The automaton with letter transitions instead of words.
Definition: algos.cc:942
static Registry< ladybird_t > & ladybird_registry()
Definition: algos.cc:868
automaton push_weights(const automaton &aut)
The weight pushing automaton of aut.
Definition: algos.cc:1230
static Registry< lightest_automaton_t > & lightest_automaton_registry()
Definition: algos.cc:985
static Registry< less_than_expression_t > & less_than_expression_registry()
Definition: algos.cc:931
static Registry< is_proper_t > & is_proper_registry()
Definition: algos.cc:769
context join(const context &lhs, const context &rhs)
The join between two contexts, i.e., their lowest common supertype.
Definition: algos.cc:861
automaton difference(const automaton &lhs, const automaton &rhs)
An automaton whose behavior is that of lhs on words not accepted by rhs.
Definition: algos.cc:438
static Registry< eval_polynomial_t > & eval_polynomial_registry()
Definition: algos.cc:481
static Registry< split_t > & split_registry()
Definition: algos.cc:1435
A dyn Value/ValueSet.
Definition: fwd.hh:23
identities identities_of(const expression &exp)
The identities of expression exp.
Definition: algos.cc:573
value_impl< detail::expression_tag > expression
Definition: fwd.hh:25
expression tuple_expression(const std::vector< expression > &es)
Bridge (tuple).
Definition: tuple.hh:160
static Registry< has_bounded_lag_t > & has_bounded_lag_registry()
Definition: algos.cc:544
weight eval_polynomial(const automaton &aut, const polynomial &poly)
Bridge (evaluate).
Definition: evaluate.hh:241
static Registry< conjunction_t > & conjunction_registry()
Definition: algos.cc:247
static Registry< filter_t > & filter_registry()
Definition: algos.cc:535
static Registry< identities_of_t > & identities_of_registry()
Definition: algos.cc:571
static Registry< condense_t > & condense_registry()
Definition: algos.cc:229
expansion add_expansion(const expansion &lhs, const expansion &rhs)
Bridge (add).
Definition: add.hh:165
static Registry< is_letterized_t > & is_letterized_registry()
Definition: algos.cc:733
bool is_codeterministic(const automaton &aut)
Whether aut is codeterministic.
Definition: algos.cc:663
expression add_expression(const expression &lhs, const expression &rhs)
Bridge (add).
Definition: add.hh:186
static Registry< star_t > & star_registry()
Definition: algos.cc:1471
static Registry< print_t > & print_registry()
Definition: algos.cc:1201
static Registry< is_ambiguous_t > & is_ambiguous_registry()
Definition: algos.cc:643
static Registry< determinize_t > & determinize_registry()
Definition: algos.cc:427
static Registry< multiply_weight_repeated_t > & multiply_weight_repeated_registry()
Definition: algos.cc:1129
static Registry< rweight_t > & rweight_registry()
Definition: algos.cc:1354
bool is_eps_acyclic(const automaton &aut)
Whether has no cycle of spontaneous transitions.
Definition: algos.cc:717
polynomial ldivide_polynomial(const polynomial &lhs, const polynomial &rhs)
Bridge (ldivide).
Definition: divide.hh:63
automaton cerny(const context &ctx, unsigned num_states)
Produce a Černý automaton of num_states states.
Definition: algos.cc:105
weight weight_zero(const context &c)
The weight zero.
Definition: algos.cc:1725
static Registry< weight_series_t > & weight_series_registry()
Definition: algos.cc:1714
static Registry< multiply_repeated_t > & multiply_repeated_registry()
Definition: algos.cc:1111
static Registry< multiply_label_t > & multiply_label_registry()
Definition: algos.cc:1084
static Registry< tuple_expansion_t > & tuple_expansion_registry()
Definition: algos.cc:1660