A better return_type_tinfo() mechanism.
authorAlexei Sheplyakov <varg@theor.jinr.ru>
Fri, 17 Oct 2008 09:15:03 +0000 (13:15 +0400)
committerAlexei Sheplyakov <varg@theor.jinr.ru>
Sun, 19 Oct 2008 17:29:11 +0000 (21:29 +0400)
return_type_tinfo() is used in order to distingish between non-commutative
objects of different type. However, often it's necessary to distingish
between non-commutative objects of the same type, for example, between
gamma matrices with different representation label. return_type_tinfo()
does not provide any clean way to do that. Hence, introduce return_type_t
type which holds representation label along with type information, and
use it for return_type_tinfo().

25 files changed:
ginac/add.cpp
ginac/add.h
ginac/basic.cpp
ginac/basic.h
ginac/clifford.cpp
ginac/clifford.h
ginac/color.cpp
ginac/color.h
ginac/ex.h
ginac/function.pl
ginac/indexed.h
ginac/integral.cpp
ginac/integral.h
ginac/mul.cpp
ginac/mul.h
ginac/ncmul.cpp
ginac/ncmul.h
ginac/power.cpp
ginac/power.h
ginac/registrar.h
ginac/relational.cpp
ginac/relational.h
ginac/structure.h
ginac/symbol.cpp
ginac/symbol.h

index 2fa73dc..547bee3 100644 (file)
@@ -498,10 +498,10 @@ unsigned add::return_type() const
                return seq.begin()->rest.return_type();
 }
 
-tinfo_t add::return_type_tinfo() const
+return_type_t add::return_type_tinfo() const
 {
        if (seq.empty())
-               return this;
+               return make_return_type_t<add>();
        else
                return seq.begin()->rest.return_type_tinfo();
 }
index 18f4351..d96e126 100644 (file)
@@ -65,7 +65,7 @@ public:
 protected:
        ex derivative(const symbol & s) const;
        unsigned return_type() const;
-       tinfo_t return_type_tinfo() const;
+       return_type_t return_type_tinfo() const;
        ex thisexpairseq(const epvector & v, const ex & oc, bool do_index_renaming = false) const;
        ex thisexpairseq(std::auto_ptr<epvector> vp, const ex & oc, bool do_index_renaming = false) const;
        expair split_ex_to_pair(const ex & e) const;
index fa6e1d9..567760c 100644 (file)
@@ -774,9 +774,12 @@ unsigned basic::return_type() const
        return return_types::commutative;
 }
 
-tinfo_t basic::return_type_tinfo() const
+return_type_t basic::return_type_tinfo() const
 {
-       return tinfo_key;
+       return_type_t rt;
+       rt.tinfo = &typeid(*this);
+       rt.rl = 0;
+       return rt;
 }
 
 /** Compute the hash value of an object and if it makes sense to store it in
index 304adcf..3685fb5 100644 (file)
@@ -216,7 +216,7 @@ public:
 
        // noncommutativity
        virtual unsigned return_type() const;
-       virtual tinfo_t return_type_tinfo() const;
+       virtual return_type_t return_type_tinfo() const;
 
        // functions for complex expressions
        virtual ex conjugate() const;
index c76fff2..e660037 100644 (file)
@@ -46,8 +46,6 @@ GINAC_IMPLEMENT_REGISTERED_CLASS_OPT(clifford, indexed,
   print_func<print_dflt>(&clifford::do_print_dflt).
   print_func<print_latex>(&clifford::do_print_latex))
 
-const tinfo_static_t clifford::return_type_tinfo_static[256] = {{}};
-
 GINAC_IMPLEMENT_REGISTERED_CLASS_OPT(diracone, tensor,
   print_func<print_dflt>(&diracone::do_print).
   print_func<print_latex>(&diracone::do_print_latex))
@@ -120,6 +118,11 @@ clifford::clifford(unsigned char rl, const ex & metr, int comm_sign, std::auto_p
        tinfo_key = &clifford::tinfo_static;
 }
 
+return_type_t clifford::return_type_tinfo() const
+{
+       return make_return_type_t<clifford>(representation_label);
+}
+
 //////////
 // archiving
 //////////
@@ -811,19 +814,11 @@ ex dirac_slash(const ex & e, const ex & dim, unsigned char rl)
    return clifford(e, varidx(0, dim), indexed((new minkmetric)->setflag(status_flags::dynallocated), symmetric2(), xi, chi), rl);
 }
 
-/** Check whether a given tinfo key (as returned by return_type_tinfo()
- *  is that of a clifford object (with an arbitrary representation label). */
-bool is_clifford_tinfo(tinfo_t ti)
-{
-       p_int start_loc=(p_int)&clifford::return_type_tinfo_static;
-       return (p_int)ti>=start_loc && (p_int)ti<start_loc+256;
-}
-
 /** Extract representation label from tinfo key (as returned by
  *  return_type_tinfo()). */
-static unsigned char get_representation_label(tinfo_t ti)
+static unsigned char get_representation_label(const return_type_t& ti)
 {
-       return (unsigned char)((p_int)ti-(p_int)&clifford::return_type_tinfo_static);
+       return (unsigned char)ti.rl;
 }
 
 /** Take trace of a string of an even number of Dirac gammas given a vector
index 62aabce..59b49d0 100644 (file)
@@ -41,9 +41,6 @@ namespace GiNaC {
 class clifford : public indexed
 {
        GINAC_DECLARE_REGISTERED_CLASS(clifford, indexed)
-public:
-       static const tinfo_static_t return_type_tinfo_static[256];
-
        // other constructors
 public:
        clifford(const ex & b, unsigned char rl = 0);
@@ -62,8 +59,7 @@ protected:
        ex thiscontainer(const exvector & v) const;
        ex thiscontainer(std::auto_ptr<exvector> vp) const;
        unsigned return_type() const { return return_types::noncommutative; }
-       tinfo_t return_type_tinfo() const { return clifford::return_type_tinfo_static+representation_label; }
-
+       return_type_t return_type_tinfo() const;
        // non-virtual functions in this class
 public:
        unsigned char get_representation_label() const { return representation_label; }
@@ -186,11 +182,14 @@ protected:
 
 // global functions
 
-/** Check whether a given tinfo key (as returned by return_type_tinfo()
+/** Check whether a given return_type_t object (as returned by return_type_tinfo()
   * is that of a clifford object (with an arbitrary representation label).
   *
   * @param ti tinfo key */
-bool is_clifford_tinfo(tinfo_t ti);
+inline bool is_clifford_tinfo(const return_type_t& ti)
+{
+       return *(ti.tinfo) == typeid(clifford);
+}
 
 /** Create a Clifford unity object.
  *
index b70298b..4376863 100644 (file)
@@ -39,8 +39,6 @@ namespace GiNaC {
 
 GINAC_IMPLEMENT_REGISTERED_CLASS(color, indexed)
 
-const tinfo_static_t color::return_type_tinfo_static[256] = {{}};
-
 GINAC_IMPLEMENT_REGISTERED_CLASS_OPT(su3one, tensor,
   print_func<print_dflt>(&su3one::do_print).
   print_func<print_latex>(&su3one::do_print_latex))
@@ -101,6 +99,11 @@ color::color(unsigned char rl, std::auto_ptr<exvector> vp) : inherited(not_symme
        tinfo_key = &color::tinfo_static;
 }
 
+return_type_t color::return_type_tinfo() const
+{
+       return make_return_type_t<color>(representation_label);
+}
+
 //////////
 // archiving
 //////////
@@ -524,17 +527,16 @@ ex color_h(const ex & a, const ex & b, const ex & c)
 
 /** Check whether a given tinfo key (as returned by return_type_tinfo()
  *  is that of a color object (with an arbitrary representation label). */
-static bool is_color_tinfo(tinfo_t ti)
+static bool is_color_tinfo(const return_type_t& ti)
 {
-       p_int start_loc=(p_int)&color::return_type_tinfo_static;
-       return (p_int)ti>=start_loc && (p_int)ti<start_loc+256;
+       return *(ti.tinfo) == typeid(color);
 }
 
 /** Extract representation label from tinfo key (as returned by
  *  return_type_tinfo()). */
-static unsigned char get_representation_label(tinfo_t ti)
+static unsigned char get_representation_label(const return_type_t& ti)
 {
-       return (unsigned char)((p_int)ti-(p_int)&color::return_type_tinfo_static);
+       return (unsigned char)ti.rl;
 }
 
 ex color_trace(const ex & e, const std::set<unsigned char> & rls)
index ebe2122..360223e 100644 (file)
@@ -41,9 +41,6 @@ namespace GiNaC {
 class color : public indexed
 {
        GINAC_DECLARE_REGISTERED_CLASS(color, indexed)
-public:
-       static const tinfo_static_t return_type_tinfo_static[256];
-
        // other constructors
 public:
        color(const ex & b, unsigned char rl = 0);
@@ -60,7 +57,7 @@ protected:
        ex thiscontainer(const exvector & v) const;
        ex thiscontainer(std::auto_ptr<exvector> vp) const;
        unsigned return_type() const { return return_types::noncommutative; }
-       tinfo_t return_type_tinfo() const { return color::return_type_tinfo_static+representation_label; }
+       return_type_t return_type_tinfo() const;
 
        // non-virtual functions in this class
 public:
index 4a603ce..60d4080 100644 (file)
@@ -217,7 +217,7 @@ public:
 
        // noncommutativity
        unsigned return_type() const { return bp->return_type(); }
-       tinfo_t return_type_tinfo() const { return bp->return_type_tinfo(); }
+       return_type_t return_type_tinfo() const { return bp->return_type_tinfo(); }
 
        unsigned gethash() const { return bp->gethash(); }
 
index b478023..88be68d 100644 (file)
@@ -410,7 +410,7 @@ $print_func_interface
                return *this;
        }
 
-       function_options & set_return_type(unsigned rt, tinfo_t rtt=NULL);
+       function_options & set_return_type(unsigned rt, const return_type_t* rtt = 0);
        function_options & do_not_evalf_params();
        function_options & remember(unsigned size, unsigned assoc_size=0,
                                    unsigned strategy=remember_strategies::delete_never);
@@ -445,7 +445,7 @@ protected:
 
        bool use_return_type;
        unsigned return_type;
-       tinfo_t return_type_tinfo;
+       return_type_t return_type_tinfo;
 
        bool use_remember;
        unsigned remember_size;
@@ -520,7 +520,7 @@ protected:
        bool is_equal_same_type(const basic & other) const;
        bool match_same_type(const basic & other) const;
        unsigned return_type() const;
-       tinfo_t return_type_tinfo() const;
+       return_type_t return_type_tinfo() const;
        
        // new virtual functions which can be overridden by derived classes
        // none
@@ -739,11 +739,14 @@ function_options& function_options::series_func(series_funcp_exvector s)
        return *this;
 }
 
-function_options & function_options::set_return_type(unsigned rt, tinfo_t rtt)
+function_options & function_options::set_return_type(unsigned rt, const return_type_t* rtt)
 {
        use_return_type = true;
        return_type = rt;
-       return_type_tinfo = rtt;
+       if (rtt != 0)
+               return_type_tinfo = *rtt;
+       else
+               return_type_tinfo = make_return_type_t<function>();
        return *this;
 }
 
@@ -1258,7 +1261,7 @@ unsigned function::return_type() const
        }
 }
 
-tinfo_t function::return_type_tinfo() const
+return_type_t function::return_type_tinfo() const
 {
        GINAC_ASSERT(serial<registered_functions().size());
        const function_options &opt = registered_functions()[serial];
@@ -1270,7 +1273,7 @@ tinfo_t function::return_type_tinfo() const
                // Default behavior is to use the return type of the first
                // argument. Thus, exp() of a matrix behaves like a matrix, etc.
                if (seq.empty())
-                       return this;
+                       return make_return_type_t<function>();
                else
                        return seq.begin()->return_type_tinfo();
        }
index 3c8951a..82a45c3 100644 (file)
@@ -156,7 +156,7 @@ protected:
        ex thiscontainer(const exvector & v) const;
        ex thiscontainer(std::auto_ptr<exvector> vp) const;
        unsigned return_type() const;
-       tinfo_t return_type_tinfo() const { return op(0).return_type_tinfo(); }
+       return_type_t return_type_tinfo() const { return op(0).return_type_tinfo(); }
        ex expand(unsigned options = 0) const;
 
        // new virtual functions which can be overridden by derived classes
index 2a33208..2200475 100644 (file)
@@ -436,7 +436,7 @@ unsigned integral::return_type() const
        return f.return_type();
 }
 
-tinfo_t integral::return_type_tinfo() const
+return_type_t integral::return_type_tinfo() const
 {
        return f.return_type_tinfo();
 }
index c85a682..e2843c8 100644 (file)
@@ -51,7 +51,7 @@ public:
        ex expand(unsigned options = 0) const;
        exvector get_free_indices() const;
        unsigned return_type() const;
-       tinfo_t return_type_tinfo() const;
+       return_type_t return_type_tinfo() const;
        ex conjugate() const;
        ex eval_integ() const;
 protected:
index 63f92e1..96b965d 100644 (file)
@@ -855,10 +855,10 @@ unsigned mul::return_type() const
        return all_commutative ? return_types::commutative : return_types::noncommutative;
 }
    
-tinfo_t mul::return_type_tinfo() const
+return_type_t mul::return_type_tinfo() const
 {
        if (seq.empty())
-               return this;  // mul without factors: should not happen
+               return make_return_type_t<mul>(); // mul without factors: should not happen
        
        // return type_info of first noncommutative element
        epvector::const_iterator i = seq.begin(), end = seq.end();
@@ -868,7 +868,7 @@ tinfo_t mul::return_type_tinfo() const
                ++i;
        }
        // no noncommutative element found, should not happen
-       return this;
+       return make_return_type_t<mul>();
 }
 
 ex mul::thisexpairseq(const epvector & v, const ex & oc, bool do_index_renaming) const
index 20faf6a..a11b29b 100644 (file)
@@ -68,7 +68,7 @@ protected:
        ex derivative(const symbol & s) const;
        ex eval_ncmul(const exvector & v) const;
        unsigned return_type() const;
-       tinfo_t return_type_tinfo() const;
+       return_type_t return_type_tinfo() const;
        ex thisexpairseq(const epvector & v, const ex & oc, bool do_index_renaming = false) const;
        ex thisexpairseq(std::auto_ptr<epvector> vp, const ex & oc, bool do_index_renaming = false) const;
        expair split_ex_to_pair(const ex & e) const;
index a5969f3..e0bc7de 100644 (file)
@@ -401,13 +401,13 @@ ex ncmul::eval(int level) const
 
                size_t assoc_num = assocseq.size();
                exvectorvector evv;
-               std::vector<tinfo_t> rttinfos;
+               std::vector<return_type_t> rttinfos;
                evv.reserve(assoc_num);
                rttinfos.reserve(assoc_num);
 
                cit = assocseq.begin(), citend = assocseq.end();
                while (cit != citend) {
-                       tinfo_t ti = cit->return_type_tinfo();
+                       return_type_t ti = cit->return_type_tinfo();
                        size_t rtt_num = rttinfos.size();
                        // search type in vector of known types
                        for (i=0; i<rtt_num; ++i) {
@@ -578,10 +578,10 @@ unsigned ncmul::return_type() const
        return all_commutative ? return_types::commutative : return_types::noncommutative;
 }
    
-tinfo_t ncmul::return_type_tinfo() const
+return_type_t ncmul::return_type_tinfo() const
 {
        if (seq.empty())
-               return this;
+               return make_return_type_t<ncmul>();
 
        // return type_info of first noncommutative element
        exvector::const_iterator i = seq.begin(), end = seq.end();
@@ -592,7 +592,7 @@ tinfo_t ncmul::return_type_tinfo() const
        }
 
        // no noncommutative element found, should not happen
-       return this;
+       return make_return_type_t<ncmul>();
 }
 
 //////////
index 7b21cf8..9101427 100644 (file)
@@ -71,7 +71,7 @@ public:
 protected:
        ex derivative(const symbol & s) const;
        unsigned return_type() const;
-       tinfo_t return_type_tinfo() const;
+       return_type_t return_type_tinfo() const;
        
        // new virtual functions which can be overridden by derived classes
        // none
index a4a33c5..ca7fea5 100644 (file)
@@ -769,7 +769,7 @@ unsigned power::return_type() const
        return basis.return_type();
 }
 
-tinfo_t power::return_type_tinfo() const
+return_type_t power::return_type_tinfo() const
 {
        return basis.return_type_tinfo();
 }
index 5c59ee7..a13f7fc 100644 (file)
@@ -74,7 +74,7 @@ protected:
        ex derivative(const symbol & s) const;
        ex eval_ncmul(const exvector & v) const;
        unsigned return_type() const;
-       tinfo_t return_type_tinfo() const;
+       return_type_t return_type_tinfo() const;
        ex expand(unsigned options = 0) const;
        
        // new virtual functions which can be overridden by derived classes
index d1f4a5c..d8a64db 100644 (file)
@@ -38,6 +38,43 @@ class archive_node;
 template <template <class T, class = std::allocator<T> > class> class container;
 typedef container<std::list> lst;
 
+/** To distinguish between different kinds of non-commutative objects */
+struct return_type_t
+{
+       /// to distinguish between non-commutative objects of different type.
+       std::type_info const* tinfo; 
+       /// to distinguish between non-commutative objects of the same type.
+       /// Think of gamma matrices with different represenation labels.
+       unsigned rl;
+
+       /// Strict weak ordering (so one can put return_type_t's into
+       /// a STL container).
+       inline bool operator<(const return_type_t& other) const
+       {
+               if (tinfo->before(*other.tinfo))
+                       return true;
+               return rl < other.rl;
+       }
+       inline bool operator==(const return_type_t& other) const
+       {
+               if (*tinfo != *(other.tinfo))
+                       return false;
+               return rl == other.rl;
+       }
+       inline bool operator!=(const return_type_t& other) const
+       {
+               return ! (operator==(other));
+       }
+};
+
+template<typename T> inline return_type_t make_return_type_t(const unsigned rl = 0)
+{
+       return_type_t ret;
+       ret.rl = rl;
+       ret.tinfo = &typeid(T);
+       return ret;
+}
+
 /** Definitions for the tinfo mechanism. */
 typedef const void * tinfo_t;
 struct tinfo_static_t {};
index 2f19d21..f3329f9 100644 (file)
@@ -250,7 +250,7 @@ unsigned relational::return_type() const
        return lh.return_type();
 }
    
-tinfo_t relational::return_type_tinfo() const
+return_type_t relational::return_type_tinfo() const
 {
        GINAC_ASSERT(lh.return_type_tinfo()==rh.return_type_tinfo());
        return lh.return_type_tinfo();
index 20e720d..91cf519 100644 (file)
@@ -63,7 +63,7 @@ protected:
        ex eval_ncmul(const exvector & v) const;
        bool match_same_type(const basic & other) const;
        unsigned return_type() const;
-       tinfo_t return_type_tinfo() const;
+       return_type_t return_type_tinfo() const;
        unsigned calchash() const;
 
        // new virtual functions which can be overridden by derived classes
index d00100b..cfd17c9 100644 (file)
@@ -200,7 +200,13 @@ public:
 
        // noncommutativity
        unsigned return_type() const { return return_types::commutative; }
-       tinfo_t return_type_tinfo() const { return this; }
+       return_type_t return_type_tinfo() const 
+       {
+               return_type_t r;
+               r.rl = 0;
+               r.tinfo = &typeid(*this);
+               return r;
+       }
 
 protected:
        bool is_equal_same_type(const basic & other) const
index f233d84..0bdebc0 100644 (file)
@@ -45,7 +45,7 @@ GINAC_IMPLEMENT_REGISTERED_CLASS_OPT(symbol, basic,
 // symbol
 
 symbol::symbol()
- : inherited(&symbol::tinfo_static), serial(next_serial++), name(autoname_prefix() + ToString(serial)), TeX_name(name), domain(domain::complex), ret_type(return_types::commutative), ret_type_tinfo(&symbol::tinfo_static)
+ : inherited(&symbol::tinfo_static), serial(next_serial++), name(autoname_prefix() + ToString(serial)), TeX_name(name), domain(domain::complex), ret_type(return_types::commutative), ret_type_tinfo(make_return_type_t<symbol>())
 {
        setflag(status_flags::evaluated | status_flags::expanded);
 }
@@ -73,24 +73,24 @@ possymbol::possymbol()
 // symbol
 
 symbol::symbol(const std::string & initname, unsigned domain)
- : inherited(&symbol::tinfo_static), serial(next_serial++), name(initname), TeX_name(default_TeX_name()), domain(domain), ret_type(return_types::commutative), ret_type_tinfo(&symbol::tinfo_static)
+ : inherited(&symbol::tinfo_static), serial(next_serial++), name(initname), TeX_name(default_TeX_name()), domain(domain), ret_type(return_types::commutative), ret_type_tinfo(make_return_type_t<symbol>())
 {
        setflag(status_flags::evaluated | status_flags::expanded);
 }
 
-symbol::symbol(const std::string & initname, unsigned rt, tinfo_t rtt, unsigned domain)
+symbol::symbol(const std::string & initname, unsigned rt, const return_type_t& rtt, unsigned domain)
  : inherited(&symbol::tinfo_static), serial(next_serial++), name(initname), TeX_name(default_TeX_name()), domain(domain), ret_type(rt), ret_type_tinfo(rtt)
 {
        setflag(status_flags::evaluated | status_flags::expanded);
 }
 
 symbol::symbol(const std::string & initname, const std::string & texname, unsigned domain)
- : inherited(&symbol::tinfo_static), serial(next_serial++), name(initname), TeX_name(texname), domain(domain), ret_type(return_types::commutative), ret_type_tinfo(&symbol::tinfo_static)
+ : inherited(&symbol::tinfo_static), serial(next_serial++), name(initname), TeX_name(texname), domain(domain), ret_type(return_types::commutative), ret_type_tinfo(make_return_type_t<symbol>())
 {
        setflag(status_flags::evaluated | status_flags::expanded);
 }
 
-symbol::symbol(const std::string & initname, const std::string & texname, unsigned rt, tinfo_t rtt, unsigned domain)
+symbol::symbol(const std::string & initname, const std::string & texname, unsigned rt, const return_type_t& rtt, unsigned domain)
  : inherited(&symbol::tinfo_static),  serial(next_serial++), name(initname), TeX_name(texname), domain(domain), ret_type(rt), ret_type_tinfo(rtt)
 {
        setflag(status_flags::evaluated | status_flags::expanded);
@@ -104,10 +104,10 @@ realsymbol::realsymbol(const std::string & initname, unsigned domain)
 realsymbol::realsymbol(const std::string & initname, const std::string & texname, unsigned domain)
  : symbol(initname, texname, domain) { }
 
-realsymbol::realsymbol(const std::string & initname, unsigned rt, tinfo_t rtt, unsigned domain)
+realsymbol::realsymbol(const std::string & initname, unsigned rt, const return_type_t& rtt, unsigned domain)
  : symbol(initname, rt, rtt, domain) { }
 
-realsymbol::realsymbol(const std::string & initname, const std::string & texname, unsigned rt, tinfo_t rtt, unsigned domain)
+realsymbol::realsymbol(const std::string & initname, const std::string & texname, unsigned rt, const return_type_t& rtt, unsigned domain)
  : symbol(initname, texname, rt, rtt, domain) { }
 
 // possymbol
@@ -118,10 +118,10 @@ possymbol::possymbol(const std::string & initname, unsigned domain)
 possymbol::possymbol(const std::string & initname, const std::string & texname, unsigned domain)
  : symbol(initname, texname, domain) { }
 
-possymbol::possymbol(const std::string & initname, unsigned rt, tinfo_t rtt, unsigned domain)
+possymbol::possymbol(const std::string & initname, unsigned rt, const return_type_t& rtt, unsigned domain)
  : symbol(initname, rt, rtt, domain) { }
 
-possymbol::possymbol(const std::string & initname, const std::string & texname, unsigned rt, tinfo_t rtt, unsigned domain)
+possymbol::possymbol(const std::string & initname, const std::string & texname, unsigned rt, const return_type_t& rtt, unsigned domain)
  : symbol(initname, texname, rt, rtt, domain) { }
 
 //////////
index 3caa24e..00d4b90 100644 (file)
@@ -47,8 +47,8 @@ public:
        explicit symbol(const std::string & initname, unsigned domain = domain::complex);
        symbol(const std::string & initname, const std::string & texname, unsigned domain = domain::complex);
        symbol(const std::string & initname, const std::string & texname, unsigned rt, unsigned domain);
-       symbol(const std::string & initname, unsigned rt, tinfo_t rtt, unsigned domain = domain::complex);
-       symbol(const std::string & initname, const std::string & texname, unsigned rt, tinfo_t rtt, unsigned domain = domain::complex);
+       symbol(const std::string & initname, unsigned rt, const return_type_t& rtt, unsigned domain = domain::complex);
+       symbol(const std::string & initname, const std::string & texname, unsigned rt, const return_type_t& rtt, unsigned domain = domain::complex);
        
        // functions overriding virtual functions from base classes
 public:
@@ -61,7 +61,7 @@ public:
        ex to_rational(exmap & repl) const;
        ex to_polynomial(exmap & repl) const;
        unsigned return_type() const { return ret_type; }
-       tinfo_t return_type_tinfo() const { return ret_type_tinfo; }
+       return_type_t return_type_tinfo() const { return ret_type_tinfo; }
        ex conjugate() const;
        ex real_part() const;
        ex imag_part() const;
@@ -93,7 +93,7 @@ protected:
        std::string TeX_name;            ///< LaTeX name of this symbol
        unsigned domain;                 ///< domain of symbol, complex (default) or real
        unsigned ret_type;               ///< value returned by return_type()
-       tinfo_t ret_type_tinfo;         ///< value returned by return_type_tinfo()
+       return_type_t ret_type_tinfo;         ///< value returned by return_type_tinfo()
 private:
        static unsigned next_serial;
 };
@@ -107,8 +107,8 @@ public:
        realsymbol();
        explicit realsymbol(const std::string & initname, unsigned domain = domain::real);
        realsymbol(const std::string & initname, const std::string & texname, unsigned domain = domain::real);
-       realsymbol(const std::string & initname, unsigned rt, tinfo_t rtt, unsigned domain = domain::real);
-       realsymbol(const std::string & initname, const std::string & texname, unsigned rt, tinfo_t rtt, unsigned domain = domain::real);
+       realsymbol(const std::string & initname, unsigned rt, const return_type_t& rtt, unsigned domain = domain::real);
+       realsymbol(const std::string & initname, const std::string & texname, unsigned rt, const return_type_t& rtt, unsigned domain = domain::real);
 };
 
 
@@ -120,8 +120,8 @@ public:
        possymbol();
        explicit possymbol(const std::string & initname, unsigned domain = domain::positive);
        possymbol(const std::string & initname, const std::string & texname, unsigned domain = domain::positive);
-       possymbol(const std::string & initname, unsigned rt, tinfo_t rtt, unsigned domain = domain::positive);
-       possymbol(const std::string & initname, const std::string & texname, unsigned rt, tinfo_t rtt, unsigned domain = domain::positive);
+       possymbol(const std::string & initname, unsigned rt, const return_type_t& rtt, unsigned domain = domain::positive);
+       possymbol(const std::string & initname, const std::string & texname, unsigned rt, const return_type_t& rtt, unsigned domain = domain::positive);
 };