diff --git a/api/mrcpp_declarations.h b/api/mrcpp_declarations.h
index f6501b726..d21058409 100644
--- a/api/mrcpp_declarations.h
+++ b/api/mrcpp_declarations.h
@@ -34,7 +34,7 @@ namespace mrcpp {
 
 class Timer;
 class Printer;
-template <int D> class Plotter;
+template <int D, typename T = double> class Plotter;
 
 template <int D> class Gaussian;
 template <int D> class GaussFunc;
@@ -42,26 +42,26 @@ template <int D> class GaussPoly;
 template <int D> class GaussExp;
 
 template <int D> class BoundingBox;
-template <int D> class NodeBox;
+template <int D, typename T = double> class NodeBox;
 template <int D> class NodeIndex;
 template <int D> class NodeIndexComp;
 
-class SharedMemory;
+template <typename T = double> class SharedMemory;
 class ScalingBasis;
 class LegendreBasis;
 class InterpolatingBasis;
 
-template <int D> class RepresentableFunction;
+template <int D, typename T = double> class RepresentableFunction;
 template <int D> class MultiResolutionAnalysis;
 
-template <int D> class MWTree;
-template <int D> class FunctionTree;
+template <int D, typename T = double> class MWTree;
+template <int D, typename T = double> class FunctionTree;
 class OperatorTree;
 
-template <int D> class NodeAllocator;
+template <int D, typename T = double> class NodeAllocator;
 
-template <int D> class MWNode;
-template <int D> class FunctionNode;
+template <int D, typename T = double> class MWNode;
+template <int D, typename T = double> class FunctionNode;
 class OperatorNode;
 
 template <int D> class IdentityConvolution;
@@ -79,31 +79,30 @@ template <int D> class DerivativeKernel;
 class PoissonKernel;
 class HelmholtzKernel;
 
-template <int D> class TreeBuilder;
-template <int D> class TreeCalculator;
-template <int D> class DefaultCalculator;
-template <int D> class ProjectionCalculator;
-template <int D> class AdditionCalculator;
-template <int D> class MultiplicationCalculator;
-template <int D> class ConvolutionCalculator;
-template <int D> class DerivativeCalculator;
+template <int D, typename T = double> class TreeBuilder;
+template <int D, typename T = double> class TreeCalculator;
+template <int D, typename T = double> class DefaultCalculator;
+template <int D, typename T = double> class ProjectionCalculator;
+template <int D, typename T = double> class AdditionCalculator;
+template <int D, typename T = double> class MultiplicationCalculator;
+template <int D, typename T = double> class ConvolutionCalculator;
+template <int D, typename T = double> class DerivativeCalculator;
 class CrossCorrelationCalculator;
 
-template <int D> class TreeAdaptor;
-template <int D> class AnalyticAdaptor;
-template <int D> class WaveletAdaptor;
-template <int D> class CopyAdaptor;
+template <int D, typename T = double> class TreeAdaptor;
+template <int D, typename T = double> class AnalyticAdaptor;
+template <int D, typename T = double> class WaveletAdaptor;
+template <int D, typename T = double> class CopyAdaptor;
 
-template <int D> class TreeIterator;
-template <int D> class IteratorNode;
+template <int D, typename T = double> class TreeIterator;
+template <int D, typename T = double> class IteratorNode;
 
 class BandWidth;
-template <int D> class OperatorState;
+template <int D, typename T = double> class OperatorState;
 
 template <int D> using Coord = std::array<double, D>;
-template <int D> using MWNodeVector = std::vector<MWNode<D> *>;
+template <int D, typename T = double> using MWNodeVector = std::vector<MWNode<D, T> *>;
 
-template <typename T, typename U> using FMap_ = std::function<T(U)>;
-typedef FMap_<double, double> FMap;
+template <typename T = double, typename U = double> using FMap = std::function<T(U)>;
 
 } // namespace mrcpp
diff --git a/examples/derivative.cpp b/examples/derivative.cpp
index bc0475db9..bd33bcfe7 100644
--- a/examples/derivative.cpp
+++ b/examples/derivative.cpp
@@ -51,8 +51,8 @@ int main(int argc, char **argv) {
     mrcpp::FunctionTree<D> err_tree(MRA);
 
     // Projecting functions
-    mrcpp::project<D>(prec, f_tree, f);
-    mrcpp::project<D>(prec, df_tree, df);
+    mrcpp::project<D, double>(prec, f_tree, f);
+    mrcpp::project<D, double>(prec, df_tree, df);
 
     // Applying derivative operator
     mrcpp::apply(dg_tree, D_00, f_tree, 0);
diff --git a/examples/mpi_matrix.cpp b/examples/mpi_matrix.cpp
index f3580d158..69c370a70 100644
--- a/examples/mpi_matrix.cpp
+++ b/examples/mpi_matrix.cpp
@@ -54,7 +54,7 @@ int main(int argc, char **argv) {
         };
         mrcpp::FunctionTree<3> *tree = new mrcpp::FunctionTree<3>(MRA);
         if (i % wsize == wrank) {
-            mrcpp::project<3>(prec, *tree, f);
+	  mrcpp::project<3, double>(prec, *tree, f);
             tree->normalize();
         }
         f_vec.push_back(std::make_tuple(1.0, tree));
diff --git a/examples/mpi_send_tree.cpp b/examples/mpi_send_tree.cpp
index 44ffd0dec..aff8be379 100644
--- a/examples/mpi_send_tree.cpp
+++ b/examples/mpi_send_tree.cpp
@@ -55,7 +55,7 @@ int main(int argc, char **argv) {
     mrcpp::FunctionTree<D> f_tree(MRA);
 
     // Only rank 0 projects the function
-    if (wrank == 0) mrcpp::project<D>(prec, f_tree, f);
+    if (wrank == 0) mrcpp::project<D, double>(prec, f_tree, f);
 
     { // Print data before send
         auto integral = f_tree.integrate();
diff --git a/examples/mpi_shared_tree.cpp b/examples/mpi_shared_tree.cpp
index aa59d8204..ba7f7db5e 100644
--- a/examples/mpi_shared_tree.cpp
+++ b/examples/mpi_shared_tree.cpp
@@ -63,12 +63,12 @@ int main(int argc, char **argv) {
     };
 
     // Initialize a shared memory tree, max 100MB
-    auto shared_mem = new mrcpp::SharedMemory(scomm, 100);
+    auto shared_mem = new mrcpp::SharedMemory<double>(scomm, 100);
     mrcpp::FunctionTree<D> f_tree(MRA, shared_mem);
 
     // Only first rank projects
     auto frank = 0;
-    if (srank == frank) mrcpp::project<D>(prec, f_tree, f);
+    if (srank == frank) mrcpp::project<D, double>(prec, f_tree, f);
     mrcpp::share_tree(f_tree, frank, 0, scomm);
 
     { // Print data after share
diff --git a/examples/projection.cpp b/examples/projection.cpp
index 92f1a7b53..9243485fb 100644
--- a/examples/projection.cpp
+++ b/examples/projection.cpp
@@ -37,7 +37,7 @@ int main(int argc, char **argv) {
 
     // Projecting function
     mrcpp::FunctionTree<D> f_tree(MRA);
-    mrcpp::project<D>(prec, f_tree, f, -1);
+    mrcpp::project<D, double>(prec, f_tree, f, -1);
     auto integral = f_tree.integrate();
 
     mrcpp::print::header(0, "Projecting analytic function");
diff --git a/examples/scf.cpp b/examples/scf.cpp
index f91058f14..fe34d936b 100644
--- a/examples/scf.cpp
+++ b/examples/scf.cpp
@@ -31,7 +31,7 @@ void setupNuclearPotential(double Z, FunctionTree<D> &V) {
     };
 
     // Projecting function
-    project<D>(prec, V, f);
+    project<D, double>(prec, V, f);
 
     print::footer(0, timer, 2);
     Printer::setPrintLevel(oldlevel);
@@ -48,7 +48,7 @@ void setupInitialGuess(FunctionTree<D> &phi) {
     };
 
     // Projecting and normalizing function
-    project<D>(prec, phi, f);
+    project<D, double>(prec, phi, f);
     phi.normalize();
 
     print::footer(0, timer, 2);
diff --git a/examples/schrodinger_semigroup1d.cpp b/examples/schrodinger_semigroup1d.cpp
index 2c1de2fa8..6035aa3c3 100644
--- a/examples/schrodinger_semigroup1d.cpp
+++ b/examples/schrodinger_semigroup1d.cpp
@@ -93,13 +93,13 @@ int main(int argc, char **argv)
 
     // Projecting functions
     mrcpp::FunctionTree<1> Re_f_tree(MRA);
-    mrcpp::project<1>(prec, Re_f_tree, Re_f);
+    mrcpp::project<1, double>(prec, Re_f_tree, Re_f);
     mrcpp::FunctionTree<1> Im_f_tree(MRA);
-    mrcpp::project<1>(prec, Im_f_tree, Im_f);
+    mrcpp::project<1, double>(prec, Im_f_tree, Im_f);
     mrcpp::FunctionTree<1> Re_g_tree(MRA);
-    mrcpp::project<1>(prec, Re_g_tree, Re_g);
+    mrcpp::project<1, double>(prec, Re_g_tree, Re_g);
     mrcpp::FunctionTree<1> Im_g_tree(MRA);
-    mrcpp::project<1>(prec, Im_g_tree, Im_g);
+    mrcpp::project<1, double>(prec, Im_g_tree, Im_g);
 
     // Output function trees
     mrcpp::FunctionTree<1> Re_fout_tree(MRA);
diff --git a/examples/tree_cleaner.cpp b/examples/tree_cleaner.cpp
index 6d970c5e3..dd4d85a05 100644
--- a/examples/tree_cleaner.cpp
+++ b/examples/tree_cleaner.cpp
@@ -9,6 +9,7 @@ const auto order = 7;
 const auto prec = 1.0e-5;
 
 const auto D = 3;
+
 int main(int argc, char **argv) {
     auto timer = mrcpp::Timer();
 
@@ -42,14 +43,14 @@ int main(int argc, char **argv) {
     auto iter = 0;
     auto n_nodes = 1;
     while (n_nodes > 0) {
-        mrcpp::project<D>(-1.0, f_tree, f);         // Projecting on fixed grid
+      mrcpp::project<D, double>(-1.0, f_tree, f);         // Projecting on fixed grid
         n_nodes = mrcpp::refine_grid(f_tree, prec); // Refine grid
         mrcpp::clear_grid(f_tree);                  // Clear MW coefs
         printout(0, " iter " << std::setw(3) << iter++ << std::setw(45));
         printout(0, " n_nodes " << std::setw(5) << n_nodes << std::endl);
     }
     // Projecting on final converged grid
-    mrcpp::project<D>(-1.0, f_tree, f);
+    mrcpp::project<D, double>(-1.0, f_tree, f);
 
     auto integral = f_tree.integrate();
     auto sq_norm = f_tree.getSquareNorm();
diff --git a/src/functions/AnalyticFunction.h b/src/functions/AnalyticFunction.h
index abf0fcbd6..7043d7fe6 100644
--- a/src/functions/AnalyticFunction.h
+++ b/src/functions/AnalyticFunction.h
@@ -32,29 +32,29 @@
 
 namespace mrcpp {
 
-template <int D> class AnalyticFunction : public RepresentableFunction<D> {
+template <int D, typename T = double> class AnalyticFunction : public RepresentableFunction<D, T> {
 public:
     AnalyticFunction() = default;
     ~AnalyticFunction() override = default;
 
-    AnalyticFunction(std::function<double(const Coord<D> &r)> f, const double *a = nullptr, const double *b = nullptr)
-            : RepresentableFunction<D>(a, b)
+    AnalyticFunction(std::function<T(const Coord<D> &r)> f, const double *a = nullptr, const double *b = nullptr)
+            : RepresentableFunction<D, T>(a, b)
             , func(f) {}
-    AnalyticFunction(std::function<double(const Coord<D> &r)> f,
+    AnalyticFunction(std::function<T(const Coord<D> &r)> f,
                      const std::vector<double> &a,
                      const std::vector<double> &b)
             : AnalyticFunction(f, a.data(), b.data()) {}
 
-    void set(std::function<double(const Coord<D> &r)> f) { this->func = f; }
+    void set(std::function<T(const Coord<D> &r)> f) { this->func = f; }
 
-    double evalf(const Coord<D> &r) const override {
-        double val = 0.0;
+    T evalf(const Coord<D> &r) const override {
+        T val = 0.0;
         if (not this->outOfBounds(r)) val = this->func(r);
         return val;
     }
 
 protected:
-    std::function<double(const Coord<D> &r)> func;
+    std::function<T(const Coord<D> &r)> func;
 };
 
 } // namespace mrcpp
diff --git a/src/functions/BoysFunction.cpp b/src/functions/BoysFunction.cpp
index 71b705139..0a3364845 100644
--- a/src/functions/BoysFunction.cpp
+++ b/src/functions/BoysFunction.cpp
@@ -32,7 +32,7 @@
 namespace mrcpp {
 
 BoysFunction::BoysFunction(int n, double p)
-        : RepresentableFunction<1>()
+  : RepresentableFunction<1, double>()
         , order(n)
         , prec(p)
         , MRA(BoundingBox<1>(), InterpolatingBasis(13)) {}
@@ -50,8 +50,8 @@ double BoysFunction::evalf(const Coord<1> &r) const {
         return std::exp(-xt_2) * t_2n;
     };
 
-    FunctionTree<1> tree(this->MRA);
-    mrcpp::project<1>(this->prec, tree, f);
+    FunctionTree<1, double> tree(this->MRA);
+    mrcpp::project<1, double>(this->prec, tree, f);
     double result = tree.integrate();
 
     Printer::setPrintLevel(oldlevel);
diff --git a/src/functions/BoysFunction.h b/src/functions/BoysFunction.h
index 4dc76bd72..cc5cc1916 100644
--- a/src/functions/BoysFunction.h
+++ b/src/functions/BoysFunction.h
@@ -30,7 +30,7 @@
 
 namespace mrcpp {
 
-class BoysFunction final : public RepresentableFunction<1> {
+  class BoysFunction final : public RepresentableFunction<1, double> {
 public:
     BoysFunction(int n, double prec = 1.0e-10);
 
diff --git a/src/functions/GaussExp.h b/src/functions/GaussExp.h
index aa6ad4da3..f33549ec1 100644
--- a/src/functions/GaussExp.h
+++ b/src/functions/GaussExp.h
@@ -51,7 +51,7 @@ namespace mrcpp {
  *
  */
 
-template <int D> class GaussExp : public RepresentableFunction<D> {
+    template <int D> class GaussExp : public RepresentableFunction<D, double> {
 public:
     GaussExp(int nTerms = 0, double prec = GAUSS_EXP_PREC);
     GaussExp(const GaussExp<D> &gExp);
diff --git a/src/functions/Gaussian.h b/src/functions/Gaussian.h
index d02cc43b1..7e79e052a 100644
--- a/src/functions/Gaussian.h
+++ b/src/functions/Gaussian.h
@@ -40,7 +40,7 @@
 
 namespace mrcpp {
 
-template <int D> class Gaussian : public RepresentableFunction<D> {
+    template <int D> class Gaussian : public RepresentableFunction<D, double> {
 public:
     Gaussian(double a, double c, const Coord<D> &r, const std::array<int, D> &p);
     Gaussian(const std::array<double, D> &a, double c, const Coord<D> &r, const std::array<int, D> &p);
diff --git a/src/functions/Polynomial.cpp b/src/functions/Polynomial.cpp
index 397b4e268..964fe687b 100644
--- a/src/functions/Polynomial.cpp
+++ b/src/functions/Polynomial.cpp
@@ -45,7 +45,7 @@ namespace mrcpp {
 /** Construct polynomial of order zero with given size and bounds.
  * Includes default constructor. */
 Polynomial::Polynomial(int k, const double *a, const double *b)
-        : RepresentableFunction<1>(a, b) {
+  : RepresentableFunction<1, double>(a, b) {
     assert(k >= 0);
     this->N = 1.0;
     this->L = 0.0;
diff --git a/src/functions/Polynomial.h b/src/functions/Polynomial.h
index e1c23e4a6..fadc2c988 100644
--- a/src/functions/Polynomial.h
+++ b/src/functions/Polynomial.h
@@ -44,7 +44,7 @@
 
 namespace mrcpp {
 
-class Polynomial : public RepresentableFunction<1> {
+  class Polynomial : public RepresentableFunction<1, double> {
 public:
     Polynomial(int k = 0, const double *a = nullptr, const double *b = nullptr);
     Polynomial(int k, const std::vector<double> &a, const std::vector<double> &b)
diff --git a/src/functions/RepresentableFunction.cpp b/src/functions/RepresentableFunction.cpp
index 8687297c7..3c55ac92b 100644
--- a/src/functions/RepresentableFunction.cpp
+++ b/src/functions/RepresentableFunction.cpp
@@ -38,7 +38,7 @@
 
 namespace mrcpp {
 
-template <int D> RepresentableFunction<D>::RepresentableFunction(const double *a, const double *b) {
+template <int D, typename T> RepresentableFunction<D, T>::RepresentableFunction(const double *a, const double *b) {
     if (a == nullptr or b == nullptr) {
         this->bounded = false;
         this->A = nullptr;
@@ -56,7 +56,7 @@ template <int D> RepresentableFunction<D>::RepresentableFunction(const double *a
 }
 
 /** Constructs a new function with same bounds as the input function */
-template <int D> RepresentableFunction<D>::RepresentableFunction(const RepresentableFunction<D> &func) {
+template <int D, typename T> RepresentableFunction<D, T>::RepresentableFunction(const RepresentableFunction<D, T> &func) {
     if (func.isBounded()) {
         this->bounded = true;
         this->A = new double[D];
@@ -74,11 +74,11 @@ template <int D> RepresentableFunction<D>::RepresentableFunction(const Represent
 
 /** Copies function, not bounds. Use copy constructor if you want an
  * identical function. */
-template <int D> RepresentableFunction<D> &RepresentableFunction<D>::operator=(const RepresentableFunction<D> &func) {
+template <int D, typename T> RepresentableFunction<D, T> &RepresentableFunction<D, T>::operator=(const RepresentableFunction<D, T> &func) {
     return *this;
 }
 
-template <int D> RepresentableFunction<D>::~RepresentableFunction() {
+template <int D, typename T> RepresentableFunction<D, T>::~RepresentableFunction() {
     if (this->isBounded()) {
         delete[] this->A;
         delete[] this->B;
@@ -87,7 +87,7 @@ template <int D> RepresentableFunction<D>::~RepresentableFunction() {
     this->B = nullptr;
 }
 
-template <int D> void RepresentableFunction<D>::setBounds(const double *a, const double *b) {
+template <int D, typename T> void RepresentableFunction<D, T>::setBounds(const double *a, const double *b) {
     if (a == nullptr or b == nullptr) { MSG_ERROR("Invalid arguments"); }
     if (not isBounded()) {
         this->bounded = true;
@@ -101,7 +101,7 @@ template <int D> void RepresentableFunction<D>::setBounds(const double *a, const
     }
 }
 
-template <int D> bool RepresentableFunction<D>::outOfBounds(const Coord<D> &r) const {
+template <int D, typename T> bool RepresentableFunction<D, T>::outOfBounds(const Coord<D> &r) const {
     if (not isBounded()) { return false; }
     for (int d = 0; d < D; d++) {
         if (r[d] < getLowerBound(d)) return true;
@@ -110,8 +110,11 @@ template <int D> bool RepresentableFunction<D>::outOfBounds(const Coord<D> &r) c
     return false;
 }
 
-template class RepresentableFunction<1>;
-template class RepresentableFunction<2>;
-template class RepresentableFunction<3>;
+template class RepresentableFunction<1, double>;
+template class RepresentableFunction<2, double>;
+template class RepresentableFunction<3, double>;
+template class RepresentableFunction<1, ComplexDouble>;
+template class RepresentableFunction<2, ComplexDouble>;
+template class RepresentableFunction<3, ComplexDouble>;
 
 } // namespace mrcpp
diff --git a/src/functions/RepresentableFunction.h b/src/functions/RepresentableFunction.h
index 2d6998812..82381beaa 100644
--- a/src/functions/RepresentableFunction.h
+++ b/src/functions/RepresentableFunction.h
@@ -38,20 +38,21 @@
 #include "MRCPP/constants.h"
 #include "MRCPP/mrcpp_declarations.h"
 #include "trees/NodeIndex.h"
+#include "MRCPP/utils/math_utils.h"
 
 namespace mrcpp {
 
-template <int D> class RepresentableFunction {
+template <int D, typename T> class RepresentableFunction {
 public:
     RepresentableFunction(const double *a = nullptr, const double *b = nullptr);
     RepresentableFunction(const std::vector<double> &a, const std::vector<double> &b)
             : RepresentableFunction(a.data(), b.data()) {}
-    RepresentableFunction(const RepresentableFunction<D> &func);
-    RepresentableFunction<D> &operator=(const RepresentableFunction<D> &func);
+    RepresentableFunction(const RepresentableFunction<D, T> &func);
+    RepresentableFunction<D, T> &operator=(const RepresentableFunction<D, T> &func);
     virtual ~RepresentableFunction();
 
     /** @returns Function value in a point @param[in] r: Cartesian coordinate */
-    virtual double evalf(const Coord<D> &r) const = 0;
+    virtual T evalf(const Coord<D> &r) const = 0;
 
     void setBounds(const double *a, const double *b);
     void clearBounds();
@@ -65,7 +66,7 @@ template <int D> class RepresentableFunction {
     const double *getLowerBounds() const { return this->A; }
     const double *getUpperBounds() const { return this->B; }
 
-    friend class AnalyticAdaptor<D>;
+    friend class AnalyticAdaptor<D, T>;
 
 protected:
     bool bounded;
diff --git a/src/functions/function_utils.cpp b/src/functions/function_utils.cpp
index 60b287e1c..39f30a938 100644
--- a/src/functions/function_utils.cpp
+++ b/src/functions/function_utils.cpp
@@ -117,4 +117,5 @@ double function_utils::ObaraSaika_ab(int power_a, int power_b, double pos_a, dou
 template double function_utils::calc_overlap<1>(const GaussFunc<1> &a, const GaussFunc<1> &b);
 template double function_utils::calc_overlap<2>(const GaussFunc<2> &a, const GaussFunc<2> &b);
 template double function_utils::calc_overlap<3>(const GaussFunc<3> &a, const GaussFunc<3> &b);
+
 } // namespace mrcpp
diff --git a/src/operators/OperatorState.h b/src/operators/OperatorState.h
index 245d9f70f..855f53060 100644
--- a/src/operators/OperatorState.h
+++ b/src/operators/OperatorState.h
@@ -42,9 +42,9 @@ namespace mrcpp {
 
 #define GET_OP_IDX(FT, GT, ID) (2 * ((GT >> ID) & 1) + ((FT >> ID) & 1))
 
-template <int D> class OperatorState final {
+template <int D, typename T> class OperatorState final {
 public:
-    OperatorState(MWNode<D> &gn, double *scr1)
+  OperatorState(MWNode<D, T> &gn, T *scr1)
             : gNode(&gn) {
         this->kp1 = this->gNode->getKp1();
         this->kp1_d = this->gNode->getKp1_d();
@@ -53,7 +53,7 @@ template <int D> class OperatorState final {
         this->gData = this->gNode->getCoefs();
         this->maxDeltaL = -1;
 
-        double *scr2 = scr1 + this->kp1_d;
+        T *scr2 = scr1 + this->kp1_d;
 
         for (int i = 1; i < D; i++) {
             if (IS_ODD(i)) {
@@ -64,9 +64,9 @@ template <int D> class OperatorState final {
         }
     }
 
-    OperatorState(MWNode<D> &gn, std::vector<double> scr1)
+  OperatorState(MWNode<D, T> &gn, std::vector<T> scr1)
             : OperatorState(gn, scr1.data()) {}
-    void setFNode(MWNode<D> &fn) {
+  void setFNode(MWNode<D, T> &fn) {
         this->fNode = &fn;
         this->fData = this->fNode->getCoefs();
     }
@@ -86,15 +86,16 @@ template <int D> class OperatorState final {
     int getMaxDeltaL() const { return this->maxDeltaL; }
     int getOperIndex(int i) const { return GET_OP_IDX(this->ft, this->gt, i); }
 
-    double **getAuxData() { return this->aux; }
+    T **getAuxData() { return this->aux; }
     double **getOperData() { return this->oData; }
 
-    friend class ConvolutionCalculator<D>;
-    friend class DerivativeCalculator<D>;
+  friend class ConvolutionCalculator<D, T>;
+  friend class DerivativeCalculator<D, T>;
 
 private:
     int ft;
     int gt;
+
     int maxDeltaL;
     double fThreshold;
     double gThreshold;
@@ -104,13 +105,13 @@ template <int D> class OperatorState final {
     int kp1_d;
     int kp1_dm1;
 
-    MWNode<D> *gNode;
-    MWNode<D> *fNode;
+    MWNode<D, T> *gNode;
+    MWNode<D, T> *fNode;
     NodeIndex<D> *fIdx;
 
-    double *aux[D + 1];
-    double *gData;
-    double *fData;
+    T *aux[D + 1];
+    T *gData;
+    T *fData;
     double *oData[D];
 
     void calcMaxDeltaL() {
diff --git a/src/operators/OperatorStatistics.cpp b/src/operators/OperatorStatistics.cpp
index d542e88f5..4ed0263cc 100644
--- a/src/operators/OperatorStatistics.cpp
+++ b/src/operators/OperatorStatistics.cpp
@@ -30,8 +30,8 @@ using namespace Eigen;
 
 namespace mrcpp {
 
-template <int D>
-OperatorStatistics<D>::OperatorStatistics()
+template <int D, typename T>
+OperatorStatistics<D, T>::OperatorStatistics()
         : nThreads(mrcpp_get_max_threads())
         , totFCount(0)
         , totGCount(0)
@@ -58,7 +58,7 @@ OperatorStatistics<D>::OperatorStatistics()
     }
 }
 
-template <int D> OperatorStatistics<D>::~OperatorStatistics() {
+template <int D, typename T> OperatorStatistics<D, T>::~OperatorStatistics() {
     for (int i = 0; i < this->nThreads; i++) { delete this->compCount[i]; }
     delete[] this->compCount;
     delete[] this->fCount;
@@ -68,7 +68,7 @@ template <int D> OperatorStatistics<D>::~OperatorStatistics() {
 }
 
 /** Sum all node counters from all threads. */
-template <int D> void OperatorStatistics<D>::flushNodeCounters() {
+template <int D, typename T> void OperatorStatistics<D, T>::flushNodeCounters() {
     for (int i = 0; i < this->nThreads; i++) {
         this->totFCount += this->fCount[i];
         this->totGCount += this->gCount[i];
@@ -82,20 +82,20 @@ template <int D> void OperatorStatistics<D>::flushNodeCounters() {
 }
 
 /** Increment g-node usage counter. Needed for load balancing. */
-template <int D> void OperatorStatistics<D>::incrementGNodeCounters(const MWNode<D> &gNode) {
+template <int D, typename T> void OperatorStatistics<D, T>::incrementGNodeCounters(const MWNode<D, T> &gNode) {
     int thread = mrcpp_get_thread_num();
     this->gCount[thread]++;
 }
 
 /** Increment operator application counter. */
-template <int D> void OperatorStatistics<D>::incrementFNodeCounters(const MWNode<D> &fNode, int ft, int gt) {
+template <int D, typename T> void OperatorStatistics<D, T>::incrementFNodeCounters(const MWNode<D, T> &fNode, int ft, int gt) {
     int thread = mrcpp_get_thread_num();
     this->fCount[thread]++;
     (*this->compCount[thread])(ft, gt) += 1;
     if (fNode.isGenNode()) { this->genCount[thread]++; }
 }
 
-template <int D> std::ostream &OperatorStatistics<D>::print(std::ostream &o) const {
+template <int D, typename T> std::ostream &OperatorStatistics<D, T>::print(std::ostream &o) const {
     o << std::setw(8);
     o << "*OperatorFunc statistics: " << std::endl << std::endl;
     o << "  Total calculated gNodes      : " << this->totGCount << std::endl;
@@ -105,8 +105,12 @@ template <int D> std::ostream &OperatorStatistics<D>::print(std::ostream &o) con
     return o;
 }
 
-template class OperatorStatistics<1>;
-template class OperatorStatistics<2>;
-template class OperatorStatistics<3>;
+template class OperatorStatistics<1, double>;
+template class OperatorStatistics<2, double>;
+template class OperatorStatistics<3, double>;
+
+template class OperatorStatistics<1, ComplexDouble>;
+template class OperatorStatistics<2, ComplexDouble>;
+template class OperatorStatistics<3, ComplexDouble>;
 
 } // namespace mrcpp
diff --git a/src/operators/OperatorStatistics.h b/src/operators/OperatorStatistics.h
index 395a5d62a..9de97f8e0 100644
--- a/src/operators/OperatorStatistics.h
+++ b/src/operators/OperatorStatistics.h
@@ -32,14 +32,14 @@
 
 namespace mrcpp {
 
-template <int D> class OperatorStatistics final {
+  template <int D, typename T> class OperatorStatistics final {
 public:
     OperatorStatistics();
     ~OperatorStatistics();
 
     void flushNodeCounters();
-    void incrementFNodeCounters(const MWNode<D> &fNode, int ft, int gt);
-    void incrementGNodeCounters(const MWNode<D> &gNode);
+    void incrementFNodeCounters(const MWNode<D, T> &fNode, int ft, int gt);
+    void incrementGNodeCounters(const MWNode<D, T> &gNode);
 
     friend std::ostream &operator<<(std::ostream &o, const OperatorStatistics &os) { return os.print(o); }
 
diff --git a/src/treebuilders/AdditionCalculator.h b/src/treebuilders/AdditionCalculator.h
index 431600192..a7804a761 100644
--- a/src/treebuilders/AdditionCalculator.h
+++ b/src/treebuilders/AdditionCalculator.h
@@ -30,24 +30,24 @@
 
 namespace mrcpp {
 
-template <int D> class AdditionCalculator final : public TreeCalculator<D> {
+template <int D, typename T> class AdditionCalculator final : public TreeCalculator<D, T> {
 public:
-    AdditionCalculator(const FunctionTreeVector<D> &inp)
+    AdditionCalculator(const FunctionTreeVector<D, T> &inp)
             : sum_vec(inp) {}
 
 private:
-    FunctionTreeVector<D> sum_vec;
+    FunctionTreeVector<D, T> sum_vec;
 
-    void calcNode(MWNode<D> &node_o) override {
+    void calcNode(MWNode<D, T> &node_o) override {
         node_o.zeroCoefs();
         const NodeIndex<D> &idx = node_o.getNodeIndex();
-        double *coefs_o = node_o.getCoefs();
+        T *coefs_o = node_o.getCoefs();
         for (int i = 0; i < this->sum_vec.size(); i++) {
-            double c_i = get_coef(this->sum_vec, i);
-            FunctionTree<D> &func_i = get_func(this->sum_vec, i);
+            T c_i = get_coef(this->sum_vec, i);
+            FunctionTree<D, T> &func_i = get_func(this->sum_vec, i);
             // This generates missing nodes
-            const MWNode<D> &node_i = func_i.getNode(idx);
-            const double *coefs_i = node_i.getCoefs();
+            const MWNode<D, T> &node_i = func_i.getNode(idx);
+            const T *coefs_i = node_i.getCoefs();
             int n_coefs = node_i.getNCoefs();
             for (int j = 0; j < n_coefs; j++) { coefs_o[j] += c_i * coefs_i[j]; }
         }
diff --git a/src/treebuilders/AnalyticAdaptor.h b/src/treebuilders/AnalyticAdaptor.h
index 45f73b4cd..d735933ec 100644
--- a/src/treebuilders/AnalyticAdaptor.h
+++ b/src/treebuilders/AnalyticAdaptor.h
@@ -30,16 +30,16 @@
 
 namespace mrcpp {
 
-template <int D> class AnalyticAdaptor final : public TreeAdaptor<D> {
+  template <int D, typename T> class AnalyticAdaptor final : public TreeAdaptor<D, T> {
 public:
-    AnalyticAdaptor(const RepresentableFunction<D> &f, int ms)
-            : TreeAdaptor<D>(ms)
+    AnalyticAdaptor(const RepresentableFunction<D, T> &f, int ms)
+      : TreeAdaptor<D, T>(ms)
             , func(&f) {}
 
 private:
-    const RepresentableFunction<D> *func;
+    const RepresentableFunction<D, T> *func;
 
-    bool splitNode(const MWNode<D> &node) const override {
+    bool splitNode(const MWNode<D, T> &node) const override {
         int scale = node.getScale();
         int nQuadPts = node.getKp1();
         if (this->func->isVisibleAtScale(scale, nQuadPts)) return false;
diff --git a/src/treebuilders/ConvolutionCalculator.cpp b/src/treebuilders/ConvolutionCalculator.cpp
index 668c86dbf..7da95813b 100644
--- a/src/treebuilders/ConvolutionCalculator.cpp
+++ b/src/treebuilders/ConvolutionCalculator.cpp
@@ -46,8 +46,8 @@ using Eigen::MatrixXi;
 
 namespace mrcpp {
 
-template <int D>
-ConvolutionCalculator<D>::ConvolutionCalculator(double p, ConvolutionOperator<D> &o, FunctionTree<D> &f, int depth)
+template <int D, typename T>
+ConvolutionCalculator<D, T>::ConvolutionCalculator(double p, ConvolutionOperator<D> &o, FunctionTree<D, T> &f, int depth)
         : maxDepth(depth)
         , prec(p)
         , oper(&o)
@@ -57,14 +57,14 @@ ConvolutionCalculator<D>::ConvolutionCalculator(double p, ConvolutionOperator<D>
     initTimers();
 }
 
-template <int D> ConvolutionCalculator<D>::~ConvolutionCalculator() {
+template <int D, typename T> ConvolutionCalculator<D, T>::~ConvolutionCalculator() {
     clearTimers();
     this->operStat.flushNodeCounters();
     println(10, this->operStat);
     for (int i = 0; i < this->bandSizes.size(); i++) { delete this->bandSizes[i]; }
 }
 
-template <int D> void ConvolutionCalculator<D>::initTimers() {
+template <int D, typename T> void ConvolutionCalculator<D, T>::initTimers() {
     int nThreads = mrcpp_get_max_threads();
     for (int i = 0; i < nThreads; i++) {
         this->band_t.push_back(new Timer(false));
@@ -73,7 +73,7 @@ template <int D> void ConvolutionCalculator<D>::initTimers() {
     }
 }
 
-template <int D> void ConvolutionCalculator<D>::clearTimers() {
+template <int D, typename T> void ConvolutionCalculator<D, T>::clearTimers() {
     int nThreads = mrcpp_get_max_threads();
     for (int i = 0; i < nThreads; i++) {
         delete this->band_t[i];
@@ -85,7 +85,7 @@ template <int D> void ConvolutionCalculator<D>::clearTimers() {
     this->norm_t.clear();
 }
 
-template <int D> void ConvolutionCalculator<D>::printTimers() const {
+template <int D, typename T> void ConvolutionCalculator<D, T>::printTimers() const {
     int oldprec = Printer::setPrecision(1);
     int nThreads = mrcpp_get_max_threads();
     printout(20, "\n\nthread ");
@@ -102,7 +102,7 @@ template <int D> void ConvolutionCalculator<D>::printTimers() const {
 
 /** Initialize the number of nodes formally within the bandwidth of an
  operator. The band size is used for thresholding. */
-template <int D> void ConvolutionCalculator<D>::initBandSizes() {
+template <int D, typename T> void ConvolutionCalculator<D, T>::initBandSizes() {
     for (int i = 0; i < this->oper->size(); i++) {
         // IMPORTANT: only 0-th dimension!
         const OperatorTree &oTree = this->oper->getComponent(i, 0);
@@ -118,7 +118,7 @@ template <int D> void ConvolutionCalculator<D>::initBandSizes() {
  * of an operator. Currently this routine ignores the fact that
  * there are edges on the world box, and thus over estimates
  * the number of nodes. This is different from the previous version. */
-template <int D> void ConvolutionCalculator<D>::calcBandSizeFactor(MatrixXi &bs, int depth, const BandWidth &bw) {
+template <int D, typename T> void ConvolutionCalculator<D, T>::calcBandSizeFactor(MatrixXi &bs, int depth, const BandWidth &bw) {
     for (int gt = 0; gt < this->nComp; gt++) {
         for (int ft = 0; ft < this->nComp; ft++) {
             int k = gt * this->nComp + ft;
@@ -139,8 +139,8 @@ template <int D> void ConvolutionCalculator<D>::calcBandSizeFactor(MatrixXi &bs,
 }
 
 /** Return a vector of nodes in F affected by O, given a node in G */
-template <int D> MWNodeVector<D> *ConvolutionCalculator<D>::makeOperBand(const MWNode<D> &gNode, std::vector<NodeIndex<D>> &idx_band) {
-    auto *band = new MWNodeVector<D>;
+template <int D, typename T> MWNodeVector<D, T> *ConvolutionCalculator<D, T>::makeOperBand(const MWNode<D, T> &gNode, std::vector<NodeIndex<D>> &idx_band) {
+    auto *band = new MWNodeVector<D, T>;
 
     int o_depth = gNode.getScale() - this->oper->getOperatorRoot();
     int g_depth = gNode.getDepth();
@@ -150,7 +150,7 @@ template <int D> MWNodeVector<D> *ConvolutionCalculator<D>::makeOperBand(const M
     int reach = this->oper->getOperatorReach();
 
     if (width >= 0) {
-        const NodeBox<D> &fWorld = this->fTree->getRootBox();
+        const NodeBox<D, T> &fWorld = this->fTree->getRootBox();
         const NodeIndex<D> &cIdx = fWorld.getCornerIndex();
         const NodeIndex<D> &gIdx = gNode.getNodeIndex();
 
@@ -180,7 +180,7 @@ template <int D> MWNodeVector<D> *ConvolutionCalculator<D>::makeOperBand(const M
 }
 
 /** Recursively retrieve all reachable f-nodes within the bandwidth. */
-template <int D> void ConvolutionCalculator<D>::fillOperBand(MWNodeVector<D> *band, std::vector<NodeIndex<D>> &idx_band, NodeIndex<D> &idx, const int *nbox, int dim) {
+template <int D, typename T> void ConvolutionCalculator<D, T>::fillOperBand(MWNodeVector<D, T> *band, std::vector<NodeIndex<D>> &idx_band, NodeIndex<D> &idx, const int *nbox, int dim) {
     int l_start = idx[dim];
     for (int j = 0; j < nbox[dim]; j++) {
         // Recurse until dim == 0
@@ -190,7 +190,7 @@ template <int D> void ConvolutionCalculator<D>::fillOperBand(MWNodeVector<D> *ba
             continue;
         }
         if (not manipulateOperator) {
-            MWNode<D> &fNode = this->fTree->getNode(idx);
+            MWNode<D, T> &fNode = this->fTree->getNode(idx);
             idx_band.push_back(idx);
             band->push_back(&fNode);
 
@@ -198,18 +198,18 @@ template <int D> void ConvolutionCalculator<D>::fillOperBand(MWNodeVector<D> *ba
             const auto oper_scale = this->oper->getOperatorRoot();
             if (oper_scale == 0) {
                 if (periodic::in_unit_cell<D>(idx) and onUnitcell) {
-                    MWNode<D> &fNode = this->fTree->getNode(idx);
+                    MWNode<D, T> &fNode = this->fTree->getNode(idx);
                     idx_band.push_back(idx);
                     band->push_back(&fNode);
                 }
                 if (not periodic::in_unit_cell<D>(idx) and not onUnitcell) {
-                    MWNode<D> &fNode = this->fTree->getNode(idx);
+                    MWNode<D, T> &fNode = this->fTree->getNode(idx);
                     idx_band.push_back(idx);
                     band->push_back(&fNode);
                 }
             } else if (oper_scale < 0) {
                 if (periodic::in_unit_cell<D>(idx) and onUnitcell) {
-                    MWNode<D> &fNode = this->fTree->getNode(idx);
+                    MWNode<D, T> &fNode = this->fTree->getNode(idx);
                     idx_band.push_back(idx);
                     band->push_back(&fNode);
                 }
@@ -222,23 +222,23 @@ template <int D> void ConvolutionCalculator<D>::fillOperBand(MWNodeVector<D> *ba
     idx[dim] = l_start;
 }
 
-template <int D> void ConvolutionCalculator<D>::calcNode(MWNode<D> &node) {
-    auto &gNode = static_cast<FunctionNode<D> &>(node);
+template <int D, typename T> void ConvolutionCalculator<D, T>::calcNode(MWNode<D, T> &node) {
+    auto &gNode = static_cast<FunctionNode<D, T> &>(node);
     gNode.zeroCoefs();
 
     int o_depth = gNode.getScale() - this->oper->getOperatorRoot();
     if (manipulateOperator and this->oper->getOperatorRoot() < 0) o_depth = gNode.getDepth();
-    double tmpCoefs[gNode.getNCoefs()];
-    OperatorState<D> os(gNode, tmpCoefs);
+    T tmpCoefs[gNode.getNCoefs()];
+    OperatorState<D, T> os(gNode, tmpCoefs);
     this->operStat.incrementGNodeCounters(gNode);
 
     // Get all nodes in f within the bandwith of O in g
     this->band_t[mrcpp_get_thread_num()]->resume();
     std::vector<NodeIndex<D>> idx_band;
-    MWNodeVector<D> *fBand = makeOperBand(gNode, idx_band);
+    MWNodeVector<D, T> *fBand = makeOperBand(gNode, idx_band);
     this->band_t[mrcpp_get_thread_num()]->stop();
 
-    MWTree<D> &gTree = gNode.getMWTree();
+    MWTree<D, T> &gTree = gNode.getMWTree();
     double gThrs = gTree.getSquareNorm();
     if (gThrs > 0.0) {
         auto nTerms = static_cast<double>(this->oper->size());
@@ -250,7 +250,7 @@ template <int D> void ConvolutionCalculator<D>::calcNode(MWNode<D> &node) {
 
     this->calc_t[mrcpp_get_thread_num()]->resume();
     for (int n = 0; n < fBand->size(); n++) {
-        MWNode<D> &fNode = *(*fBand)[n];
+        MWNode<D, T> &fNode = *(*fBand)[n];
         NodeIndex<D> &fIdx = idx_band[n];
         os.setFNode(fNode);
         os.setFIndex(fIdx);
@@ -275,7 +275,7 @@ template <int D> void ConvolutionCalculator<D>::calcNode(MWNode<D> &node) {
 }
 
 /** Apply each component (term) of the operator expansion to a node in f */
-template <int D> void ConvolutionCalculator<D>::applyOperComp(OperatorState<D> &os) {
+  template <int D, typename T> void ConvolutionCalculator<D, T>::applyOperComp(OperatorState<D, T> &os) {
     double fNorm = os.fNode->getComponentNorm(os.ft);
     int o_depth = os.fNode->getScale() - this->oper->getOperatorRoot();
     for (int i = 0; i < this->oper->size(); i++) {
@@ -288,7 +288,6 @@ template <int D> void ConvolutionCalculator<D>::applyOperComp(OperatorState<D> &
     }
 }
 
-
 /** @brief Apply a single operator component (term) to a single f-node.
  * 
  * @details Apply a single operator component (term) to a single f-node.
@@ -296,9 +295,10 @@ template <int D> void ConvolutionCalculator<D>::applyOperComp(OperatorState<D> &
  * Here we make use of the sparcity of matrices \f$ A, B, C \f$.
  * 
  */
-template <int D> void ConvolutionCalculator<D>::applyOperator(int i, OperatorState<D> &os) {
-    MWNode<D> &gNode = *os.gNode;
-    MWNode<D> &fNode = *os.fNode;
+ template <int D, typename T> void ConvolutionCalculator<D, T>::applyOperator(int i, OperatorState<D, T> &os) {
+    MWNode<D, T> &gNode = *os.gNode;
+    MWNode<D, T> &fNode = *os.fNode;
+
     const NodeIndex<D> &fIdx = *os.fIdx;
     const NodeIndex<D> &gIdx = gNode.getNodeIndex();
     int o_depth = gNode.getScale() - this->oper->getOperatorRoot();
@@ -331,9 +331,10 @@ template <int D> void ConvolutionCalculator<D>::applyOperator(int i, OperatorSta
 
 /** Perorm the required linear algebra operations in order to apply an
 operator component to a f-node in a n-dimensional tesor space. */
-template <int D> void ConvolutionCalculator<D>::tensorApplyOperComp(OperatorState<D> &os) {
-    double **aux = os.getAuxData();
+  template <int D, typename T> void ConvolutionCalculator<D, T>::tensorApplyOperComp(OperatorState<D, T> &os) {
+    T **aux = os.getAuxData();
     double **oData = os.getOperData();
+    /*
 #ifdef HAVE_BLAS
     double mult = 0.0;
     for (int i = 0; i < D; i++) {
@@ -358,9 +359,10 @@ template <int D> void ConvolutionCalculator<D>::tensorApplyOperComp(OperatorStat
         }
     }
 #else
+    */
     for (int i = 0; i < D; i++) {
-        Eigen::Map<MatrixXd> f(aux[i], os.kp1, os.kp1_dm1);
-        Eigen::Map<MatrixXd> g(aux[i + 1], os.kp1_dm1, os.kp1);
+        Eigen::Map<Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >> f(aux[i], os.kp1, os.kp1_dm1);
+        Eigen::Map<Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >> g(aux[i + 1], os.kp1_dm1, os.kp1);
         if (oData[i] != nullptr) {
             Eigen::Map<MatrixXd> op(oData[i], os.kp1, os.kp1);
             if (i == D - 1) { // Last dir: Add up into g
@@ -377,10 +379,10 @@ template <int D> void ConvolutionCalculator<D>::tensorApplyOperComp(OperatorStat
             }
         }
     }
-#endif
+    //#endif
 }
 
-template <int D> void ConvolutionCalculator<D>::touchParentNodes(MWTree<D> &tree) const {
+template <int D, typename T> void ConvolutionCalculator<D, T>::touchParentNodes(MWTree<D, T> &tree) const {
     if (not manipulateOperator) {
         const auto oper_scale = this->oper->getOperatorRoot();
         auto car_prod = math_utils::cartesian_product(std::vector<int>{-1, 0}, D);
@@ -396,15 +398,19 @@ template <int D> void ConvolutionCalculator<D>::touchParentNodes(MWTree<D> &tree
     }
 }
 
-template <int D> MWNodeVector<D> *ConvolutionCalculator<D>::getInitialWorkVector(MWTree<D> &tree) const {
-    auto *nodeVec = new MWNodeVector<D>;
+template <int D, typename T> MWNodeVector<D, T> *ConvolutionCalculator<D, T>::getInitialWorkVector(MWTree<D, T> &tree) const {
+    auto *nodeVec = new MWNodeVector<D, T>;
     if (tree.isPeriodic()) touchParentNodes(tree);
     tree_utils::make_node_table(tree, *nodeVec);
     return nodeVec;
 }
 
-template class ConvolutionCalculator<1>;
-template class ConvolutionCalculator<2>;
-template class ConvolutionCalculator<3>;
+template class ConvolutionCalculator<1, double>;
+template class ConvolutionCalculator<2, double>;
+template class ConvolutionCalculator<3, double>;
+
+template class ConvolutionCalculator<1, ComplexDouble>;
+template class ConvolutionCalculator<2, ComplexDouble>;
+template class ConvolutionCalculator<3, ComplexDouble>;
 
 } // namespace mrcpp
diff --git a/src/treebuilders/ConvolutionCalculator.h b/src/treebuilders/ConvolutionCalculator.h
index 3b88cb9b1..f114ba976 100644
--- a/src/treebuilders/ConvolutionCalculator.h
+++ b/src/treebuilders/ConvolutionCalculator.h
@@ -33,12 +33,12 @@
 
 namespace mrcpp {
 
-template <int D> class ConvolutionCalculator final : public TreeCalculator<D> {
+template <int D, typename T> class ConvolutionCalculator final : public TreeCalculator<D, T> {
 public:
-    ConvolutionCalculator(double p, ConvolutionOperator<D> &o, FunctionTree<D> &f, int depth = MaxDepth);
+    ConvolutionCalculator(double p, ConvolutionOperator<D> &o, FunctionTree<D, T> &f, int depth = MaxDepth);
     ~ConvolutionCalculator() override;
 
-    MWNodeVector<D> *getInitialWorkVector(MWTree<D> &tree) const override;
+    MWNodeVector<D, T> *getInitialWorkVector(MWTree<D, T> &tree) const override;
 
     void setPrecFunction(const std::function<double(const NodeIndex<D> &idx)> &prec_func) { this->precFunc = prec_func; }
     void startManipulateOperator(bool excUnit) {
@@ -52,45 +52,45 @@ template <int D> class ConvolutionCalculator final : public TreeCalculator<D> {
     bool manipulateOperator{false};
     bool onUnitcell{false};
     ConvolutionOperator<D> *oper;
-    FunctionTree<D> *fTree;
+    FunctionTree<D, T> *fTree;
     std::vector<Timer *> band_t;
     std::vector<Timer *> calc_t;
     std::vector<Timer *> norm_t;
 
-    OperatorStatistics<D> operStat;
+    OperatorStatistics<D, T> operStat;
     std::vector<Eigen::MatrixXi *> bandSizes;
     std::function<double(const NodeIndex<D> &idx)> precFunc = [](const NodeIndex<D> &idx) { return 1.0; };
 
     static const int nComp = (1 << D);
     static const int nComp2 = (1 << D) * (1 << D);
 
-    MWNodeVector<D> *makeOperBand(const MWNode<D> &gNode, std::vector<NodeIndex<D>> &idx_band);
-    void fillOperBand(MWNodeVector<D> *band, std::vector<NodeIndex<D>> &idx_band, NodeIndex<D> &idx, const int *nbox, int dim);
+    MWNodeVector<D, T> *makeOperBand(const MWNode<D, T> &gNode, std::vector<NodeIndex<D>> &idx_band);
+    void fillOperBand(MWNodeVector<D, T> *band, std::vector<NodeIndex<D>> &idx_band, NodeIndex<D> &idx, const int *nbox, int dim);
 
     void initTimers();
     void clearTimers();
     void printTimers() const;
 
     void initBandSizes();
-    int getBandSizeFactor(int i, int depth, const OperatorState<D> &os) const {
+    int getBandSizeFactor(int i, int depth, const OperatorState<D, T> &os) const {
         int k = os.gt * this->nComp + os.ft;
         return (*this->bandSizes[i])(depth, k);
     }
 
     void calcBandSizeFactor(Eigen::MatrixXi &bs, int depth, const BandWidth &bw);
 
-    void calcNode(MWNode<D> &node) override;
+    void calcNode(MWNode<D, T> &node) override;
     void postProcess() override {
         printTimers();
         clearTimers();
         initTimers();
     }
 
-    void applyOperComp(OperatorState<D> &os);
-    void applyOperator(int i, OperatorState<D> &os);
-    void tensorApplyOperComp(OperatorState<D> &os);
+    void applyOperComp(OperatorState<D, T> &os);
+    void applyOperator(int i, OperatorState<D, T> &os);
+    void tensorApplyOperComp(OperatorState<D, T> &os);
 
-    void touchParentNodes(MWTree<D> &tree) const;
+    void touchParentNodes(MWTree<D, T> &tree) const;
 };
 
 } // namespace mrcpp
diff --git a/src/treebuilders/CopyAdaptor.cpp b/src/treebuilders/CopyAdaptor.cpp
index 4017c6e5e..8312ebb0f 100644
--- a/src/treebuilders/CopyAdaptor.cpp
+++ b/src/treebuilders/CopyAdaptor.cpp
@@ -29,21 +29,21 @@
 
 namespace mrcpp {
 
-template <int D>
-CopyAdaptor<D>::CopyAdaptor(FunctionTree<D> &t, int ms, int *bw)
-        : TreeAdaptor<D>(ms) {
+template <int D, typename T>
+CopyAdaptor<D, T>::CopyAdaptor(FunctionTree<D, T> &t, int ms, int *bw)
+        : TreeAdaptor<D, T>(ms) {
     setBandWidth(bw);
     tree_vec.push_back(std::make_tuple(1.0, &t));
 }
 
-template <int D>
-CopyAdaptor<D>::CopyAdaptor(FunctionTreeVector<D> &t, int ms, int *bw)
-        : TreeAdaptor<D>(ms)
+template <int D, typename T>
+CopyAdaptor<D, T>::CopyAdaptor(FunctionTreeVector<D, T> &t, int ms, int *bw)
+        : TreeAdaptor<D, T>(ms)
         , tree_vec(t) {
     setBandWidth(bw);
 }
 
-template <int D> void CopyAdaptor<D>::setBandWidth(int *bw) {
+template <int D, typename T> void CopyAdaptor<D, T>::setBandWidth(int *bw) {
     for (int d = 0; d < D; d++) {
         if (bw != nullptr) {
             this->bandWidth[d] = bw[d];
@@ -53,7 +53,7 @@ template <int D> void CopyAdaptor<D>::setBandWidth(int *bw) {
     }
 }
 
-template <int D> bool CopyAdaptor<D>::splitNode(const MWNode<D> &node) const {
+template <int D, typename T> bool CopyAdaptor<D, T>::splitNode(const MWNode<D, T> &node) const {
     const NodeIndex<D> &idx = node.getNodeIndex();
     for (int c = 0; c < node.getTDim(); c++) {
         for (int d = 0; d < D; d++) {
@@ -61,8 +61,8 @@ template <int D> bool CopyAdaptor<D>::splitNode(const MWNode<D> &node) const {
                 NodeIndex<D> bwIdx = idx.child(c);
                 bwIdx[d] += bw;
                 for (int i = 0; i < this->tree_vec.size(); i++) {
-                    const FunctionTree<D> &func_i = get_func(tree_vec, i);
-                    const MWNode<D> *node_i = func_i.findNode(bwIdx);
+                    const FunctionTree<D, T> &func_i = get_func(tree_vec, i);
+                    const MWNode<D, T> *node_i = func_i.findNode(bwIdx);
                     if (node_i != nullptr) return true;
                 }
             }
@@ -71,8 +71,12 @@ template <int D> bool CopyAdaptor<D>::splitNode(const MWNode<D> &node) const {
     return false;
 }
 
-template class CopyAdaptor<1>;
-template class CopyAdaptor<2>;
-template class CopyAdaptor<3>;
+template class CopyAdaptor<1, double>;
+template class CopyAdaptor<2, double>;
+template class CopyAdaptor<3, double>;
+
+template class CopyAdaptor<1, ComplexDouble>;
+template class CopyAdaptor<2, ComplexDouble>;
+template class CopyAdaptor<3, ComplexDouble>;
 
 } // namespace mrcpp
diff --git a/src/treebuilders/CopyAdaptor.h b/src/treebuilders/CopyAdaptor.h
index c9451e599..adeeb6766 100644
--- a/src/treebuilders/CopyAdaptor.h
+++ b/src/treebuilders/CopyAdaptor.h
@@ -30,17 +30,17 @@
 
 namespace mrcpp {
 
-template <int D> class CopyAdaptor final : public TreeAdaptor<D> {
+  template <int D, typename T> class CopyAdaptor final : public TreeAdaptor<D, T> {
 public:
-    CopyAdaptor(FunctionTree<D> &t, int ms, int *bw);
-    CopyAdaptor(FunctionTreeVector<D> &t, int ms, int *bw);
+    CopyAdaptor(FunctionTree<D, T> &t, int ms, int *bw);
+    CopyAdaptor(FunctionTreeVector<D, T> &t, int ms, int *bw);
 
 private:
     int bandWidth[D];
-    FunctionTreeVector<D> tree_vec;
+    FunctionTreeVector<D, T> tree_vec;
 
     void setBandWidth(int *bw);
-    bool splitNode(const MWNode<D> &node) const override;
+    bool splitNode(const MWNode<D, T> &node) const override;
 };
 
 } // namespace mrcpp
diff --git a/src/treebuilders/CrossCorrelationCalculator.cpp b/src/treebuilders/CrossCorrelationCalculator.cpp
index efe9a3390..b4c2fc3ad 100644
--- a/src/treebuilders/CrossCorrelationCalculator.cpp
+++ b/src/treebuilders/CrossCorrelationCalculator.cpp
@@ -77,7 +77,7 @@ template <int T> void CrossCorrelationCalculator::applyCcc(MWNode<2> &node, Cros
         const MWNode<1> &node_a = this->kernel->getNode(idx_a);
         const MWNode<1> &node_b = this->kernel->getNode(idx_b);
 
-        VectorXd vec_a;
+        Eigen::Matrix<double, Eigen::Dynamic, 1> vec_a;
         VectorXd vec_b;
         node_a.getCoefs(vec_a);
         node_b.getCoefs(vec_b);
diff --git a/src/treebuilders/DefaultCalculator.h b/src/treebuilders/DefaultCalculator.h
index 13f698162..4a1a4ce54 100644
--- a/src/treebuilders/DefaultCalculator.h
+++ b/src/treebuilders/DefaultCalculator.h
@@ -29,16 +29,16 @@
 
 namespace mrcpp {
 
-template <int D> class DefaultCalculator final : public TreeCalculator<D> {
+template <int D, typename T> class DefaultCalculator final : public TreeCalculator<D, T> {
 public:
     // Reimplementation without OpenMP, the default is faster this way
-    void calcNodeVector(MWNodeVector<D> &nodeVec) override {
+    void calcNodeVector(MWNodeVector<D, T> &nodeVec) override {
         int nNodes = nodeVec.size();
         for (int n = 0; n < nNodes; n++) { calcNode(*nodeVec[n]); }
     }
 
 private:
-    void calcNode(MWNode<D> &node) override {
+    void calcNode(MWNode<D, T> &node) override {
         node.clearHasCoefs();
         node.clearNorms();
     }
diff --git a/src/treebuilders/DerivativeCalculator.cpp b/src/treebuilders/DerivativeCalculator.cpp
index a5acdc297..9f384013e 100644
--- a/src/treebuilders/DerivativeCalculator.cpp
+++ b/src/treebuilders/DerivativeCalculator.cpp
@@ -42,8 +42,8 @@ using Eigen::MatrixXd;
 
 namespace mrcpp {
 
-template <int D>
-DerivativeCalculator<D>::DerivativeCalculator(int dir, DerivativeOperator<D> &o, FunctionTree<D> &f)
+template <int D, typename T>
+DerivativeCalculator<D, T>::DerivativeCalculator(int dir, DerivativeOperator<D> &o, FunctionTree<D, T> &f)
         : applyDir(dir)
         , fTree(&f)
         , oper(&o) {
@@ -51,12 +51,12 @@ DerivativeCalculator<D>::DerivativeCalculator(int dir, DerivativeOperator<D> &o,
     initTimers();
 }
 
-template <int D> DerivativeCalculator<D>::~DerivativeCalculator() {
+template <int D, typename T> DerivativeCalculator<D, T>::~DerivativeCalculator() {
     this->operStat.flushNodeCounters();
     println(10, this->operStat);
 }
 
-template <int D> void DerivativeCalculator<D>::initTimers() {
+template <int D, typename T> void DerivativeCalculator<D, T>::initTimers() {
     int nThreads = mrcpp_get_max_threads();
     for (int i = 0; i < nThreads; i++) {
         this->band_t.push_back(Timer(false));
@@ -65,13 +65,13 @@ template <int D> void DerivativeCalculator<D>::initTimers() {
     }
 }
 
-template <int D> void DerivativeCalculator<D>::clearTimers() {
+template <int D, typename T> void DerivativeCalculator<D, T>::clearTimers() {
     this->band_t.clear();
     this->calc_t.clear();
     this->norm_t.clear();
 }
 
-template <int D> void DerivativeCalculator<D>::printTimers() const {
+template <int D, typename T> void DerivativeCalculator<D, T>::printTimers() const {
     int oldprec = Printer::setPrecision(1);
     int nThreads = mrcpp_get_max_threads();
     printout(20, "\n\nthread ");
@@ -86,12 +86,12 @@ template <int D> void DerivativeCalculator<D>::printTimers() const {
     Printer::setPrecision(oldprec);
 }
 
-template <int D> void DerivativeCalculator<D>::calcNode(MWNode<D> &inpNode, MWNode<D> &outNode) {
+    template <int D, typename T> void DerivativeCalculator<D, T>::calcNode(MWNode<D, T> &inpNode, MWNode<D, T> &outNode) {
     //if (this->oper->getMaxBandWidth() > 1) MSG_ABORT("Only implemented for zero bw");
     outNode.zeroCoefs();
     int nComp = (1 << D);
-    double tmpCoefs[outNode.getNCoefs()];
-    OperatorState<D> os(outNode, tmpCoefs);
+    T tmpCoefs[outNode.getNCoefs()];
+    OperatorState<D, T> os(outNode, tmpCoefs);
 
     os.setFNode(inpNode);
     os.setFIndex(inpNode.nodeIndex);
@@ -114,24 +114,24 @@ template <int D> void DerivativeCalculator<D>::calcNode(MWNode<D> &inpNode, MWNo
 }
 
 
-template <int D> void DerivativeCalculator<D>::calcNode(MWNode<D> &gNode) {
+template <int D, typename T> void DerivativeCalculator<D, T>::calcNode(MWNode<D, T> &gNode) {
     gNode.zeroCoefs();
 
     int nComp = (1 << D);
-    double tmpCoefs[gNode.getNCoefs()];
-    OperatorState<D> os(gNode, tmpCoefs);
+    T tmpCoefs[gNode.getNCoefs()];
+    OperatorState<D, T> os(gNode, tmpCoefs);
     this->operStat.incrementGNodeCounters(gNode);
 
     // Get all nodes in f within the bandwith of O in g
     this->band_t[mrcpp_get_thread_num()].resume();
     std::vector<NodeIndex<D>> idx_band;
-    MWNodeVector<D> fBand = makeOperBand(gNode, idx_band);
+    MWNodeVector<D, T> fBand = makeOperBand(gNode, idx_band);
     this->band_t[mrcpp_get_thread_num()].stop();
 
     this->calc_t[mrcpp_get_thread_num()].resume();
 
     for (int n = 0; n < fBand.size(); n++) {
-        MWNode<D> &fNode = *fBand[n];
+        MWNode<D, T> &fNode = *fBand[n];
         NodeIndex<D> &fIdx = idx_band[n];
         os.setFNode(fNode);
         os.setFIndex(fIdx);
@@ -157,12 +157,12 @@ template <int D> void DerivativeCalculator<D>::calcNode(MWNode<D> &gNode) {
 }
 
 /** Return a vector of nodes in F affected by O, given a node in G */
-template <int D>
-MWNodeVector<D> DerivativeCalculator<D>::makeOperBand(const MWNode<D> &gNode, std::vector<NodeIndex<D>> &idx_band) {
+template <int D, typename T>
+MWNodeVector<D, T> DerivativeCalculator<D, T>::makeOperBand(const MWNode<D, T> &gNode, std::vector<NodeIndex<D>> &idx_band) {
     assert(this->applyDir >= 0);
     assert(this->applyDir < D);
 
-    MWNodeVector<D> band;
+    MWNodeVector<D, T> band;
     const NodeIndex<D> &idx_0 = gNode.getNodeIndex();
 
     // Assumes given width only in applyDir, otherwise width = 0
@@ -182,10 +182,10 @@ MWNodeVector<D> DerivativeCalculator<D>::makeOperBand(const MWNode<D> &gNode, st
 }
 
 /** Apply a single operator component (term) to a single f-node assuming zero bandwidth */
-template <int D> void DerivativeCalculator<D>::applyOperator_bw0(OperatorState<D> &os) {
+template <int D, typename T> void DerivativeCalculator<D, T>::applyOperator_bw0(OperatorState<D, T> &os) {
     //cout<<" applyOperator "<<endl;
-    MWNode<D> &gNode = *os.gNode;
-    MWNode<D> &fNode = *os.fNode;
+    MWNode<D, T> &gNode = *os.gNode;
+    MWNode<D, T> &fNode = *os.fNode;
     const NodeIndex<D> &fIdx = *os.fIdx;
     const NodeIndex<D> &gIdx = gNode.getNodeIndex();
     int depth = gNode.getDepth();
@@ -216,9 +216,9 @@ template <int D> void DerivativeCalculator<D>::applyOperator_bw0(OperatorState<D
 
 /** Apply a single operator component (term) to a single f-node. Whether the
 operator actualy is applied is determined by a screening threshold. */
-template <int D> void DerivativeCalculator<D>::applyOperator(OperatorState<D> &os) {
-    MWNode<D> &gNode = *os.gNode;
-    MWNode<D> &fNode = *os.fNode;
+template <int D, typename T> void DerivativeCalculator<D, T>::applyOperator(OperatorState<D, T> &os) {
+    MWNode<D, T> &gNode = *os.gNode;
+    MWNode<D, T> &fNode = *os.fNode;
     const NodeIndex<D> &fIdx = *os.fIdx;
     const NodeIndex<D> &gIdx = gNode.getNodeIndex();
     int depth = gNode.getDepth();
@@ -261,9 +261,10 @@ template <int D> void DerivativeCalculator<D>::applyOperator(OperatorState<D> &o
 
 /** Perform the required linear algebra operations in order to apply an
 operator component to a f-node in a n-dimensional tensor space. */
-template <int D> void DerivativeCalculator<D>::tensorApplyOperComp(OperatorState<D> &os) {
-    double **aux = os.getAuxData();
+template <int D, typename T> void DerivativeCalculator<D, T>::tensorApplyOperComp(OperatorState<D, T> &os) {
+    T **aux = os.getAuxData();
     double **oData = os.getOperData();
+    /*
 #ifdef HAVE_BLAS
     double mult = 0.0;
     for (int i = 0; i < D; i++) {
@@ -271,8 +272,8 @@ template <int D> void DerivativeCalculator<D>::tensorApplyOperComp(OperatorState
             if (i == D - 1) { // Last dir: Add up into g
                 mult = 1.0;
             }
-            const double *f = aux[i];
-            double *g = const_cast<double *>(aux[i + 1]);
+            const T *f = aux[i];
+            T *g = const_cast<T *>(aux[i + 1]);
             cblas_dgemm(CblasColMajor,
                         CblasTrans,
                         CblasNoTrans,
@@ -301,9 +302,10 @@ template <int D> void DerivativeCalculator<D>::tensorApplyOperComp(OperatorState
         }
     }
 #else
+    */
     for (int i = 0; i < D; i++) {
-        Eigen::Map<MatrixXd> f(aux[i], os.kp1, os.kp1_dm1);
-        Eigen::Map<MatrixXd> g(aux[i + 1], os.kp1_dm1, os.kp1);
+        Eigen::Map<Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >> f(aux[i], os.kp1, os.kp1_dm1);
+        Eigen::Map<Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >> g(aux[i + 1], os.kp1_dm1, os.kp1);
         if (oData[i] != nullptr) {
             Eigen::Map<MatrixXd> op(oData[i], os.kp1, os.kp1);
             if (i == D - 1) { // Last dir: Add up into g
@@ -320,15 +322,19 @@ template <int D> void DerivativeCalculator<D>::tensorApplyOperComp(OperatorState
             }
         }
     }
-#endif
+    //#endif
 }
 
-template <int D> MWNodeVector<D> *DerivativeCalculator<D>::getInitialWorkVector(MWTree<D> &tree) const {
+template <int D, typename T> MWNodeVector<D, T> *DerivativeCalculator<D, T>::getInitialWorkVector(MWTree<D, T> &tree) const {
     return tree.copyEndNodeTable();
 }
 
-template class DerivativeCalculator<1>;
-template class DerivativeCalculator<2>;
-template class DerivativeCalculator<3>;
+template class DerivativeCalculator<1, double>;
+template class DerivativeCalculator<2, double>;
+template class DerivativeCalculator<3, double>;
+
+template class DerivativeCalculator<1, ComplexDouble>;
+template class DerivativeCalculator<2, ComplexDouble>;
+template class DerivativeCalculator<3, ComplexDouble>;
 
 } // namespace mrcpp
diff --git a/src/treebuilders/DerivativeCalculator.h b/src/treebuilders/DerivativeCalculator.h
index 5d4d28716..9adc48046 100644
--- a/src/treebuilders/DerivativeCalculator.h
+++ b/src/treebuilders/DerivativeCalculator.h
@@ -30,40 +30,40 @@
 
 namespace mrcpp {
 
-template <int D> class DerivativeCalculator final : public TreeCalculator<D> {
+template <int D, typename T> class DerivativeCalculator final : public TreeCalculator<D, T> {
 public:
-    DerivativeCalculator(int dir, DerivativeOperator<D> &o, FunctionTree<D> &f);
+  DerivativeCalculator(int dir, DerivativeOperator<D> &o, FunctionTree<D, T> &f);
     ~DerivativeCalculator() override;
 
-    MWNodeVector<D> *getInitialWorkVector(MWTree<D> &tree) const override;
-    void calcNode(MWNode<D> &fNode, MWNode<D> &gNode);
+    MWNodeVector<D, T> *getInitialWorkVector(MWTree<D, T> &tree) const override;
+    void calcNode(MWNode<D, T> &fNode, MWNode<D, T> &gNode);
 
 private:
     int applyDir;
-    FunctionTree<D> *fTree;
+    FunctionTree<D, T> *fTree;
     DerivativeOperator<D> *oper;
 
     std::vector<Timer> band_t;
     std::vector<Timer> calc_t;
     std::vector<Timer> norm_t;
-    OperatorStatistics<D> operStat;
+    OperatorStatistics<D, T> operStat;
 
-    MWNodeVector<D> makeOperBand(const MWNode<D> &gNode, std::vector<NodeIndex<D>> &idx_band);
+    MWNodeVector<D, T> makeOperBand(const MWNode<D, T> &gNode, std::vector<NodeIndex<D>> &idx_band);
 
     void initTimers();
     void clearTimers();
     void printTimers() const;
 
-    void calcNode(MWNode<D> &node) override;
+    void calcNode(MWNode<D, T> &node) override;
     void postProcess() override {
         printTimers();
         clearTimers();
         initTimers();
     }
 
-    void applyOperator(OperatorState<D> &os);
-    void applyOperator_bw0(OperatorState<D> &os);
-    void tensorApplyOperComp(OperatorState<D> &os);
+    void applyOperator(OperatorState<D, T> &os);
+    void applyOperator_bw0(OperatorState<D, T> &os);
+    void tensorApplyOperComp(OperatorState<D, T> &os);
 };
 
 } // namespace mrcpp
diff --git a/src/treebuilders/MapCalculator.h b/src/treebuilders/MapCalculator.h
index 492c1f440..33f799ee9 100644
--- a/src/treebuilders/MapCalculator.h
+++ b/src/treebuilders/MapCalculator.h
@@ -29,24 +29,24 @@
 
 namespace mrcpp {
 
-template <int D> class MapCalculator final : public TreeCalculator<D> {
+template <int D, typename T> class MapCalculator final : public TreeCalculator<D, T> {
 public:
-    MapCalculator(FMap fm, FunctionTree<D> &inp)
+    MapCalculator(FMap<T, T> fm, FunctionTree<D, T> &inp)
             : func(&inp)
             , fmap(std::move(fm)) {}
 
 private:
-    FunctionTree<D> *func;
-    FMap fmap;
-    void calcNode(MWNode<D> &node_o) override {
+    FunctionTree<D, T> *func;
+    FMap<T, T> fmap;
+    void calcNode(MWNode<D, T> &node_o) override {
         const NodeIndex<D> &idx = node_o.getNodeIndex();
         int n_coefs = node_o.getNCoefs();
-        double *coefs_o = node_o.getCoefs();
+        T *coefs_o = node_o.getCoefs();
         // This generates missing nodes
-        MWNode<D> node_i = func->getNode(idx); // Copy node
+        MWNode<D, T> node_i = func->getNode(idx); // Copy node
         node_i.mwTransform(Reconstruction);
         node_i.cvTransform(Forward);
-        const double *coefs_i = node_i.getCoefs();
+        const T *coefs_i = node_i.getCoefs();
         for (int j = 0; j < n_coefs; j++) { coefs_o[j] = fmap(coefs_i[j]); }
         node_o.cvTransform(Backward);
         node_o.mwTransform(Compression);
diff --git a/src/treebuilders/MultiplicationAdaptor.h b/src/treebuilders/MultiplicationAdaptor.h
index ff0fe992d..9637ac055 100644
--- a/src/treebuilders/MultiplicationAdaptor.h
+++ b/src/treebuilders/MultiplicationAdaptor.h
@@ -31,19 +31,19 @@
 
 namespace mrcpp {
 
-template <int D> class MultiplicationAdaptor : public TreeAdaptor<D> {
+template <int D, typename T> class MultiplicationAdaptor : public TreeAdaptor<D, T> {
 public:
-    MultiplicationAdaptor(double pr, int ms, FunctionTreeVector<D> &t)
-            : TreeAdaptor<D>(ms)
+    MultiplicationAdaptor(double pr, int ms, FunctionTreeVector<D, T> &t)
+            : TreeAdaptor<D, T>(ms)
             , prec(pr)
             , trees(t) {}
     ~MultiplicationAdaptor() override = default;
 
 protected:
     double prec;
-    mutable FunctionTreeVector<D> trees;
+    mutable FunctionTreeVector<D, T> trees;
 
-    bool splitNode(const MWNode<D> &node) const override {
+    bool splitNode(const MWNode<D, T> &node) const override {
         if (this->trees.size() != 2) MSG_ERROR("Invalid tree vec size: " << this->trees.size());
         auto &pNode0 = get_func(trees, 0).getNode(node.getNodeIndex());
         auto &pNode1 = get_func(trees, 1).getNode(node.getNodeIndex());
diff --git a/src/treebuilders/MultiplicationCalculator.h b/src/treebuilders/MultiplicationCalculator.h
index ba5669f4d..4f82756c2 100644
--- a/src/treebuilders/MultiplicationCalculator.h
+++ b/src/treebuilders/MultiplicationCalculator.h
@@ -30,26 +30,26 @@
 
 namespace mrcpp {
 
-template <int D> class MultiplicationCalculator final : public TreeCalculator<D> {
+template <int D, typename T> class MultiplicationCalculator final : public TreeCalculator<D, T> {
 public:
-    MultiplicationCalculator(const FunctionTreeVector<D> &inp)
+    MultiplicationCalculator(const FunctionTreeVector<D, T> &inp)
             : prod_vec(inp) {}
 
 private:
-    FunctionTreeVector<D> prod_vec;
+    FunctionTreeVector<D, T> prod_vec;
 
-    void calcNode(MWNode<D> &node_o) override {
+    void calcNode(MWNode<D, T> &node_o) override {
         const NodeIndex<D> &idx = node_o.getNodeIndex();
-        double *coefs_o = node_o.getCoefs();
+        T *coefs_o = node_o.getCoefs();
         for (int j = 0; j < node_o.getNCoefs(); j++) { coefs_o[j] = 1.0; }
         for (int i = 0; i < this->prod_vec.size(); i++) {
-            double c_i = get_coef(this->prod_vec, i);
-            FunctionTree<D> &func_i = get_func(this->prod_vec, i);
+            T c_i = get_coef(this->prod_vec, i);
+            FunctionTree<D, T> &func_i = get_func(this->prod_vec, i);
             // This generates missing nodes
-            MWNode<D> node_i = func_i.getNode(idx); // Copy node
+            MWNode<D, T> node_i = func_i.getNode(idx); // Copy node
             node_i.mwTransform(Reconstruction);
             node_i.cvTransform(Forward);
-            const double *coefs_i = node_i.getCoefs();
+            const T *coefs_i = node_i.getCoefs();
             int n_coefs = node_i.getNCoefs();
             for (int j = 0; j < n_coefs; j++) { coefs_o[j] *= c_i * coefs_i[j]; }
         }
diff --git a/src/treebuilders/PowerCalculator.h b/src/treebuilders/PowerCalculator.h
index bb2124b73..79147fc4b 100644
--- a/src/treebuilders/PowerCalculator.h
+++ b/src/treebuilders/PowerCalculator.h
@@ -29,25 +29,25 @@
 
 namespace mrcpp {
 
-template <int D> class PowerCalculator final : public TreeCalculator<D> {
+template <int D, typename T> class PowerCalculator final : public TreeCalculator<D, T> {
 public:
-    PowerCalculator(FunctionTree<D> &inp, double pow)
+    PowerCalculator(FunctionTree<D, T> &inp, double pow)
             : power(pow)
             , func(&inp) {}
 
 private:
     double power;
-    FunctionTree<D> *func;
+    FunctionTree<D, T> *func;
 
-    void calcNode(MWNode<D> &node_o) override {
+    void calcNode(MWNode<D, T> &node_o) override {
         const NodeIndex<D> &idx = node_o.getNodeIndex();
         int n_coefs = node_o.getNCoefs();
-        double *coefs_o = node_o.getCoefs();
+        T *coefs_o = node_o.getCoefs();
         // This generates missing nodes
-        MWNode<D> node_i = func->getNode(idx); // Copy node
+        MWNode<D, T> node_i = func->getNode(idx); // Copy node
         node_i.mwTransform(Reconstruction);
         node_i.cvTransform(Forward);
-        const double *coefs_i = node_i.getCoefs();
+        const T *coefs_i = node_i.getCoefs();
         for (int j = 0; j < n_coefs; j++) { coefs_o[j] = std::pow(coefs_i[j], this->power); }
         node_o.cvTransform(Backward);
         node_o.mwTransform(Compression);
diff --git a/src/treebuilders/ProjectionCalculator.cpp b/src/treebuilders/ProjectionCalculator.cpp
index 46335d092..e451ea69e 100644
--- a/src/treebuilders/ProjectionCalculator.cpp
+++ b/src/treebuilders/ProjectionCalculator.cpp
@@ -30,18 +30,19 @@ using Eigen::MatrixXd;
 
 namespace mrcpp {
 
-template <int D> void ProjectionCalculator<D>::calcNode(MWNode<D> &node) {
+template <int D, typename T> void ProjectionCalculator<D, T>::calcNode(MWNode<D, T> &node) {
     MatrixXd exp_pts;
     node.getExpandedChildPts(exp_pts);
 
     assert(exp_pts.cols() == node.getNCoefs());
 
     Coord<D> r;
-    double *coefs = node.getCoefs();
+    T *coefs = node.getCoefs();
     for (int i = 0; i < node.getNCoefs(); i++) {
-        for (int d = 0; d < D; d++) { r[d] = scaling_factor[d] * exp_pts(d, i); }
-        coefs[i] = this->func->evalf(r);
+      for (int d = 0; d < D; d++) { r[d] = scaling_factor[d] * exp_pts(d, i); }
+      coefs[i] = this->func->evalf(r);
     }
+
     node.cvTransform(Backward);
     node.mwTransform(Compression);
     node.setHasCoefs();
@@ -50,7 +51,7 @@ template <int D> void ProjectionCalculator<D>::calcNode(MWNode<D> &node) {
 
 /* Old interpolating version, somewhat faster
 template<int D>
-void ProjectionCalculator<D>::calcNode(MWNode<D> &node) {
+void ProjectionCalculator<D, T>::calcNode(MWNode<D, T> &node) {
     const ScalingBasis &sf = node.getMWTree().getMRA().getScalingBasis();
     if (sf.getScalingType() != Interpol) {
         NOT_IMPLEMENTED_ABORT;
@@ -104,8 +105,12 @@ void ProjectionCalculator<D>::calcNode(MWNode<D> &node) {
 }
 */
 
-template class ProjectionCalculator<1>;
-template class ProjectionCalculator<2>;
-template class ProjectionCalculator<3>;
+template class ProjectionCalculator<1, double>;
+template class ProjectionCalculator<2, double>;
+template class ProjectionCalculator<3, double>;
+
+template class ProjectionCalculator<1, ComplexDouble>;
+template class ProjectionCalculator<2, ComplexDouble>;
+template class ProjectionCalculator<3, ComplexDouble>;
 
 } // namespace mrcpp
diff --git a/src/treebuilders/ProjectionCalculator.h b/src/treebuilders/ProjectionCalculator.h
index 2fbbb09fe..067c41422 100644
--- a/src/treebuilders/ProjectionCalculator.h
+++ b/src/treebuilders/ProjectionCalculator.h
@@ -29,16 +29,16 @@
 
 namespace mrcpp {
 
-template <int D> class ProjectionCalculator final : public TreeCalculator<D> {
+template <int D, typename T> class ProjectionCalculator final : public TreeCalculator<D, T> {
 public:
-    ProjectionCalculator(const RepresentableFunction<D> &inp_func, const std::array<double, D> &sf)
+    ProjectionCalculator(const RepresentableFunction<D, T> &inp_func, const std::array<double, D> &sf)
             : func(&inp_func)
             , scaling_factor(sf) {}
 
 private:
-    const RepresentableFunction<D> *func;
+    const RepresentableFunction<D, T> *func;
     const std::array<double, D> scaling_factor;
-    void calcNode(MWNode<D> &node) override;
+    void calcNode(MWNode<D, T> &node) override;
 };
 
 } // namespace mrcpp
diff --git a/src/treebuilders/SplitAdaptor.h b/src/treebuilders/SplitAdaptor.h
index b9d50fe8b..7e81bbe8b 100644
--- a/src/treebuilders/SplitAdaptor.h
+++ b/src/treebuilders/SplitAdaptor.h
@@ -29,16 +29,16 @@
 
 namespace mrcpp {
 
-template <int D> class SplitAdaptor final : public TreeAdaptor<D> {
+template <int D, typename T = double> class SplitAdaptor final : public TreeAdaptor<D, T> {
 public:
     SplitAdaptor(int ms, bool sp)
-            : TreeAdaptor<D>(ms)
+            : TreeAdaptor<D, T>(ms)
             , split(sp) {}
 
 private:
     bool split;
 
-    bool splitNode(const MWNode<D> &node) const override { return this->split; }
+    bool splitNode(const MWNode<D, T> &node) const override { return this->split; }
 };
 
 } // namespace mrcpp
diff --git a/src/treebuilders/SquareCalculator.h b/src/treebuilders/SquareCalculator.h
index e9bb0f8d3..e56b41cf0 100644
--- a/src/treebuilders/SquareCalculator.h
+++ b/src/treebuilders/SquareCalculator.h
@@ -29,23 +29,23 @@
 
 namespace mrcpp {
 
-template <int D> class SquareCalculator final : public TreeCalculator<D> {
+template <int D, typename T> class SquareCalculator final : public TreeCalculator<D, T> {
 public:
-    SquareCalculator(FunctionTree<D> &inp)
+    SquareCalculator(FunctionTree<D, T> &inp)
             : func(&inp) {}
 
 private:
-    FunctionTree<D> *func;
+    FunctionTree<D, T> *func;
 
-    void calcNode(MWNode<D> &node_o) override {
+    void calcNode(MWNode<D, T> &node_o) override {
         const NodeIndex<D> &idx = node_o.getNodeIndex();
         int n_coefs = node_o.getNCoefs();
-        double *coefs_o = node_o.getCoefs();
+        T *coefs_o = node_o.getCoefs();
         // This generates missing nodes
-        MWNode<D> node_i = func->getNode(idx); // Copy node
+        MWNode<D, T> node_i = func->getNode(idx); // Copy node
         node_i.mwTransform(Reconstruction);
         node_i.cvTransform(Forward);
-        const double *coefs_i = node_i.getCoefs();
+        const T *coefs_i = node_i.getCoefs();
         for (int j = 0; j < n_coefs; j++) { coefs_o[j] = coefs_i[j] * coefs_i[j]; }
         node_o.cvTransform(Backward);
         node_o.mwTransform(Compression);
diff --git a/src/treebuilders/TreeAdaptor.h b/src/treebuilders/TreeAdaptor.h
index a46bab648..80cecb09e 100644
--- a/src/treebuilders/TreeAdaptor.h
+++ b/src/treebuilders/TreeAdaptor.h
@@ -30,7 +30,7 @@
 
 namespace mrcpp {
 
-template <int D> class TreeAdaptor {
+template <int D, typename T> class TreeAdaptor {
 public:
     TreeAdaptor(int ms)
             : maxScale(ms) {}
@@ -38,9 +38,9 @@ template <int D> class TreeAdaptor {
 
     void setMaxScale(int ms) { this->maxScale = ms; }
 
-    void splitNodeVector(MWNodeVector<D> &out, MWNodeVector<D> &inp) const {
+    void splitNodeVector(MWNodeVector<D, T> &out, MWNodeVector<D, T> &inp) const {
         for (int n = 0; n < inp.size(); n++) {
-            MWNode<D> &node = *inp[n];
+            MWNode<D, T> &node = *inp[n];
             // Can be BranchNode in operator application
             if (node.isBranchNode()) continue;
             if (node.getScale() + 2 > this->maxScale) continue;
@@ -54,7 +54,7 @@ template <int D> class TreeAdaptor {
 protected:
     int maxScale;
 
-    virtual bool splitNode(const MWNode<D> &node) const = 0;
+    virtual bool splitNode(const MWNode<D, T> &node) const = 0;
 };
 
 } // namespace mrcpp
diff --git a/src/treebuilders/TreeBuilder.cpp b/src/treebuilders/TreeBuilder.cpp
index 223d94794..225b55cb5 100644
--- a/src/treebuilders/TreeBuilder.cpp
+++ b/src/treebuilders/TreeBuilder.cpp
@@ -35,13 +35,13 @@
 
 namespace mrcpp {
 
-template <int D>
-void TreeBuilder<D>::build(MWTree<D> &tree, TreeCalculator<D> &calculator, TreeAdaptor<D> &adaptor, int maxIter) const {
+template <int D, typename T>
+void TreeBuilder<D, T>::build(MWTree<D, T> &tree, TreeCalculator<D, T> &calculator, TreeAdaptor<D, T> &adaptor, int maxIter) const {
     Timer calc_t(false), split_t(false), norm_t(false);
     println(10, " == Building tree");
 
-    MWNodeVector<D> *newVec = nullptr;
-    MWNodeVector<D> *workVec = calculator.getInitialWorkVector(tree);
+    MWNodeVector<D, T> *newVec = nullptr;
+    MWNodeVector<D, T> *workVec = calculator.getInitialWorkVector(tree);
 
     double sNorm = 0.0;
     double wNorm = 0.0;
@@ -69,7 +69,7 @@ void TreeBuilder<D>::build(MWTree<D> &tree, TreeCalculator<D> &calculator, TreeA
         norm_t.stop();
 
         split_t.resume();
-        newVec = new MWNodeVector<D>;
+        newVec = new MWNodeVector<D, T>;
         if (iter >= maxIter and maxIter >= 0) workVec->clear();
         adaptor.splitNodeVector(*newVec, *workVec);
         split_t.stop();
@@ -87,11 +87,11 @@ void TreeBuilder<D>::build(MWTree<D> &tree, TreeCalculator<D> &calculator, TreeA
     print::time(10, "Time split", split_t);
 }
 
-template <int D> void TreeBuilder<D>::clear(MWTree<D> &tree, TreeCalculator<D> &calculator) const {
+template <int D, typename T> void TreeBuilder<D, T>::clear(MWTree<D, T> &tree, TreeCalculator<D, T> &calculator) const {
     println(10, " == Clearing tree");
 
     Timer clean_t;
-    MWNodeVector<D> nodeVec;
+    MWNodeVector<D, T> nodeVec;
     tree_utils::make_node_table(tree, nodeVec);
     calculator.calcNodeVector(nodeVec); // clear all coefficients
     clean_t.stop();
@@ -104,16 +104,16 @@ template <int D> void TreeBuilder<D>::clear(MWTree<D> &tree, TreeCalculator<D> &
     print::separator(10, ' ');
 }
 
-template <int D> int TreeBuilder<D>::split(MWTree<D> &tree, TreeAdaptor<D> &adaptor, bool passCoefs) const {
+template <int D, typename T> int TreeBuilder<D, T>::split(MWTree<D, T> &tree, TreeAdaptor<D, T> &adaptor, bool passCoefs) const {
     println(10, " == Refining tree");
 
     Timer split_t;
-    MWNodeVector<D> newVec;
-    MWNodeVector<D> *workVec = tree.copyEndNodeTable();
+    MWNodeVector<D, T> newVec;
+    MWNodeVector<D, T> *workVec = tree.copyEndNodeTable();
     adaptor.splitNodeVector(newVec, *workVec);
     if (passCoefs) {
         for (int i = 0; i < workVec->size(); i++) {
-            MWNode<D> &node = *(*workVec)[i];
+            MWNode<D, T> &node = *(*workVec)[i];
             if (node.isBranchNode()) { node.giveChildrenCoefs(true); }
         }
     }
@@ -131,11 +131,11 @@ template <int D> int TreeBuilder<D>::split(MWTree<D> &tree, TreeAdaptor<D> &adap
     return newVec.size();
 }
 
-template <int D> void TreeBuilder<D>::calc(MWTree<D> &tree, TreeCalculator<D> &calculator) const {
+template <int D, typename T> void TreeBuilder<D, T>::calc(MWTree<D, T> &tree, TreeCalculator<D, T> &calculator) const {
     println(10, " == Calculating tree");
 
     Timer calc_t;
-    MWNodeVector<D> *workVec = calculator.getInitialWorkVector(tree);
+    MWNodeVector<D, T> *workVec = calculator.getInitialWorkVector(tree);
     calculator.calcNodeVector(*workVec);
     printout(10, "  -- #" << std::setw(3) << 0 << ": Calculated ");
     printout(10, std::setw(6) << workVec->size() << " nodes ");
@@ -148,26 +148,31 @@ template <int D> void TreeBuilder<D>::calc(MWTree<D> &tree, TreeCalculator<D> &c
     print::time(10, "Time calc", calc_t);
 }
 
-template <int D> double TreeBuilder<D>::calcScalingNorm(const MWNodeVector<D> &vec) const {
+template <int D, typename T> double TreeBuilder<D, T>::calcScalingNorm(const MWNodeVector<D, T> &vec) const {
     double sNorm = 0.0;
     for (int i = 0; i < vec.size(); i++) {
-        const MWNode<D> &node = *vec[i];
+        const MWNode<D, T> &node = *vec[i];
         if (node.getDepth() >= 0) sNorm += node.getScalingNorm();
     }
     return sNorm;
 }
 
-template <int D> double TreeBuilder<D>::calcWaveletNorm(const MWNodeVector<D> &vec) const {
+template <int D, typename T> double TreeBuilder<D, T>::calcWaveletNorm(const MWNodeVector<D, T> &vec) const {
     double wNorm = 0.0;
     for (int i = 0; i < vec.size(); i++) {
-        const MWNode<D> &node = *vec[i];
+        const MWNode<D, T> &node = *vec[i];
         if (node.getDepth() >= 0) wNorm += node.getWaveletNorm();
     }
     return wNorm;
 }
 
-template class TreeBuilder<1>;
-template class TreeBuilder<2>;
-template class TreeBuilder<3>;
+template class TreeBuilder<1, double>;
+template class TreeBuilder<2, double>;
+template class TreeBuilder<3, double>;
+
+
+template class TreeBuilder<1, ComplexDouble>;
+template class TreeBuilder<2, ComplexDouble>;
+template class TreeBuilder<3, ComplexDouble>;
 
 } // namespace mrcpp
diff --git a/src/treebuilders/TreeBuilder.h b/src/treebuilders/TreeBuilder.h
index 313e9f4f4..81c32afe6 100644
--- a/src/treebuilders/TreeBuilder.h
+++ b/src/treebuilders/TreeBuilder.h
@@ -29,16 +29,16 @@
 
 namespace mrcpp {
 
-template <int D> class TreeBuilder final {
+template <int D, typename T> class TreeBuilder final {
 public:
-    void build(MWTree<D> &tree, TreeCalculator<D> &calculator, TreeAdaptor<D> &adaptor, int maxIter) const;
-    void clear(MWTree<D> &tree, TreeCalculator<D> &calculator) const;
-    void calc(MWTree<D> &tree, TreeCalculator<D> &calculator) const;
-    int split(MWTree<D> &tree, TreeAdaptor<D> &adaptor, bool passCoefs) const;
+    void build(MWTree<D, T> &tree, TreeCalculator<D, T> &calculator, TreeAdaptor<D, T> &adaptor, int maxIter) const;
+    void clear(MWTree<D, T> &tree, TreeCalculator<D, T> &calculator) const;
+    void calc(MWTree<D, T> &tree, TreeCalculator<D, T> &calculator) const;
+    int split(MWTree<D, T> &tree, TreeAdaptor<D, T> &adaptor, bool passCoefs) const;
 
 private:
-    double calcScalingNorm(const MWNodeVector<D> &vec) const;
-    double calcWaveletNorm(const MWNodeVector<D> &vec) const;
+    double calcScalingNorm(const MWNodeVector<D, T> &vec) const;
+    double calcWaveletNorm(const MWNodeVector<D, T> &vec) const;
 };
 
 } // namespace mrcpp
diff --git a/src/treebuilders/TreeCalculator.h b/src/treebuilders/TreeCalculator.h
index acd9f00f8..4e171d91c 100644
--- a/src/treebuilders/TreeCalculator.h
+++ b/src/treebuilders/TreeCalculator.h
@@ -29,20 +29,20 @@
 
 namespace mrcpp {
 
-template <int D> class TreeCalculator {
+  template <int D, typename T> class TreeCalculator {
 public:
     TreeCalculator() = default;
     virtual ~TreeCalculator() = default;
 
-    virtual MWNodeVector<D> *getInitialWorkVector(MWTree<D> &tree) const { return tree.copyEndNodeTable(); }
+    virtual MWNodeVector<D, T> *getInitialWorkVector(MWTree<D, T> &tree) const { return tree.copyEndNodeTable(); }
 
-    virtual void calcNodeVector(MWNodeVector<D> &nodeVec) {
+    virtual void calcNodeVector(MWNodeVector<D, T> &nodeVec) {
 #pragma omp parallel shared(nodeVec) num_threads(mrcpp_get_num_threads())
         {
             int nNodes = nodeVec.size();
 #pragma omp for schedule(guided)
             for (int n = 0; n < nNodes; n++) {
-                MWNode<D> &node = *nodeVec[n];
+	      MWNode<D, T> &node = *nodeVec[n];
                 calcNode(node);
             }
         }
@@ -50,7 +50,7 @@ template <int D> class TreeCalculator {
     }
 
 protected:
-    virtual void calcNode(MWNode<D> &node) = 0;
+  virtual void calcNode(MWNode<D, T> &node) = 0;
     virtual void postProcess() {}
 };
 
diff --git a/src/treebuilders/WaveletAdaptor.h b/src/treebuilders/WaveletAdaptor.h
index 15da130e1..759f6b7ee 100644
--- a/src/treebuilders/WaveletAdaptor.h
+++ b/src/treebuilders/WaveletAdaptor.h
@@ -31,10 +31,10 @@
 
 namespace mrcpp {
 
-template <int D> class WaveletAdaptor : public TreeAdaptor<D> {
+  template <int D, typename T> class WaveletAdaptor : public TreeAdaptor<D, T> {
 public:
     WaveletAdaptor(double pr, int ms, bool ap = false, double sf = 1.0)
-            : TreeAdaptor<D>(ms)
+      : TreeAdaptor<D, T>(ms)
             , absPrec(ap)
             , prec(pr)
             , splitFac(sf) {}
@@ -50,7 +50,7 @@ template <int D> class WaveletAdaptor : public TreeAdaptor<D> {
     double splitFac;
     std::function<double(const NodeIndex<D> &idx)> precFunc = [](const NodeIndex<D> &idx) { return 1.0; };
 
-    bool splitNode(const MWNode<D> &node) const override {
+    bool splitNode(const MWNode<D, T> &node) const override {
         auto precFac = this->precFunc(node.getNodeIndex()); // returns 1.0 by default
         return tree_utils::split_check(node, this->prec * precFac, this->splitFac, this->absPrec);
     }
diff --git a/src/treebuilders/add.cpp b/src/treebuilders/add.cpp
index 86b7f30a7..584e61e68 100644
--- a/src/treebuilders/add.cpp
+++ b/src/treebuilders/add.cpp
@@ -61,16 +61,16 @@ namespace mrcpp {
  * no coefs).
  *
  */
-template <int D>
+template <int D, typename T>
 void add(double prec,
-         FunctionTree<D> &out,
-         double a,
-         FunctionTree<D> &inp_a,
-         double b,
-         FunctionTree<D> &inp_b,
+         FunctionTree<D, T> &out,
+         T a,
+         FunctionTree<D, T> &inp_a,
+         T b,
+         FunctionTree<D, T> &inp_b,
          int maxIter,
          bool absPrec) {
-    FunctionTreeVector<D> tmp_vec;
+    FunctionTreeVector<D, T> tmp_vec;
     tmp_vec.push_back(std::make_tuple(a, &inp_a));
     tmp_vec.push_back(std::make_tuple(b, &inp_b));
     add(prec, out, tmp_vec, maxIter, absPrec);
@@ -98,14 +98,14 @@ void add(double prec,
  * no coefs).
  *
  */
-template <int D> void add(double prec, FunctionTree<D> &out, FunctionTreeVector<D> &inp, int maxIter, bool absPrec) {
+template <int D, typename T> void add(double prec, FunctionTree<D, T> &out, FunctionTreeVector<D, T> &inp, int maxIter, bool absPrec) {
     for (auto i = 0; i < inp.size(); i++)
         if (out.getMRA() != get_func(inp, i).getMRA()) MSG_ABORT("Incompatible MRA");
 
     int maxScale = out.getMRA().getMaxScale();
-    TreeBuilder<D> builder;
-    WaveletAdaptor<D> adaptor(prec, maxScale, absPrec);
-    AdditionCalculator<D> calculator(inp);
+    TreeBuilder<D, T> builder;
+    WaveletAdaptor<D, T> adaptor(prec, maxScale, absPrec);
+    AdditionCalculator<D, T> calculator(inp);
 
     builder.build(out, calculator, adaptor, maxIter);
 
@@ -116,7 +116,7 @@ template <int D> void add(double prec, FunctionTree<D> &out, FunctionTreeVector<
 
     Timer clean_t;
     for (int i = 0; i < inp.size(); i++) {
-        FunctionTree<D> &tree = get_func(inp, i);
+        FunctionTree<D, T> &tree = get_func(inp, i);
         tree.deleteGenerated();
     }
     clean_t.stop();
@@ -126,66 +126,124 @@ template <int D> void add(double prec, FunctionTree<D> &out, FunctionTreeVector<
     print::separator(10, ' ');
 }
 
-template <int D> void add(double prec, FunctionTree<D> &out, std::vector<FunctionTree<D> *> &inp, int maxIter, bool absPrec) {
-    FunctionTreeVector<D> inp_vec;
+template <int D, typename T> void add(double prec, FunctionTree<D, T> &out, std::vector<FunctionTree<D, T> *> &inp, int maxIter, bool absPrec) {
+    FunctionTreeVector<D, T> inp_vec;
     for (auto &t : inp) inp_vec.push_back({1.0, t});
     add(prec, out, inp_vec, maxIter, absPrec);
 }
 
-template void add<1>(double prec,
-                     FunctionTree<1> &out,
+template void add<1, double>(double prec,
+                     FunctionTree<1, double> &out,
                      double a,
-                     FunctionTree<1> &tree_a,
+                     FunctionTree<1, double> &tree_a,
                      double b,
-                     FunctionTree<1> &tree_b,
+                     FunctionTree<1, double> &tree_b,
                      int maxIter,
                      bool absPrec);
-template void add<2>(double prec,
-                     FunctionTree<2> &out,
+template void add<2, double>(double prec,
+                     FunctionTree<2, double> &out,
                      double a,
-                     FunctionTree<2> &tree_a,
+                     FunctionTree<2, double> &tree_a,
                      double b,
-                     FunctionTree<2> &tree_b,
+                     FunctionTree<2, double> &tree_b,
                      int maxIter,
                      bool absPrec);
-template void add<3>(double prec,
-                     FunctionTree<3> &out,
+template void add<3, double>(double prec,
+                     FunctionTree<3, double> &out,
                      double a,
-                     FunctionTree<3> &tree_a,
+                     FunctionTree<3, double> &tree_a,
                      double b,
-                     FunctionTree<3> &tree_b,
+                     FunctionTree<3, double> &tree_b,
                      int maxIter,
                      bool absPrec);
 
-template void add<1>(double prec,
-                     FunctionTree<1> &out,
-                     FunctionTreeVector<1> &inp,
+template void add<1, double>(double prec,
+                     FunctionTree<1, double> &out,
+                     FunctionTreeVector<1, double> &inp,
                      int maxIter,
                      bool absPrec);
-template void add<2>(double prec,
-                     FunctionTree<2> &out,
-                     FunctionTreeVector<2> &inp,
+template void add<2, double>(double prec,
+                     FunctionTree<2, double> &out,
+                     FunctionTreeVector<2, double> &inp,
                      int maxIter,
                      bool absPrec);
-template void add<3>(double prec,
-                     FunctionTree<3> &out,
-                     FunctionTreeVector<3> &inp,
+template void add<3, double>(double prec,
+                     FunctionTree<3, double> &out,
+		     FunctionTreeVector<3, double> &inp,
                      int maxIter,
                      bool absPrec);
 
-template void add<1>(double prec,
-                     FunctionTree<1> &out,
-                     std::vector<FunctionTree<1> *> &inp,
+template void add<1, double>(double prec,
+                     FunctionTree<1, double> &out,
+                     std::vector<FunctionTree<1, double> *> &inp,
                      int maxIter,
                      bool absPrec);
-template void add<2>(double prec,
-                     FunctionTree<2> &out,
-                     std::vector<FunctionTree<2> *> &inp,
+template void add<2, double>(double prec,
+                     FunctionTree<2, double> &out,
+                     std::vector<FunctionTree<2, double> *> &inp,
                      int maxIter,
                      bool absPrec);
-template void add<3>(double prec,
-                     FunctionTree<3> &out,
-                     std::vector<FunctionTree<3> *> &inp,
+template void add<3, double>(double prec,
+                     FunctionTree<3, double> &out,
+                     std::vector<FunctionTree<3, double> *> &inp,
+                     int maxIter,
+                     bool absPrec);
+
+
+template void add<1, ComplexDouble>(double prec,
+                     FunctionTree<1, ComplexDouble> &out,
+                     ComplexDouble a,
+                     FunctionTree<1, ComplexDouble> &tree_a,
+                     ComplexDouble b,
+                     FunctionTree<1, ComplexDouble> &tree_b,
+                     int maxIter,
+                     bool absPrec);
+template void add<2, ComplexDouble>(double prec,
+                     FunctionTree<2, ComplexDouble> &out,
+                     ComplexDouble a,
+                     FunctionTree<2, ComplexDouble> &tree_a,
+                     ComplexDouble b,
+                     FunctionTree<2, ComplexDouble> &tree_b,
+                     int maxIter,
+                     bool absPrec);
+template void add<3, ComplexDouble>(double prec,
+                     FunctionTree<3, ComplexDouble> &out,
+                     ComplexDouble a,
+                     FunctionTree<3, ComplexDouble> &tree_a,
+                     ComplexDouble b,
+                     FunctionTree<3, ComplexDouble> &tree_b,
+                     int maxIter,
+                     bool absPrec);
+
+template void add<1, ComplexDouble>(double prec,
+                     FunctionTree<1, ComplexDouble> &out,
+                     FunctionTreeVector<1, ComplexDouble> &inp,
+                     int maxIter,
+                     bool absPrec);
+template void add<2, ComplexDouble>(double prec,
+                     FunctionTree<2, ComplexDouble> &out,
+                     FunctionTreeVector<2, ComplexDouble> &inp,
+                     int maxIter,
+                     bool absPrec);
+template void add<3, ComplexDouble>(double prec,
+                     FunctionTree<3, ComplexDouble> &out,
+                     FunctionTreeVector<3, ComplexDouble> &inp,
+                     int maxIter,
+                     bool absPrec);
+
+template void add<1, ComplexDouble>(double prec,
+                     FunctionTree<1, ComplexDouble> &out,
+                     std::vector<FunctionTree<1, ComplexDouble> *> &inp,
+                     int maxIter,
+                     bool absPrec);
+template void add<2, ComplexDouble>(double prec,
+                     FunctionTree<2, ComplexDouble> &out,
+                     std::vector<FunctionTree<2, ComplexDouble> *> &inp,
+                     int maxIter,
+                     bool absPrec);
+template void add<3, ComplexDouble>(double prec,
+                     FunctionTree<3, ComplexDouble> &out,
+                     std::vector<FunctionTree<3, ComplexDouble> *> &inp,
                      int maxIter,
                      bool absPrec);
 
diff --git a/src/treebuilders/add.h b/src/treebuilders/add.h
index 105245829..dae1b366a 100644
--- a/src/treebuilders/add.h
+++ b/src/treebuilders/add.h
@@ -28,22 +28,22 @@
 
 namespace mrcpp {
 
-template <int D> void add(double prec,
-                          FunctionTree<D> &out,
-                          double a,
-                          FunctionTree<D> &tree_a,
-                          double b,
-                          FunctionTree<D> &tree_b,
+template <int D, typename T> void add(double prec,
+                          FunctionTree<D, T> &out,
+                          T a,
+                          FunctionTree<D, T> &tree_a,
+                          T b,
+                          FunctionTree<D, T> &tree_b,
                           int maxIter = -1,
                           bool absPrec = false);
-template <int D> void add(double prec,
-                          FunctionTree<D> &out,
-                          FunctionTreeVector<D> &inp,
+template <int D, typename T> void add(double prec,
+                          FunctionTree<D, T> &out,
+                          FunctionTreeVector<D, T> &inp,
                           int maxIter = -1,
                           bool absPrec = false);
-template <int D> void add(double prec,
-                          FunctionTree<D> &out,
-                          std::vector<FunctionTree<D> *> &inp,
+template <int D, typename T> void add(double prec,
+                          FunctionTree<D, T> &out,
+                          std::vector<FunctionTree<D, T> *> &inp,
                           int maxIter = -1,
                           bool absPrec = false);
 
diff --git a/src/treebuilders/apply.cpp b/src/treebuilders/apply.cpp
index 3dc49de3c..4a072f694 100644
--- a/src/treebuilders/apply.cpp
+++ b/src/treebuilders/apply.cpp
@@ -41,7 +41,7 @@
 
 namespace mrcpp {
 
-template <int D> void apply_on_unit_cell(bool inside, double prec, FunctionTree<D> &out, ConvolutionOperator<D> &oper, FunctionTree<D> &inp, int maxIter, bool absPrec);
+template <int D, typename T> void apply_on_unit_cell(bool inside, double prec, FunctionTree<D, T> &out, ConvolutionOperator<D> &oper, FunctionTree<D, T> &inp, int maxIter, bool absPrec);
 
 /** @brief Application of MW integral convolution operator
  *
@@ -64,16 +64,16 @@ template <int D> void apply_on_unit_cell(bool inside, double prec, FunctionTree<
  * no coefs).
  *
  */
-template <int D> void apply(double prec, FunctionTree<D> &out, ConvolutionOperator<D> &oper, FunctionTree<D> &inp, int maxIter, bool absPrec) {
+template <int D, typename T> void apply(double prec, FunctionTree<D, T> &out, ConvolutionOperator<D> &oper, FunctionTree<D, T> &inp, int maxIter, bool absPrec) {
     if (out.getMRA() != inp.getMRA()) MSG_ABORT("Incompatible MRA");
 
     Timer pre_t;
     oper.calcBandWidths(prec);
     int maxScale = out.getMRA().getMaxScale();
-    WaveletAdaptor<D> adaptor(prec, maxScale, absPrec);
-    ConvolutionCalculator<D> calculator(prec, oper, inp);
+    WaveletAdaptor<D, T> adaptor(prec, maxScale, absPrec);
+    ConvolutionCalculator<D, T> calculator(prec, oper, inp);
     pre_t.stop();
-    TreeBuilder<D> builder;
+    TreeBuilder<D, T> builder;
     builder.build(out, calculator, adaptor, maxIter);
 
     Timer post_t;
@@ -113,18 +113,18 @@ template <int D> void apply(double prec, FunctionTree<D> &out, ConvolutionOperat
  * no coefs).
  *
  */
-template <int D> void apply_on_unit_cell(bool inside, double prec, FunctionTree<D> &out, ConvolutionOperator<D> &oper, FunctionTree<D> &inp, int maxIter, bool absPrec) {
+template <int D, typename T> void apply_on_unit_cell(bool inside, double prec, FunctionTree<D, T> &out, ConvolutionOperator<D> &oper, FunctionTree<D, T> &inp, int maxIter, bool absPrec) {
     if (out.getMRA() != inp.getMRA()) MSG_ABORT("Incompatible MRA");
 
     Timer pre_t;
     oper.calcBandWidths(prec);
     int maxScale = out.getMRA().getMaxScale();
-    WaveletAdaptor<D> adaptor(prec, maxScale, absPrec);
-    ConvolutionCalculator<D> calculator(prec, oper, inp);
+    WaveletAdaptor<D, T> adaptor(prec, maxScale, absPrec);
+    ConvolutionCalculator<D, T> calculator(prec, oper, inp);
     calculator.startManipulateOperator(inside);
     pre_t.stop();
 
-    TreeBuilder<D> builder;
+    TreeBuilder<D, T> builder;
     builder.build(out, calculator, adaptor, maxIter);
 
     Timer post_t;
@@ -166,7 +166,7 @@ template <int D> void apply_on_unit_cell(bool inside, double prec, FunctionTree<
  * no coefs).
  *
  */
-template <int D> void apply(double prec, FunctionTree<D> &out, ConvolutionOperator<D> &oper, FunctionTree<D> &inp, FunctionTreeVector<D> &precTrees, int maxIter, bool absPrec) {
+template <int D, typename T> void apply(double prec, FunctionTree<D, T> &out, ConvolutionOperator<D> &oper, FunctionTree<D, T> &inp, FunctionTreeVector<D, T> &precTrees, int maxIter, bool absPrec) {
     Timer pre_t;
     oper.calcBandWidths(prec);
     int maxScale = out.getMRA().getMaxScale();
@@ -183,13 +183,13 @@ template <int D> void apply(double prec, FunctionTree<D> &out, ConvolutionOperat
         return 1.0 / maxNorm;
     };
 
-    WaveletAdaptor<D> adaptor(prec, maxScale, absPrec);
+    WaveletAdaptor<D, T> adaptor(prec, maxScale, absPrec);
     adaptor.setPrecFunction(precFunc);
-    ConvolutionCalculator<D> calculator(prec, oper, inp);
+    ConvolutionCalculator<D, T> calculator(prec, oper, inp);
     calculator.setPrecFunction(precFunc);
     pre_t.stop();
 
-    TreeBuilder<D> builder;
+    TreeBuilder<D, T> builder;
     builder.build(out, calculator, adaptor, maxIter);
 
     Timer post_t;
@@ -227,7 +227,7 @@ template <int D> void apply(double prec, FunctionTree<D> &out, ConvolutionOperat
  * no coefs).
  *
  */
-template <int D> void apply_far_field(double prec, FunctionTree<D> &out, ConvolutionOperator<D> &oper, FunctionTree<D> &inp, int maxIter, bool absPrec) {
+template <int D, typename T> void apply_far_field(double prec, FunctionTree<D, T> &out, ConvolutionOperator<D> &oper, FunctionTree<D, T> &inp, int maxIter, bool absPrec) {
     apply_on_unit_cell<D>(false, prec, out, oper, inp, maxIter, absPrec);
 }
 
@@ -253,7 +253,7 @@ template <int D> void apply_far_field(double prec, FunctionTree<D> &out, Convolu
  * no coefs).
  *
  */
-template <int D> void apply_near_field(double prec, FunctionTree<D> &out, ConvolutionOperator<D> &oper, FunctionTree<D> &inp, int maxIter, bool absPrec) {
+template <int D, typename T> void apply_near_field(double prec, FunctionTree<D, T> &out, ConvolutionOperator<D> &oper, FunctionTree<D, T> &inp, int maxIter, bool absPrec) {
     apply_on_unit_cell<D>(true, prec, out, oper, inp, maxIter, absPrec);
 }
 
@@ -273,9 +273,9 @@ template <int D> void apply_near_field(double prec, FunctionTree<D> &out, Convol
  * @note The output function should contain only empty root nodes at entry.
  *
  */
-template <int D> void apply(FunctionTree<D> &out, DerivativeOperator<D> &oper, FunctionTree<D> &inp, int dir) {
+template <int D, typename T> void apply(FunctionTree<D, T> &out, DerivativeOperator<D> &oper, FunctionTree<D, T> &inp, int dir) {
     if (out.getMRA() != inp.getMRA()) MSG_ABORT("Incompatible MRA");
-    TreeBuilder<D> builder;
+    TreeBuilder<D, T> builder;
     int maxScale = out.getMRA().getMaxScale();
 
     int bw[D]; // Operator bandwidth in [x,y,z]
@@ -285,14 +285,14 @@ template <int D> void apply(FunctionTree<D> &out, DerivativeOperator<D> &oper, F
     Timer pre_t;
     oper.calcBandWidths(1.0); // Fixed 0 or 1 for derivatives
     bw[dir] = oper.getMaxBandWidth();
-    CopyAdaptor<D> pre_adaptor(inp, maxScale, bw);
-    DefaultCalculator<D> pre_calculator;
+    CopyAdaptor<D, T> pre_adaptor(inp, maxScale, bw);
+    DefaultCalculator<D, T> pre_calculator;
     builder.build(out, pre_calculator, pre_adaptor, -1);
     pre_t.stop();
 
     // Apply operator on fixed expanded grid
-    SplitAdaptor<D> apply_adaptor(maxScale, false); // Splits no nodes
-    DerivativeCalculator<D> apply_calculator(dir, oper, inp);
+    SplitAdaptor<D, T> apply_adaptor(maxScale, false); // Splits no nodes
+    DerivativeCalculator<D, T> apply_calculator(dir, oper, inp);
     builder.build(out, apply_calculator, apply_adaptor, 0);
     if (out.isPeriodic()) out.rescale(std::pow(2.0, -oper.getOperatorRoot()));
 
@@ -320,10 +320,10 @@ template <int D> void apply(FunctionTree<D> &out, DerivativeOperator<D> &oper, F
  * @note The length of the output vector will be the template dimension D.
  *
  */
-template <int D> FunctionTreeVector<D> gradient(DerivativeOperator<D> &oper, FunctionTree<D> &inp) {
-    FunctionTreeVector<D> out;
+template <int D, typename T> FunctionTreeVector<D, T> gradient(DerivativeOperator<D> &oper, FunctionTree<D, T> &inp) {
+    FunctionTreeVector<D, T> out;
     for (int d = 0; d < D; d++) {
-        auto *grad_d = new FunctionTree<D>(inp.getMRA());
+        auto *grad_d = new FunctionTree<D, T>(inp.getMRA());
         apply(*grad_d, oper, inp, d);
         out.push_back({1.0, grad_d});
     }
@@ -346,16 +346,16 @@ template <int D> FunctionTreeVector<D> gradient(DerivativeOperator<D> &oper, Fun
  * - The output function should contain only empty root nodes at entry.
  *
  */
-template <int D> void divergence(FunctionTree<D> &out, DerivativeOperator<D> &oper, FunctionTreeVector<D> &inp) {
+template <int D, typename T> void divergence(FunctionTree<D, T> &out, DerivativeOperator<D> &oper, FunctionTreeVector<D, T> &inp) {
     if (inp.size() != D) MSG_ABORT("Dimension mismatch");
     for (auto i = 0; i < inp.size(); i++)
         if (out.getMRA() != get_func(inp, i).getMRA()) MSG_ABORT("Incompatible MRA");
 
-    FunctionTreeVector<D> tmp_vec;
+    FunctionTreeVector<D, T> tmp_vec;
     for (int d = 0; d < D; d++) {
-        double coef_d = get_coef(inp, d);
-        FunctionTree<D> &func_d = get_func(inp, d);
-        auto *out_d = new FunctionTree<D>(func_d.getMRA());
+        T coef_d = get_coef(inp, d);
+        FunctionTree<D, T> &func_d = get_func(inp, d);
+        auto *out_d = new FunctionTree<D, T>(func_d.getMRA());
         apply(*out_d, oper, func_d, d);
         tmp_vec.push_back(std::make_tuple(coef_d, out_d));
     }
@@ -364,35 +364,62 @@ template <int D> void divergence(FunctionTree<D> &out, DerivativeOperator<D> &op
     clear(tmp_vec, true);
 }
 
-template <int D> void divergence(FunctionTree<D> &out, DerivativeOperator<D> &oper, std::vector<FunctionTree<D> *> &inp) {
-    FunctionTreeVector<D> inp_vec;
+template <int D, typename T> void divergence(FunctionTree<D, T> &out, DerivativeOperator<D> &oper, std::vector<FunctionTree<D, T> *> &inp) {
+    FunctionTreeVector<D, T> inp_vec;
     for (auto &t : inp) inp_vec.push_back({1.0, t});
     divergence(out, oper, inp_vec);
 }
 
-template void apply<1>(double prec, FunctionTree<1> &out, ConvolutionOperator<1> &oper, FunctionTree<1> &inp, int maxIter, bool absPrec);
-template void apply<2>(double prec, FunctionTree<2> &out, ConvolutionOperator<2> &oper, FunctionTree<2> &inp, int maxIter, bool absPrec);
-template void apply<3>(double prec, FunctionTree<3> &out, ConvolutionOperator<3> &oper, FunctionTree<3> &inp, int maxIter, bool absPrec);
-template void apply<1>(double prec, FunctionTree<1> &out, ConvolutionOperator<1> &oper, FunctionTree<1> &inp, FunctionTreeVector<1> &precTrees, int maxIter, bool absPrec);
-template void apply<2>(double prec, FunctionTree<2> &out, ConvolutionOperator<2> &oper, FunctionTree<2> &inp, FunctionTreeVector<2> &precTrees, int maxIter, bool absPrec);
-template void apply<3>(double prec, FunctionTree<3> &out, ConvolutionOperator<3> &oper, FunctionTree<3> &inp, FunctionTreeVector<3> &precTrees, int maxIter, bool absPrec);
-template void apply_far_field<1>(double prec, FunctionTree<1> &out, ConvolutionOperator<1> &oper, FunctionTree<1> &inp, int maxIter, bool absPrec);
-template void apply_far_field<2>(double prec, FunctionTree<2> &out, ConvolutionOperator<2> &oper, FunctionTree<2> &inp, int maxIter, bool absPrec);
-template void apply_far_field<3>(double prec, FunctionTree<3> &out, ConvolutionOperator<3> &oper, FunctionTree<3> &inp, int maxIter, bool absPrec);
-template void apply_near_field<1>(double prec, FunctionTree<1> &out, ConvolutionOperator<1> &oper, FunctionTree<1> &inp, int maxIter, bool absPrec);
-template void apply_near_field<2>(double prec, FunctionTree<2> &out, ConvolutionOperator<2> &oper, FunctionTree<2> &inp, int maxIter, bool absPrec);
-template void apply_near_field<3>(double prec, FunctionTree<3> &out, ConvolutionOperator<3> &oper, FunctionTree<3> &inp, int maxIter, bool absPrec);
-template void apply<1>(FunctionTree<1> &out, DerivativeOperator<1> &oper, FunctionTree<1> &inp, int dir);
-template void apply<2>(FunctionTree<2> &out, DerivativeOperator<2> &oper, FunctionTree<2> &inp, int dir);
-template void apply<3>(FunctionTree<3> &out, DerivativeOperator<3> &oper, FunctionTree<3> &inp, int dir);
-template void divergence<1>(FunctionTree<1> &out, DerivativeOperator<1> &oper, FunctionTreeVector<1> &inp);
-template void divergence<2>(FunctionTree<2> &out, DerivativeOperator<2> &oper, FunctionTreeVector<2> &inp);
-template void divergence<3>(FunctionTree<3> &out, DerivativeOperator<3> &oper, FunctionTreeVector<3> &inp);
-template void divergence<1>(FunctionTree<1> &out, DerivativeOperator<1> &oper, std::vector<FunctionTree<1> *> &inp);
-template void divergence<2>(FunctionTree<2> &out, DerivativeOperator<2> &oper, std::vector<FunctionTree<2> *> &inp);
-template void divergence<3>(FunctionTree<3> &out, DerivativeOperator<3> &oper, std::vector<FunctionTree<3> *> &inp);
-template FunctionTreeVector<1> gradient<1>(DerivativeOperator<1> &oper, FunctionTree<1> &inp);
-template FunctionTreeVector<2> gradient<2>(DerivativeOperator<2> &oper, FunctionTree<2> &inp);
-template FunctionTreeVector<3> gradient<3>(DerivativeOperator<3> &oper, FunctionTree<3> &inp);
+template void apply<1, double>(double prec, FunctionTree<1, double> &out, ConvolutionOperator<1> &oper, FunctionTree<1, double> &inp, int maxIter, bool absPrec);
+template void apply<2, double>(double prec, FunctionTree<2, double> &out, ConvolutionOperator<2> &oper, FunctionTree<2, double> &inp, int maxIter, bool absPrec);
+template void apply<3, double>(double prec, FunctionTree<3, double> &out, ConvolutionOperator<3> &oper, FunctionTree<3, double> &inp, int maxIter, bool absPrec);
+template void apply<1, double>(double prec, FunctionTree<1, double> &out, ConvolutionOperator<1> &oper, FunctionTree<1, double> &inp, FunctionTreeVector<1, double> &precTrees, int maxIter, bool absPrec);
+template void apply<2, double>(double prec, FunctionTree<2, double> &out, ConvolutionOperator<2> &oper, FunctionTree<2, double> &inp, FunctionTreeVector<2, double> &precTrees, int maxIter, bool absPrec);
+template void apply<3, double>(double prec, FunctionTree<3, double> &out, ConvolutionOperator<3> &oper, FunctionTree<3, double> &inp, FunctionTreeVector<3, double> &precTrees, int maxIter, bool absPrec);
+template void apply_far_field<1, double>(double prec, FunctionTree<1, double> &out, ConvolutionOperator<1> &oper, FunctionTree<1, double> &inp, int maxIter, bool absPrec);
+template void apply_far_field<2, double>(double prec, FunctionTree<2, double> &out, ConvolutionOperator<2> &oper, FunctionTree<2, double> &inp, int maxIter, bool absPrec);
+template void apply_far_field<3, double>(double prec, FunctionTree<3, double> &out, ConvolutionOperator<3> &oper, FunctionTree<3, double> &inp, int maxIter, bool absPrec);
+template void apply_near_field<1, double>(double prec, FunctionTree<1, double> &out, ConvolutionOperator<1> &oper, FunctionTree<1, double> &inp, int maxIter, bool absPrec);
+template void apply_near_field<2, double>(double prec, FunctionTree<2, double> &out, ConvolutionOperator<2> &oper, FunctionTree<2, double> &inp, int maxIter, bool absPrec);
+template void apply_near_field<3, double>(double prec, FunctionTree<3, double> &out, ConvolutionOperator<3> &oper, FunctionTree<3, double> &inp, int maxIter, bool absPrec);
+template void apply<1, double>(FunctionTree<1, double> &out, DerivativeOperator<1> &oper, FunctionTree<1, double> &inp, int dir);
+template void apply<2, double>(FunctionTree<2, double> &out, DerivativeOperator<2> &oper, FunctionTree<2, double> &inp, int dir);
+template void apply<3, double>(FunctionTree<3, double> &out, DerivativeOperator<3> &oper, FunctionTree<3, double> &inp, int dir);
+template void divergence<1, double>(FunctionTree<1, double> &out, DerivativeOperator<1> &oper, FunctionTreeVector<1, double> &inp);
+template void divergence<2, double>(FunctionTree<2, double> &out, DerivativeOperator<2> &oper, FunctionTreeVector<2, double> &inp);
+template void divergence<3, double>(FunctionTree<3, double> &out, DerivativeOperator<3> &oper, FunctionTreeVector<3, double> &inp);
+template void divergence<1, double>(FunctionTree<1, double> &out, DerivativeOperator<1> &oper, std::vector<FunctionTree<1, double> *> &inp);
+template void divergence<2, double>(FunctionTree<2, double> &out, DerivativeOperator<2> &oper, std::vector<FunctionTree<2, double> *> &inp);
+template void divergence<3, double>(FunctionTree<3, double> &out, DerivativeOperator<3> &oper, std::vector<FunctionTree<3, double> *> &inp);
+template FunctionTreeVector<1, double> gradient<1>(DerivativeOperator<1> &oper, FunctionTree<1, double> &inp);
+template FunctionTreeVector<2, double> gradient<2>(DerivativeOperator<2> &oper, FunctionTree<2, double> &inp);
+template FunctionTreeVector<3, double> gradient<3>(DerivativeOperator<3> &oper, FunctionTree<3, double> &inp);
+
+
+
+template void apply<1, ComplexDouble>(double prec, FunctionTree<1, ComplexDouble> &out, ConvolutionOperator<1> &oper, FunctionTree<1, ComplexDouble> &inp, int maxIter, bool absPrec);
+template void apply<2, ComplexDouble>(double prec, FunctionTree<2, ComplexDouble> &out, ConvolutionOperator<2> &oper, FunctionTree<2, ComplexDouble> &inp, int maxIter, bool absPrec);
+template void apply<3, ComplexDouble>(double prec, FunctionTree<3, ComplexDouble> &out, ConvolutionOperator<3> &oper, FunctionTree<3, ComplexDouble> &inp, int maxIter, bool absPrec);
+template void apply<1, ComplexDouble>(double prec, FunctionTree<1, ComplexDouble> &out, ConvolutionOperator<1> &oper, FunctionTree<1, ComplexDouble> &inp, FunctionTreeVector<1, ComplexDouble> &precTrees, int maxIter, bool absPrec);
+template void apply<2, ComplexDouble>(double prec, FunctionTree<2, ComplexDouble> &out, ConvolutionOperator<2> &oper, FunctionTree<2, ComplexDouble> &inp, FunctionTreeVector<2, ComplexDouble> &precTrees, int maxIter, bool absPrec);
+template void apply<3, ComplexDouble>(double prec, FunctionTree<3, ComplexDouble> &out, ConvolutionOperator<3> &oper, FunctionTree<3, ComplexDouble> &inp, FunctionTreeVector<3, ComplexDouble> &precTrees, int maxIter, bool absPrec);
+template void apply_far_field<1, ComplexDouble>(double prec, FunctionTree<1, ComplexDouble> &out, ConvolutionOperator<1> &oper, FunctionTree<1, ComplexDouble> &inp, int maxIter, bool absPrec);
+template void apply_far_field<2, ComplexDouble>(double prec, FunctionTree<2, ComplexDouble> &out, ConvolutionOperator<2> &oper, FunctionTree<2, ComplexDouble> &inp, int maxIter, bool absPrec);
+template void apply_far_field<3, ComplexDouble>(double prec, FunctionTree<3, ComplexDouble> &out, ConvolutionOperator<3> &oper, FunctionTree<3, ComplexDouble> &inp, int maxIter, bool absPrec);
+template void apply_near_field<1, ComplexDouble>(double prec, FunctionTree<1, ComplexDouble> &out, ConvolutionOperator<1> &oper, FunctionTree<1, ComplexDouble> &inp, int maxIter, bool absPrec);
+template void apply_near_field<2, ComplexDouble>(double prec, FunctionTree<2, ComplexDouble> &out, ConvolutionOperator<2> &oper, FunctionTree<2, ComplexDouble> &inp, int maxIter, bool absPrec);
+template void apply_near_field<3, ComplexDouble>(double prec, FunctionTree<3, ComplexDouble> &out, ConvolutionOperator<3> &oper, FunctionTree<3, ComplexDouble> &inp, int maxIter, bool absPrec);
+template void apply<1, ComplexDouble>(FunctionTree<1, ComplexDouble> &out, DerivativeOperator<1> &oper, FunctionTree<1, ComplexDouble> &inp, int dir);
+template void apply<2, ComplexDouble>(FunctionTree<2, ComplexDouble> &out, DerivativeOperator<2> &oper, FunctionTree<2, ComplexDouble> &inp, int dir);
+template void apply<3, ComplexDouble>(FunctionTree<3, ComplexDouble> &out, DerivativeOperator<3> &oper, FunctionTree<3, ComplexDouble> &inp, int dir);
+template void divergence<1, ComplexDouble>(FunctionTree<1, ComplexDouble> &out, DerivativeOperator<1> &oper, FunctionTreeVector<1, ComplexDouble> &inp);
+template void divergence<2, ComplexDouble>(FunctionTree<2, ComplexDouble> &out, DerivativeOperator<2> &oper, FunctionTreeVector<2, ComplexDouble> &inp);
+template void divergence<3, ComplexDouble>(FunctionTree<3, ComplexDouble> &out, DerivativeOperator<3> &oper, FunctionTreeVector<3, ComplexDouble> &inp);
+template void divergence<1, ComplexDouble>(FunctionTree<1, ComplexDouble> &out, DerivativeOperator<1> &oper, std::vector<FunctionTree<1, ComplexDouble> *> &inp);
+template void divergence<2, ComplexDouble>(FunctionTree<2, ComplexDouble> &out, DerivativeOperator<2> &oper, std::vector<FunctionTree<2, ComplexDouble> *> &inp);
+template void divergence<3, ComplexDouble>(FunctionTree<3, ComplexDouble> &out, DerivativeOperator<3> &oper, std::vector<FunctionTree<3, ComplexDouble> *> &inp);
+template FunctionTreeVector<1, ComplexDouble> gradient<1>(DerivativeOperator<1> &oper, FunctionTree<1, ComplexDouble> &inp);
+template FunctionTreeVector<2, ComplexDouble> gradient<2>(DerivativeOperator<2> &oper, FunctionTree<2, ComplexDouble> &inp);
+template FunctionTreeVector<3, ComplexDouble> gradient<3>(DerivativeOperator<3> &oper, FunctionTree<3, ComplexDouble> &inp);
 
 } // namespace mrcpp
diff --git a/src/treebuilders/apply.h b/src/treebuilders/apply.h
index ae38e96ad..f6217e381 100644
--- a/src/treebuilders/apply.h
+++ b/src/treebuilders/apply.h
@@ -30,18 +30,18 @@
 namespace mrcpp {
 
 // clang-format off
-template <int D> class FunctionTree;
+template <int D, typename T> class FunctionTree;
 template <int D> class DerivativeOperator;
 template <int D> class ConvolutionOperator;
 
-template <int D> void apply(double prec, FunctionTree<D> &out, ConvolutionOperator<D> &oper, FunctionTree<D> &inp, int maxIter = -1, bool absPrec = false);
-template <int D> void apply(double prec, FunctionTree<D> &out, ConvolutionOperator<D> &oper, FunctionTree<D> &inp, FunctionTreeVector<D> &precTrees, int maxIter = -1, bool absPrec = false);
-template <int D> void apply_far_field(double prec, FunctionTree<D> &out, ConvolutionOperator<D> &oper, FunctionTree<D> &inp, int maxIter = -1, bool absPrec = false);
-template <int D> void apply_near_field(double prec, FunctionTree<D> &out, ConvolutionOperator<D> &oper, FunctionTree<D> &inp, int maxIter = -1, bool absPrec = false);
-template <int D> void apply(FunctionTree<D> &out, DerivativeOperator<D> &oper, FunctionTree<D> &inp, int dir = -1);
-template <int D> void divergence(FunctionTree<D> &out, DerivativeOperator<D> &oper, FunctionTreeVector<D> &inp);
-template <int D> void divergence(FunctionTree<D> &out, DerivativeOperator<D> &oper, std::vector<FunctionTree<D> *> &inp);
-template <int D> FunctionTreeVector<D> gradient(DerivativeOperator<D> &oper, FunctionTree<D> &inp);
+template <int D, typename T> void apply(double prec, FunctionTree<D, T> &out, ConvolutionOperator<D> &oper, FunctionTree<D, T> &inp, int maxIter = -1, bool absPrec = false);
+template <int D, typename T> void apply(double prec, FunctionTree<D, T> &out, ConvolutionOperator<D> &oper, FunctionTree<D, T> &inp, FunctionTreeVector<D, T> &precTrees, int maxIter = -1, bool absPrec = false);
+template <int D, typename T> void apply_far_field(double prec, FunctionTree<D, T> &out, ConvolutionOperator<D> &oper, FunctionTree<D, T> &inp, int maxIter = -1, bool absPrec = false);
+template <int D, typename T> void apply_near_field(double prec, FunctionTree<D, T> &out, ConvolutionOperator<D> &oper, FunctionTree<D, T> &inp, int maxIter = -1, bool absPrec = false);
+template <int D, typename T> void apply(FunctionTree<D, T> &out, DerivativeOperator<D> &oper, FunctionTree<D, T> &inp, int dir = -1);
+template <int D, typename T> void divergence(FunctionTree<D, T> &out, DerivativeOperator<D> &oper, FunctionTreeVector<D, T> &inp);
+template <int D, typename T> void divergence(FunctionTree<D, T> &out, DerivativeOperator<D> &oper, std::vector<FunctionTree<D, T> *> &inp);
+template <int D, typename T> FunctionTreeVector<D, T> gradient(DerivativeOperator<D> &oper, FunctionTree<D, T> &inp);
 // clang-format on
 
 } // namespace mrcpp
diff --git a/src/treebuilders/complex_apply.cpp b/src/treebuilders/complex_apply.cpp
index ab410244e..8b22d19f6 100644
--- a/src/treebuilders/complex_apply.cpp
+++ b/src/treebuilders/complex_apply.cpp
@@ -101,9 +101,6 @@ void apply
 }
 
 
-
-
-
 template
 void apply <1>
 (
diff --git a/src/treebuilders/grid.cpp b/src/treebuilders/grid.cpp
index fb9e65a91..86f71f41c 100644
--- a/src/treebuilders/grid.cpp
+++ b/src/treebuilders/grid.cpp
@@ -48,11 +48,11 @@ namespace mrcpp {
  * @note This algorithm will start at whatever grid is present in the `out`
  * tree when the function is called.
  */
-template <int D> void build_grid(FunctionTree<D> &out, int scales) {
+template <int D, typename T> void build_grid(FunctionTree<D, T> &out, int scales) {
     auto maxScale = out.getMRA().getMaxScale();
-    TreeBuilder<D> builder;
-    DefaultCalculator<D> calculator;
-    SplitAdaptor<D> adaptor(maxScale, true); // Splits all nodes
+    TreeBuilder<D, T> builder;
+    DefaultCalculator<D, T> calculator;
+    SplitAdaptor<D, T> adaptor(maxScale, true); // Splits all nodes
     for (auto n = 0; n < scales; n++) builder.build(out, calculator, adaptor, 1);
 }
 
@@ -75,11 +75,11 @@ template <int D> void build_grid(FunctionTree<D> &out, int scales) {
  * particular `RepresentableFunction`.
  *
  */
-template <int D> void build_grid(FunctionTree<D> &out, const RepresentableFunction<D> &inp, int maxIter) {
+template <int D, typename T> void build_grid(FunctionTree<D, T> &out, const RepresentableFunction<D, T> &inp, int maxIter) {
     auto maxScale = out.getMRA().getMaxScale();
-    TreeBuilder<D> builder;
-    AnalyticAdaptor<D> adaptor(inp, maxScale);
-    DefaultCalculator<D> calculator;
+    TreeBuilder<D, T> builder;
+    AnalyticAdaptor<D, T> adaptor(inp, maxScale);
+    DefaultCalculator<D, T> calculator;
     builder.build(out, calculator, adaptor, maxIter);
     print::separator(10, ' ');
 }
@@ -109,7 +109,7 @@ template <int D> void build_grid(FunctionTree<D> &out, const GaussExp<D> &inp, i
         TreeBuilder<D> builder;
         DefaultCalculator<D> calculator;
         for (auto i = 0; i < inp.size(); i++) {
-            AnalyticAdaptor<D> adaptor(inp.getFunc(i), maxScale);
+	  AnalyticAdaptor<D> adaptor(inp.getFunc(i), maxScale);
             builder.build(out, calculator, adaptor, maxIter);
         }
     } else {
@@ -142,12 +142,12 @@ template <int D> void build_grid(FunctionTree<D> &out, const GaussExp<D> &inp, i
  * but NOT vice versa.
  *
  */
-template <int D> void build_grid(FunctionTree<D> &out, FunctionTree<D> &inp, int maxIter) {
+template <int D, typename T> void build_grid(FunctionTree<D, T> &out, FunctionTree<D, T> &inp, int maxIter) {
     if (out.getMRA() != inp.getMRA()) MSG_ABORT("Incompatible MRA");
     auto maxScale = out.getMRA().getMaxScale();
-    TreeBuilder<D> builder;
-    CopyAdaptor<D> adaptor(inp, maxScale, nullptr);
-    DefaultCalculator<D> calculator;
+    TreeBuilder<D, T> builder;
+    CopyAdaptor<D, T> adaptor(inp, maxScale, nullptr);
+    DefaultCalculator<D, T> calculator;
     builder.build(out, calculator, adaptor, maxIter);
     print::separator(10, ' ');
 }
@@ -171,20 +171,20 @@ template <int D> void build_grid(FunctionTree<D> &out, FunctionTree<D> &inp, int
  * `maxIter` is reached).
  *
  */
-template <int D> void build_grid(FunctionTree<D> &out, FunctionTreeVector<D> &inp, int maxIter) {
+template <int D, typename T> void build_grid(FunctionTree<D, T> &out, FunctionTreeVector<D, T> &inp, int maxIter) {
     for (auto i = 0; i < inp.size(); i++)
         if (out.getMRA() != get_func(inp, i).getMRA()) MSG_ABORT("Incompatible MRA");
 
     auto maxScale = out.getMRA().getMaxScale();
-    TreeBuilder<D> builder;
-    CopyAdaptor<D> adaptor(inp, maxScale, nullptr);
-    DefaultCalculator<D> calculator;
+    TreeBuilder<D, T> builder;
+    CopyAdaptor<D, T> adaptor(inp, maxScale, nullptr);
+    DefaultCalculator<D, T> calculator;
     builder.build(out, calculator, adaptor, maxIter);
     print::separator(10, ' ');
 }
 
-template <int D> void build_grid(FunctionTree<D> &out, std::vector<FunctionTree<D> *> &inp, int maxIter) {
-    FunctionTreeVector<D> inp_vec;
+template <int D, typename T> void build_grid(FunctionTree<D, T> &out, std::vector<FunctionTree<D, T> *> &inp, int maxIter) {
+    FunctionTreeVector<D, T> inp_vec;
     for (auto *t : inp) inp_vec.push_back({1.0, t});
     build_grid(out, inp_vec, maxIter);
 }
@@ -202,8 +202,8 @@ template <int D> void build_grid(FunctionTree<D> &out, std::vector<FunctionTree<
  * tree when the function is called and will overwrite any existing coefs.
  *
  */
-template <int D> void copy_func(FunctionTree<D> &out, FunctionTree<D> &inp) {
-    FunctionTreeVector<D> tmp_vec;
+template <int D, typename T> void copy_func(FunctionTree<D, T> &out, FunctionTree<D, T> &inp) {
+    FunctionTreeVector<D, T> tmp_vec;
     tmp_vec.push_back(std::make_tuple(1.0, &inp));
     add(-1.0, out, tmp_vec);
 }
@@ -218,7 +218,7 @@ template <int D> void copy_func(FunctionTree<D> &out, FunctionTree<D> &inp) {
  * will _extend_ the existing grid.
  *
  */
-template <int D> void copy_grid(FunctionTree<D> &out, FunctionTree<D> &inp) {
+template <int D, typename T> void copy_grid(FunctionTree<D, T> &out, FunctionTree<D, T> &inp) {
     if (out.getMRA() != inp.getMRA()) MSG_ABORT("Incompatible MRA")
     out.clear();
     build_grid(out, inp);
@@ -233,9 +233,9 @@ template <int D> void copy_grid(FunctionTree<D> &out, FunctionTree<D> &inp) {
  * grid refinement as well.
  *
  */
-template <int D> void clear_grid(FunctionTree<D> &out) {
-    TreeBuilder<D> builder;
-    DefaultCalculator<D> calculator;
+template <int D, typename T> void clear_grid(FunctionTree<D, T> &out) {
+    TreeBuilder<D, T> builder;
+    DefaultCalculator<D, T> calculator;
     builder.clear(out, calculator);
 }
 
@@ -250,11 +250,11 @@ template <int D> void clear_grid(FunctionTree<D> &out) {
  * the function representation unchanged, but on a larger grid.
  *
  */
-template <int D> int refine_grid(FunctionTree<D> &out, int scales) {
+template <int D, typename T> int refine_grid(FunctionTree<D, T> &out, int scales) {
     auto nSplit = 0;
     auto maxScale = out.getMRA().getMaxScale();
-    TreeBuilder<D> builder;
-    SplitAdaptor<D> adaptor(maxScale, true); // Splits all nodes
+    TreeBuilder<D, T> builder;
+    SplitAdaptor<D, T> adaptor(maxScale, true); // Splits all nodes
     for (auto n = 0; n < scales; n++) {
         nSplit += builder.split(out, adaptor, true); // Transfers coefs to children
     }
@@ -274,10 +274,10 @@ template <int D> int refine_grid(FunctionTree<D> &out, int scales) {
  * unchanged, but (possibly) on a larger grid.
  *
  */
-template <int D> int refine_grid(FunctionTree<D> &out, double prec, bool absPrec) {
+template <int D, typename T> int refine_grid(FunctionTree<D, T> &out, double prec, bool absPrec) {
     int maxScale = out.getMRA().getMaxScale();
-    TreeBuilder<D> builder;
-    WaveletAdaptor<D> adaptor(prec, maxScale, absPrec);
+    TreeBuilder<D, T> builder;
+    WaveletAdaptor<D, T> adaptor(prec, maxScale, absPrec);
     int nSplit = builder.split(out, adaptor, true);
     return nSplit;
 }
@@ -294,11 +294,11 @@ template <int D> int refine_grid(FunctionTree<D> &out, double prec, bool absPrec
  * leaving the function representation unchanged, but on a larger grid.
  *
  */
-template <int D> int refine_grid(FunctionTree<D> &out, FunctionTree<D> &inp) {
+template <int D, typename T> int refine_grid(FunctionTree<D, T> &out, FunctionTree<D, T> &inp) {
     if (out.getMRA() != inp.getMRA()) MSG_ABORT("Incompatible MRA")
     auto maxScale = out.getMRA().getMaxScale();
-    TreeBuilder<D> builder;
-    CopyAdaptor<D> adaptor(inp, maxScale, nullptr);
+    TreeBuilder<D, T> builder;
+    CopyAdaptor<D, T> adaptor(inp, maxScale, nullptr);
     auto nSplit = builder.split(out, adaptor, true);
     return nSplit;
 }
@@ -316,52 +316,90 @@ template <int D> int refine_grid(FunctionTree<D> &out, FunctionTree<D> &inp) {
  * is implemented in the particular `RepresentableFunction`.
  *
  */
-template <int D> int refine_grid(FunctionTree<D> &out, const RepresentableFunction<D> &inp) {
+template <int D, typename T> int refine_grid(FunctionTree<D, T> &out, const RepresentableFunction<D, T> &inp) {
     auto maxScale = out.getMRA().getMaxScale();
-    TreeBuilder<D> builder;
-    AnalyticAdaptor<D> adaptor(inp, maxScale);
+    TreeBuilder<D, T> builder;
+    AnalyticAdaptor<D, T> adaptor(inp, maxScale);
     int nSplit = builder.split(out, adaptor, true);
     return nSplit;
 }
 
-template void build_grid<1>(FunctionTree<1> &out, int scales);
-template void build_grid<2>(FunctionTree<2> &out, int scales);
-template void build_grid<3>(FunctionTree<3> &out, int scales);
+template void build_grid<1, double>(FunctionTree<1, double> &out, int scales);
+template void build_grid<2, double>(FunctionTree<2, double> &out, int scales);
+template void build_grid<3, double>(FunctionTree<3, double> &out, int scales);
 template void build_grid<1>(FunctionTree<1> &out, const GaussExp<1> &inp, int maxIter);
 template void build_grid<2>(FunctionTree<2> &out, const GaussExp<2> &inp, int maxIter);
 template void build_grid<3>(FunctionTree<3> &out, const GaussExp<3> &inp, int maxIter);
-template void build_grid<1>(FunctionTree<1> &out, const RepresentableFunction<1> &inp, int maxIter);
-template void build_grid<2>(FunctionTree<2> &out, const RepresentableFunction<2> &inp, int maxIter);
-template void build_grid<3>(FunctionTree<3> &out, const RepresentableFunction<3> &inp, int maxIter);
-template void build_grid<1>(FunctionTree<1> &out, FunctionTree<1> &inp, int maxIter);
-template void build_grid<2>(FunctionTree<2> &out, FunctionTree<2> &inp, int maxIter);
-template void build_grid<3>(FunctionTree<3> &out, FunctionTree<3> &inp, int maxIter);
-template void build_grid<1>(FunctionTree<1> &out, FunctionTreeVector<1> &inp, int maxIter);
-template void build_grid<2>(FunctionTree<2> &out, FunctionTreeVector<2> &inp, int maxIter);
-template void build_grid<3>(FunctionTree<3> &out, FunctionTreeVector<3> &inp, int maxIter);
-template void build_grid<1>(FunctionTree<1> &out, std::vector<FunctionTree<1> *> &inp, int maxIter);
-template void build_grid<2>(FunctionTree<2> &out, std::vector<FunctionTree<2> *> &inp, int maxIter);
-template void build_grid<3>(FunctionTree<3> &out, std::vector<FunctionTree<3> *> &inp, int maxIter);
-template void copy_func<1>(FunctionTree<1> &out, FunctionTree<1> &inp);
-template void copy_func<2>(FunctionTree<2> &out, FunctionTree<2> &inp);
-template void copy_func<3>(FunctionTree<3> &out, FunctionTree<3> &inp);
-template void copy_grid<1>(FunctionTree<1> &out, FunctionTree<1> &inp);
-template void copy_grid<2>(FunctionTree<2> &out, FunctionTree<2> &inp);
-template void copy_grid<3>(FunctionTree<3> &out, FunctionTree<3> &inp);
-template void clear_grid<1>(FunctionTree<1> &out);
-template void clear_grid<2>(FunctionTree<2> &out);
-template void clear_grid<3>(FunctionTree<3> &out);
-template int refine_grid<1>(FunctionTree<1> &out, int scales);
-template int refine_grid<2>(FunctionTree<2> &out, int scales);
-template int refine_grid<3>(FunctionTree<3> &out, int scales);
-template int refine_grid<1>(FunctionTree<1> &out, double prec, bool absPrec);
-template int refine_grid<2>(FunctionTree<2> &out, double prec, bool absPrec);
-template int refine_grid<3>(FunctionTree<3> &out, double prec, bool absPrec);
-template int refine_grid<1>(FunctionTree<1> &out, FunctionTree<1> &inp);
-template int refine_grid<2>(FunctionTree<2> &out, FunctionTree<2> &inp);
-template int refine_grid<3>(FunctionTree<3> &out, FunctionTree<3> &inp);
-template int refine_grid<1>(FunctionTree<1> &out, const RepresentableFunction<1> &inp);
-template int refine_grid<2>(FunctionTree<2> &out, const RepresentableFunction<2> &inp);
-template int refine_grid<3>(FunctionTree<3> &out, const RepresentableFunction<3> &inp);
+template void build_grid<1, double>(FunctionTree<1, double> &out, const RepresentableFunction<1, double> &inp, int maxIter);
+template void build_grid<2, double>(FunctionTree<2, double> &out, const RepresentableFunction<2, double> &inp, int maxIter);
+template void build_grid<3, double>(FunctionTree<3, double> &out, const RepresentableFunction<3, double> &inp, int maxIter);
+template void build_grid<1, double>(FunctionTree<1, double> &out, FunctionTree<1, double> &inp, int maxIter);
+template void build_grid<2, double>(FunctionTree<2, double> &out, FunctionTree<2, double> &inp, int maxIter);
+template void build_grid<3, double>(FunctionTree<3, double> &out, FunctionTree<3, double> &inp, int maxIter);
+template void build_grid<1, double>(FunctionTree<1, double> &out, FunctionTreeVector<1, double> &inp, int maxIter);
+template void build_grid<2, double>(FunctionTree<2, double> &out, FunctionTreeVector<2, double> &inp, int maxIter);
+template void build_grid<3, double>(FunctionTree<3, double> &out, FunctionTreeVector<3, double> &inp, int maxIter);
+template void build_grid<1, double>(FunctionTree<1, double> &out, std::vector<FunctionTree<1, double> *> &inp, int maxIter);
+template void build_grid<2, double>(FunctionTree<2, double> &out, std::vector<FunctionTree<2, double> *> &inp, int maxIter);
+template void build_grid<3, double>(FunctionTree<3, double> &out, std::vector<FunctionTree<3, double> *> &inp, int maxIter);
+template void copy_func<1, double>(FunctionTree<1, double> &out, FunctionTree<1, double> &inp);
+template void copy_func<2, double>(FunctionTree<2, double> &out, FunctionTree<2, double> &inp);
+template void copy_func<3, double>(FunctionTree<3, double> &out, FunctionTree<3, double> &inp);
+template void copy_grid<1, double>(FunctionTree<1, double> &out, FunctionTree<1, double> &inp);
+template void copy_grid<2, double>(FunctionTree<2, double> &out, FunctionTree<2, double> &inp);
+template void copy_grid<3, double>(FunctionTree<3, double> &out, FunctionTree<3, double> &inp);
+template void clear_grid<1, double>(FunctionTree<1, double> &out);
+template void clear_grid<2, double>(FunctionTree<2, double> &out);
+template void clear_grid<3, double>(FunctionTree<3, double> &out);
+template int refine_grid<1, double>(FunctionTree<1, double> &out, int scales);
+template int refine_grid<2, double>(FunctionTree<2, double> &out, int scales);
+template int refine_grid<3, double>(FunctionTree<3, double> &out, int scales);
+template int refine_grid<1, double>(FunctionTree<1, double> &out, double prec, bool absPrec);
+template int refine_grid<2, double>(FunctionTree<2, double> &out, double prec, bool absPrec);
+template int refine_grid<3, double>(FunctionTree<3, double> &out, double prec, bool absPrec);
+template int refine_grid<1, double>(FunctionTree<1, double> &out, FunctionTree<1, double> &inp);
+template int refine_grid<2, double>(FunctionTree<2, double> &out, FunctionTree<2, double> &inp);
+template int refine_grid<3, double>(FunctionTree<3, double> &out, FunctionTree<3, double> &inp);
+template int refine_grid<1, double>(FunctionTree<1, double> &out, const RepresentableFunction<1, double> &inp);
+template int refine_grid<2, double>(FunctionTree<2, double> &out, const RepresentableFunction<2, double> &inp);
+template int refine_grid<3, double>(FunctionTree<3, double> &out, const RepresentableFunction<3, double> &inp);
+
+
+template void build_grid<1, ComplexDouble>(FunctionTree<1, ComplexDouble> &out, int scales);
+template void build_grid<2, ComplexDouble>(FunctionTree<2, ComplexDouble> &out, int scales);
+template void build_grid<3, ComplexDouble>(FunctionTree<3, ComplexDouble> &out, int scales);
+template void build_grid<1, ComplexDouble>(FunctionTree<1, ComplexDouble> &out, const RepresentableFunction<1, ComplexDouble> &inp, int maxIter);
+template void build_grid<2, ComplexDouble>(FunctionTree<2, ComplexDouble> &out, const RepresentableFunction<2, ComplexDouble> &inp, int maxIter);
+template void build_grid<3, ComplexDouble>(FunctionTree<3, ComplexDouble> &out, const RepresentableFunction<3, ComplexDouble> &inp, int maxIter);
+template void build_grid<1, ComplexDouble>(FunctionTree<1, ComplexDouble> &out, FunctionTree<1, ComplexDouble> &inp, int maxIter);
+template void build_grid<2, ComplexDouble>(FunctionTree<2, ComplexDouble> &out, FunctionTree<2, ComplexDouble> &inp, int maxIter);
+template void build_grid<3, ComplexDouble>(FunctionTree<3, ComplexDouble> &out, FunctionTree<3, ComplexDouble> &inp, int maxIter);
+template void build_grid<1, ComplexDouble>(FunctionTree<1, ComplexDouble> &out, FunctionTreeVector<1, ComplexDouble> &inp, int maxIter);
+template void build_grid<2, ComplexDouble>(FunctionTree<2, ComplexDouble> &out, FunctionTreeVector<2, ComplexDouble> &inp, int maxIter);
+template void build_grid<3, ComplexDouble>(FunctionTree<3, ComplexDouble> &out, FunctionTreeVector<3, ComplexDouble> &inp, int maxIter);
+template void build_grid<1, ComplexDouble>(FunctionTree<1, ComplexDouble> &out, std::vector<FunctionTree<1, ComplexDouble> *> &inp, int maxIter);
+template void build_grid<2, ComplexDouble>(FunctionTree<2, ComplexDouble> &out, std::vector<FunctionTree<2, ComplexDouble> *> &inp, int maxIter);
+template void build_grid<3, ComplexDouble>(FunctionTree<3, ComplexDouble> &out, std::vector<FunctionTree<3, ComplexDouble> *> &inp, int maxIter);
+template void copy_func<1, ComplexDouble>(FunctionTree<1, ComplexDouble> &out, FunctionTree<1, ComplexDouble> &inp);
+template void copy_func<2, ComplexDouble>(FunctionTree<2, ComplexDouble> &out, FunctionTree<2, ComplexDouble> &inp);
+template void copy_func<3, ComplexDouble>(FunctionTree<3, ComplexDouble> &out, FunctionTree<3, ComplexDouble> &inp);
+template void copy_grid<1, ComplexDouble>(FunctionTree<1, ComplexDouble> &out, FunctionTree<1, ComplexDouble> &inp);
+template void copy_grid<2, ComplexDouble>(FunctionTree<2, ComplexDouble> &out, FunctionTree<2, ComplexDouble> &inp);
+template void copy_grid<3, ComplexDouble>(FunctionTree<3, ComplexDouble> &out, FunctionTree<3, ComplexDouble> &inp);
+template void clear_grid<1, ComplexDouble>(FunctionTree<1, ComplexDouble> &out);
+template void clear_grid<2, ComplexDouble>(FunctionTree<2, ComplexDouble> &out);
+template void clear_grid<3, ComplexDouble>(FunctionTree<3, ComplexDouble> &out);
+template int refine_grid<1, ComplexDouble>(FunctionTree<1, ComplexDouble> &out, int scales);
+template int refine_grid<2, ComplexDouble>(FunctionTree<2, ComplexDouble> &out, int scales);
+template int refine_grid<3, ComplexDouble>(FunctionTree<3, ComplexDouble> &out, int scales);
+template int refine_grid<1, ComplexDouble>(FunctionTree<1, ComplexDouble> &out, double prec, bool absPrec);
+template int refine_grid<2, ComplexDouble>(FunctionTree<2, ComplexDouble> &out, double prec, bool absPrec);
+template int refine_grid<3, ComplexDouble>(FunctionTree<3, ComplexDouble> &out, double prec, bool absPrec);
+template int refine_grid<1, ComplexDouble>(FunctionTree<1, ComplexDouble> &out, FunctionTree<1, ComplexDouble> &inp);
+template int refine_grid<2, ComplexDouble>(FunctionTree<2, ComplexDouble> &out, FunctionTree<2, ComplexDouble> &inp);
+template int refine_grid<3, ComplexDouble>(FunctionTree<3, ComplexDouble> &out, FunctionTree<3, ComplexDouble> &inp);
+template int refine_grid<1, ComplexDouble>(FunctionTree<1, ComplexDouble> &out, const RepresentableFunction<1, ComplexDouble> &inp);
+template int refine_grid<2, ComplexDouble>(FunctionTree<2, ComplexDouble> &out, const RepresentableFunction<2, ComplexDouble> &inp);
+template int refine_grid<3, ComplexDouble>(FunctionTree<3, ComplexDouble> &out, const RepresentableFunction<3, ComplexDouble> &inp);
 
 } // namespace mrcpp
diff --git a/src/treebuilders/grid.h b/src/treebuilders/grid.h
index 1f4c3e4f5..42f54aa0a 100644
--- a/src/treebuilders/grid.h
+++ b/src/treebuilders/grid.h
@@ -30,17 +30,17 @@
 #include "trees/FunctionTreeVector.h"
 
 namespace mrcpp {
-template <int D> void build_grid(FunctionTree<D> &out, int scales);
+template <int D, typename T> void build_grid(FunctionTree<D, T> &out, int scales);
 template <int D> void build_grid(FunctionTree<D> &out, const GaussExp<D> &inp, int maxIter = -1);
-template <int D> void build_grid(FunctionTree<D> &out, const RepresentableFunction<D> &inp, int maxIter = -1);
-template <int D> void build_grid(FunctionTree<D> &out, FunctionTree<D> &inp, int maxIter = -1);
-template <int D> void build_grid(FunctionTree<D> &out, FunctionTreeVector<D> &inp, int maxIter = -1);
-template <int D> void build_grid(FunctionTree<D> &out, std::vector<FunctionTree<D> *> &inp, int maxIter = -1);
-template <int D> void copy_func(FunctionTree<D> &out, FunctionTree<D> &inp);
-template <int D> void copy_grid(FunctionTree<D> &out, FunctionTree<D> &inp);
-template <int D> void clear_grid(FunctionTree<D> &out);
-template <int D> int refine_grid(FunctionTree<D> &out, int scales);
-template <int D> int refine_grid(FunctionTree<D> &out, double prec, bool absPrec = false);
-template <int D> int refine_grid(FunctionTree<D> &out, FunctionTree<D> &inp);
-template <int D> int refine_grid(FunctionTree<D> &out, const RepresentableFunction<D> &inp);
+template <int D, typename T> void build_grid(FunctionTree<D, T> &out, const RepresentableFunction<D, T> &inp, int maxIter = -1);
+template <int D, typename T> void build_grid(FunctionTree<D, T> &out, FunctionTree<D, T> &inp, int maxIter = -1);
+template <int D, typename T> void build_grid(FunctionTree<D, T> &out, FunctionTreeVector<D, T> &inp, int maxIter = -1);
+template <int D, typename T> void build_grid(FunctionTree<D, T> &out, std::vector<FunctionTree<D, T> *> &inp, int maxIter = -1);
+template <int D, typename T> void copy_func(FunctionTree<D, T> &out, FunctionTree<D, T> &inp);
+template <int D, typename T> void copy_grid(FunctionTree<D, T> &out, FunctionTree<D, T> &inp);
+template <int D, typename T> void clear_grid(FunctionTree<D, T> &out);
+template <int D, typename T> int refine_grid(FunctionTree<D, T> &out, int scales);
+template <int D, typename T> int refine_grid(FunctionTree<D, T> &out, double prec, bool absPrec = false);
+template <int D, typename T> int refine_grid(FunctionTree<D, T> &out, FunctionTree<D, T> &inp);
+template <int D, typename T> int refine_grid(FunctionTree<D, T> &out, const RepresentableFunction<D, T> &inp);
 } // namespace mrcpp
diff --git a/src/treebuilders/map.cpp b/src/treebuilders/map.cpp
index 98824d002..ba064ca39 100644
--- a/src/treebuilders/map.cpp
+++ b/src/treebuilders/map.cpp
@@ -66,12 +66,12 @@ namespace mrcpp {
  *
  */
 template <int D>
-void map(double prec, FunctionTree<D> &out, FunctionTree<D> &inp, FMap fmap, int maxIter, bool absPrec) {
+void map(double prec, FunctionTree<D, double> &out, FunctionTree<D, double> &inp, FMap<double, double> fmap, int maxIter, bool absPrec) {
 
     int maxScale = out.getMRA().getMaxScale();
-    TreeBuilder<D> builder;
-    WaveletAdaptor<D> adaptor(prec, maxScale, absPrec);
-    MapCalculator<D> calculator(fmap, inp);
+    TreeBuilder<D, double> builder;
+    WaveletAdaptor<D, double> adaptor(prec, maxScale, absPrec);
+    MapCalculator<D, double> calculator(fmap, inp);
 
     builder.build(out, calculator, adaptor, maxIter);
 
@@ -89,8 +89,8 @@ void map(double prec, FunctionTree<D> &out, FunctionTree<D> &inp, FMap fmap, int
     print::separator(10, ' ');
 }
 
-template void map<1>(double prec, FunctionTree<1> &out, FunctionTree<1> &inp, FMap fmap, int maxIter, bool absPrec);
-template void map<2>(double prec, FunctionTree<2> &out, FunctionTree<2> &inp, FMap fmap, int maxIter, bool absPrec);
-template void map<3>(double prec, FunctionTree<3> &out, FunctionTree<3> &inp, FMap fmap, int maxIter, bool absPrec);
+template void map<1>(double prec, FunctionTree<1, double> &out, FunctionTree<1, double> &inp, FMap<double, double> fmap, int maxIter, bool absPrec);
+template void map<2>(double prec, FunctionTree<2, double> &out, FunctionTree<2, double> &inp, FMap<double, double> fmap, int maxIter, bool absPrec);
+template void map<3>(double prec, FunctionTree<3, double> &out, FunctionTree<3, double> &inp, FMap<double, double> fmap, int maxIter, bool absPrec);
 
 } // Namespace mrcpp
diff --git a/src/treebuilders/map.h b/src/treebuilders/map.h
index 1c54dac32..4fe3cf72d 100644
--- a/src/treebuilders/map.h
+++ b/src/treebuilders/map.h
@@ -28,10 +28,9 @@
 #include "trees/FunctionTreeVector.h"
 
 namespace mrcpp {
-template <int D> class RepresentableFunction;
-template <int D> class FunctionTree;
+template <int D, typename T> class FunctionTree;
 
 template <int D>
-void map(double prec, FunctionTree<D> &out, FunctionTree<D> &inp, FMap fmap, int maxIter = -1, bool absPrec = false);
+void map(double prec, FunctionTree<D, double> &out, FunctionTree<D, double> &inp, FMap<double, double> fmap, int maxIter = -1, bool absPrec = false);
 
 } // namespace mrcpp
diff --git a/src/treebuilders/multiply.cpp b/src/treebuilders/multiply.cpp
index a21e539ab..6cbf58b72 100644
--- a/src/treebuilders/multiply.cpp
+++ b/src/treebuilders/multiply.cpp
@@ -68,16 +68,16 @@ namespace mrcpp {
  * no coefs).
  *
  */
-template <int D>
+template <int D, typename T>
 void multiply(double prec,
-              FunctionTree<D> &out,
-              double c,
-              FunctionTree<D> &inp_a,
-              FunctionTree<D> &inp_b,
+              FunctionTree<D, T> &out,
+              T c,
+              FunctionTree<D, T> &inp_a,
+              FunctionTree<D, T> &inp_b,
               int maxIter,
               bool absPrec,
               bool useMaxNorms) {
-    FunctionTreeVector<D> tmp_vec;
+    FunctionTreeVector<D, T> tmp_vec;
     tmp_vec.push_back({c, &inp_a});
     tmp_vec.push_back({1.0, &inp_b});
     multiply(prec, out, tmp_vec, maxIter, absPrec, useMaxNorms);
@@ -106,10 +106,10 @@ void multiply(double prec,
  * no coefs).
  *
  */
-template <int D>
+template <int D, typename T>
 void multiply(double prec,
-              FunctionTree<D> &out,
-              FunctionTreeVector<D> &inp,
+              FunctionTree<D, T> &out,
+              FunctionTreeVector<D, T> &inp,
               int maxIter,
               bool absPrec,
               bool useMaxNorms) {
@@ -117,15 +117,15 @@ void multiply(double prec,
         if (out.getMRA() != get_func(inp, i).getMRA()) MSG_ABORT("Incompatible MRA");
 
     int maxScale = out.getMRA().getMaxScale();
-    TreeBuilder<D> builder;
-    MultiplicationCalculator<D> calculator(inp);
+    TreeBuilder<D, T> builder;
+    MultiplicationCalculator<D, T> calculator(inp);
 
     if (useMaxNorms) {
         for (int i = 0; i < inp.size(); i++) get_func(inp, i).makeMaxSquareNorms();
-        MultiplicationAdaptor<D> adaptor(prec, maxScale, inp);
+        MultiplicationAdaptor<D, T> adaptor(prec, maxScale, inp);
         builder.build(out, calculator, adaptor, maxIter);
     } else {
-        WaveletAdaptor<D> adaptor(prec, maxScale, absPrec);
+        WaveletAdaptor<D, T> adaptor(prec, maxScale, absPrec);
         builder.build(out, calculator, adaptor, maxIter);
     }
 
@@ -136,7 +136,7 @@ void multiply(double prec,
 
     Timer clean_t;
     for (int i = 0; i < inp.size(); i++) {
-        FunctionTree<D> &tree = get_func(inp, i);
+        FunctionTree<D, T> &tree = get_func(inp, i);
         tree.deleteGenerated();
     }
     clean_t.stop();
@@ -146,14 +146,14 @@ void multiply(double prec,
     print::separator(10, ' ');
 }
 
-template <int D>
+template <int D, typename T>
 void multiply(double prec,
-              FunctionTree<D> &out,
-              std::vector<FunctionTree<D> *> &inp,
+              FunctionTree<D, T> &out,
+              std::vector<FunctionTree<D, T> *> &inp,
               int maxIter,
               bool absPrec,
               bool useMaxNorms) {
-    FunctionTreeVector<D> inp_vec;
+    FunctionTreeVector<D, T> inp_vec;
     for (auto &t : inp) inp_vec.push_back({1.0, t});
     multiply(prec, out, inp_vec, maxIter, absPrec, useMaxNorms);
 }
@@ -179,13 +179,13 @@ void multiply(double prec,
  * no coefs).
  *
  */
-template <int D> void square(double prec, FunctionTree<D> &out, FunctionTree<D> &inp, int maxIter, bool absPrec) {
+template <int D, typename T> void square(double prec, FunctionTree<D, T> &out, FunctionTree<D, T> &inp, int maxIter, bool absPrec) {
     if (out.getMRA() != inp.getMRA()) MSG_ABORT("Incompatible MRA");
 
     int maxScale = out.getMRA().getMaxScale();
-    TreeBuilder<D> builder;
-    WaveletAdaptor<D> adaptor(prec, maxScale, absPrec);
-    SquareCalculator<D> calculator(inp);
+    TreeBuilder<D, T> builder;
+    WaveletAdaptor<D, T> adaptor(prec, maxScale, absPrec);
+    SquareCalculator<D, T> calculator(inp);
 
     builder.build(out, calculator, adaptor, maxIter);
 
@@ -225,14 +225,14 @@ template <int D> void square(double prec, FunctionTree<D> &out, FunctionTree<D>
  * no coefs).
  *
  */
-template <int D>
-void power(double prec, FunctionTree<D> &out, FunctionTree<D> &inp, double p, int maxIter, bool absPrec) {
+template <int D, typename T>
+void power(double prec, FunctionTree<D, T> &out, FunctionTree<D, T> &inp, double p, int maxIter, bool absPrec) {
     if (out.getMRA() != inp.getMRA()) MSG_ABORT("Incompatible MRA");
 
     int maxScale = out.getMRA().getMaxScale();
-    TreeBuilder<D> builder;
-    WaveletAdaptor<D> adaptor(prec, maxScale, absPrec);
-    PowerCalculator<D> calculator(inp, p);
+    TreeBuilder<D, T> builder;
+    WaveletAdaptor<D, T> adaptor(prec, maxScale, absPrec);
+    PowerCalculator<D, T> calculator(inp, p);
 
     builder.build(out, calculator, adaptor, maxIter);
 
@@ -267,24 +267,25 @@ void power(double prec, FunctionTree<D> &out, FunctionTree<D> &inp, double p, in
  * @note The length of the input vectors must be the same.
  *
  */
-template <int D>
+template <int D, typename T>
 void dot(double prec,
-         FunctionTree<D> &out,
-         FunctionTreeVector<D> &inp_a,
-         FunctionTreeVector<D> &inp_b,
+         FunctionTree<D, T> &out,
+         FunctionTreeVector<D, T> &inp_a,
+         FunctionTreeVector<D, T> &inp_b,
          int maxIter,
          bool absPrec) {
     if (inp_a.size() != inp_b.size()) MSG_ABORT("Input length mismatch");
 
-    FunctionTreeVector<D> tmp_vec;
+    FunctionTreeVector<D, T> tmp_vec;
     for (int d = 0; d < inp_a.size(); d++) {
-        double coef_a = get_coef(inp_a, d);
-        double coef_b = get_coef(inp_b, d);
-        FunctionTree<D> &tree_a = get_func(inp_a, d);
-        FunctionTree<D> &tree_b = get_func(inp_b, d);
-        auto *out_d = new FunctionTree<D>(out.getMRA());
+        T coef_a = get_coef(inp_a, d);
+        T coef_b = get_coef(inp_b, d);
+        FunctionTree<D, T> &tree_a = get_func(inp_a, d);
+        FunctionTree<D, T> &tree_b = get_func(inp_b, d);
+        auto *out_d = new FunctionTree<D, T>(out.getMRA());
         build_grid(*out_d, out);
-        multiply(prec, *out_d, 1.0, tree_a, tree_b, maxIter, absPrec);
+        T One = 1.0;
+        multiply(prec, *out_d, One, tree_a, tree_b, maxIter, absPrec);
         tmp_vec.push_back({coef_a * coef_b, out_d});
     }
     build_grid(out, tmp_vec);
@@ -305,19 +306,19 @@ void dot(double prec,
  * grids overlap.
  *
  */
-template <int D> double dot(FunctionTree<D> &bra, FunctionTree<D> &ket) {
+template <int D, typename T> T dot(FunctionTree<D, T> &bra, FunctionTree<D, T> &ket) {
     if (bra.getMRA() != ket.getMRA()) MSG_ABORT("Trees not compatible");
 
-    MWNodeVector<D> nodeTable;
-    TreeIterator<D> it(bra);
+    MWNodeVector<D, T> nodeTable;
+    TreeIterator<D, T> it(bra);
     it.setReturnGenNodes(false);
     while (it.next()) {
-        MWNode<D> &node = it.getNode();
+        MWNode<D, T> &node = it.getNode();
         nodeTable.push_back(&node);
     }
     int nNodes = nodeTable.size();
-    double result = 0.0;
-    double locResult = 0.0;
+    T result = 0.0;
+    T locResult = 0.0;
     // OMP is disabled in order to get EXACT results (to the very last digit), the
     // order of summation makes the result different beyond the 14th digit or so.
     // OMP does improve the performace, but its not worth it for the time being.
@@ -326,11 +327,11 @@ template <int D> double dot(FunctionTree<D> &bra, FunctionTree<D> &ket) {
     //    {
     //#pragma omp for schedule(guided)
     for (int n = 0; n < nNodes; n++) {
-        const auto &braNode = static_cast<const FunctionNode<D> &>(*nodeTable[n]);
-        const MWNode<D> *mwNode = ket.findNode(braNode.getNodeIndex());
+        const auto &braNode = static_cast<const FunctionNode<D, T> &>(*nodeTable[n]);
+        const MWNode<D, T> *mwNode = ket.findNode(braNode.getNodeIndex());
         if (mwNode == nullptr) continue;
 
-        const auto &ketNode = static_cast<const FunctionNode<D> &>(*mwNode);
+        const auto &ketNode = static_cast<const FunctionNode<D, T> &>(*mwNode);
         if (braNode.isRootNode()) locResult += dot_scaling(braNode, ketNode);
         locResult += dot_wavelet(braNode, ketNode);
     }
@@ -352,30 +353,30 @@ template <int D> double dot(FunctionTree<D> &bra, FunctionTree<D> &ket) {
  * distribution within the node.
  * If the product is zero, the functions are disjoints.
  */
-template <int D> double node_norm_dot(FunctionTree<D> &bra, FunctionTree<D> &ket, bool exact) {
+template <int D, typename T> double node_norm_dot(FunctionTree<D, T> &bra, FunctionTree<D, T> &ket, bool exact) {
     if (bra.getMRA() != ket.getMRA()) MSG_ABORT("Incompatible MRA");
 
     double result = 0.0;
     int ncoef = bra.getKp1_d() * bra.getTDim();
-    double valA[ncoef];
-    double valB[ncoef];
+    T valA[ncoef];
+    T valB[ncoef];
     int nNodes = bra.getNEndNodes();
 
     for (int n = 0; n < nNodes; n++) {
-        FunctionNode<D> &node = bra.getEndFuncNode(n);
+        FunctionNode<D, T> &node = bra.getEndFuncNode(n);
         const NodeIndex<D> idx = node.getNodeIndex();
         if (exact) {
             // convert to interpolating coef, take abs, convert back
-            FunctionNode<D> *mwNode = static_cast<FunctionNode<D> *>(ket.findNode(idx));
+            FunctionNode<D, T> *mwNode = static_cast<FunctionNode<D, T> *>(ket.findNode(idx));
             if (mwNode == nullptr) MSG_ABORT("Trees must have same grid");
             node.getAbsCoefs(valA);
             mwNode->getAbsCoefs(valB);
-            for (int i = 0; i < ncoef; i++) result += valA[i] * valB[i];
+            for (int i = 0; i < ncoef; i++) result += std::abs(valA[i] * valB[i]);
         } else {
             // approximate by product of node norms
             int rIdx = ket.getRootBox().getBoxIndex(idx);
             assert(rIdx >= 0);
-            const MWNode<D> &root = ket.getRootBox().getNode(rIdx);
+            const MWNode<D, T> &root = ket.getRootBox().getNode(rIdx);
             result += std::sqrt(node.getSquareNorm()) * root.getNodeNorm(idx);
         }
     }
@@ -383,124 +384,249 @@ template <int D> double node_norm_dot(FunctionTree<D> &bra, FunctionTree<D> &ket
     return result;
 }
 
-template void multiply<1>(double prec,
-                          FunctionTree<1> &out,
+template void multiply<1, double>(double prec,
+                          FunctionTree<1, double> &out,
                           double c,
-                          FunctionTree<1> &tree_a,
-                          FunctionTree<1> &tree_b,
+                          FunctionTree<1, double> &tree_a,
+                          FunctionTree<1, double> &tree_b,
                           int maxIter,
                           bool absPrec,
                           bool useMaxNorms);
-template void multiply<2>(double prec,
-                          FunctionTree<2> &out,
+template void multiply<2, double>(double prec,
+                          FunctionTree<2, double> &out,
                           double c,
-                          FunctionTree<2> &tree_a,
-                          FunctionTree<2> &tree_b,
+                          FunctionTree<2, double> &tree_a,
+                          FunctionTree<2, double> &tree_b,
                           int maxIter,
                           bool absPrec,
                           bool useMaxNorms);
-template void multiply<3>(double prec,
-                          FunctionTree<3> &out,
+template void multiply<3, double>(double prec,
+                          FunctionTree<3, double> &out,
                           double c,
-                          FunctionTree<3> &tree_a,
-                          FunctionTree<3> &tree_b,
+                          FunctionTree<3, double> &tree_a,
+                          FunctionTree<3, double> &tree_b,
                           int maxIter,
                           bool absPrec,
                           bool useMaxNorms);
-template void multiply<1>(double prec,
-                          FunctionTree<1> &out,
-                          FunctionTreeVector<1> &inp,
+template void multiply<1, double>(double prec,
+                          FunctionTree<1, double> &out,
+                          FunctionTreeVector<1, double> &inp,
                           int maxIter,
                           bool absPrec,
                           bool useMaxNorms);
-template void multiply<2>(double prec,
-                          FunctionTree<2> &out,
-                          FunctionTreeVector<2> &inp,
+template void multiply<2, double>(double prec,
+                          FunctionTree<2, double> &out,
+                          FunctionTreeVector<2, double> &inp,
                           int maxIter,
                           bool absPrec,
                           bool useMaxNorms);
-template void multiply<3>(double prec,
-                          FunctionTree<3> &out,
-                          FunctionTreeVector<3> &inp,
+template void multiply<3, double>(double prec,
+                          FunctionTree<3, double> &out,
+                          FunctionTreeVector<3, double> &inp,
                           int maxIter,
                           bool absPrec,
                           bool useMaxNorms);
-template void multiply<1>(double prec,
-                          FunctionTree<1> &out,
-                          std::vector<FunctionTree<1> *> &inp,
+template void multiply<1, double>(double prec,
+                          FunctionTree<1, double> &out,
+                          std::vector<FunctionTree<1, double> *> &inp,
                           int maxIter,
                           bool absPrec,
                           bool useMaxNorms);
-template void multiply<2>(double prec,
-                          FunctionTree<2> &out,
-                          std::vector<FunctionTree<2> *> &inp,
+template void multiply<2, double>(double prec,
+                          FunctionTree<2, double> &out,
+                          std::vector<FunctionTree<2, double> *> &inp,
                           int maxIter,
                           bool absPrec,
                           bool useMaxNorms);
-template void multiply<3>(double prec,
-                          FunctionTree<3> &out,
-                          std::vector<FunctionTree<3> *> &inp,
+template void multiply<3, double>(double prec,
+                          FunctionTree<3, double> &out,
+                          std::vector<FunctionTree<3, double> *> &inp,
                           int maxIter,
                           bool absPrec,
                           bool useMaxNorms);
-template void power<1>(double prec,
-                       FunctionTree<1> &out,
-                       FunctionTree<1> &tree,
+template void power<1, double>(double prec,
+                       FunctionTree<1, double> &out,
+                       FunctionTree<1, double> &tree,
                        double pow,
                        int maxIter,
                        bool absPrec);
-template void power<2>(double prec,
-                       FunctionTree<2> &out,
-                       FunctionTree<2> &tree,
+template void power<2, double>(double prec,
+                       FunctionTree<2, double> &out,
+                       FunctionTree<2, double> &tree,
                        double pow,
                        int maxIter,
                        bool absPrec);
-template void power<3>(double prec,
-                       FunctionTree<3> &out,
-                       FunctionTree<3> &tree,
+template void power<3, double>(double prec,
+                       FunctionTree<3, double> &out,
+                       FunctionTree<3, double> &tree,
                        double pow,
                        int maxIter,
                        bool absPrec);
-template void square<1>(double prec,
-                        FunctionTree<1> &out,
-                        FunctionTree<1> &tree,
+template void square<1, double>(double prec,
+                        FunctionTree<1, double> &out,
+                        FunctionTree<1, double> &tree,
                         int maxIter,
                         bool absPrec);
-template void square<2>(double prec,
-                        FunctionTree<2> &out,
-                        FunctionTree<2> &tree,
+template void square<2, double>(double prec,
+                        FunctionTree<2, double> &out,
+                        FunctionTree<2, double> &tree,
                         int maxIter,
                         bool absPrec);
-template void square<3>(double prec,
-                        FunctionTree<3> &out,
-                        FunctionTree<3> &tree,
+template void square<3, double>(double prec,
+                        FunctionTree<3, double> &out,
+                        FunctionTree<3, double> &tree,
                         int maxIter,
                         bool absPrec);
-template void dot<1>(double prec,
-                     FunctionTree<1> &out,
-                     FunctionTreeVector<1> &inp_a,
-                     FunctionTreeVector<1> &inp_b,
+template void dot<1, double>(double prec,
+                     FunctionTree<1, double> &out,
+                     FunctionTreeVector<1, double> &inp_a,
+                     FunctionTreeVector<1, double> &inp_b,
                      int maxIter,
                      bool absPrec);
-template void dot<2>(double prec,
-                     FunctionTree<2> &out,
-                     FunctionTreeVector<2> &inp_a,
-                     FunctionTreeVector<2> &inp_b,
+template void dot<2, double>(double prec,
+                     FunctionTree<2, double> &out,
+                     FunctionTreeVector<2, double> &inp_a,
+                     FunctionTreeVector<2, double> &inp_b,
                      int maxIter,
                      bool absPrec);
-template void dot<3>(double prec,
-                     FunctionTree<3> &out,
-                     FunctionTreeVector<3> &inp_a,
-                     FunctionTreeVector<3> &inp_b,
+template void dot<3, double>(double prec,
+                     FunctionTree<3, double> &out,
+                     FunctionTreeVector<3, double> &inp_a,
+                     FunctionTreeVector<3, double> &inp_b,
                      int maxIter,
                      bool absPrec);
 
-template double dot<1>(FunctionTree<1> &bra, FunctionTree<1> &ket);
-template double dot<2>(FunctionTree<2> &bra, FunctionTree<2> &ket);
-template double dot<3>(FunctionTree<3> &bra, FunctionTree<3> &ket);
+template double dot<1, double>(FunctionTree<1, double> &bra, FunctionTree<1, double> &ket);
+template double dot<2, double>(FunctionTree<2, double> &bra, FunctionTree<2, double> &ket);
+template double dot<3, double>(FunctionTree<3, double> &bra, FunctionTree<3, double> &ket);
+
+template double node_norm_dot<1, double>(FunctionTree<1, double> &bra, FunctionTree<1, double> &ket, bool exact);
+template double node_norm_dot<2, double>(FunctionTree<2, double> &bra, FunctionTree<2, double> &ket, bool exact);
+template double node_norm_dot<3, double>(FunctionTree<3, double> &bra, FunctionTree<3, double> &ket, bool exact);
+
+
+
+
+
+template void multiply<1, ComplexDouble>(double prec,
+                          FunctionTree<1, ComplexDouble> &out,
+                          ComplexDouble c,
+                          FunctionTree<1, ComplexDouble> &tree_a,
+                          FunctionTree<1, ComplexDouble> &tree_b,
+                          int maxIter,
+                          bool absPrec,
+                          bool useMaxNorms);
+template void multiply<2, ComplexDouble>(double prec,
+                          FunctionTree<2, ComplexDouble> &out,
+                          ComplexDouble c,
+                          FunctionTree<2, ComplexDouble> &tree_a,
+                          FunctionTree<2, ComplexDouble> &tree_b,
+                          int maxIter,
+                          bool absPrec,
+                          bool useMaxNorms);
+template void multiply<3, ComplexDouble>(double prec,
+                          FunctionTree<3, ComplexDouble> &out,
+                          ComplexDouble c,
+                          FunctionTree<3, ComplexDouble> &tree_a,
+                          FunctionTree<3, ComplexDouble> &tree_b,
+                          int maxIter,
+                          bool absPrec,
+                          bool useMaxNorms);
+template void multiply<1, ComplexDouble>(double prec,
+                          FunctionTree<1, ComplexDouble> &out,
+                          FunctionTreeVector<1, ComplexDouble> &inp,
+                          int maxIter,
+                          bool absPrec,
+                          bool useMaxNorms);
+template void multiply<2, ComplexDouble>(double prec,
+                          FunctionTree<2, ComplexDouble> &out,
+                          FunctionTreeVector<2, ComplexDouble> &inp,
+                          int maxIter,
+                          bool absPrec,
+                          bool useMaxNorms);
+template void multiply<3, ComplexDouble>(double prec,
+                          FunctionTree<3, ComplexDouble> &out,
+                          FunctionTreeVector<3, ComplexDouble> &inp,
+                          int maxIter,
+                          bool absPrec,
+                          bool useMaxNorms);
+template void multiply<1, ComplexDouble>(double prec,
+                          FunctionTree<1, ComplexDouble> &out,
+                          std::vector<FunctionTree<1, ComplexDouble> *> &inp,
+                          int maxIter,
+                          bool absPrec,
+                          bool useMaxNorms);
+template void multiply<2, ComplexDouble>(double prec,
+                          FunctionTree<2, ComplexDouble> &out,
+                          std::vector<FunctionTree<2, ComplexDouble> *> &inp,
+                          int maxIter,
+                          bool absPrec,
+                          bool useMaxNorms);
+template void multiply<3, ComplexDouble>(double prec,
+                          FunctionTree<3, ComplexDouble> &out,
+                          std::vector<FunctionTree<3, ComplexDouble> *> &inp,
+                          int maxIter,
+                          bool absPrec,
+                          bool useMaxNorms);
+template void power<1, ComplexDouble>(double prec,
+                       FunctionTree<1, ComplexDouble> &out,
+                       FunctionTree<1, ComplexDouble> &tree,
+                       double pow,
+                       int maxIter,
+                       bool absPrec);
+template void power<2, ComplexDouble>(double prec,
+                       FunctionTree<2, ComplexDouble> &out,
+                       FunctionTree<2, ComplexDouble> &tree,
+                       double pow,
+                       int maxIter,
+                       bool absPrec);
+template void power<3, ComplexDouble>(double prec,
+                       FunctionTree<3, ComplexDouble> &out,
+                       FunctionTree<3, ComplexDouble> &tree,
+                       double pow,
+                       int maxIter,
+                       bool absPrec);
+template void square<1, ComplexDouble>(double prec,
+                        FunctionTree<1, ComplexDouble> &out,
+                        FunctionTree<1, ComplexDouble> &tree,
+                        int maxIter,
+                        bool absPrec);
+template void square<2, ComplexDouble>(double prec,
+                        FunctionTree<2, ComplexDouble> &out,
+                        FunctionTree<2, ComplexDouble> &tree,
+                        int maxIter,
+                        bool absPrec);
+template void square<3, ComplexDouble>(double prec,
+                        FunctionTree<3, ComplexDouble> &out,
+                        FunctionTree<3, ComplexDouble> &tree,
+                        int maxIter,
+                        bool absPrec);
+template void dot<1, ComplexDouble>(double prec,
+                     FunctionTree<1, ComplexDouble> &out,
+                     FunctionTreeVector<1, ComplexDouble> &inp_a,
+                     FunctionTreeVector<1, ComplexDouble> &inp_b,
+                     int maxIter,
+                     bool absPrec);
+template void dot<2, ComplexDouble>(double prec,
+                     FunctionTree<2, ComplexDouble> &out,
+                     FunctionTreeVector<2, ComplexDouble> &inp_a,
+                     FunctionTreeVector<2, ComplexDouble> &inp_b,
+                     int maxIter,
+                     bool absPrec);
+template void dot<3, ComplexDouble>(double prec,
+                     FunctionTree<3, ComplexDouble> &out,
+                     FunctionTreeVector<3, ComplexDouble> &inp_a,
+                     FunctionTreeVector<3, ComplexDouble> &inp_b,
+                     int maxIter,
+                     bool absPrec);
+
+template ComplexDouble dot<1, ComplexDouble>(FunctionTree<1, ComplexDouble> &bra, FunctionTree<1, ComplexDouble> &ket);
+template ComplexDouble dot<2, ComplexDouble>(FunctionTree<2, ComplexDouble> &bra, FunctionTree<2, ComplexDouble> &ket);
+template ComplexDouble dot<3, ComplexDouble>(FunctionTree<3, ComplexDouble> &bra, FunctionTree<3, ComplexDouble> &ket);
+
+template double node_norm_dot<1, ComplexDouble>(FunctionTree<1, ComplexDouble> &bra, FunctionTree<1, ComplexDouble> &ket, bool exact);
+template double node_norm_dot<2, ComplexDouble>(FunctionTree<2, ComplexDouble> &bra, FunctionTree<2, ComplexDouble> &ket, bool exact);
+template double node_norm_dot<3, ComplexDouble>(FunctionTree<3, ComplexDouble> &bra, FunctionTree<3, ComplexDouble> &ket, bool exact);
 
-template double node_norm_dot<1>(FunctionTree<1> &bra, FunctionTree<1> &ket, bool exact);
-template double node_norm_dot<2>(FunctionTree<2> &bra, FunctionTree<2> &ket, bool exact);
-template double node_norm_dot<3>(FunctionTree<3> &bra, FunctionTree<3> &ket, bool exact);
 
 } // namespace mrcpp
diff --git a/src/treebuilders/multiply.h b/src/treebuilders/multiply.h
index 54947bf78..96a956f3b 100644
--- a/src/treebuilders/multiply.h
+++ b/src/treebuilders/multiply.h
@@ -28,56 +28,56 @@
 #include "trees/FunctionTreeVector.h"
 
 namespace mrcpp {
-template <int D> class RepresentableFunction;
-template <int D> class FunctionTree;
+template <int D, typename T> class RepresentableFunction;
+template <int D, typename T> class FunctionTree;
 
-template <int D> void dot(double prec,
-                          FunctionTree<D> &out,
-                          FunctionTreeVector<D> &inp_a,
-                          FunctionTreeVector<D> &inp_b,
+template <int D, typename T> void dot(double prec,
+                          FunctionTree<D, T> &out,
+                          FunctionTreeVector<D, T> &inp_a,
+                          FunctionTreeVector<D, T> &inp_b,
                           int maxIter = -1,
                           bool absPrec = false);
 
-template <int D> double dot(FunctionTree<D> &bra,
-                            FunctionTree<D> &ket);
+template <int D, typename T> T dot(FunctionTree<D, T> &bra,
+                            FunctionTree<D, T> &ket);
 
-template <int D> double node_norm_dot(FunctionTree<D> &bra,
-                                      FunctionTree<D> &ket,
+template <int D, typename T> double node_norm_dot(FunctionTree<D, T> &bra,
+                                      FunctionTree<D, T> &ket,
                                       bool exact = false);
 
-template <int D> void multiply(double prec,
-                               FunctionTree<D> &out,
-                               double c,
-                               FunctionTree<D> &inp_a,
-                               FunctionTree<D> &inp_b,
+template <int D, typename T> void multiply(double prec,
+                               FunctionTree<D, T> &out,
+                               T c,
+                               FunctionTree<D, T> &inp_a,
+                               FunctionTree<D, T> &inp_b,
                                int maxIter = -1,
                                bool absPrec = false,
                                bool useMaxNorms = false);
 
-template <int D> void multiply(double prec,
-                               FunctionTree<D> &out,
-                               std::vector<FunctionTree<D> *> &inp,
+template <int D, typename T> void multiply(double prec,
+                               FunctionTree<D, T> &out,
+                               std::vector<FunctionTree<D, T> *> &inp,
                                int maxIter = -1,
                                bool absPrec = false,
                                bool useMaxNorms = false);
 
-template <int D> void multiply(double prec,
-                               FunctionTree<D> &out,
-                               FunctionTreeVector<D> &inp,
+template <int D, typename T> void multiply(double prec,
+                               FunctionTree<D, T> &out,
+                               FunctionTreeVector<D, T> &inp,
                                int maxIter = -1,
                                bool absPrec = false,
                                bool useMaxNorms = false);
 
-template <int D> void power(double prec,
-                            FunctionTree<D> &out,
-                            FunctionTree<D> &inp,
+template <int D, typename T> void power(double prec,
+                            FunctionTree<D, T> &out,
+                            FunctionTree<D, T> &inp,
                             double p,
                             int maxIter = -1,
                             bool absPrec = false);
 
-template <int D> void square(double prec,
-                             FunctionTree<D> &out,
-                             FunctionTree<D> &inp,
+template <int D, typename T> void square(double prec,
+                             FunctionTree<D, T> &out,
+                             FunctionTree<D, T> &inp,
                              int maxIter = -1,
                              bool absPrec = false);
 
diff --git a/src/treebuilders/project.cpp b/src/treebuilders/project.cpp
index c22f22ec8..65d17fd16 100644
--- a/src/treebuilders/project.cpp
+++ b/src/treebuilders/project.cpp
@@ -56,8 +56,8 @@ namespace mrcpp {
  * no coefs).
  *
  */
-template <int D> void project(double prec, FunctionTree<D> &out, std::function<double(const Coord<D> &r)> func, int maxIter, bool absPrec) {
-    AnalyticFunction<D> inp(func);
+template <int D, typename T> void project(double prec, FunctionTree<D, T> &out, std::function<T(const Coord<D> &r)> func, int maxIter, bool absPrec) {
+    AnalyticFunction<D, T> inp(func);
     mrcpp::project(prec, out, inp, maxIter, absPrec);
 }
 
@@ -81,14 +81,14 @@ template <int D> void project(double prec, FunctionTree<D> &out, std::function<d
  * no coefs).
  *
  */
-template <int D> void project(double prec, FunctionTree<D> &out, RepresentableFunction<D> &inp, int maxIter, bool absPrec) {
+template <int D, typename T> void project(double prec, FunctionTree<D, T> &out, RepresentableFunction<D, T> &inp, int maxIter, bool absPrec) {
 
     int maxScale = out.getMRA().getMaxScale();
     const auto scaling_factor = out.getMRA().getWorldBox().getScalingFactors();
-    TreeBuilder<D> builder;
-    WaveletAdaptor<D> adaptor(prec, maxScale, absPrec);
+    TreeBuilder<D, T> builder;
+    WaveletAdaptor<D, T> adaptor(prec, maxScale, absPrec);
 
-    ProjectionCalculator<D> calculator(inp, scaling_factor);
+    ProjectionCalculator<D, T> calculator(inp, scaling_factor);
 
     builder.build(out, calculator, adaptor, maxIter);
 
@@ -121,19 +121,33 @@ template <int D> void project(double prec, FunctionTree<D> &out, RepresentableFu
  * no coefs).
  *
  */
-template <int D> void project(double prec, FunctionTreeVector<D> &out, std::vector<std::function<double(const Coord<D> &r)>> func, int maxIter, bool absPrec) {
+template <int D, typename T> void project(double prec, FunctionTreeVector<D, T> &out, std::vector<std::function<T(const Coord<D> &r)>> func, int maxIter, bool absPrec) {
     if (out.size() != func.size()) MSG_ABORT("Size mismatch");
     for (auto j = 0; j < D; j++) mrcpp::project<D>(prec, get_func(out, j), func[j], maxIter, absPrec);
 }
 
-template void project<1>(double prec, FunctionTree<1> &out, RepresentableFunction<1> &inp, int maxIter, bool absPrec);
-template void project<2>(double prec, FunctionTree<2> &out, RepresentableFunction<2> &inp, int maxIter, bool absPrec);
-template void project<3>(double prec, FunctionTree<3> &out, RepresentableFunction<3> &inp, int maxIter, bool absPrec);
+template void project<1, double>(double prec, FunctionTree<1, double> &out, RepresentableFunction<1, double> &inp, int maxIter, bool absPrec);
+template void project<2, double>(double prec, FunctionTree<2, double> &out, RepresentableFunction<2, double> &inp, int maxIter, bool absPrec);
+template void project<3, double>(double prec, FunctionTree<3, double> &out, RepresentableFunction<3, double> &inp, int maxIter, bool absPrec);
+
+template void project<1, double>(double prec, FunctionTree<1, double> &out, std::function<double(const Coord<1> &r)> func, int maxIter, bool absPrec);
+template void project<2, double>(double prec, FunctionTree<2, double> &out, std::function<double(const Coord<2> &r)> func, int maxIter, bool absPrec);
+template void project<3, double>(double prec, FunctionTree<3, double> &out, std::function<double(const Coord<3> &r)> func, int maxIter, bool absPrec);
+template void project<1, double>(double prec, FunctionTreeVector<1, double> &out, std::vector<std::function<double(const Coord<1> &r)>> inp, int maxIter, bool absPrec);
+template void project<2, double>(double prec, FunctionTreeVector<2, double> &out, std::vector<std::function<double(const Coord<2> &r)>> inp, int maxIter, bool absPrec);
+template void project<3, double>(double prec, FunctionTreeVector<3, double> &out, std::vector<std::function<double(const Coord<3> &r)>> inp, int maxIter, bool absPrec);
+
+
+template void project<1, ComplexDouble>(double prec, FunctionTree<1, ComplexDouble> &out, RepresentableFunction<1, ComplexDouble> &inp, int maxIter, bool absPrec);
+template void project<2, ComplexDouble>(double prec, FunctionTree<2, ComplexDouble> &out, RepresentableFunction<2, ComplexDouble> &inp, int maxIter, bool absPrec);
+template void project<3, ComplexDouble>(double prec, FunctionTree<3, ComplexDouble> &out, RepresentableFunction<3, ComplexDouble> &inp, int maxIter, bool absPrec);
+
+template void project<1, ComplexDouble>(double prec, FunctionTree<1, ComplexDouble> &out, std::function<ComplexDouble(const Coord<1> &r)> func, int maxIter, bool absPrec);
+template void project<2, ComplexDouble>(double prec, FunctionTree<2, ComplexDouble> &out, std::function<ComplexDouble(const Coord<2> &r)> func, int maxIter, bool absPrec);
+template void project<3, ComplexDouble>(double prec, FunctionTree<3, ComplexDouble> &out, std::function<ComplexDouble(const Coord<3> &r)> func, int maxIter, bool absPrec);
+template void project<1, ComplexDouble>(double prec, FunctionTreeVector<1, ComplexDouble> &out, std::vector<std::function<ComplexDouble(const Coord<1> &r)>> inp, int maxIter, bool absPrec);
+template void project<2, ComplexDouble>(double prec, FunctionTreeVector<2, ComplexDouble> &out, std::vector<std::function<ComplexDouble(const Coord<2> &r)>> inp, int maxIter, bool absPrec);
+template void project<3, ComplexDouble>(double prec, FunctionTreeVector<3, ComplexDouble> &out, std::vector<std::function<ComplexDouble(const Coord<3> &r)>> inp, int maxIter, bool absPrec);
+
 
-template void project<1>(double prec, FunctionTree<1> &out, std::function<double(const Coord<1> &r)> func, int maxIter, bool absPrec);
-template void project<2>(double prec, FunctionTree<2> &out, std::function<double(const Coord<2> &r)> func, int maxIter, bool absPrec);
-template void project<3>(double prec, FunctionTree<3> &out, std::function<double(const Coord<3> &r)> func, int maxIter, bool absPrec);
-template void project<1>(double prec, FunctionTreeVector<1> &out, std::vector<std::function<double(const Coord<1> &r)>> inp, int maxIter, bool absPrec);
-template void project<2>(double prec, FunctionTreeVector<2> &out, std::vector<std::function<double(const Coord<2> &r)>> inp, int maxIter, bool absPrec);
-template void project<3>(double prec, FunctionTreeVector<3> &out, std::vector<std::function<double(const Coord<3> &r)>> inp, int maxIter, bool absPrec);
 } // namespace mrcpp
diff --git a/src/treebuilders/project.h b/src/treebuilders/project.h
index 790914a4b..f9e070ef2 100644
--- a/src/treebuilders/project.h
+++ b/src/treebuilders/project.h
@@ -30,7 +30,7 @@
 #include <functional>
 
 namespace mrcpp {
-template <int D> void project(double prec, FunctionTree<D> &out, RepresentableFunction<D> &inp, int maxIter = -1, bool absPrec = false);
-template <int D> void project(double prec, FunctionTree<D> &out, std::function<double(const Coord<D> &r)> func, int maxIter = -1, bool absPrec = false);
-template <int D> void project(double prec, FunctionTreeVector<D> &out, std::vector<std::function<double(const Coord<D> &r)>> func, int maxIter = -1, bool absPrec = false);
+template <int D, typename T = double> void project(double prec, FunctionTree<D, T> &out, RepresentableFunction<D, T> &inp, int maxIter = -1, bool absPrec = false);
+template <int D, typename T = double> void project(double prec, FunctionTree<D, T> &out, std::function<T(const Coord<D> &r)> func, int maxIter = -1, bool absPrec = false);
+template <int D, typename T = double> void project(double prec, FunctionTreeVector<D, T> &out, std::vector<std::function<T(const Coord<D> &r)>> func, int maxIter = -1, bool absPrec = false);
 } // namespace mrcpp
diff --git a/src/trees/FunctionNode.cpp b/src/trees/FunctionNode.cpp
index c839e2b57..98858e503 100644
--- a/src/trees/FunctionNode.cpp
+++ b/src/trees/FunctionNode.cpp
@@ -44,7 +44,7 @@ namespace mrcpp {
 
 /** Function evaluation.
  * Evaluate all polynomials defined on the node. */
-template <int D> double FunctionNode<D>::evalf(Coord<D> r) {
+template <int D, typename T> T FunctionNode<D, T>::evalf(Coord<D> r) {
     if (not this->hasCoefs()) MSG_ERROR("Evaluating node without coefs");
 
     // The 1.0 appearing in the if tests comes from the period is always 1.0
@@ -57,7 +57,7 @@ template <int D> double FunctionNode<D>::evalf(Coord<D> r) {
     return getFuncChild(cIdx).evalScaling(r);
 }
 
-template <int D> double FunctionNode<D>::evalScaling(const Coord<D> &r) const {
+template <int D, typename T> T FunctionNode<D, T>::evalScaling(const Coord<D> &r) const {
     if (not this->hasCoefs()) MSG_ERROR("Evaluating node without coefs");
 
     double arg[D];
@@ -72,10 +72,10 @@ template <int D> double FunctionNode<D>::evalScaling(const Coord<D> &r) const {
     const ScalingBasis &basis = this->getMWTree().getMRA().getScalingBasis();
     basis.evalf(arg, val);
 
-    double result = 0.0;
+    T result = 0.0;
     //#pragma omp parallel for shared(fact) reduction(+:result) num_threads(mrcpp_get_num_threads())
     for (int i = 0; i < this->getKp1_d(); i++) {
-        double temp = this->coefs[i];
+        T temp = this->coefs[i];
         for (int j = 0; j < D; j++) {
             int k = (i % fact[j + 1]) / fact[j];
             temp *= val(k, j);
@@ -92,7 +92,7 @@ template <int D> double FunctionNode<D>::evalScaling(const Coord<D> &r) const {
  * Wrapper for function integration, that requires different methods depending
  * on scaling type. Integrates the function represented on the node on the
  * full support of the node. */
-template <int D> double FunctionNode<D>::integrate() const {
+template <int D, typename T> T FunctionNode<D, T>::integrate() const {
     if (not this->hasCoefs()) { return 0.0; }
     switch (this->getScalingType()) {
         case Legendre:
@@ -115,7 +115,7 @@ template <int D> double FunctionNode<D>::integrate() const {
  *          s_i = int f(x)phi_i(x)dx
  * and since the first Legendre function is the constant 1, the first
  * coefficient is simply the integral of f(x). */
-template <int D> double FunctionNode<D>::integrateLegendre() const {
+template <int D, typename T> T FunctionNode<D, T>::integrateLegendre() const {
     double n = (D * this->getScale()) / 2.0;
     double two_n = std::pow(2.0, -n);
     return two_n * this->getCoefs()[0];
@@ -126,7 +126,7 @@ template <int D> double FunctionNode<D>::integrateLegendre() const {
  * Integrates the function represented on the node on the full support of the
  * node. A bit more involved than in the Legendre basis, as is requires some
  * coupling of quadrature weights. */
-template <int D> double FunctionNode<D>::integrateInterpolating() const {
+template <int D, typename T> T FunctionNode<D, T>::integrateInterpolating() const {
     int qOrder = this->getKp1();
     getQuadratureCache(qc);
     const VectorXd &weights = qc.getWeights(qOrder);
@@ -136,7 +136,7 @@ template <int D> double FunctionNode<D>::integrateInterpolating() const {
     int kp1_p[D];
     for (int i = 0; i < D; i++) kp1_p[i] = math_utils::ipow(qOrder, i);
 
-    VectorXd coefs;
+    Eigen::Matrix<T, Eigen::Dynamic, 1> coefs;
     this->getCoefs(coefs);
     for (int p = 0; p < D; p++) {
 
@@ -152,7 +152,7 @@ template <int D> double FunctionNode<D>::integrateInterpolating() const {
     }
     double n = (D * this->getScale()) / 2.0;
     double two_n = std::pow(2.0, -n);
-    double sum = coefs.segment(0, this->getKp1_d()).sum();
+    T sum = coefs.segment(0, this->getKp1_d()).sum();
 
     return two_n * sum;
 }
@@ -162,27 +162,27 @@ template <int D> double FunctionNode<D>::integrateInterpolating() const {
  * Integrates the function represented on the node on the full support of the
  * node. A bit more involved than in the Legendre basis, as is requires some
  * coupling of quadrature weights. */
-template <int D> double FunctionNode<D>::integrateValues() const {
+template <int D, typename T> T FunctionNode<D, T>::integrateValues() const {
     int qOrder = this->getKp1();
     getQuadratureCache(qc);
     const VectorXd &weights = qc.getWeights(qOrder);
-    VectorXd coefs;
+    Eigen::Matrix<T, Eigen::Dynamic, 1> coefs;
     this->getCoefs(coefs);
     int ncoefs = coefs.size();
     int ncoefChild = ncoefs/(1<<D);
-    double cc[ncoefChild];
+    T cc[ncoefChild];
     // factorize out the children
     for (int i = 0; i < ncoefChild; i++)cc[i]=coefs[i];
     for (int j = 1; j < (1<<D); j++) for (int i = 0; i < ncoefChild; i++)cc[i]+=coefs[j*ncoefChild+i];
 
     int nc = 0;
-    double sum = 0.0;
+    T sum = 0.0;
     if (D > 3) MSG_ABORT("Not Implemented")
     else if (D == 3) {
         for (int i = 0; i < qOrder; i++) {
-            double sumj = 0.0;
+            T sumj = 0.0;
             for (int j = 0; j < qOrder; j++) {
-                double sumk = 0.0;
+                T sumk = 0.0;
                 for (int k = 0; k < qOrder; k++) sumk += cc[nc++] * weights[k];
                 sumj += sumk * weights[j];
             }
@@ -190,7 +190,7 @@ template <int D> double FunctionNode<D>::integrateValues() const {
         }
     } else if (D==2) {
         for (int j = 0; j < qOrder; j++) {
-                double sumk = 0.0;
+                T sumk = 0.0;
                 for (int k = 0; k < qOrder; k++) sumk += cc[nc++] * weights[k];
                 sum += sumk * weights[j];
         }
@@ -203,7 +203,7 @@ template <int D> double FunctionNode<D>::integrateValues() const {
     return sum;
 }
 
-template <int D> void FunctionNode<D>::setValues(const VectorXd &vec) {
+template <int D, typename T> void FunctionNode<D, T>::setValues(const Matrix<T, Eigen::Dynamic, 1> &vec) {
     this->zeroCoefs();
     this->setCoefBlock(0, vec.size(), vec.data());
     this->cvTransform(Backward);
@@ -212,15 +212,15 @@ template <int D> void FunctionNode<D>::setValues(const VectorXd &vec) {
     this->calcNorms();
 }
 
-template <int D> void FunctionNode<D>::getValues(VectorXd &vec) {
+  template <int D, typename T> void FunctionNode<D, T>::getValues(Matrix<T , Eigen::Dynamic, 1 > &vec) {
     if (this->isGenNode()) {
-        MWNode<D> copy(*this);
-        vec = Eigen::VectorXd::Zero(copy.getNCoefs());
+        MWNode<D, T> copy(*this);
+        vec = Eigen::Matrix<T, Eigen::Dynamic, 1>::Zero(copy.getNCoefs());
         copy.mwTransform(Reconstruction);
         copy.cvTransform(Forward);
         for (int i = 0; i < this->n_coefs; i++) vec(i) = copy.getCoefs()[i];
     } else {
-        vec = VectorXd::Zero(this->n_coefs);
+        vec = Eigen::Matrix<T, Eigen::Dynamic, 1>::Zero(this->n_coefs);
         this->mwTransform(Reconstruction);
         this->cvTransform(Forward);
         for (int i = 0; i < this->n_coefs; i++) vec(i) = this->coefs[i];
@@ -232,8 +232,8 @@ template <int D> void FunctionNode<D>::getValues(VectorXd &vec) {
 /** get coefficients corresponding to absolute value of function
  *
  * Leaves the original coefficients unchanged. */
-template <int D> void FunctionNode<D>::getAbsCoefs(double *absCoefs) {
-    double *coefsTmp = this->coefs;
+template <int D, typename T> void FunctionNode<D, T>::getAbsCoefs(T *absCoefs) {
+    T *coefsTmp = this->coefs;
     for (int i = 0; i < this->n_coefs; i++) absCoefs[i] = coefsTmp[i]; // copy
     this->coefs = absCoefs;                                            // swap coefs
     this->mwTransform(Reconstruction);
@@ -244,7 +244,7 @@ template <int D> void FunctionNode<D>::getAbsCoefs(double *absCoefs) {
     this->coefs = coefsTmp; // restore original array (same address)
 }
 
-template <int D> void FunctionNode<D>::createChildren(bool coefs) {
+template <int D, typename T> void FunctionNode<D, T>::createChildren(bool coefs) {
     if (this->isBranchNode()) MSG_ABORT("Node already has children");
     auto &allocator = this->getFuncTree().getNodeAllocator();
 
@@ -258,7 +258,7 @@ template <int D> void FunctionNode<D>::createChildren(bool coefs) {
     this->childSerialIx = sIdx;
     for (int cIdx = 0; cIdx < nChildren; cIdx++) {
         // construct into allocator memory
-        new (child_p) FunctionNode<D>(this, cIdx);
+        new (child_p) FunctionNode<D, T>(this, cIdx);
         this->children[cIdx] = child_p;
 
         child_p->serialIx = sIdx;
@@ -282,7 +282,7 @@ template <int D> void FunctionNode<D>::createChildren(bool coefs) {
     this->clearIsEndNode();
 }
 
-template <int D> void FunctionNode<D>::genChildren() {
+template <int D, typename T> void FunctionNode<D, T>::genChildren() {
     if (this->isBranchNode()) MSG_ABORT("Node already has children");
     auto &allocator = this->getFuncTree().getGenNodeAllocator();
 
@@ -296,7 +296,7 @@ template <int D> void FunctionNode<D>::genChildren() {
     this->childSerialIx = sIdx;
     for (int cIdx = 0; cIdx < nChildren; cIdx++) {
         // construct into allocator memory
-        new (child_p) FunctionNode<D>(this, cIdx);
+        new (child_p) FunctionNode<D, T>(this, cIdx);
         this->children[cIdx] = child_p;
 
         child_p->serialIx = sIdx;
@@ -319,7 +319,7 @@ template <int D> void FunctionNode<D>::genChildren() {
     this->setIsBranchNode();
 }
 
-template <int D> void FunctionNode<D>::genParent() {
+template <int D, typename T> void FunctionNode<D, T>::genParent() {
     if (this->parent != nullptr) MSG_ABORT("Node is not an orphan");
 
     auto &allocator = this->getFuncTree().getNodeAllocator();
@@ -332,7 +332,7 @@ template <int D> void FunctionNode<D>::genParent() {
     this->parentSerialIx = sIdx;
 
     // construct into allocator memory
-    new (parent_p) FunctionNode<D>(this->tree, this->getNodeIndex().parent());
+    new (parent_p) FunctionNode<D, T>(this->tree, this->getNodeIndex().parent());
 
     this->parent = parent_p;
 
@@ -351,12 +351,12 @@ template <int D> void FunctionNode<D>::genParent() {
     this->getMWTree().incrementNodeCount(parent_p->getScale());
 }
 
-template <int D> void FunctionNode<D>::deleteChildren() {
-    MWNode<D>::deleteChildren();
+template <int D, typename T> void FunctionNode<D, T>::deleteChildren() {
+    MWNode<D, T>::deleteChildren();
     this->setIsEndNode();
 }
 
-template <int D> void FunctionNode<D>::dealloc() {
+template <int D, typename T> void FunctionNode<D, T>::dealloc() {
     int sIdx = this->serialIx;
     this->serialIx = -1;
     this->parentSerialIx = -1;
@@ -376,8 +376,8 @@ template <int D> void FunctionNode<D>::dealloc() {
 /** Update the coefficients of the node by a mw transform of the scaling
  * coefficients of the children. Option to overwrite or add up existing
  * coefficients. Specialized for D=3 below. */
-template <int D> void FunctionNode<D>::reCompress() {
-    MWNode<D>::reCompress();
+template <int D, typename T> void FunctionNode<D, T>::reCompress() {
+    MWNode<D, T>::reCompress();
 }
 
 template <> void FunctionNode<3>::reCompress() {
@@ -406,18 +406,18 @@ template <> void FunctionNode<3>::reCompress() {
  * the node on the full support of the nodes. The scaling basis is fully
  * orthonormal, and the inner product is simply the dot product of the
  * coefficient vectors. Assumes the nodes have identical support. */
-template <int D> double dot_scaling(const FunctionNode<D> &bra, const FunctionNode<D> &ket) {
+template <int D, typename T> T dot_scaling(const FunctionNode<D, T> &bra, const FunctionNode<D, T> &ket) {
     assert(bra.hasCoefs());
     assert(ket.hasCoefs());
 
-    const double *a = bra.getCoefs();
-    const double *b = ket.getCoefs();
+    const T *a = bra.getCoefs();
+    const T *b = ket.getCoefs();
 
     int size = bra.getKp1_d();
 #ifdef HAVE_BLAS
     return cblas_ddot(size, a, 1, b, 1);
 #else
-    double result = 0.0;
+    T result = 0.0;
     for (int i = 0; i < size; i++) result += a[i] * b[i];
     return result;
 #endif
@@ -429,35 +429,46 @@ template <int D> double dot_scaling(const FunctionNode<D> &bra, const FunctionNo
  * the node on the full support of the nodes. The wavelet basis is fully
  * orthonormal, and the inner product is simply the dot product of the
  * coefficient vectors. Assumes the nodes have identical support. */
-template <int D> double dot_wavelet(const FunctionNode<D> &bra, const FunctionNode<D> &ket) {
+template <int D, typename T> T dot_wavelet(const FunctionNode<D, T> &bra, const FunctionNode<D, T> &ket) {
     if (bra.isGenNode() or ket.isGenNode()) return 0.0;
 
     assert(bra.hasCoefs());
     assert(ket.hasCoefs());
 
-    const double *a = bra.getCoefs();
-    const double *b = ket.getCoefs();
+    const T *a = bra.getCoefs();
+    const T *b = ket.getCoefs();
 
     int start = bra.getKp1_d();
     int size = (bra.getTDim() - 1) * start;
 #ifdef HAVE_BLAS
     return cblas_ddot(size, &a[start], 1, &b[start], 1);
 #else
-    double result = 0.0;
+    T result = 0.0;
     for (int i = 0; i < size; i++) result += a[start + i] * b[start + i];
     return result;
 #endif
 }
 
-template double dot_scaling(const FunctionNode<1> &bra, const FunctionNode<1> &ket);
-template double dot_scaling(const FunctionNode<2> &bra, const FunctionNode<2> &ket);
-template double dot_scaling(const FunctionNode<3> &bra, const FunctionNode<3> &ket);
-template double dot_wavelet(const FunctionNode<1> &bra, const FunctionNode<1> &ket);
-template double dot_wavelet(const FunctionNode<2> &bra, const FunctionNode<2> &ket);
-template double dot_wavelet(const FunctionNode<3> &bra, const FunctionNode<3> &ket);
-
-template class FunctionNode<1>;
-template class FunctionNode<2>;
-template class FunctionNode<3>;
+template double dot_scaling(const FunctionNode<1, double> &bra, const FunctionNode<1, double> &ket);
+template double dot_scaling(const FunctionNode<2, double> &bra, const FunctionNode<2, double> &ket);
+template double dot_scaling(const FunctionNode<3, double> &bra, const FunctionNode<3, double> &ket);
+template double dot_wavelet(const FunctionNode<1, double> &bra, const FunctionNode<1, double> &ket);
+template double dot_wavelet(const FunctionNode<2, double> &bra, const FunctionNode<2, double> &ket);
+template double dot_wavelet(const FunctionNode<3, double> &bra, const FunctionNode<3, double> &ket);
+
+template class FunctionNode<1, double>;
+template class FunctionNode<2, double>;
+template class FunctionNode<3, double>;
+
+template class FunctionNode<1, ComplexDouble>;
+template class FunctionNode<2, ComplexDouble>;
+template class FunctionNode<3, ComplexDouble>;
+
+template ComplexDouble dot_scaling(const FunctionNode<1, ComplexDouble> &bra, const FunctionNode<1, ComplexDouble> &ket);
+template ComplexDouble dot_scaling(const FunctionNode<2, ComplexDouble> &bra, const FunctionNode<2, ComplexDouble> &ket);
+template ComplexDouble dot_scaling(const FunctionNode<3, ComplexDouble> &bra, const FunctionNode<3, ComplexDouble> &ket);
+template ComplexDouble dot_wavelet(const FunctionNode<1, ComplexDouble> &bra, const FunctionNode<1, ComplexDouble> &ket);
+template ComplexDouble dot_wavelet(const FunctionNode<2, ComplexDouble> &bra, const FunctionNode<2, ComplexDouble> &ket);
+template ComplexDouble dot_wavelet(const FunctionNode<3, ComplexDouble> &bra, const FunctionNode<3, ComplexDouble> &ket);
 
 } // namespace mrcpp
diff --git a/src/trees/FunctionNode.h b/src/trees/FunctionNode.h
index 97a3d74d3..14c44fb7e 100644
--- a/src/trees/FunctionNode.h
+++ b/src/trees/FunctionNode.h
@@ -32,55 +32,55 @@
 
 namespace mrcpp {
 
-template <int D> class FunctionNode final : public MWNode<D> {
+template <int D, typename T> class FunctionNode final : public MWNode<D, T> {
 public:
-    FunctionTree<D> &getFuncTree() { return static_cast<FunctionTree<D> &>(*this->tree); }
-    FunctionNode<D> &getFuncParent() { return static_cast<FunctionNode<D> &>(*this->parent); }
-    FunctionNode<D> &getFuncChild(int i) { return static_cast<FunctionNode<D> &>(*this->children[i]); }
+    FunctionTree<D, T> &getFuncTree() { return static_cast<FunctionTree<D, T> &>(*this->tree); }
+    FunctionNode<D, T> &getFuncParent() { return static_cast<FunctionNode<D, T> &>(*this->parent); }
+    FunctionNode<D, T> &getFuncChild(int i) { return static_cast<FunctionNode<D, T> &>(*this->children[i]); }
 
-    const FunctionTree<D> &getFuncTree() const { return static_cast<const FunctionTree<D> &>(*this->tree); }
-    const FunctionNode<D> &getFuncParent() const { return static_cast<const FunctionNode<D> &>(*this->parent); }
-    const FunctionNode<D> &getFuncChild(int i) const { return static_cast<const FunctionNode<D> &>(*this->children[i]); }
+    const FunctionTree<D, T> &getFuncTree() const { return static_cast<const FunctionTree<D, T> &>(*this->tree); }
+    const FunctionNode<D, T> &getFuncParent() const { return static_cast<const FunctionNode<D, T> &>(*this->parent); }
+    const FunctionNode<D, T> &getFuncChild(int i) const { return static_cast<const FunctionNode<D, T> &>(*this->children[i]); }
 
     void createChildren(bool coefs) override;
     void genChildren() override;
     void genParent() override;
     void deleteChildren() override;
 
-    double integrate() const;
+    T integrate() const;
 
-    void setValues(const Eigen::VectorXd &vec);
-    void getValues(Eigen::VectorXd &vec);
-    void getAbsCoefs(double *absCoefs);
+    void setValues(const Eigen::Matrix<T , Eigen::Dynamic, 1> &vec);
+    void getValues(Eigen::Matrix<T, Eigen::Dynamic, 1> &vec);
+    void getAbsCoefs(T *absCoefs);
 
-    friend class FunctionTree<D>;
-    friend class NodeAllocator<D>;
+    friend class FunctionTree<D, T>;
+    friend class NodeAllocator<D, T>;
 
 protected:
     FunctionNode()
-            : MWNode<D>() {}
-    FunctionNode(MWTree<D> *tree, int rIdx)
-            : MWNode<D>(tree, rIdx) {}
-    FunctionNode(MWNode<D> *parent, int cIdx)
-            : MWNode<D>(parent, cIdx) {}
-    FunctionNode(MWTree<D> *tree, const NodeIndex<D> &idx)
-            : MWNode<D>(tree, idx) {}
-    FunctionNode(const FunctionNode<D> &node) = delete;
-    FunctionNode<D> &operator=(const FunctionNode<D> &node) = delete;
+            : MWNode<D, T>() {}
+    FunctionNode(MWTree<D, T> *tree, int rIdx)
+            : MWNode<D, T>(tree, rIdx) {}
+    FunctionNode(MWNode<D, T> *parent, int cIdx)
+            : MWNode<D, T>(parent, cIdx) {}
+    FunctionNode(MWTree<D, T> *tree, const NodeIndex<D> &idx)
+            : MWNode<D, T>(tree, idx) {}
+    FunctionNode(const FunctionNode<D, T> &node) = delete;
+    FunctionNode<D, T> &operator=(const FunctionNode<D, T> &node) = delete;
     ~FunctionNode() = default;
 
-    double evalf(Coord<D> r);
-    double evalScaling(const Coord<D> &r) const;
+    T evalf(Coord<D> r);
+    T evalScaling(const Coord<D> &r) const;
 
     void dealloc() override;
     void reCompress() override;
 
-    double integrateLegendre() const;
-    double integrateInterpolating() const;
-    double integrateValues() const;
+    T integrateLegendre() const;
+    T integrateInterpolating() const;
+    T integrateValues() const;
 };
 
-template <int D> double dot_scaling(const FunctionNode<D> &bra, const FunctionNode<D> &ket);
-template <int D> double dot_wavelet(const FunctionNode<D> &bra, const FunctionNode<D> &ket);
+template <int D, typename T> T dot_scaling(const FunctionNode<D, T> &bra, const FunctionNode<D, T> &ket);
+template <int D, typename T> T dot_wavelet(const FunctionNode<D, T> &bra, const FunctionNode<D, T> &ket);
 
 } // namespace mrcpp
diff --git a/src/trees/FunctionTree.cpp b/src/trees/FunctionTree.cpp
index 47614a933..1c91cf2cd 100644
--- a/src/trees/FunctionTree.cpp
+++ b/src/trees/FunctionTree.cpp
@@ -50,20 +50,20 @@ namespace mrcpp {
  *  If a shared memory pointer is provided the tree will be allocated in this
  *  shared memory window, otherwise it will be local to each MPI process.
  */
-template <int D>
-FunctionTree<D>::FunctionTree(const MultiResolutionAnalysis<D> &mra, SharedMemory *sh_mem, const std::string &name)
-        : MWTree<D>(mra, name)
-        , RepresentableFunction<D>(mra.getWorldBox().getLowerBounds().data(), mra.getWorldBox().getUpperBounds().data()) {
+template <int D, typename T>
+FunctionTree<D, T>::FunctionTree(const MultiResolutionAnalysis<D> &mra, SharedMemory<T> *sh_mem, const std::string &name)
+        : MWTree<D, T>(mra, name)
+        , RepresentableFunction<D, T>(mra.getWorldBox().getLowerBounds().data(), mra.getWorldBox().getUpperBounds().data()) {
     int nodesPerChunk = 2048; // Large chunks are required for not leading to memory fragmentation (32 MB on "Betzy" 2023)
     int coefsGenNodes = this->getKp1_d();
     int coefsRegNodes = this->getTDim() * this->getKp1_d();
-    this->nodeAllocator_p = std::make_unique<NodeAllocator<D>>(this, sh_mem, coefsRegNodes, nodesPerChunk);
-    this->genNodeAllocator_p = std::make_unique<NodeAllocator<D>>(this, nullptr, coefsGenNodes, nodesPerChunk);
+    this->nodeAllocator_p = std::make_unique<NodeAllocator<D, T>>(this, sh_mem, coefsRegNodes, nodesPerChunk);
+    this->genNodeAllocator_p = std::make_unique<NodeAllocator<D, T>>(this, nullptr, coefsGenNodes, nodesPerChunk);
     this->allocRootNodes();
     this->resetEndNodeTable();
 }
 
-template <int D> void FunctionTree<D>::allocRootNodes() {
+template <int D, typename T> void FunctionTree<D, T>::allocRootNodes() {
     auto &allocator = this->getNodeAllocator();
     auto &rootbox = this->getRootBox();
 
@@ -74,10 +74,10 @@ template <int D> void FunctionTree<D>::allocRootNodes() {
     auto *coef_p = allocator.getCoef_p(sIdx);
     auto *root_p = allocator.getNode_p(sIdx);
 
-    MWNode<D> **roots = rootbox.getNodes();
+    MWNode<D, T> **roots = rootbox.getNodes();
     for (int rIdx = 0; rIdx < nRoots; rIdx++) {
         // construct into allocator memory
-        new (root_p) FunctionNode<D>(this, rIdx);
+        new (root_p) FunctionNode<D, T>(this, rIdx);
         roots[rIdx] = root_p;
 
         root_p->serialIx = sIdx;
@@ -101,14 +101,14 @@ template <int D> void FunctionTree<D>::allocRootNodes() {
 }
 
 // FunctionTree destructor
-template <int D> FunctionTree<D>::~FunctionTree() {
+template <int D, typename T> FunctionTree<D, T>::~FunctionTree() {
     this->deleteRootNodes();
 }
 
 /** @brief Write the tree structure to disk, for later use
  * @param[in] file: File name, will get ".tree" extension
  */
-template <int D> void FunctionTree<D>::saveTree(const std::string &file) {
+template <int D, typename T> void FunctionTree<D, T>::saveTree(const std::string &file) {
     Timer t1;
     this->deleteGenerated();
     auto &allocator = this->getNodeAllocator();
@@ -137,7 +137,7 @@ template <int D> void FunctionTree<D>::saveTree(const std::string &file) {
  * @param[in] file: File name, will get ".tree" extension
  * @note This tree must have the exact same MRA the one that was saved
  */
-template <int D> void FunctionTree<D>::loadTree(const std::string &file) {
+template <int D, typename T> void FunctionTree<D, T>::loadTree(const std::string &file) {
     Timer t1;
     std::stringstream fname;
     fname << file << ".tree";
@@ -168,11 +168,11 @@ template <int D> void FunctionTree<D>::loadTree(const std::string &file) {
 }
 
 /** @returns Integral of the function over the entire computational domain */
-template <int D> double FunctionTree<D>::integrate() const {
+template <int D, typename T> T FunctionTree<D, T>::integrate() const {
 
-    double result = 0.0;
+    T result = 0.0;
     for (int i = 0; i < this->rootBox.size(); i++) {
-        const FunctionNode<D> &fNode = getRootFuncNode(i);
+        const FunctionNode<D, T> &fNode = getRootFuncNode(i);
         result += fNode.integrate();
     }
 
@@ -188,7 +188,7 @@ template <int D> double FunctionTree<D>::integrate() const {
 
 
 /** @returns Integral of a representable function over the grid given by the tree */
-template <> double FunctionTree<3>::integrateEndNodes(RepresentableFunction_M &f) {
+  template <> double FunctionTree<3, double>::integrateEndNodes(RepresentableFunction_M &f) {
     //traverse tree, and treat end nodes only
     std::vector<FunctionNode<3> *> stack;   // node from this
     for (int i = 0; i < this->getRootBox().size(); i++) stack.push_back(&(this->getRootFuncNode(i)));
@@ -236,7 +236,7 @@ template <> double FunctionTree<3>::integrateEndNodes(RepresentableFunction_M &f
  *       the MW grid by one level before evaluating, using
  *       `mrcpp::refine_grid(tree, 1)`
  */
-template <int D> double FunctionTree<D>::evalf(const Coord<D> &r) const {
+template <int D, typename T> T FunctionTree<D, T>::evalf(const Coord<D> &r) const {
     // Handle potential scaling
     const auto scaling_factor = this->getMRA().getWorldBox().getScalingFactors();
     auto arg = r;
@@ -249,8 +249,8 @@ template <int D> double FunctionTree<D>::evalf(const Coord<D> &r) const {
     // Function is zero outside the domain for non-periodic functions
     if (this->outOfBounds(arg) and not this->getRootBox().isPeriodic()) return 0.0;
 
-    const MWNode<D> &mw_node = this->getNodeOrEndNode(arg);
-    auto &f_node = static_cast<const FunctionNode<D> &>(mw_node);
+    const MWNode<D, T> &mw_node = this->getNodeOrEndNode(arg);
+    auto &f_node = static_cast<const FunctionNode<D, T> &>(mw_node);
     auto result = f_node.evalScaling(arg);
 
     // Adjust for scaling factor included in basis
@@ -270,7 +270,7 @@ template <int D> double FunctionTree<D>::evalf(const Coord<D> &r) const {
  *       need fast evaluation, use refine_grid(tree, 1) first, and then
  *       evalf.
  */
-template <int D> double FunctionTree<D>::evalf_precise(const Coord<D> &r) {
+template <int D, typename T> T FunctionTree<D, T>::evalf_precise(const Coord<D> &r) {
     // Handle potential scaling
     const auto scaling_factor = this->getMRA().getWorldBox().getScalingFactors();
     auto arg = r;
@@ -283,8 +283,8 @@ template <int D> double FunctionTree<D>::evalf_precise(const Coord<D> &r) {
     // Function is zero outside the domain for non-periodic functions
     if (this->outOfBounds(arg) and not this->getRootBox().isPeriodic()) return 0.0;
 
-    MWNode<D> &mw_node = this->getNodeOrEndNode(arg);
-    auto &f_node = static_cast<FunctionNode<D> &>(mw_node);
+    MWNode<D, T> &mw_node = this->getNodeOrEndNode(arg);
+    auto &f_node = static_cast<FunctionNode<D, T> &>(mw_node);
     auto result = f_node.evalf(arg);
     this->deleteGenerated();
 
@@ -301,7 +301,7 @@ template <int D> double FunctionTree<D>::evalf_precise(const Coord<D> &r) {
  * squared, no grid refinement.
  *
  */
-template <int D> void FunctionTree<D>::square() {
+template <int D, typename T> void FunctionTree<D, T>::square() {
     if (this->getNGenNodes() != 0) MSG_ABORT("GenNodes not cleared");
 
 #pragma omp parallel num_threads(mrcpp_get_num_threads())
@@ -310,10 +310,10 @@ template <int D> void FunctionTree<D>::square() {
         int nCoefs = this->getTDim() * this->getKp1_d();
 #pragma omp for schedule(guided)
         for (int n = 0; n < nNodes; n++) {
-            MWNode<D> &node = *this->endNodeTable[n];
+            MWNode<D, T> &node = *this->endNodeTable[n];
             node.mwTransform(Reconstruction);
             node.cvTransform(Forward);
-            double *coefs = node.getCoefs();
+            T *coefs = node.getCoefs();
             for (int i = 0; i < nCoefs; i++) { coefs[i] *= coefs[i]; }
             node.cvTransform(Backward);
             node.mwTransform(Compression);
@@ -332,7 +332,7 @@ template <int D> void FunctionTree<D>::square() {
  * to the given power, no grid refinement.
  *
  */
-template <int D> void FunctionTree<D>::power(double p) {
+template <int D, typename T> void FunctionTree<D, T>::power(double p) {
     if (this->getNGenNodes() != 0) MSG_ABORT("GenNodes not cleared");
 
 #pragma omp parallel num_threads(mrcpp_get_num_threads())
@@ -341,10 +341,10 @@ template <int D> void FunctionTree<D>::power(double p) {
         int nCoefs = this->getTDim() * this->getKp1_d();
 #pragma omp for schedule(guided)
         for (int n = 0; n < nNodes; n++) {
-            MWNode<D> &node = *this->endNodeTable[n];
+            MWNode<D, T> &node = *this->endNodeTable[n];
             node.mwTransform(Reconstruction);
             node.cvTransform(Forward);
-            double *coefs = node.getCoefs();
+            T *coefs = node.getCoefs();
             for (int i = 0; i < nCoefs; i++) { coefs[i] = std::pow(coefs[i], p); }
             node.cvTransform(Backward);
             node.mwTransform(Compression);
@@ -363,7 +363,7 @@ template <int D> void FunctionTree<D>::power(double p) {
  * in-place multiplied by the given coefficient, no grid refinement.
  *
  */
-template <int D> void FunctionTree<D>::rescale(double c) {
+template <int D, typename T> void FunctionTree<D, T>::rescale(T c) {
     if (this->getNGenNodes() != 0) MSG_ABORT("GenNodes not cleared");
 #pragma omp parallel firstprivate(c) num_threads(mrcpp_get_num_threads())
     {
@@ -371,9 +371,9 @@ template <int D> void FunctionTree<D>::rescale(double c) {
         int nCoefs = this->getTDim() * this->getKp1_d();
 #pragma omp for schedule(guided)
         for (int i = 0; i < nNodes; i++) {
-            MWNode<D> &node = *this->endNodeTable[i];
+            MWNode<D, T> &node = *this->endNodeTable[i];
             if (not node.hasCoefs()) MSG_ABORT("No coefs");
-            double *coefs = node.getCoefs();
+            T *coefs = node.getCoefs();
             for (int j = 0; j < nCoefs; j++) { coefs[j] *= c; }
             node.calcNorms();
         }
@@ -383,7 +383,7 @@ template <int D> void FunctionTree<D>::rescale(double c) {
 }
 
 /** @brief In-place rescaling by a function norm \f$ ||f||^{-1} \f$, fixed grid */
-template <int D> void FunctionTree<D>::normalize() {
+template <int D, typename T> void FunctionTree<D, T>::normalize() {
     if (this->getNGenNodes() != 0) MSG_ABORT("GenNodes not cleared");
     double sq_norm = this->getSquareNorm();
     if (sq_norm < 0.0) MSG_ERROR("Normalizing uninitialized function");
@@ -399,7 +399,7 @@ template <int D> void FunctionTree<D>::normalize() {
  * the function, i.e. no further grid refinement.
  *
  */
-template <int D> void FunctionTree<D>::add(double c, FunctionTree<D> &inp) {
+template <int D, typename T> void FunctionTree<D, T>::add(T c, FunctionTree<D, T> &inp) {
     if (this->getMRA() != inp.getMRA()) MSG_ABORT("Incompatible MRA");
     if (this->getNGenNodes() != 0) MSG_ABORT("GenNodes not cleared");
 #pragma omp parallel firstprivate(c) shared(inp) num_threads(mrcpp_get_num_threads())
@@ -407,10 +407,10 @@ template <int D> void FunctionTree<D>::add(double c, FunctionTree<D> &inp) {
         int nNodes = this->getNEndNodes();
 #pragma omp for schedule(guided)
         for (int n = 0; n < nNodes; n++) {
-            MWNode<D> &out_node = *this->endNodeTable[n];
-            MWNode<D> &inp_node = inp.getNode(out_node.getNodeIndex());
-            double *out_coefs = out_node.getCoefs();
-            const double *inp_coefs = inp_node.getCoefs();
+            MWNode<D, T> &out_node = *this->endNodeTable[n];
+            MWNode<D, T> &inp_node = inp.getNode(out_node.getNodeIndex());
+            T *out_coefs = out_node.getCoefs();
+            const T *inp_coefs = inp_node.getCoefs();
             for (int i = 0; i < inp_node.getNCoefs(); i++) { out_coefs[i] += c * inp_coefs[i]; }
             out_node.calcNorms();
         }
@@ -428,22 +428,22 @@ template <int D> void FunctionTree<D>::add(double c, FunctionTree<D> &inp) {
  * function, i.e. no further grid refinement.
  *
  */
-template <int D> void FunctionTree<D>::absadd(double c, FunctionTree<D> &inp) {
+template <int D, typename T> void FunctionTree<D, T>::absadd (T c, FunctionTree<D, T> &inp) {
     if (this->getNGenNodes() != 0) MSG_ABORT("GenNodes not cleared");
 #pragma omp parallel firstprivate(c) shared(inp) num_threads(mrcpp_get_num_threads())
     {
         int nNodes = this->getNEndNodes();
 #pragma omp for schedule(guided)
         for (int n = 0; n < nNodes; n++) {
-            MWNode<D> &out_node = *this->endNodeTable[n];
-            MWNode<D> inp_node = inp.getNode(out_node.getNodeIndex()); // Full copy
+            MWNode<D, T> &out_node = *this->endNodeTable[n];
+            MWNode<D, T> inp_node = inp.getNode(out_node.getNodeIndex()); // Full copy
             out_node.mwTransform(Reconstruction);
             out_node.cvTransform(Forward);
             inp_node.mwTransform(Reconstruction);
             inp_node.cvTransform(Forward);
-            double *out_coefs = out_node.getCoefs();
-            const double *inp_coefs = inp_node.getCoefs();
-            for (int i = 0; i < inp_node.getNCoefs(); i++) { out_coefs[i] = abs(out_coefs[i]) + c * abs(inp_coefs[i]); }
+            T *out_coefs = out_node.getCoefs();
+            const T *inp_coefs = inp_node.getCoefs();
+            for (int i = 0; i < inp_node.getNCoefs(); i++) { out_coefs[i] = std::norm(out_coefs[i]) + std::norm(c * inp_coefs[i]); }
             out_node.cvTransform(Backward);
             out_node.mwTransform(Compression);
             out_node.calcNorms();
@@ -463,7 +463,7 @@ template <int D> void FunctionTree<D>::absadd(double c, FunctionTree<D> &inp) {
  * of the function, i.e. no further grid refinement.
  *
  */
-template <int D> void FunctionTree<D>::multiply(double c, FunctionTree<D> &inp) {
+template <int D, typename T> void FunctionTree<D, T>::multiply(T c, FunctionTree<D, T> &inp) {
     if (this->getMRA() != inp.getMRA()) MSG_ABORT("Incompatible MRA");
     if (this->getNGenNodes() != 0) MSG_ABORT("GenNodes not cleared");
 #pragma omp parallel firstprivate(c) shared(inp) num_threads(mrcpp_get_num_threads())
@@ -471,14 +471,14 @@ template <int D> void FunctionTree<D>::multiply(double c, FunctionTree<D> &inp)
         int nNodes = this->getNEndNodes();
 #pragma omp for schedule(guided)
         for (int n = 0; n < nNodes; n++) {
-            MWNode<D> &out_node = *this->endNodeTable[n];
-            MWNode<D> inp_node = inp.getNode(out_node.getNodeIndex()); // Full copy
+            MWNode<D, T> &out_node = *this->endNodeTable[n];
+            MWNode<D, T> inp_node = inp.getNode(out_node.getNodeIndex()); // Full copy
             out_node.mwTransform(Reconstruction);
             out_node.cvTransform(Forward);
             inp_node.mwTransform(Reconstruction);
             inp_node.cvTransform(Forward);
-            double *out_coefs = out_node.getCoefs();
-            const double *inp_coefs = inp_node.getCoefs();
+            T *out_coefs = out_node.getCoefs();
+            const T *inp_coefs = inp_node.getCoefs();
             for (int i = 0; i < inp_node.getNCoefs(); i++) { out_coefs[i] *= c * inp_coefs[i]; }
             out_node.cvTransform(Backward);
             out_node.mwTransform(Compression);
@@ -498,16 +498,16 @@ template <int D> void FunctionTree<D>::multiply(double c, FunctionTree<D> &inp)
  * of the function, i.e. no further grid refinement.
  *
  */
-template <int D> void FunctionTree<D>::map(FMap fmap) {
+template <int D, typename T> void FunctionTree<D, T>::map(FMap<T, T> fmap) {
     if (this->getNGenNodes() != 0) MSG_ABORT("GenNodes not cleared");
     {
         int nNodes = this->getNEndNodes();
 #pragma omp parallel for schedule(guided) num_threads(mrcpp_get_num_threads())
         for (int n = 0; n < nNodes; n++) {
-            MWNode<D> &node = *this->endNodeTable[n];
+            MWNode<D, T> &node = *this->endNodeTable[n];
             node.mwTransform(Reconstruction);
             node.cvTransform(Forward);
-            double *coefs = node.getCoefs();
+            T *coefs = node.getCoefs();
             for (int i = 0; i < node.getNCoefs(); i++) { coefs[i] = fmap(coefs[i]); }
             node.cvTransform(Backward);
             node.mwTransform(Compression);
@@ -518,29 +518,29 @@ template <int D> void FunctionTree<D>::map(FMap fmap) {
     this->calcSquareNorm();
 }
 
-template <int D> void FunctionTree<D>::getEndValues(VectorXd &data) {
+template <int D, typename T> void FunctionTree<D, T>::getEndValues(Eigen::Matrix<T , Eigen::Dynamic, 1 > &data) {
     if (this->getNGenNodes() != 0) MSG_ABORT("GenNodes not cleared");
     int nNodes = this->getNEndNodes();
     int nCoefs = this->getTDim() * this->getKp1_d();
     data = VectorXd::Zero(nNodes * nCoefs);
     for (int n = 0; n < nNodes; n++) {
-        MWNode<D> &node = getEndFuncNode(n);
+        MWNode<D, T> &node = getEndFuncNode(n);
         node.mwTransform(Reconstruction);
         node.cvTransform(Forward);
-        const double *c = node.getCoefs();
+        const T *c = node.getCoefs();
         for (int i = 0; i < nCoefs; i++) { data(n * nCoefs + i) = c[i]; }
         node.cvTransform(Backward);
         node.mwTransform(Compression);
     }
 }
 
-template <int D> void FunctionTree<D>::setEndValues(VectorXd &data) {
+template <int D, typename T> void FunctionTree<D, T>::setEndValues(Eigen::Matrix<T , Eigen::Dynamic, 1 > &data) {
     if (this->getNGenNodes() != 0) MSG_ABORT("GenNodes not cleared");
     int nNodes = this->getNEndNodes();
     int nCoefs = this->getTDim() * this->getKp1_d();
     for (int i = 0; i < nNodes; i++) {
-        MWNode<D> &node = getEndFuncNode(i);
-        const double *c = data.segment(i * nCoefs, nCoefs).data();
+        MWNode<D, T> &node = getEndFuncNode(i);
+        const T *c = data.segment(i * nCoefs, nCoefs).data();
         node.setCoefBlock(0, nCoefs, c);
         node.cvTransform(Backward);
         node.mwTransform(Compression);
@@ -551,10 +551,10 @@ template <int D> void FunctionTree<D>::setEndValues(VectorXd &data) {
     this->calcSquareNorm();
 }
 
-template <int D> std::ostream &FunctionTree<D>::print(std::ostream &o) const {
+template <int D, typename T> std::ostream &FunctionTree<D, T>::print(std::ostream &o) const {
     o << std::endl << "*FunctionTree: " << this->name << std::endl;
     o << "  genNodes: " << getNGenNodes() << std::endl;
-    return MWTree<D>::print(o);
+    return MWTree<D, T>::print(o);
 }
 
 /** @brief Reduce the precision of the tree by deleting nodes
@@ -571,9 +571,9 @@ template <int D> std::ostream &FunctionTree<D>::print(std::ostream &o) const {
  * \f$ ||w|| < 2^{-sn/2} ||f|| \epsilon \f$. In principal, `s` should be equal
  * to the dimension; in practice, it is set to `s=1`.
  */
-template <int D> int FunctionTree<D>::crop(double prec, double splitFac, bool absPrec) {
+template <int D, typename T> int FunctionTree<D, T>::crop(double prec, double splitFac, bool absPrec) {
     for (int i = 0; i < this->rootBox.size(); i++) {
-        MWNode<D> &root = this->getRootMWNode(i);
+        MWNode<D, T> &root = this->getRootMWNode(i);
         root.crop(prec, splitFac, absPrec);
     }
     int nChunks = this->getNodeAllocator().compress();
@@ -586,22 +586,22 @@ template <int D> int FunctionTree<D>::crop(double prec, double splitFac, bool ab
  * Also returns an array with the corresponding indices defined as the
  * values of serialIx in refTree, and an array with the indices of the parent.
  * Set index -1 for nodes that are not present in refTree */
-template <int D>
-void FunctionTree<D>::makeCoeffVector(std::vector<double *> &coefs,
+template <int D, typename T>
+void FunctionTree<D, T>::makeCoeffVector(std::vector<T *> &coefs,
                                       std::vector<int> &indices,
                                       std::vector<int> &parent_indices,
                                       std::vector<double> &scalefac,
                                       int &max_index,
-                                      MWTree<D> &refTree,
-                                      std::vector<MWNode<D> *> *refNodes) {
+                                      MWTree<D, T> &refTree,
+                                      std::vector<MWNode<D, T> *> *refNodes) {
     coefs.clear();
     indices.clear();
     parent_indices.clear();
     max_index = 0;
     int sizecoeff = (1 << refTree.getDim()) * refTree.getKp1_d();
     int sizecoeffW = ((1 << refTree.getDim()) - 1) * refTree.getKp1_d();
-    std::vector<MWNode<D> *> refstack;  // nodes from refTree
-    std::vector<MWNode<D> *> thisstack; // nodes from this Tree
+    std::vector<MWNode<D, T> *> refstack;  // nodes from refTree
+    std::vector<MWNode<D, T> *> thisstack; // nodes from this Tree
     for (int rIdx = 0; rIdx < this->getRootBox().size(); rIdx++) {
         refstack.push_back(refTree.getRootBox().getNodes()[rIdx]);
         thisstack.push_back(this->getRootBox().getNodes()[rIdx]);
@@ -609,8 +609,8 @@ void FunctionTree<D>::makeCoeffVector(std::vector<double *> &coefs,
     int stack_p = 0;
     while (thisstack.size() > stack_p) {
         // refNode and thisNode are the same node in space, but on different trees
-        MWNode<D> *thisNode = thisstack[stack_p];
-        MWNode<D> *refNode = refstack[stack_p++];
+        MWNode<D, T> *thisNode = thisstack[stack_p];
+        MWNode<D, T> *refNode = refstack[stack_p++];
         coefs.push_back(thisNode->getCoefs());
         if (refNodes != nullptr) refNodes->push_back(refNode);
         if (refNode != nullptr) {
@@ -640,26 +640,26 @@ void FunctionTree<D>::makeCoeffVector(std::vector<double *> &coefs,
  * reference tree and a list of coefficients.
  * It is the reference tree (refTree) which is traversed, but one does not descend
  * into children if the norm of the tree is smaller than absPrec. */
-template <int D> void FunctionTree<D>::makeTreefromCoeff(MWTree<D> &refTree, std::vector<double *> coefpVec, std::map<int, int> &ix2coef, double absPrec, const std::string &mode) {
-    std::vector<MWNode<D> *> stack;
-    std::map<int, MWNode<D> *> ix2node; // gives the nodes in this tree for a given ix
+template <int D, typename T> void FunctionTree<D, T>::makeTreefromCoeff(MWTree<D, T> &refTree, std::vector<T *> coefpVec, std::map<int, int> &ix2coef, double absPrec, const std::string &mode) {
+    std::vector<MWNode<D, T> *> stack;
+    std::map<int, MWNode<D, T> *> ix2node; // gives the nodes in this tree for a given ix
     int sizecoef = (1 << this->getDim()) * this->getKp1_d();
     int sizecoefW = ((1 << this->getDim()) - 1) * this->getKp1_d();
     this->squareNorm = 0.0;
     this->clearEndNodeTable();
     for (int rIdx = 0; rIdx < refTree.getRootBox().size(); rIdx++) {
-        MWNode<D> *refNode = refTree.getRootBox().getNodes()[rIdx];
+        MWNode<D, T> *refNode = refTree.getRootBox().getNodes()[rIdx];
         stack.push_back(refNode);
         int ix = ix2coef[refNode->getSerialIx()];
         ix2node[ix] = this->getRootBox().getNodes()[rIdx];
     }
 
     while (stack.size() > 0) {
-        MWNode<D> *refNode = stack.back(); // node in the reference tree refTree
+        MWNode<D, T> *refNode = stack.back(); // node in the reference tree refTree
         stack.pop_back();
         assert(ix2coef.count(refNode->getSerialIx()) > 0);
         int ix = ix2coef[refNode->getSerialIx()];
-        MWNode<D> *node = ix2node[ix]; // corresponding node in this tree
+        MWNode<D, T> *node = ix2node[ix]; // corresponding node in this tree
         // copy coefficients into this tree
         int size = sizecoefW;
         if (refNode->isRootNode() or mode == "copy") {
@@ -701,8 +701,8 @@ template <int D> void FunctionTree<D>::makeTreefromCoeff(MWTree<D> &refTree, std
         } else if ((absPrec < 0 or tree_utils::split_check(*node, absPrec, 1.0, true)) and refNode->getNChildren() > 0) {
             // include children in tree
             node->createChildren(true);
-            double *inp = node->getCoefs();
-            double *out = node->getMWChild(0).getCoefs();
+            T *inp = node->getCoefs();
+            T *out = node->getMWChild(0).getCoefs();
             tree_utils::mw_transform(*this, inp, out, false, sizecoef, true); // make the scaling part
             for (int i = 0; i < refNode->getNChildren(); i++) {
                 stack.push_back(refNode->children[i]); // means we continue to traverse the reference tree
@@ -717,9 +717,9 @@ template <int D> void FunctionTree<D>::makeTreefromCoeff(MWTree<D> &refTree, std
 }
 
 /** Traverse tree using DFS and append same nodes as another tree, without coefficients */
-template <int D> void FunctionTree<D>::appendTreeNoCoeff(MWTree<D> &inTree) {
-    std::vector<MWNode<D> *> instack;   // node from inTree
-    std::vector<MWNode<D> *> thisstack; // node from this Tree
+template <int D, typename T> void FunctionTree<D, T>::appendTreeNoCoeff(MWTree<D, T> &inTree) {
+    std::vector<MWNode<D, T> *> instack;   // node from inTree
+    std::vector<MWNode<D, T> *> thisstack; // node from this Tree
     this->clearEndNodeTable();
     for (int rIdx = 0; rIdx < inTree.getRootBox().size(); rIdx++) {
         instack.push_back(inTree.getRootBox().getNodes()[rIdx]);
@@ -727,9 +727,9 @@ template <int D> void FunctionTree<D>::appendTreeNoCoeff(MWTree<D> &inTree) {
     }
     while (thisstack.size() > 0) {
         // inNode and thisNode are the same node in space, but on different trees
-        MWNode<D> *thisNode = thisstack.back();
+        MWNode<D, T> *thisNode = thisstack.back();
         thisstack.pop_back();
-        MWNode<D> *inNode = instack.back();
+        MWNode<D, T> *inNode = instack.back();
         instack.pop_back();
         if (inNode->getNChildren() > 0) {
             thisNode->clearIsEndNode();
@@ -741,10 +741,10 @@ template <int D> void FunctionTree<D>::appendTreeNoCoeff(MWTree<D> &inTree) {
         } else {
             // construct EndNodeTable for "This", starting from this branch
             // This could be done more efficiently, if it proves to be time consuming
-            std::vector<MWNode<D> *> branchstack; // local stack starting from this branch
+            std::vector<MWNode<D, T> *> branchstack; // local stack starting from this branch
             branchstack.push_back(thisNode);
             while (branchstack.size() > 0) {
-                MWNode<D> *branchNode = branchstack.back();
+                MWNode<D, T> *branchNode = branchstack.back();
                 branchstack.pop_back();
                 if (branchNode->getNChildren() > 0) {
                     for (int i = 0; i < branchNode->getNChildren(); i++) { branchstack.push_back(branchNode->children[i]); }
@@ -755,24 +755,24 @@ template <int D> void FunctionTree<D>::appendTreeNoCoeff(MWTree<D> &inTree) {
     }
 }
 
-template <int D> void FunctionTree<D>::deleteGenerated() {
+template <int D, typename T> void FunctionTree<D, T>::deleteGenerated() {
     for (int n = 0; n < this->getNEndNodes(); n++) this->getEndMWNode(n).deleteGenerated();
 }
 
-template <int D> void FunctionTree<D>::deleteGeneratedParents() {
+template <int D, typename T> void FunctionTree<D, T>::deleteGeneratedParents() {
     for (int n = 0; n < this->getRootBox().size(); n++) this->getRootMWNode(n).deleteParent();
 }
 
-template <> int FunctionTree<3>::saveNodesAndRmCoeff() {
+template <> int FunctionTree<3, double>::saveNodesAndRmCoeff() {
     if (this->isLocal) MSG_INFO("Tree is already in local representation");
     NodesCoeff = new BankAccount; // NB: must be a collective call!
     int stack_p = 0;
     if (mpi::wrk_rank == 0) {
         int sizecoeff = (1 << 3) * this->getKp1_d();
-        std::vector<MWNode<3> *> stack; // nodes from this Tree
+        std::vector<MWNode<3, double> *> stack; // nodes from this Tree
         for (int rIdx = 0; rIdx < this->getRootBox().size(); rIdx++) { stack.push_back(this->getRootBox().getNodes()[rIdx]); }
         while (stack.size() > stack_p) {
-            MWNode<3> *Node = stack[stack_p++];
+            MWNode<3, double> *Node = stack[stack_p++];
             int id = 0;
             NodesCoeff->put_data(Node->getNodeIndex(), sizecoeff, Node->getCoefs());
             for (int i = 0; i < Node->getNChildren(); i++) { stack.push_back(Node->children[i]); }
@@ -785,8 +785,35 @@ template <> int FunctionTree<3>::saveNodesAndRmCoeff() {
     return this->NodeIndex2serialIx.size();
 }
 
-template class FunctionTree<1>;
-template class FunctionTree<2>;
-template class FunctionTree<3>;
+template <> int FunctionTree<3, ComplexDouble>::saveNodesAndRmCoeff() {
+    if (this->isLocal) MSG_INFO("Tree is already in local representation");
+    NodesCoeff = new BankAccount; // NB: must be a collective call!
+    int stack_p = 0;
+    if (mpi::wrk_rank == 0) {
+        int sizecoeff = (1 << 3) * this->getKp1_d();
+        sizecoeff *= 2; // double->ComplexDouble. Saved as twice as many doubles
+        std::vector<MWNode<3, ComplexDouble> *> stack; // nodes from this Tree
+        for (int rIdx = 0; rIdx < this->getRootBox().size(); rIdx++) { stack.push_back(this->getRootBox().getNodes()[rIdx]); }
+        while (stack.size() > stack_p) {
+            MWNode<3, ComplexDouble> *Node = stack[stack_p++];
+            int id = 0;
+            NodesCoeff->put_data(Node->getNodeIndex(), sizecoeff, Node->getCoefs());
+            for (int i = 0; i < Node->getNChildren(); i++) { stack.push_back(Node->children[i]); }
+        }
+    }
+    this->nodeAllocator_p->deallocAllCoeff();
+    mpi::broadcast_Tree_noCoeff(*this, mpi::comm_wrk);
+    this->isLocal = true;
+    assert(this->NodeIndex2serialIx.size() == getNNodes());
+    return this->NodeIndex2serialIx.size();
+}
+
+template class FunctionTree<1, double>;
+template class FunctionTree<2, double>;
+template class FunctionTree<3, double>;
+
+template class FunctionTree<1, ComplexDouble>;
+template class FunctionTree<2, ComplexDouble>;
+template class FunctionTree<3, ComplexDouble>;
 
 } // namespace mrcpp
diff --git a/src/trees/FunctionTree.h b/src/trees/FunctionTree.h
index 0be9563ea..c9e8ecde8 100644
--- a/src/trees/FunctionTree.h
+++ b/src/trees/FunctionTree.h
@@ -52,24 +52,24 @@ namespace mrcpp {
  * uninitialized, and its square norm will be negative (minus one).
  */
 
-template <int D> class FunctionTree final : public MWTree<D>, public RepresentableFunction<D> {
+template <int D, typename T> class FunctionTree final : public MWTree<D, T>, public RepresentableFunction<D, T> {
 public:
     FunctionTree(const MultiResolutionAnalysis<D> &mra, const std::string &name)
             : FunctionTree(mra, nullptr, name) {}
-    FunctionTree(const MultiResolutionAnalysis<D> &mra, SharedMemory *sh_mem = nullptr, const std::string &name = "nn");
-    FunctionTree(const FunctionTree<D> &tree) = delete;
-    FunctionTree<D> &operator=(const FunctionTree<D> &tree) = delete;
+    FunctionTree(const MultiResolutionAnalysis<D> &mra, SharedMemory<T> *sh_mem = nullptr, const std::string &name = "nn");
+    FunctionTree(const FunctionTree<D, T> &tree) = delete;
+    FunctionTree<D, T> &operator=(const FunctionTree<D, T> &tree) = delete;
     ~FunctionTree() override;
 
-    double integrate() const;
+    T integrate() const;
     double integrateEndNodes(RepresentableFunction_M &f);
-    double evalf_precise(const Coord<D> &r);
-    double evalf(const Coord<D> &r) const override;
+    T evalf_precise(const Coord<D> &r);
+    T evalf(const Coord<D> &r) const override;
 
     int getNGenNodes() const { return getGenNodeAllocator().getNNodes(); }
 
-    void getEndValues(Eigen::VectorXd &data);
-    void setEndValues(Eigen::VectorXd &data);
+    void getEndValues(Eigen::Matrix<T , Eigen::Dynamic, 1 > &data);
+    void setEndValues(Eigen::Matrix<T , Eigen::Dynamic, 1 > &data);
 
     void saveTree(const std::string &file);
     void loadTree(const std::string &file);
@@ -77,44 +77,44 @@ template <int D> class FunctionTree final : public MWTree<D>, public Representab
     // In place operations
     void square();
     void power(double p);
-    void rescale(double c);
+    void rescale(T c);
     void normalize();
-    void add(double c, FunctionTree<D> &inp);
-    void absadd(double c, FunctionTree<D> &inp);
-    void multiply(double c, FunctionTree<D> &inp);
-    void map(FMap fmap);
+    void add(T c, FunctionTree<D, T> &inp);
+    void absadd(T c, FunctionTree<D, T> &inp);
+    void multiply(T c, FunctionTree<D, T> &inp);
+    void map(FMap<T, T> fmap);
 
     int getNChunks() { return this->getNodeAllocator().getNChunks(); }
     int getNChunksUsed() { return this->getNodeAllocator().getNChunksUsed(); }
 
     int crop(double prec, double splitFac = 1.0, bool absPrec = true);
 
-    FunctionNode<D> &getEndFuncNode(int i) { return static_cast<FunctionNode<D> &>(this->getEndMWNode(i)); }
-    FunctionNode<D> &getRootFuncNode(int i) { return static_cast<FunctionNode<D> &>(this->rootBox.getNode(i)); }
+    FunctionNode<D, T> &getEndFuncNode(int i) { return static_cast<FunctionNode<D, T> &>(this->getEndMWNode(i)); }
+    FunctionNode<D, T> &getRootFuncNode(int i) { return static_cast<FunctionNode<D, T> &>(this->rootBox.getNode(i)); }
 
-    NodeAllocator<D> &getGenNodeAllocator() { return *this->genNodeAllocator_p; }
-    const NodeAllocator<D> &getGenNodeAllocator() const { return *this->genNodeAllocator_p; }
+    NodeAllocator<D, T> &getGenNodeAllocator() { return *this->genNodeAllocator_p; }
+    const NodeAllocator<D, T> &getGenNodeAllocator() const { return *this->genNodeAllocator_p; }
 
-    const FunctionNode<D> &getEndFuncNode(int i) const { return static_cast<const FunctionNode<D> &>(this->getEndMWNode(i)); }
-    const FunctionNode<D> &getRootFuncNode(int i) const { return static_cast<const FunctionNode<D> &>(this->rootBox.getNode(i)); }
+    const FunctionNode<D, T> &getEndFuncNode(int i) const { return static_cast<const FunctionNode<D, T> &>(this->getEndMWNode(i)); }
+    const FunctionNode<D, T> &getRootFuncNode(int i) const { return static_cast<const FunctionNode<D, T> &>(this->rootBox.getNode(i)); }
 
     void deleteGenerated();
     void deleteGeneratedParents();
 
-    void makeCoeffVector(std::vector<double *> &coefs,
+    void makeCoeffVector(std::vector<T *> &coefs,
                          std::vector<int> &indices,
                          std::vector<int> &parent_indices,
                          std::vector<double> &scalefac,
                          int &max_index,
-                         MWTree<D> &refTree,
-                         std::vector<MWNode<D> *> *refNodes = nullptr);
-    void makeTreefromCoeff(MWTree<D> &refTree, std::vector<double *> coefpVec, std::map<int, int> &ix2coef, double absPrec, const std::string &mode = "adaptive");
-    void appendTreeNoCoeff(MWTree<D> &inTree);
+                         MWTree<D, T> &refTree,
+                         std::vector<MWNode<D, T> *> *refNodes = nullptr);
+    void makeTreefromCoeff(MWTree<D, T> &refTree, std::vector<T *> coefpVec, std::map<int, int> &ix2coef, double absPrec, const std::string &mode = "adaptive");
+    void appendTreeNoCoeff(MWTree<D, T> &inTree);
 
     // tools for use of local (nodes are stored in Bank) representation
     int saveNodesAndRmCoeff(); // put all nodes coefficients in Bank and delete all coefficients
 protected:
-    std::unique_ptr<NodeAllocator<D>> genNodeAllocator_p{nullptr};
+    std::unique_ptr<NodeAllocator<D, T>> genNodeAllocator_p{nullptr};
     std::ostream &print(std::ostream &o) const override;
 
     void allocRootNodes();
diff --git a/src/trees/FunctionTreeVector.h b/src/trees/FunctionTreeVector.h
index d73005cd8..a9ed84d91 100644
--- a/src/trees/FunctionTreeVector.h
+++ b/src/trees/FunctionTreeVector.h
@@ -32,14 +32,14 @@
 
 namespace mrcpp {
 
-template <int D> using CoefsFunctionTree = std::tuple<double, FunctionTree<D> *>;
-template <int D> using FunctionTreeVector = std::vector<CoefsFunctionTree<D>>;
+template <int D, typename T = double> using CoefsFunctionTree = std::tuple<T, FunctionTree<D, T> *>;
+template <int D, typename T = double> using FunctionTreeVector = std::vector<CoefsFunctionTree<D, T>>;
 
 /** @brief Remove all entries in the vector
  *  @param[in] fs: Vector to clear
  *  @param[in] dealloc: Option to free FunctionTree pointer before clearing
  */
-template <int D> void clear(FunctionTreeVector<D> &fs, bool dealloc = false) {
+  template <int D, typename T> void clear(FunctionTreeVector<D, T> &fs, bool dealloc = false) {
     if (dealloc) {
         for (auto &t : fs) {
             auto f = std::get<1>(t);
@@ -52,7 +52,7 @@ template <int D> void clear(FunctionTreeVector<D> &fs, bool dealloc = false) {
 /** @returns Total number of nodes of all trees in the vector
  *  @param[in] fs: Vector to fetch from
  */
-template <int D> int get_n_nodes(const FunctionTreeVector<D> &fs) {
+template <int D, typename T> int get_n_nodes(const FunctionTreeVector<D, T> &fs) {
     int nNodes = 0;
     for (const auto &t : fs) {
         auto f = std::get<1>(t);
@@ -64,7 +64,7 @@ template <int D> int get_n_nodes(const FunctionTreeVector<D> &fs) {
 /** @returns Total size of all trees in the vector, in kB
  *  @param[in] fs: Vector to fetch from
  */
-template <int D> int get_size_nodes(const FunctionTreeVector<D> &fs) {
+template <int D, typename T> int get_size_nodes(const FunctionTreeVector<D, T> &fs) {
     int sNodes = 0;
     for (const auto &t : fs) {
         auto f = std::get<1>(t);
@@ -77,7 +77,7 @@ template <int D> int get_size_nodes(const FunctionTreeVector<D> &fs) {
  *  @param[in] fs: Vector to fetch from
  *  @param[in] i: Position in vector
  */
-template <int D> double get_coef(const FunctionTreeVector<D> &fs, int i) {
+template <int D, typename T> T get_coef(const FunctionTreeVector<D, T> &fs, int i) {
     return std::get<0>(fs[i]);
 }
 
@@ -85,7 +85,7 @@ template <int D> double get_coef(const FunctionTreeVector<D> &fs, int i) {
  *  @param[in] fs: Vector to fetch from
  *  @param[in] i: Position in vector
  */
-template <int D> FunctionTree<D> &get_func(FunctionTreeVector<D> &fs, int i) {
+template <int D, typename T> FunctionTree<D, T> &get_func(FunctionTreeVector<D, T> &fs, int i) {
     return *(std::get<1>(fs[i]));
 }
 
@@ -93,7 +93,7 @@ template <int D> FunctionTree<D> &get_func(FunctionTreeVector<D> &fs, int i) {
  *  @param[in] fs: Vector to fetch from
  *  @param[in] i: Position in vector
  */
-template <int D> const FunctionTree<D> &get_func(const FunctionTreeVector<D> &fs, int i) {
+template <int D, typename T> const FunctionTree<D, T> &get_func(const FunctionTreeVector<D, T> &fs, int i) {
     return *(std::get<1>(fs[i]));
 }
 } // namespace mrcpp
diff --git a/src/trees/MWNode.cpp b/src/trees/MWNode.cpp
index d15c0939f..7bfa510de 100644
--- a/src/trees/MWNode.cpp
+++ b/src/trees/MWNode.cpp
@@ -45,8 +45,8 @@ namespace mrcpp {
  *
  * @details Should be used only by NodeAllocator to obtain
  *  virtual table pointers for the derived classes. */
-template <int D>
-MWNode<D>::MWNode()
+  template <int D, typename T>
+  MWNode<D, T>::MWNode()
         : tree(nullptr)
         , parent(nullptr)
         , nodeIndex()
@@ -66,8 +66,8 @@ MWNode<D>::MWNode()
  *
  * @details Constructor for an empty node, given the corresponding MWTree and NodeIndex
  */
-template <int D>
-MWNode<D>::MWNode(MWTree<D> *tree, const NodeIndex<D> &idx)
+template <int D, typename T>
+MWNode<D, T>::MWNode(MWTree<D, T> *tree, const NodeIndex<D> &idx)
         : tree(tree)
         , parent(nullptr)
         , nodeIndex(idx)
@@ -87,8 +87,8 @@ MWNode<D>::MWNode(MWTree<D> *tree, const NodeIndex<D> &idx)
  * @details Constructor for root nodes. It requires the corresponding
  * MWTree and an integer to fetch the right NodeIndex
  */
-template <int D>
-MWNode<D>::MWNode(MWTree<D> *tree, int rIdx)
+template <int D, typename T>
+MWNode<D, T>::MWNode(MWTree<D, T> *tree, int rIdx)
         : tree(tree)
         , parent(nullptr)
         , nodeIndex(tree->getRootBox().getNodeIndex(rIdx))
@@ -108,8 +108,8 @@ MWNode<D>::MWNode(MWTree<D> *tree, int rIdx)
  * @details Constructor for leaf nodes. It requires the corresponding
  * parent and an integer to identify the correct child.
  */
-template <int D>
-MWNode<D>::MWNode(MWNode<D> *parent, int cIdx)
+template <int D, typename T>
+MWNode<D, T>::MWNode(MWNode<D, T> *parent, int cIdx)
         : tree(parent->tree)
         , parent(parent)
         , nodeIndex(parent->getNodeIndex().child(cIdx))
@@ -130,8 +130,8 @@ MWNode<D>::MWNode(MWNode<D> *parent, int cIdx)
  * does not "belong" to the tree: it cannot be accessed by traversing
  * the tree.
  */
-template <int D>
-MWNode<D>::MWNode(const MWNode<D> &node, bool allocCoef, bool SetCoef)
+template <int D, typename T>
+MWNode<D, T>::MWNode(const MWNode<D, T> &node, bool allocCoef, bool SetCoef)
         : tree(node.tree)
         , parent(nullptr)
         , nodeIndex(node.nodeIndex)
@@ -163,7 +163,7 @@ MWNode<D>::MWNode(const MWNode<D> &node, bool allocCoef, bool SetCoef)
  *
  * @details Recursive deallocation of a node and all its decendants
  */
-template <int D> MWNode<D>::~MWNode() {
+  template <int D, typename T> MWNode<D, T>::~MWNode() {
     if (this->isLooseNode()) this->freeCoefs();
     MRCPP_DESTROY_OMP_LOCK();
 }
@@ -174,7 +174,7 @@ template <int D> MWNode<D>::~MWNode() {
  * called (derived classes must implement their own version). This was
  * to avoid having pure virtual methods in the base class.
  */
-template <int D> void MWNode<D>::dealloc() {
+  template <int D, typename T> void MWNode<D, T>::dealloc() {
     NOT_REACHED_ABORT;
 }
 
@@ -184,13 +184,13 @@ template <int D> void MWNode<D>::dealloc() {
  * are not treated by the NodeAllocator class.
  *
  */
-template <int D> void MWNode<D>::allocCoefs(int n_blocks, int block_size) {
+  template <int D, typename T> void MWNode<D, T>::allocCoefs(int n_blocks, int block_size) {
     if (this->n_coefs != 0) MSG_ABORT("n_coefs should be zero");
     if (this->isAllocated()) MSG_ABORT("Coefs already allocated");
     if (not this->isLooseNode()) MSG_ABORT("Only loose nodes here!");
 
     this->n_coefs = n_blocks * block_size;
-    this->coefs = new double[this->n_coefs];
+    this->coefs = new T[this->n_coefs];
 
     this->clearHasCoefs();
     this->setIsAllocated();
@@ -202,7 +202,7 @@ template <int D> void MWNode<D>::allocCoefs(int n_blocks, int block_size) {
  * are not treated by the NodeAllocator class.
  *
  */
-template <int D> void MWNode<D>::freeCoefs() {
+  template <int D, typename T> void MWNode<D, T>::freeCoefs() {
     if (not this->isLooseNode()) MSG_ABORT("Only loose nodes here!");
 
     if (this->coefs != nullptr) delete[] this->coefs;
@@ -216,7 +216,7 @@ template <int D> void MWNode<D>::freeCoefs() {
 
 /** @brief Printout of node coefficients
  */
-template <int D> void MWNode<D>::printCoefs() const {
+  template <int D, typename T> void MWNode<D, T>::printCoefs() const {
     if (not this->isAllocated()) MSG_ABORT("Node is not allocated");
     println(0, "\nMW coefs");
     int kp1_d = this->getKp1_d();
@@ -228,18 +228,18 @@ template <int D> void MWNode<D>::printCoefs() const {
 
 /** @brief wraps the MW coefficients into an eigen vector object
  */
-template <int D> void MWNode<D>::getCoefs(Eigen::VectorXd &c) const {
+  template <int D, typename T> void MWNode<D, T>::getCoefs(Eigen::Matrix<T, Eigen::Dynamic, 1> &c) const {
     if (not this->isAllocated()) MSG_ABORT("Node is not allocated");
     if (not this->hasCoefs()) MSG_ABORT("Node has no coefs");
     if (this->n_coefs == 0) MSG_ABORT("ncoefs == 0");
 
-    c = VectorXd::Map(this->coefs, this->n_coefs);
+    c = Eigen::Matrix<T, Eigen::Dynamic, 1>::Map(this->coefs, this->n_coefs);
 }
 
 /** @brief sets all MW coefficients and the norms to zero
  *
  */
-template <int D> void MWNode<D>::zeroCoefs() {
+  template <int D, typename T> void MWNode<D, T>::zeroCoefs() {
     if (not this->isAllocated()) MSG_ABORT("Coefs not allocated " << *this);
 
     for (int i = 0; i < this->n_coefs; i++) { this->coefs[i] = 0.0; }
@@ -249,7 +249,7 @@ template <int D> void MWNode<D>::zeroCoefs() {
 
 /** @brief Attach a set of coefs to this node. Only used locally (the tree is not aware of this).
  */
-template <int D> void MWNode<D>::attachCoefs(double *coefs) {
+  template <int D, typename T> void MWNode<D, T>::attachCoefs(T *coefs) {
     this->coefs = coefs;
     this->setHasCoefs();
 }
@@ -264,7 +264,7 @@ template <int D> void MWNode<D>::attachCoefs(double *coefs) {
  * (given scaling/wavelet in each direction). Its size is then \f$
  * (k+1)^D \f$ and the index is between 0 and \f$ 2^D-1 \f$.
  */
-template <int D> void MWNode<D>::setCoefBlock(int block, int block_size, const double *c) {
+  template <int D, typename T> void MWNode<D, T>::setCoefBlock(int block, int block_size, const T *c) {
     if (not this->isAllocated()) MSG_ABORT("Coefs not allocated");
     for (int i = 0; i < block_size; i++) { this->coefs[block * block_size + i] = c[i]; }
 }
@@ -279,7 +279,7 @@ template <int D> void MWNode<D>::setCoefBlock(int block, int block_size, const d
  * (given scaling/wavelet in each direction). Its size is then \f$
  * (k+1)^D \f$ and the index is between 0 and \f$ 2^D-1 \f$.
  */
-template <int D> void MWNode<D>::addCoefBlock(int block, int block_size, const double *c) {
+  template <int D, typename T> void MWNode<D, T>::addCoefBlock(int block, int block_size, const T *c) {
     if (not this->isAllocated()) MSG_ABORT("Coefs not allocated");
     for (int i = 0; i < block_size; i++) { this->coefs[block * block_size + i] += c[i]; }
 }
@@ -293,7 +293,7 @@ template <int D> void MWNode<D>::addCoefBlock(int block, int block_size, const d
  * (given scaling/wavelet in each direction). Its size is then \f$
  * (k+1)^D \f$ and the index is between 0 and \f$ 2^D-1 \f$.
  */
-template <int D> void MWNode<D>::zeroCoefBlock(int block, int block_size) {
+  template <int D, typename T> void MWNode<D, T>::zeroCoefBlock(int block, int block_size) {
     if (not this->isAllocated()) MSG_ABORT("Coefs not allocated");
     for (int i = 0; i < block_size; i++) { this->coefs[block * block_size + i] = 0.0; }
 }
@@ -309,7 +309,7 @@ template <int D> void MWNode<D>::zeroCoefBlock(int block, int block_size) {
  * already be present and its memory allocated for this to work
  * properly.
  */
-template <int D> void MWNode<D>::giveChildrenCoefs(bool overwrite) {
+  template <int D, typename T> void MWNode<D, T>::giveChildrenCoefs(bool overwrite) {
     assert(this->isBranchNode());
     if (not this->isAllocated()) MSG_ABORT("Not allocated!");
     if (not this->hasCoefs()) MSG_ABORT("No coefficients!");
@@ -320,8 +320,8 @@ template <int D> void MWNode<D>::giveChildrenCoefs(bool overwrite) {
 
     // coeff of child should be have been allocated already here
     int stride = getMWChild(0).getNCoefs();
-    double *inp = getCoefs();
-    double *out = getMWChild(0).getCoefs();
+    T *inp = getCoefs();
+    T *out = getMWChild(0).getCoefs();
     bool readOnlyScaling = false;
     if (this->isGenNode()) readOnlyScaling = true;
 
@@ -345,9 +345,9 @@ template <int D> void MWNode<D>::giveChildrenCoefs(bool overwrite) {
  * node. The scaling coefficients of the selected child are then
  * copied/summed in the correct child node.
  */
-template <int D> void MWNode<D>::giveChildCoefs(int cIdx, bool overwrite) {
+  template <int D, typename T> void MWNode<D, T>::giveChildCoefs(int cIdx, bool overwrite) {
 
-    MWNode<D> node_i = *this;
+    MWNode<D, T> node_i = *this;
 
     node_i.mwTransform(Reconstruction);
 
@@ -355,7 +355,7 @@ template <int D> void MWNode<D>::giveChildCoefs(int cIdx, bool overwrite) {
     int nChildren = this->getTDim();
 
     if (this->children[cIdx] == nullptr) MSG_ABORT("Child does not exist!");
-    MWNode<D> &child = getMWChild(cIdx);
+    MWNode<D, T> &child = getMWChild(cIdx);
     if (overwrite) {
         child.setCoefBlock(0, kp1_d, &node_i.getCoefs()[cIdx * kp1_d]);
     } else {
@@ -371,12 +371,12 @@ template <int D> void MWNode<D>::giveChildCoefs(int cIdx, bool overwrite) {
  *
  * \warning This routine is only used in connection with Periodic Boundary Conditions
  */
-template <int D> void MWNode<D>::giveParentCoefs(bool overwrite) {
-    MWNode<D> node = *this;
-    MWNode<D> &parent = getMWParent();
+  template <int D, typename T> void MWNode<D, T>::giveParentCoefs(bool overwrite) {
+    MWNode<D, T> node = *this;
+    MWNode<D, T> &parent = getMWParent();
     int kp1_d = this->getKp1_d();
     if (node.getScale() == 0) {
-        NodeBox<D> &box = this->getMWTree().getRootBox();
+        NodeBox<D, T> &box = this->getMWTree().getRootBox();
         auto reverse = getTDim() - 1;
         for (auto i = 0; i < getTDim(); i++) { parent.setCoefBlock(i, kp1_d, &box.getNode(reverse - i).getCoefs()[0]); }
     } else {
@@ -393,11 +393,11 @@ template <int D> void MWNode<D>::giveParentCoefs(bool overwrite) {
  * them consecutively in the corresponding block of the parent,
  * following the usual bitwise notation.
  */
-template <int D> void MWNode<D>::copyCoefsFromChildren() {
+  template <int D, typename T> void MWNode<D, T>::copyCoefsFromChildren() {
     int kp1_d = this->getKp1_d();
     int nChildren = this->getTDim();
     for (int cIdx = 0; cIdx < nChildren; cIdx++) {
-        MWNode<D> &child = getMWChild(cIdx);
+      MWNode<D, T> &child = getMWChild(cIdx);
         if (not child.hasCoefs()) MSG_ABORT("Child has no coefs");
         setCoefBlock(cIdx, kp1_d, child.getCoefs());
     }
@@ -411,7 +411,7 @@ template <int D> void MWNode<D>::copyCoefsFromChildren() {
  * them consecutively in the corresponding block of the parent,
  * following the usual bitwise notation.
  */
-template <int D> void MWNode<D>::threadSafeGenChildren() {
+  template <int D, typename T> void MWNode<D, T>::threadSafeGenChildren() {
     if (tree->isLocal) { NOT_IMPLEMENTED_ABORT; }
     MRCPP_SET_OMP_LOCK();
     if (isLeafNode()) {
@@ -431,7 +431,7 @@ template <int D> void MWNode<D>::threadSafeGenChildren() {
  * NOTE: this routine assumes a 0/1 (scaling on child 0 and 1)
  *       representation, instead of s/d (scaling and wavelet).
  */
-template <int D> void MWNode<D>::cvTransform(int operation) {
+  template <int D, typename T> void MWNode<D, T>::cvTransform(int operation) {
     int kp1 = this->getKp1();
     int kp1_dm1 = math_utils::ipow(kp1, D - 1);
     int kp1_d = this->getKp1_d();
@@ -439,17 +439,17 @@ template <int D> void MWNode<D>::cvTransform(int operation) {
 
     auto sb = this->getMWTree().getMRA().getScalingBasis();
     const MatrixXd &S = sb.getCVMap(operation);
-    double o_vec[nCoefs];
-    double *out_vec = o_vec;
-    double *in_vec = this->coefs;
+    T o_vec[nCoefs];
+    T *out_vec = o_vec;
+    T *in_vec = this->coefs;
 
     for (int i = 0; i < D; i++) {
         for (int t = 0; t < this->getTDim(); t++) {
-            double *out = out_vec + t * kp1_d;
-            double *in = in_vec + t * kp1_d;
+            T *out = out_vec + t * kp1_d;
+            T *in = in_vec + t * kp1_d;
             math_utils::apply_filter(out, in, S, kp1, kp1_dm1, 0.0);
         }
-        double *tmp = in_vec;
+        T *tmp = in_vec;
         in_vec = out_vec;
         out_vec = tmp;
     }
@@ -473,8 +473,8 @@ template <int D> void MWNode<D>::cvTransform(int operation) {
     }
 }
 /* Old interpolating version, somewhat faster
-template<int D>
-void MWNode<D>::cvTransform(int operation) {
+template<int D, typename T>
+void MWNode<D, T>::cvTransform(int operation) {
     const ScalingBasis &sf = this->getMWTree().getMRA().getScalingBasis();
     if (sf.getScalingType() != Interpol) {
         NOT_IMPLEMENTED_ABORT;
@@ -538,7 +538,7 @@ void MWNode<D>::cvTransform(int operation) {
   *
   *  * @param[in] operation: compression (s0,s1->s,d) or reconstruction (s,d->s0,s1).
   */
-template <int D> void MWNode<D>::mwTransform(int operation) {
+  template <int D, typename T> void MWNode<D, T>::mwTransform(int operation) {
     int kp1 = this->getKp1();
     int kp1_dm1 = math_utils::ipow(kp1, D - 1);
     int kp1_d = this->getKp1_d();
@@ -546,20 +546,20 @@ template <int D> void MWNode<D>::mwTransform(int operation) {
     const MWFilter &filter = getMWTree().getMRA().getFilter();
     double overwrite = 0.0;
 
-    double o_vec[nCoefs];
-    double *out_vec = o_vec;
-    double *in_vec = this->coefs;
+    T o_vec[nCoefs];
+    T *out_vec = o_vec;
+    T *in_vec = this->coefs;
 
     for (int i = 0; i < D; i++) {
         int mask = 1 << i;
         for (int gt = 0; gt < this->getTDim(); gt++) {
-            double *out = out_vec + gt * kp1_d;
+            T *out = out_vec + gt * kp1_d;
             for (int ft = 0; ft < this->getTDim(); ft++) {
                 /* Operate in direction i only if the bits along other
                  * directions are identical. The bit of the direction we
                  * operate on determines the appropriate filter/operator */
                 if ((gt | mask) == (ft | mask)) {
-                    double *in = in_vec + ft * kp1_d;
+                    T *in = in_vec + ft * kp1_d;
                     int fIdx = 2 * ((gt >> i) & 1) + ((ft >> i) & 1);
                     const MatrixXd &oper = filter.getSubFilter(fIdx, operation);
                     math_utils::apply_filter(out, in, oper, kp1, kp1_dm1, overwrite);
@@ -568,7 +568,7 @@ template <int D> void MWNode<D>::mwTransform(int operation) {
             }
             overwrite = 0.0;
         }
-        double *tmp = in_vec;
+        T *tmp = in_vec;
         in_vec = out_vec;
         out_vec = tmp;
     }
@@ -578,19 +578,19 @@ template <int D> void MWNode<D>::mwTransform(int operation) {
 }
 
 /** @brief Set all norms to Undefined. */
-template <int D> void MWNode<D>::clearNorms() {
+  template <int D, typename T> void MWNode<D, T>::clearNorms() {
     this->squareNorm = -1.0;
     for (int i = 0; i < this->getTDim(); i++) { this->componentNorms[i] = -1.0; }
 }
 
 /** @brief Set all norms to zero. */
-template <int D> void MWNode<D>::zeroNorms() {
+  template <int D, typename T> void MWNode<D, T>::zeroNorms() {
     this->squareNorm = 0.0;
     for (int i = 0; i < this->getTDim(); i++) { this->componentNorms[i] = 0.0; }
 }
 
 /** @brief Calculate and store square norm and component norms, if allocated. */
-template <int D> void MWNode<D>::calcNorms() {
+  template <int D, typename T> void MWNode<D, T>::calcNorms() {
     this->squareNorm = 0.0;
     for (int i = 0; i < this->getTDim(); i++) {
         double norm_i = calcComponentNorm(i);
@@ -600,7 +600,7 @@ template <int D> void MWNode<D>::calcNorms() {
 }
 
 /** @brief Calculate and return the squared scaling norm. */
-template <int D> double MWNode<D>::getScalingNorm() const {
+  template <int D, typename T> double MWNode<D, T>::getScalingNorm() const {
     double sNorm = this->getComponentNorm(0);
     if (sNorm >= 0.0) {
         return sNorm * sNorm;
@@ -610,7 +610,7 @@ template <int D> double MWNode<D>::getScalingNorm() const {
 }
 
 /** @brief Calculate and return the squared wavelet norm. */
-template <int D> double MWNode<D>::getWaveletNorm() const {
+  template <int D, typename T> double MWNode<D, T>::getWaveletNorm() const {
     double wNorm = 0.0;
     for (int i = 1; i < this->getTDim(); i++) {
         double norm_i = this->getComponentNorm(i);
@@ -624,28 +624,28 @@ template <int D> double MWNode<D>::getWaveletNorm() const {
 }
 
 /** @brief Calculate the norm of one component (NOT the squared norm!). */
-template <int D> double MWNode<D>::calcComponentNorm(int i) const {
+  template <int D, typename T> double MWNode<D, T>::calcComponentNorm(int i) const {
     if (this->isGenNode() and i != 0) return 0.0;
     assert(this->isAllocated());
     assert(this->hasCoefs());
 
-    const double *c = this->getCoefs();
+    const T *c = this->getCoefs();
     int size = this->getKp1_d();
     int start = i * size;
 
     double sq_norm = 0.0;
-#ifdef HAVE_BLAS
-    sq_norm = cblas_ddot(size, &c[start], 1, &c[start], 1);
-#else
-    for (int i = start; i < start + size; i++) { sq_norm += c[i] * c[i]; }
-#endif
+//#ifdef HAVE_BLAS
+//    sq_norm = cblas_ddot(size, &c[start], 1, &c[start], 1);
+//#else
+    for (int i = start; i < start + size; i++) { sq_norm += std::norm(c[i]); }
+//#endif
     return std::sqrt(sq_norm);
 }
 
 /** @brief Update the coefficients of the node by a mw transform of the scaling
  * coefficients of the children.
  */
-template <int D> void MWNode<D>::reCompress() {
+  template <int D, typename T> void MWNode<D, T>::reCompress() {
     if (this->isGenNode()) NOT_IMPLEMENTED_ABORT;
     if (this->isBranchNode()) {
         if (not this->isAllocated()) MSG_ABORT("Coefs not allocated");
@@ -662,12 +662,12 @@ template <int D> void MWNode<D>::reCompress() {
  * @param[in] splitFac: factor used in the split check (larger factor means tighter threshold for finer nodes)
  * @param[in] absPrec: flag to switch from relative (false) to absolute (true) precision.
  */
-template <int D> bool MWNode<D>::crop(double prec, double splitFac, bool absPrec) {
+  template <int D, typename T> bool MWNode<D, T>::crop(double prec, double splitFac, bool absPrec) {
     if (this->isEndNode()) {
         return true;
     } else {
         for (int i = 0; i < this->getTDim(); i++) {
-            MWNode<D> &child = *this->children[i];
+	  MWNode<D, T> &child = *this->children[i];
             if (child.crop(prec, splitFac, absPrec)) {
                 if (tree_utils::split_check(*this, prec, splitFac, absPrec) == false) {
                     this->deleteChildren();
@@ -679,15 +679,15 @@ template <int D> bool MWNode<D>::crop(double prec, double splitFac, bool absPrec
     return false;
 }
 
-template <int D> void MWNode<D>::createChildren(bool coefs) {
+  template <int D, typename T> void MWNode<D, T>::createChildren(bool coefs) {
     NOT_REACHED_ABORT;
 }
 
-template <int D> void MWNode<D>::genChildren() {
+  template <int D, typename T> void MWNode<D, T>::genChildren() {
     NOT_REACHED_ABORT;
 }
 
-template <int D> void MWNode<D>::genParent() {
+  template <int D, typename T> void MWNode<D, T>::genParent() {
     NOT_REACHED_ABORT;
 }
 
@@ -696,11 +696,11 @@ template <int D> void MWNode<D>::genParent() {
  * @details
  * Leaves node as LeafNode and children[] as null pointer.
  */
-template <int D> void MWNode<D>::deleteChildren() {
+  template <int D, typename T> void MWNode<D, T>::deleteChildren() {
     if (this->isLeafNode()) return;
     for (int cIdx = 0; cIdx < getTDim(); cIdx++) {
         if (this->children[cIdx] != nullptr) {
-            MWNode<D> &child = getMWChild(cIdx);
+	  MWNode<D, T> &child = getMWChild(cIdx);
             child.deleteChildren();
             child.dealloc();
         }
@@ -711,9 +711,9 @@ template <int D> void MWNode<D>::deleteChildren() {
 }
 
 /** @brief Recursive deallocation of parent and all their forefathers. */
-template <int D> void MWNode<D>::deleteParent() {
+  template <int D, typename T> void MWNode<D, T>::deleteParent() {
     if (this->parent == nullptr) return;
-    MWNode<D> &parent = getMWParent();
+    MWNode<D, T> &parent = getMWParent();
     parent.deleteParent();
     parent.dealloc();
     this->parentSerialIx = -1;
@@ -722,7 +722,7 @@ template <int D> void MWNode<D>::deleteParent() {
 
 
 /** @brief Deallocation of all generated nodes . */
-template <int D> void MWNode<D>::deleteGenerated() {
+  template <int D, typename T> void MWNode<D, T>::deleteGenerated() {
     if (this->isBranchNode()) {
         if (this->isEndNode()) {
             this->deleteChildren();
@@ -733,7 +733,7 @@ template <int D> void MWNode<D>::deleteGenerated() {
 }
 
 /** @brief returns the coordinates of the centre of the node */
-template <int D> Coord<D> MWNode<D>::getCenter() const {
+  template <int D, typename T> Coord<D> MWNode<D, T>::getCenter() const {
     auto two_n = std::pow(2.0, -getScale());
     auto scaling_factor = getMWTree().getMRA().getWorldBox().getScalingFactors();
     auto &l = getNodeIndex();
@@ -743,7 +743,7 @@ template <int D> Coord<D> MWNode<D>::getCenter() const {
 }
 
 /** @brief returns the upper bounds of the D-interval defining the node  */
-template <int D> Coord<D> MWNode<D>::getUpperBounds() const {
+  template <int D, typename T> Coord<D> MWNode<D, T>::getUpperBounds() const {
     auto two_n = std::pow(2.0, -getScale());
     auto scaling_factor = getMWTree().getMRA().getWorldBox().getScalingFactors();
     auto &l = getNodeIndex();
@@ -753,7 +753,7 @@ template <int D> Coord<D> MWNode<D>::getUpperBounds() const {
 }
 
 /** @brief returns the lower bounds of the D-interval defining the node  */
-template <int D> Coord<D> MWNode<D>::getLowerBounds() const {
+  template <int D, typename T> Coord<D> MWNode<D, T>::getLowerBounds() const {
     auto two_n = std::pow(2.0, -getScale());
     auto scaling_factor = getMWTree().getMRA().getWorldBox().getScalingFactors();
     auto &l = getNodeIndex();
@@ -770,7 +770,7 @@ template <int D> Coord<D> MWNode<D>::getLowerBounds() const {
  * to be followed at the current scale in oder to get to the requested
  * node at the final scale. The result is the index of the child needed.
  * The index is obtained by bit manipulation of of the translation indices. */
-template <int D> int MWNode<D>::getChildIndex(const NodeIndex<D> &nIdx) const {
+  template <int D, typename T> int MWNode<D, T>::getChildIndex(const NodeIndex<D> &nIdx) const {
     assert(isAncestor(nIdx));
     int cIdx = 0;
     int diffScale = nIdx.getScale() - getScale() - 1;
@@ -790,7 +790,7 @@ template <int D> int MWNode<D>::getChildIndex(const NodeIndex<D> &nIdx) const {
  *
  * @detailsGiven a point in space, determines which child should be followed
  * to get to the corresponding terminal node. */
-template <int D> int MWNode<D>::getChildIndex(const Coord<D> &r) const {
+  template <int D, typename T> int MWNode<D, T>::getChildIndex(const Coord<D> &r) const {
     assert(hasCoord(r));
     int cIdx = 0;
     double sFac = std::pow(2.0, -getScale());
@@ -815,7 +815,7 @@ template <int D> int MWNode<D>::getChildIndex(const Coord<D> &r) const {
  * grid of quadrature points.
  *
  */
-template <int D> void MWNode<D>::getPrimitiveQuadPts(MatrixXd &pts) const {
+  template <int D, typename T> void MWNode<D, T>::getPrimitiveQuadPts(MatrixXd &pts) const {
     int kp1 = this->getKp1();
     pts = MatrixXd::Zero(D, kp1);
 
@@ -840,7 +840,7 @@ template <int D> void MWNode<D>::getPrimitiveQuadPts(MatrixXd &pts) const {
  * nodes.
  *
  */
-template <int D> void MWNode<D>::getPrimitiveChildPts(MatrixXd &pts) const {
+  template <int D, typename T> void MWNode<D, T>::getPrimitiveChildPts(MatrixXd &pts) const {
     int kp1 = this->getKp1();
     pts = MatrixXd::Zero(D, 2 * kp1);
 
@@ -865,7 +865,7 @@ template <int D> void MWNode<D>::getPrimitiveChildPts(MatrixXd &pts) const {
  * vectors of quadrature points.
  *
  */
-template <int D> void MWNode<D>::getExpandedQuadPts(Eigen::MatrixXd &pts) const {
+  template <int D, typename T> void MWNode<D, T>::getExpandedQuadPts(Eigen::MatrixXd &pts) const {
     MatrixXd prim_pts;
     getPrimitiveQuadPts(prim_pts);
 
@@ -889,7 +889,7 @@ template <int D> void MWNode<D>::getExpandedQuadPts(Eigen::MatrixXd &pts) const
  * vectors of quadrature points.
  *
  */
-template <int D> void MWNode<D>::getExpandedChildPts(MatrixXd &pts) const {
+  template <int D, typename T> void MWNode<D, T>::getExpandedChildPts(MatrixXd &pts) const {
     MatrixXd prim_pts;
     getPrimitiveChildPts(prim_pts);
 
@@ -923,7 +923,7 @@ template <int D> void MWNode<D>::getExpandedChildPts(MatrixXd &pts) const {
  * the node does not exist, or if it is a GenNode. Recursion starts at at this
  * node and ASSUMES the requested node is in fact decending from this node.
  */
-template <int D> const MWNode<D> *MWNode<D>::retrieveNodeNoGen(const NodeIndex<D> &idx) const {
+  template <int D, typename T> const MWNode<D, T> *MWNode<D, T>::retrieveNodeNoGen(const NodeIndex<D> &idx) const {
     if (getScale() == idx.getScale()) { // we're done
         assert(getNodeIndex() == idx);
         return this;
@@ -947,7 +947,7 @@ template <int D> const MWNode<D> *MWNode<D>::retrieveNodeNoGen(const NodeIndex<D
  * the node does not exist, or if it is a GenNode. Recursion starts at at this
  * node and ASSUMES the requested node is in fact decending from this node.
  */
-template <int D> MWNode<D> *MWNode<D>::retrieveNodeNoGen(const NodeIndex<D> &idx) {
+  template <int D, typename T> MWNode<D, T> *MWNode<D, T>::retrieveNodeNoGen(const NodeIndex<D> &idx) {
     if (getScale() == idx.getScale()) { // we're done
         assert(getNodeIndex() == idx);
         return this;
@@ -973,7 +973,7 @@ template <int D> MWNode<D> *MWNode<D>::retrieveNodeNoGen(const NodeIndex<D> &idx
  * this node and ASSUMES the requested node is in fact decending from
  * this node.
  */
-template <int D> const MWNode<D> *MWNode<D>::retrieveNodeOrEndNode(const Coord<D> &r, int depth) const {
+  template <int D, typename T> const MWNode<D, T> *MWNode<D, T>::retrieveNodeOrEndNode(const Coord<D> &r, int depth) const {
     if (getDepth() == depth or this->isEndNode()) { return this; }
     int cIdx = getChildIndex(r);
     assert(this->children[cIdx] != nullptr);
@@ -992,7 +992,7 @@ template <int D> const MWNode<D> *MWNode<D>::retrieveNodeOrEndNode(const Coord<D
  * this node and ASSUMES the requested node is in fact decending from
  * this node.
  */
-template <int D> MWNode<D> *MWNode<D>::retrieveNodeOrEndNode(const Coord<D> &r, int depth) {
+  template <int D, typename T> MWNode<D, T> *MWNode<D, T>::retrieveNodeOrEndNode(const Coord<D> &r, int depth) {
     if (getDepth() == depth or this->isEndNode()) { return this; }
     int cIdx = getChildIndex(r);
     assert(this->children[cIdx] != nullptr);
@@ -1010,7 +1010,7 @@ template <int D> MWNode<D> *MWNode<D>::retrieveNodeOrEndNode(const Coord<D> &r,
  * this node and ASSUMES the requested node is in fact decending from
  * this node.
  */
-template <int D> const MWNode<D> *MWNode<D>::retrieveNodeOrEndNode(const NodeIndex<D> &idx) const {
+  template <int D, typename T> const MWNode<D, T> *MWNode<D, T>::retrieveNodeOrEndNode(const NodeIndex<D> &idx) const {
     if (getScale() == idx.getScale()) { // we're done
         assert(getNodeIndex() == idx);
         return this;
@@ -1036,7 +1036,7 @@ template <int D> const MWNode<D> *MWNode<D>::retrieveNodeOrEndNode(const NodeInd
  * this node and ASSUMES the requested node is in fact decending from
  * this node.
  */
-template <int D> MWNode<D> *MWNode<D>::retrieveNodeOrEndNode(const NodeIndex<D> &idx) {
+  template <int D, typename T> MWNode<D, T> *MWNode<D, T>::retrieveNodeOrEndNode(const NodeIndex<D> &idx) {
     if (getScale() == idx.getScale()) { // we're done
         assert(getNodeIndex() == idx);
         return this;
@@ -1061,7 +1061,7 @@ template <int D> MWNode<D> *MWNode<D>::retrieveNodeOrEndNode(const NodeIndex<D>
  * that does not exist. Recursion starts at this node and ASSUMES the
  * requested node is in fact decending from this node.
  */
-template <int D> MWNode<D> *MWNode<D>::retrieveNode(const Coord<D> &r, int depth) {
+  template <int D, typename T> MWNode<D, T> *MWNode<D, T>::retrieveNode(const Coord<D> &r, int depth) {
     if (depth < 0) MSG_ABORT("Invalid argument");
 
     if (getDepth() == depth) { return this; }
@@ -1082,13 +1082,15 @@ template <int D> MWNode<D> *MWNode<D>::retrieveNode(const Coord<D> &r, int depth
  * does not exist. Recursion starts at this node and ASSUMES the requested
  * node is in fact descending from this node.
  */
-template <int D> MWNode<D> *MWNode<D>::retrieveNode(const NodeIndex<D> &idx) {
+  template <int D, typename T> MWNode<D, T> *MWNode<D, T>::retrieveNode(const NodeIndex<D> &idx) {
     if (getScale() == idx.getScale()) { // we're done
         if (tree->isLocal) {
+	   NOT_IMPLEMENTED_ABORT;
             // has to fetch coeff in Bank. NOT USED YET
-            int ncoefs = (1 << D) * this->getKp1_d();
-            coefs = new double[ncoefs]; // TODO must be cleaned at some stage
-            tree->getNodeCoeff(idx, coefs);
+            //int ncoefs = (1 << D) * this->getKp1_d();
+            //coefs = new double[ncoefs]; // TODO must be cleaned at some stage
+            //coefs = new double[ncoefs]; // TODO must be cleaned at some stage
+            //tree->getNodeCoeff(idx, coefs);
         }
         assert(getNodeIndex() == idx);
         return this;
@@ -1113,7 +1115,7 @@ template <int D> MWNode<D> *MWNode<D>::retrieveNode(const NodeIndex<D> &idx) {
  * does not exist. Recursion starts at this node and ASSUMES the requested
  * node is in fact related to this node.
  */
-template <int D> MWNode<D> *MWNode<D>::retrieveParent(const NodeIndex<D> &idx) {
+  template <int D, typename T> MWNode<D, T> *MWNode<D, T>::retrieveParent(const NodeIndex<D> &idx) {
     if (getScale() < idx.getScale()) MSG_ABORT("Scale error")
     if (getScale() == idx.getScale()) return this;
     if (this->parent == nullptr) {
@@ -1132,7 +1134,7 @@ template <int D> MWNode<D> *MWNode<D>::retrieveParent(const NodeIndex<D> &idx) {
  * found, do not generate any new node, but rather give the value of the norm
  * assuming the function is uniformly distributed within the node.
  */
-template <int D> double MWNode<D>::getNodeNorm(const NodeIndex<D> &idx) const {
+  template <int D, typename T> double MWNode<D, T>::getNodeNorm(const NodeIndex<D> &idx) const {
     if (this->getScale() == idx.getScale()) { // we're done
         assert(getNodeIndex() == idx);
         return std::sqrt(this->squareNorm);
@@ -1150,7 +1152,7 @@ template <int D> double MWNode<D>::getNodeNorm(const NodeIndex<D> &idx) const {
  *
  * @param[in] r: point coordinates
  */
-template <int D> bool MWNode<D>::hasCoord(const Coord<D> &r) const {
+  template <int D, typename T> bool MWNode<D, T>::hasCoord(const Coord<D> &r) const {
     double sFac = std::pow(2.0, -getScale());
     const NodeIndex<D> &l = getNodeIndex();
     //    println(1, "[" << r[0] << "," << r[1] << "," << r[2] << "]");
@@ -1168,7 +1170,7 @@ template <int D> bool MWNode<D>::hasCoord(const Coord<D> &r) const {
 
 /** Testing if nodes are compatible wrt NodeIndex and Tree (order, rootScale,
  * relPrec, etc). */
-template <int D> bool MWNode<D>::isCompatible(const MWNode<D> &node) {
+  template <int D, typename T> bool MWNode<D, T>::isCompatible(const MWNode<D, T> &node) {
     NOT_IMPLEMENTED_ABORT;
     //    if (nodeIndex != node.nodeIndex) {
     //        println(0, "nodeIndex mismatch" << std::endl);
@@ -1186,7 +1188,7 @@ template <int D> bool MWNode<D>::isCompatible(const MWNode<D> &node) {
  *
  * @param[in] idx: the NodeIndex of the requested node
  */
-template <int D> bool MWNode<D>::isAncestor(const NodeIndex<D> &idx) const {
+  template <int D, typename T> bool MWNode<D, T>::isAncestor(const NodeIndex<D> &idx) const {
     int relScale = idx.getScale() - getScale();
     if (relScale < 0) return false;
     const NodeIndex<D> &l = getNodeIndex();
@@ -1197,7 +1199,7 @@ template <int D> bool MWNode<D>::isAncestor(const NodeIndex<D> &idx) const {
     return true;
 }
 
-template <int D> bool MWNode<D>::isDecendant(const NodeIndex<D> &idx) const {
+  template <int D, typename T> bool MWNode<D, T>::isDecendant(const NodeIndex<D> &idx) const {
     NOT_IMPLEMENTED_ABORT;
 }
 
@@ -1205,7 +1207,7 @@ template <int D> bool MWNode<D>::isDecendant(const NodeIndex<D> &idx) const {
  *
  * @param[in] o: the output stream
  */
-template <int D> std::ostream &MWNode<D>::print(std::ostream &o) const {
+  template <int D, typename T> std::ostream &MWNode<D, T>::print(std::ostream &o) const {
     std::string flags = "       ";
     o << getNodeIndex();
     if (isRootNode()) flags[0] = 'R';
@@ -1236,14 +1238,14 @@ template <int D> std::ostream &MWNode<D>::print(std::ostream &o) const {
  * normalization is such that a constant function gives constant value,
  * i.e. *not* same normalization as a squareNorm
  */
-template <int D> void MWNode<D>::setMaxSquareNorm() {
+  template <int D, typename T> void MWNode<D, T>::setMaxSquareNorm() {
     auto n = this->getScale();
     this->maxWSquareNorm = calcScaledWSquareNorm();
     this->maxSquareNorm = calcScaledSquareNorm();
 
     if (not this->isEndNode()) {
         for (int i = 0; i < this->getTDim(); i++) {
-            MWNode<D> &child = *this->children[i];
+	  MWNode<D, T> &child = *this->children[i];
             child.setMaxSquareNorm();
             this->maxSquareNorm = std::max(this->maxSquareNorm, child.maxSquareNorm);
             this->maxWSquareNorm = std::max(this->maxWSquareNorm, child.maxWSquareNorm);
@@ -1252,20 +1254,23 @@ template <int D> void MWNode<D>::setMaxSquareNorm() {
 }
 /** @brief recursively reset maxSquaredNorm and maxWSquareNorm of parent and descendants to value -1
  */
-template <int D> void MWNode<D>::resetMaxSquareNorm() {
+  template <int D, typename T> void MWNode<D, T>::resetMaxSquareNorm() {
     auto n = this->getScale();
     this->maxSquareNorm = -1.0;
     this->maxWSquareNorm = -1.0;
     if (not this->isEndNode()) {
         for (int i = 0; i < this->getTDim(); i++) {
-            MWNode<D> &child = *this->children[i];
+	  MWNode<D, T> &child = *this->children[i];
             child.resetMaxSquareNorm();
         }
     }
 }
 
-template class MWNode<1>;
-template class MWNode<2>;
-template class MWNode<3>;
+  template class MWNode<1, double>;
+  template class MWNode<2, double>;
+  template class MWNode<3, double>;
+  template class MWNode<1, ComplexDouble>;
+  template class MWNode<2, ComplexDouble>;
+  template class MWNode<3, ComplexDouble>;
 
 } // namespace mrcpp
diff --git a/src/trees/MWNode.h b/src/trees/MWNode.h
index d7d7a18a7..ed25762b4 100644
--- a/src/trees/MWNode.h
+++ b/src/trees/MWNode.h
@@ -30,6 +30,7 @@
 
 #include "MRCPP/macros.h"
 #include "utils/omp_utils.h"
+#include "utils/math_utils.h"
 
 #include "HilbertPath.h"
 #include "MWTree.h"
@@ -49,12 +50,12 @@ namespace mrcpp {
  * translation index, the norm, pointers to parent node and child
  * nodes, pointer to the corresponding MWTree etc... See member and
  * data descriptions for details.
- * 
+ *
  */
-template <int D> class MWNode {
+template <int D, typename T> class MWNode {
 public:
-    MWNode(const MWNode<D> &node, bool allocCoef = true, bool SetCoef = true);
-    MWNode<D> &operator=(const MWNode<D> &node) = delete;
+    MWNode(const MWNode<D, T> &node, bool allocCoef = true, bool SetCoef = true);
+    MWNode<D , T> &operator=(const MWNode<D , T> &node) = delete;
     virtual ~MWNode();
 
     int getKp1() const { return getMWTree().getKp1(); }
@@ -76,7 +77,7 @@ template <int D> class MWNode {
     Coord<D> getLowerBounds() const;
 
     bool hasCoord(const Coord<D> &r) const;
-    bool isCompatible(const MWNode<D> &node);
+    bool isCompatible(const MWNode<D, T> &node);
     bool isAncestor(const NodeIndex<D> &idx) const;
     bool isDecendant(const NodeIndex<D> &idx) const;
 
@@ -89,30 +90,30 @@ template <int D> class MWNode {
     double getComponentNorm(int i) const { return this->componentNorms[i]; }
 
     int getNCoefs() const { return this->n_coefs; }
-    void getCoefs(Eigen::VectorXd &c) const;
+    void getCoefs(Eigen::Matrix<T, Eigen::Dynamic, 1> &c) const;
     void printCoefs() const;
 
-    double *getCoefs() { return this->coefs; }
-    const double *getCoefs() const { return this->coefs; }
+    T *getCoefs() { return this->coefs; }
+    const T *getCoefs() const { return this->coefs; }
 
     void getPrimitiveQuadPts(Eigen::MatrixXd &pts) const;
     void getPrimitiveChildPts(Eigen::MatrixXd &pts) const;
     void getExpandedQuadPts(Eigen::MatrixXd &pts) const;
     void getExpandedChildPts(Eigen::MatrixXd &pts) const;
 
-    MWTree<D> &getMWTree() { return static_cast<MWTree<D> &>(*this->tree); }
-    MWNode<D> &getMWParent() { return static_cast<MWNode<D> &>(*this->parent); }
-    MWNode<D> &getMWChild(int i) { return static_cast<MWNode<D> &>(*this->children[i]); }
+    MWTree<D, T> &getMWTree() { return static_cast<MWTree<D, T> &>(*this->tree); }
+    MWNode<D , T> &getMWParent() { return static_cast<MWNode<D , T> &>(*this->parent); }
+    MWNode<D , T> &getMWChild(int i) { return static_cast<MWNode<D , T> &>(*this->children[i]); }
 
-    const MWTree<D> &getMWTree() const { return static_cast<const MWTree<D> &>(*this->tree); }
-    const MWNode<D> &getMWParent() const { return static_cast<const MWNode<D> &>(*this->parent); }
-    const MWNode<D> &getMWChild(int i) const { return static_cast<const MWNode<D> &>(*this->children[i]); }
+    const MWTree<D, T> &getMWTree() const { return static_cast<const MWTree<D, T> &>(*this->tree); }
+    const MWNode<D , T> &getMWParent() const { return static_cast<const MWNode<D , T> &>(*this->parent); }
+    const MWNode<D , T> &getMWChild(int i) const { return static_cast<const MWNode<D , T> &>(*this->children[i]); }
 
     void zeroCoefs();
-    void setCoefBlock(int block, int block_size, const double *c);
-    void addCoefBlock(int block, int block_size, const double *c);
+    void setCoefBlock(int block, int block_size, const T *c);
+    void addCoefBlock(int block, int block_size, const T *c);
     void zeroCoefBlock(int block, int block_size);
-    void attachCoefs(double *coefs);
+    void attachCoefs(T *coefs);
 
     void calcNorms();
     void zeroNorms();
@@ -154,34 +155,35 @@ template <int D> class MWNode {
     void clearIsRootNode() { CLEAR_BITS(status, FlagRootNode); }
     void clearIsAllocated() { CLEAR_BITS(status, FlagAllocated); }
 
-    friend std::ostream &operator<<(std::ostream &o, const MWNode<D> &nd) { return nd.print(o); }
+    friend std::ostream &operator<<(std::ostream &o, const MWNode<D , T> &nd) { return nd.print(o); }
 
-    friend class TreeBuilder<D>;
-    friend class MultiplicationCalculator<D>;
-    friend class NodeAllocator<D>;
-    friend class MWTree<D>;
-    friend class FunctionTree<D>;
+    friend class TreeBuilder<D, T>;
+    friend class MultiplicationCalculator<D, T>;
+    friend class NodeAllocator<D, T>;
+    friend class MWTree<D, T>;
+    friend class FunctionTree<D, T>;
     friend class OperatorTree;
-    friend class FunctionNode<D>;
+    friend class FunctionNode<D, T>;
     friend class OperatorNode;
-    friend class DerivativeCalculator<D>;
+    friend class DerivativeCalculator<D, T>;
+    bool isComplex = false; //TODO put as one of the flags
 
 protected:
-    MWTree<D> *tree{nullptr};    ///< Tree the node belongs to
-    MWNode<D> *parent{nullptr};  ///< Parent node
-    MWNode<D> *children[1 << D]; ///< 2^D children
+    MWTree<D, T> *tree{nullptr};    ///< Tree the node belongs to
+    MWNode<D , T> *parent{nullptr};  ///< Parent node
+    MWNode<D , T> *children[1 << D]; ///< 2^D children
 
     double squareNorm{-1.0};       ///< Squared norm of all 2^D (k+1)^D coefficients
     double componentNorms[1 << D]; ///< Squared norms of the separeted 2^D components
     double maxSquareNorm{-1.0};    ///< Largest squared norm among itself and descendants.
     double maxWSquareNorm{-1.0};   ///< Largest wavelet squared norm among itself and descendants.
                                    ///< NB: must be set before used.
-    double *coefs{nullptr};     ///< the 2^D (k+1)^D MW coefficients
-                                ///< For example, in case of a one dimensional function \f$ f \f$
-                                ///< this array equals \f$ s_0, \ldots, s_k, d_0, \ldots, d_k \f$,
-                                ///< where scaling coefficients \f$ s_j = s_{jl}^n(f) \f$
-                                ///< and wavelet coefficients \f$ d_j = d_{jl}^n(f) \f$.
-                                ///< Here \f$ n, l \f$ are unique for every node.
+    T *coefs{nullptr};     ///< the 2^D (k+1)^D MW coefficients
+                           ///< For example, in case of a one dimensional function \f$ f \f$
+                           ///< this array equals \f$ s_0, \ldots, s_k, d_0, \ldots, d_k \f$,
+                           ///< where scaling coefficients \f$ s_j = s_{jl}^n(f) \f$
+                           ///< and wavelet coefficients \f$ d_j = d_{jl}^n(f) \f$.
+                           ///< Here \f$ n, l \f$ are unique for every node.
     int n_coefs{0};
 
     int serialIx{-1};       ///< index in serial Tree
@@ -192,9 +194,9 @@ template <int D> class MWNode {
     HilbertPath<D> hilbertPath; ///< To be documented
 
     MWNode();
-    MWNode(MWTree<D> *tree, int rIdx);
-    MWNode(MWTree<D> *tree, const NodeIndex<D> &idx);
-    MWNode(MWNode<D> *parent, int cIdx);
+    MWNode(MWTree<D, T> *tree, int rIdx);
+    MWNode(MWTree<D, T> *tree, const NodeIndex<D> &idx);
+    MWNode(MWNode<D, T> *parent, int cIdx);
 
     virtual void dealloc();
 
@@ -219,20 +221,20 @@ template <int D> class MWNode {
     int getChildIndex(const NodeIndex<D> &nIdx) const;
     int getChildIndex(const Coord<D> &r) const;
 
-    bool diffBranch(const MWNode<D> &rhs) const;
+    bool diffBranch(const MWNode<D , T> &rhs) const;
 
-    MWNode<D> *retrieveNode(const Coord<D> &r, int depth);
-    MWNode<D> *retrieveNode(const NodeIndex<D> &idx);
-    MWNode<D> *retrieveParent(const NodeIndex<D> &idx);
+    MWNode<D , T> *retrieveNode(const Coord<D> &r, int depth);
+    MWNode<D , T> *retrieveNode(const NodeIndex<D> &idx);
+    MWNode<D , T> *retrieveParent(const NodeIndex<D> &idx);
 
-    const MWNode<D> *retrieveNodeNoGen(const NodeIndex<D> &idx) const;
-    MWNode<D> *retrieveNodeNoGen(const NodeIndex<D> &idx);
+    const MWNode<D , T> *retrieveNodeNoGen(const NodeIndex<D> &idx) const;
+    MWNode<D , T> *retrieveNodeNoGen(const NodeIndex<D> &idx);
 
-    const MWNode<D> *retrieveNodeOrEndNode(const Coord<D> &r, int depth) const;
-    MWNode<D> *retrieveNodeOrEndNode(const Coord<D> &r, int depth);
+    const MWNode<D , T> *retrieveNodeOrEndNode(const Coord<D> &r, int depth) const;
+    MWNode<D , T> *retrieveNodeOrEndNode(const Coord<D> &r, int depth);
 
-    const MWNode<D> *retrieveNodeOrEndNode(const NodeIndex<D> &idx) const;
-    MWNode<D> *retrieveNodeOrEndNode(const NodeIndex<D> &idx);
+    const MWNode<D , T> *retrieveNodeOrEndNode(const NodeIndex<D> &idx) const;
+    MWNode<D , T> *retrieveNodeOrEndNode(const NodeIndex<D> &idx);
 
     void threadSafeGenChildren();
     void deleteGenerated();
diff --git a/src/trees/MWTree.cpp b/src/trees/MWTree.cpp
index 583fb1fc1..c849517da 100644
--- a/src/trees/MWTree.cpp
+++ b/src/trees/MWTree.cpp
@@ -49,8 +49,8 @@ namespace mrcpp {
  * root nodes. The information for the root node configuration to use
  * is in the mra object which is passed to the constructor.
  */
-template <int D>
-MWTree<D>::MWTree(const MultiResolutionAnalysis<D> &mra, const std::string &n)
+  template <int D, typename T>
+MWTree<D, T>::MWTree(const MultiResolutionAnalysis<D> &mra, const std::string &n)
         : MRA(mra)
         , order(mra.getOrder()) /// polynomial order
         , kp1_d(math_utils::ipow(mra.getOrder() + 1, D)) ///nr of scaling coefficients \f$ (k+1)^D \f$
@@ -61,7 +61,7 @@ MWTree<D>::MWTree(const MultiResolutionAnalysis<D> &mra, const std::string &n)
 }
 
 /** @brief MWTree destructor. */
-template <int D> MWTree<D>::~MWTree() {
+template <int D, typename T> MWTree<D, T>::~MWTree() {
     this->endNodeTable.clear();
     if (this->nodesAtDepth.size() != 1) MSG_ERROR("Nodes at depth != 1 -> " << this->nodesAtDepth.size());
     if (this->nodesAtDepth[0] != 0) MSG_ERROR("Nodes at depth 0 != 0 -> " << this->nodesAtDepth[0]);
@@ -73,9 +73,9 @@ template <int D> MWTree<D>::~MWTree() {
   * including the root nodes. Derived classes will call this method
   * when the object is deleted.
   */
-template <int D> void MWTree<D>::deleteRootNodes() {
+template <int D, typename T> void MWTree<D, T>::deleteRootNodes() {
     for (int i = 0; i < this->rootBox.size(); i++) {
-        MWNode<D> &root = this->getRootMWNode(i);
+        MWNode<D, T> &root = this->getRootMWNode(i);
         root.deleteChildren();
         root.dealloc();
         this->rootBox.clearNode(i);
@@ -90,9 +90,9 @@ template <int D> void MWTree<D>::deleteRootNodes() {
  * nodes, (nodeChunks in NodeAllocator) is NOT released, but is
  * immediately available to the new function.
  */
-template <int D> void MWTree<D>::clear() {
+template <int D, typename T> void MWTree<D, T>::clear() {
     for (int i = 0; i < this->rootBox.size(); i++) {
-        MWNode<D> &root = this->getRootMWNode(i);
+        MWNode<D, T> &root = this->getRootMWNode(i);
         root.deleteChildren();
         root.clearHasCoefs();
         root.clearNorms();
@@ -106,10 +106,10 @@ template <int D> void MWTree<D>::clear() {
  * @details The norm is calculated using endNodes only. The specific
  * type of norm which is computed will depend on the derived class
  */
-template <int D> void MWTree<D>::calcSquareNorm() {
+template <int D, typename T> void MWTree<D, T>::calcSquareNorm() {
     double treeNorm = 0.0;
     for (int n = 0; n < this->getNEndNodes(); n++) {
-        const MWNode<D> &node = getEndMWNode(n);
+        const MWNode<D, T> &node = getEndMWNode(n);
         assert(node.hasCoefs());
         treeNorm += node.getSquareNorm();
     }
@@ -126,9 +126,9 @@ template <int D> void MWTree<D>::calcSquareNorm() {
  * @details It performs a Multiwavlet transform of the whole tree. The
  * input parameters will specify the direction (upwards or downwards)
  * and whether the result is added to the coefficients or it
- * overwrites them. See the documentation for the #mwTransformUp 
+ * overwrites them. See the documentation for the #mwTransformUp
  * and #mwTransformDown for details.
- * \f[ 
+ * \f[
  * \pmatrix{
  * s_{nl}\\
  * d_{nl}
@@ -139,7 +139,7 @@ template <int D> void MWTree<D>::calcSquareNorm() {
  * }
  * \f]
  */
-template <int D> void MWTree<D>::mwTransform(int type, bool overwrite) {
+template <int D, typename T> void MWTree<D, T>::mwTransform(int type, bool overwrite) {
     switch (type) {
         case TopDown:
             mwTransformDown(overwrite);
@@ -162,8 +162,8 @@ template <int D> void MWTree<D>::mwTransform(int type, bool overwrite) {
  * projection to purify the coefficients obtained by quadrature at
  * coarser scales which are therefore not precise enough.
  */
-template <int D> void MWTree<D>::mwTransformUp() {
-    std::vector<MWNodeVector<D>> nodeTable;
+template <int D, typename T> void MWTree<D, T>::mwTransformUp() {
+    std::vector<MWNodeVector<D, T>> nodeTable;
     tree_utils::make_node_table(*this, nodeTable);
 #pragma omp parallel shared(nodeTable) num_threads(mrcpp_get_num_threads())
     {
@@ -172,7 +172,7 @@ template <int D> void MWTree<D>::mwTransformUp() {
             int nNodes = nodeTable[n].size();
 #pragma omp for schedule(guided)
             for (int i = 0; i < nNodes; i++) {
-                MWNode<D> &node = *nodeTable[n][i];
+                MWNode<D, T> &node = *nodeTable[n][i];
                 if (node.isBranchNode()) { node.reCompress(); }
             }
         }
@@ -190,8 +190,8 @@ template <int D> void MWTree<D>::mwTransformUp() {
  * operation is generally used after the operator application.
  *
  */
-template <int D> void MWTree<D>::mwTransformDown(bool overwrite) {
-    std::vector<MWNodeVector<D>> nodeTable;
+template <int D, typename T> void MWTree<D, T>::mwTransformDown(bool overwrite) {
+    std::vector<MWNodeVector<D, T>> nodeTable;
     tree_utils::make_node_table(*this, nodeTable);
 #pragma omp parallel shared(nodeTable) num_threads(mrcpp_get_num_threads())
     {
@@ -199,7 +199,7 @@ template <int D> void MWTree<D>::mwTransformDown(bool overwrite) {
             int n_nodes = nodeTable[n].size();
 #pragma omp for schedule(guided)
             for (int i = 0; i < n_nodes; i++) {
-                MWNode<D> &node = *nodeTable[n][i];
+                MWNode<D, T> &node = *nodeTable[n][i];
                 if (node.isBranchNode()) {
                     if (this->getRootScale() > node.getScale()) {
                         int reverse = n_nodes - 1;
@@ -215,15 +215,15 @@ template <int D> void MWTree<D>::mwTransformDown(bool overwrite) {
 }
 
 /** @brief Set the MW coefficients to zero, keeping the same tree structure
- *   
+ *
  * @details Keeps the node structure of the tree, even though the zero
  * function is representable at depth zero. One should then use \ref cropTree to remove
  * unnecessary nodes.
  */
-template <int D> void MWTree<D>::setZero() {
-    TreeIterator<D> it(*this);
+template <int D, typename T> void MWTree<D, T>::setZero() {
+    TreeIterator<D, T> it(*this);
     while (it.next()) {
-        MWNode<D> &node = it.getNode();
+        MWNode<D, T> &node = it.getNode();
         node.zeroCoefs();
     }
     this->squareNorm = 0.0;
@@ -236,7 +236,7 @@ template <int D> void MWTree<D>::setZero() {
  * safe, and must NEVER be called outside a critical region in parallel.
  * It's way. way too expensive to lock the tree, so don't even think
  * about it. */
-template <int D> void MWTree<D>::incrementNodeCount(int scale) {
+template <int D, typename T> void MWTree<D, T>::incrementNodeCount(int scale) {
     int depth = scale - getRootScale();
     if (depth < 0) {
         int n = this->nodesAtNegativeDepth.size();
@@ -261,7 +261,7 @@ template <int D> void MWTree<D>::incrementNodeCount(int scale) {
  * It's way. way too expensive to lock the tree, so don't even think
  * about it.
  */
-template <int D> void MWTree<D>::decrementNodeCount(int scale) {
+template <int D, typename T> void MWTree<D, T>::decrementNodeCount(int scale) {
     int depth = scale - getRootScale();
     if (depth < 0) {
         assert(-depth - 1 < this->nodesAtNegativeDepth.size());
@@ -280,7 +280,7 @@ template <int D> void MWTree<D>::decrementNodeCount(int scale) {
  *
  * @param[in] depth: Tree depth (0 depth is the coarsest scale) to count.
  */
-template <int D> int MWTree<D>::getNNodesAtDepth(int depth) const {
+template <int D, typename T> int MWTree<D, T>::getNNodesAtDepth(int depth) const {
     int N = 0;
     if (depth < 0) {
         if (this->nodesAtNegativeDepth.size() >= -depth) N = this->nodesAtNegativeDepth[-depth];
@@ -291,9 +291,9 @@ template <int D> int MWTree<D>::getNNodesAtDepth(int depth) const {
 }
 
 /** @returns Size of all MW coefs in the tree, in kB */
-template <int D> int MWTree<D>::getSizeNodes() const {
+template <int D, typename T> int MWTree<D, T>::getSizeNodes() const {
     auto nCoefs = 1ll * getNNodes() * getTDim() * getKp1_d();
-    return sizeof(double) * nCoefs / 1024;
+    return sizeof(T) * nCoefs / 1024;
 }
 
 /** @brief Finds and returns the node pointer with the given \ref NodeIndex, const version.
@@ -303,11 +303,11 @@ template <int D> int MWTree<D>::getSizeNodes() const {
  * pointer if the node does not exist, or if it is a
  * GenNode. Recursion starts at the appropriate rootNode.
  */
-template <int D> const MWNode<D> *MWTree<D>::findNode(NodeIndex<D> idx) const {
+template <int D, typename T> const MWNode<D, T> *MWTree<D, T>::findNode(NodeIndex<D> idx) const {
     if (getRootBox().isPeriodic()) { periodic::index_manipulation<D>(idx, getRootBox().getPeriodic()); }
     int rIdx = getRootBox().getBoxIndex(idx);
     if (rIdx < 0) return nullptr;
-    const MWNode<D> &root = this->rootBox.getNode(rIdx);
+    const MWNode<D, T> &root = this->rootBox.getNode(rIdx);
     assert(root.isAncestor(idx));
     return root.retrieveNodeNoGen(idx);
 }
@@ -319,11 +319,11 @@ template <int D> const MWNode<D> *MWTree<D>::findNode(NodeIndex<D> idx) const {
  * pointer if the node does not exist, or if it is a
  * GenNode. Recursion starts at the appropriate rootNode.
  */
-template <int D> MWNode<D> *MWTree<D>::findNode(NodeIndex<D> idx) {
+template <int D, typename T> MWNode<D, T> *MWTree<D, T>::findNode(NodeIndex<D> idx) {
     if (getRootBox().isPeriodic()) { periodic::index_manipulation<D>(idx, getRootBox().getPeriodic()); }
     int rIdx = getRootBox().getBoxIndex(idx);
     if (rIdx < 0) return nullptr;
-    MWNode<D> &root = this->rootBox.getNode(rIdx);
+    MWNode<D, T> &root = this->rootBox.getNode(rIdx);
     assert(root.isAncestor(idx));
     return root.retrieveNodeNoGen(idx);
 }
@@ -335,11 +335,11 @@ template <int D> MWNode<D> *MWTree<D>::findNode(NodeIndex<D> idx) {
  * transform. Recursion starts at the appropriate rootNode and descends
  * from this.
  */
-template <int D> MWNode<D> &MWTree<D>::getNode(NodeIndex<D> idx) {
+template <int D, typename T> MWNode<D, T> &MWTree<D, T>::getNode(NodeIndex<D> idx) {
     if (getRootBox().isPeriodic()) periodic::index_manipulation<D>(idx, getRootBox().getPeriodic());
 
-    MWNode<D> *out = nullptr;
-    MWNode<D> &root = getRootBox().getNode(idx);
+    MWNode<D, T> *out = nullptr;
+    MWNode<D, T> &root = getRootBox().getNode(idx);
     if (idx.getScale() < getRootScale()) {
 #pragma omp critical(gen_parent)
         out = root.retrieveParent(idx);
@@ -357,9 +357,9 @@ template <int D> MWNode<D> &MWTree<D>::getNode(NodeIndex<D> idx) {
  * GenNodes.  Recursion starts at the appropriate rootNode and decends
  * from this.
  */
-template <int D> MWNode<D> &MWTree<D>::getNodeOrEndNode(NodeIndex<D> idx) {
+template <int D, typename T> MWNode<D, T> &MWTree<D, T>::getNodeOrEndNode(NodeIndex<D> idx) {
     if (getRootBox().isPeriodic()) { periodic::index_manipulation<D>(idx, getRootBox().getPeriodic()); }
-    MWNode<D> &root = getRootBox().getNode(idx);
+    MWNode<D, T> &root = getRootBox().getNode(idx);
     assert(root.isAncestor(idx));
     return *root.retrieveNodeOrEndNode(idx);
 }
@@ -371,9 +371,9 @@ template <int D> MWNode<D> &MWTree<D>::getNodeOrEndNode(NodeIndex<D> idx) {
  * transform. Recursion starts at the appropriate rootNode and decends
  * from this.
  */
-template <int D> const MWNode<D> &MWTree<D>::getNodeOrEndNode(NodeIndex<D> idx) const {
+template <int D, typename T> const MWNode<D, T> &MWTree<D, T>::getNodeOrEndNode(NodeIndex<D> idx) const {
     if (getRootBox().isPeriodic()) { periodic::index_manipulation<D>(idx, getRootBox().getPeriodic()); }
-    const MWNode<D> &root = getRootBox().getNode(idx);
+    const MWNode<D, T> &root = getRootBox().getNode(idx);
     assert(root.isAncestor(idx));
     return *root.retrieveNodeOrEndNode(idx);
 }
@@ -387,8 +387,8 @@ template <int D> const MWNode<D> &MWTree<D>::getNodeOrEndNode(NodeIndex<D> idx)
  * generate nodes that do not exist. Recursion starts at the
  * appropriate rootNode and decends from this.
  */
-template <int D> MWNode<D> &MWTree<D>::getNode(Coord<D> r, int depth) {
-    MWNode<D> &root = getRootBox().getNode(r);
+template <int D, typename T> MWNode<D, T> &MWTree<D, T>::getNode(Coord<D> r, int depth) {
+    MWNode<D, T> &root = getRootBox().getNode(r);
     if (depth >= 0) {
         return *root.retrieveNode(r, depth);
     } else {
@@ -405,11 +405,11 @@ template <int D> MWNode<D> &MWTree<D>::getNode(Coord<D> r, int depth) {
  * the path to the requested node, and will never create or return GenNodes.
  * Recursion starts at the appropriate rootNode and decends from this.
  */
-template <int D> MWNode<D> &MWTree<D>::getNodeOrEndNode(Coord<D> r, int depth) {
+template <int D, typename T> MWNode<D, T> &MWTree<D, T>::getNodeOrEndNode(Coord<D> r, int depth) {
 
     if (getRootBox().isPeriodic()) { periodic::coord_manipulation<D>(r, getRootBox().getPeriodic()); }
 
-    MWNode<D> &root = getRootBox().getNode(r);
+    MWNode<D, T> &root = getRootBox().getNode(r);
     return *root.retrieveNodeOrEndNode(r, depth);
 }
 
@@ -422,10 +422,10 @@ template <int D> MWNode<D> &MWTree<D>::getNodeOrEndNode(Coord<D> r, int depth) {
  * the path to the requested node, and will never create or return GenNodes.
  * Recursion starts at the appropriate rootNode and decends from this.
  */
-template <int D> const MWNode<D> &MWTree<D>::getNodeOrEndNode(Coord<D> r, int depth) const {
+template <int D, typename T> const MWNode<D, T> &MWTree<D, T>::getNodeOrEndNode(Coord<D> r, int depth) const {
 
     if (getRootBox().isPeriodic()) { periodic::coord_manipulation<D>(r, getRootBox().getPeriodic()); }
-    const MWNode<D> &root = getRootBox().getNode(r);
+    const MWNode<D, T> &root = getRootBox().getNode(r);
     return *root.retrieveNodeOrEndNode(r, depth);
 }
 
@@ -434,10 +434,10 @@ template <int D> const MWNode<D> &MWTree<D>::getNodeOrEndNode(Coord<D> r, int de
  * @details copies the list of all EndNode pointers into a new vector
  * and retunrs it.
  */
-template <int D> MWNodeVector<D> *MWTree<D>::copyEndNodeTable() {
-    auto *nVec = new MWNodeVector<D>;
+template <int D, typename T> MWNodeVector<D, T> *MWTree<D, T>::copyEndNodeTable() {
+    auto *nVec = new MWNodeVector<D, T>;
     for (int n = 0; n < getNEndNodes(); n++) {
-        MWNode<D> &node = getEndMWNode(n);
+        MWNode<D, T> &node = getEndMWNode(n);
         nVec->push_back(&node);
     }
     return nVec;
@@ -447,29 +447,29 @@ template <int D> MWNodeVector<D> *MWTree<D>::copyEndNodeTable() {
  *
  * @details the endNodeTable is first deleted and then rebuilt from
  * scratch. It makes use of the TreeIterator to traverse the tree.
- * 
+ *
  */
-template <int D> void MWTree<D>::resetEndNodeTable() {
+template <int D, typename T> void MWTree<D, T>::resetEndNodeTable() {
     clearEndNodeTable();
-    TreeIterator<D> it(*this, TopDown, Hilbert);
+    TreeIterator<D, T> it(*this, TopDown, Hilbert);
     it.setReturnGenNodes(false);
     while (it.next()) {
-        MWNode<D> &node = it.getNode();
+        MWNode<D, T> &node = it.getNode();
         if (node.isEndNode()) { this->endNodeTable.push_back(&node); }
     }
 }
 
 
-template <int D> int MWTree<D>::countBranchNodes(int depth) {
+template <int D, typename T> int MWTree<D, T>::countBranchNodes(int depth) {
     NOT_IMPLEMENTED_ABORT;
 }
 
-template <int D> int MWTree<D>::countLeafNodes(int depth) {
+template <int D, typename T> int MWTree<D, T>::countLeafNodes(int depth) {
     NOT_IMPLEMENTED_ABORT;
     //    int nNodes = 0;
-    //    TreeIterator<D> it(*this);
+    //    TreeIterator<D, T> it(*this);
     //    while (it.next()) {
-    //        MWNode<D> &node = it.getNode();
+    //        MWNode<D, T> &node = it.getNode();
     //        if (node.getDepth() == depth or depth < 0) {
     //            if (node.isLeafNode()) {
     //                nNodes++;
@@ -480,12 +480,12 @@ template <int D> int MWTree<D>::countLeafNodes(int depth) {
 }
 
 /* Traverse tree and count nodes belonging to this rank. */
-template <int D> int MWTree<D>::countNodes(int depth) {
+template <int D, typename T> int MWTree<D, T>::countNodes(int depth) {
     NOT_IMPLEMENTED_ABORT;
-    //    TreeIterator<D> it(*this);
+    //    TreeIterator<D, T> it(*this);
     //    int count = 0;
     //    while (it.next()) {
-    //        MWNode<D> &node = it.getNode();
+    //        MWNode<D, T> &node = it.getNode();
     //        if (node.isGenNode()) {
     //            continue;
     //        }
@@ -497,12 +497,12 @@ template <int D> int MWTree<D>::countNodes(int depth) {
 }
 
 /* Traverse tree and count nodes with allocated coefficients. */
-template <int D> int MWTree<D>::countAllocNodes(int depth) {
+template <int D, typename T> int MWTree<D, T>::countAllocNodes(int depth) {
     NOT_IMPLEMENTED_ABORT;
-    //    TreeIterator<D> it(*this);
+    //    TreeIterator<D, T> it(*this);
     //    int count = 0;
     //    while (it.next()) {
-    //        MWNode<D> &node = it.getNode();
+    //        MWNode<D, T> &node = it.getNode();
     //        if (node.isGenNode()) {
     //            continue;
     //        }
@@ -515,7 +515,7 @@ template <int D> int MWTree<D>::countAllocNodes(int depth) {
 
 /** @brief Prints a summary of the tree structure on the output file
  */
-template <int D> std::ostream &MWTree<D>::print(std::ostream &o) const {
+template <int D, typename T> std::ostream &MWTree<D, T>::print(std::ostream &o) const {
     o << "  square norm: " << this->squareNorm << std::endl;
     o << "  root scale: " << this->getRootScale() << std::endl;
     o << "  order: " << this->order << std::endl;
@@ -532,9 +532,9 @@ template <int D> std::ostream &MWTree<D>::print(std::ostream &o) const {
  * @details it defines the upper bound of the squared norm \f$
  * ||f||^2_{\ldots} \f$ in this node or its descendents
  */
-template <int D> void MWTree<D>::makeMaxSquareNorms() {
-    NodeBox<D> &rBox = this->getRootBox();
-    MWNode<D> **roots = rBox.getNodes();
+template <int D, typename T> void MWTree<D, T>::makeMaxSquareNorms() {
+    NodeBox<D, T> &rBox = this->getRootBox();
+    MWNode<D, T> **roots = rBox.getNodes();
     for (int rIdx = 0; rIdx < rBox.size(); rIdx++) {
         // recursively set value of children and descendants
         roots[rIdx]->setMaxSquareNorm();
@@ -543,15 +543,16 @@ template <int D> void MWTree<D>::makeMaxSquareNorms() {
 
 /** @brief gives serialIx of a node from its NodeIndex
  *
- * @details Peter will document this!
+ * @details gives a unique integer for each nodes corresponding to the position
+ * of the node in the serialized representation
  */
-template <int D> int MWTree<D>::getIx(NodeIndex<D> nIdx) {
+template <int D, typename T> int MWTree<D, T>::getIx(NodeIndex<D> nIdx) {
     if (this->isLocal == false) MSG_ERROR("getIx only implemented in local representation");
     if(NodeIndex2serialIx.count(nIdx) == 0) return -1;
     else return NodeIndex2serialIx[nIdx];
 }
 
-template <int D> void MWTree<D>::getNodeCoeff(NodeIndex<D> nIdx, double *data) {
+template <int D, typename T> void MWTree<D, T>::getNodeCoeff(NodeIndex<D> nIdx, T *data) {
     assert(this->isLocal);
     int size = (1 << D) * kp1_d;
     int id = 0;
@@ -559,8 +560,13 @@ template <int D> void MWTree<D>::getNodeCoeff(NodeIndex<D> nIdx, double *data) {
     this->NodesCoeff->get_data(id, size, data);
 }
 
-template class MWTree<1>;
-template class MWTree<2>;
-template class MWTree<3>;
+template class MWTree<1, double>;
+template class MWTree<2, double>;
+template class MWTree<3, double>;
+
+
+template class MWTree<1, ComplexDouble>;
+template class MWTree<2, ComplexDouble>;
+template class MWTree<3, ComplexDouble>;
 
 } // namespace mrcpp
diff --git a/src/trees/MWTree.h b/src/trees/MWTree.h
index 51cfe3eed..c2f231ccf 100644
--- a/src/trees/MWTree.h
+++ b/src/trees/MWTree.h
@@ -61,11 +61,11 @@ class BankAccount;
  * present. See specific methods for details.
  *
  */
-template <int D> class MWTree {
+  template <int D, typename T> class MWTree {
 public:
     MWTree(const MultiResolutionAnalysis<D> &mra, const std::string &n);
-    MWTree(const MWTree<D> &tree) = delete;
-    MWTree<D> &operator=(const MWTree<D> &tree) = delete;
+    MWTree(const MWTree<D, T> &tree) = delete;
+    MWTree<D, T> &operator=(const MWTree<D, T> &tree) = delete;
     virtual ~MWTree();
 
     void setZero();
@@ -90,8 +90,8 @@ template <int D> class MWTree {
     int getSizeNodes() const;
 
     /** @returns */
-    NodeBox<D> &getRootBox() { return this->rootBox; }
-    const NodeBox<D> &getRootBox() const { return this->rootBox; }
+    NodeBox<D, T> &getRootBox() { return this->rootBox; }
+    const NodeBox<D, T> &getRootBox() const { return this->rootBox; }
     const MultiResolutionAnalysis<D> &getMRA() const { return this->MRA; }
 
     void mwTransform(int type, bool overwrite = true);
@@ -102,28 +102,28 @@ template <int D> class MWTree {
     int getRootIndex(Coord<D> r) const { return this->rootBox.getBoxIndex(r); }
     int getRootIndex(NodeIndex<D> nIdx) const { return this->rootBox.getBoxIndex(nIdx); }
 
-    MWNode<D> *findNode(NodeIndex<D> nIdx);
-    const MWNode<D> *findNode(NodeIndex<D> nIdx) const;
+    MWNode<D, T> *findNode(NodeIndex<D> nIdx);
+    const MWNode<D, T> *findNode(NodeIndex<D> nIdx) const;
 
-    MWNode<D> &getNode(NodeIndex<D> nIdx);
-    MWNode<D> &getNodeOrEndNode(NodeIndex<D> nIdx);
-    const MWNode<D> &getNodeOrEndNode(NodeIndex<D> nIdx) const;
+    MWNode<D, T> &getNode(NodeIndex<D> nIdx);
+    MWNode<D, T> &getNodeOrEndNode(NodeIndex<D> nIdx);
+    const MWNode<D, T> &getNodeOrEndNode(NodeIndex<D> nIdx) const;
 
-    MWNode<D> &getNode(Coord<D> r, int depth = -1);
-    MWNode<D> &getNodeOrEndNode(Coord<D> r, int depth = -1);
-    const MWNode<D> &getNodeOrEndNode(Coord<D> r, int depth = -1) const;
+    MWNode<D, T> &getNode(Coord<D> r, int depth = -1);
+    MWNode<D, T> &getNodeOrEndNode(Coord<D> r, int depth = -1);
+    const MWNode<D, T> &getNodeOrEndNode(Coord<D> r, int depth = -1) const;
 
     int getNEndNodes() const { return this->endNodeTable.size(); }
     int getNRootNodes() const { return this->rootBox.size(); }
-    MWNode<D> &getEndMWNode(int i) { return *this->endNodeTable[i]; }
-    MWNode<D> &getRootMWNode(int i) { return this->rootBox.getNode(i); }
-    const MWNode<D> &getEndMWNode(int i) const { return *this->endNodeTable[i]; }
-    const MWNode<D> &getRootMWNode(int i) const { return this->rootBox.getNode(i); }
+    MWNode<D, T> &getEndMWNode(int i) { return *this->endNodeTable[i]; }
+    MWNode<D, T> &getRootMWNode(int i) { return this->rootBox.getNode(i); }
+    const MWNode<D, T> &getEndMWNode(int i) const { return *this->endNodeTable[i]; }
+    const MWNode<D, T> &getRootMWNode(int i) const { return this->rootBox.getNode(i); }
 
     bool isPeriodic() const { return this->MRA.getWorldBox().isPeriodic(); }
 
-    MWNodeVector<D> *copyEndNodeTable();
-    MWNodeVector<D> *getEndNodeTable() { return &this->endNodeTable; }
+    MWNodeVector<D, T> *copyEndNodeTable();
+    MWNodeVector<D, T> *getEndNodeTable() { return &this->endNodeTable; }
 
     void deleteRootNodes();
     void resetEndNodeTable();
@@ -138,19 +138,19 @@ template <int D> class MWTree {
 
     void makeMaxSquareNorms(); // sets values for maxSquareNorm and maxWSquareNorm in all nodes
 
-    NodeAllocator<D> &getNodeAllocator() { return *this->nodeAllocator_p; }
-    const NodeAllocator<D> &getNodeAllocator() const { return *this->nodeAllocator_p; }
-    MWNodeVector<D> endNodeTable;          ///< Final projected nodes
+    NodeAllocator<D, T> &getNodeAllocator() { return *this->nodeAllocator_p; }
+    const NodeAllocator<D, T> &getNodeAllocator() const { return *this->nodeAllocator_p; }
+    MWNodeVector<D, T> endNodeTable;          ///< Final projected nodes
 
-    void getNodeCoeff(NodeIndex<D> nIdx, double *data); // fetch coefficient from a specific node stored in Bank
+    void getNodeCoeff(NodeIndex<D> nIdx, T *data); // fetch coefficient from a specific node stored in Bank
 
-    friend std::ostream &operator<<(std::ostream &o, const MWTree<D> &tree) { return tree.print(o); }
+    friend std::ostream &operator<<(std::ostream &o, const MWTree<D, T> &tree) { return tree.print(o); }
 
-    friend class MWNode<D>;
-    friend class FunctionNode<D>;
+    friend class MWNode<D, T>;
+    friend class FunctionNode<D, T>;
     friend class OperatorNode;
-    friend class TreeBuilder<D>;
-    friend class NodeAllocator<D>;
+    friend class TreeBuilder<D, T>;
+    friend class NodeAllocator<D, T>;
 
 protected:
     // Parameters that are set in construction and should never change
@@ -165,11 +165,11 @@ template <int D> class MWTree {
     // Parameters that are dynamic and can be set by user
     std::string name;
 
-    std::unique_ptr<NodeAllocator<D>> nodeAllocator_p{nullptr};
+    std::unique_ptr<NodeAllocator<D, T>> nodeAllocator_p{nullptr};
 
     // Tree data
     double squareNorm;
-    NodeBox<D> rootBox;                    ///< The actual container of nodes
+    NodeBox<D, T> rootBox;                    ///< The actual container of nodes
     std::vector<int> nodesAtDepth;         ///< Node counter
     std::vector<int> nodesAtNegativeDepth; ///< Node counter
 
diff --git a/src/trees/NodeAllocator.cpp b/src/trees/NodeAllocator.cpp
index 9ca79f0b4..b33d5ccf1 100644
--- a/src/trees/NodeAllocator.cpp
+++ b/src/trees/NodeAllocator.cpp
@@ -38,7 +38,7 @@
 
 namespace mrcpp {
 
-template <int D> NodeAllocator<D>::NodeAllocator(FunctionTree<D> *tree, SharedMemory *mem, int coefsPerNode, int nodesPerChunk)
+template <int D, typename T> NodeAllocator<D, T>::NodeAllocator(FunctionTree<D, T> *tree, SharedMemory<T> *mem, int coefsPerNode, int nodesPerChunk)
         : coefsPerNode(coefsPerNode)
         , maxNodesPerChunk(nodesPerChunk)
         , tree_p(tree)
@@ -47,14 +47,14 @@ template <int D> NodeAllocator<D>::NodeAllocator(FunctionTree<D> *tree, SharedMe
     this->nodeChunks.reserve(100);
     this->coefChunks.reserve(100);
 
-    FunctionNode<D> tmp;
+    FunctionNode<D, T> tmp;
     this->cvptr = *(char **)(&tmp);
-    this->sizeOfNode = sizeof(FunctionNode<D>);
+    this->sizeOfNode = sizeof(FunctionNode<D, T>);
 
     MRCPP_INIT_OMP_LOCK();
 }
 
-template <> NodeAllocator<2>::NodeAllocator(OperatorTree *tree, SharedMemory *mem, int coefsPerNode, int nodesPerChunk)
+template <> NodeAllocator<2>::NodeAllocator(OperatorTree *tree, SharedMemory<double> *mem, int coefsPerNode, int nodesPerChunk)
         : coefsPerNode(coefsPerNode)
         , maxNodesPerChunk(nodesPerChunk)
         , tree_p(tree)
@@ -70,11 +70,11 @@ template <> NodeAllocator<2>::NodeAllocator(OperatorTree *tree, SharedMemory *me
     MRCPP_INIT_OMP_LOCK();
 }
 
-template <int D> NodeAllocator<D>::NodeAllocator(OperatorTree *tree, SharedMemory *mem, int coefsPerNode, int nodesPerChunk) {
+template <int D, typename T> NodeAllocator<D, T>::NodeAllocator(OperatorTree *tree, SharedMemory<T> *mem, int coefsPerNode, int nodesPerChunk) {
     NOT_REACHED_ABORT;
 }
 
-template <int D> NodeAllocator<D>::~NodeAllocator() {
+template <int D, typename T> NodeAllocator<D, T>::~NodeAllocator() {
     for (auto &chunk : this->nodeChunks) delete[](char *) chunk;
     if (not isShared()) // if the data is shared, it must be freed by MPI_Win_free
         for (auto &chunk : this->coefChunks) delete[] chunk;
@@ -82,35 +82,35 @@ template <int D> NodeAllocator<D>::~NodeAllocator() {
     MRCPP_DESTROY_OMP_LOCK();
 }
 
-template <int D> MWNode<D> * NodeAllocator<D>::getNode_p(int sIdx) {
+template <int D, typename T> MWNode<D, T> * NodeAllocator<D, T>::getNode_p(int sIdx) {
     MRCPP_SET_OMP_LOCK();
     auto *node = getNodeNoLock(sIdx);
     MRCPP_UNSET_OMP_LOCK();
     return node;
 }
 
-template <int D> double * NodeAllocator<D>::getCoef_p(int sIdx) {
+template <int D, typename T> T * NodeAllocator<D, T>::getCoef_p(int sIdx) {
     MRCPP_SET_OMP_LOCK();
     auto *coefs = getCoefNoLock(sIdx);
     MRCPP_UNSET_OMP_LOCK();
     return coefs;
 }
 
-template <int D> MWNode<D> * NodeAllocator<D>::getNodeNoLock(int sIdx) {
+template <int D, typename T> MWNode<D, T> * NodeAllocator<D, T>::getNodeNoLock(int sIdx) {
     if (sIdx < 0 or sIdx >= this->stackStatus.size()) return nullptr;
     int chunk = sIdx / this->maxNodesPerChunk; // which chunk
     int cIdx = sIdx % this->maxNodesPerChunk;  // position in chunk
     return this->nodeChunks[chunk] + cIdx;
 }
 
-template <int D> double * NodeAllocator<D>::getCoefNoLock(int sIdx) {
+template <int D, typename T> T * NodeAllocator<D, T>::getCoefNoLock(int sIdx) {
     if (sIdx < 0 or sIdx >= this->stackStatus.size()) return nullptr;
     int chunk = sIdx / this->maxNodesPerChunk; // which chunk
     int idx = sIdx % this->maxNodesPerChunk;   // position in chunk
     return this->coefChunks[chunk] + idx * this->coefsPerNode;
 }
 
-template <int D> int NodeAllocator<D>::alloc(int nNodes, bool coefs) {
+template <int D, typename T> int NodeAllocator<D, T>::alloc(int nNodes, bool coefs) {
     MRCPP_SET_OMP_LOCK();
     if (nNodes <= 0 or nNodes > this->maxNodesPerChunk) MSG_ABORT("Cannot allocate " << nNodes << " nodes");
 
@@ -143,7 +143,7 @@ template <int D> int NodeAllocator<D>::alloc(int nNodes, bool coefs) {
     return sIdx;
 }
 
-template <int D> void NodeAllocator<D>::dealloc(int sIdx) {
+template <int D, typename T> void NodeAllocator<D, T>::dealloc(int sIdx) {
     MRCPP_SET_OMP_LOCK();
     if (sIdx < 0 or sIdx >= this->stackStatus.size()) MSG_ABORT("Invalid serial index: " << sIdx);
     auto *node_p = getNodeNoLock(sIdx);
@@ -161,7 +161,7 @@ template <int D> void NodeAllocator<D>::dealloc(int sIdx) {
     MRCPP_UNSET_OMP_LOCK();
 }
 
-template <int D> void NodeAllocator<D>::deallocAllCoeff() {
+template <int D, typename T> void NodeAllocator<D, T>::deallocAllCoeff() {
     if (not this->isShared())
         for (auto &chunk : this->coefChunks) delete[] chunk;
     else delete this->shmem_p;
@@ -170,7 +170,7 @@ template <int D> void NodeAllocator<D>::deallocAllCoeff() {
 
 }
 
-template <int D> void NodeAllocator<D>::init(int nChunks, bool coefs) {
+template <int D, typename T> void NodeAllocator<D, T>::init(int nChunks, bool coefs) {
     MRCPP_SET_OMP_LOCK();
     if (nChunks <= 0) MSG_ABORT("Invalid number of chunks: " << nChunks);
     for (int i = getNChunks(); i < nChunks; i++) appendChunk(coefs);
@@ -182,10 +182,10 @@ template <int D> void NodeAllocator<D>::init(int nChunks, bool coefs) {
     MRCPP_UNSET_OMP_LOCK();
 }
 
-template <int D> void NodeAllocator<D>::appendChunk(bool coefs) {
+template <int D, typename T> void NodeAllocator<D, T>::appendChunk(bool coefs) {
     // make coeff chunk
     if (coefs) {
-        double *c_chunk = nullptr;
+        T *c_chunk = nullptr;
         if (this->isShared()) {
             // for coefficients, take from the shared memory block
             c_chunk = this->shmem_p->sh_end_ptr;
@@ -193,13 +193,13 @@ template <int D> void NodeAllocator<D>::appendChunk(bool coefs) {
             // may increase size dynamically in the future
             if (this->shmem_p->sh_max_ptr < this->shmem_p->sh_end_ptr) MSG_ABORT("Shared block too small");
         } else {
-            c_chunk = new double[getCoefChunkSize() / sizeof(double)];
+            c_chunk = new T[getCoefChunkSize() / sizeof(T)];
         }
         this->coefChunks.push_back(c_chunk);
     }
 
     // make node chunk
-    auto n_chunk = (MWNode<D> *)new char[getNodeChunkSize()];
+    auto n_chunk = (MWNode<D, T> *)new char[getNodeChunkSize()];
     for (int i = 0; i < this->maxNodesPerChunk; i++) {
         n_chunk[i].serialIx = -1;
         n_chunk[i].parentSerialIx = -1;
@@ -215,7 +215,7 @@ template <int D> void NodeAllocator<D>::appendChunk(bool coefs) {
 }
 
 /** Fill all holes in the chunks with occupied nodes, then remove all empty chunks */
-template <int D> int NodeAllocator<D>::compress() {
+template <int D, typename T> int NodeAllocator<D, T>::compress() {
     MRCPP_SET_OMP_LOCK();
     int nNodes = (1 << D);
     if (this->maxNodesPerChunk * this->nodeChunks.size() <=
@@ -249,7 +249,7 @@ template <int D> int NodeAllocator<D>::compress() {
     return nChunksDeleted;
 }
 
-template <int D> int NodeAllocator<D>::deleteUnusedChunks() {
+template <int D, typename T> int NodeAllocator<D, T>::deleteUnusedChunks() {
     // number of occupied chunks
     int nChunksTotal = getNChunks();
     int nChunksUsed = getNChunksUsed();
@@ -271,7 +271,7 @@ template <int D> int NodeAllocator<D>::deleteUnusedChunks() {
     return nChunksTotal - nChunksUsed;
 }
 
-template <int D> void NodeAllocator<D>::moveNodes(int nNodes, int srcIdx, int dstIdx) {
+template <int D, typename T> void NodeAllocator<D, T>::moveNodes(int nNodes, int srcIdx, int dstIdx) {
     assert(nNodes > 0);
     assert(nNodes <= this->maxNodesPerChunk);
 
@@ -288,7 +288,7 @@ template <int D> void NodeAllocator<D>::moveNodes(int nNodes, int srcIdx, int ds
     for (int i = 0; i < nNodes * this->sizeOfNode; i++) ((char *)dstNode)[i] = ((char *)srcNode)[i];
 
     // coefs have new adresses
-    double *coefs_p = getCoefNoLock(dstIdx);
+    T *coefs_p = getCoefNoLock(dstIdx);
     if (coefs_p == nullptr) NOT_IMPLEMENTED_ABORT; // Nodes without coefs not handled atm
     for (int i = 0; i < nNodes; i++) (dstNode + i)->coefs = coefs_p + i * getNCoefs();
 
@@ -325,7 +325,7 @@ template <int D> void NodeAllocator<D>::moveNodes(int nNodes, int srcIdx, int ds
 }
 
 // Last positions on a chunk cannot be used if there is no place for nNodes siblings on the same chunk
-template <int D> int NodeAllocator<D>::findNextAvailable(int sIdx, int nNodes) const {
+template <int D, typename T> int NodeAllocator<D, T>::findNextAvailable(int sIdx, int nNodes) const {
     assert(sIdx >= 0);
     assert(sIdx < this->stackStatus.size());
     assert(nNodes >= 0);
@@ -343,7 +343,7 @@ template <int D> int NodeAllocator<D>::findNextAvailable(int sIdx, int nNodes) c
     return sIdx;
 }
 
-template <int D> int NodeAllocator<D>::findNextOccupied(int sIdx) const {
+template <int D, typename T> int NodeAllocator<D, T>::findNextOccupied(int sIdx) const {
     assert(sIdx >= 0);
     assert(sIdx < this->stackStatus.size());
     bool endOfStack = (sIdx >= this->topStack);
@@ -359,17 +359,17 @@ template <int D> int NodeAllocator<D>::findNextOccupied(int sIdx) const {
 }
 
 /** Traverse tree and redefine pointer, counter and tables. */
-template <int D> void NodeAllocator<D>::reassemble() {
+template <int D, typename T> void NodeAllocator<D, T>::reassemble() {
     MRCPP_SET_OMP_LOCK();
     this->nNodes = 0;
     getTree().nodesAtDepth.clear();
     getTree().squareNorm = 0.0;
     getTree().clearEndNodeTable();
 
-    NodeBox<D> &rootbox = getTree().getRootBox();
-    MWNode<D> **roots = rootbox.getNodes();
+    NodeBox<D, T> &rootbox = getTree().getRootBox();
+    MWNode<D, T> **roots = rootbox.getNodes();
 
-    std::stack<MWNode<D> *> stack;
+    std::stack<MWNode<D, T> *> stack;
     for (int rIdx = 0; rIdx < rootbox.size(); rIdx++) {
         auto *root_p = getNodeNoLock(rIdx);
         assert(root_p != nullptr);
@@ -414,7 +414,7 @@ template <int D> void NodeAllocator<D>::reassemble() {
     MRCPP_UNSET_OMP_LOCK();
 }
 
-template <int D> void NodeAllocator<D>::print() const {
+template <int D, typename T> void NodeAllocator<D, T>::print() const {
     int n = 0;
     for (int iChunk = 0; iChunk < getNChunks(); iChunk++) {
         int iShift = iChunk * this->maxNodesPerChunk;
@@ -436,8 +436,12 @@ template <int D> void NodeAllocator<D>::print() const {
     }
 }
 
-template class NodeAllocator<1>;
-template class NodeAllocator<2>;
-template class NodeAllocator<3>;
+template class NodeAllocator<1, double>;
+template class NodeAllocator<2, double>;
+template class NodeAllocator<3, double>;
+
+template class NodeAllocator<1, ComplexDouble>;
+template class NodeAllocator<2, ComplexDouble>;
+template class NodeAllocator<3, ComplexDouble>;
 
 } // namespace mrcpp
diff --git a/src/trees/NodeAllocator.h b/src/trees/NodeAllocator.h
index 38e4ba7eb..b426d0021 100644
--- a/src/trees/NodeAllocator.h
+++ b/src/trees/NodeAllocator.h
@@ -40,12 +40,12 @@
 
 namespace mrcpp {
 
-template <int D> class NodeAllocator final {
+  template <int D, typename T> class NodeAllocator final {
 public:
-    NodeAllocator(OperatorTree *tree, SharedMemory *mem, int coefsPerNode, int nodesPerChunk);
-    NodeAllocator(FunctionTree<D> *tree, SharedMemory *mem, int coefsPerNode, int nodesPerChunk);
-    NodeAllocator(const NodeAllocator<D> &tree) = delete;
-    NodeAllocator<D> &operator=(const NodeAllocator<D> &tree) = delete;
+    NodeAllocator(OperatorTree *tree, SharedMemory<T> *mem, int coefsPerNode, int nodesPerChunk);
+    NodeAllocator(FunctionTree<D, T> *tree, SharedMemory<T> *mem, int coefsPerNode, int nodesPerChunk);
+    NodeAllocator(const NodeAllocator<D, T> &tree) = delete;
+    NodeAllocator<D, T> &operator=(const NodeAllocator<D, T> &tree) = delete;
     ~NodeAllocator();
 
     int alloc(int nNodes, bool coefs = true);
@@ -63,13 +63,13 @@ template <int D> class NodeAllocator final {
     int getNChunks() const { return this->nodeChunks.size(); }
     int getNChunksUsed() const { return (this->topStack + this->maxNodesPerChunk - 1) / this->maxNodesPerChunk; }
     int getNodeChunkSize() const { return this->maxNodesPerChunk * this->sizeOfNode; }
-    int getCoefChunkSize() const { return this->maxNodesPerChunk * this->coefsPerNode * sizeof(double); }
+    int getCoefChunkSize() const { return this->maxNodesPerChunk * this->coefsPerNode * sizeof(T); }
 
-    double * getCoef_p(int sIdx);
-    MWNode<D> * getNode_p(int sIdx);
+    T * getCoef_p(int sIdx);
+    MWNode<D, T> * getNode_p(int sIdx);
 
-    double * getCoefChunk(int i) { return this->coefChunks[i]; }
-    MWNode<D> * getNodeChunk(int i) { return this->nodeChunks[i]; }
+    T * getCoefChunk(int i) { return this->coefChunks[i]; }
+    MWNode<D, T> * getNodeChunk(int i) { return this->nodeChunks[i]; }
 
     void print() const;
 
@@ -81,20 +81,20 @@ template <int D> class NodeAllocator final {
     int maxNodesPerChunk{0};        // max number of nodes per allocation
 
     std::vector<int> stackStatus{};
-    std::vector<double *> coefChunks{};
-    std::vector<MWNode<D> *> nodeChunks{};
+    std::vector<T *> coefChunks{};
+    std::vector<MWNode<D, T> *> nodeChunks{};
 
     char *cvptr{nullptr};           // pointer to virtual table
-    MWNode<D> *last_p{nullptr};     // pointer just after the last active node, i.e. where to put next node
-    MWTree<D> *tree_p{nullptr};     // pointer to external object
-    SharedMemory *shmem_p{nullptr}; // pointer to external object
+    MWNode<D, T> *last_p{nullptr};     // pointer just after the last active node, i.e. where to put next node
+    MWTree<D, T> *tree_p{nullptr};     // pointer to external object
+    SharedMemory<T> *shmem_p{nullptr}; // pointer to external object
 
     bool isShared() const { return (this->shmem_p != nullptr); }
-    MWTree<D> &getTree() { return *this->tree_p; }
-    SharedMemory &getMemory() { return *this->shmem_p; }
+    MWTree<D, T> &getTree() { return *this->tree_p; }
+    SharedMemory<T> &getMemory() { return *this->shmem_p; }
 
-    double * getCoefNoLock(int sIdx);
-    MWNode<D> * getNodeNoLock(int sIdx);
+    T * getCoefNoLock(int sIdx);
+    MWNode<D, T> * getNodeNoLock(int sIdx);
 
     void moveNodes(int nNodes, int srcIdx, int dstIdx);
     void appendChunk(bool coefs);
diff --git a/src/trees/NodeBox.cpp b/src/trees/NodeBox.cpp
index cc247d58e..bf747c4fc 100644
--- a/src/trees/NodeBox.cpp
+++ b/src/trees/NodeBox.cpp
@@ -36,50 +36,50 @@
 
 namespace mrcpp {
 
-template <int D>
-NodeBox<D>::NodeBox(const NodeIndex<D> &idx, const std::array<int, D> &nb)
+template <int D, typename T>
+NodeBox<D, T>::NodeBox(const NodeIndex<D> &idx, const std::array<int, D> &nb)
         : BoundingBox<D>(idx, nb)
         , nOccupied(0)
         , nodes(nullptr) {
     allocNodePointers();
 }
 
-template <int D>
-NodeBox<D>::NodeBox(const BoundingBox<D> &box)
+template <int D, typename T>
+NodeBox<D, T>::NodeBox(const BoundingBox<D> &box)
         : BoundingBox<D>(box)
         , nOccupied(0)
         , nodes(nullptr) {
     allocNodePointers();
 }
 
-template <int D>
-NodeBox<D>::NodeBox(const NodeBox<D> &box)
+template <int D, typename T>
+NodeBox<D, T>::NodeBox(const NodeBox<D, T> &box)
         : BoundingBox<D>(box)
         , nOccupied(0)
         , nodes(nullptr) {
     allocNodePointers();
 }
 
-template <int D> void NodeBox<D>::allocNodePointers() {
+template <int D, typename T> void NodeBox<D, T>::allocNodePointers() {
     assert(this->nodes == nullptr);
     int nNodes = this->size();
-    this->nodes = new MWNode<D> *[nNodes];
+    this->nodes = new MWNode<D, T> *[nNodes];
     for (int n = 0; n < nNodes; n++) { this->nodes[n] = nullptr; }
     this->nOccupied = 0;
 }
 
-template <int D> NodeBox<D>::~NodeBox() {
+template <int D, typename T> NodeBox<D, T>::~NodeBox() {
     deleteNodes();
 }
 
-template <int D> void NodeBox<D>::deleteNodes() {
+template <int D, typename T> void NodeBox<D, T>::deleteNodes() {
     if (this->nodes == nullptr) { return; }
     for (int n = 0; n < this->size(); n++) { clearNode(n); }
     delete[] this->nodes;
     this->nodes = nullptr;
 }
 
-template <int D> void NodeBox<D>::setNode(int bIdx, MWNode<D> **node) {
+template <int D, typename T> void NodeBox<D, T>::setNode(int bIdx, MWNode<D, T> **node) {
     assert(bIdx >= 0);
     assert(bIdx < this->totBoxes);
     clearNode(bIdx);
@@ -89,44 +89,48 @@ template <int D> void NodeBox<D>::setNode(int bIdx, MWNode<D> **node) {
     *node = nullptr;
 }
 
-template <int D> MWNode<D> &NodeBox<D>::getNode(NodeIndex<D> nIdx) {
+template <int D, typename T> MWNode<D, T> &NodeBox<D, T>::getNode(NodeIndex<D> nIdx) {
     int bIdx = this->getBoxIndex(nIdx);
     return getNode(bIdx);
 }
 
-template <int D> MWNode<D> &NodeBox<D>::getNode(Coord<D> r) {
+template <int D, typename T> MWNode<D, T> &NodeBox<D, T>::getNode(Coord<D> r) {
     int bIdx = this->getBoxIndex(r);
     if (bIdx < 0) MSG_ERROR("Coord out of bounds");
     return getNode(bIdx);
 }
 
-template <int D> MWNode<D> &NodeBox<D>::getNode(int bIdx) {
+template <int D, typename T> MWNode<D, T> &NodeBox<D, T>::getNode(int bIdx) {
     assert(bIdx >= 0);
     assert(bIdx < this->totBoxes);
     assert(this->nodes[bIdx] != nullptr);
     return *this->nodes[bIdx];
 }
 
-template <int D> const MWNode<D> &NodeBox<D>::getNode(NodeIndex<D> nIdx) const {
+template <int D, typename T> const MWNode<D, T> &NodeBox<D, T>::getNode(NodeIndex<D> nIdx) const {
     int bIdx = this->getBoxIndex(nIdx);
     return getNode(bIdx);
 }
 
-template <int D> const MWNode<D> &NodeBox<D>::getNode(Coord<D> r) const {
+template <int D, typename T> const MWNode<D, T> &NodeBox<D, T>::getNode(Coord<D> r) const {
     int bIdx = this->getBoxIndex(r);
     if (bIdx < 0) MSG_ERROR("Coord out of bounds");
     return getNode(bIdx);
 }
 
-template <int D> const MWNode<D> &NodeBox<D>::getNode(int bIdx) const {
+template <int D, typename T> const MWNode<D, T> &NodeBox<D, T>::getNode(int bIdx) const {
     assert(bIdx >= 0);
     assert(bIdx < this->totBoxes);
     assert(this->nodes[bIdx] != nullptr);
     return *this->nodes[bIdx];
 }
 
-template class NodeBox<1>;
-template class NodeBox<2>;
-template class NodeBox<3>;
+template class NodeBox<1, double>;
+template class NodeBox<2, double>;
+template class NodeBox<3, double>;
+
+template class NodeBox<1, ComplexDouble>;
+template class NodeBox<2, ComplexDouble>;
+template class NodeBox<3, ComplexDouble>;
 
 } // namespace mrcpp
diff --git a/src/trees/NodeBox.h b/src/trees/NodeBox.h
index dfb0dc20c..3b53da538 100644
--- a/src/trees/NodeBox.h
+++ b/src/trees/NodeBox.h
@@ -30,31 +30,31 @@
 
 namespace mrcpp {
 
-template <int D> class NodeBox final : public BoundingBox<D> {
+  template <int D, typename T> class NodeBox final : public BoundingBox<D> {
 public:
     NodeBox(const NodeIndex<D> &idx, const std::array<int, D> &nb = {});
-    NodeBox(const NodeBox<D> &box);
+    NodeBox(const NodeBox<D, T> &box);
     NodeBox(const BoundingBox<D> &box);
-    NodeBox<D> &operator=(const NodeBox<D> &box) = delete;
+    NodeBox<D, T> &operator=(const NodeBox<D, T> &box) = delete;
     ~NodeBox() override;
 
-    void setNode(int idx, MWNode<D> **node);
+    void setNode(int idx, MWNode<D, T> **node);
     void clearNode(int idx) { this->nodes[idx] = nullptr; }
 
-    MWNode<D> &getNode(NodeIndex<D> idx);
-    MWNode<D> &getNode(Coord<D> r);
-    MWNode<D> &getNode(int i = 0);
+    MWNode<D, T> &getNode(NodeIndex<D> idx);
+    MWNode<D, T> &getNode(Coord<D> r);
+    MWNode<D, T> &getNode(int i = 0);
 
-    const MWNode<D> &getNode(NodeIndex<D> idx) const;
-    const MWNode<D> &getNode(Coord<D> r) const;
-    const MWNode<D> &getNode(int i = 0) const;
+    const MWNode<D, T> &getNode(NodeIndex<D> idx) const;
+    const MWNode<D, T> &getNode(Coord<D> r) const;
+    const MWNode<D, T> &getNode(int i = 0) const;
 
     int getNOccupied() const { return this->nOccupied; }
-    MWNode<D> **getNodes() { return this->nodes; }
+    MWNode<D, T> **getNodes() { return this->nodes; }
 
 protected:
     int nOccupied;     ///< Number of non-zero pointers in box
-    MWNode<D> **nodes; ///< Container of nodes
+    MWNode<D, T> **nodes; ///< Container of nodes
 
     void allocNodePointers();
     void deleteNodes();
diff --git a/src/trees/TreeIterator.cpp b/src/trees/TreeIterator.cpp
index 9bf9fb054..f7f88e03b 100644
--- a/src/trees/TreeIterator.cpp
+++ b/src/trees/TreeIterator.cpp
@@ -29,7 +29,7 @@
 
 namespace mrcpp {
 
-template <int D> TreeIterator<D>::TreeIterator(int traverse, int iterator)
+template <int D, typename T> TreeIterator<D, T>::TreeIterator(int traverse, int iterator)
         : root(0)
         , nRoots(0)
         , mode(traverse)
@@ -38,7 +38,7 @@ template <int D> TreeIterator<D>::TreeIterator(int traverse, int iterator)
         , state(nullptr)
         , initialState(nullptr) {}
 
-template <int D> TreeIterator<D>::TreeIterator(MWTree<D> &tree, int traverse, int iterator)
+template <int D, typename T> TreeIterator<D, T>::TreeIterator(MWTree<D, T> &tree, int traverse, int iterator)
         : root(0)
         , nRoots(0)
         , mode(traverse)
@@ -49,23 +49,23 @@ template <int D> TreeIterator<D>::TreeIterator(MWTree<D> &tree, int traverse, in
     init(tree);
 }
 
-template <int D> TreeIterator<D>::~TreeIterator() {
+template <int D, typename T> TreeIterator<D, T>::~TreeIterator() {
     if (this->initialState != nullptr) delete this->initialState;
 }
 
-template<int D> int TreeIterator<D>::getChildIndex(int i) const {
-    const MWNode<D> &node = *this->state->node;
+  template<int D, typename T> int TreeIterator<D, T>::getChildIndex(int i) const {
+    const MWNode<D, T> &node = *this->state->node;
     const HilbertPath<D> &h = node.getHilbertPath();
     // Legesgue type returns i, Hilbert type returns Hilbert index
     return (this->type == Hilbert) ? h.getZIndex(i) : i;
 }
 
-template <int D> bool TreeIterator<D>::next() {
+template <int D, typename T> bool TreeIterator<D, T>::next() {
     if (not this->state) return false;
     if (this->mode == TopDown) {
         if (this->tryNode()) return true;
     }
-    MWNode<D> &node = *this->state->node;
+    MWNode<D, T> &node = *this->state->node;
     if (checkDepth(node) and checkGenerated(node)) {
         const int nChildren = 1 << D;
         for (int i = 0; i < nChildren; i++) {
@@ -80,12 +80,12 @@ template <int D> bool TreeIterator<D>::next() {
     this->removeState();
     return next();
 }
-template <int D> bool TreeIterator<D>::nextParent() {
+template <int D, typename T> bool TreeIterator<D, T>::nextParent() {
     if (not this->state) return false;
     if (this->mode == BottomUp) {
         if (this->tryNode()) return true;
     }
-    MWNode<D> &node = *this->state->node;
+    MWNode<D, T> &node = *this->state->node;
     if (this->tryNextRootParent()) return true;
     if (checkDepth(node)) {
         if (this->tryParent()) return true;
@@ -97,73 +97,73 @@ template <int D> bool TreeIterator<D>::nextParent() {
     return nextParent();
 }
 
-template <int D> void TreeIterator<D>::init(MWTree<D> &tree) {
+template <int D, typename T> void TreeIterator<D, T>::init(MWTree<D, T> &tree) {
     this->root = 0;
     this->maxDepth = -1;
     this->nRoots = tree.getRootBox().size();
-    this->state = new IteratorNode<D>(&tree.getRootBox().getNode(this->root));
+    this->state = new IteratorNode<D, T>(&tree.getRootBox().getNode(this->root));
     // Save the first state so it can be properly deleted later
     this->initialState = this->state;
 }
 
-template <int D> bool TreeIterator<D>::tryNode() {
+template <int D, typename T> bool TreeIterator<D, T>::tryNode() {
     if (not this->state) { return false; }
     if (this->state->doneNode) { return false; }
     this->state->doneNode = true;
     return true;
 }
 
-template <int D> bool TreeIterator<D>::tryChild(int i) {
+template <int D, typename T> bool TreeIterator<D, T>::tryChild(int i) {
     if (not this->state) { return false; }
     if (this->state->doneChild[i]) { return false; }
     this->state->doneChild[i] = true;
     if (this->state->node->isLeafNode()) { return false; }
-    MWNode<D> *child = &this->state->node->getMWChild(i);
-    this->state = new IteratorNode<D>(child, this->state);
+    MWNode<D, T> *child = &this->state->node->getMWChild(i);
+    this->state = new IteratorNode<D, T>(child, this->state);
     return next();
 }
 
-template <int D> bool TreeIterator<D>::tryParent() {
+template <int D, typename T> bool TreeIterator<D, T>::tryParent() {
     if (not this->state) return false;
     if (this->state->doneParent) return false;
     this->state->doneParent = true;
     if (not this->state->node->hasParent()) return false;
-    MWNode<D> *parent = &this->state->node->getMWParent();
-    this->state = new IteratorNode<D>(parent, this->state);
+    MWNode<D, T> *parent = &this->state->node->getMWParent();
+    this->state = new IteratorNode<D, T>(parent, this->state);
     return nextParent();
 }
 
-template <int D> bool TreeIterator<D>::tryNextRoot() {
+template <int D, typename T> bool TreeIterator<D, T>::tryNextRoot() {
     if (not this->state) { return false; }
     if (not this->state->node->isRootNode()) { return false; }
     this->root++;
     if (this->root >= this->nRoots) { return false; }
-    MWNode<D> *nextRoot = &state->node->getMWTree().getRootBox().getNode(root);
-    this->state = new IteratorNode<D>(nextRoot, this->state);
+    MWNode<D, T> *nextRoot = &state->node->getMWTree().getRootBox().getNode(root);
+    this->state = new IteratorNode<D, T>(nextRoot, this->state);
     return next();
 }
 
-template <int D> bool TreeIterator<D>::tryNextRootParent() {
+template <int D, typename T> bool TreeIterator<D, T>::tryNextRootParent() {
     if (not this->state) { return false; }
     if (not this->state->node->isRootNode()) { return false; }
     this->root++;
     if (this->root >= this->nRoots) { return false; }
-    MWNode<D> *nextRoot = &state->node->getMWTree().getRootBox().getNode(root);
-    this->state = new IteratorNode<D>(nextRoot, this->state);
+    MWNode<D, T> *nextRoot = &state->node->getMWTree().getRootBox().getNode(root);
+    this->state = new IteratorNode<D, T>(nextRoot, this->state);
     return nextParent();
 }
 
-template <int D> void TreeIterator<D>::removeState() {
+template <int D, typename T> void TreeIterator<D, T>::removeState() {
     if (this->state == this->initialState) { this->initialState = nullptr; }
     if (this->state != nullptr) {
-        IteratorNode<D> *spare = this->state;
+        IteratorNode<D, T> *spare = this->state;
         this->state = spare->next;
         spare->next = nullptr;
         delete spare;
     }
 }
 
-template <int D> void TreeIterator<D>::setTraverse(int traverse) {
+template <int D, typename T> void TreeIterator<D, T>::setTraverse(int traverse) {
     switch (traverse) {
         case TopDown:
             this->mode = TopDown;
@@ -177,7 +177,7 @@ template <int D> void TreeIterator<D>::setTraverse(int traverse) {
     }
 }
 
-template <int D> void TreeIterator<D>::setIterator(int iterator) {
+template <int D, typename T> void TreeIterator<D, T>::setIterator(int iterator) {
     switch (iterator) {
         case Lebesgue:
             this->type = Lebesgue;
@@ -191,7 +191,7 @@ template <int D> void TreeIterator<D>::setIterator(int iterator) {
     }
 }
 
-template <int D> bool TreeIterator<D>::checkDepth(const MWNode<D> &node) const {
+template <int D, typename T> bool TreeIterator<D, T>::checkDepth(const MWNode<D, T> &node) const {
     if (this->maxDepth < 0) {
         return true;
     } else if (node.getDepth() < this->maxDepth) {
@@ -201,7 +201,7 @@ template <int D> bool TreeIterator<D>::checkDepth(const MWNode<D> &node) const {
     }
 }
 
-template <int D> bool TreeIterator<D>::checkGenerated(const MWNode<D> &node) const {
+template <int D, typename T> bool TreeIterator<D, T>::checkGenerated(const MWNode<D, T> &node) const {
     if (node.isEndNode() and not this->returnGenNodes) {
         return false;
     } else {
@@ -209,8 +209,8 @@ template <int D> bool TreeIterator<D>::checkGenerated(const MWNode<D> &node) con
     }
 }
 
-template <int D>
-IteratorNode<D>::IteratorNode(MWNode<D> *nd, IteratorNode<D> *nx)
+template <int D, typename T>
+IteratorNode<D, T>::IteratorNode(MWNode<D, T> *nd, IteratorNode<D, T> *nx)
         : node(nd)
         , next(nx)
         , doneNode(false)
@@ -219,8 +219,12 @@ IteratorNode<D>::IteratorNode(MWNode<D> *nd, IteratorNode<D> *nx)
     for (int i = 0; i < nChildren; i++) { this->doneChild[i] = false; }
 }
 
-template class TreeIterator<1>;
-template class TreeIterator<2>;
-template class TreeIterator<3>;
+template class TreeIterator<1, double>;
+template class TreeIterator<2, double>;
+template class TreeIterator<3, double>;
+
+template class TreeIterator<1, ComplexDouble>;
+template class TreeIterator<2, ComplexDouble>;
+template class TreeIterator<3, ComplexDouble>;
 
 } // namespace mrcpp
diff --git a/src/trees/TreeIterator.h b/src/trees/TreeIterator.h
index d82db82a0..a79fe8412 100644
--- a/src/trees/TreeIterator.h
+++ b/src/trees/TreeIterator.h
@@ -30,10 +30,10 @@
 
 namespace mrcpp {
 
-template <int D> class TreeIterator {
+template <int D, typename T> class TreeIterator {
 public:
     TreeIterator(int traverse = TopDown, int iterator = Lebesgue);
-    TreeIterator(MWTree<D> &tree, int traverse = TopDown, int iterator = Lebesgue);
+    TreeIterator(MWTree<D, T> &tree, int traverse = TopDown, int iterator = Lebesgue);
     virtual ~TreeIterator();
 
     void setReturnGenNodes(bool i = true) { this->returnGenNodes = i; }
@@ -41,12 +41,12 @@ template <int D> class TreeIterator {
     void setTraverse(int traverse);
     void setIterator(int iterator);
 
-    void init(MWTree<D> &tree);
+    void init(MWTree<D, T> &tree);
     bool next();
     bool nextParent();
-    MWNode<D> &getNode() { return *this->state->node; }
+    MWNode<D, T> &getNode() { return *this->state->node; }
 
-    friend class IteratorNode<D>;
+  friend class IteratorNode<D, T>;
 
 protected:
     int root;
@@ -55,8 +55,8 @@ template <int D> class TreeIterator {
     int type;
     int maxDepth;
     bool returnGenNodes{true};
-    IteratorNode<D> *state;
-    IteratorNode<D> *initialState;
+    IteratorNode<D, T> *state;
+    IteratorNode<D, T> *initialState;
 
     int getChildIndex(int i) const;
 
@@ -66,19 +66,19 @@ template <int D> class TreeIterator {
     bool tryNextRoot();
     bool tryNextRootParent();
     void removeState();
-    bool checkDepth(const MWNode<D> &node) const;
-    bool checkGenerated(const MWNode<D> &node) const;
+    bool checkDepth(const MWNode<D, T> &node) const;
+    bool checkGenerated(const MWNode<D, T> &node) const;
 };
 
-template <int D> class IteratorNode final {
+template <int D, typename T> class IteratorNode final {
 public:
-    MWNode<D> *node;
-    IteratorNode<D> *next;
+    MWNode<D, T> *node;
+    IteratorNode<D, T> *next;
     bool doneNode;
     bool doneParent;
     bool doneChild[1 << D];
 
-    IteratorNode(MWNode<D> *nd, IteratorNode<D> *nx = nullptr);
+    IteratorNode(MWNode<D, T> *nd, IteratorNode<D, T> *nx = nullptr);
     ~IteratorNode() { delete this->next; }
 };
 
diff --git a/src/utils/Bank.cpp b/src/utils/Bank.cpp
index a774c44ff..c00338a9c 100644
--- a/src/utils/Bank.cpp
+++ b/src/utils/Bank.cpp
@@ -385,7 +385,6 @@ void Bank::open() {
             deposits[ix].source = status.MPI_SOURCE;
             if (message == SAVE_FUNCTION) {
                 recv_function(*deposits[ix].orb, deposits[ix].source, 1, comm_bank);
-                cout<<"recv ORB size "<<deposits[ix].orb->getSizeNodes(NUMBER::Total)<<endl;
                 if (exist_flag == 0) {
                     currentsize[account] += deposits[ix].orb->getSizeNodes(NUMBER::Total);
                     totcurrentsize += deposits[ix].orb->getSizeNodes(NUMBER::Total);
@@ -721,6 +720,23 @@ int BankAccount::put_data(int id, int size, double *data) {
     return 1;
 }
 
+// save data in Bank with identity id . datasize MUST have been set already. NB:not tested
+int BankAccount::put_data(int id, int size, ComplexDouble *data) {
+#ifdef MRCPP_HAS_MPI
+    // for now we distribute according to id
+    int messages[message_size];
+
+    messages[0] = SAVE_DATA;
+    messages[1] = account_id;
+    messages[2] = id;
+    messages[3] = size * 2;//save as twice as many doubles
+    messages[4] = MIN_SCALE; // to indicate that it is defined by id
+    MPI_Send(messages, 5, MPI_INT, bankmaster[id % bank_size], 0, comm_bank);
+    MPI_Send(data, size, MPI_DOUBLE, bankmaster[id % bank_size], 1, comm_bank);
+#endif
+    return 1;
+}
+
 // save data in Bank with identity nIdx. datasize MUST have been set already. NB:not tested
 int BankAccount::put_data(NodeIndex<3> nIdx, int size, double *data) {
 #ifdef MRCPP_HAS_MPI
@@ -740,6 +756,26 @@ int BankAccount::put_data(NodeIndex<3> nIdx, int size, double *data) {
     return 1;
 }
 
+// save data in Bank with identity nIdx. datasize MUST have been set already. NB:not tested
+int BankAccount::put_data(NodeIndex<3> nIdx, int size, ComplexDouble *data) {
+#ifdef MRCPP_HAS_MPI
+    // for now we distribute according to id
+    int messages[message_size];
+    messages[0] = SAVE_DATA;
+    messages[1] = account_id;
+    messages[2] = nIdx.getTranslation(0);
+    messages[3] = size * 2; //save as twice as many doubles
+    messages[4] = nIdx.getScale();
+    messages[5] = nIdx.getTranslation(1);
+    messages[6] = nIdx.getTranslation(2);
+    int id = std::abs(nIdx.getTranslation(0) + nIdx.getTranslation(1) + nIdx.getTranslation(2));
+    MPI_Send(messages, 7, MPI_INT, bankmaster[id % bank_size], 0, comm_bank);
+    MPI_Send(data, size, MPI_DOUBLE, bankmaster[id % bank_size], 1, comm_bank);
+#endif
+    return 1;
+}
+
+
 // get data with identity id
 int BankAccount::get_data(int id, int size, double *data) {
 #ifdef MRCPP_HAS_MPI
@@ -755,6 +791,23 @@ int BankAccount::get_data(int id, int size, double *data) {
     return 1;
 }
 
+
+// get data with identity id
+int BankAccount::get_data(int id, int size, ComplexDouble *data) {
+#ifdef MRCPP_HAS_MPI
+    MPI_Status status;
+    int messages[message_size];
+    messages[0] = GET_DATA;
+    messages[1] = account_id;
+    messages[2] = id;
+    messages[3] = MIN_SCALE;
+    MPI_Send(messages, 4, MPI_INT, bankmaster[id % bank_size], 0, comm_bank);
+    //fetch as twice as many doubles
+    MPI_Recv(data, size*2, MPI_DOUBLE, bankmaster[id % bank_size], 1, comm_bank, &status);
+#endif
+    return 1;
+}
+
 // get data with identity id
 int BankAccount::get_data(NodeIndex<3> nIdx, int size, double *data) {
 #ifdef MRCPP_HAS_MPI
@@ -774,6 +827,26 @@ int BankAccount::get_data(NodeIndex<3> nIdx, int size, double *data) {
     return 1;
 }
 
+// get data with identity id
+int BankAccount::get_data(NodeIndex<3> nIdx, int size, ComplexDouble *data) {
+#ifdef MRCPP_HAS_MPI
+    MPI_Status status;
+    int messages[message_size];
+    int id = std::abs(nIdx.getTranslation(0) + nIdx.getTranslation(1) + nIdx.getTranslation(2));
+    messages[0] = GET_DATA;
+    messages[1] = account_id;
+    messages[2] = id;
+    messages[3] = nIdx.getScale();
+    messages[4] = nIdx.getTranslation(0);
+    messages[5] = nIdx.getTranslation(1);
+    messages[6] = nIdx.getTranslation(2);
+    MPI_Send(messages, 7, MPI_INT, bankmaster[id % bank_size], 0, comm_bank);
+    //fetch as twice as many doubles
+    MPI_Recv(data, size*2, MPI_DOUBLE, bankmaster[id % bank_size], 1, comm_bank, &status);
+#endif
+    return 1;
+}
+
 // save data in Bank with identity id as part of block with identity nodeid.
 int BankAccount::put_nodedata(int id, int nodeid, int size, double *data) {
 #ifdef MRCPP_HAS_MPI
diff --git a/src/utils/Bank.h b/src/utils/Bank.h
index 501faa7a0..7293d73ab 100644
--- a/src/utils/Bank.h
+++ b/src/utils/Bank.h
@@ -100,9 +100,13 @@ class BankAccount {
     int put_func(int id, ComplexFunction &func);
     int get_func(int id, ComplexFunction &func, int wait = 0);
     int put_data(int id, int size, double *data);
+    int put_data(int id, int size, ComplexDouble *data);
     int get_data(int id, int size, double *data);
+    int get_data(int id, int size, ComplexDouble *data);
     int put_data(NodeIndex<3> nIdx, int size, double *data);
+    int put_data(NodeIndex<3> nIdx, int size, ComplexDouble *data);
     int get_data(NodeIndex<3> nIdx, int size, double *data);
+    int get_data(NodeIndex<3> nIdx, int size, ComplexDouble *data);
     int put_nodedata(int id, int nodeid, int size, double *data);
     int get_nodedata(int id, int nodeid, int size, double *data, std::vector<int> &idVec);
     int get_nodeblock(int nodeid, double *data, std::vector<int> &idVec);
diff --git a/src/utils/ComplexFunction.h b/src/utils/ComplexFunction.h
index cf33cadfb..c43d3475c 100644
--- a/src/utils/ComplexFunction.h
+++ b/src/utils/ComplexFunction.h
@@ -22,7 +22,7 @@ class MPI_FuncVector;
 namespace mrcpp {
 
 class BankAccount;
-template <int D> class FunctionTree;
+  template <int D, typename T> class FunctionTree;
 template <int D> class MultiResolutionAnalysis;
 
 using ComplexDouble = std::complex<double>;
@@ -58,8 +58,8 @@ class TreePtr final {
         if (this->func_data.is_shared and mpi::share_size > 1) {
             // Memory size in MB defined in input. Virtual memory, does not cost anything if not used.
 #ifdef MRCPP_HAS_MPI
-            this->shared_mem_re = new mrcpp::SharedMemory(mpi::comm_share, mpi::shared_memory_size);
-            this->shared_mem_im = new mrcpp::SharedMemory(mpi::comm_share, mpi::shared_memory_size);
+            this->shared_mem_re = new mrcpp::SharedMemory<double>(mpi::comm_share, mpi::shared_memory_size);
+            this->shared_mem_im = new mrcpp::SharedMemory<double>(mpi::comm_share, mpi::shared_memory_size);
 #endif
         }
     }
@@ -75,10 +75,10 @@ class TreePtr final {
 
 private:
     FunctionData func_data;
-    mrcpp::SharedMemory *shared_mem_re;
-    mrcpp::SharedMemory *shared_mem_im;
-    mrcpp::FunctionTree<3> *re; ///< Real part of function
-    mrcpp::FunctionTree<3> *im; ///< Imaginary part of function
+    mrcpp::SharedMemory<double> *shared_mem_re;
+    mrcpp::SharedMemory<double> *shared_mem_im;
+    mrcpp::FunctionTree<3, double> *re; ///< Real part of function
+    mrcpp::FunctionTree<3, double> *im; ///< Imaginary part of function
 
     void flushFuncData() {
         this->func_data.real_size = 0;
@@ -121,10 +121,10 @@ class ComplexFunction {
     FunctionData &getFunctionData();
     int occ() const { return this->func_ptr->func_data.occ; }
     int spin() const { return this->func_ptr->func_data.spin; }
-    FunctionTree<3> &real() { return *this->func_ptr->re; }
-    FunctionTree<3> &imag() { return *this->func_ptr->im; }
-    const FunctionTree<3> &real() const { return *this->func_ptr->re; }
-    const FunctionTree<3> &imag() const { return *this->func_ptr->im; }
+    FunctionTree<3, double> &real() { return *this->func_ptr->re; }
+    FunctionTree<3, double> &imag() { return *this->func_ptr->im; }
+    const FunctionTree<3, double> &real() const { return *this->func_ptr->re; }
+    const FunctionTree<3, double> &imag() const { return *this->func_ptr->im; }
     void release() { this->func_ptr.reset(); }
     bool conjugate() const { return this->conj; }
     MultiResolutionAnalysis<3> *funcMRA = nullptr;
@@ -141,8 +141,8 @@ class ComplexFunction {
     int getSizeNodes(int type) const;
     int getNNodes(int type) const;
 
-    void setReal(mrcpp::FunctionTree<3> *tree);
-    void setImag(mrcpp::FunctionTree<3> *tree);
+    void setReal(mrcpp::FunctionTree<3, double> *tree);
+    void setImag(mrcpp::FunctionTree<3, double> *tree);
 
     double norm() const;
     double squaredNorm() const;
@@ -172,8 +172,8 @@ void project(ComplexFunction &out, RepresentableFunction<3> &f, int type, double
 void multiply(ComplexFunction &out, ComplexFunction inp_a, ComplexFunction inp_b, double prec, bool absPrec = false, bool useMaxNorms = false);
 void multiply_real(ComplexFunction &out, ComplexFunction inp_a, ComplexFunction inp_b, double prec, bool absPrec = false, bool useMaxNorms = false);
 void multiply_imag(ComplexFunction &out, ComplexFunction inp_a, ComplexFunction inp_b, double prec, bool absPrec = false, bool useMaxNorms = false);
-void multiply(ComplexFunction &out, ComplexFunction &inp_a, RepresentableFunction<3> &f, double prec, int nrefine = 0);
-void multiply(ComplexFunction &out, FunctionTree<3> &inp_a, RepresentableFunction<3> &f, double prec, int nrefine = 0);
+void multiply(ComplexFunction &out, ComplexFunction &inp_a, RepresentableFunction<3, double> &f, double prec, int nrefine = 0);
+void multiply(ComplexFunction &out, FunctionTree<3, double> &inp_a, RepresentableFunction<3, double> &f, double prec, int nrefine = 0);
 void linear_combination(ComplexFunction &out, const ComplexVector &c, std::vector<ComplexFunction> &inp, double prec);
 } // namespace cplxfunc
 
@@ -187,7 +187,7 @@ class MPI_FuncVector : public std::vector<ComplexFunction> {
 namespace mpifuncvec {
 void rotate(MPI_FuncVector &Phi, const ComplexMatrix &U, double prec = -1.0);
 void rotate(MPI_FuncVector &Phi, const ComplexMatrix &U, MPI_FuncVector &Psi, double prec = -1.0);
-void save_nodes(MPI_FuncVector &Phi, mrcpp::FunctionTree<3> &refTree, BankAccount &account, int sizes = -1);
+void save_nodes(MPI_FuncVector &Phi, mrcpp::FunctionTree<3, double> &refTree, BankAccount &account, int sizes = -1);
 MPI_FuncVector multiply(MPI_FuncVector &Phi, RepresentableFunction<3> &f, double prec = -1.0, ComplexFunction *Func = nullptr, int nrefine = 1, bool all = false);
 ComplexVector dot(MPI_FuncVector &Bra, MPI_FuncVector &Ket);
 ComplexMatrix calc_lowdin_matrix(MPI_FuncVector &Phi);
diff --git a/src/utils/Plotter.cpp b/src/utils/Plotter.cpp
index 455bb57e6..b24f2a643 100644
--- a/src/utils/Plotter.cpp
+++ b/src/utils/Plotter.cpp
@@ -37,24 +37,24 @@ namespace mrcpp {
  *
  *  @param[in] o: Plot origin, default `(0, 0, ... , 0)`
  */
-template <int D>
-Plotter<D>::Plotter(const Coord<D> &o)
+template <int D, typename T>
+Plotter<D, T>::Plotter(const Coord<D> &o)
         : O(o) {
-    setSuffix(Plotter<D>::Line, ".line");
-    setSuffix(Plotter<D>::Surface, ".surf");
-    setSuffix(Plotter<D>::Cube, ".cube");
-    setSuffix(Plotter<D>::Grid, ".grid");
+    setSuffix(Plotter<D, T>::Line, ".line");
+    setSuffix(Plotter<D, T>::Surface, ".surf");
+    setSuffix(Plotter<D, T>::Cube, ".cube");
+    setSuffix(Plotter<D, T>::Grid, ".grid");
 }
 
 /** @brief Set file extension for output file
  *
- *  @param[in] t: Plot type (`Plotter<D>::Line`, `::Surface`, `::Cube`, `::Grid`)
+ *  @param[in] t: Plot type (`Plotter<D, T>::Line`, `::Surface`, `::Cube`, `::Grid`)
  *  @param[in] s: Extension string, default `.line`, `.surf`, `.cube`, `.grid`
  *
  *  @details The file name you decide for the output will get a predefined
  *  suffix that differentiates between different types of plot.
  */
-template <int D> void Plotter<D>::setSuffix(int t, const std::string &s) {
+template <int D, typename T> void Plotter<D, T>::setSuffix(int t, const std::string &s) {
     this->suffix.insert(std::pair<int, std::string>(t, s));
 }
 
@@ -62,7 +62,7 @@ template <int D> void Plotter<D>::setSuffix(int t, const std::string &s) {
  *
  *  @param[in] o: Plot origin, default `(0, 0, ... , 0)`
  */
-template <int D> void Plotter<D>::setOrigin(const Coord<D> &o) {
+template <int D, typename T> void Plotter<D, T>::setOrigin(const Coord<D> &o) {
     this->O = o;
 }
 
@@ -72,7 +72,7 @@ template <int D> void Plotter<D>::setOrigin(const Coord<D> &o) {
  *  @param[in] b: B vector
  *  @param[in] c: C vector
  */
-template <int D> void Plotter<D>::setRange(const Coord<D> &a, const Coord<D> &b, const Coord<D> &c) {
+template <int D, typename T> void Plotter<D, T>::setRange(const Coord<D> &a, const Coord<D> &b, const Coord<D> &c) {
     this->A = a;
     this->B = b;
     this->C = c;
@@ -89,10 +89,10 @@ template <int D> void Plotter<D>::setRange(const Coord<D> &a, const Coord<D> &b,
  *  separate file, and will print only nodes owned by itself (pluss the
  *  rootNodes).
  */
-template <int D> void Plotter<D>::gridPlot(const MWTree<D> &tree, const std::string &fname) {
+template <int D, typename T> void Plotter<D, T>::gridPlot(const MWTree<D, T> &tree, const std::string &fname) {
     println(20, "----------Grid Plot-----------");
     std::stringstream file;
-    file << fname << this->suffix[Plotter<D>::Grid];
+    file << fname << this->suffix[Plotter<D, T>::Grid];
     openPlot(file.str());
     writeGrid(tree);
     closePlot();
@@ -109,16 +109,16 @@ template <int D> void Plotter<D>::gridPlot(const MWTree<D> &tree, const std::str
  *  vector A starting from the origin O to a file named fname + file extension
  *  (".line" as default).
  */
-template <int D>
-void Plotter<D>::linePlot(const std::array<int, 1> &npts,
-                          const RepresentableFunction<D> &func,
+template <int D, typename T>
+void Plotter<D, T>::linePlot(const std::array<int, 1> &npts,
+                          const RepresentableFunction<D, T> &func,
                           const std::string &fname) {
     println(20, "----------Line Plot-----------");
     std::stringstream file;
-    file << fname << this->suffix[Plotter<D>::Line];
+    file << fname << this->suffix[Plotter<D, T>::Line];
     if (verifyRange(1)) { // Verifies only A vector
         Eigen::MatrixXd coords = calcLineCoordinates(npts[0]);
-        Eigen::VectorXd values = evaluateFunction(func, coords);
+        Eigen::Matrix< T, Eigen::Dynamic, 1 > values = evaluateFunction(func, coords);
         openPlot(file.str());
         writeData(coords, values);
         closePlot();
@@ -138,16 +138,16 @@ void Plotter<D>::linePlot(const std::array<int, 1> &npts,
  *  vectors A (npts[0] points) and B (npts[1] points), starting from the
  *  origin O, to a file named fname + file extension (".surf" as default).
  */
-template <int D>
-void Plotter<D>::surfPlot(const std::array<int, 2> &npts,
-                          const RepresentableFunction<D> &func,
+template <int D, typename T>
+void Plotter<D, T>::surfPlot(const std::array<int, 2> &npts,
+                          const RepresentableFunction<D, T> &func,
                           const std::string &fname) {
     println(20, "--------Surface Plot----------");
     std::stringstream file;
-    file << fname << this->suffix[Plotter<D>::Surface];
+    file << fname << this->suffix[Plotter<D, T>::Surface];
     if (verifyRange(2)) { // Verifies A and B vectors
         Eigen::MatrixXd coords = calcSurfCoordinates(npts[0], npts[1]);
-        Eigen::VectorXd values = evaluateFunction(func, coords);
+        Eigen::Matrix< T, Eigen::Dynamic, 1 > values = evaluateFunction(func, coords);
         openPlot(file.str());
         writeData(coords, values);
         closePlot();
@@ -168,16 +168,16 @@ void Plotter<D>::surfPlot(const std::array<int, 2> &npts,
  *  starting from the origin O, to a file named fname + file extension
  *  (".cube" as default).
  */
-template <int D>
-void Plotter<D>::cubePlot(const std::array<int, 3> &npts,
-                          const RepresentableFunction<D> &func,
+template <int D, typename T>
+void Plotter<D, T>::cubePlot(const std::array<int, 3> &npts,
+                          const RepresentableFunction<D, T> &func,
                           const std::string &fname) {
     println(20, "----------Cube Plot-----------");
     std::stringstream file;
-    file << fname << this->suffix[Plotter<D>::Cube];
+    file << fname << this->suffix[Plotter<D, T>::Cube];
     if (verifyRange(3)) { // Verifies A, B and C vectors
         Eigen::MatrixXd coords = calcCubeCoordinates(npts[0], npts[1], npts[2]);
-        Eigen::VectorXd values = evaluateFunction(func, coords);
+        Eigen::Matrix< T, Eigen::Dynamic, 1 > values = evaluateFunction(func, coords);
         openPlot(file.str());
         writeCube(npts, values);
         closePlot();
@@ -192,7 +192,7 @@ void Plotter<D>::cubePlot(const std::array<int, 3> &npts,
  *  @details Generating a vector of pts_a equidistant coordinates that makes
  *  up the vector A in D dimensions, starting from the origin O.
  */
-template <int D> Eigen::MatrixXd Plotter<D>::calcLineCoordinates(int pts_a) const {
+template <int D, typename T> Eigen::MatrixXd Plotter<D, T>::calcLineCoordinates(int pts_a) const {
     MatrixXd coords;
     if (pts_a > 0) {
         Coord<D> a = calcStep(this->A, pts_a);
@@ -211,7 +211,7 @@ template <int D> Eigen::MatrixXd Plotter<D>::calcLineCoordinates(int pts_a) cons
  *  @details Generating a vector of equidistant coordinates that makes up the
  *  area spanned by vectors A and B in D dimensions, starting from the origin O.
  */
-template <int D> Eigen::MatrixXd Plotter<D>::calcSurfCoordinates(int pts_a, int pts_b) const {
+template <int D, typename T> Eigen::MatrixXd Plotter<D, T>::calcSurfCoordinates(int pts_a, int pts_b) const {
     if (D < 2) MSG_ERROR("Cannot surfPlot less than 2D");
 
     MatrixXd coords;
@@ -240,7 +240,7 @@ template <int D> Eigen::MatrixXd Plotter<D>::calcSurfCoordinates(int pts_a, int
  *  volume spanned by vectors A, B and C in D dimensions, starting from
  *  the origin O.
  */
-template <int D> Eigen::MatrixXd Plotter<D>::calcCubeCoordinates(int pts_a, int pts_b, int pts_c) const {
+template <int D, typename T> Eigen::MatrixXd Plotter<D, T>::calcCubeCoordinates(int pts_a, int pts_b, int pts_c) const {
     if (D < 3) MSG_ERROR("Cannot cubePlot less than 3D function");
 
     MatrixXd coords;
@@ -272,12 +272,12 @@ template <int D> Eigen::MatrixXd Plotter<D>::calcCubeCoordinates(int pts_a, int
  *  this routine evaluates the function in these points and stores the results
  *  in the vector "values".
  */
-template <int D>
-Eigen::VectorXd Plotter<D>::evaluateFunction(const RepresentableFunction<D> &func,
+template <int D, typename T>
+Eigen::Matrix< T, Eigen::Dynamic, 1 > Plotter<D, T>::evaluateFunction(const RepresentableFunction<D, T> &func,
                                              const Eigen::MatrixXd &coords) const {
     auto npts = coords.rows();
     if (npts == 0) MSG_ERROR("Empty coordinates");
-    Eigen::VectorXd values = VectorXd::Zero(npts);
+    Eigen::Matrix< T, Eigen::Dynamic, 1 > values = Eigen::Matrix< T, Eigen::Dynamic, 1 >::Zero(npts);
 #pragma omp parallel for schedule(static) num_threads(mrcpp_get_num_threads())
     for (auto i = 0; i < npts; i++) {
         Coord<D> r{};
@@ -294,7 +294,7 @@ Eigen::VectorXd Plotter<D>::evaluateFunction(const RepresentableFunction<D> &fun
  *  point number (between 0 and nPoints), coordinates 1 through D and the
  *  function value.
  */
-template <int D> void Plotter<D>::writeData(const Eigen::MatrixXd &coords, const Eigen::VectorXd &values) {
+  template <int D, typename T> void Plotter<D, T>::writeData(const Eigen::MatrixXd &coords, const Eigen::Matrix< T, Eigen::Dynamic, 1 > &values) {
     if (coords.rows() != values.size()) INVALID_ARG_ABORT;
     std::ofstream &o = *this->fout;
     for (auto i = 0; i < values.size(); i++) {
@@ -308,17 +308,17 @@ template <int D> void Plotter<D>::writeData(const Eigen::MatrixXd &coords, const
 }
 
 // Specialized for D=3 below
-template <int D> void Plotter<D>::writeCube(const std::array<int, 3> &npts, const Eigen::VectorXd &values) {
+  template <int D, typename T> void Plotter<D, T>::writeCube(const std::array<int, 3> &npts, const Eigen::Matrix< T, Eigen::Dynamic, 1 > &values) {
     NOT_IMPLEMENTED_ABORT
 }
 
 // Specialized for D=3 below
-template <int D> void Plotter<D>::writeNodeGrid(const MWNode<D> &node, const std::string &color) {
+template <int D, typename T> void Plotter<D, T>::writeNodeGrid(const MWNode<D, T> &node, const std::string &color) {
     NOT_IMPLEMENTED_ABORT
 }
 
 // Specialized for D=3 below
-template <int D> void Plotter<D>::writeGrid(const MWTree<D> &tree) {
+template <int D, typename T> void Plotter<D, T>::writeGrid(const MWTree<D, T> &tree) {
     NOT_IMPLEMENTED_ABORT
 }
 
@@ -326,7 +326,7 @@ template <int D> void Plotter<D>::writeGrid(const MWTree<D> &tree) {
  *
  *  @details Opens a file output stream fout for file named fname.
  */
-template <int D> void Plotter<D>::openPlot(const std::string &fname) {
+template <int D, typename T> void Plotter<D, T>::openPlot(const std::string &fname) {
     if (fname.empty()) {
         if (this->fout == nullptr) {
             MSG_ERROR("Plot file not set!");
@@ -350,7 +350,7 @@ template <int D> void Plotter<D>::openPlot(const std::string &fname) {
  *
  *  @details Closes the file output stream fout.
  */
-template <int D> void Plotter<D>::closePlot() {
+template <int D, typename T> void Plotter<D, T>::closePlot() {
     if (this->fout != nullptr) this->fout->close();
     this->fout = nullptr;
 }
@@ -462,7 +462,7 @@ template <> void Plotter<3>::writeGrid(const MWTree<3> &tree) {
 }
 
 /** @brief Checks the validity of the plotting range */
-template <int D> bool Plotter<D>::verifyRange(int dim) const {
+template <int D, typename T> bool Plotter<D, T>::verifyRange(int dim) const {
 
     auto is_len_zero = [](Coord<D> vec) {
         double vec_sq = 0.0;
@@ -483,14 +483,18 @@ template <int D> bool Plotter<D>::verifyRange(int dim) const {
 }
 
 /** @brief Compute step length to cover vector with `pts` points, including edges */
-template <int D> Coord<D> Plotter<D>::calcStep(const Coord<D> &vec, int pts) const {
+template <int D, typename T> Coord<D> Plotter<D, T>::calcStep(const Coord<D> &vec, int pts) const {
     Coord<D> step;
     for (auto d = 0; d < D; d++) step[d] = vec[d] / (pts - 1.0);
     return step;
 }
 
-template class Plotter<1>;
-template class Plotter<2>;
-template class Plotter<3>;
+template class Plotter<1, double>;
+template class Plotter<2, double>;
+template class Plotter<3, double>;
+
+template class Plotter<1, ComplexDouble>;
+template class Plotter<2, ComplexDouble>;
+template class Plotter<3, ComplexDouble>;
 
 } // namespace mrcpp
diff --git a/src/utils/Plotter.h b/src/utils/Plotter.h
index d38941b27..547150197 100644
--- a/src/utils/Plotter.h
+++ b/src/utils/Plotter.h
@@ -56,7 +56,7 @@ namespace mrcpp {
  *
  */
 
-template <int D> class Plotter {
+template <int D, typename T> class Plotter {
 public:
     explicit Plotter(const Coord<D> &o = {});
     virtual ~Plotter() = default;
@@ -65,10 +65,10 @@ template <int D> class Plotter {
     void setOrigin(const Coord<D> &o);
     void setRange(const Coord<D> &a, const Coord<D> &b = {}, const Coord<D> &c = {});
 
-    void gridPlot(const MWTree<D> &tree, const std::string &fname);
-    void linePlot(const std::array<int, 1> &npts, const RepresentableFunction<D> &func, const std::string &fname);
-    void surfPlot(const std::array<int, 2> &npts, const RepresentableFunction<D> &func, const std::string &fname);
-    void cubePlot(const std::array<int, 3> &npts, const RepresentableFunction<D> &func, const std::string &fname);
+    void gridPlot(const MWTree<D, T> &tree, const std::string &fname);
+    void linePlot(const std::array<int, 1> &npts, const RepresentableFunction<D, T> &func, const std::string &fname);
+    void surfPlot(const std::array<int, 2> &npts, const RepresentableFunction<D, T> &func, const std::string &fname);
+    void cubePlot(const std::array<int, 3> &npts, const RepresentableFunction<D, T> &func, const std::string &fname);
 
     enum type { Line, Surface, Cube, Grid };
 
@@ -86,13 +86,13 @@ template <int D> class Plotter {
     Eigen::MatrixXd calcSurfCoordinates(int pts_a, int pts_b) const;
     Eigen::MatrixXd calcCubeCoordinates(int pts_a, int pts_b, int pts_c) const;
 
-    Eigen::VectorXd evaluateFunction(const RepresentableFunction<D> &func, const Eigen::MatrixXd &coords) const;
+    Eigen::Matrix< T, Eigen::Dynamic, 1 > evaluateFunction(const RepresentableFunction<D, T> &func, const Eigen::MatrixXd &coords) const;
 
-    void writeData(const Eigen::MatrixXd &coords, const Eigen::VectorXd &values);
-    virtual void writeCube(const std::array<int, 3> &npts, const Eigen::VectorXd &values);
+  void writeData(const Eigen::MatrixXd &coords, const Eigen::Matrix< T, Eigen::Dynamic, 1 > &values);
+  virtual void writeCube(const std::array<int, 3> &npts, const Eigen::Matrix< T, Eigen::Dynamic, 1 >  &values);
 
-    void writeGrid(const MWTree<D> &tree);
-    void writeNodeGrid(const MWNode<D> &node, const std::string &color);
+    void writeGrid(const MWTree<D, T> &tree);
+    void writeNodeGrid(const MWNode<D, T> &node, const std::string &color);
 
 private:
     bool verifyRange(int dim) const;
diff --git a/src/utils/Printer.cpp b/src/utils/Printer.cpp
index d9d04f4bd..957d7322b 100644
--- a/src/utils/Printer.cpp
+++ b/src/utils/Printer.cpp
@@ -265,7 +265,7 @@ void print::tree(int level, const std::string &txt, int n, int m, double t) {
  * @param[in] tree: Tree to be printed
  * @param[in] timer: Timer to be evaluated
  */
-template <int D> void print::tree(int level, const std::string &txt, const MWTree<D> &tree, const Timer &timer) {
+  template <int D, typename T> void print::tree(int level, const std::string &txt, const MWTree<D, T> &tree, const Timer &timer) {
     if (level > Printer::getPrintLevel()) return;
 
     auto n = tree.getNNodes();
diff --git a/src/utils/Printer.h b/src/utils/Printer.h
index dc4935aa8..c021155e8 100644
--- a/src/utils/Printer.h
+++ b/src/utils/Printer.h
@@ -39,7 +39,7 @@
 namespace mrcpp {
 
 class Timer;
-template <int D> class MWTree;
+template <int D, typename T> class MWTree;
 
 /** @class Printer
  *
@@ -128,7 +128,7 @@ void memory(int level, const std::string &txt);
 void value(int level, const std::string &txt, double v, const std::string &unit = "", int p = -1, bool sci = true);
 void time(int level, const std::string &txt, const Timer &timer);
 void tree(int level, const std::string &txt, int n, int m, double t);
-template <int D> void tree(int level, const std::string &txt, const MWTree<D> &tree, const Timer &timer);
+template <int D, typename T> void tree(int level, const std::string &txt, const MWTree<D, T> &tree, const Timer &timer);
 } // namespace print
 
 // clang-format off
diff --git a/src/utils/math_utils.cpp b/src/utils/math_utils.cpp
index 8506be298..5ee9294f6 100644
--- a/src/utils/math_utils.cpp
+++ b/src/utils/math_utils.cpp
@@ -185,6 +185,20 @@ void math_utils::apply_filter(double *out, double *in, const MatrixXd &filter, i
 #endif
 }
 
+void math_utils::apply_filter(ComplexDouble *out, ComplexDouble *in, const MatrixXd &filter, int kp1, int kp1_dm1, double fac) {
+  //#ifdef HAVE_BLAS
+//    cblas_dgemm(CblasColMajor, CblasTrans, CblasNoTrans, kp1_dm1, kp1, kp1, 1.0, in, kp1, filter.data(), kp1, fac, out, kp1_dm1);
+//#else
+    Map<MatrixXcd> f(in, kp1, kp1_dm1);
+    Map<MatrixXcd> g(out, kp1_dm1, kp1);
+    if (fac < MachineZero) {
+        g.noalias() = f.transpose() * filter;
+    } else {
+        g.noalias() += f.transpose() * filter;
+    }
+//#endif
+}
+
 /** Make a nD-representation from 1D-representations of separable functions.
  *
  * This method uses the "output" vector as initial input, in order to
diff --git a/src/utils/math_utils.h b/src/utils/math_utils.h
index 9c371aa51..9dcdb6956 100644
--- a/src/utils/math_utils.h
+++ b/src/utils/math_utils.h
@@ -67,6 +67,7 @@ double matrix_norm_1(const Eigen::MatrixXd &M);
 double matrix_norm_2(const Eigen::MatrixXd &M);
 
 void apply_filter(double *out, double *in, const Eigen::MatrixXd &filter, int kp1, int kp1_dm1, double fac);
+void apply_filter(ComplexDouble *out, ComplexDouble *in, const Eigen::MatrixXd &filter, int kp1, int kp1_dm1, double fac);
 
 void tensor_expand_coefs(int dim, int dir, int kp1, int kp1_d, const Eigen::MatrixXd &primitive, Eigen::VectorXd &expanded);
 
diff --git a/src/utils/mpi_utils.cpp b/src/utils/mpi_utils.cpp
index d61f2bd23..e193aea3a 100644
--- a/src/utils/mpi_utils.cpp
+++ b/src/utils/mpi_utils.cpp
@@ -36,7 +36,7 @@ namespace mrcpp {
  *  @param[in] comm: Communicator sharing resources
  *  @param[in] sh_size: Memory size, in MB
  */
-SharedMemory::SharedMemory(mrcpp::mpi_comm comm, int sh_size)
+template <typename T> SharedMemory<T>::SharedMemory(mrcpp::mpi_comm comm, int sh_size)
         : sh_start_ptr(nullptr)
         , sh_end_ptr(nullptr)
         , sh_max_ptr(nullptr)
@@ -57,18 +57,18 @@ SharedMemory::SharedMemory(mrcpp::mpi_comm comm, int sh_size)
     int qdisp = 0;
     MPI_Win_shared_query(this->sh_win, 0, &qsize, &qdisp, &this->sh_start_ptr);
     MPI_Win_fence(0, this->sh_win);
-    this->sh_max_ptr = this->sh_start_ptr + qsize / sizeof(double);
+    this->sh_max_ptr = this->sh_start_ptr + qsize / sizeof(T);
     this->sh_end_ptr = this->sh_start_ptr;
 #endif
 }
 
-void SharedMemory::clear() {
+template <typename T> void SharedMemory<T>::clear() {
 #ifdef MRCPP_HAS_MPI
     this->sh_end_ptr = this->sh_start_ptr;
 #endif
 }
 
-SharedMemory::~SharedMemory() {
+template <typename T> SharedMemory<T>::~SharedMemory() {
 #ifdef MRCPP_HAS_MPI
     // deallocates the memory block
     MPI_Win_free(&this->sh_win);
@@ -88,7 +88,7 @@ SharedMemory::~SharedMemory() {
  *  to speed up communication, otherwise it will be communicated in a separate
  *  step before the main communication.
  */
-template <int D> void send_tree(FunctionTree<D> &tree, int dst, int tag, mrcpp::mpi_comm comm, int nChunks, bool coeff) {
+template <int D, typename T> void send_tree(FunctionTree<D, T> &tree, int dst, int tag, mrcpp::mpi_comm comm, int nChunks, bool coeff) {
 #ifdef MRCPP_HAS_MPI
     auto &allocator = tree.getNodeAllocator();
 
@@ -121,7 +121,7 @@ template <int D> void send_tree(FunctionTree<D> &tree, int dst, int tag, mrcpp::
  *  to speed up communication, otherwise it will be communicated in a separate
  *  step before the main communication.
  */
-template <int D> void recv_tree(FunctionTree<D> &tree, int src, int tag, mrcpp::mpi_comm comm, int nChunks, bool coeff) {
+template <int D, typename T> void recv_tree(FunctionTree<D, T> &tree, int src, int tag, mrcpp::mpi_comm comm, int nChunks, bool coeff) {
 #ifdef MRCPP_HAS_MPI
     MPI_Status status;
     auto &allocator = tree.getNodeAllocator();
@@ -157,7 +157,7 @@ template <int D> void recv_tree(FunctionTree<D> &tree, int src, int tag, mrcpp::
  *  @details This function should be called every time a shared function is
  *  updated, in order to update the local memory of each MPI process.
  */
-template <int D> void share_tree(FunctionTree<D> &tree, int src, int tag, mrcpp::mpi_comm comm) {
+template <int D, typename T> void share_tree(FunctionTree<D, T> &tree, int src, int tag, mrcpp::mpi_comm comm) {
 #ifdef MRCPP_HAS_MPI
     Timer t1;
     auto &allocator = tree.getNodeAllocator();
@@ -197,15 +197,27 @@ template <int D> void share_tree(FunctionTree<D> &tree, int src, int tag, mrcpp:
     println(10, " Time share                  " << std::setw(30) << t1.elapsed());
 #endif
 }
-
-template void send_tree<1>(FunctionTree<1> &tree, int dst, int tag, mrcpp::mpi_comm comm, int nChunks, bool coeff);
-template void send_tree<2>(FunctionTree<2> &tree, int dst, int tag, mrcpp::mpi_comm comm, int nChunks, bool coeff);
-template void send_tree<3>(FunctionTree<3> &tree, int dst, int tag, mrcpp::mpi_comm comm, int nChunks, bool coeff);
-template void recv_tree<1>(FunctionTree<1> &tree, int src, int tag, mrcpp::mpi_comm comm, int nChunks, bool coeff);
-template void recv_tree<2>(FunctionTree<2> &tree, int src, int tag, mrcpp::mpi_comm comm, int nChunks, bool coeff);
-template void recv_tree<3>(FunctionTree<3> &tree, int src, int tag, mrcpp::mpi_comm comm, int nChunks, bool coeff);
-template void share_tree<1>(FunctionTree<1> &tree, int src, int tag, mrcpp::mpi_comm comm);
-template void share_tree<2>(FunctionTree<2> &tree, int src, int tag, mrcpp::mpi_comm comm);
-template void share_tree<3>(FunctionTree<3> &tree, int src, int tag, mrcpp::mpi_comm comm);
+template class SharedMemory<double>;
+template class SharedMemory<ComplexDouble>;
+
+template void send_tree<1>(FunctionTree<1, double> &tree, int dst, int tag, mrcpp::mpi_comm comm, int nChunks, bool coeff);
+template void send_tree<2>(FunctionTree<2, double> &tree, int dst, int tag, mrcpp::mpi_comm comm, int nChunks, bool coeff);
+template void send_tree<3>(FunctionTree<3, double> &tree, int dst, int tag, mrcpp::mpi_comm comm, int nChunks, bool coeff);
+template void recv_tree<1>(FunctionTree<1, double> &tree, int src, int tag, mrcpp::mpi_comm comm, int nChunks, bool coeff);
+template void recv_tree<2>(FunctionTree<2, double> &tree, int src, int tag, mrcpp::mpi_comm comm, int nChunks, bool coeff);
+template void recv_tree<3>(FunctionTree<3, double> &tree, int src, int tag, mrcpp::mpi_comm comm, int nChunks, bool coeff);
+template void share_tree<1>(FunctionTree<1, double> &tree, int src, int tag, mrcpp::mpi_comm comm);
+template void share_tree<2>(FunctionTree<2, double> &tree, int src, int tag, mrcpp::mpi_comm comm);
+template void share_tree<3>(FunctionTree<3, double> &tree, int src, int tag, mrcpp::mpi_comm comm);
+
+template void send_tree<1>(FunctionTree<1, ComplexDouble> &tree, int dst, int tag, mrcpp::mpi_comm comm, int nChunks, bool coeff);
+template void send_tree<2>(FunctionTree<2, ComplexDouble> &tree, int dst, int tag, mrcpp::mpi_comm comm, int nChunks, bool coeff);
+template void send_tree<3>(FunctionTree<3, ComplexDouble> &tree, int dst, int tag, mrcpp::mpi_comm comm, int nChunks, bool coeff);
+template void recv_tree<1>(FunctionTree<1, ComplexDouble> &tree, int src, int tag, mrcpp::mpi_comm comm, int nChunks, bool coeff);
+template void recv_tree<2>(FunctionTree<2, ComplexDouble> &tree, int src, int tag, mrcpp::mpi_comm comm, int nChunks, bool coeff);
+template void recv_tree<3>(FunctionTree<3, ComplexDouble> &tree, int src, int tag, mrcpp::mpi_comm comm, int nChunks, bool coeff);
+template void share_tree<1>(FunctionTree<1, ComplexDouble> &tree, int src, int tag, mrcpp::mpi_comm comm);
+template void share_tree<2>(FunctionTree<2, ComplexDouble> &tree, int src, int tag, mrcpp::mpi_comm comm);
+template void share_tree<3>(FunctionTree<3, ComplexDouble> &tree, int src, int tag, mrcpp::mpi_comm comm);
 
 } // namespace mrcpp
diff --git a/src/utils/mpi_utils.h b/src/utils/mpi_utils.h
index 1b94b0dc9..93211fd1a 100644
--- a/src/utils/mpi_utils.h
+++ b/src/utils/mpi_utils.h
@@ -74,26 +74,26 @@ namespace mrcpp {
  *  communicator. In order to allocate a FunctionTree in shared memory,
  *  simply pass a SharedMemory object to the FunctionTree constructor.
  */
-class SharedMemory {
+template <typename T> class SharedMemory {
 public:
     SharedMemory(mrcpp::mpi_comm comm, int sh_size);
     SharedMemory(const SharedMemory &mem) = delete;
-    SharedMemory &operator=(const SharedMemory &mem) = delete;
+    SharedMemory<T> &operator=(const SharedMemory<T> &mem) = delete;
     ~SharedMemory();
 
     void clear(); // show shared memory as entirely available
 
-    double *sh_start_ptr;  // start of shared block
-    double *sh_end_ptr;    // end of used part
-    double *sh_max_ptr;    // end of shared block
+    T *sh_start_ptr;  // start of shared block
+    T *sh_end_ptr;    // end of used part
+    T *sh_max_ptr;    // end of shared block
     mrcpp::mpi_win sh_win; // MPI window object
     int rank;              // rank among shared group
 };
 
-template <int D> class FunctionTree;
+template <int D, typename T> class FunctionTree;
 
-template <int D> void send_tree(FunctionTree<D> &tree, int dst, int tag, mrcpp::mpi_comm comm, int nChunks = -1, bool coeff = true);
-template <int D> void recv_tree(FunctionTree<D> &tree, int src, int tag, mrcpp::mpi_comm comm, int nChunks = -1, bool coeff = true);
-template <int D> void share_tree(FunctionTree<D> &tree, int src, int tag, mrcpp::mpi_comm comm);
+template <int D, typename T> void send_tree(FunctionTree<D, T> &tree, int dst, int tag, mrcpp::mpi_comm comm, int nChunks = -1, bool coeff = true);
+template <int D, typename T> void recv_tree(FunctionTree<D, T> &tree, int src, int tag, mrcpp::mpi_comm comm, int nChunks = -1, bool coeff = true);
+template <int D, typename T> void share_tree(FunctionTree<D, T> &tree, int src, int tag, mrcpp::mpi_comm comm);
 
 } // namespace mrcpp
diff --git a/src/utils/parallel.cpp b/src/utils/parallel.cpp
index 2877d12e9..85afe2426 100644
--- a/src/utils/parallel.cpp
+++ b/src/utils/parallel.cpp
@@ -406,7 +406,7 @@ void mpi::reduce_function(double prec, ComplexFunction &func, MPI_Comm comm) {
 }
 
 /** @brief make union tree and send into rank zero */
-void mpi::reduce_Tree_noCoeff(mrcpp::FunctionTree<3> &tree, MPI_Comm comm) {
+void mpi::reduce_Tree_noCoeff(mrcpp::FunctionTree<3, double> &tree, MPI_Comm comm) {
 /* 1) Each odd rank send to the left rank
    2) All odd ranks are "deleted" (can exit routine)
    3) new "effective" ranks are defined within the non-deleted ranks
@@ -446,10 +446,51 @@ void mpi::reduce_Tree_noCoeff(mrcpp::FunctionTree<3> &tree, MPI_Comm comm) {
 #endif
 }
 
+/** @brief make union tree and send into rank zero */
+void mpi::reduce_Tree_noCoeff(mrcpp::FunctionTree<3, ComplexDouble> &tree, MPI_Comm comm) {
+/* 1) Each odd rank send to the left rank
+   2) All odd ranks are "deleted" (can exit routine)
+   3) new "effective" ranks are defined within the non-deleted ranks
+      effective rank = rank/fac , where fac are powers of 2
+   4) repeat
+ */
+#ifdef MRCPP_HAS_MPI
+    int comm_size, comm_rank;
+    MPI_Comm_rank(comm, &comm_rank);
+    MPI_Comm_size(comm, &comm_size);
+    if (comm_size == 1) return;
+
+    int fac = 1; // powers of 2
+    while (fac < comm_size) {
+        if ((comm_rank / fac) % 2 == 0) {
+            // receive
+            int src = comm_rank + fac;
+            if (src < comm_size) {
+                int tag = 3333 + src;
+                mrcpp::FunctionTree<3, ComplexDouble> tree_i(tree.getMRA());
+                mrcpp::recv_tree(tree_i, src, tag, comm, -1, false);
+                tree.appendTreeNoCoeff(tree_i); // make union grid
+            }
+        }
+        if ((comm_rank / fac) % 2 == 1) {
+            // send
+            int dest = comm_rank - fac;
+            if (dest >= 0) {
+                int tag = 3333 + comm_rank;
+                mrcpp::send_tree(tree, dest, tag, comm, -1, false);
+                break; // once data is sent we are done
+            }
+        }
+        fac *= 2;
+    }
+    MPI_Barrier(comm);
+#endif
+}
+
 /** @brief make union tree without coeff and send to all
  *  Include both real and imaginary parts
  */
-void mpi::allreduce_Tree_noCoeff(mrcpp::FunctionTree<3> &tree, vector<ComplexFunction> &Phi, MPI_Comm comm) {
+void mpi::allreduce_Tree_noCoeff(mrcpp::FunctionTree<3, double> &tree, vector<ComplexFunction> &Phi, MPI_Comm comm) {
     /* 1) make union grid of own orbitals
        2) make union grid with others orbitals (sent to rank zero)
        3) rank zero broadcast func to everybody
@@ -465,6 +506,25 @@ void mpi::allreduce_Tree_noCoeff(mrcpp::FunctionTree<3> &tree, vector<ComplexFun
     mpi::broadcast_Tree_noCoeff(tree, mpi::comm_wrk);
 }
 
+
+/** @brief make union tree without coeff and send to all
+ *  Include both real and imaginary parts
+ */
+    void mpi::allreduce_Tree_noCoeff(mrcpp::FunctionTree<3, ComplexDouble> &tree, vector<FunctionTree<3, ComplexDouble>> &Phi, MPI_Comm comm) {
+    /* 1) make union grid of own orbitals
+       2) make union grid with others orbitals (sent to rank zero)
+       3) rank zero broadcast func to everybody
+     */
+
+    int N = Phi.size();
+    for (int j = 0; j < N; j++) {
+        if (not mpi::my_orb(j)) continue;
+        tree.appendTreeNoCoeff(Phi[j]);
+    }
+    mpi::reduce_Tree_noCoeff(tree, mpi::comm_wrk);
+    mpi::broadcast_Tree_noCoeff(tree, mpi::comm_wrk);
+}
+
 /** @brief Distribute rank zero function to all ranks */
 void mpi::broadcast_function(ComplexFunction &func, MPI_Comm comm) {
 /* use same strategy as a reduce, but in reverse order */
@@ -498,7 +558,39 @@ void mpi::broadcast_function(ComplexFunction &func, MPI_Comm comm) {
 }
 
 /** @brief Distribute rank zero function to all ranks */
-void mpi::broadcast_Tree_noCoeff(mrcpp::FunctionTree<3> &tree, MPI_Comm comm) {
+void mpi::broadcast_Tree_noCoeff(mrcpp::FunctionTree<3, double> &tree, MPI_Comm comm) {
+/* use same strategy as a reduce, but in reverse order */
+#ifdef MRCPP_HAS_MPI
+    int comm_size, comm_rank;
+    MPI_Comm_rank(comm, &comm_rank);
+    MPI_Comm_size(comm, &comm_size);
+    if (comm_size == 1) return;
+
+    int fac = 1; // powers of 2
+    while (fac < comm_size) fac *= 2;
+    fac /= 2;
+
+    while (fac > 0) {
+        if (comm_rank % fac == 0 and (comm_rank / fac) % 2 == 1) {
+            // receive
+            int src = comm_rank - fac;
+            int tag = 4334 + comm_rank;
+            mrcpp::recv_tree(tree, src, tag, comm, -1, false);
+        }
+        if (comm_rank % fac == 0 and (comm_rank / fac) % 2 == 0) {
+            // send
+            int dst = comm_rank + fac;
+            int tag = 4334 + dst;
+            if (dst < comm_size) mrcpp::send_tree(tree, dst, tag, comm, -1, false);
+        }
+        fac /= 2;
+    }
+    MPI_Barrier(comm);
+#endif
+}
+
+/** @brief Distribute rank zero function to all ranks */
+void mpi::broadcast_Tree_noCoeff(mrcpp::FunctionTree<3, ComplexDouble> &tree, MPI_Comm comm) {
 /* use same strategy as a reduce, but in reverse order */
 #ifdef MRCPP_HAS_MPI
     int comm_size, comm_rank;
diff --git a/src/utils/parallel.h b/src/utils/parallel.h
index 78a3e2fd9..50c5ad581 100644
--- a/src/utils/parallel.h
+++ b/src/utils/parallel.h
@@ -54,9 +54,12 @@ void share_function(ComplexFunction &func, int src, int tag, MPI_Comm comm);
 void reduce_function(double prec, ComplexFunction &func, MPI_Comm comm);
 void broadcast_function(ComplexFunction &func, MPI_Comm comm);
 
-void reduce_Tree_noCoeff(mrcpp::FunctionTree<3> &tree, MPI_Comm comm);
-void allreduce_Tree_noCoeff(mrcpp::FunctionTree<3> &tree, std::vector<ComplexFunction> &Phi, MPI_Comm comm);
-void broadcast_Tree_noCoeff(mrcpp::FunctionTree<3> &tree, MPI_Comm comm);
+void reduce_Tree_noCoeff(mrcpp::FunctionTree<3, double> &tree, MPI_Comm comm);
+void allreduce_Tree_noCoeff(mrcpp::FunctionTree<3, double> &tree, std::vector<ComplexFunction> &Phi, MPI_Comm comm);
+void broadcast_Tree_noCoeff(mrcpp::FunctionTree<3, double> &tree, MPI_Comm comm);
+void reduce_Tree_noCoeff(mrcpp::FunctionTree<3, ComplexDouble> &tree, MPI_Comm comm);
+void allreduce_Tree_noCoeff(mrcpp::FunctionTree<3, ComplexDouble> &tree, std::vector<FunctionTree<3, ComplexDouble>> &Phi, MPI_Comm comm);
+void broadcast_Tree_noCoeff(mrcpp::FunctionTree<3, ComplexDouble> &tree, MPI_Comm comm);
 
 void allreduce_vector(IntVector &vec, MPI_Comm comm);
 void allreduce_vector(DoubleVector &vec, MPI_Comm comm);
diff --git a/src/utils/tree_utils.cpp b/src/utils/tree_utils.cpp
index 523d3e263..f45fcc158 100644
--- a/src/utils/tree_utils.cpp
+++ b/src/utils/tree_utils.cpp
@@ -44,7 +44,7 @@ namespace mrcpp {
  * Calculates the threshold that has to be met in the wavelet norm in order to
  * guarantee the precision in the function representation. Depends on the
  * square norm of the function and the requested relative accuracy. */
-template <int D> bool tree_utils::split_check(const MWNode<D> &node, double prec, double split_fac, bool abs_prec) {
+template <int D, typename T> bool tree_utils::split_check(const MWNode<D, T> &node, double prec, double split_fac, bool abs_prec) {
     bool split = false;
     if (prec > 0.0) {
         double t_norm = 1.0;
@@ -66,40 +66,40 @@ template <int D> bool tree_utils::split_check(const MWNode<D> &node, double prec
 
 /** Traverse tree along the Hilbert path and find nodes of any rankId.
  * Returns one nodeVector for the whole tree. GenNodes disregarded. */
-template <int D> void tree_utils::make_node_table(MWTree<D> &tree, MWNodeVector<D> &table) {
-    TreeIterator<D> it(tree, TopDown, Hilbert);
+template <int D, typename T> void tree_utils::make_node_table(MWTree<D, T> &tree, MWNodeVector<D, T> &table) {
+    TreeIterator<D, T> it(tree, TopDown, Hilbert);
     it.setReturnGenNodes(false);
     while (it.nextParent()) {
-        MWNode<D> &node = it.getNode();
+        MWNode<D, T> &node = it.getNode();
         if (node.getDepth() == 0) continue;
         table.push_back(&node);
     }
     it.init(tree);
     while (it.next()) {
-        MWNode<D> &node = it.getNode();
+        MWNode<D, T> &node = it.getNode();
         table.push_back(&node);
     }
 }
 
 /** Traverse tree along the Hilbert path and find nodes of any rankId.
  * Returns one nodeVector per scale. GenNodes disregarded. */
-template <int D> void tree_utils::make_node_table(MWTree<D> &tree, std::vector<MWNodeVector<D>> &table) {
-    TreeIterator<D> it(tree, TopDown, Hilbert);
+template <int D, typename T> void tree_utils::make_node_table(MWTree<D, T> &tree, std::vector<MWNodeVector<D, T>> &table) {
+    TreeIterator<D, T> it(tree, TopDown, Hilbert);
     it.setReturnGenNodes(false);
     while (it.nextParent()) {
-        MWNode<D> &node = it.getNode();
+        MWNode<D, T> &node = it.getNode();
         if (node.getDepth() == 0) continue;
         int depth = node.getDepth() + tree.getNNegScales();
         // Add one more element
-        if (depth + 1 > table.size()) table.push_back(MWNodeVector<D>());
+        if (depth + 1 > table.size()) table.push_back(MWNodeVector<D, T>());
         table[depth].push_back(&node);
     }
     it.init(tree);
     while (it.next()) {
-        MWNode<D> &node = it.getNode();
+        MWNode<D, T> &node = it.getNode();
         int depth = node.getDepth() + tree.getNNegScales();
         // Add one more element
-        if (depth + 1 > table.size()) table.push_back(MWNodeVector<D>());
+        if (depth + 1 > table.size()) table.push_back(MWNodeVector<D, T>());
         table[depth].push_back(&node);
     }
 }
@@ -110,7 +110,7 @@ template <int D> void tree_utils::make_node_table(MWTree<D> &tree, std::vector<M
  * The output is written directly into the 8 children scaling coefficients.
  * NB: ASSUMES that the children coefficients are separated by Children_Stride!
  */
-template <int D> void tree_utils::mw_transform(const MWTree<D> &tree, double *coeff_in, double *coeff_out, bool readOnlyScaling, int stride, bool b_overwrite) {
+template <int D, typename T> void tree_utils::mw_transform(const MWTree<D, T> &tree, T *coeff_in, T *coeff_out, bool readOnlyScaling, int stride, bool b_overwrite) {
     int operation = Reconstruction;
     int kp1 = tree.getKp1();
     int kp1_d = tree.getKp1_d();
@@ -118,8 +118,8 @@ template <int D> void tree_utils::mw_transform(const MWTree<D> &tree, double *co
     int kp1_dm1 = math_utils::ipow(kp1, D - 1);
     const MWFilter &filter = tree.getMRA().getFilter();
     double overwrite = 0.0;
-    double tmpcoeff[kp1_d * tDim];
-    double tmpcoeff2[kp1_d * tDim];
+    T tmpcoeff[kp1_d * tDim];
+    T tmpcoeff2[kp1_d * tDim];
     int ftlim = tDim;
     int ftlim2 = tDim;
     int ftlim3 = tDim;
@@ -135,13 +135,13 @@ template <int D> void tree_utils::mw_transform(const MWTree<D> &tree, double *co
     int i = 0;
     int mask = 1;
     for (int gt = 0; gt < tDim; gt++) {
-        double *out = tmpcoeff + gt * kp1_d;
+        T *out = tmpcoeff + gt * kp1_d;
         for (int ft = 0; ft < ftlim; ft++) {
             // Operate in direction i only if the bits along other
             // directions are identical. The bit of the direction we
             // operate on determines the appropriate filter/operator
             if ((gt | mask) == (ft | mask)) {
-                double *in = coeff_in + ft * kp1_d;
+                T *in = coeff_in + ft * kp1_d;
                 int filter_index = 2 * ((gt >> i) & 1) + ((ft >> i) & 1);
                 const Eigen::MatrixXd &oper = filter.getSubFilter(filter_index, operation);
 
@@ -155,13 +155,13 @@ template <int D> void tree_utils::mw_transform(const MWTree<D> &tree, double *co
         i++;
         mask = 2; // 1 << i;
         for (int gt = 0; gt < tDim; gt++) {
-            double *out = tmpcoeff2 + gt * kp1_d;
+            T *out = tmpcoeff2 + gt * kp1_d;
             for (int ft = 0; ft < ftlim2; ft++) {
                 // Operate in direction i only if the bits along other
                 // directions are identical. The bit of the direction we
                 // operate on determines the appropriate filter/operator
                 if ((gt | mask) == (ft | mask)) {
-                    double *in = tmpcoeff + ft * kp1_d;
+                    T *in = tmpcoeff + ft * kp1_d;
                     int filter_index = 2 * ((gt >> i) & 1) + ((ft >> i) & 1);
                     const Eigen::MatrixXd &oper = filter.getSubFilter(filter_index, operation);
 
@@ -178,13 +178,13 @@ template <int D> void tree_utils::mw_transform(const MWTree<D> &tree, double *co
         i++;
         mask = 4; // 1 << i;
         for (int gt = 0; gt < tDim; gt++) {
-            double *out = coeff_out + gt * stride; // write right into children
+            T *out = coeff_out + gt * stride; // write right into children
             for (int ft = 0; ft < ftlim3; ft++) {
                 // Operate in direction i only if the bits along other
                 // directions are identical. The bit of the direction we
                 // operate on determines the appropriate filter/operator
                 if ((gt | mask) == (ft | mask)) {
-                    double *in = tmpcoeff2 + ft * kp1_d;
+                    T *in = tmpcoeff2 + ft * kp1_d;
                     int filter_index = 2 * ((gt >> i) & 1) + ((ft >> i) & 1);
                     const Eigen::MatrixXd &oper = filter.getSubFilter(filter_index, operation);
 
@@ -200,7 +200,7 @@ template <int D> void tree_utils::mw_transform(const MWTree<D> &tree, double *co
     if (D > 3) MSG_ABORT("D>3 NOT IMPLEMENTED for S_mwtransform");
 
     if (D < 3) {
-        double *out;
+        T *out;
         if (D == 1) out = tmpcoeff;
         if (D == 2) out = tmpcoeff2;
         if (b_overwrite) {
@@ -216,9 +216,9 @@ template <int D> void tree_utils::mw_transform(const MWTree<D> &tree, double *co
 }
 
 // Specialized for D=3 below.
-template <int D> void tree_utils::mw_transform_back(MWTree<D> &tree, double *coeff_in, double *coeff_out, int stride) {
-    NOT_IMPLEMENTED_ABORT;
-}
+//template <int D, typename T> void tree_utils::mw_transform_back(MWTree<D, T> &tree, double *coeff_in, double *coeff_out, int stride) {
+//    NOT_IMPLEMENTED_ABORT;
+//}
 
 /** Make parent from children scaling coefficients
  * Other node info are not used/set
@@ -226,7 +226,7 @@ template <int D> void tree_utils::mw_transform_back(MWTree<D> &tree, double *coe
  * The output is read directly from the 8 children scaling coefficients.
  * NB: ASSUMES that the children coefficients are separated by Children_Stride!
  */
-template <> void tree_utils::mw_transform_back<3>(MWTree<3> &tree, double *coeff_in, double *coeff_out, int stride) {
+template <typename T>  void tree_utils::mw_transform_back(MWTree<3, T> &tree, T *coeff_in, T *coeff_out, int stride) {
     int operation = Compression;
     int kp1 = tree.getKp1();
     int kp1_d = tree.getKp1_d();
@@ -234,7 +234,7 @@ template <> void tree_utils::mw_transform_back<3>(MWTree<3> &tree, double *coeff
     int kp1_dm1 = math_utils::ipow(kp1, 2);
     const MWFilter &filter = tree.getMRA().getFilter();
     double overwrite = 0.0;
-    double tmpcoeff[kp1_d * tDim];
+    T tmpcoeff[kp1_d * tDim];
 
     int ftlim = tDim;
     int ftlim2 = tDim;
@@ -243,13 +243,13 @@ template <> void tree_utils::mw_transform_back<3>(MWTree<3> &tree, double *coeff
     int i = 0;
     int mask = 1;
     for (int gt = 0; gt < tDim; gt++) {
-        double *out = coeff_out + gt * kp1_d;
+        T *out = coeff_out + gt * kp1_d;
         for (int ft = 0; ft < ftlim; ft++) {
             // Operate in direction i only if the bits along other
             // directions are identical. The bit of the direction we
             // operate on determines the appropriate filter/operator
             if ((gt | mask) == (ft | mask)) {
-                double *in = coeff_in + ft * stride;
+                T *in = coeff_in + ft * stride;
                 int filter_index = 2 * ((gt >> i) & 1) + ((ft >> i) & 1);
                 const Eigen::MatrixXd &oper = filter.getSubFilter(filter_index, operation);
 
@@ -262,13 +262,13 @@ template <> void tree_utils::mw_transform_back<3>(MWTree<3> &tree, double *coeff
     i++;
     mask = 2; // 1 << i;
     for (int gt = 0; gt < tDim; gt++) {
-        double *out = tmpcoeff + gt * kp1_d;
+        T *out = tmpcoeff + gt * kp1_d;
         for (int ft = 0; ft < ftlim2; ft++) {
             // Operate in direction i only if the bits along other
             // directions are identical. The bit of the direction we
             // operate on determines the appropriate filter/operator
             if ((gt | mask) == (ft | mask)) {
-                double *in = coeff_out + ft * kp1_d;
+                T *in = coeff_out + ft * kp1_d;
                 int filter_index = 2 * ((gt >> i) & 1) + ((ft >> i) & 1);
                 const Eigen::MatrixXd &oper = filter.getSubFilter(filter_index, operation);
 
@@ -281,14 +281,14 @@ template <> void tree_utils::mw_transform_back<3>(MWTree<3> &tree, double *coeff
     i++;
     mask = 4; // 1 << i;
     for (int gt = 0; gt < tDim; gt++) {
-        double *out = coeff_out + gt * kp1_d;
-        // double *out = coeff_out + gt * N_coeff;
+        T *out = coeff_out + gt * kp1_d;
+        // T *out = coeff_out + gt * N_coeff;
         for (int ft = 0; ft < ftlim3; ft++) {
             // Operate in direction i only if the bits along other
             // directions are identical. The bit of the direction we
             // operate on determines the appropriate filter/operator
             if ((gt | mask) == (ft | mask)) {
-                double *in = tmpcoeff + ft * kp1_d;
+                T *in = tmpcoeff + ft * kp1_d;
                 int filter_index = 2 * ((gt >> i) & 1) + ((ft >> i) & 1);
                 const Eigen::MatrixXd &oper = filter.getSubFilter(filter_index, operation);
 
@@ -300,24 +300,46 @@ template <> void tree_utils::mw_transform_back<3>(MWTree<3> &tree, double *coeff
     }
 }
 
-template bool tree_utils::split_check<1>(const MWNode<1> &node, double prec, double split_fac, bool abs_prec);
-template bool tree_utils::split_check<2>(const MWNode<2> &node, double prec, double split_fac, bool abs_prec);
-template bool tree_utils::split_check<3>(const MWNode<3> &node, double prec, double split_fac, bool abs_prec);
 
-template void tree_utils::make_node_table<1>(MWTree<1> &tree, MWNodeVector<1> &table);
-template void tree_utils::make_node_table<2>(MWTree<2> &tree, MWNodeVector<2> &table);
-template void tree_utils::make_node_table<3>(MWTree<3> &tree, MWNodeVector<3> &table);
+template void tree_utils::make_node_table<1, double>(MWTree<1, double> &tree, MWNodeVector<1, double> &table);
+template void tree_utils::make_node_table<2, double>(MWTree<2, double> &tree, MWNodeVector<2, double> &table);
+template void tree_utils::make_node_table<3, double>(MWTree<3, double> &tree, MWNodeVector<3, double> &table);
+
+template void tree_utils::make_node_table<1, double>(MWTree<1, double> &tree, std::vector<MWNodeVector<1, double>> &table);
+template void tree_utils::make_node_table<2, double>(MWTree<2, double> &tree, std::vector<MWNodeVector<2, double>> &table);
+template void tree_utils::make_node_table<3, double>(MWTree<3, double> &tree, std::vector<MWNodeVector<3, double>> &table);
+
+template bool tree_utils::split_check<1, double>(const MWNode<1, double> &node, double prec, double split_fac, bool abs_prec);
+template bool tree_utils::split_check<2, double>(const MWNode<2, double> &node, double prec, double split_fac, bool abs_prec);
+template bool tree_utils::split_check<3, double>(const MWNode<3, double> &node, double prec, double split_fac, bool abs_prec);
+
+template void tree_utils::mw_transform<1, double>(const MWTree<1, double> &tree, double *coeff_in, double *coeff_out, bool readOnlyScaling, int stride, bool b_overwrite);
+template void tree_utils::mw_transform<2, double>(const MWTree<2, double> &tree, double *coeff_in, double *coeff_out, bool readOnlyScaling, int stride, bool b_overwrite);
+template void tree_utils::mw_transform<3, double>(const MWTree<3, double> &tree, double *coeff_in, double *coeff_out, bool readOnlyScaling, int stride, bool b_overwrite);
+
+//template void tree_utils::mw_transform_back<1, double>(MWTree<1, double> &tree, double *coeff_in, double *coeff_out, int stride);
+//template void tree_utils::mw_transform_back<2, double>(MWTree<2, double> &tree, double *coeff_in, double *coeff_out, int stride);
+template void tree_utils::mw_transform_back<double>(MWTree<3, double> &tree, double *coeff_in, double *coeff_out, int stride);
+
+  
+template void tree_utils::make_node_table<1, ComplexDouble>(MWTree<1, ComplexDouble> &tree, MWNodeVector<1, ComplexDouble> &table);
+template void tree_utils::make_node_table<2, ComplexDouble>(MWTree<2, ComplexDouble> &tree, MWNodeVector<2, ComplexDouble> &table);
+template void tree_utils::make_node_table<3, ComplexDouble>(MWTree<3, ComplexDouble> &tree, MWNodeVector<3, ComplexDouble> &table);
+
+template void tree_utils::make_node_table<1, ComplexDouble>(MWTree<1, ComplexDouble> &tree, std::vector<MWNodeVector<1, ComplexDouble>> &table);
+template void tree_utils::make_node_table<2, ComplexDouble>(MWTree<2, ComplexDouble> &tree, std::vector<MWNodeVector<2, ComplexDouble>> &table);
+template void tree_utils::make_node_table<3, ComplexDouble>(MWTree<3, ComplexDouble> &tree, std::vector<MWNodeVector<3, ComplexDouble>> &table);
 
-template void tree_utils::make_node_table<1>(MWTree<1> &tree, std::vector<MWNodeVector<1>> &table);
-template void tree_utils::make_node_table<2>(MWTree<2> &tree, std::vector<MWNodeVector<2>> &table);
-template void tree_utils::make_node_table<3>(MWTree<3> &tree, std::vector<MWNodeVector<3>> &table);
+template bool tree_utils::split_check<1, ComplexDouble>(const MWNode<1, ComplexDouble> &node, double prec, double split_fac, bool abs_prec);
+template bool tree_utils::split_check<2, ComplexDouble>(const MWNode<2, ComplexDouble> &node, double prec, double split_fac, bool abs_prec);
+template bool tree_utils::split_check<3, ComplexDouble>(const MWNode<3, ComplexDouble> &node, double prec, double split_fac, bool abs_prec);
 
-template void tree_utils::mw_transform<1>(const MWTree<1> &tree, double *coeff_in, double *coeff_out, bool readOnlyScaling, int stride, bool b_overwrite);
-template void tree_utils::mw_transform<2>(const MWTree<2> &tree, double *coeff_in, double *coeff_out, bool readOnlyScaling, int stride, bool b_overwrite);
-template void tree_utils::mw_transform<3>(const MWTree<3> &tree, double *coeff_in, double *coeff_out, bool readOnlyScaling, int stride, bool b_overwrite);
+template void tree_utils::mw_transform<1, ComplexDouble>(const MWTree<1, ComplexDouble> &tree, ComplexDouble *coeff_in, ComplexDouble *coeff_out, bool readOnlyScaling, int stride, bool b_overwrite);
+template void tree_utils::mw_transform<2, ComplexDouble>(const MWTree<2, ComplexDouble> &tree, ComplexDouble *coeff_in, ComplexDouble *coeff_out, bool readOnlyScaling, int stride, bool b_overwrite);
+template void tree_utils::mw_transform<3, ComplexDouble>(const MWTree<3, ComplexDouble> &tree, ComplexDouble *coeff_in, ComplexDouble *coeff_out, bool readOnlyScaling, int stride, bool b_overwrite);
 
-template void tree_utils::mw_transform_back<1>(MWTree<1> &tree, double *coeff_in, double *coeff_out, int stride);
-template void tree_utils::mw_transform_back<2>(MWTree<2> &tree, double *coeff_in, double *coeff_out, int stride);
-template void tree_utils::mw_transform_back<3>(MWTree<3> &tree, double *coeff_in, double *coeff_out, int stride);
+//template void tree_utils::mw_transform_back<1, ComplexDouble>(MWTree<1, ComplexDouble &tree, ComplexDouble *coeff_in, ComplexDouble *coeff_out, int stride);
+//template void tree_utils::mw_transform_back<2, ComplexDouble>(MWTree<2, ComplexDouble &tree, ComplexDouble *coeff_in, ComplexDouble *coeff_out, int stride);
+template void tree_utils::mw_transform_back<ComplexDouble>(MWTree<3, ComplexDouble> &tree, ComplexDouble *coeff_in, ComplexDouble *coeff_out, int stride);
 
 } // namespace mrcpp
diff --git a/src/utils/tree_utils.h b/src/utils/tree_utils.h
index 8f2c4220a..90ff2a418 100644
--- a/src/utils/tree_utils.h
+++ b/src/utils/tree_utils.h
@@ -25,18 +25,21 @@
 
 #pragma once
 
+#include "utils/math_utils.h"
 #include "MRCPP/mrcpp_declarations.h"
 
 namespace mrcpp {
 namespace tree_utils {
 
-template <int D> bool split_check(const MWNode<D> &node, double prec, double split_fac, bool abs_prec);
+template <int D, typename T> bool split_check(const MWNode<D, T> &node, double prec, double split_fac, bool abs_prec);
 
-template <int D> void make_node_table(MWTree<D> &tree, MWNodeVector<D> &table);
-template <int D> void make_node_table(MWTree<D> &tree, std::vector<MWNodeVector<D>> &table);
+template <int D, typename T> void make_node_table(MWTree<D, T> &tree, MWNodeVector<D, T> &table);
+template <int D, typename T> void make_node_table(MWTree<D, T> &tree, std::vector<MWNodeVector<D, T>> &table);
+
+template <int D, typename T> void mw_transform(const MWTree<D, T> &tree, T *coeff_in, T *coeff_out, bool readOnlyScaling, int stride, bool overwrite = true);
+//template <int D, typename T> void mw_transform_back(MWTree<D, T> &tree, T *coeff_in, T *coeff_out, int stride);
+template <typename T> void mw_transform_back(MWTree<3, T> &tree, T *coeff_in, T *coeff_out, int stride);
 
-template <int D> void mw_transform(const MWTree<D> &tree, double *coeff_in, double *coeff_out, bool readOnlyScaling, int stride, bool overwrite = true);
-template <int D> void mw_transform_back(MWTree<D> &tree, double *coeff_in, double *coeff_out, int stride);
 
 } // namespace tree_utils
 } // namespace mrcpp
diff --git a/tests/operators/derivative_operator.cpp b/tests/operators/derivative_operator.cpp
index 5f4400d1b..773c12ec9 100644
--- a/tests/operators/derivative_operator.cpp
+++ b/tests/operators/derivative_operator.cpp
@@ -102,10 +102,10 @@ template <int D> void testDifferentiationABGV(double a, double b) {
     };
 
     FunctionTree<D> f_tree(*mra);
-    project<D>(prec / 10, f_tree, f);
+    project<D, double>(prec / 10, f_tree, f);
 
     FunctionTree<D> df_tree(*mra);
-    project<D>(prec / 10, df_tree, df);
+    project<D, double>(prec / 10, df_tree, df);
 
     FunctionTree<D> dg_tree(*mra);
     apply(dg_tree, diff, f_tree, 0);
@@ -122,6 +122,47 @@ template <int D> void testDifferentiationABGV(double a, double b) {
     delete mra;
 }
 
+template <int D> void testDifferentiationCplxABGV(double a, double b) {
+    MultiResolutionAnalysis<D> *mra = initializeMRA<D>();
+
+    double prec = 1.0e-3;
+    ABGVOperator<D> diff(*mra, a, b);
+    ComplexDouble s = {1.1, 1.3};
+
+    Coord<D> r_0;
+    for (auto &x : r_0) x = pi;
+
+    auto f = [r_0, s](const Coord<D> &r) {
+        double R = math_utils::calc_distance<D>(r, r_0);
+        return std::exp(-R * R * s);
+    };
+
+    auto df = [r_0, s](const Coord<D> &r) {
+        double R = math_utils::calc_distance<D>(r, r_0);
+        return -2.0 * s * std::exp(-R * R * s) * (r[0] - r_0[0]);
+    };
+
+    FunctionTree<D, ComplexDouble> f_tree(*mra);
+    project<D, ComplexDouble>(prec / 10, f_tree, f);
+
+    FunctionTree<D, ComplexDouble> df_tree(*mra);
+    project<D, ComplexDouble>(prec / 10, df_tree, df);
+
+    FunctionTree<D, ComplexDouble> dg_tree(*mra);
+    apply(dg_tree, diff, f_tree, 0);
+
+    FunctionTree<D, ComplexDouble> err_tree(*mra);
+    add(-1.0, err_tree, {1.0, 0.0}, df_tree, {-1.0, 0.0}, dg_tree);
+
+    double df_norm = std::sqrt(df_tree.getSquareNorm());
+    double abs_err = std::sqrt(err_tree.getSquareNorm());
+    double rel_err = abs_err / df_norm;
+
+    REQUIRE(rel_err == Catch::Approx(0.0).margin(prec));
+
+    delete mra;
+}
+
 template <int D> void testDifferentiationPH(int order) {
     MultiResolutionAnalysis<D> *mra = initializeMRA<D>();
 
@@ -143,10 +184,10 @@ template <int D> void testDifferentiationPH(int order) {
     };
 
     FunctionTree<D> f_tree(*mra);
-    project<D>(prec / 10, f_tree, f);
+    project<D, double>(prec / 10, f_tree, f);
 
     FunctionTree<D> df_tree(*mra);
-    project<D>(prec / 10, df_tree, df);
+    project<D, double>(prec / 10, df_tree, df);
 
     FunctionTree<D> dg_tree(*mra);
     apply(dg_tree, diff, f_tree, 0);
@@ -174,7 +215,7 @@ template <int D> void testDifferentiationPeriodicABGV(double a, double b) {
     FunctionTree<D> g_tree(*mra);
     FunctionTree<D> dg_tree(*mra);
 
-    project<D>(prec, g_tree, g_func);
+    project<D, double>(prec, g_tree, g_func);
 
     apply(dg_tree, diff, g_tree, 0);
     refine_grid(dg_tree, 1); // for accurate evalf
@@ -202,7 +243,7 @@ template <int D> void testDifferentiationPeriodicPH(int order) {
     FunctionTree<D> g_tree(*mra);
     FunctionTree<D> dg_tree(*mra);
 
-    project<D>(prec, g_tree, g_func);
+    project<D, double>(prec, g_tree, g_func);
 
     apply(dg_tree, diff, g_tree, 0);
     refine_grid(dg_tree, 1); // for accurate evalf
@@ -237,10 +278,10 @@ template <int D> void testDifferentiationBS(int order) {
     };
 
     FunctionTree<D> f_tree(*mra);
-    project<D>(prec / 10, f_tree, f);
+    project<D, double>(prec / 10, f_tree, f);
 
     FunctionTree<D> df_tree(*mra);
-    project<D>(prec / 10, df_tree, df);
+    project<D, double>(prec / 10, df_tree, df);
 
     FunctionTree<D> dg_tree(*mra);
     apply(dg_tree, diff, f_tree, 0);
@@ -271,6 +312,14 @@ TEST_CASE("ABGV differentiantion center difference", "[derivative_operator], [ce
     SECTION("3D derivative test") { testDifferentiationABGV<3>(0, 0); }
 }
 
+
+TEST_CASE("ABGV differentiantion of Complex function", "[derivative_operator], [Complex]") {
+    // 0.5,0.5 specifies central difference
+    SECTION("1D derivative test") { testDifferentiationCplxABGV<1>(0.5, 0.5); }
+    SECTION("2D derivative test") { testDifferentiationCplxABGV<2>(0.5, 0.5); }
+    SECTION("3D derivative test") { testDifferentiationCplxABGV<3>(0.5, 0.5); }
+}
+
 TEST_CASE("PH differentiantion first order", "[derivative_operator], [PH_first_order]") {
     SECTION("1D derivative test") { testDifferentiationPH<1>(1); }
     SECTION("2D derivative test") { testDifferentiationPH<2>(1); }
@@ -335,7 +384,7 @@ TEST_CASE("Gradient operator", "[derivative_operator], [gradient_operator]") {
     };
 
     FunctionTree<3> f_tree(*mra);
-    project<3>(prec, f_tree, f);
+    project<3, double>(prec, f_tree, f);
 
     auto grad_f = gradient(diff, f_tree);
     REQUIRE(grad_f.size() == 3);
@@ -373,7 +422,7 @@ TEST_CASE("Divergence operator", "[derivative_operator], [divergence_operator]")
     };
 
     FunctionTree<3> f_tree(*mra);
-    project<3>(prec, f_tree, f);
+    project<3, double>(prec, f_tree, f);
     FunctionTreeVector<3> f_vec;
     f_vec.push_back(std::make_tuple(1.0, &f_tree));
     f_vec.push_back(std::make_tuple(2.0, &f_tree));
@@ -389,6 +438,6 @@ TEST_CASE("Divergence operator", "[derivative_operator], [divergence_operator]")
     }
 
     delete mra;
-}
+    }
 
 } // namespace derivative_operator
diff --git a/tests/operators/helmholtz_operator.cpp b/tests/operators/helmholtz_operator.cpp
index 7a0dc0243..8f570691d 100644
--- a/tests/operators/helmholtz_operator.cpp
+++ b/tests/operators/helmholtz_operator.cpp
@@ -169,14 +169,14 @@ TEST_CASE("Apply Helmholtz' operator", "[apply_helmholtz], [helmholtz_operator],
         return R_0 * Y_00;
     };
     FunctionTree<3> psi_n(MRA);
-    project<3>(proj_prec, psi_n, hFunc);
+    project<3, double>(proj_prec, psi_n, hFunc);
 
     auto f = [Z](const Coord<3> &r) -> double {
         double x = std::sqrt(r[0] * r[0] + r[1] * r[1] + r[2] * r[2]);
         return -Z / x;
     };
     FunctionTree<3> V(MRA);
-    project<3>(proj_prec, V, f);
+    project<3, double>(proj_prec, V, f);
 
     FunctionTree<3> Vpsi(MRA);
     copy_grid(Vpsi, psi_n);
@@ -222,7 +222,7 @@ TEST_CASE("Apply Periodic Helmholtz' operator", "[apply_periodic_helmholtz], [he
     auto source = [mu](const mrcpp::Coord<3> &r) { return 3.0 * cos(r[0]) * cos(r[1]) * cos(r[2]) / (4.0 * pi) + mu * mu * cos(r[0]) * cos(r[1]) * cos(r[2]) / (4.0 * pi); };
 
     FunctionTree<3> source_tree(MRA);
-    project<3>(proj_prec, source_tree, source);
+    project<3, double>(proj_prec, source_tree, source);
 
     FunctionTree<3> sol_tree(MRA);
     FunctionTree<3> in_tree(MRA);
@@ -265,7 +265,7 @@ TEST_CASE("Apply negative scale Helmholtz' operator", "[apply_periodic_helmholtz
     auto source = [mu](const mrcpp::Coord<3> &r) { return 3.0 * cos(r[0]) * cos(r[1]) * cos(r[2]) / (4.0 * pi) + mu * mu * cos(r[0]) * cos(r[1]) * cos(r[2]) / (4.0 * pi); };
 
     FunctionTree<3> source_tree(MRA);
-    project<3>(proj_prec, source_tree, source);
+    project<3, double>(proj_prec, source_tree, source);
 
     FunctionTree<3> sol_tree(MRA);
 
@@ -274,4 +274,5 @@ TEST_CASE("Apply negative scale Helmholtz' operator", "[apply_periodic_helmholtz
     REQUIRE(sol_tree.evalf({0.0, 0.0, 0.0}) == Catch::Approx(1.0).epsilon(apply_prec));
     REQUIRE(sol_tree.evalf({pi, 0.0, 0.0}) == Catch::Approx(-1.0).epsilon(apply_prec));
 }
+
 } // namespace helmholtz_operator
diff --git a/tests/operators/poisson_operator.cpp b/tests/operators/poisson_operator.cpp
index df841a625..eab986886 100644
--- a/tests/operators/poisson_operator.cpp
+++ b/tests/operators/poisson_operator.cpp
@@ -187,7 +187,7 @@ TEST_CASE("Apply Periodic Poisson' operator", "[apply_periodic_Poisson], [poisso
     auto source = [](const mrcpp::Coord<3> &r) { return 3.0 * cos(r[0]) * cos(r[1]) * cos(r[2]) / (4.0 * pi); };
 
     FunctionTree<3> source_tree(MRA);
-    project<3>(proj_prec, source_tree, source);
+    project<3, double>(proj_prec, source_tree, source);
 
     FunctionTree<3> sol_tree(MRA);
 
@@ -195,6 +195,6 @@ TEST_CASE("Apply Periodic Poisson' operator", "[apply_periodic_Poisson], [poisso
 
     REQUIRE(sol_tree.evalf({0.0, 0.0, 0.0}) == Catch::Approx(1.0).epsilon(apply_prec));
     REQUIRE(sol_tree.evalf({pi, 0.0, 0.0}) == Catch::Approx(-1.0).epsilon(apply_prec));
-}
+    }
 
 } // namespace poisson_operator
diff --git a/tests/operators/schrodinger_evolution_operator.cpp b/tests/operators/schrodinger_evolution_operator.cpp
index c986ec756..477065062 100644
--- a/tests/operators/schrodinger_evolution_operator.cpp
+++ b/tests/operators/schrodinger_evolution_operator.cpp
@@ -38,7 +38,6 @@
 
 namespace schrodinger_evolution_operator {
 
-
 TEST_CASE("Apply Schrodinger's evolution operator", "[apply_schrodinger_evolution], [schrodinger_evolution_operator], [mw_operator]") {
     const auto min_scale = 0;
     const auto max_depth = 25;
@@ -87,13 +86,13 @@ TEST_CASE("Apply Schrodinger's evolution operator", "[apply_schrodinger_evolutio
 
     // Projecting functions
     mrcpp::FunctionTree<1> Re_f_tree(MRA);
-    mrcpp::project<1>(prec, Re_f_tree, Re_f);
+    mrcpp::project<1, double>(prec, Re_f_tree, Re_f);
     mrcpp::FunctionTree<1> Im_f_tree(MRA);
-    mrcpp::project<1>(prec, Im_f_tree, Im_f);
+    mrcpp::project<1, double>(prec, Im_f_tree, Im_f);
     mrcpp::FunctionTree<1> Re_g_tree(MRA);
-    mrcpp::project<1>(prec, Re_g_tree, Re_g);
+    mrcpp::project<1, double>(prec, Re_g_tree, Re_g);
     mrcpp::FunctionTree<1> Im_g_tree(MRA);
-    mrcpp::project<1>(prec, Im_g_tree, Im_g);
+    mrcpp::project<1, double>(prec, Im_g_tree, Im_g);
 
     // Output function trees
     mrcpp::FunctionTree<1> Re_fout_tree(MRA);
@@ -129,5 +128,4 @@ TEST_CASE("Apply Schrodinger's evolution operator", "[apply_schrodinger_evolutio
     REQUIRE(Im_sq_norm == Catch::Approx(0.0).margin(tolerance));
 }
 
-
-} // namespace schrodinger_evolution_operator
\ No newline at end of file
+} // namespace schrodinger_evolution_operator
diff --git a/tests/treebuilders/map.cpp b/tests/treebuilders/map.cpp
index 0745db2e6..c3c333bba 100644
--- a/tests/treebuilders/map.cpp
+++ b/tests/treebuilders/map.cpp
@@ -77,7 +77,7 @@ template <int D> void testMapping() {
     const double inp_int = inp_tree.integrate();
     const double inp_norm = inp_tree.getSquareNorm();
 
-    auto fmap = [](double val) { return val * val; };
+    FMap<double,double> fmap = [](double val) { return val * val; };
 
     WHEN("the function is mapped") {
         FunctionTree<D> out_tree(*mra);
diff --git a/tests/treebuilders/multiplication.cpp b/tests/treebuilders/multiplication.cpp
index 5fa2178e1..7e8437f77 100644
--- a/tests/treebuilders/multiplication.cpp
+++ b/tests/treebuilders/multiplication.cpp
@@ -202,7 +202,7 @@ template <int D> void testSquare() {
     }
     finalize(&mra);
 }
-
+  
 TEST_CASE("Dot product FunctionTreeVectors", "[multiplication], [tree_vector_dot]") {
     MultiResolutionAnalysis<3> *mra = nullptr;
     initialize<3>(&mra);
@@ -221,14 +221,14 @@ TEST_CASE("Dot product FunctionTreeVectors", "[multiplication], [tree_vector_dot
         double r2 = (r[0] * r[0] + r[1] * r[1] + r[2] * r[2]);
         return r[0] * r[1] * std::exp(-2.0 * r2);
     };
-
+    
     FunctionTree<3> fx_tree(*mra);
     FunctionTree<3> fy_tree(*mra);
     FunctionTree<3> fz_tree(*mra);
 
-    project<3>(prec, fx_tree, fx);
-    project<3>(prec, fy_tree, fy);
-    project<3>(prec, fz_tree, fz);
+    project<3, double>(prec, fx_tree, fx);
+    project<3, double>(prec, fy_tree, fy);
+    project<3, double>(prec, fz_tree, fz);
 
     FunctionTreeVector<3> vec_a;
     vec_a.push_back(std::make_tuple(1.0, &fx_tree));
@@ -252,6 +252,6 @@ TEST_CASE("Dot product FunctionTreeVectors", "[multiplication], [tree_vector_dot
     }
 
     finalize(&mra);
-}
+    }
 
 } // namespace multiplication