- removed inert Diff() function; only Derivative() remains
authorChristian Bauer <Christian.Bauer@uni-mainz.de>
Wed, 22 Mar 2000 21:32:23 +0000 (21:32 +0000)
committerChristian Bauer <Christian.Bauer@uni-mainz.de>
Wed, 22 Mar 2000 21:32:23 +0000 (21:32 +0000)
- deriving Derivative() now works

ginac/function.pl
ginac/inifcns.cpp
ginac/inifcns.h

index 988206e9265ebfb231c607b1d75eb3bd4a321525..caa4175c3cc269b77d6619a654c5a8bd783a78f7 100755 (executable)
@@ -572,6 +572,7 @@ $implementation=<<END_OF_IMPLEMENTATION;
 
 #include "function.h"
 #include "ex.h"
+#include "lst.h"
 #include "archive.h"
 #include "inifcns.h"
 #include "utils.h"
@@ -972,9 +973,24 @@ ex function::derivative(const symbol & s) const
 {
     ex result;
     
-    if (serial==function_index_Order) {
+    if (serial == function_index_Order) {
         // Order Term function only differentiates the argument
         return Order(seq[0].diff(s));
+    } else if (serial == function_index_Derivative) {
+        // Inert derivative performs chain rule on the first argument only, and
+        // adds differentiation parameter to list (second argument)
+        GINAC_ASSERT(is_ex_exactly_of_type(seq[0], function));
+        GINAC_ASSERT(is_ex_exactly_of_type(seq[1], function));
+        ex fcn = seq[0];
+        ex arg_diff;
+        for (unsigned i=0; i!=fcn.nops(); i++) {
+            arg_diff = fcn.op(i).diff(s);
+            if (!arg_diff.is_zero()) {
+                lst new_lst = ex_to_lst(seq[1]);
+                new_lst.append(i);
+                result += arg_diff * Derivative(fcn, new_lst);
+            }
+        }
     } else {
         // Chain rule
         ex arg_diff;
@@ -1045,7 +1061,7 @@ ex function::pderivative(unsigned diff_param) const // partial differentiation
     GINAC_ASSERT(serial<registered_functions().size());
     
     if (registered_functions()[serial].derivative_f==0) {
-        return Derivative(*this, diff_param);
+        return Derivative(*this, lst(diff_param));
     }
     switch (registered_functions()[serial].nparams) {
         // the following lines have been generated for max. ${maxargs} parameters
index e8531a062e8e7d6b2baed72620c23006c48ff8c8..fcf2d05dc088052d60e7d12f9e577b7a103cd4f9 100644 (file)
@@ -171,41 +171,19 @@ static ex Order_series(const ex & x, const symbol & s, const ex & point, int ord
 REGISTER_FUNCTION(Order, eval_func(Order_eval).
                          series_func(Order_series));
 
-//////////
-// Inert differentiation
-//////////
-
-static ex Diff_eval(const ex & f, const ex & x)
-{
-       return Diff(f, x).hold();
-}
-
-static ex Diff_deriv(const ex & f, const ex & x, unsigned deriv_param)
-{
-       GINAC_ASSERT(deriv_param == 0 || deriv_param == 1);
-       if (deriv_param == 1)
-               return Diff(Diff(f, x), x);
-       else
-               return _ex0();
-}
-
-REGISTER_FUNCTION(Diff, eval_func(Diff_eval).
-                        derivative_func(Diff_deriv));
-
 //////////
 // Inert partial differentiation operator
 //////////
 
-static ex Derivative_eval(const ex & f, const ex & n)
+static ex Derivative_eval(const ex & f, const ex & l)
 {
-       if (is_ex_exactly_of_type(n, numeric) && ex_to_numeric(n).is_nonneg_integer()) {
-               unsigned i = ex_to_numeric(n).to_int();
-               if (is_ex_exactly_of_type(f, function)) {
-                       if (i < f.nops() && is_ex_exactly_of_type(f.op(i), symbol))
-                               return Diff(f, f.op(i));
-               }
+       if (!is_ex_exactly_of_type(f, function)) {
+        throw(std::invalid_argument("Derivative(): 1st argument must be a function"));
        }
-       return Derivative(f, n).hold();
+    if (!is_ex_exactly_of_type(l, lst)) {
+        throw(std::invalid_argument("Derivative(): 2nd argument must be a list"));
+    }
+       return Derivative(f, l).hold();
 }
 
 REGISTER_FUNCTION(Derivative, eval_func(Derivative_eval));
index 5dfbdaa902844d31f101f020e191d3ed06968e97..cff2bb2484309200a3ff777665e1c5b6dbb90979 100644 (file)
@@ -123,9 +123,6 @@ DECLARE_FUNCTION_2P(binomial)
 /** Order term function (for truncated power series). */
 DECLARE_FUNCTION_1P(Order)
 
-/** Inert differentiation. */
-DECLARE_FUNCTION_2P(Diff)
-
 /** Inert partial differentiation operator. */
 DECLARE_FUNCTION_2P(Derivative)