Vaucanson: numerical_semiring.hh Source File

00001 // numerical_semiring.hh: this file is part of the Vaucanson project.
00002 //
00003 // Vaucanson, a generic library for finite state machines.
00004 //
00005 // Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007 The Vaucanson Group.
00006 //
00007 // This program is free software; you can redistribute it and/or
00008 // modify it under the terms of the GNU General Public License
00009 // as published by the Free Software Foundation; either version 2
00010 // of the License, or (at your option) any later version.
00011 //
00012 // The complete GNU General Public Licence Notice can be found as the
00013 // `COPYING' file in the root directory.
00014 //
00015 // The Vaucanson Group consists of people listed in the `AUTHORS' file.
00016 //
00017 #ifndef VCSN_ALGEBRA_IMPLEMENTATION_SEMIRING_NUMERICAL_SEMIRING_HH
00018 # define VCSN_ALGEBRA_IMPLEMENTATION_SEMIRING_NUMERICAL_SEMIRING_HH
00019 
00020 # include <vaucanson/algebra/concept/numerical_semiring.hh>
00021 # include <vaucanson/algebra/implementation/semiring/rational_number.hh>
00022 
00023 namespace vcsn {
00024 
00025   namespace algebra {
00026 
00027     template<typename T>
00028     bool op_contains(const algebra::NumericalSemiring& s, T c);
00029 
00030     template<typename T, typename U>
00031     void op_in_mul(const algebra::NumericalSemiring& s1, T& dst, U arg);
00032 
00033     template<typename T, typename U>
00034     void op_in_add(const algebra::NumericalSemiring& s1, T& dst, U arg);
00035 
00036     template<typename T, typename U>
00037     T op_mul(const algebra::NumericalSemiring& s, T a, U b);
00038 
00039     template<typename T, typename U>
00040     T op_add(const algebra::NumericalSemiring& s, T a, U b);
00041 
00042     template<typename T>
00043     T identity_value(SELECTOR(algebra::NumericalSemiring), SELECTOR(T));
00044 
00045     template<typename T>
00046     T zero_value(SELECTOR(algebra::NumericalSemiring), SELECTOR(T));
00047 
00048     template <class T>
00049     Element<algebra::NumericalSemiring, T>
00050     op_choose(const algebra::NumericalSemiring& s, SELECTOR(T));
00051 
00052     /*-----------------------------.
00053     | specializations for integers |
00054     `-----------------------------*/
00055 
00056     bool
00057     op_can_choose_non_starable(const algebra::NumericalSemiring& set,
00058                                SELECTOR(int));
00059 
00060     Element<algebra::NumericalSemiring, int>
00061     op_choose_starable(const algebra::NumericalSemiring& set, SELECTOR(int));
00062 
00063     Element<algebra::NumericalSemiring, int>
00064     op_choose_non_starable(const algebra::NumericalSemiring& set,
00065                            SELECTOR(int));
00066 
00067     /*-----------------------------.
00068     | specializations for Booleans |
00069     `-----------------------------*/
00070     template<typename T>
00071     void op_in_mul(const algebra::NumericalSemiring& s1,
00072                           bool& dst, bool src);
00073 
00074     inline bool op_mul(const algebra::NumericalSemiring& s, bool a, bool b);
00075 
00076     inline void op_in_add(const algebra::NumericalSemiring& s1,
00077                           bool& dst, bool src);
00078 
00079     inline bool op_add(const algebra::NumericalSemiring& s, bool a, bool b);
00080 
00081     inline bool identity_value(SELECTOR(algebra::NumericalSemiring),
00082                                SELECTOR(bool));
00083 
00084     inline bool zero_value(SELECTOR(algebra::NumericalSemiring),
00085                            SELECTOR(bool));
00086 
00087     inline bool op_starable(const algebra::NumericalSemiring& s, bool b);
00088 
00089     inline void op_in_star(const algebra::NumericalSemiring& s, bool& b);
00090 
00091     Element<algebra::NumericalSemiring, bool>
00092     op_choose_starable(const algebra::NumericalSemiring& set, SELECTOR(bool));
00093 
00094     Element<algebra::NumericalSemiring, bool>
00095     op_choose_non_starable(const algebra::NumericalSemiring& set,
00096                            SELECTOR(bool));
00097 
00098     /*-------------------------.
00099     | goodies for real numbers |
00100     `-------------------------*/
00101     template<typename T>
00102     bool op_starable(const algebra::NumericalSemiring& s, T v);
00103 
00104     inline bool op_starable(const algebra::NumericalSemiring& s,
00105                             const float& f);
00106 
00107     inline bool op_starable(const algebra::NumericalSemiring& s,
00108                             const double& f);
00109 
00110     inline void op_in_star(const algebra::NumericalSemiring& s, float& f);
00111 
00112     inline void op_in_star(const algebra::NumericalSemiring& s, double& f);
00113 
00114     bool
00115     op_can_choose_non_starable(const algebra::NumericalSemiring& set,
00116                                 SELECTOR(float));
00117 
00118     Element<algebra::NumericalSemiring, float>
00119     op_choose_starable(const algebra::NumericalSemiring& set,
00120                        SELECTOR(float));
00121 
00122     Element<algebra::NumericalSemiring, float>
00123     op_choose_non_starable(const algebra::NumericalSemiring& set,
00124                            SELECTOR(float));
00125 
00126     bool
00127     op_can_choose_non_starable(const algebra::NumericalSemiring& set,
00128                                 SELECTOR(double));
00129 
00130     Element<algebra::NumericalSemiring, double>
00131     op_choose_starable(const algebra::NumericalSemiring& set,
00132                        SELECTOR(double));
00133 
00134     Element<algebra::NumericalSemiring, double>
00135     op_choose_non_starable(const algebra::NumericalSemiring& set,
00136                            SELECTOR(double));
00137 
00138     /*-------------------------------------.
00139     | specializations for rational numbers |
00140     `-------------------------------------*/
00141 
00142     inline algebra::RationalNumber
00143     identity_value(SELECTOR(algebra::NumericalSemiring),
00144                    SELECTOR(algebra::RationalNumber));
00145 
00146     inline algebra::RationalNumber
00147     zero_value(SELECTOR(algebra::NumericalSemiring),
00148                SELECTOR(algebra::RationalNumber));
00149 
00150     template<typename T>
00151     bool op_starable(const algebra::NumericalSemiring& s, T v);
00152 
00153     inline bool op_starable(const algebra::NumericalSemiring& s,
00154                             const algebra::RationalNumber& r);
00155 
00156     inline void op_in_star(const algebra::NumericalSemiring& s,
00157                            algebra::RationalNumber& r);
00158 
00159     bool
00160     op_can_choose_non_starable(const algebra::NumericalSemiring& set,
00161                                SELECTOR(algebra::RationalNumber));
00162 
00163     Element<algebra::NumericalSemiring, algebra::RationalNumber>
00164     op_choose_starable(const algebra::NumericalSemiring& set,
00165                        SELECTOR(algebra::RationalNumber));
00166 
00167     Element<algebra::NumericalSemiring, algebra::RationalNumber>
00168     op_choose_non_starable(const algebra::NumericalSemiring& set,
00169                            SELECTOR(algebra::RationalNumber));
00170 
00171   } // algebra
00172 
00173 } // vcsn
00174 
00175 
00176 # if !defined VCSN_USE_INTERFACE_ONLY || defined VCSN_USE_LIB
00177 # include <vaucanson/algebra/implementation/semiring/numerical_semiring.hxx>
00178 #endif // VCSN_USE_INTERFACE_ONLY
00179 
00180 
00181 #endif // ! VCSN_ALGEBRA_IMPLEMENTATION_SEMIRING_NUMERICAL_SEMIRING_HH