function(unsigned, const exprseq &) constructor clears status_flags::evaluated

[ginac.git] / ginac / function.pl

diff --git a/ginac/function.pl b/ginac/function.pl
index 47cc5492bf5867be978fe666c4d97081ebe4e7f1..727eb52ff683cd386e5c1e0d221f54d302502487 100755 (executable)
--- a/ginac/function.pl
+++ b/ginac/function.pl
@@ -164,7 +164,7 @@ $interface=<<END_OF_INTERFACE;
  *  Please do not modify it directly, edit the perl script instead!
  *  function.pl options: \$maxargs=${maxargs}
  *
- *  GiNaC Copyright (C) 1999-2001 Johannes Gutenberg University Mainz, Germany
+ *  GiNaC Copyright (C) 1999-2003 Johannes Gutenberg University Mainz, Germany
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -320,9 +320,6 @@ $constructors_interface
 public:
        void print(const print_context & c, unsigned level = 0) const;
        unsigned precedence(void) const {return 70;}
-       int degree(const ex & s) const;
-       int ldegree(const ex & s) const;
-       ex coeff(const ex & s, int n = 1) const;
        ex expand(unsigned options=0) const;
        ex eval(int level=0) const;
        ex evalf(int level=0) const;
@@ -368,7 +365,7 @@ template<> inline bool is_exactly_a<function>(const basic & obj)
 }
 
 #define is_ex_the_function(OBJ, FUNCNAME) \\
-       (is_exactly_a<GiNaC::function>(OBJ) && ex_to<GiNaC::function>(OBJ).get_serial() == function_index_##FUNCNAME)
+       (GiNaC::is_exactly_a<GiNaC::function>(OBJ) && GiNaC::ex_to<GiNaC::function>(OBJ).get_serial() == function_index_##FUNCNAME)
 
 } // namespace GiNaC
 
@@ -386,7 +383,7 @@ $implementation=<<END_OF_IMPLEMENTATION;
  *  Please do not modify it directly, edit the perl script instead!
  *  function.pl options: \$maxargs=${maxargs}
  *
- *  GiNaC Copyright (C) 1999-2001 Johannes Gutenberg University Mainz, Germany
+ *  GiNaC Copyright (C) 1999-2003 Johannes Gutenberg University Mainz, Germany
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -507,7 +504,6 @@ function_options& function_options::series_func(series_funcp_exvector s)
        return *this;
 }
 
-
 function_options & function_options::set_return_type(unsigned rt, unsigned rtt)
 {
        use_return_type = true;
@@ -608,6 +604,10 @@ $constructors_implementation
 function::function(unsigned ser, const exprseq & es) : exprseq(es), serial(ser)
 {
        tinfo_key = TINFO_function;
+
+       // Force re-evaluation even if the exprseq was already evaluated
+       // (the exprseq copy constructor copies the flags)
+       clearflag(status_flags::evaluated);
 }
 
 function::function(unsigned ser, const exvector & v, bool discardable) 
@@ -719,24 +719,6 @@ ex function::expand(unsigned options) const
                return (options == 0) ? setflag(status_flags::expanded) : *this;
 }
 
-int function::degree(const ex & s) const
-{
-       return is_equal(ex_to<basic>(s)) ? 1 : 0;
-}
-
-int function::ldegree(const ex & s) const
-{
-       return is_equal(ex_to<basic>(s)) ? 1 : 0;
-}
-
-ex function::coeff(const ex & s, int n) const
-{
-       if (is_equal(ex_to<basic>(s)))
-               return n==1 ? _ex1 : _ex0;
-       else
-               return n==0 ? ex(*this) : _ex0;
-}
-
 ex function::eval(int level) const
 {
        GINAC_ASSERT(serial<registered_functions().size());
@@ -791,28 +773,31 @@ ex function::evalf(int level) const
 {
        GINAC_ASSERT(serial<registered_functions().size());
 
+       const function_options &opt = registered_functions()[serial];
+
        // Evaluate children first
        exvector eseq;
-       if (level == 1)
+       if (level == 1 || !(opt.evalf_params_first))
                eseq = seq;
        else if (level == -max_recursion_level)
                throw(std::runtime_error("max recursion level reached"));
-       else
+       else {
                eseq.reserve(seq.size());
-       --level;
-       exvector::const_iterator it = seq.begin(), itend = seq.end();
-       while (it != itend) {
-               eseq.push_back(it->evalf(level));
-               ++it;
+               --level;
+               exvector::const_iterator it = seq.begin(), itend = seq.end();
+               while (it != itend) {
+                       eseq.push_back(it->evalf(level));
+                       ++it;
+               }
        }
-       
-       if (registered_functions()[serial].evalf_f==0) {
+
+       if (opt.evalf_f==0) {
                return function(serial,eseq).hold();
        }
        current_serial = serial;
-       if (registered_functions()[serial].evalf_use_exvector_args)
-               return ((evalf_funcp_exvector)(registered_functions()[serial].evalf_f))(seq);
-       switch (registered_functions()[serial].nparams) {
+       if (opt.evalf_use_exvector_args)
+               return ((evalf_funcp_exvector)(opt.evalf_f))(seq);
+       switch (opt.nparams) {
                // the following lines have been generated for max. ${maxargs} parameters
 ${evalf_switch_statement}
                // end of generated lines
@@ -934,18 +919,36 @@ bool function::match_same_type(const basic & other) const
 
 unsigned function::return_type(void) const
 {
-       if (seq.empty())
-               return return_types::commutative;
-       else
-               return seq.begin()->return_type();
+       const function_options &opt = registered_functions()[serial];
+
+       if (opt.use_return_type) {
+               // Return type was explicitly specified
+               return opt.return_type;
+       } else {
+               // 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 return_types::commutative;
+               else
+                       return seq.begin()->return_type();
+       }
 }
 
 unsigned function::return_type_tinfo(void) const
 {
-       if (seq.empty())
-               return tinfo_key;
-       else
-               return seq.begin()->return_type_tinfo();
+       const function_options &opt = registered_functions()[serial];
+
+       if (opt.use_return_type) {
+               // Return type was explicitly specified
+               return opt.return_type_tinfo;
+       } else {
+               // 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 tinfo_key;
+               else
+                       return seq.begin()->return_type_tinfo();
+       }
 }
 
 //////////