Merge pull request #8 from kpeeters/master

Sync with upstream

Author: cbehan

CMakeLists.txt

@@ -10,6 +10,14 @@ project(Cadabra)
 # Preamble
 #---------------------------------------------------------------------------
 
+# Aliases for directories
+set(CADABRA_ROOT_DIR ${CMAKE_SOURCE_DIR})
+set(CADABRA_CLIENT_SERVER_DIR ${CADABRA_ROOT_DIR}/client_server)
+set(CADABRA_CORE_DIR ${CADABRA_ROOT_DIR}/core)
+set(CADABRA_FRONTEND_DIR ${CADABRA_ROOT_DIR}/frontend)
+set(CADABRA_IMAGES_DIR ${CADABRA_ROOT_DIR}/images)
+set(CADABRA_LIBS_DIR ${CADABRA_ROOT_DIR}/libs)
+
 include(cmake/functions.cmake)
 
 # Include Visual Studio specific build commands
@@ -59,19 +67,19 @@ install(
   endif()
   "
   )
+
+  # Are we trying to build cadabra as a c++ library?
+  option(BUILD_AS_CPP_LIBRARY "Build cadabra as a C++ library" OFF)
+  if (BUILD_AS_CPP_LIBRARY)
+	enable_testing()
+	add_subdirectory(c++lib)
+	return()
+  endif()
 
 
 # Include packaging logic.
 include(cmake/packaging.cmake)
 
-# Aliases for directories
-set(CADABRA_ROOT_DIR ${CMAKE_SOURCE_DIR})
-set(CADABRA_CLIENT_SERVER_DIR ${CADABRA_ROOT_DIR}/client_server)
-set(CADABRA_CORE_DIR ${CADABRA_ROOT_DIR}/core)
-set(CADABRA_FRONTEND_DIR ${CADABRA_ROOT_DIR}/frontend)
-set(CADABRA_IMAGES_DIR ${CADABRA_ROOT_DIR}/images)
-set(CADABRA_LIBS_DIR ${CADABRA_ROOT_DIR}/libs)
-
 
 #---------------------------------------------------------------------------
 # User options and other notifications

JUPYTER.rst

@@ -147,3 +147,16 @@ Build the Cadabra Jupyter kernel with::
 The 'new' button in the Jupyterhub file browser should now offer you
 the option of creating a new Cadabra notebook.
 
+
+Creating a Conda package of the Cadabra Jupyter kernel
+------------------------------------------------------
+
+To build a Conda package of the Cadabra Jupyter kernel from scratch,
+first install miniconda as above, and activate::
+
+    source ~/miniconda3/bin/activate
+
+Install the prerequisites for building conda packages::
+
+    conda install conda-build
+

c++lib/CMakeLists.txt

@@ -0,0 +1,15 @@
+# Conda build script to build a Cadabra Jupyter kernel.
+
+mkdir build
+cd build
+cmake -G $CMAKE_GENERATOR \
+      -DCMAKE_INSTALL_PREFIX=$PREFIX \
+      -DCMAKE_BUILD_TYPE=Release $SRC_DIR \
+      -DENABLE_JUPYTER=ON \
+      -DENABLE_FRONTEND=OFF \
+      -DCMAKE_INCLUDE_PATH=${HOME}/miniconda3/include \
+      -DCMAKE_LIBRARY_PATH=${HOME}/miniconda3/lib \
+      -DCMAKE_INSTALL_PREFIX=${HOME}/miniconda3
+
+cmake --build .
+cmake --build . --target install

c++lib/cadabra2++

@@ -0,0 +1,33 @@
+package:
+  name: "cadabra2-jupyter-kernel"
+  version: "2.2.7"
+
+source:
+  path: ../  
+
+requirements:
+  build:
+    - python
+    - setuptools
+    - cmake
+    - pkg-config
+    - glibmm
+    - zeromq
+    - cppzmq
+    - xtl
+    - cryptopp
+    - sqlite
+    - util-linux
+    - xeus
+    - nlohmann_json
+    - sympy
+    - jupyter
+
+  run:
+    - python
+
+about:
+  home: https://cadabra.science
+  license: GPL
+  license_family: GPL
+  summary: Jupyter kernel for the Cadabra2 computer algebra system.

conda/build.sh

@@ -34,6 +34,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "properties/Indices.hh"
 #include "properties/Coordinate.hh"
 #include "properties/Symbol.hh"
+#include "properties/Trace.hh"
 #include "properties/DependsBase.hh"
 
 #include <sstream>
@@ -319,7 +320,8 @@ void Algorithm::propagate_zeroes(post_order_iterator& it, const iterator& topnod
 		return;
 
 	const Derivative *der=kernel.properties.get<Derivative>(walk);
-	if(*walk->name=="\\prod" || der) {
+	const Trace *trace=kernel.properties.get<Trace>(walk);
+	if(*walk->name=="\\prod" || der || trace) {
 		if(der && it->is_index()) return;
 		walk->multiplier=rat_set.insert(0).first;
 		it=walk;

conda/meta.yaml

@@ -1158,6 +1158,23 @@ namespace cadabra {
 		return sign;
 		}
 
+	int Ex_comparator::can_swap_components(Ex::iterator one, Ex::iterator two, match_t subtree_comparison)
+		{
+		int tmp;
+		auto impi=properties.get_with_pattern<ImplicitIndex>(one, tmp);
+		if(impi.first) {
+			if(impi.first->explicit_form.size()>0) {
+				one=impi.first->explicit_form.begin();
+				}
+			}
+		impi=properties.get_with_pattern<ImplicitIndex>(two, tmp);
+		if(impi.first) {
+			if(impi.first->explicit_form.size()>0) {
+				two=impi.first->explicit_form.begin();
+				}
+			}
+		return can_swap(one, two, subtree_comparison, true);
+		}
 
 	// Determine the sign required to move the last factor in 'factors' to
 	// the right of the first.  If moving left, do not count signs from

core/Algorithm.cc

@@ -313,6 +313,14 @@ namespace cadabra {
 			int  can_swap(Ex::iterator one, Ex::iterator two, match_t subtree_comparison,
 			              bool ignore_implicit_indices=false);
 
+			/// Wrapper for can_swap which is meant for objects that have implicit
+			/// indices. This checks whether a single component of A commutes or
+			/// anticommutes with a single component of B, saying nothing about
+			/// whether A and B commute under matrix multiplication.
+
+			int  can_swap_components(Ex::iterator one, Ex::iterator two,
+						 match_t subtree_comparison);
+
 			/// Determine whether object 'one' and 'two' can be moved next
 			/// to each other by moving either one or the other: if fix_one==true
 			/// the first node is kept fixed, otherwise the second node is kept fixed.

core/Compare.cc

@@ -4,6 +4,7 @@
 #include "Functional.hh"
 #include "algorithms/canonicalise.hh"
 #include "modules/xperm_new.h"
+#include "properties/Trace.hh"
 #include "properties/Traceless.hh"
 #include "properties/Diagonal.hh"
 #include "properties/Derivative.hh"
@@ -50,18 +51,53 @@ bool canonicalise::remove_traceless_traces(iterator& it)
 	while(facit!=tr.end(it)) {
 		const Traceless *trl=kernel.properties.get_composite<Traceless>(facit);
 		if(trl) {
+			unsigned int ihits=0;
 			tree_exact_less_mod_prel_obj comp(&kernel.properties);
 			std::set<Ex, tree_exact_less_mod_prel_obj> countmap(comp);
 			index_iterator indit=begin_index(facit);
 			while(indit!=end_index(facit)) {
+				bool incremented_now=false;
+				auto ind=kernel.properties.get<Indices>(indit, true);
+				if(ind) {
+					// The indexs need to be in the set for which the object is
+					// traceless (if specified, otherwise accept all).
+					if(ind->set_name==trl->index_set_name || trl->index_set_name=="") {
+						incremented_now=true;
+						++ihits;
+						}
+					}
+				else incremented_now=true;
+				// Having no name is treated as having the right name
 				if(countmap.find(Ex(indit))==countmap.end()) {
 					countmap.insert(Ex(indit));
-					++indit;
 					}
-				else {
+				else if(incremented_now) {
 					zero(it->multiplier);
 					return true;
 					}
+				++indit;
+				}
+			iterator parent=it;
+			if (tr.number_of_children(it)==1 && !tr.is_head(it)) parent=tr.parent(it);
+			const Trace *trace=kernel.properties.get<Trace>(parent);
+			if(trace) {
+				int tmp;
+				auto impi=kernel.properties.get_with_pattern<ImplicitIndex>(facit, tmp);
+				if(impi.first->explicit_form.size()>0) {
+					// Does the explicit form have two more indices of the right type?
+					Ex::iterator eform=impi.first->explicit_form.begin();
+					unsigned int ehits=0;
+					indit=begin_index(eform);
+					while(indit!=end_index(eform)) {
+						auto ind=kernel.properties.get<Indices>(indit, true);
+						if(ind->set_name==trl->index_set_name && ind->set_name==trace->index_set_name) ++ehits;
+						if(ehits - ihits > 1) {
+							zero(it->multiplier);
+							return true;
+							}
+						++indit;
+						}
+					}
 				}
 			}
 		++facit;