10
10
11
11
from numpy .random import randn , rand , randint
12
12
import numpy as np
13
- from numpy .testing import assert_array_equal , assert_allclose
13
+ from numpy .testing import assert_allclose
14
14
from numpy .testing .decorators import slow
15
15
16
16
import pandas as pd
@@ -220,7 +220,7 @@ def check_complex_cmp_op(self, lhs, cmp1, rhs, binop, cmp2):
220
220
expected = _eval_single_bin (
221
221
lhs_new , binop , rhs_new , self .engine )
222
222
result = pd .eval (ex , engine = self .engine , parser = self .parser )
223
- assert_array_equal (result , expected )
223
+ tm . assert_numpy_array_equivalent (result , expected )
224
224
225
225
def check_chained_cmp_op (self , lhs , cmp1 , mid , cmp2 , rhs ):
226
226
skip_these = _scalar_skip
@@ -240,7 +240,7 @@ def check_operands(left, right, cmp_op):
240
240
for ex in (ex1 , ex2 , ex3 ):
241
241
result = pd .eval (ex , engine = self .engine ,
242
242
parser = self .parser )
243
- assert_array_equal (result , expected )
243
+ tm . assert_numpy_array_equivalent (result , expected )
244
244
245
245
def check_simple_cmp_op (self , lhs , cmp1 , rhs ):
246
246
ex = 'lhs {0} rhs' .format (cmp1 )
@@ -251,13 +251,13 @@ def check_simple_cmp_op(self, lhs, cmp1, rhs):
251
251
else :
252
252
expected = _eval_single_bin (lhs , cmp1 , rhs , self .engine )
253
253
result = pd .eval (ex , engine = self .engine , parser = self .parser )
254
- assert_array_equal (result , expected )
254
+ tm . assert_numpy_array_equivalent (result , expected )
255
255
256
256
def check_binary_arith_op (self , lhs , arith1 , rhs ):
257
257
ex = 'lhs {0} rhs' .format (arith1 )
258
258
result = pd .eval (ex , engine = self .engine , parser = self .parser )
259
259
expected = _eval_single_bin (lhs , arith1 , rhs , self .engine )
260
- assert_array_equal (result , expected )
260
+ tm . assert_numpy_array_equivalent (result , expected )
261
261
ex = 'lhs {0} rhs {0} rhs' .format (arith1 )
262
262
result = pd .eval (ex , engine = self .engine , parser = self .parser )
263
263
nlhs = _eval_single_bin (lhs , arith1 , rhs ,
@@ -273,7 +273,7 @@ def check_alignment(self, result, nlhs, ghs, op):
273
273
pass
274
274
else :
275
275
expected = self .ne .evaluate ('nlhs {0} ghs' .format (op ))
276
- assert_array_equal (result , expected )
276
+ tm . assert_numpy_array_equivalent (result , expected )
277
277
278
278
# modulus, pow, and floor division require special casing
279
279
@@ -291,7 +291,7 @@ def check_floor_division(self, lhs, arith1, rhs):
291
291
if self .engine == 'python' :
292
292
res = pd .eval (ex , engine = self .engine , parser = self .parser )
293
293
expected = lhs // rhs
294
- assert_array_equal (res , expected )
294
+ tm . assert_numpy_array_equivalent (res , expected )
295
295
else :
296
296
self .assertRaises (TypeError , pd .eval , ex , local_dict = {'lhs' : lhs ,
297
297
'rhs' : rhs },
@@ -325,7 +325,7 @@ def check_pow(self, lhs, arith1, rhs):
325
325
326
326
if (np .isscalar (lhs ) and np .isscalar (rhs ) and
327
327
_is_py3_complex_incompat (result , expected )):
328
- self .assertRaises (AssertionError , assert_array_equal , result ,
328
+ self .assertRaises (AssertionError , tm . assert_numpy_array_equivalent , result ,
329
329
expected )
330
330
else :
331
331
assert_allclose (result , expected )
@@ -345,11 +345,11 @@ def check_single_invert_op(self, lhs, cmp1, rhs):
345
345
elb = np .array ([bool (el )])
346
346
expected = ~ elb
347
347
result = pd .eval ('~elb' , engine = self .engine , parser = self .parser )
348
- assert_array_equal (expected , result )
348
+ tm . assert_numpy_array_equivalent (expected , result )
349
349
350
350
for engine in self .current_engines :
351
351
tm .skip_if_no_ne (engine )
352
- assert_array_equal (result , pd .eval ('~elb' , engine = engine ,
352
+ tm . assert_numpy_array_equivalent (result , pd .eval ('~elb' , engine = engine ,
353
353
parser = self .parser ))
354
354
355
355
def check_compound_invert_op (self , lhs , cmp1 , rhs ):
@@ -370,13 +370,13 @@ def check_compound_invert_op(self, lhs, cmp1, rhs):
370
370
else :
371
371
expected = ~ expected
372
372
result = pd .eval (ex , engine = self .engine , parser = self .parser )
373
- assert_array_equal (expected , result )
373
+ tm . assert_numpy_array_equivalent (expected , result )
374
374
375
375
# make sure the other engines work the same as this one
376
376
for engine in self .current_engines :
377
377
tm .skip_if_no_ne (engine )
378
378
ev = pd .eval (ex , engine = self .engine , parser = self .parser )
379
- assert_array_equal (ev , result )
379
+ tm . assert_numpy_array_equivalent (ev , result )
380
380
381
381
def ex (self , op , var_name = 'lhs' ):
382
382
return '{0}{1}' .format (op , var_name )
@@ -620,6 +620,38 @@ def test_disallow_scalar_bool_ops(self):
620
620
with tm .assertRaises (NotImplementedError ):
621
621
pd .eval (ex , engine = self .engine , parser = self .parser )
622
622
623
+ def test_identical (self ):
624
+ # GH 10546
625
+ x = 1
626
+ result = pd .eval ('x' , engine = self .engine , parser = self .parser )
627
+ self .assertEqual (result , 1 )
628
+ self .assertTrue (np .isscalar (result ))
629
+
630
+ x = 1.5
631
+ result = pd .eval ('x' , engine = self .engine , parser = self .parser )
632
+ self .assertEqual (result , 1.5 )
633
+ self .assertTrue (np .isscalar (result ))
634
+
635
+ x = False
636
+ result = pd .eval ('x' , engine = self .engine , parser = self .parser )
637
+ self .assertEqual (result , False )
638
+ self .assertTrue (np .isscalar (result ))
639
+
640
+ x = np .array ([1 ])
641
+ result = pd .eval ('x' , engine = self .engine , parser = self .parser )
642
+ tm .assert_numpy_array_equivalent (result , np .array ([1 ]))
643
+ self .assertEqual (result .shape , (1 , ))
644
+
645
+ x = np .array ([1.5 ])
646
+ result = pd .eval ('x' , engine = self .engine , parser = self .parser )
647
+ tm .assert_numpy_array_equivalent (result , np .array ([1.5 ]))
648
+ self .assertEqual (result .shape , (1 , ))
649
+
650
+ x = np .array ([False ])
651
+ result = pd .eval ('x' , engine = self .engine , parser = self .parser )
652
+ tm .assert_numpy_array_equivalent (result , np .array ([False ]))
653
+ self .assertEqual (result .shape , (1 , ))
654
+
623
655
624
656
class TestEvalNumexprPython (TestEvalNumexprPandas ):
625
657
@@ -675,7 +707,7 @@ def check_alignment(self, result, nlhs, ghs, op):
675
707
pass
676
708
else :
677
709
expected = eval ('nlhs {0} ghs' .format (op ))
678
- assert_array_equal (result , expected )
710
+ tm . assert_numpy_array_equivalent (result , expected )
679
711
680
712
681
713
class TestEvalPythonPandas (TestEvalPythonPython ):
@@ -1086,10 +1118,10 @@ def test_truediv(self):
1086
1118
1087
1119
if PY3 :
1088
1120
res = self .eval (ex , truediv = False )
1089
- assert_array_equal (res , np .array ([1.0 ]))
1121
+ tm . assert_numpy_array_equivalent (res , np .array ([1.0 ]))
1090
1122
1091
1123
res = self .eval (ex , truediv = True )
1092
- assert_array_equal (res , np .array ([1.0 ]))
1124
+ tm . assert_numpy_array_equivalent (res , np .array ([1.0 ]))
1093
1125
1094
1126
res = self .eval ('1 / 2' , truediv = True )
1095
1127
expec = 0.5
@@ -1108,10 +1140,10 @@ def test_truediv(self):
1108
1140
self .assertEqual (res , expec )
1109
1141
else :
1110
1142
res = self .eval (ex , truediv = False )
1111
- assert_array_equal (res , np .array ([1 ]))
1143
+ tm . assert_numpy_array_equivalent (res , np .array ([1 ]))
1112
1144
1113
1145
res = self .eval (ex , truediv = True )
1114
- assert_array_equal (res , np .array ([1.0 ]))
1146
+ tm . assert_numpy_array_equivalent (res , np .array ([1.0 ]))
1115
1147
1116
1148
res = self .eval ('1 / 2' , truediv = True )
1117
1149
expec = 0.5
@@ -1414,8 +1446,8 @@ class TestScope(object):
1414
1446
1415
1447
def check_global_scope (self , e , engine , parser ):
1416
1448
tm .skip_if_no_ne (engine )
1417
- assert_array_equal (_var_s * 2 , pd .eval (e , engine = engine ,
1418
- parser = parser ))
1449
+ tm . assert_numpy_array_equivalent (_var_s * 2 , pd .eval (e , engine = engine ,
1450
+ parser = parser ))
1419
1451
1420
1452
def test_global_scope (self ):
1421
1453
e = '_var_s * 2'
0 commit comments