Univariate Hensel lifting now uses upoly.

[ginac.git] / ginac / function.pl

diff --git a/ginac/function.pl b/ginac/function.pl
index 7a4d5e78cbc25fb4431f7807f9b424cd9bb6edd0..3ac3c3cab9e23549b35696f951dd3e307d0df278 100644 (file)
--- a/ginac/function.pl
+++ b/ginac/function.pl
@@ -138,7 +138,6 @@ $constructors_implementation=generate(
 function::function(unsigned ser, ${SEQ1})
        : exprseq(${SEQ2}), serial(ser)
 {
-       tinfo_key = &function::tinfo_static;
 }
 END_OF_CONSTRUCTORS_IMPLEMENTATION
 
@@ -410,7 +409,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 +444,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;
@@ -515,12 +514,14 @@ public:
        ex conjugate() const;
        ex real_part() const;
        ex imag_part() const;
+       void archive(archive_node& n) const;
+       void read_archive(const archive_node& n, lst& syms);
 protected:
        ex derivative(const symbol & s) const;
        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
@@ -544,6 +545,7 @@ public:
 protected:
        unsigned serial;
 };
+GINAC_DECLARE_UNARCHIVER(function);
 
 // utility functions/macros
 
@@ -739,11 +741,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;
 }
 
@@ -811,7 +816,6 @@ GINAC_IMPLEMENT_REGISTERED_CLASS(function, exprseq)
 
 function::function() : serial(0)
 {
-       tinfo_key = &function::tinfo_static;
 }
 
 //////////
@@ -822,7 +826,6 @@ function::function() : serial(0)
 
 function::function(unsigned ser) : serial(ser)
 {
-       tinfo_key = &function::tinfo_static;
 }
 
 // the following lines have been generated for max. ${maxargs} parameters
@@ -831,7 +834,6 @@ $constructors_implementation
 
 function::function(unsigned ser, const exprseq & es) : exprseq(es), serial(ser)
 {
-       tinfo_key = &function::tinfo_static;
 
        // Force re-evaluation even if the exprseq was already evaluated
        // (the exprseq copy constructor copies the flags)
@@ -841,13 +843,11 @@ function::function(unsigned ser, const exprseq & es) : exprseq(es), serial(ser)
 function::function(unsigned ser, const exvector & v, bool discardable) 
   : exprseq(v,discardable), serial(ser)
 {
-       tinfo_key = &function::tinfo_static;
 }
 
 function::function(unsigned ser, std::auto_ptr<exvector> vp) 
   : exprseq(vp), serial(ser)
 {
-       tinfo_key = &function::tinfo_static;
 }
 
 //////////
@@ -855,8 +855,9 @@ function::function(unsigned ser, std::auto_ptr<exvector> vp)
 //////////
 
 /** Construct object from archive_node. */
-function::function(const archive_node &n, lst &sym_lst) : inherited(n, sym_lst)
+void function::read_archive(const archive_node& n, lst& sym_lst)
 {
+       inherited::read_archive(n, sym_lst);
        // Find serial number by function name
        std::string s;
        if (n.find_string("name", s)) {
@@ -874,12 +875,6 @@ function::function(const archive_node &n, lst &sym_lst) : inherited(n, sym_lst)
                throw (std::runtime_error("unnamed function in archive"));
 }
 
-/** Unarchive the object. */
-ex function::unarchive(const archive_node &n, lst &sym_lst)
-{
-       return (new function(n, sym_lst))->setflag(status_flags::dynallocated);
-}
-
 /** Archive the object. */
 void function::archive(archive_node &n) const
 {
@@ -888,6 +883,8 @@ void function::archive(archive_node &n) const
        n.add_string("name", registered_functions()[serial].name);
 }
 
+GINAC_BIND_UNARCHIVER(function);
+
 //////////
 // functions overriding virtual functions from base classes
 //////////
@@ -1066,7 +1063,8 @@ ex function::eval_ncmul(const exvector & v) const
 
 unsigned function::calchash() const
 {
-       unsigned v = golden_ratio_hash(golden_ratio_hash((p_int)tinfo()) ^ serial);
+       const void* this_tinfo = (const void*)typeid(*this).name();
+       unsigned v = golden_ratio_hash(golden_ratio_hash((p_int)this_tinfo) ^ serial);
        for (size_t i=0; i<nops(); i++) {
                v = rotate_left(v);
                v ^= this->op(i).gethash();
@@ -1257,7 +1255,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];
@@ -1269,7 +1267,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();
        }