[PATCH] Clean up Tensor (2nd try)

[Richard Guenther]

Hi!

The following patch cleans up Tensor wrt TensorAssign and friends. It does
so by using partial specialization of TensorAssign for the engine types.
It also uses template template parameters to get rid of code duplication
for identical specializations for Tensor<> and TensorEngine<>.

Tested on ia32 for Tiny, Particles, DataBrowser and Array with no
regressions.

Ok?

Richard.

# This is a BitKeeper generated patch for the following project:
# Project Name: pooma/cheetah repository tracking CVS/tarball
# This patch format is intended for GNU patch command version 2.5 or higher.
# This patch includes the following deltas:
#                  ChangeSet    1.69    -> 1.70
#       r2/src/Tiny/TensorOperators.h   1.1     -> 1.2
#       r2/src/Tiny/Tensor.h    1.7     -> 1.11
#
# The following is the BitKeeper ChangeSet Log
# --------------------------------------------
# 03/11/08      address@hidden(none)    1.70
# Clean up Tensor wrt TensorAssign and friends.
# --------------------------------------------
#
diff -Nru a/r2/src/Tiny/Tensor.h b/r2/src/Tiny/Tensor.h
--- a/r2/src/Tiny/Tensor.h      Sat Nov  8 15:26:41 2003
+++ b/r2/src/Tiny/Tensor.h      Sat Nov  8 15:26:41 2003
@@ -72,12 +72,6 @@
 //-----------------------------------------------------------------------------

 template<int D, class T, class EngineTag> class Tensor;
-template<class T1, class T2, class Op, int B1, int L1, int B2, int L2>
-struct SymmetricTensorAssign;
-template<class T1, class T2, class Op, int B1, int L1, int B2, int L2>
-struct AntisymmetricTensorAssign;
-template<class T1, class T2, class Op, int B1, int L1, int B2, int L2>
-struct DiagonalTensorAssign;

 template <class T>
 void reverseBytes(T&);
@@ -399,7 +393,6 @@
 { };


-
 /**
  * TensorEngine definitions for a Full Tensor.
  */
@@ -671,7 +664,7 @@
   // Copy ctor is deep.
   TensorEngine(const TensorEngine<d,T,Antisymmetric> &x)
   {
-    AntisymmetricTensorAssign<This_t,This_t,OpAssign,0,d,0,d>::
+    TensorAssign<This_t,This_t,OpAssign,0,d,0,d>::
       apply(*this,x,OpAssign());
   }

@@ -680,7 +673,7 @@
   template<class X>
   TensorEngine(const X& x)
   {
-    AntisymmetricTensorAssign<This_t,X,OpAssign,0,d,0,d>::
+    TensorAssign<This_t,X,OpAssign,0,d,0,d>::
       apply(*this,x,OpAssign());
   }

@@ -728,7 +721,7 @@
   operator=(const This_t& x)
   {
     if (this != &x) {
-      AntisymmetricTensorAssign<This_t,This_t,OpAssign,0,d,0,d>::
+      TensorAssign<This_t,This_t,OpAssign,0,d,0,d>::
         apply(*this,x,OpAssign());
     }
     return *this;
@@ -739,7 +732,7 @@
   This_t&
   operator=(const V& x)
   {
-    AntisymmetricTensorAssign<This_t,V,OpAssign,0,d,0,d>::
+    TensorAssign<This_t,V,OpAssign,0,d,0,d>::
       apply(*this,x,OpAssign());
     return *this;
   }
@@ -857,88 +850,43 @@
 T TensorEngine<D,T,Antisymmetric>::Zero = 0.0;


-// ----------------------------------------------------------------------------
-// Special antisymmetric assignment class: Has specializations for different
-// dimensionalities (for 1, 2, and 3, so far). This may ultimately be
-// replaceable with a dimensionality-independent equivalent that uses template
-// metaprogramming. It may, in fact, be replaceable with partial
-// specializations of TensorAssign itself, with
-// TensorEngine<D,T,Antisymmetric> partial specializations for the general
-// class parameter T1 and/or T2 of TensorAssign. --TJW 9/10/1999
-// ----------------------------------------------------------------------------
+/**
+ * Special antisymmetric assignment class: Has specializations for different
+ * dimensionalities (for 1, 2, and 3, so far). This may ultimately be
+ * replaceable with a dimensionality-independent equivalent that uses template
+ * metaprogramming. It may, in fact, be replaceable with partial
+ * specializations of TensorAssign itself, with
+ * TensorEngine<D,T,Antisymmetric> partial specializations for the general
+ * class parameter T1 and/or T2 of TensorAssign. --TJW 9/10/1999
+ */

-// General template: does nothing:
-template<class T1, class T2, class Op, int B1, int L1, int B2, int L2>
-struct AntisymmetricTensorAssign
-{
-  static void apply(T1& x, const T2& y, Op op=Op())
-  { }
-};
 // 1D partial specialization:
-template<class T, class T2, class Op, int B1, int L1, int B2, int L2>
-struct AntisymmetricTensorAssign<TensorEngine<1,T,Antisymmetric>,
-  T2,Op,B1,L1,B2,L2>
+template<template <int, class, class> class T1, class T, class T2, class Op>
+struct TensorAssign<T1<1,T,Antisymmetric>,T2,Op,0,1,0,1>
 {
-  static void apply(TensorEngine<1,T,Antisymmetric> &x, const T2 &y,
-                    Op op=Op())
-  { }
-};
-template<class T, class T2, class Op, int B1, int L1, int B2, int L2>
-struct AntisymmetricTensorAssign<Tensor<1,T,Antisymmetric>,
-  T2,Op,B1,L1,B2,L2>
-{
-  static void apply(Tensor<1,T,Antisymmetric> &x, const T2 &y,
+  static void apply(T1<1,T,Antisymmetric> &x, const T2 &y,
                     Op op=Op())
   { }
 };
 // 2D partial specialization:
-template<class T, class T2, class Op, int B1, int L1, int B2, int L2>
-struct AntisymmetricTensorAssign<TensorEngine<2,T,Antisymmetric>,
-  T2,Op,B1,L1,B2,L2>
+template<template <int, class, class> class T1, class T, class T2, class Op>
+struct TensorAssign<T1<2,T,Antisymmetric>,T2,Op,0,2,0,2>
 {
-  static void apply(TensorEngine<2,T,Antisymmetric> &x, const T2 &y,
+  static void apply(T1<2,T,Antisymmetric> &x, const T2 &y,
                     Op op=Op())
   {
-//     TensorAssign<TensorEngine<2,T,Antisymmetric>,T2,OpAssign,1,1,0,1>::
-//       apply(x,y,op);
-    TensorAssign<TensorEngine<2,T,Antisymmetric>,T2,Op,1,1,0,1>::apply(x,y,op);
-  }
-};
-template<class T, class T2, class Op, int B1, int L1, int B2, int L2>
-struct AntisymmetricTensorAssign<Tensor<2,T,Antisymmetric>,
-  T2,Op,B1,L1,B2,L2>
-{
-  static void apply(Tensor<2,T,Antisymmetric> &x, const T2 &y,
-                    Op op=Op())
-  {
-    TensorAssign<Tensor<2,T,Antisymmetric>,T2,Op,1,1,0,1>::apply(x,y,op);
+    TensorAssign<T1<2,T,Antisymmetric>,T2,Op,1,1,0,1>::apply(x,y,op);
   }
 };
 // 3D partial specialization:
-template<class T, class T2, class Op, int B1, int L1, int B2, int L2>
-struct AntisymmetricTensorAssign<TensorEngine<3,T,Antisymmetric>,
-  T2,Op,B1,L1,B2,L2>
+template<template <int, class, class> class T1, class T, class T2, class Op>
+struct TensorAssign<T1<3,T,Antisymmetric>,T2,Op,0,3,0,3>
 {
-  static void apply(TensorEngine<3,T,Antisymmetric> &x, const T2 &y,
-                    Op op=Op())
+  static void apply(T1<3,T,Antisymmetric> &x, const T2 &y,
+                   Op op=Op())
   {
-//     TensorAssign<TensorEngine<3,T,Antisymmetric>,T2,OpAssign,1,1,0,1>::
-//       apply(x,y,op);
-//     TensorAssign<TensorEngine<3,T,Antisymmetric>,T2,OpAssign,2,1,0,2>::
-//       apply(x,y,op);
-    TensorAssign<TensorEngine<3,T,Antisymmetric>,T2,Op,1,1,0,1>::apply(x,y,op);
-    TensorAssign<TensorEngine<3,T,Antisymmetric>,T2,Op,2,1,0,2>::apply(x,y,op);
-  }
-};
-template<class T, class T2, class Op, int B1, int L1, int B2, int L2>
-struct AntisymmetricTensorAssign<Tensor<3,T,Antisymmetric>,
-  T2,Op,B1,L1,B2,L2>
-{
-  static void apply(Tensor<3,T,Antisymmetric> &x, const T2 &y,
-                    Op op=Op())
-  {
-    TensorAssign<Tensor<3,T,Antisymmetric>,T2,Op,1,1,0,1>::apply(x,y,op);
-    TensorAssign<Tensor<3,T,Antisymmetric>,T2,Op,2,1,0,2>::apply(x,y,op);
+    TensorAssign<T1<3,T,Antisymmetric>,T2,Op,1,1,0,1>::apply(x,y,op);
+    TensorAssign<T1<3,T,Antisymmetric>,T2,Op,2,1,0,2>::apply(x,y,op);
   }
 };

@@ -986,7 +934,7 @@
   // Copy ctor is deep.
   TensorEngine(const TensorEngine<D,T,Symmetric> &x)
   {
-    SymmetricTensorAssign<This_t,This_t,OpAssign,0,d,0,d>::
+    TensorAssign<This_t,This_t,OpAssign,0,d,0,d>::
       apply(*this,x,OpAssign());
   }

@@ -1042,7 +990,7 @@
   operator=(const This_t &x)
   {
     if (this != &x) {
-      SymmetricTensorAssign<This_t,This_t,OpAssign,0,d,0,d>::
+      TensorAssign<This_t,This_t,OpAssign,0,d,0,d>::
         apply(*this,x,OpAssign());
     }
     return *this;
@@ -1053,7 +1001,7 @@
   This_t&
   operator=(const V &x)
   {
-    SymmetricTensorAssign<This_t,V,OpAssign,0,d,0,d>::
+    TensorAssign<This_t,V,OpAssign,0,d,0,d>::
       apply(*this,x,OpAssign());
     return *this;
   }
@@ -1144,101 +1092,37 @@
 };


-// ----------------------------------------------------------------------------
-// Special symmetric assignment class: Has specializations for different
-// dimensionalities (for 1, 2, and 3, so far). This may ultimately be
-// replaceable with a dimensionality-independent equivalent that uses template
-// metaprogramming. It may, in fact, be replaceable with partial
-// specializations of TensorAssign itself, with
-// TensorEngine<D,T,Symmetric> partial specializations for the general
-// class parameter T1 and/or T2 of TensorAssign. --TJW 9/10/1999
-// ----------------------------------------------------------------------------
+/**
+ * Special symmetric assignment class: Has specializations for different
+ * dimensionalities (for 2, and 3, so far). This may ultimately be
+ * replaceable with a dimensionality-independent equivalent that uses template
+ * metaprogramming. It may, in fact, be replaceable with partial
+ * specializations of TensorAssign itself, with
+ * TensorEngine<D,T,Symmetric> partial specializations for the general
+ * class parameter T1 and/or T2 of TensorAssign. --TJW 9/10/1999
+ */

-// General template: does nothing:
-template<class T1, class T2, class Op, int B1, int L1, int B2, int L2>
-struct SymmetricTensorAssign
-{
-  // We're not supposed to come along here.
-  static void apply(T1& x, const T2& y, Op op=Op());
-};
-// 1D partial specialization:
-template<class T, class T2, class Op, int B1, int L1, int B2, int L2>
-struct SymmetricTensorAssign<TensorEngine<1,T,Symmetric>,
-  T2,Op,B1,L1,B2,L2>
-{
-  static void apply(TensorEngine<1,T,Symmetric> &x, const T2 &y,
-                    Op op=Op())
-  {
-//     TensorAssign<TensorEngine<1,T,Symmetric>,T2,OpAssign,0,1,0,1>::
-//       apply(x,y,op);
-    TensorAssign<TensorEngine<1,T,Symmetric>,T2,Op,0,1,0,1>::apply(x,y,op);
-  }
-};
-template<class T, class T2, class Op, int B1, int L1, int B2, int L2>
-struct SymmetricTensorAssign<Tensor<1,T,Symmetric>,
-  T2,Op,B1,L1,B2,L2>
-{
-  static void apply(Tensor<1,T,Symmetric> &x, const T2 &y,
-                    Op op=Op())
-  {
-    TensorAssign<Tensor<1,T,Symmetric>,T2,Op,0,1,0,1>::apply(x,y,op);
-  }
-};
 // 2D partial specialization:
-template<class T, class T2, class Op, int B1, int L1, int B2, int L2>
-struct SymmetricTensorAssign<TensorEngine<2,T,Symmetric>,
-  T2,Op,B1,L1,B2,L2>
+template<template <int, class, class> class T1, class T, class T2, class Op>
+struct TensorAssign<T1<2,T,Symmetric>,T2,Op,0,2,0,2>
 {
-  static void apply(TensorEngine<2,T,Symmetric> &x, const T2 &y,
+  static void apply(T1<2,T,Symmetric> &x, const T2 &y,
                     Op op=Op())
   {
-//     TensorAssign<TensorEngine<2,T,Symmetric>,T2,OpAssign,0,1,0,1>::
-//       apply(x,y,op);
-//     TensorAssign<TensorEngine<2,T,Symmetric>,T2,OpAssign,1,1,0,2>::
-//       apply(x,y,op);
-    TensorAssign<TensorEngine<2,T,Symmetric>,T2,Op,0,1,0,1>::apply(x,y,op);
-    TensorAssign<TensorEngine<2,T,Symmetric>,T2,Op,1,1,0,2>::apply(x,y,op);
-  }
-};
-template<class T, class T2, class Op, int B1, int L1, int B2, int L2>
-struct SymmetricTensorAssign<Tensor<2,T,Symmetric>,
-  T2,Op,B1,L1,B2,L2>
-{
-  static void apply(Tensor<2,T,Symmetric> &x, const T2 &y,
-                    Op op=Op())
-  {
-    TensorAssign<Tensor<2,T,Symmetric>,T2,Op,0,1,0,1>::apply(x,y,op);
-    TensorAssign<Tensor<2,T,Symmetric>,T2,Op,1,1,0,2>::apply(x,y,op);
+    TensorAssign<T1<2,T,Symmetric>,T2,Op,0,1,0,1>::apply(x,y,op);
+    TensorAssign<T1<2,T,Symmetric>,T2,Op,1,1,0,2>::apply(x,y,op);
   }
 };
 // 3D partial specialization:
-template<class T, class T2, class Op, int B1, int L1, int B2, int L2>
-struct SymmetricTensorAssign<TensorEngine<3,T,Symmetric>,
-  T2,Op,B1,L1,B2,L2>
-{
-  static void apply(TensorEngine<3,T,Symmetric> &x, const T2 &y,
-                    Op op=Op())
-  {
-//     TensorAssign<TensorEngine<3,T,Symmetric>,T2,OpAssign,0,1,0,1>::
-//       apply(x,y,op);
-//     TensorAssign<TensorEngine<3,T,Symmetric>,T2,OpAssign,1,1,0,2>::
-//       apply(x,y,op);
-//     TensorAssign<TensorEngine<3,T,Symmetric>,T2,OpAssign,2,1,0,3>::
-//       apply(x,y,op);
-    TensorAssign<TensorEngine<3,T,Symmetric>,T2,Op,0,1,0,1>::apply(x,y,op);
-    TensorAssign<TensorEngine<3,T,Symmetric>,T2,Op,1,1,0,2>::apply(x,y,op);
-    TensorAssign<TensorEngine<3,T,Symmetric>,T2,Op,2,1,0,3>::apply(x,y,op);
-  }
-};
-template<class T, class T2, class Op, int B1, int L1, int B2, int L2>
-struct SymmetricTensorAssign<Tensor<3,T,Symmetric>,T2,Op,B1,L1,B2,L2>
+template<template <int, class, class> class T1, class T, class T2, class Op>
+struct TensorAssign<T1<3,T,Symmetric>,T2,Op,0,3,0,3>
 {
-  static void apply(Tensor<3,T,Symmetric> &x, const T2 &y,
+  static void apply(T1<3,T,Symmetric> &x, const T2 &y,
                     Op op=Op())
   {
-    TensorAssign<Tensor<3,T,Symmetric>,T2,Op,0,1,0,1>::apply(x,y,op);
-    TensorAssign<Tensor<3,T,Symmetric>,T2,Op,1,1,0,2>::apply(x,y,op);
-    TensorAssign<Tensor<3,T,Symmetric>,T2,Op,2,1,0,3>::apply(x,y,op);
+    TensorAssign<T1<3,T,Symmetric>,T2,Op,0,1,0,1>::apply(x,y,op);
+    TensorAssign<T1<3,T,Symmetric>,T2,Op,1,1,0,2>::apply(x,y,op);
+    TensorAssign<T1<3,T,Symmetric>,T2,Op,2,1,0,3>::apply(x,y,op);
   }
 };

@@ -1319,7 +1203,7 @@
   // Copy ctor is deep.
   TensorEngine(const TensorEngine<D,T,Diagonal> &x)
   {
-    DiagonalTensorAssign<This_t,This_t,OpAssign,0,d,0,d>::
+    TensorAssign<This_t,This_t,OpAssign,0,d,0,d>::
       apply(*this,x,OpAssign());
   }

@@ -1424,7 +1308,7 @@
   operator=(const This_t &x)
   {
     if (this != &x) {
-      DiagonalTensorAssign<This_t,This_t,OpAssign,0,d,0,d>::
+      TensorAssign<This_t,This_t,OpAssign,0,d,0,d>::
         apply(*this,x,OpAssign());
     }
     return *this;
@@ -1435,8 +1319,7 @@
   This_t&
   operator=(const V &x)
   {
-//     TensorAssign<This_t,V,OpAssign,0,D,0,D>::apply(*this,x,OpAssign());
-    DiagonalTensorAssign<This_t,V,OpAssign,0,d,0,d>::
+    TensorAssign<This_t,V,OpAssign,0,d,0,d>::
       apply(*this,x,OpAssign());
     return *this;
   }
@@ -1543,91 +1426,35 @@
 T TensorEngine<D,T,Diagonal>::Zero = 0.0;


-// ----------------------------------------------------------------------------
-// Special diagonal assignment class: Has specializations for different
-// dimensionalities (for 1, 2, and 3, so far). This may ultimately be
-// replaceable with a dimensionality-independent equivalent that uses template
-// metaprogramming. It may, in fact, be replaceable with partial
-// specializations of TensorAssign itself, with
-// TensorEngine<D,T,Diagonal> partial specializations for the general
-// class parameter T1 and/or T2 of TensorAssign. --TJW 9/10/1999
-// ----------------------------------------------------------------------------
+/**
+ * Special diagonal assignment class: Has specializations for different
+ * dimensionalities (for 2, and 3, so far). This may ultimately be
+ * replaceable with a dimensionality-independent equivalent that uses template
+ * metaprogramming. It may, in fact, be replaceable with partial
+ * specializations of TensorAssign itself, with
+ * TensorEngine<D,T,Diagonal> partial specializations for the general
+ * class parameter T1 and/or T2 of TensorAssign. --TJW 9/10/1999
+ */

-// General template: does nothing:
-template<class T1, class T2, class Op, int B1, int L1, int B2, int L2>
-struct DiagonalTensorAssign
-{
-  static void apply(T1& x, const T2& y, Op op=Op()) { }
-};
-// 1D partial specialization:
-template<class T, class T2, class Op, int B1, int L1, int B2, int L2>
-struct DiagonalTensorAssign<TensorEngine<1,T,Diagonal>,T2,Op,B1,L1,B2,L2>
-{
-  static void apply(TensorEngine<1,T,Diagonal> &x, const T2 &y, Op op=Op())
-  {
-//     TensorAssign<TensorEngine<1,T,Diagonal>,T2,OpAssign,0,1,0,1>::
-//       apply(x,y,op);
-    TensorAssign<TensorEngine<1,T,Diagonal>,T2,Op,0,1,0,1>::apply(x,y,op);
-  }
-};
-template<class T, class T2, class Op, int B1, int L1, int B2, int L2>
-struct DiagonalTensorAssign<Tensor<1,T,Diagonal>,T2,Op,B1,L1,B2,L2>
-{
-  static void apply(Tensor<1,T,Diagonal> &x, const T2 &y, Op op=Op())
-  {
-    TensorAssign<Tensor<1,T,Diagonal>,T2,Op,0,1,0,1>::apply(x,y,op);
-  }
-};
 // 2D partial specialization:
-template<class T, class T2, class Op, int B1, int L1, int B2, int L2>
-struct DiagonalTensorAssign<TensorEngine<2,T,Diagonal>,T2,Op,B1,L1,B2,L2>
-{
-  static void apply(TensorEngine<2,T,Diagonal> &x, const T2 &y, Op op=Op())
-  {
-//     TensorAssign<TensorEngine<2,T,Diagonal>,T2,OpAssign,0,1,0,1>::
-//       apply(x,y,op);
-//     TensorAssign<TensorEngine<2,T,Diagonal>,T2,OpAssign,1,1,1,1>::
-//       apply(x,y,op);
-    TensorAssign<TensorEngine<2,T,Diagonal>,T2,Op,0,1,0,1>::
-      apply(x,y,op);
-    TensorAssign<TensorEngine<2,T,Diagonal>,T2,Op,1,1,1,1>::
-      apply(x,y,op);
-  }
-};
-template<class T, class T2, class Op, int B1, int L1, int B2, int L2>
-struct DiagonalTensorAssign<Tensor<2,T,Diagonal>,T2,Op,B1,L1,B2,L2>
+template<template <int, class, class> class T1, class T, class T2, class Op>
+struct TensorAssign<T1<2,T,Diagonal>,T2,Op,0,2,0,2>
 {
-  static void apply(Tensor<2,T,Diagonal> &x, const T2 &y, Op op=Op())
+  static void apply(T1<2,T,Diagonal> &x, const T2 &y, Op op=Op())
   {
-    TensorAssign<Tensor<2,T,Diagonal>,T2,Op,0,1,0,1>::apply(x,y,op);
-    TensorAssign<Tensor<2,T,Diagonal>,T2,Op,1,1,1,1>::apply(x,y,op);
+    TensorAssign<T1<2,T,Diagonal>,T2,Op,0,1,0,1>::apply(x,y,op);
+    TensorAssign<T1<2,T,Diagonal>,T2,Op,1,1,1,1>::apply(x,y,op);
   }
 };
 // 3D partial specialization:
-template<class T, class T2, class Op, int B1, int L1, int B2, int L2>
-struct DiagonalTensorAssign<TensorEngine<3,T,Diagonal>,T2,Op,B1,L1,B2,L2>
-{
-  static void apply(TensorEngine<3,T,Diagonal> &x, const T2 &y, Op op=Op())
-  {
-//     TensorAssign<TensorEngine<3,T,Diagonal>,T2,OpAssign,0,1,0,1>::
-//       apply(x,y,op);
-//     TensorAssign<TensorEngine<3,T,Diagonal>,T2,OpAssign,1,1,1,1>::
-//       apply(x,y,op);
-//     TensorAssign<TensorEngine<3,T,Diagonal>,T2,OpAssign,2,1,2,1>::
-//       apply(x,y,op);
-    TensorAssign<TensorEngine<3,T,Diagonal>,T2,Op,0,1,0,1>::apply(x,y,op);
-    TensorAssign<TensorEngine<3,T,Diagonal>,T2,Op,1,1,1,1>::apply(x,y,op);
-    TensorAssign<TensorEngine<3,T,Diagonal>,T2,Op,2,1,2,1>::apply(x,y,op);
-  }
-};
-template<class T, class T2, class Op, int B1, int L1, int B2, int L2>
-struct DiagonalTensorAssign<Tensor<3,T,Diagonal>,T2,Op,B1,L1,B2,L2>
+template<template <int, class, class> class T1, class T, class T2, class Op>
+struct TensorAssign<T1<3,T,Diagonal>,T2,Op,0,3,0,3>
 {
-  static void apply(Tensor<3,T,Diagonal> &x, const T2 &y, Op op=Op())
+  static void apply(T1<3,T,Diagonal> &x, const T2 &y, Op op=Op())
   {
-    TensorAssign<Tensor<3,T,Diagonal>,T2,Op,0,1,0,1>::apply(x,y,op);
-    TensorAssign<Tensor<3,T,Diagonal>,T2,Op,1,1,1,1>::apply(x,y,op);
-    TensorAssign<Tensor<3,T,Diagonal>,T2,Op,2,1,2,1>::apply(x,y,op);
+    TensorAssign<T1<3,T,Diagonal>,T2,Op,0,1,0,1>::apply(x,y,op);
+    TensorAssign<T1<3,T,Diagonal>,T2,Op,1,1,1,1>::apply(x,y,op);
+    TensorAssign<T1<3,T,Diagonal>,T2,Op,2,1,2,1>::apply(x,y,op);
   }
 };

diff -Nru a/r2/src/Tiny/TensorOperators.h b/r2/src/Tiny/TensorOperators.h
--- a/r2/src/Tiny/TensorOperators.h     Sat Nov  8 15:26:41 2003
+++ b/r2/src/Tiny/TensorOperators.h     Sat Nov  8 15:26:41 2003
@@ -53,12 +53,6 @@

 template<int D, class T, class E> class Tensor;
 class Full;
-template<class T1, class T2, class Op, int B1, int L1, int B2, int L2>
-struct SymmetricTensorAssign;
-template<class T1, class T2, class Op, int B1, int L1, int B2, int L2>
-struct AntisymmetricTensorAssign;
-template<class T1, class T2, class Op, int B1, int L1, int B2, int L2>
-struct DiagonalTensorAssign;

 //-----------------------------------------------------------------------------
 //
@@ -744,7 +738,7 @@
 {                                                                             \
   typedef Tensor<D,T1,Symmetric> Left_t;                                      \
   typedef Tensor<D,T2,Symmetric> Right_t;                                     \
-  SymmetricTensorAssign<Left_t,Right_t,TAG,0,D,0,D>::apply(v1,v2,TAG());      \
+  TensorAssign<Left_t,Right_t,TAG,0,D,0,D>::apply(v1,v2,TAG());      \
   return v1;                                                                  \
 }                                                                             \
                                                                               \
@@ -754,7 +748,7 @@
 {                                                                             \
   typedef Tensor<D,T1,Antisymmetric> Left_t;                                  \
   typedef Tensor<D,T2,Antisymmetric> Right_t;                                 \
-  AntisymmetricTensorAssign<Left_t,Right_t,TAG,0,D,0,D>::apply(v1,v2,TAG());  \
+  TensorAssign<Left_t,Right_t,TAG,0,D,0,D>::apply(v1,v2,TAG());  \
   return v1;                                                                  \
 }                                                                             \
                                                                               \
@@ -764,7 +758,7 @@
 {                                                                             \
   typedef Tensor<D,T1,Diagonal> Left_t;                                       \
   typedef Tensor<D,T2,Diagonal> Right_t;                                      \
-  DiagonalTensorAssign<Left_t,Right_t,TAG,0,D,0,D>::apply(v1,v2,TAG());       \
+  TensorAssign<Left_t,Right_t,TAG,0,D,0,D>::apply(v1,v2,TAG());       \
   return v1;                                                                  \
 }                                                                             \
                                                                               \
@@ -780,7 +774,7 @@
 inline Tensor<D,T1,Symmetric>&                                                \
 FUNC( Tensor<D,T1,Symmetric>& v1, const T2& v2 )                              \
 {                                                                             \
-  SymmetricTensorAssign<Tensor<D,T1,Symmetric>,T2,TAG,0,D,0,D>::              \
+  TensorAssign<Tensor<D,T1,Symmetric>,T2,TAG,0,D,0,D>::              \
     apply(v1,v2,TAG());                                                       \
   return v1;                                                                  \
 }                                                                             \
@@ -789,7 +783,7 @@
 inline Tensor<D,T1,Antisymmetric>&                                            \
 FUNC( Tensor<D,T1,Antisymmetric>& v1, const T2& v2 )                          \
 {                                                                             \
-  AntisymmetricTensorAssign<Tensor<D,T1,Antisymmetric>,T2,TAG,0,D,0,D>::      \
+  TensorAssign<Tensor<D,T1,Antisymmetric>,T2,TAG,0,D,0,D>::      \
     apply(v1,v2,TAG());                                                       \
   return v1;                                                                  \
 }                                                                             \
@@ -798,7 +792,7 @@
 inline Tensor<D,T1,Diagonal>&                                                 \
 FUNC( Tensor<D,T1,Diagonal>& v1, const T2& v2 )                               \
 {                                                                             \
-  DiagonalTensorAssign<Tensor<D,T1,Diagonal>,T2,TAG,0,D,0,D>::                \
+  TensorAssign<Tensor<D,T1,Diagonal>,T2,TAG,0,D,0,D>::                \
     apply(v1,v2,TAG());                                                       \
   return v1;                                                                  \
 }