Added tests for 4D tensors. Now using a consistant cubes,slices,rows,columns index order everywhere.

4 files changed, 635 insertions, 0 deletions

diff --git a/doc/swig/test/SuperTensor.cxx b/doc/swig/test/SuperTensor.cxx
new file mode 100644
index 000000000..82e8a4bd5
--- /dev/null
+++ b/doc/swig/test/SuperTensor.cxx
@@ -0,0 +1,144 @@
+#include <stdlib.h>
+#include <math.h>
+#include <iostream>
+#include "SuperTensor.h"
+
+// The following macro defines a family of functions that work with 3D
+// arrays with the forms
+//
+//     TYPE SNAMENorm(   TYPE supertensor[2][2][2][2]);
+//     TYPE SNAMEMax(    TYPE * supertensor, int cubes, int slices, int rows, int cols);
+//     TYPE SNAMEMin(    int cubes, int slices, int rows, int cols, TYPE * supertensor);
+//     void SNAMEScale(  TYPE supertensor[3][3][3][3]);
+//     void SNAMEFloor(  TYPE * array,  int cubes, int slices, int rows, int cols, TYPE floor);
+//     void SNAMECeil(   int slices, int cubes, int slices, int rows, int cols, TYPE * array, TYPE ceil);
+//     void SNAMELUSplit(TYPE in[2][2][2][2], TYPE lower[2][2][2][2], TYPE upper[2][2][2][2]);
+//
+// for any specified type TYPE (for example: short, unsigned int, long
+// long, etc.) with given short name SNAME (for example: short, uint,
+// longLong, etc.).  The macro is then expanded for the given
+// TYPE/SNAME pairs.  The resulting functions are for testing numpy
+// interfaces, respectively, for:
+//
+//  * 4D input arrays, hard-coded length
+//  * 4D input arrays
+//  * 4D input arrays, data last
+//  * 4D in-place arrays, hard-coded lengths
+//  * 4D in-place arrays
+//  * 4D in-place arrays, data last
+//  * 4D argout arrays, hard-coded length
+//
+#define TEST_FUNCS(TYPE, SNAME) \
+\
+TYPE SNAME ## Norm(TYPE supertensor[2][2][2][2]) {	     \
+  double result = 0;				     \
+  for (int l=0; l<2; ++l)			     \
+    for (int k=0; k<2; ++k)			     \
+      for (int j=0; j<2; ++j)			     \
+        for (int i=0; i<2; ++i)			     \
+          result += supertensor[l][k][j][i] * supertensor[l][k][j][i]; \
+  return (TYPE)sqrt(result/16);			     \
+}						     \
+\
+TYPE SNAME ## Max(TYPE * supertensor, int cubes, int slices, int rows, int cols) { \
+  int i, j, k, l, index;						\
+  TYPE result = supertensor[0];					\
+  for (l=0; l<cubes; ++l) {					\
+    for (k=0; k<slices; ++k) {					\
+      for (j=0; j<rows; ++j) {					\
+        for (i=0; i<cols; ++i) {					\
+          index = l*slices*rows*cols + k*rows*cols + j*cols + i;			\
+          if (supertensor[index] > result) result = supertensor[index];	\
+        }                           \
+      }								\
+    }								\
+  }								\
+  return result;						\
+}								\
+\
+TYPE SNAME ## Min(int cubes, int slices, int rows, int cols, TYPE * supertensor) {	\
+  int i, j, k, l, index;						\
+  TYPE result = supertensor[0];					\
+  for (l=0; l<cubes; ++l) {					\
+    for (k=0; k<slices; ++k) {					\
+      for (j=0; j<rows; ++j) {					\
+        for (i=0; i<cols; ++i) {					\
+          index = l*slices*rows*cols + k*rows*cols + j*cols + i;			\
+          if (supertensor[index] < result) result = supertensor[index];	\
+        }                       \
+      }								\
+    }								\
+  }								\
+  return result;						\
+}								\
+\
+void SNAME ## Scale(TYPE array[3][3][3][3], TYPE val) { \
+  for (int l=0; l<3; ++l)			     \
+    for (int k=0; k<3; ++k)			     \
+      for (int j=0; j<3; ++j)			     \
+        for (int i=0; i<3; ++i)			     \
+          array[l][k][j][i] *= val;			     \
+}						     \
+\
+void SNAME ## Floor(TYPE * array, int cubes, int slices, int rows, int cols, TYPE floor) { \
+  int i, j, k, l, index;							     \
+  for (l=0; l<cubes; ++l) {			     \
+    for (k=0; k<slices; ++k) {						     \
+      for (j=0; j<rows; ++j) {						     \
+        for (i=0; i<cols; ++i) {						     \
+          index = l*slices*rows*cols + k*rows*cols + j*cols + i;			\
+          if (array[index] < floor) array[index] = floor;			     \
+        }									     \
+      }                                         \
+    }									     \
+  }									     \
+}									     \
+\
+void SNAME ## Ceil(int cubes, int slices, int rows, int cols, TYPE * array, TYPE ceil) { \
+  int i, j, k, l, index;							   \
+  for (l=0; l<cubes; ++l) {						   \
+    for (k=0; k<slices; ++k) {						   \
+      for (j=0; j<rows; ++j) {						   \
+        for (i=0; i<cols; ++i) {						   \
+          index = l*slices*rows*cols + k*rows*cols + j*cols + i;			\
+          if (array[index] > ceil) array[index] = ceil;			   \
+        }                                   \
+      }									   \
+    }									   \
+  }									   \
+}									   \
+\
+void SNAME ## LUSplit(TYPE supertensor[2][2][2][2], TYPE lower[2][2][2][2], \
+		      TYPE upper[2][2][2][2]) {			 \
+  int sum;							 \
+  for (int l=0; l<2; ++l) {					 \
+    for (int k=0; k<2; ++k) {					 \
+      for (int j=0; j<2; ++j) {					 \
+        for (int i=0; i<2; ++i) {					 \
+          sum = i + j + k + l;					 \
+          if (sum < 2) {						 \
+            lower[l][k][j][i] = supertensor[l][k][j][i];			 \
+            upper[l][k][j][i] = 0;					 \
+          } else {						 \
+            upper[l][k][j][i] = supertensor[l][k][j][i];			 \
+            lower[l][k][j][i] = 0;					 \
+          }							 \
+        }                           \
+      }								 \
+    }								 \
+  }								 \
+}
+
+TEST_FUNCS(signed char       , schar    )
+TEST_FUNCS(unsigned char     , uchar    )
+TEST_FUNCS(short             , short    )
+TEST_FUNCS(unsigned short    , ushort   )
+TEST_FUNCS(int               , int      )
+TEST_FUNCS(unsigned int      , uint     )
+TEST_FUNCS(long              , long     )
+TEST_FUNCS(unsigned long     , ulong    )
+TEST_FUNCS(long long         , longLong )
+TEST_FUNCS(unsigned long long, ulongLong)
+TEST_FUNCS(float             , float    )
+TEST_FUNCS(double            , double   )
+
diff --git a/doc/swig/test/SuperTensor.h b/doc/swig/test/SuperTensor.h
new file mode 100644
index 000000000..29cc3bbbb
--- /dev/null
+++ b/doc/swig/test/SuperTensor.h
@@ -0,0 +1,53 @@
+#ifndef SUPERTENSOR_H
+#define SUPERTENSOR_H
+
+// The following macro defines the prototypes for a family of
+// functions that work with 4D arrays with the forms
+//
+//     TYPE SNAMENorm(   TYPE supertensor[2][2][2][2]);
+//     TYPE SNAMEMax(    TYPE * supertensor, int cubes, int slices, int rows, int cols);
+//     TYPE SNAMEMin(    int cubes, int slices, int rows, int cols, TYPE * supertensor);
+//     void SNAMEScale(  TYPE array[3][3][3][3]);
+//     void SNAMEFloor(  TYPE * array,  int cubes, int slices, int rows, int cols, TYPE floor);
+//     void SNAMECeil(   int cubes, int slices, int rows, int cols, TYPE * array,  TYPE ceil );
+//     void SNAMELUSplit(TYPE in[3][3][3][3], TYPE lower[3][3][3][3], TYPE upper[3][3][3][3]);
+//
+// for any specified type TYPE (for example: short, unsigned int, long
+// long, etc.) with given short name SNAME (for example: short, uint,
+// longLong, etc.).  The macro is then expanded for the given
+// TYPE/SNAME pairs.  The resulting functions are for testing numpy
+// interfaces, respectively, for:
+//
+//  * 4D input arrays, hard-coded lengths
+//  * 4D input arrays
+//  * 4D input arrays, data last
+//  * 4D in-place arrays, hard-coded lengths
+//  * 4D in-place arrays
+//  * 4D in-place arrays, data last
+//  * 4D argout arrays, hard-coded length
+//
+#define TEST_FUNC_PROTOS(TYPE, SNAME) \
+\
+TYPE SNAME ## Norm(   TYPE supertensor[2][2][2][2]); \
+TYPE SNAME ## Max(    TYPE * supertensor, int cubes, int slices, int rows, int cols); \
+TYPE SNAME ## Min(    int cubes, int slices, int rows, int cols, TYPE * supertensor); \
+void SNAME ## Scale(  TYPE array[3][3][3][3], TYPE val); \
+void SNAME ## Floor(  TYPE * array, int cubes, int slices, int rows, int cols, TYPE floor); \
+void SNAME ## Ceil(   int cubes, int slices, int rows, int cols, TYPE * array, TYPE ceil ); \
+void SNAME ## LUSplit(TYPE supertensor[2][2][2][2], TYPE lower[2][2][2][2], TYPE upper[2][2][2][2]);
+
+TEST_FUNC_PROTOS(signed char       , schar    )
+TEST_FUNC_PROTOS(unsigned char     , uchar    )
+TEST_FUNC_PROTOS(short             , short    )
+TEST_FUNC_PROTOS(unsigned short    , ushort   )
+TEST_FUNC_PROTOS(int               , int      )
+TEST_FUNC_PROTOS(unsigned int      , uint     )
+TEST_FUNC_PROTOS(long              , long     )
+TEST_FUNC_PROTOS(unsigned long     , ulong    )
+TEST_FUNC_PROTOS(long long         , longLong )
+TEST_FUNC_PROTOS(unsigned long long, ulongLong)
+TEST_FUNC_PROTOS(float             , float    )
+TEST_FUNC_PROTOS(double            , double   )
+
+#endif
+
diff --git a/doc/swig/test/SuperTensor.i b/doc/swig/test/SuperTensor.i
new file mode 100644
index 000000000..7521b8ec4
--- /dev/null
+++ b/doc/swig/test/SuperTensor.i
@@ -0,0 +1,50 @@
+// -*- c++ -*-
+%module SuperTensor
+
+%{
+#define SWIG_FILE_WITH_INIT
+#include "SuperTensor.h"
+%}
+
+// Get the NumPy typemaps
+%include "../numpy.i"
+
+%init %{
+  import_array();
+%}
+
+%define %apply_numpy_typemaps(TYPE)
+
+%apply (TYPE IN_ARRAY4[ANY][ANY][ANY][ANY]) {(TYPE supertensor[ANY][ANY][ANY][ANY])};
+%apply (TYPE* IN_ARRAY4, int DIM1, int DIM2, int DIM3, int DIM4)
+      {(TYPE* supertensor, int cubes, int slices, int rows, int cols)};
+%apply (int DIM1, int DIM2, int DIM3, int DIM4, TYPE* IN_ARRAY4)
+      {(int cubes, int slices, int rows, int cols, TYPE* supertensor)};
+
+%apply (TYPE INPLACE_ARRAY4[ANY][ANY][ANY][ANY]) {(TYPE array[3][3][3][3])};
+%apply (TYPE* INPLACE_ARRAY4, int DIM1, int DIM2, int DIM3, int DIM4)
+      {(TYPE* array, int cubes, int slices, int rows, int cols)};
+%apply (int DIM1, int DIM2, int DIM3, int DIM4, TYPE* INPLACE_ARRAY4)
+      {(int cubes, int slices, int rows, int cols, TYPE* array)};
+
+%apply (TYPE ARGOUT_ARRAY4[ANY][ANY][ANY][ANY]) {(TYPE lower[2][2][2][2])};
+%apply (TYPE ARGOUT_ARRAY4[ANY][ANY][ANY][ANY]) {(TYPE upper[2][2][2][2])};
+
+%enddef    /* %apply_numpy_typemaps() macro */
+
+%apply_numpy_typemaps(signed char       )
+%apply_numpy_typemaps(unsigned char     )
+%apply_numpy_typemaps(short             )
+%apply_numpy_typemaps(unsigned short    )
+%apply_numpy_typemaps(int               )
+%apply_numpy_typemaps(unsigned int      )
+%apply_numpy_typemaps(long              )
+%apply_numpy_typemaps(unsigned long     )
+%apply_numpy_typemaps(long long         )
+%apply_numpy_typemaps(unsigned long long)
+%apply_numpy_typemaps(float             )
+%apply_numpy_typemaps(double            )
+
+// Include the header file to be wrapped
+%include "SuperTensor.h"
+
diff --git a/doc/swig/test/testSuperTensor.py b/doc/swig/test/testSuperTensor.py
new file mode 100644
index 000000000..f4ae09e76
--- /dev/null
+++ b/doc/swig/test/testSuperTensor.py
@@ -0,0 +1,388 @@
+#! /usr/bin/env python
+from __future__ import division
+
+# System imports
+from   distutils.util import get_platform
+from   math           import sqrt
+import os
+import sys
+import unittest
+
+# Import NumPy
+import numpy as np
+major, minor = [ int(d) for d in np.__version__.split(".")[:2] ]
+if major == 0: BadListError = TypeError
+else:          BadListError = ValueError
+
+import SuperTensor
+
+######################################################################
+
+class SuperTensorTestCase(unittest.TestCase):
+
+    def __init__(self, methodName="runTests"):
+        unittest.TestCase.__init__(self, methodName)
+        self.typeStr  = "double"
+        self.typeCode = "d"
+
+    # Test (type IN_ARRAY3[ANY][ANY][ANY]) typemap
+    def testNorm(self):
+        "Test norm function"
+        print >>sys.stderr, self.typeStr, "... ",
+        norm = SuperTensor.__dict__[self.typeStr + "Norm"]
+        supertensor = np.arange(2*2*2*2,dtype=self.typeCode).reshape((2,2,2,2))
+        #Note: cludge to get an answer of the same type as supertensor.
+        #Answer is simply sqrt(sum(supertensor*supertensor)/16)
+        answer = np.array([np.sqrt(np.sum(supertensor.astype('d')*supertensor)/16.)],dtype=self.typeCode)[0]
+        self.assertAlmostEqual(norm(supertensor), answer, 6)
+
+    # Test (type IN_ARRAY3[ANY][ANY][ANY]) typemap
+    def testNormBadList(self):
+        "Test norm function with bad list"
+        print >>sys.stderr, self.typeStr, "... ",
+        norm = SuperTensor.__dict__[self.typeStr + "Norm"]
+        supertensor = [[[[0,"one"],[2,3]], [[3,"two"],[1,0]]],[[[0,"one"],[2,3]], [[3,"two"],[1,0]]]]
+        self.assertRaises(BadListError, norm, supertensor)
+
+    # Test (type IN_ARRAY3[ANY][ANY][ANY]) typemap
+    def testNormWrongDim(self):
+        "Test norm function with wrong dimensions"
+        print >>sys.stderr, self.typeStr, "... ",
+        norm = SuperTensor.__dict__[self.typeStr + "Norm"]
+        supertensor = np.arange(2*2*2,dtype=self.typeCode).reshape((2,2,2))
+        self.assertRaises(TypeError, norm, supertensor)
+
+    # Test (type IN_ARRAY3[ANY][ANY][ANY]) typemap
+    def testNormWrongSize(self):
+        "Test norm function with wrong size"
+        print >>sys.stderr, self.typeStr, "... ",
+        norm = SuperTensor.__dict__[self.typeStr + "Norm"]
+        supertensor = np.arange(3*2*2,dtype=self.typeCode).reshape((3,2,2))
+        self.assertRaises(TypeError, norm, supertensor)
+
+    # Test (type IN_ARRAY3[ANY][ANY][ANY]) typemap
+    def testNormNonContainer(self):
+        "Test norm function with non-container"
+        print >>sys.stderr, self.typeStr, "... ",
+        norm = SuperTensor.__dict__[self.typeStr + "Norm"]
+        self.assertRaises(TypeError, norm, None)
+
+    # Test (type* IN_ARRAY3, int DIM1, int DIM2, int DIM3) typemap
+    def testMax(self):
+        "Test max function"
+        print >>sys.stderr, self.typeStr, "... ",
+        max = SuperTensor.__dict__[self.typeStr + "Max"]
+        supertensor = [[[[1,2], [3,4]], [[5,6], [7,8]]],[[[1,2], [3,4]], [[5,6], [7,8]]]]
+        self.assertEquals(max(supertensor), 8)
+
+    # Test (type* IN_ARRAY3, int DIM1, int DIM2, int DIM3) typemap
+    def testMaxBadList(self):
+        "Test max function with bad list"
+        print >>sys.stderr, self.typeStr, "... ",
+        max = SuperTensor.__dict__[self.typeStr + "Max"]
+        supertensor = [[[[1,"two"], [3,4]], [[5,"six"], [7,8]]],[[[1,"two"], [3,4]], [[5,"six"], [7,8]]]]
+        self.assertRaises(BadListError, max, supertensor)
+
+    # Test (type* IN_ARRAY3, int DIM1, int DIM2, int DIM3) typemap
+    def testMaxNonContainer(self):
+        "Test max function with non-container"
+        print >>sys.stderr, self.typeStr, "... ",
+        max = SuperTensor.__dict__[self.typeStr + "Max"]
+        self.assertRaises(TypeError, max, None)
+
+    # Test (type* IN_ARRAY3, int DIM1, int DIM2, int DIM3) typemap
+    def testMaxWrongDim(self):
+        "Test max function with wrong dimensions"
+        print >>sys.stderr, self.typeStr, "... ",
+        max = SuperTensor.__dict__[self.typeStr + "Max"]
+        self.assertRaises(TypeError, max, [0, -1, 2, -3])
+
+    # Test (int DIM1, int DIM2, int DIM3, type* IN_ARRAY3) typemap
+    def testMin(self):
+        "Test min function"
+        print >>sys.stderr, self.typeStr, "... ",
+        min = SuperTensor.__dict__[self.typeStr + "Min"]
+        supertensor = [[[[9,8], [7,6]], [[5,4], [3,2]]],[[[9,8], [7,6]], [[5,4], [3,2]]]]
+        self.assertEquals(min(supertensor), 2)
+
+    # Test (int DIM1, int DIM2, int DIM3, type* IN_ARRAY3) typemap
+    def testMinBadList(self):
+        "Test min function with bad list"
+        print >>sys.stderr, self.typeStr, "... ",
+        min = SuperTensor.__dict__[self.typeStr + "Min"]
+        supertensor = [[[["nine",8], [7,6]], [["five",4], [3,2]]],[[["nine",8], [7,6]], [["five",4], [3,2]]]]
+        self.assertRaises(BadListError, min, supertensor)
+
+    # Test (int DIM1, int DIM2, int DIM3, type* IN_ARRAY3) typemap
+    def testMinNonContainer(self):
+        "Test min function with non-container"
+        print >>sys.stderr, self.typeStr, "... ",
+        min = SuperTensor.__dict__[self.typeStr + "Min"]
+        self.assertRaises(TypeError, min, True)
+
+    # Test (int DIM1, int DIM2, int DIM3, type* IN_ARRAY3) typemap
+    def testMinWrongDim(self):
+        "Test min function with wrong dimensions"
+        print >>sys.stderr, self.typeStr, "... ",
+        min = SuperTensor.__dict__[self.typeStr + "Min"]
+        self.assertRaises(TypeError, min, [[1,3],[5,7]])
+
+    # Test (type INPLACE_ARRAY3[ANY][ANY][ANY]) typemap
+    def testScale(self):
+        "Test scale function"
+        print >>sys.stderr, self.typeStr, "... ",
+        scale = SuperTensor.__dict__[self.typeStr + "Scale"]
+        supertensor = np.arange(3*3*3*3,dtype=self.typeCode).reshape((3,3,3,3))
+        answer = supertensor.copy()*4
+        scale(supertensor,4)
+        self.assertEquals((supertensor == answer).all(), True)
+
+    # Test (type INPLACE_ARRAY3[ANY][ANY][ANY]) typemap
+    def testScaleWrongType(self):
+        "Test scale function with wrong type"
+        print >>sys.stderr, self.typeStr, "... ",
+        scale = SuperTensor.__dict__[self.typeStr + "Scale"]
+        supertensor = np.array([[[1,0,1], [0,1,0], [1,0,1]],
+                          [[0,1,0], [1,0,1], [0,1,0]],
+                          [[1,0,1], [0,1,0], [1,0,1]]],'c')
+        self.assertRaises(TypeError, scale, supertensor)
+
+    # Test (type INPLACE_ARRAY3[ANY][ANY][ANY]) typemap
+    def testScaleWrongDim(self):
+        "Test scale function with wrong dimensions"
+        print >>sys.stderr, self.typeStr, "... ",
+        scale = SuperTensor.__dict__[self.typeStr + "Scale"]
+        supertensor = np.array([[1,0,1], [0,1,0], [1,0,1],
+                          [0,1,0], [1,0,1], [0,1,0]],self.typeCode)
+        self.assertRaises(TypeError, scale, supertensor)
+
+    # Test (type INPLACE_ARRAY3[ANY][ANY][ANY]) typemap
+    def testScaleWrongSize(self):
+        "Test scale function with wrong size"
+        print >>sys.stderr, self.typeStr, "... ",
+        scale = SuperTensor.__dict__[self.typeStr + "Scale"]
+        supertensor = np.array([[[1,0], [0,1], [1,0]],
+                          [[0,1], [1,0], [0,1]],
+                          [[1,0], [0,1], [1,0]]],self.typeCode)
+        self.assertRaises(TypeError, scale, supertensor)
+
+    # Test (type INPLACE_ARRAY3[ANY][ANY][ANY]) typemap
+    def testScaleNonArray(self):
+        "Test scale function with non-array"
+        print >>sys.stderr, self.typeStr, "... ",
+        scale = SuperTensor.__dict__[self.typeStr + "Scale"]
+        self.assertRaises(TypeError, scale, True)
+
+    # Test (type* INPLACE_ARRAY3, int DIM1, int DIM2, int DIM3) typemap
+    def testFloor(self):
+        "Test floor function"
+        print >>sys.stderr, self.typeStr, "... ",
+        supertensor = np.arange(2*2*2*2,dtype=self.typeCode).reshape((2,2,2,2))
+        answer = supertensor.copy()
+        answer[answer < 4] = 4
+
+        floor = SuperTensor.__dict__[self.typeStr + "Floor"]
+        floor(supertensor,4)
+        np.testing.assert_array_equal(supertensor, answer)
+
+    # Test (type* INPLACE_ARRAY3, int DIM1, int DIM2, int DIM3) typemap
+    def testFloorWrongType(self):
+        "Test floor function with wrong type"
+        print >>sys.stderr, self.typeStr, "... ",
+        floor = SuperTensor.__dict__[self.typeStr + "Floor"]
+        supertensor = np.ones(2*2*2*2,dtype='c').reshape((2,2,2,2))
+        self.assertRaises(TypeError, floor, supertensor)
+
+    # Test (type* INPLACE_ARRAY3, int DIM1, int DIM2, int DIM3) typemap
+    def testFloorWrongDim(self):
+        "Test floor function with wrong type"
+        print >>sys.stderr, self.typeStr, "... ",
+        floor = SuperTensor.__dict__[self.typeStr + "Floor"]
+        supertensor = np.arange(2*2*2,dtype=self.typeCode).reshape((2,2,2))
+        self.assertRaises(TypeError, floor, supertensor)
+
+    # Test (type* INPLACE_ARRAY3, int DIM1, int DIM2, int DIM3) typemap
+    def testFloorNonArray(self):
+        "Test floor function with non-array"
+        print >>sys.stderr, self.typeStr, "... ",
+        floor = SuperTensor.__dict__[self.typeStr + "Floor"]
+        self.assertRaises(TypeError, floor, object)
+
+    # Test (int DIM1, int DIM2, int DIM3, type* INPLACE_ARRAY3) typemap
+    def testCeil(self):
+        "Test ceil function"
+        print >>sys.stderr, self.typeStr, "... ",
+        supertensor = np.arange(2*2*2*2,dtype=self.typeCode).reshape((2,2,2,2))
+        answer = supertensor.copy()
+        answer[answer > 5] = 5
+        ceil = SuperTensor.__dict__[self.typeStr + "Ceil"]
+        ceil(supertensor,5)
+        np.testing.assert_array_equal(supertensor, answer)
+
+    # Test (int DIM1, int DIM2, int DIM3, type* INPLACE_ARRAY3) typemap
+    def testCeilWrongType(self):
+        "Test ceil function with wrong type"
+        print >>sys.stderr, self.typeStr, "... ",
+        ceil = SuperTensor.__dict__[self.typeStr + "Ceil"]
+        supertensor = np.ones(2*2*2*2,'c').reshape((2,2,2,2))
+        self.assertRaises(TypeError, ceil, supertensor)
+
+    # Test (int DIM1, int DIM2, int DIM3, type* INPLACE_ARRAY3) typemap
+    def testCeilWrongDim(self):
+        "Test ceil function with wrong dimensions"
+        print >>sys.stderr, self.typeStr, "... ",
+        ceil = SuperTensor.__dict__[self.typeStr + "Ceil"]
+        supertensor = np.arange(2*2*2,dtype=self.typeCode).reshape((2,2,2))
+        self.assertRaises(TypeError, ceil, supertensor)
+
+    # Test (int DIM1, int DIM2, int DIM3, type* INPLACE_ARRAY3) typemap
+    def testCeilNonArray(self):
+        "Test ceil function with non-array"
+        print >>sys.stderr, self.typeStr, "... ",
+        ceil = SuperTensor.__dict__[self.typeStr + "Ceil"]
+        supertensor = np.arange(2*2*2*2,dtype=self.typeCode).reshape((2,2,2,2)).tolist()
+        self.assertRaises(TypeError, ceil, supertensor)
+
+    # Test (type ARGOUT_ARRAY3[ANY][ANY][ANY]) typemap
+    def testLUSplit(self):
+        "Test luSplit function"
+        print >>sys.stderr, self.typeStr, "... ",
+        luSplit = SuperTensor.__dict__[self.typeStr + "LUSplit"]
+        supertensor = np.ones(2*2*2*2,dtype=self.typeCode).reshape((2,2,2,2))
+        answer_upper = [[[[0, 0], [0, 1]], [[0, 1], [1, 1]]], [[[0, 1], [1, 1]], [[1, 1], [1, 1]]]]
+        answer_lower = [[[[1, 1], [1, 0]], [[1, 0], [0, 0]]], [[[1, 0], [0, 0]], [[0, 0], [0, 0]]]]
+        lower, upper = luSplit(supertensor)
+        self.assertEquals((lower == answer_lower).all(), True)
+        self.assertEquals((upper == answer_upper).all(), True)
+
+######################################################################
+
+class scharTestCase(SuperTensorTestCase):
+    def __init__(self, methodName="runTest"):
+        SuperTensorTestCase.__init__(self, methodName)
+        self.typeStr  = "schar"
+        self.typeCode = "b"
+        #self.result   = int(self.result)
+
+######################################################################
+
+class ucharTestCase(SuperTensorTestCase):
+    def __init__(self, methodName="runTest"):
+        SuperTensorTestCase.__init__(self, methodName)
+        self.typeStr  = "uchar"
+        self.typeCode = "B"
+        #self.result   = int(self.result)
+
+######################################################################
+
+class shortTestCase(SuperTensorTestCase):
+    def __init__(self, methodName="runTest"):
+        SuperTensorTestCase.__init__(self, methodName)
+        self.typeStr  = "short"
+        self.typeCode = "h"
+        #self.result   = int(self.result)
+
+######################################################################
+
+class ushortTestCase(SuperTensorTestCase):
+    def __init__(self, methodName="runTest"):
+        SuperTensorTestCase.__init__(self, methodName)
+        self.typeStr  = "ushort"
+        self.typeCode = "H"
+        #self.result   = int(self.result)
+
+######################################################################
+
+class intTestCase(SuperTensorTestCase):
+    def __init__(self, methodName="runTest"):
+        SuperTensorTestCase.__init__(self, methodName)
+        self.typeStr  = "int"
+        self.typeCode = "i"
+        #self.result   = int(self.result)
+
+######################################################################
+
+class uintTestCase(SuperTensorTestCase):
+    def __init__(self, methodName="runTest"):
+        SuperTensorTestCase.__init__(self, methodName)
+        self.typeStr  = "uint"
+        self.typeCode = "I"
+        #self.result   = int(self.result)
+
+######################################################################
+
+class longTestCase(SuperTensorTestCase):
+    def __init__(self, methodName="runTest"):
+        SuperTensorTestCase.__init__(self, methodName)
+        self.typeStr  = "long"
+        self.typeCode = "l"
+        #self.result   = int(self.result)
+
+######################################################################
+
+class ulongTestCase(SuperTensorTestCase):
+    def __init__(self, methodName="runTest"):
+        SuperTensorTestCase.__init__(self, methodName)
+        self.typeStr  = "ulong"
+        self.typeCode = "L"
+        #self.result   = int(self.result)
+
+######################################################################
+
+class longLongTestCase(SuperTensorTestCase):
+    def __init__(self, methodName="runTest"):
+        SuperTensorTestCase.__init__(self, methodName)
+        self.typeStr  = "longLong"
+        self.typeCode = "q"
+        #self.result   = int(self.result)
+
+######################################################################
+
+class ulongLongTestCase(SuperTensorTestCase):
+    def __init__(self, methodName="runTest"):
+        SuperTensorTestCase.__init__(self, methodName)
+        self.typeStr  = "ulongLong"
+        self.typeCode = "Q"
+        #self.result   = int(self.result)
+
+######################################################################
+
+class floatTestCase(SuperTensorTestCase):
+    def __init__(self, methodName="runTest"):
+        SuperTensorTestCase.__init__(self, methodName)
+        self.typeStr  = "float"
+        self.typeCode = "f"
+
+######################################################################
+
+class doubleTestCase(SuperTensorTestCase):
+    def __init__(self, methodName="runTest"):
+        SuperTensorTestCase.__init__(self, methodName)
+        self.typeStr  = "double"
+        self.typeCode = "d"
+
+######################################################################
+
+if __name__ == "__main__":
+
+    # Build the test suite
+    suite = unittest.TestSuite()
+    suite.addTest(unittest.makeSuite(    scharTestCase))
+    suite.addTest(unittest.makeSuite(    ucharTestCase))
+    suite.addTest(unittest.makeSuite(    shortTestCase))
+    suite.addTest(unittest.makeSuite(   ushortTestCase))
+    suite.addTest(unittest.makeSuite(      intTestCase))
+    suite.addTest(unittest.makeSuite(     uintTestCase))
+    suite.addTest(unittest.makeSuite(     longTestCase))
+    suite.addTest(unittest.makeSuite(    ulongTestCase))
+    suite.addTest(unittest.makeSuite( longLongTestCase))
+    suite.addTest(unittest.makeSuite(ulongLongTestCase))
+    suite.addTest(unittest.makeSuite(    floatTestCase))
+    suite.addTest(unittest.makeSuite(   doubleTestCase))
+
+    # Execute the test suite
+    print "Testing 4D Functions of Module SuperTensor"
+    print "NumPy version", np.__version__
+    print
+    result = unittest.TextTestRunner(verbosity=2).run(suite)
+    sys.exit(len(result.errors) + len(result.failures))