00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017 #ifndef VCSN_ALGEBRA_IMPLEMENTATION_SERIES_KRAT_HXX
00018 # define VCSN_ALGEBRA_IMPLEMENTATION_SERIES_KRAT_HXX
00019
00020 # include <utility>
00021 # include <list>
00022
00023 # include <vaucanson/algebra/implementation/series/series.hh>
00024 # include <vaucanson/algebra/implementation/series/rat/exp.hh>
00025 # include <vaucanson/algebra/implementation/series/rat/random_visitor.hh>
00026 # include <vaucanson/misc/usual_macros.hh>
00027
00028 # include <vaucanson/algebra/implementation/series/krat_exp_is_finite_app.hxx>
00029 # include <vaucanson/algebra/implementation/series/krat_exp_support.hxx>
00030 # include <vaucanson/algebra/implementation/series/krat_exp_transpose.hxx>
00031
00032 # include <vaucanson/algorithms/eval.hh>
00033 # include <vaucanson/algorithms/standard_of.hh>
00034
00035 # include <vaucanson/algebra/implementation/series/polynoms.hh>
00036 # include <vaucanson/automata/concept/automata.hh>
00037
00038 # include <vaucanson/misc/contract.hh>
00039
00040 namespace vcsn
00041 {
00042 namespace algebra
00043 {
00058 template<typename W, typename M, typename Tm, typename Tw>
00059 bool op_contains(const algebra::Series<W, M>&, const rat::exp<Tm, Tw>&)
00060 {
00061 pure_service_call ("default version of op_contains(Series<W,M>, exp<Tm,Tw>)");
00062 return true;
00063 }
00064
00065 template<typename W, typename M, typename Tm, typename Tw>
00066 bool op_is_finite_app(const algebra::Series<W, M>&,
00067 const rat::exp<Tm, Tw>& m)
00068 {
00069 vcsn::IsFiniteAppMatcher<
00070 algebra::Series<W, M>,
00071 vcsn::rat::exp<Tm, Tw>,
00072 algebra::DispatchFunction<vcsn::rat::exp<Tm, Tw> >
00073 > matcher;
00074 return matcher.match(m);
00075 }
00076
00077 template<typename W, typename M, typename Tm, typename Tw>
00078 typename algebra::series_traits<rat::exp<Tm, Tw> >::support_t
00079 op_support(const algebra::Series<W, M>& s, const rat::exp<Tm, Tw>& m)
00080 {
00081 vcsn::SupportMatcher<
00082 algebra::Series<W, M>, rat::exp<Tm, Tw>,
00083 algebra::DispatchFunction<rat::exp<Tm, Tw> >
00084 > matcher(s);
00085 matcher.match(m);
00086 return matcher.get();
00087 }
00088
00089 template <typename W, typename M, typename Tm, typename Tw>
00090 Tm op_choose_from_supp(const algebra::Series<W, M>&,
00091 const rat::exp<Tm, Tw>& m)
00092 {
00093 rat::RandomVisitor<Tm, Tw> v;
00094 m.accept(v);
00095 return v.get();
00096 }
00097
00098 template<typename W, typename M, typename Tm, typename Tw>
00099 const rat::exp<Tm, Tw>& identity_value(SELECTOR2(algebra::Series<W, M>),
00100 SELECTOR2(rat::exp<Tm, Tw>))
00101 {
00102 static const rat::exp<Tm, Tw> instance = rat::exp<Tm, Tw>::one();
00103 return instance;
00104 }
00105
00106 template<typename W, typename M, typename Tm, typename Tw>
00107 const rat::exp<Tm, Tw>& zero_value(SELECTOR2(algebra::Series<W, M>),
00108 SELECTOR2(rat::exp<Tm, Tw>))
00109 {
00110 static const rat::exp<Tm, Tw> instance = rat::exp<Tm, Tw>::zero();
00111 return instance;
00112 }
00113
00114 template <typename W, typename M, typename Tm, typename Tw>
00115 void op_in_transpose(const algebra::Series<W, M>& s,
00116 rat::exp<Tm, Tw>& exp)
00117 {
00118 Element<algebra::Series<W, M>,
00119 rat::exp<Tm, Tw> > elt(s, exp);
00120
00121 vcsn::algebra::KRatExpTranspose<
00122 algebra::Series<W, M>,
00123 rat::exp<Tm, Tw>,
00124 algebra::DispatchFunction<vcsn::rat::exp<Tm, Tw> >
00125 > matcher(elt);
00126
00127 elt = matcher.match(exp);
00128 exp = elt.value();
00129 }
00130
00131 template<typename W, typename M, typename Tm, typename Tw>
00132 void op_in_add(const algebra::Series<W, M>&,
00133 rat::exp<Tm, Tw>& dst,
00134 const rat::exp<Tm, Tw>& arg)
00135 {
00136
00137 if (arg.base()->what() == rat::Node<Tm, Tw>::zero)
00138 return ;
00139
00140
00141 if (dst.base()->what() == rat::Node<Tm, Tw>::zero)
00142 {
00143 delete dst.base();
00144 dst.base() = arg.base()->clone();
00145 return;
00146 }
00147
00148 dst.base() = new rat::Sum<Tm, Tw>(dst.base(), arg.base()->clone());
00149 }
00150
00151 template<typename W, typename M, typename Tm, typename Tw>
00152 rat::exp<Tm, Tw> op_add(const algebra::Series<W, M>& s,
00153 const rat::exp<Tm, Tw>& a,
00154 const rat::exp<Tm, Tw>& b)
00155 {
00156 rat::exp<Tm, Tw> ret(a);
00157 op_in_add(s, ret, b);
00158 return ret;
00159 }
00160
00161 template<typename W, typename M, typename Tm, typename Tw>
00162 void op_in_mul(const algebra::Series<W, M>& s,
00163 rat::exp<Tm, Tw>& dst,
00164 const rat::exp<Tm, Tw>& arg)
00165 {
00166 typedef rat::Node<Tm, Tw> node_t;
00167 typedef typename rat::Node<Tm, Tw>::type type;
00168 typedef rat::One<Tm, Tw> n_one_t;
00169 typedef rat::Constant<Tm, Tw> n_const_t;
00170 typedef rat::Zero<Tm, Tw> n_zero_t;
00171 typedef rat::Star<Tm, Tw> n_star_t;
00172 typedef rat::LeftWeighted<Tm, Tw> n_lweight_t;
00173 typedef rat::RightWeighted<Tm, Tw> n_rweight_t;
00174 typedef rat::Sum<Tm, Tw> n_sum_t;
00175 typedef rat::Product<Tm, Tw> n_prod_t;
00176
00177 type this_type = dst.base()->what();
00178 type arg_type = arg.base()->what();
00179
00180
00181 if (this_type == node_t::zero)
00182 return;
00183
00184
00185 if (arg_type == node_t::zero)
00186 {
00187 delete dst.base();
00188 dst.base() = new n_zero_t;
00189 return;
00190 }
00191
00192
00193 if (this_type == node_t::one)
00194 {
00195 delete dst.base();
00196 dst.base() = arg.base()->clone();
00197 return;
00198 }
00199
00200
00201 if (arg_type == node_t::one)
00202 {
00203 return;
00204 }
00205
00206
00207 if (arg_type == node_t::lweight)
00208 {
00209 n_lweight_t *p = dynamic_cast<n_lweight_t*>(arg.base());
00210 if (p->child_->what() == node_t::one)
00211 {
00212 op_in_mul(s, s.semiring(), dst, p->weight_);
00213 return;
00214 }
00215 }
00216
00218
00219
00220
00221
00222
00223
00224
00225
00226
00227
00228
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238
00239
00240
00241
00242
00243
00244 if (this_type == node_t::lweight)
00245 {
00246 n_lweight_t *p = dynamic_cast<n_lweight_t*>(dst.base());
00247 if (p->child_->what() == node_t::one)
00248 {
00249 dst = op_mul(s.semiring(), s, p->weight_, arg);
00250 return;
00251 }
00252 }
00253
00254
00255 dst.base() = new n_prod_t(dst.base(), arg.base()->clone());
00256 return;
00257 }
00258
00259 template<typename W, typename M, typename Tm, typename Tw>
00260 rat::exp<Tm, Tw> op_mul(const algebra::Series<W, M>& s,
00261 const rat::exp<Tm, Tw>& a,
00262 const rat::exp<Tm, Tw>& b)
00263 {
00264 rat::exp<Tm, Tw> ret(a);
00265 op_in_mul(s, ret, b);
00266 return ret;
00267 }
00268
00269
00270
00271
00272
00273 template<typename Tm, typename Tw, typename M, typename W>
00274 rat::exp<Tm, Tw> op_convert(SELECTOR2(algebra::Series<M, W>),
00275 SELECTOR2(rat::exp<Tm, Tw>),
00276 const Tm& m_value)
00277 {
00278 return new rat::Constant<Tm, Tw>(m_value);
00279 }
00280
00281 template<typename Tm, typename Tw, typename M, typename W>
00282 rat::exp<Tm, Tw> op_convert(SELECTOR2(algebra::Series<M, W>),
00283 SELECTOR2(rat::exp<Tm, Tw>),
00284 char m_value)
00285 {
00286 const char str[] = {m_value, '\0'};
00287 return new rat::Constant<Tm, Tw>(str);
00288 }
00289
00290 template<typename Tm, typename Tw, typename W, typename M, typename oTm>
00291 rat::exp<Tm, Tw> op_convert(SELECTOR2(algebra::Series<W, M>) s,
00292 SELECTOR2(rat::exp<Tm, Tw>),
00293 SELECTOR(M),
00294 const oTm& m_value)
00295 {
00296
00297
00298 if (m_value == identity_value(SELECT(M), SELECT(oTm)))
00299 return rat::exp<Tm, Tw>::one();
00300 return rat::exp<Tm, Tw>::constant(op_convert(s.monoid(), SELECT(Tm),
00301 m_value));
00302 }
00303
00304 template<typename Tm, typename Tw, typename W, typename M, typename oTw>
00305 rat::exp<Tm, Tw> op_convert(SELECTOR2(algebra::Series<W, M>),
00306 SELECTOR2(rat::exp<Tm, Tw>),
00307 SELECTOR(W),
00308 const oTw& w_value)
00309 {
00310 if (w_value == identity_value(SELECT(W), SELECT(oTw)))
00311 return rat::exp<Tm, Tw>::one();
00312 if (w_value == zero_value(SELECT(W), SELECT(oTw)))
00313 return rat::exp<Tm, Tw>::zero();
00314 rat::exp<Tm, Tw> ret = rat::exp<Tm, Tw>::one();
00315 ret.base() = new rat::LeftWeighted<Tm, Tw>
00316 (op_convert(SELECT(W), SELECT(Tw),
00317 w_value), ret.base());
00318 return ret;
00319 }
00320
00321 template<typename W, typename M, typename Tm, typename Tw, typename oTm>
00322 void op_assign(const algebra::Series<W, M>&,
00323 const M&,
00324 rat::exp<Tm, Tw>& dst,
00325 const oTm& src)
00326 {
00327
00328
00329 if (src == identity_value(SELECT(M), SELECT(oTm)))
00330 dst = rat::exp<Tm, Tw>::one();
00331 else
00332 dst = rat::exp<Tm, Tw>::constant(src);
00333 }
00334
00335 template<typename W, typename M, typename Tm, typename Tw, typename oTw>
00336 void op_assign(const algebra::Series<W, M>&,
00337 const W& semiring,
00338 rat::exp<Tm, Tw>& dst,
00339 const oTw& src)
00340 {
00341 dst = op_convert
00342 (SELECT2(algebra::Series<W, M>), SELECT2(rat::exp<Tm, Tw>), SELECT(W), src);
00343 }
00344
00345
00346
00347
00348
00349 template<typename W, typename M, typename Tm, typename Tw>
00350 bool op_starable(const algebra::Series<W, M>&,
00351 const rat::exp<Tm, Tw>&)
00352 {
00353 return true;
00354 }
00355
00356 template<typename W, typename M, typename Tm, typename Tw>
00357 void op_in_star(const algebra::Series<W, M>&,
00358 rat::exp<Tm, Tw>& dst)
00359 {
00360 if (dst.base()->what() == rat::Node<Tm, Tw>::zero)
00361 dst = rat::exp<Tm, Tw>::one();
00362 else
00363 dst.base() = new rat::Star<Tm, Tw>(dst.base());
00364 }
00365
00366 template<typename W, typename M, typename Tm, typename Tw>
00367 rat::exp<Tm, Tw>
00368 op_star(const algebra::Series<W, M>&,
00369 const rat::exp<Tm, Tw>& src)
00370 {
00371 if (src.base()->what() == rat::Node<Tm, Tw>::zero)
00372 return rat::exp<Tm, Tw>::one();
00373 rat::exp<Tm, Tw> ret(src);
00374 ret.base() = new rat::Star<Tm, Tw>(ret.base());
00375 return ret;
00376 }
00377
00378
00379
00380
00381
00382 template<typename W, typename M, typename Tm, typename Tw, typename oTm>
00383 void op_in_add(const algebra::Series<W, M>& s,
00384 const M& monoid,
00385 rat::exp<Tm, Tw>& dst,
00386 const oTm& src)
00387 {
00388 op_in_add(s, dst, op_convert(SELECT2(algebra::Series<W, M>),
00389 SELECT2(rat::exp<Tm, Tw>),
00390 SELECT(M),
00391 src));
00392 }
00393
00394 template<typename W, typename M, typename Tm, typename Tw, typename oTm>
00395 rat::exp<Tm, Tw> op_add(const algebra::Series<W, M>& s,
00396 const M& monoid,
00397 const rat::exp<Tm, Tw>& a,
00398 const oTm& b)
00399 {
00400 rat::exp<Tm, Tw> ret(a);
00401 op_in_add(s, monoid, ret, b);
00402 return ret;
00403 }
00404
00405 template<typename M, typename W, typename oTm, typename Tm, typename Tw>
00406 rat::exp<Tm, Tw> op_add(const M& monoid,
00407 const algebra::Series<W, M>& s,
00408 const oTm& a,
00409 const rat::exp<Tm, Tw>& b)
00410 {
00411 rat::exp<Tm, Tw> ret(b);
00412 op_in_add(s, monoid, ret, a);
00413 return ret;
00414 }
00415
00416
00417
00418
00419
00420 template<typename W, typename M, typename Tm, typename Tw, typename oTw>
00421 void op_in_add(const algebra::Series<W, M>& s,
00422 const W& semiring,
00423 rat::exp<Tm, Tw>& dst,
00424 const oTw& src)
00425 {
00426 precondition(& s.semiring() == & semiring);
00427 op_in_add(s, dst, op_convert(SELECT2(algebra::Series<W, M>),
00428 SELECT2(rat::exp<Tm, Tw>),
00429 SELECT(W),
00430 src));
00431 }
00432
00433 template<typename W, typename M, typename Tm, typename Tw, typename oTw>
00434 rat::exp<Tm, Tw> op_add(const algebra::Series<W, M>& s,
00435 const W& semiring,
00436 const rat::exp<Tm, Tw>& a,
00437 const oTw& b)
00438 {
00439 rat::exp<Tm, Tw> ret(a);
00440 op_in_add(s, semiring, ret, b);
00441 return ret;
00442 }
00443
00444 template<typename W, typename M, typename oTw, typename Tm, typename Tw>
00445 rat::exp<Tm, Tw> op_add(const W& semiring,
00446 const algebra::Series<W, M>& s,
00447 const oTw& a,
00448 const rat::exp<Tm, Tw>& b)
00449 {
00450 rat::exp<Tm, Tw> ret(b);
00451 op_in_add(s, semiring, ret, a);
00452 return ret;
00453 }
00454
00455
00456
00457
00458
00459 template<typename W, typename M, typename Tm, typename Tw, typename oTw>
00460 void op_in_mul(const algebra::Series<W, M>& s,
00461 const W& semiring,
00462 rat::exp<Tm, Tw>& ret,
00463 const oTw& w)
00464 {
00465 precondition(& s.semiring() == & semiring);
00466 (void) s; (void) semiring;
00467
00468 typedef rat::Node<Tm, Tw> node_t;
00469 typedef typename rat::Node<Tm, Tw>::type type;
00470 typedef rat::One<Tm, Tw> n_one_t;
00471 typedef rat::Constant<Tm, Tw> n_const_t;
00472 typedef rat::Zero<Tm, Tw> n_zero_t;
00473 typedef rat::Star<Tm, Tw> n_star_t;
00474 typedef rat::LeftWeighted<Tm, Tw> n_lweight_t;
00475 typedef rat::RightWeighted<Tm, Tw> n_rweight_t;
00476 typedef rat::Sum<Tm, Tw> n_sum_t;
00477 typedef rat::Product<Tm, Tw> n_prod_t;
00478
00479 type this_type = ret.base()->what();
00480
00481
00482 if (this_type == node_t::zero)
00483 return;
00484
00485
00486 if (w == identity_value(SELECT(W), SELECT(oTw)))
00487 return;
00488
00489
00490 if (w == zero_value(SELECT(W), SELECT(oTw)))
00491 {
00492 delete ret.base();
00493 ret.base() = new n_zero_t;
00494 return;
00495 }
00496
00497
00498 if (this_type == node_t::one)
00499 {
00500 ret.base() = new n_lweight_t
00501 (op_convert(SELECT(W), SELECT(Tw), w), ret.base());
00502 return;
00503 }
00504
00506
00507
00508
00509
00510
00511
00512
00513
00514
00515
00516
00517
00518
00519
00520
00521
00522
00523
00524
00525
00526
00527
00528
00529
00530
00531
00532
00533
00534 ret.base() =
00535 new n_rweight_t(op_convert(SELECT(W), SELECT(Tw), w), ret.base());
00536 return;
00537 }
00538
00539 template<typename W, typename M, typename Tm, typename Tw, typename oTw>
00540 rat::exp<Tm, Tw> op_mul(const algebra::Series<W, M>& s,
00541 const W& semiring,
00542 const rat::exp<Tm, Tw>& a,
00543 const oTw& w)
00544 {
00545 rat::exp<Tm, Tw> ret(a);
00546 op_in_mul(s, semiring, ret, w);
00547 return ret;
00548 }
00549
00550 template<typename W, typename M, typename oTw, typename Tm, typename Tw>
00551 rat::exp<Tm, Tw> op_mul(const W& semiring,
00552 const algebra::Series<W, M>& s,
00553 const oTw& w,
00554 const rat::exp<Tm, Tw>& b)
00555 {
00556 precondition(& s.semiring() == & semiring);
00557 (void) s; (void) semiring;
00558
00559 typedef rat::Node<Tm, Tw> node_t;
00560 typedef typename rat::Node<Tm, Tw>::type type;
00561 typedef rat::One<Tm, Tw> n_one_t;
00562 typedef rat::Constant<Tm, Tw> n_const_t;
00563 typedef rat::Zero<Tm, Tw> n_zero_t;
00564 typedef rat::Star<Tm, Tw> n_star_t;
00565 typedef rat::LeftWeighted<Tm, Tw> n_lweight_t;
00566 typedef rat::RightWeighted<Tm, Tw> n_rweight_t;
00567 typedef rat::Sum<Tm, Tw> n_sum_t;
00568 typedef rat::Product<Tm, Tw> n_prod_t;
00569
00570 rat::exp<Tm, Tw> ret(b);
00571
00572 type this_type = ret.base()->what();
00573
00574
00575 if (this_type == node_t::zero)
00576 return ret;
00577
00578
00579
00580
00581 if (w == zero_value(SELECT(W), SELECT(oTw)))
00582 { return rat::exp<Tm, Tw>::zero(); }
00583
00584
00585 if (w == identity_value(SELECT(W), SELECT(oTw)))
00586 return ret;
00587
00589
00590
00591
00592
00593
00594
00595
00596
00597
00598
00599
00600
00601
00602
00603
00604
00605
00606
00607
00608
00609
00610 ret.base() = new n_lweight_t(w, ret.base());
00611 return ret;
00612 }
00613
00614 template<typename W, typename M, typename Tm, typename Tw, typename oTm>
00615 Tw op_series_get(const algebra::Series<W, M>& s,
00616 const rat::exp<Tm, Tw>& p,
00617 const oTm& m)
00618 {
00619 typedef typename standard_of_traits<algebra::Series<W, M>,
00620 rat::exp<Tm, Tw> >::
00621 automaton_t automaton_t;
00622
00623 typename automaton_t::set_t automata (s);
00624 automaton_t a (automata);
00625 standard_of(a, p);
00626 return eval(a, m).value();
00627 }
00628
00629 template<typename W, typename M, typename Tm, typename Tw,
00630 typename oTm, typename oTw>
00631 void op_series_set(const algebra::Series<W, M>& s,
00632 rat::exp<Tm, Tw>& p,
00633 const oTm& m,
00634 const oTw& w)
00635 {
00636 if ((m == algebra::identity_as<oTm>::of(s.monoid())) &&
00637 (w == algebra::identity_as<oTw>::of(s.semiring())) &&
00638 (p == algebra::zero_as<rat::exp<Tm, Tw> >::of(s)))
00639 {
00640 p = algebra::identity_as<rat::exp<Tm, Tw> >::of(s).value();
00641 return ;
00642 }
00643
00644 typedef Element<algebra::Series<W, M>, rat::exp<Tm, Tw> > series_set_elt_t;
00645 typedef typename series_set_elt_t::monoid_elt_t monoid_elt_t;
00646 typedef typename monoid_elt_t::value_t monoid_elt_value_t;
00647 typedef std::list<monoid_elt_value_t> support_t;
00648
00649 rat::exp<Tm, Tw> pp = p;
00650 p = algebra::zero_as<rat::exp<Tm, Tw> >::of(s).value();
00651
00652
00653
00654 support_t supp = op_support(s, pp);
00655 oTw sw;
00656 bool exist = false;
00657 for_all_const_(support_t, e, supp)
00658 {
00659 rat::exp<Tm, Tw> ret =
00660 rat::exp<Tm, Tw>::constant(op_convert(s.monoid(),
00661 SELECT(Tm),
00662 *e));
00663 if (*e == m)
00664 {
00665 exist = true;
00666 sw = w;
00667 }
00668 else
00669 sw = op_series_get(s, pp, *e);
00670 op_in_add(s, p, op_mul(s.semiring(), s, sw, ret));
00671 }
00672 if (!exist)
00673 op_in_add(s, p, op_mul(s.semiring(), s, w,
00674 rat::exp<Tm, Tw>::constant(op_convert(s.monoid(),
00675 SELECT(Tm),
00676 m))));
00677 }
00678
00679 }
00680
00681
00682
00683
00684
00685 template <typename W, typename M, typename Tm, typename Tw>
00686 void
00687 MetaElement<algebra::Series<W, M>, rat::exp<Tm, Tw> >::accept
00688 (const rat::ConstNodeVisitor<Tm, Tw>& v) const
00689 {
00690 this->value().accept(v);
00691 }
00692
00693 template <typename W, typename M, typename Tm, typename Tw>
00694 size_t
00695 MetaElement<algebra::Series<W, M>, rat::exp<Tm, Tw> >::depth() const
00696 {
00697 return this->value().depth();
00698 }
00699
00700 namespace algebra
00701 {
00702 template <class W, class M, class Tm, class Tw>
00703 Element<algebra::Series<W,M>, rat::exp<Tm,Tw> >
00704 op_choose(const algebra::Series<W,M>& s,
00705 SELECTOR2(rat::exp<Tm,Tw>))
00706 {
00707 Element<algebra::Series<W,M>, rat::exp<Tm, Tw> > e(s);
00708
00709 unsigned nb = RAND___(10);
00710 while (nb != 0)
00711 {
00712 --nb;
00713 unsigned t = RAND___(3);
00714 switch (t)
00715 {
00716
00717 case 0 :
00718 {
00719 e = e.star();
00720 continue;
00721 }
00722
00723 case 1 :
00724 {
00725 Element<algebra::Series<W,M>, rat::exp<Tm,Tw> >
00726 ep(s, s.monoid().choose(SELECT(Tm)));
00727 ep = ep * s.semiring().choose(SELECT(Tw));
00728 unsigned t = RAND___(2);
00729 if (t < 1)
00730 e = e + ep;
00731 else
00732 e = ep + e;
00733 continue;
00734 }
00735
00736 case 2 :
00737 {
00738 Element<algebra::Series<W,M>, rat::exp<Tm,Tw> >
00739 ep(s, s.monoid().choose(SELECT(Tm)));
00740 ep = ep * s.semiring().choose(SELECT(Tw));
00741 unsigned t = RAND___(2);
00742 if (t < 1)
00743 e = e * ep;
00744 else
00745 e = ep * e;
00746 continue;
00747 }
00748 }
00749 }
00750 return Element<algebra::Series<W,M>, rat::exp<Tm,Tw> >(s, e);
00751 }
00752
00753 }
00754
00755 }
00756
00757 #endif // ! VCSN_ALGEBRA_IMPLEMENTATION_SERIES_KRAT_HXX