Added 'with_respect_to' argument to Derivative, and updated docs.

Author: kpeeters

core/DisplaySympy.cc

@@ -4,6 +4,7 @@
 #include "DisplaySympy.hh"
 #include "properties/Depends.hh"
 #include "properties/Accent.hh"
+#include "properties/Derivative.hh"
 #include <regex>
 
 // #define DEBUG 1
@@ -201,6 +202,9 @@ void DisplaySympy::print_children(std::ostream& str, Ex::iterator it, int )
 			// deplist is always a \comma node
 			auto sib=tree.begin(deplist.begin());
 			while(sib!=tree.end(deplist.begin())) {
+				const Derivative *dep_is_derivative=kernel.properties.get<Derivative>(sib);
+				if(dep_is_derivative)
+					throw RuntimeException("Dependencies on derivatives are not yet handled in the SymPy bridge");
 				dispatch(str, sib);
 				++sib;
 				if(sib!=tree.end(deplist.begin()))
@@ -522,6 +526,16 @@ void DisplaySympy::print_partial(std::ostream& str, Ex::iterator it)
 			}
 		++sib;
 		}
+	// write the implicit direction of the derivative, if any.
+	const Derivative *derivative = kernel.properties.get<Derivative>(it);
+	if(derivative) {
+		if(derivative->with_respect_to.size()>0) {
+			str << ", ";
+			dispatch(str, derivative->with_respect_to.begin());
+			}
+		}
+	
+	// write the explicit direction(s) of the derivative.
 	sib=tree.begin(it);
 	while(sib!=tree.end(it)) {
 		if(sib->fl.parent_rel!=str_node::p_none) {
@@ -654,11 +668,55 @@ void DisplaySympy::import(Ex& ex)
 
 				args=nxt;
 				}
+
+			// Strip subscripts which are the same as the 'with_respect_to' member of the
+			// derivative (if any), as these are implicit in Cadabra. This is tricky, because
+			// a multiple derivative with respect to this argument needs to be replaced
+			// with a multiple nesting of the derivative operator itself, e.g.
+			//   \partial{\partial{r}} -> diff(diff(r(t),t),t) -> diff(r(t),t,t)
+		  
+			const Derivative *derivative = kernel.properties.get<Derivative>(it);
+			if(derivative) {
+#ifdef DEBUG
+				std::cerr << "is proper derivative" << std::endl;
+#endif
+				if(derivative->with_respect_to.size()>0) {
+					auto it_copy=it;
+					args=ex.begin(it_copy);
+					bool first=true;
+					while(args!=ex.end(it_copy)) {
+#ifdef DEBUG
+						std::cerr << "Comparing: " << args << std::endl
+									 << "and " << derivative->with_respect_to.begin()
+									 << std::endl;
+#endif
+						 
+						if(subtree_equal(0, args, derivative->with_respect_to.begin(), 0) ) {
+							args=ex.erase(args);
+							if(first) {
+								first=false;
+								}
+							else {
+								it=ex.wrap(it, str_node(it->name));
+								}
+							}
+						else
+							++args;
+						}
+					}
+				}
+			else {
+#ifdef DEBUG
+				std::cerr << it << " is not a proper derivative" << std::endl;
+#endif
+				
+				}
+			
 			//				ex.flatten(comma);
 			//				ex.erase(comma);
 			//				}
 			}
 
 		return it;
-		});
+			});
 	}

core/SympyCdb.cc

@@ -31,6 +31,9 @@ pybind11::object sympy::SympyBridge::export_ex()
 	output(str);
 	pybind11::module sympy_parser = pybind11::module::import("sympy.parsing.sympy_parser");
 	auto parse = sympy_parser.attr("parse_expr");
+#ifdef DEBUG
+	std::cerr << str.str() << std::endl;
+#endif
 	pybind11::object ret = parse(str.str());
 
 	return ret;

core/algorithms/unwrap.cc

@@ -143,16 +143,22 @@ Algorithm::result_t unwrap::apply(iterator& it)
 #ifdef DEBUG
 						std::cerr << *factor->name << " acted on by " << *old_it->name << "; depends" << std::endl;
 #endif
+						auto derivative=kernel.properties.get<Derivative>(old_it);
 						Ex deps=dep->dependencies(kernel, factor /* it */);
 						sibling_iterator depobjs=deps.begin(deps.begin());
 						while(depobjs!=deps.end(deps.begin())) {
 #ifdef DEBUG
 							std::cerr << "?" << *old_it->name << " == " << *depobjs->name << std::endl;
 #endif
+							// FIXME: need to compare more than the name
 							if(old_it->name == depobjs->name) {
 								move_out=false;
 								break;
 								}
+							else if(derivative && derivative->with_respect_to.size()>0 && derivative->with_respect_to.begin()->name==depobjs->name) {
+								move_out=false;
+								break;
+								}
 							else {
 								// compare all indices
 #ifdef DEBUG

core/properties/Derivative.cc

@@ -5,6 +5,18 @@
 
 using namespace cadabra;
 
+bool Derivative::parse(Kernel&, std::shared_ptr<Ex>, keyval_t& keyvals)
+	{
+	keyval_t::const_iterator ki=keyvals.begin();
+	while(ki!=keyvals.end()) {
+		if(ki->first=="to") {
+			with_respect_to=ki->second;
+			}
+		++ki;
+		}
+	return true;
+	}
+			
 unsigned int Derivative::size(const Properties& properties, Ex& tr, Ex::iterator it) const
 	{
 	it=properties.head<Derivative>(it);

core/properties/Derivative.hh

@@ -28,6 +28,13 @@ namespace cadabra {
 			virtual unsigned int size(const Properties&, Ex&, Ex::iterator) const override;
 			virtual tab_t        get_tab(const Properties&, Ex&, Ex::iterator, unsigned int) const override;
 			virtual multiplier_t value(const Kernel&, Ex::iterator, const std::string& forcedlabel) const override;
+			virtual bool         parse(Kernel&, std::shared_ptr<Ex>, keyval_t& keyvals) override;
+			virtual std::string unnamed_argument() const override
+				{
+				return "to";
+				};
+	
+			Ex with_respect_to;
 		};
 
 	}