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