Class test_evaluate

numexpr3/tests/test_numexpr.py:306–361

        self.ssize = ssize

class test_evaluate(unittest.TestCase):

    def setUp(self, N_threads=1, ssize=SMALL_SIZE):
        logger.info( "**Run evaluate() tests with {} thread(s) over {} element arrays**".format(N_threads, ssize) )
        ne3.set_nthreads(N_threads)
        self.ssize = ssize

    def test_eval_versus_run(self):
        logger.info( 'Compare evaluate and .run' )
        a = np.arange(100.0).reshape(10, 10)[::2]
        b = np.arange(10.0)
        expr = ne3.NumExpr('2*a+3*b')
        npt.assert_array_almost_equal(expr(a=a, b=b), expr.run(a=a, b=b))

    def test_prealloc(self):
        logger.info( 'Test pre-allocated output evaluate' )
        a = np.array([1., 2., 3.])
        b = np.array([4., 5., 6.])
        c = np.array([7., 8., 9.])
        y = 2*a + 3*b*c
        x = np.empty_like(y)
        ne3.evaluate('x=2*a + 3*b*c')
        npt.assert_array_equal(x, y)

    def test_magic(self):
        logger.info( 'Test magic output evaluate' )
        a = np.array([1., 2., 3.])
        b = np.array([4., 5., 6.])
        c = np.array([7., 8., 9.])
        y = 2*a + 3*b*c
        ne3.evaluate('x_magic=2*a + 3*b*c')
        # For some reason, only in unittest, does y_magic not appear in the 
        # scope unless explicitely looked for in locals. This works in normal
        # scripts however.
        npt.assert_array_equal( locals()['x_magic'], y)

    def test_copy(self):
        logger.info( 'Test copy evaluate with preallocated output' )
        x = np.arange(SMALL_SIZE)
        y = np.zeros_like(x)
        ne3.evaluate('y=x')
        npt.assert_array_equal(x, y)
        
    def test_copy_magic(self):
        logger.info( 'Test copy evaluate with magic output' )
        x = np.arange(self.ssize)
        ne3.evaluate('y_magic=x')
        npt.assert_array_equal(x, locals()['y_magic'] )

    def test_rational(self):
        logger.info( 'Test rational evaluation' )
        a = np.arange(1e5)
        b = np.arange(1e5) * 0.1
        x = (a + 2 * b) / (1 + a + 4 * b * b)
        ne3.evaluate('y=(a + 2*b) / (1 + a + 4*b*b)')
        npt.assert_array_almost_equal(x, locals()['y'] )
		
class test_reductions(unittest.TestCase):