From: Christian Bauer <Christian.Bauer@uni-mainz.de>
Date: Wed, 22 Mar 2000 21:32:23 +0000 (+0000)
Subject: - removed inert Diff() function; only Derivative() remains
X-Git-Tag: release_0-6-0~55
X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=commitdiff_plain;h=8d08b902f1bb734fe91b5aa29c66c59788464be7;ds=sidebyside

- removed inert Diff() function; only Derivative() remains
- deriving Derivative() now works
---

diff --git a/ginac/function.pl b/ginac/function.pl
index 988206e9..caa4175c 100755
--- a/ginac/function.pl
+++ b/ginac/function.pl
@@ -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
diff --git a/ginac/inifcns.cpp b/ginac/inifcns.cpp
index e8531a06..fcf2d05d 100644
--- a/ginac/inifcns.cpp
+++ b/ginac/inifcns.cpp
@@ -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));
diff --git a/ginac/inifcns.h b/ginac/inifcns.h
index 5dfbdaa9..cff2bb24 100644
--- a/ginac/inifcns.h
+++ b/ginac/inifcns.h
@@ -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)