[PATCH] Clean up Tensor.h

[Richard Guenther]

Hi!

I'm staring a lot on Tensor.h and TensorElement.h from time to time.
And I think its very complicated and undocumented. Does anyone remember
what exactly the TensorAssign<> template is doing? And why it was done
this way instead of simple loops? Are the T1 and T2 argument templates
really independend, or are they supposed to have the same tensor structure
(Antisymmentric, Symmetric, etc.) and the same base type?

Anyway, here's some first cleanup to reduce the code one has to look at ;)

Tested on x86 using gcc3.3 and Intel icpc.

Ok?

Richard.


2003Nov03  Richard Guenther <address@hidden>

        * src/Tiny/Tensor.h: remove default implementations of
        (Antisymmentric|Symmetric|Diagonal)TensorAssign<>.
        Use template template parameter specialization
        to get rid of Tensor<> and TensorEngine<> specialization
        duplicates.

===== Tensor.h 1.8 vs edited =====
--- 1.8/r2/src/Tiny/Tensor.h    Mon Nov  3 11:03:34 2003
+++ edited/Tensor.h     Mon Nov  3 13:02:25 2003
@@ -871,64 +871,36 @@
 struct AntisymmetricTensorAssign;

 // 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>
-{
-  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>
+template<template <int, class, class> class T1, class T, class T2, class Op, 
int B1, int L1, int B2, int L2>
+struct AntisymmetricTensorAssign<T1<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>,
+template<template <int, class, class> class T1, class T, class T2, class Op, 
int B1, int L1, int B2, int L2>
+struct AntisymmetricTensorAssign<T1<2,T,Antisymmetric>,
   T2,Op,B1,L1,B2,L2>
 {
-  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,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>,
+template<template <int, class, class> class T1, class T, class T2, class Op, 
int B1, int L1, int B2, int L2>
+struct AntisymmetricTensorAssign<T1<3,T,Antisymmetric>,
   T2,Op,B1,L1,B2,L2>
 {
-  static void apply(TensorEngine<3,T,Antisymmetric> &x, const T2 &y,
+  static void apply(T1<3,T,Antisymmetric> &x, const T2 &y,
                     Op op=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);
   }
 };

@@ -1148,71 +1120,37 @@
 struct SymmetricTensorAssign;

 // 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,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>,
+template<template <int, class, class> class T1, class T, class T2, class Op, 
int B1, int L1, int B2, int L2>
+struct SymmetricTensorAssign<T1<1,T,Symmetric>,
   T2,Op,B1,L1,B2,L2>
 {
-  static void apply(Tensor<1,T,Symmetric> &x, const T2 &y,
+  static void apply(T1<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);
+    TensorAssign<T1<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, 
int B1, int L1, int B2, int L2>
+struct SymmetricTensorAssign<T1<2,T,Symmetric>,T2,Op,B1,L1,B2,L2>
 {
-  static void apply(TensorEngine<2,T,Symmetric> &x, const T2 &y,
-                    Op op=Op())
+  static void apply(T1<2,T,Symmetric> &x, const T2 &y, Op op=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>
+template<template <int, class, class> class T1, class T, class T2, class Op, 
int B1, int L1, int B2, int L2>
+struct SymmetricTensorAssign<T1<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,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>
-{
-  static void apply(Tensor<3,T,Symmetric> &x, const T2 &y,
-                    Op op=Op())
+  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);
   }
 };

@@ -1531,62 +1469,37 @@
 struct DiagonalTensorAssign;

 // 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>
+template<template <int, class, class> class T1, class T, class T2, class Op, 
int B1, int L1, int B2, int L2>
+struct DiagonalTensorAssign<T1<1,T,Diagonal>,T2,Op,B1,L1,B2,L2>
 {
-  static void apply(TensorEngine<1,T,Diagonal> &x, const T2 &y, Op op=Op())
+  static void apply(T1<1,T,Diagonal> &x, const T2 &y, Op op=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);
+    TensorAssign<T1<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>
+template<template <int, class, class> class T1, class T, class T2, class Op, 
int B1, int L1, int B2, int L2>
+struct DiagonalTensorAssign<T1<2,T,Diagonal>,T2,Op,B1,L1,B2,L2>
 {
-  static void apply(TensorEngine<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<TensorEngine<2,T,Diagonal>,T2,Op,0,1,0,1>::
+    TensorAssign<T1<2,T,Diagonal>,T2,Op,0,1,0,1>::
       apply(x,y,op);
-    TensorAssign<TensorEngine<2,T,Diagonal>,T2,Op,1,1,1,1>::
+    TensorAssign<T1<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>
-{
-  static void apply(Tensor<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);
-  }
-};
+
 // 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,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, 
int B1, int L1, int B2, int L2>
+struct DiagonalTensorAssign<T1<3,T,Diagonal>,T2,Op,B1,L1,B2,L2>
 {
-  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);
   }
 };