Exemple #1
0
        def testit():

            for f, f2 in [(self.frame, self.frame2),
                          (self.mixed, self.mixed2)]:

                for op, op_str in [('add', '+'), ('sub', '-'), ('mul', '*'),
                                   ('div', '/'), ('pow', '**')]:

                    op = getattr(operator, op, None)
                    if op is not None:
                        result = expr._can_use_numexpr(op, op_str, f, f,
                                                       'evaluate')
                        self.assert_(result == (not f._is_mixed_type))

                        result = expr.evaluate(op,
                                               op_str,
                                               f,
                                               f,
                                               use_numexpr=True)
                        expected = expr.evaluate(op,
                                                 op_str,
                                                 f,
                                                 f,
                                                 use_numexpr=False)
                        assert_array_equal(result, expected.values)

                        result = expr._can_use_numexpr(op, op_str, f2, f2,
                                                       'evaluate')
                        self.assert_(result == False)
Exemple #2
0
        def testit():
            for f, f2 in [(self.frame, self.frame2),
                          (self.mixed, self.mixed2)]:

                f11 = f
                f12 = f + 1

                f21 = f2
                f22 = f2 + 1

                for op, op_str in [('gt', '>'), ('lt', '<'), ('ge', '>='),
                                   ('le', '<='), ('eq', '=='), ('ne', '!=')]:

                    op = getattr(operator, op)

                    result = expr._can_use_numexpr(op, op_str, f11, f12,
                                                   'evaluate')
                    self.assert_(result == (not f11._is_mixed_type))

                    result = expr.evaluate(op,
                                           op_str,
                                           f11,
                                           f12,
                                           use_numexpr=True)
                    expected = expr.evaluate(op,
                                             op_str,
                                             f11,
                                             f12,
                                             use_numexpr=False)
                    assert_array_equal(result, expected.values)

                    result = expr._can_use_numexpr(op, op_str, f21, f22,
                                                   'evaluate')
                    self.assert_(result == False)
Exemple #3
0
        def testit():

            for f, f2 in [(self.frame, self.frame2), (self.mixed, self.mixed2)]:

                for op, op_str in [("add", "+"), ("sub", "-"), ("mul", "*"), ("div", "/"), ("pow", "**")]:

                    op = getattr(operator, op)
                    result = expr._can_use_numexpr(op, op_str, f, f, "evaluate")
                    self.assert_(result == (not f._is_mixed_type))

                    result = expr.evaluate(op, op_str, f, f, use_numexpr=True)
                    expected = expr.evaluate(op, op_str, f, f, use_numexpr=False)
                    assert_array_equal(result, expected.values)

                    result = expr._can_use_numexpr(op, op_str, f2, f2, "evaluate")
                    self.assert_(result == False)
Exemple #4
0
        def testit():

            for f, f2 in [ (self.frame, self.frame2), (self.mixed, self.mixed2) ]:

                for op, op_str in [('add','+'),('sub','-'),('mul','*'),('div','/'),('pow','**')]:

                    op = getattr(operator,op)
                    result   = expr._can_use_numexpr(op, op_str, f, f)
                    self.assert_(result == (not f._is_mixed_type))

                    result   = expr.evaluate(op, op_str, f, f, use_numexpr=True)
                    expected = expr.evaluate(op, op_str, f, f, use_numexpr=False)
                    assert_array_equal(result,expected.values)
                
                    result   = expr._can_use_numexpr(op, op_str, f2, f2)
                    self.assert_(result == False)
Exemple #5
0
    def test_invalid(self):

        # no op
        result = expr._can_use_numexpr(operator.add, None, self.frame, self.frame, "evaluate")
        self.assert_(result == False)

        # mixed
        result = expr._can_use_numexpr(operator.add, "+", self.mixed, self.frame, "evaluate")
        self.assert_(result == False)

        # min elements
        result = expr._can_use_numexpr(operator.add, "+", self.frame2, self.frame2, "evaluate")
        self.assert_(result == False)

        # ok, we only check on first part of expression
        result = expr._can_use_numexpr(operator.add, "+", self.frame, self.frame2, "evaluate")
        self.assert_(result == True)
Exemple #6
0
    def test_invalid(self):

        # no op
        result   = expr._can_use_numexpr(operator.add, None, self.frame, self.frame, 'evaluate')
        self.assertTrue(result == False)

        # mixed
        result   = expr._can_use_numexpr(operator.add, '+', self.mixed, self.frame, 'evaluate')
        self.assertTrue(result == False)

        # min elements
        result   = expr._can_use_numexpr(operator.add, '+', self.frame2, self.frame2, 'evaluate')
        self.assertTrue(result == False)

        # ok, we only check on first part of expression
        result   = expr._can_use_numexpr(operator.add, '+', self.frame, self.frame2, 'evaluate')
        self.assertTrue(result == True)
Exemple #7
0
        def testit():
            for f, f2 in [(self.frame, self.frame2), (self.mixed, self.mixed2)]:

                f11 = f
                f12 = f + 1

                f21 = f2
                f22 = f2 + 1

                for op, op_str in [("gt", ">"), ("lt", "<"), ("ge", ">="), ("le", "<="), ("eq", "=="), ("ne", "!=")]:

                    op = getattr(operator, op)

                    result = expr._can_use_numexpr(op, op_str, f11, f12, "evaluate")
                    self.assert_(result == (not f11._is_mixed_type))

                    result = expr.evaluate(op, op_str, f11, f12, use_numexpr=True)
                    expected = expr.evaluate(op, op_str, f11, f12, use_numexpr=False)
                    assert_array_equal(result, expected.values)

                    result = expr._can_use_numexpr(op, op_str, f21, f22, "evaluate")
                    self.assert_(result == False)
Exemple #8
0
        def testit():
            for f, f2 in [ (self.frame, self.frame2), (self.mixed, self.mixed2) ]:

                f11 = f
                f12 = f + 1
            
                f21 = f2
                f22 = f2 + 1

                for op, op_str in [('gt','>'),('lt','<'),('ge','>='),('le','<='),('eq','=='),('ne','!=')]:

                    op = getattr(operator,op)

                    result   = expr._can_use_numexpr(op, op_str, f11, f12, 'evaluate')
                    self.assert_(result == (not f11._is_mixed_type))

                    result   = expr.evaluate(op, op_str, f11, f12, use_numexpr=True)
                    expected = expr.evaluate(op, op_str, f11, f12, use_numexpr=False)
                    assert_array_equal(result,expected.values)
                    
                    result   = expr._can_use_numexpr(op, op_str, f21, f22, 'evaluate')
                    self.assert_(result == False)