update some tests (for ctest)

hysop/operator/tests/test_spectral_curl.py

-import random, primefac
+import random
+import primefac
 from hysop.deps import it, sm, random
 from hysop.constants import HYSOP_REAL, BoxBoundaryCondition
 from hysop.defaults import VelocityField, VorticityField
@@ -11,18 +12,19 @@ from hysop.tools.io_utils import IO
 from hysop.tools.numpywrappers import npw
 from hysop.tools.sympy_utils import truncate_expr, round_expr
 from hysop.tools.spectral_utils import make_multivariate_trigonometric_polynomial, \
-                                       make_multivariate_polynomial
+    make_multivariate_polynomial
 from hysop.operator.curl import SpectralCurl, Implementation
 from hysop.defaults import VorticityField, VelocityField
 
 from hysop import Field, Box
 
+
 class TestSpectralCurl(object):
 
     @classmethod
     def setup_class(cls,
-            enable_extra_tests=__ENABLE_LONG_TESTS__,
-            enable_debug_mode=False):
+                    enable_extra_tests=__ENABLE_LONG_TESTS__,
+                    enable_debug_mode=False):
 
         IO.set_default_path('/tmp/hysop_tests/test_spectral_curl')
 
@@ -30,53 +32,52 @@ class TestSpectralCurl(object):
         cls.size_max = 16
 
         cls.enable_extra_tests = enable_extra_tests
-        cls.enable_debug_mode  = enable_debug_mode
-        
+        cls.enable_debug_mode = enable_debug_mode
+
         from hysop.tools.sympy_utils import enable_pretty_printing
         enable_pretty_printing()
-    
+
     @classmethod
     def teardown_class(cls):
         pass
 
-
     @classmethod
-    def build_analytic_solutions(cls, polynomial, 
-                                      dim, nb_components,
-                                      lboundaries, rboundaries,
-                                      origin, end):
-        from hysop.symbolic.base  import TensorBase
+    def build_analytic_solutions(cls, polynomial,
+                                 dim, nb_components,
+                                 lboundaries, rboundaries,
+                                 origin, end):
+        from hysop.symbolic.base import TensorBase
         from hysop.symbolic.frame import SymbolicFrame
         from hysop.symbolic.field import laplacian, curl
 
-        assert len(lboundaries)==nb_components
-        assert len(rboundaries)==nb_components
-        
-        frame  = SymbolicFrame(dim=dim)
+        assert len(lboundaries) == nb_components
+        assert len(rboundaries) == nb_components
+
+        frame = SymbolicFrame(dim=dim)
         coords = frame.coords
-                
+
         def gen_Fin():
             Fins = ()
             for i in xrange(nb_components):
                 if polynomial:
                     fin, y = make_multivariate_polynomial(origin, end,
-                                                        lboundaries[i], rboundaries[i], 
-                                                        10, 4)
+                                                          lboundaries[i], rboundaries[i],
+                                                          10, 4)
                 else:
                     fin, y = make_multivariate_trigonometric_polynomial(origin, end,
-                            lboundaries[i], rboundaries[i], 2)
-                fin = fin.xreplace({yi: xi for (yi,xi) in zip(y, coords)})
+                                                                        lboundaries[i], rboundaries[i], 2)
+                fin = fin.xreplace({yi: xi for (yi, xi) in zip(y, coords)})
                 Fins += (fin,)
             return npw.asarray(Fins).view(TensorBase)
-        
-        Fins  = gen_Fin()
+
+        Fins = gen_Fin()
         Fouts = npw.atleast_1d(curl(Fins, frame))
 
-        fFins  = tuple(sm.lambdify(coords, Fin) for Fin in Fins)
+        fFins = tuple(sm.lambdify(coords, Fin) for Fin in Fins)
         fFouts = tuple(sm.lambdify(coords, Fout) for Fout in Fouts)
 
-        analytic_expressions = {'Fin':Fins,  'Fout':Fouts}
-        analytic_functions   = {'Fin':fFins, 'Fout':fFouts}
+        analytic_expressions = {'Fin': Fins,  'Fout': Fouts}
+        analytic_functions = {'Fin': fFins, 'Fout': fFouts}
         return (analytic_expressions, analytic_functions)
 
     @staticmethod
@@ -93,20 +94,20 @@ class TestSpectralCurl(object):
         data[...] = npw.asarray(fn(*coords)).astype(dtype)
 
     def _test(self, dim, dtype, nb_components, max_runs=5,
-            polynomial=False, size_min=None, size_max=None):
+              polynomial=False, size_min=None, size_max=None):
         enable_extra_tests = self.enable_extra_tests
 
         size_min = first_not_None(size_min, self.size_min)
         size_max = first_not_None(size_max, self.size_max)
 
-        valid_factors = {2,3,5,7,11,13}
+        valid_factors = {2, 3, 5, 7, 11, 13}
         factors = {1}
         while (factors-valid_factors):
             factors.clear()
             shape = tuple(npw.random.randint(low=size_min, high=size_max+1, size=dim).tolist())
             for Si in shape:
-                factors.update( set(primefac.primefac(int(Si))) )
-        
+                factors.update(set(primefac.primefac(int(Si))))
+
         domain_boundaries = list(domain_boundary_iterator(dim=dim))
         periodic = domain_boundaries[0]
         domain_boundaries = domain_boundaries[1:]
@@ -114,51 +115,53 @@ class TestSpectralCurl(object):
         domain_boundaries.insert(0, periodic)
 
         for i, (lboundaries, rboundaries) in enumerate(domain_boundaries, 1):
-            
+
             domain = Box(origin=(npw.random.rand(dim)-0.5),
                          length=(0.5+npw.random.rand(dim)*2*npw.pi),
-                            lboundaries=lboundaries,
-                            rboundaries=rboundaries)
-            
-            if (dim==nb_components):
-                Fin  = VelocityField(name='Fin', domain=domain)
+                         lboundaries=lboundaries,
+                         rboundaries=rboundaries)
+
+            if (dim == nb_components):
+                Fin = VelocityField(name='Fin', domain=domain)
                 Fout = VorticityField(name='Fout', velocity=Fin)
             else:
-                Fin  = Field(name='Fin', domain=domain, dtype=dtype, nb_components=nb_components)
+                Fin = Field(name='Fin', domain=domain, dtype=dtype, nb_components=nb_components)
                 Fout = Fin.curl(name='Fout')
 
-            self._test_one(shape=shape, dim=dim, dtype=dtype, 
-                    domain=domain, Fin=Fin, Fout=Fout, polynomial=polynomial)
-            if (max_runs is not None) and (i==max_runs):
+            self._test_one(shape=shape, dim=dim, dtype=dtype,
+                           domain=domain, Fin=Fin, Fout=Fout, polynomial=polynomial)
+            if (max_runs is not None) and (i == max_runs):
                 missing = ((4**(dim+1) - 1) / 3) - i
                 print
-                print '>> MAX RUNS ACHIEVED FOR {}D DOMAINS -- SKIPING {} OTHER BOUNDARY CONDITIONS <<'.format(dim, missing)
+                print '>> MAX RUNS ACHIEVED FOR {}D DOMAINS -- SKIPING {} OTHER BOUNDARY CONDITIONS <<'.format(
+                    dim, missing)
                 print
                 print
                 break
         else:
-            assert (i==(4**(dim+1)-1)/3), (i+1, (4**(dim+1)-1)/3)
+            assert (i == (4**(dim+1)-1)/3), (i+1, (4**(dim+1)-1)/3)
             print
             print '>> TESTED ALL {}D BOUNDARY CONDITIONS <<'.format(dim)
             print
             print
 
     def _test_one(self, shape, dim, dtype,
-            domain, Fout, Fin, polynomial):
-        
+                  domain, Fout, Fin, polynomial):
+
         (analytic_expressions, analytic_functions) = \
             self.build_analytic_solutions(
-                dim=dim, nb_components=Fin.nb_components, polynomial=polynomial, 
-                lboundaries=[fin.lboundaries[::-1] for fin in Fin.fields], # => boundaries in variable order x0,...,xn
+                dim=dim, nb_components=Fin.nb_components, polynomial=polynomial,
+                lboundaries=[fin.lboundaries[::-1]
+                             for fin in Fin.fields],  # => boundaries in variable order x0,...,xn
                 rboundaries=[fin.rboundaries[::-1] for fin in Fin.fields],
                 origin=domain.origin[::-1],
                 end=domain.end[::-1])
-        
+
         def format_expr(e):
             return truncate_expr(round_expr(e, 3), 80)
 
-        msg='\nTesting {}D Curl: dtype={} shape={} polynomial={}, bc=[{}]'.format(
-                dim, dtype.__name__, shape, polynomial, domain.format_boundaries())
+        msg = '\nTesting {}D Curl: dtype={} shape={} polynomial={}, bc=[{}]'.format(
+            dim, dtype.__name__, shape, polynomial, domain.format_boundaries())
         print msg
         print ' >Input analytic field is (truncated):'
         for (fin, fins) in zip(Fin.fields, analytic_expressions['Fin']):
@@ -169,55 +172,55 @@ class TestSpectralCurl(object):
         print ' >Testing all implementations:'
 
         implementations = SpectralCurl.implementations().keys()
-        variables = { Fout:shape, Fin:shape }
+        variables = {Fout: shape, Fin: shape}
 
         def iter_impl(impl):
             base_kwds = dict(Fin=Fin, Fout=Fout, variables=variables,
                              implementation=impl,
                              name='curl_{}'.format(str(impl).lower()))
             if impl is Implementation.PYTHON:
-                msg='   *Python FFTW: '
+                msg = '   *Python FFTW: '
                 print msg,
                 yield SpectralCurl(**base_kwds)
             elif impl is Implementation.OPENCL:
-                msg='   *OpenCl CLFFT: '
+                msg = '   *OpenCl CLFFT: '
                 print msg
                 for cl_env in iter_clenv():
-                    msg='     |platform {}, device {}'.format(cl_env.platform.name.strip(),
-                                                              cl_env.device.name.strip())
+                    msg = '     |platform {}, device {}'.format(cl_env.platform.name.strip(),
+                                                                cl_env.device.name.strip())
                     print msg,
                     yield SpectralCurl(cl_env=cl_env, **base_kwds)
             else:
-                msg='Unknown implementation to test {}.'.format(impl)
+                msg = 'Unknown implementation to test {}.'.format(impl)
                 raise NotImplementedError(msg)
 
         # Compare to analytic solution
         Fout_ref = None
         Fin_ref = None
         for impl in implementations:
-            for (i,op) in enumerate(iter_impl(impl)):
+            for (i, op) in enumerate(iter_impl(impl)):
                 from hysop.tools.debug_dumper import DebugDumper
-                name='{}_{}'.format(impl, i)
+                name = '{}_{}'.format(impl, i)
 
                 op = op.build()
-                
+
                 dFin = op.get_input_discrete_field(Fin).as_contiguous_dfield()
                 dFout = op.get_output_discrete_field(Fout).as_contiguous_dfield()
-                
+
                 dFin.initialize(self.__analytic_init, dtype=dtype,
-                                    fns=analytic_functions['Fin'])
+                                fns=analytic_functions['Fin'])
 
                 if (Fout_ref is None):
                     dFout.initialize(self.__analytic_init, dtype=dtype,
-                                    fns=analytic_functions['Fout'])
-                    Fin_ref = tuple( data.get().handle.copy() for data in dFin.data )
-                    Fout_ref = tuple( data.get().handle.copy() for data in dFout.data )
+                                     fns=analytic_functions['Fout'])
+                    Fin_ref = tuple(data.get().handle.copy() for data in dFin.data)
+                    Fout_ref = tuple(data.get().handle.copy() for data in dFout.data)
                 dFout.initialize(self.__random_init, dtype=dtype)
 
                 op.apply(simulation=None)
 
-                Wout = tuple( data.get().handle.copy() for data in dFin.data )
-                Uout = tuple( data.get().handle.copy() for data in dFout.data )
+                Wout = tuple(data.get().handle.copy() for data in dFin.data)
+                Uout = tuple(data.get().handle.copy() for data in dFout.data)
                 self._check_output(impl, op, Fin_ref, Fout_ref, Wout, Uout)
                 print
 
@@ -229,9 +232,9 @@ class TestSpectralCurl(object):
         check_instance(Uout, tuple, values=npw.ndarray, size=len(Fout_ref))
 
         msg0 = 'Reference field {} is not finite.'
-        for (fields, name) in zip((Fin_ref, Fout_ref),('Fin_ref', 'Fout_ref')):
-            for (i,field) in enumerate(fields):
-                iname = '{}{}'.format(name,i)
+        for (fields, name) in zip((Fin_ref, Fout_ref), ('Fin_ref', 'Fout_ref')):
+            for (i, field) in enumerate(fields):
+                iname = '{}{}'.format(name, i)
                 mask = npw.isfinite(field)
                 if not mask.all():
                     print
@@ -243,8 +246,8 @@ class TestSpectralCurl(object):
                     raise ValueError(msg)
 
         for (out_buffers, ref_buffers, name) in zip((Wout, Uout), (Fin_ref, Fout_ref), ('Fin', 'Fout')):
-            for i, (fout,fref) in enumerate(zip(out_buffers, ref_buffers)):
-                iname = '{}{}'.format(name,i)
+            for i, (fout, fref) in enumerate(zip(out_buffers, ref_buffers)):
+                iname = '{}{}'.format(name, i)
                 assert fout.dtype == fref.dtype, iname
                 assert fout.shape == fref.shape, iname
                 assert not npw.any(npw.isnan(fref))
@@ -257,7 +260,7 @@ class TestSpectralCurl(object):
                 elif has_inf:
                     deps = 'inf'
                 else:
-                    eps  = npw.finfo(fout.dtype).eps
+                    eps = npw.finfo(fout.dtype).eps
                     dist = npw.abs(fout-fref)
                     dinf = npw.max(dist)
                     try:
@@ -277,26 +280,26 @@ class TestSpectralCurl(object):
                 print
                 if cls.enable_debug_mode:
                     print 'REFERENCE INPUTS:'
-                    for (i,w) in enumerate(Fin_ref):
+                    for (i, w) in enumerate(Fin_ref):
                         print 'Fin{}'.format(i)
                         print w
                         print
                     if (name == 'Fout'):
                         print 'REFERENCE OUTPUT:'
-                        for (i,u) in enumerate(Fout_ref):
+                        for (i, u) in enumerate(Fout_ref):
                             print 'Fout{}'.format(i)
                             print u
                             print
                         print
                         print 'OPERATOR {} OUTPUT:'.format(op.name.upper())
                         print
-                        for (i,u) in enumerate(Uout):
+                        for (i, u) in enumerate(Uout):
                             print 'Fout{}'.format(i)
                             print u
                             print
                     else:
                         print 'MODIFIED INPUTS:'
-                        for (i,w) in enumerate(Wout):
+                        for (i, w) in enumerate(Wout):
                             print 'Fin{}'.format(i)
                             print w
                             print
@@ -306,34 +309,44 @@ class TestSpectralCurl(object):
                 msg = msg.format(name, i, impl)
                 raise RuntimeError(msg)
 
-
     def test_2d_float32__1(self, **kwds):
-        self._test(dim=2, dtype=npw.float32, nb_components=1, **kwds)
+        if HYSOP_REAL == npw.float32:
+            self._test(dim=2, dtype=npw.float32, nb_components=1, **kwds)
+
     def test_2d_float32__2(self, **kwds):
-        self._test(dim=2, dtype=npw.float32, nb_components=2, **kwds)
+        if HYSOP_REAL == npw.float32:
+            self._test(dim=2, dtype=npw.float32, nb_components=2, **kwds)
+
     def test_3d_float32(self, **kwds):
-        self._test(dim=3, dtype=npw.float32, nb_components=3, **kwds)
-    
+        if HYSOP_REAL == npw.float32:
+            self._test(dim=3, dtype=npw.float32, nb_components=3, **kwds)
+
     def test_2d_float64__1(self, **kwds):
-        self._test(dim=2, dtype=npw.float64, nb_components=1, **kwds)
+        if HYSOP_REAL == npw.float64:
+            self._test(dim=2, dtype=npw.float64, nb_components=1, **kwds)
+
     def test_2d_float64__2(self, **kwds):
-        self._test(dim=2, dtype=npw.float64, nb_components=2, **kwds)
+        if HYSOP_REAL == npw.float64:
+            self._test(dim=2, dtype=npw.float64, nb_components=2, **kwds)
+
     def test_3d_float64(self, **kwds):
-        self._test(dim=3, dtype=npw.float64, nb_components=3, **kwds)
+        if HYSOP_REAL == npw.float64:
+            self._test(dim=3, dtype=npw.float64, nb_components=3, **kwds)
 
     def perform_tests(self):
         max_2d_runs = None if __ENABLE_LONG_TESTS__ else 2
         max_3d_runs = None if __ENABLE_LONG_TESTS__ else 2
 
-        if __ENABLE_LONG_TESTS__ or (HYSOP_REAL==npw.float32):
+        if __ENABLE_LONG_TESTS__ or (HYSOP_REAL == npw.float32):
             self.test_2d_float32__1(max_runs=max_2d_runs)
             self.test_2d_float32__2(max_runs=max_2d_runs)
             self.test_3d_float32(max_runs=max_3d_runs)
-        if __ENABLE_LONG_TESTS__ or (HYSOP_REAL==npw.float64):
+        if __ENABLE_LONG_TESTS__ or (HYSOP_REAL == npw.float64):
             self.test_2d_float64__1(max_runs=max_2d_runs)
             self.test_2d_float64__2(max_runs=max_2d_runs)
             self.test_3d_float64(max_runs=max_3d_runs)
 
+
 if __name__ == '__main__':
     TestSpectralCurl.setup_class(enable_extra_tests=False,
                                  enable_debug_mode=False)

hysop/operator/tests/test_spectral_derivative.py

@@ -322,22 +322,28 @@ class TestSpectralDerivative(object):
                 raise RuntimeError(msg)
 
     def test_1d_trigonometric_float32(self, **kwds):
+        kwds.update({'max_derivative': 3})
         self._test(dim=1, dtype=npw.float32, polynomial=False, **kwds)
 
     def test_2d_trigonometric_float32(self, **kwds):
+        kwds.update({'max_derivative': 1, 'max_runs': None})
         self._test(dim=2, dtype=npw.float32, polynomial=False, **kwds)
 
     def test_3d_trigonometric_float32(self, **kwds):
+        kwds.update({'max_derivative': 1, 'max_runs': 5})
         if __ENABLE_LONG_TESTS__:
             self._test(dim=3, dtype=npw.float32, polynomial=False, **kwds)
 
     def test_1d_trigonometric_float64(self, **kwds):
+        kwds.update({'max_derivative': 3})
         self._test(dim=1, dtype=npw.float64, polynomial=False, **kwds)
 
     def test_2d_trigonometric_float64(self, **kwds):
+        kwds.update({'max_derivative': 1, 'max_runs': None})
         self._test(dim=2, dtype=npw.float64, polynomial=False, **kwds)
 
     def test_3d_trigonometric_float64(self, **kwds):
+        kwds.update({'max_derivative': 1, 'max_runs': 5})
         if __ENABLE_LONG_TESTS__:
             self._test(dim=3, dtype=npw.float64, polynomial=False, **kwds)
 
@@ -348,6 +354,7 @@ class TestSpectralDerivative(object):
         self._test(dim=2, dtype=npw.float32, polynomial=True, **kwds)
 
     def test_3d_polynomial_float32(self, **kwds):
+        kwds.update({'max_derivative': 1})
         if __ENABLE_LONG_TESTS__:
             self._test(dim=3, dtype=npw.float32, polynomial=True, **kwds)
 
@@ -355,6 +362,9 @@ class TestSpectralDerivative(object):
         self.test_1d_trigonometric_float32(max_derivative=3)
         self.test_2d_trigonometric_float32(max_derivative=1, max_runs=None)
         self.test_3d_trigonometric_float32(max_derivative=1, max_runs=5)
+        self.test_1d_trigonometric_float64(max_derivative=3)
+        self.test_2d_trigonometric_float64(max_derivative=1, max_runs=None)
+        self.test_3d_trigonometric_float64(max_derivative=1, max_runs=5)
 
         if __ENABLE_LONG_TESTS__:
             # self.test_1d_trigonometric_float64(max_derivative=3)