zmc
2023-10-12 ed135d79df12a2466b52dae1a82326941211dcc9
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
U
O±dxÒã @sddlZddlZddlZddlZddlZddlmZddlZddl    m
m Z ddl mmZddlm
mZddlm
mZddlmZmZmZmZmZmZmZmZmZm Z m!Z!ddl"m#Z#ddl$m%Z%dd„ej
j&j' (¡DƒZ)dd„e)DƒZ*Gd    d
„d
ƒZ+Gd d „d ƒZ,d d„Z-Gdd„dƒZ.ej/ 0ddd„e1eƒDƒ¡dd„ƒZ2ej/ 0ddd„e1eƒDƒ¡e 3¡dd„ƒƒZ4ej/ 0dej5ej6g¡dd„ƒZ7ej/j8e dddd„ƒZ9ej/ 0dde:ej;dƒg¡d d!„ƒZ<ej/j8e!d"dej/ 0dde:ej;dƒg¡d#d$„ƒƒZ=d%d&„Z>ej/j8e ddej/ 0d'dej;d(e:dej;ƒg¡d)d*„ƒƒZ?ej/j8e!d"dej/ 0d+ej@jAej@jBejd,d-„d.d/ejd0d-„d1d/g¡d2d3„ƒƒZCd4d5„ZDej/ 0d6ejEd7¡d8d9„ƒZFej/ 0d6ejEd7¡ej/ 0d:d;d<g¡d=d>„ƒƒZGGd?d@„d@ƒZHdS)AéN)Úparam) Úassert_Ú assert_equalÚ assert_raisesÚassert_array_equalÚassert_almost_equalÚassert_array_almost_equalÚassert_no_warningsÚassert_allcloseÚ HAS_REFCOUNTÚsuppress_warningsÚIS_WASM)Úrequires_memory)ÚpicklecCsg|]}t|tjƒr|‘qS©)Ú
isinstanceÚnpÚufunc)Ú.0ÚobjrrúRd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\numpy/core/tests/test_ufunc.pyÚ
<listcomp>s ÿrcCsg|]}d|jkr|‘qS)zO->O)Útypes)rÚufrrrrs
c@s,eZdZdd„Zdd„Zdd„Zdd„Zd    S)
ÚTestUfuncKwargscCs¨tttjddddtttjddtdtttjdddgdtttjddddtttjddd    d
tttjddd    d tttjddd d tttjdddgddS)NééÚsafe)Zcastingx)Zdtypexé)Zextobjx)Zoutxúii->i)Zsigx)Z
signaturexF)ZsubokxT)Zwherex©rÚ    TypeErrorrÚaddÚint©ÚselfrrrÚtest_kwarg_exactsz TestUfuncKwargs.test_kwarg_exactcCstttjddddddS)Nrrr)ÚsigÚ    signature©rr!rr"r$rrrÚtest_sig_signature'sÿz"TestUfuncKwargs.test_sig_signaturecCs0tttjdddtdtttjdddtddS)Nrrr)r'Údtype)r(r+r r$rrrÚtest_sig_dtype+s ÿÿzTestUfuncKwargs.test_sig_dtypecCstttjdddgdddS)NrrrT)ZextobjÚparrotr)r$rrrÚtest_extobj_refcount1sz$TestUfuncKwargs.test_extobj_refcountN)Ú__name__Ú
__module__Ú __qualname__r&r*r,r.rrrrrs
rc    @s
eZdZdZejejfejejfejejfejejfejejfej    ej    fejejfej
ej
fgZ e j  de ¡ejddfdd„ƒZdd„Ze j  de ¡eddfd    d
„ƒZGd d „d ƒZd d„Zefdd„Zdd„Zefdd„Zefdd„Zdd„Ze j  de¡dd„ƒZdS)ÚTestUfuncGenericLoopsabTest generic loops.
 
    The loops to be tested are:
 
        PyUFunc_ff_f_As_dd_d
        PyUFunc_ff_f
        PyUFunc_dd_d
        PyUFunc_gg_g
        PyUFunc_FF_F_As_DD_D
        PyUFunc_DD_D
        PyUFunc_FF_F
        PyUFunc_GG_G
        PyUFunc_OO_O
        PyUFunc_OO_O_method
        PyUFunc_f_f_As_d_d
        PyUFunc_d_d
        PyUFunc_f_f
        PyUFunc_g_g
        PyUFunc_F_F_As_D_D
        PyUFunc_F_F
        PyUFunc_D_D
        PyUFunc_G_G
        PyUFunc_O_O
        PyUFunc_O_O_method
        PyUFunc_On_Om
 
    Where:
 
        f -- float
        d -- double
        g -- long double
        F -- complex float
        D -- complex double
        G -- complex long double
        O -- python object
 
    It is difficult to assure that each of these loops is entered from the
    Python level as the special cased loops are a moving target and the
    corresponding types are architecture dependent. We probably need to
    define C level testing ufuncs to get at them. For the time being, I've
    just looked at the signatures registered in the build directory to find
    relevant functions.
 
    zinput_dtype,output_dtyperrcCs@tjd||ƒ|d}||ƒddd…}t||ƒt|j|ƒdS©Né
©r+r©rÚfullr
rr+©r%Z input_dtypeZ output_dtypeÚfÚxÚyÚxsZysrrrÚtest_unary_PyUFuncis
z(TestUfuncGenericLoops.test_unary_PyUFunccCs||S©Nr)r:r;rrrÚf2pszTestUfuncGenericLoops.f2cCsBtjd||ƒ|d}|||ƒddd…}t||ƒt|j|ƒdSr3r6r8rrrÚtest_binary_PyUFuncss
z)TestUfuncGenericLoops.test_binary_PyUFuncc@seZdZdd„Zdd„ZdS)zTestUfuncGenericLoops.foocCs
t d¡S©Nr©rÚbool_r$rrrÚ    conjugate|sz#TestUfuncGenericLoops.foo.conjugatecCs
t d¡SrArB©r%rrrrÚ logical_xorsz%TestUfuncGenericLoops.foo.logical_xorN)r/r0r1rDrFrrrrÚfoo{srGcCs*tjdtd}tt t |¡dk¡ƒdS)Nr4r5r)rÚonesÚobjectrÚallÚabs©r%r:rrrÚtest_unary_PyUFunc_O_O‚sz,TestUfuncGenericLoops.test_unary_PyUFunc_O_OcCs.tjd|ƒtd}tt t |¡dk¡ƒdS)Nr4r5T)rr7rIrrJrD©r%rGr:rrrÚ$test_unary_PyUFunc_O_O_method_simple†sz:TestUfuncGenericLoops.test_unary_PyUFunc_O_O_method_simplecCs,tjdtd}tt t ||¡dk¡ƒdSr3)rrHrIrrJr"rLrrrÚtest_binary_PyUFunc_OO_OŠsz.TestUfuncGenericLoops.test_binary_PyUFunc_OO_OcCs,tjd|ƒtd}tt t ||¡¡ƒdS)Nr4r5©rr7rIrrJrFrNrrrÚtest_binary_PyUFunc_OO_O_methodŽsz5TestUfuncGenericLoops.test_binary_PyUFunc_OO_O_methodcCs,tjd|ƒtd}tt t ||¡¡ƒdS)N)r4rér5rQrNrrrÚ test_binary_PyUFunc_On_Om_method’sz6TestUfuncGenericLoops.test_binary_PyUFunc_On_Om_methodcCs^tjddgdd}t|dtƒs$t‚t |¡}|jt d¡ksBt‚t|tjddgddƒdS)Nyð?@y@ÀÚOr5ryð?Ày@@)rÚarrayrÚcomplexÚAssertionErrorrDr+r©r%ÚarrÚresrrrÚtest_python_complex_conjugate–s
 
z3TestUfuncGenericLoops.test_python_complex_conjugaterc sÌt tjd¡‰G‡fdd„dtjƒ}tjˆtjd}tj|ˆƒdd}tjddnz ||ƒ}WnBtk
r¤}z$tt|ƒƒ||ƒW5QRXW5d}~XYnX||ƒ}t|     d¡|ƒW5QRXdS)    z9Compare the result of the object loop with non-object oneécseZdZ‡‡fdd„Z‡ZS)zITestUfuncGenericLoops.test_unary_PyUFunc_O_O_method_full.<locals>.MyFloatcs6ztƒ ˆ¡WStk
r0‡‡fdd„YSXdS)NcsttjjˆƒˆƒSr>)ÚgetattrrÚcoreÚumathr)ÚattrÚvalrrÚ<lambda>¨ózgTestUfuncGenericLoops.test_unary_PyUFunc_O_O_method_full.<locals>.MyFloat.__getattr__.<locals>.<lambda>)ÚsuperÚ __getattr__ÚAttributeError)r%ra)Ú    __class__rb)rarrf¤szUTestUfuncGenericLoops.test_unary_PyUFunc_O_O_method_full.<locals>.MyFloat.__getattr__)r/r0r1rfÚ __classcell__r©rb)rhrÚMyFloat£srkr5rUÚraise©rJN)
rÚfloat64ÚpirVÚerrstateÚ    ExceptionrÚtyperÚastype)r%rrkZnum_arrZobj_arrZres_numÚexcZres_objrrjrÚ"test_unary_PyUFunc_O_O_method_fullžs $z8TestUfuncGenericLoops.test_unary_PyUFunc_O_O_method_fullN)r/r0r1Ú__doc__rÚsingleÚdoubleZcsingleZcdoubleÚ
longdoubleÚ clongdoubleZ    np_dtypesÚpytestÚmarkÚ parametrizeÚexpr=r?r@rGrMrOrPrRrTr\ÚUNARY_OBJECT_UFUNCSrurrrrr26s0-
 
 
 
 
 
 
 
ü      r2cCsdSr>rrrrrÚ_pickleable_module_global¹sr€c @sòeZdZdd„Zdd„Zdd„Zdd„Zd    d
„Zd Zd Z    d d„Z
dd„Z dd„Z dd„Z dd„Zdd„Zdd„Zdd„Zdd„Zdd „Zd!d"„Zd#d$„Zd%d&„Zd'd(„Zd)d*„Zd+d,„Zd-d.„Zd/d0„Zd1d2„Zej d3d4d5„d6d5„g¡d7d8„ƒZ ej d3e!d9d5„d:d;e!d<d5„d=d;g¡d>d8„ƒZ ej d?d@dAdBg¡dCdD„ƒZ"dEdF„Z#dGdH„Z$dIdJ„Z%dKdL„Z&ej dMe'j(e'j)g¡dNdO„ƒZ*dPdQ„Z+dRdS„Z,ejj-e.dTdUdVdW„ƒZ/dXdY„Z0dZd[„Z1d\d]„Z2d^d_„Z3d`da„Z4dbdc„Z5ejjdddegd ge' 6df¡fdgd ge' 6dg¡fe' 7dh¡e' 6di¡fgdjdkdlgdmdndo„ƒZ8dpdq„Z9drds„Z:dtdu„Z;dvdw„Z<dxdy„Z=dzd{„Z>d|d}„Z?d~d„Z@d€d„ZAd‚dƒ„ZBd„d…„ZCd†d‡„ZDdˆd‰„ZEdŠd‹„ZFdŒd„ZGdŽd„ZHdd‘„ZId’d“„ZJd”d•„ZKd–d—„ZLd˜d™„ZMdšd›„ZNdœd„ZOdždŸ„ZPd d¡„ZQd¢d£„ZRd¤d¥„ZSd¦d§„ZTd¨d©„ZUdªd«„ZVd¬d­„ZWd®d¯„ZXeYd°ƒd±d²„ƒZZd³d´„Z[dµd¶„Z\d·d¸„Z]d¹dº„Z^d»d¼„Z_d½d¾„Z`ej d¿dÀ¡ej dÁe' adÂdÃdÃg¡e' adÃgdÂgdÃgg¡e' adÃdÂdÂgdÂdÃdÂgdÂdÃdÃgg¡f¡dÄdńƒƒZbej dÆdÇe' adÃdÂdÃg¡fdgdÃdÃdÂgfdÈf¡ej dÉe'jc dÊf¡dËd̄ƒƒZddÍd΄ZedÏdЄZfdÑd҄ZgdÓdԄZhdÕdքZid×d؄ZjdÙdڄZkdÛd܄ZldÝdބZmdßdà„Zndádâ„Zodãdä„Zpdådæ„Zqdçdè„Zrdédê„Zsdëdì„Ztej dMe'jue'jvg¡ej d=dídíewfewdídífdíewdífg¡dîdƒZxej dMe'jue'jve'jyg¡ej d=ezdíewfewdíezfdíewezfg¡dðdñ„ƒƒZ{ej dMe'jue'jve'jyg¡dòdó„ƒZ|ej dMe'jue'jve'jyg¡dôdõ„ƒZ}ej dMe'jue'jve'jyg¡död÷„ƒZ~dødù„Zdúdû„Z€düdý„Zdþdÿ„Z‚ej ddÃdÂg¡dd„ƒZƒej ddfdddddhg¡ej ddÃdÂg¡ej d    e'j(j„e'j…j„g¡d
d „ƒƒƒZ†d d „Z‡dd„Zˆdd„Z‰dd„ZŠej de' ‹d¡e' Œd¡g¡dd„ƒZej de' ‹d¡e' Œd¡g¡dd„ƒZŽej de' ‹d¡e' Œd¡g¡dd„ƒZdíS(Ú    TestUfunccCs^tdtjdƒD]H}tt tjtj|d¡tjkƒt tjtj    |d¡}t|tj    kƒqdS)Nrr)Úprotocol)
ÚrangerÚHIGHEST_PROTOCOLrÚloadsÚdumpsrÚsinÚ_rational_testsÚtest_add)r%Úprotor[rrrÚ test_pickle¾sÿÿ ÿzTestUfunc.test_picklecCsd}tt |¡tjkƒdS)NsMcnumpy.core
_ufunc_reconstruct
p0
(S'numpy.core.umath'
p1
S'cos'
p2
tp3
Rp4
.)rrr…rÚcos)r%ZastringrrrÚtest_pickle_withstringÉsz TestUfunc.test_pickle_withstringcCs,tjt_t t tj¡¡}|tjks(t‚dSr>)ÚumtZ_pickleable_module_global_ufuncr€rrr…r†rXrErrrÚtest_pickle_name_is_qualnameÎsz&TestUfunc.test_pickle_name_is_qualnamec    Cshd}t |¡}t ttt |d¡t |d¡dƒƒ¡ ¡}ttj ||¡ddd…ddddgƒdS)NérrrSéé)    rÚarangerVÚlistÚzipZravelrr"Úreduceat)r%ÚLr:ÚidxrrrÚtest_reduceat_shifting_sum×s
0z$TestUfunc.test_reduceat_shifting_sumcCsdS)aLTry to check presence and results of all ufuncs.
 
        The list of ufuncs comes from generate_umath.py and is as follows:
 
        =====  ====  =============  ===============  ========================
        done   args   function        types                notes
        =====  ====  =============  ===============  ========================
        n      1     conjugate      nums + O
        n      1     absolute       nums + O         complex -> real
        n      1     negative       nums + O
        n      1     sign           nums + O         -> int
        n      1     invert         bool + ints + O  flts raise an error
        n      1     degrees        real + M         cmplx raise an error
        n      1     radians        real + M         cmplx raise an error
        n      1     arccos         flts + M
        n      1     arccosh        flts + M
        n      1     arcsin         flts + M
        n      1     arcsinh        flts + M
        n      1     arctan         flts + M
        n      1     arctanh        flts + M
        n      1     cos            flts + M
        n      1     sin            flts + M
        n      1     tan            flts + M
        n      1     cosh           flts + M
        n      1     sinh           flts + M
        n      1     tanh           flts + M
        n      1     exp            flts + M
        n      1     expm1          flts + M
        n      1     log            flts + M
        n      1     log10          flts + M
        n      1     log1p          flts + M
        n      1     sqrt           flts + M         real x < 0 raises error
        n      1     ceil           real + M
        n      1     trunc          real + M
        n      1     floor          real + M
        n      1     fabs           real + M
        n      1     rint           flts + M
        n      1     isnan          flts             -> bool
        n      1     isinf          flts             -> bool
        n      1     isfinite       flts             -> bool
        n      1     signbit        real             -> bool
        n      1     modf           real             -> (frac, int)
        n      1     logical_not    bool + nums + M  -> bool
        n      2     left_shift     ints + O         flts raise an error
        n      2     right_shift    ints + O         flts raise an error
        n      2     add            bool + nums + O  boolean + is ||
        n      2     subtract       bool + nums + O  boolean - is ^
        n      2     multiply       bool + nums + O  boolean * is &
        n      2     divide         nums + O
        n      2     floor_divide   nums + O
        n      2     true_divide    nums + O         bBhH -> f, iIlLqQ -> d
        n      2     fmod           nums + M
        n      2     power          nums + O
        n      2     greater        bool + nums + O  -> bool
        n      2     greater_equal  bool + nums + O  -> bool
        n      2     less           bool + nums + O  -> bool
        n      2     less_equal     bool + nums + O  -> bool
        n      2     equal          bool + nums + O  -> bool
        n      2     not_equal      bool + nums + O  -> bool
        n      2     logical_and    bool + nums + M  -> bool
        n      2     logical_or     bool + nums + M  -> bool
        n      2     logical_xor    bool + nums + M  -> bool
        n      2     maximum        bool + nums + O
        n      2     minimum        bool + nums + O
        n      2     bitwise_and    bool + ints + O  flts raise an error
        n      2     bitwise_or     bool + ints + O  flts raise an error
        n      2     bitwise_xor    bool + ints + O  flts raise an error
        n      2     arctan2        real + M
        n      2     remainder      ints + real + O
        n      2     hypot          real + M
        =====  ====  =============  ===============  ========================
 
        Types other than those listed will be accepted, but they are cast to
        the smallest compatible type for which the function is defined. The
        casting rules are:
 
        bool -> int8 -> float32
        ints -> double
 
        Nrr$rrrÚtest_all_ufuncÝsQzTestUfunc.test_all_ufuncrr]cCsRt ddd¡\}}}}}t|dƒt|dƒt|dƒt||jfƒt|dƒdS)Nrrú (i),(i)->())rrr©rr©éÿÿÿÿ©rŽÚtest_signaturerÚ size_inferred©r%ZenabledZnum_dimsZixsÚflagsÚsizesrrrÚtest_signature03sÿ
 
 
zTestUfunc.test_signature0cCsNt ddd¡\}}}}}t|dƒt|dƒt|dƒt|dƒt|dƒdS)Nrrz    (),()->()r©rrrr©rŽr rr¢rrrÚtest_signature1=sÿ
 
 
 
zTestUfunc.test_signature1cCsVt ddd¡\}}}}}t|dƒt|dƒt|dƒt||jfdƒt|dƒdS)Nrrz(i1,i2),(J_1)->(_kAB)©rrr)rrrrSr]©ržržržržrŸr¢rrrÚtest_signature2Gsÿ
 
 
zTestUfunc.test_signature2cCsVt ddd¡\}}}}}t|dƒt|dƒt|dƒt||jfdƒt|dƒdS)Nrrz(i1, i12),   (J_1)->(i12, i2)©rrr)rrrrrSr]rªrŸr¢rrrÚtest_signature3Qsÿ
 
 
zTestUfunc.test_signature3cCsVt ddd¡\}}}}}t|dƒt|dƒt|dƒt||jfdƒt|dƒdS)Nrrz(n,k),(k,m)->(n,m)©rrr©rrrrrrrS©ržržržrŸr¢rrrÚtest_signature4Zsÿ
 
 
zTestUfunc.test_signature4cCsft ddd¡\}}}}}t|dƒt|dƒt|dƒt||j|jB|j|j|jBfƒt|dƒdS)Nrrz(n?,k),(k,m?)->(n?,m?)r®r¯r°)rŽr rr¡Ú
can_ignorer¢rrrÚtest_signature5dsÿ
 
 
 
þzTestUfunc.test_signature5cCsNt ddd¡\}}}}}t|dƒt|dƒt|dƒt|dƒt|dƒdS)Nrz(3)->()©rr©r©rSr§r¢rrrÚtest_signature6psÿ
 
 
 
zTestUfunc.test_signature6cCsVt ddd¡\}}}}}t|dƒt|dƒt|dƒt|d|jdfƒt|dƒdS)NrSrz(3),(03,3),(n)->(9)©rrrr©rrrrrr©rSržé    rŸr¢rrrÚtest_signature7ysÿ
 
 
zTestUfunc.test_signature7cCsXt ddd¡\}}}}}t|dƒt|dƒt|dƒt||j|jdfƒt|dƒdS)NrSrz(3?),(3?,3?),(n)->(9)r¸r¹rrº©rŽr rr²r¡r¢rrrÚtest_signature8‚sÿ
 
 
zTestUfunc.test_signature8cCsNt ddd¡\}}}}}t|dƒt|dƒt|dƒt|dƒt|dƒdS)Nrz (  3)  -> ( )r´rµr¶r§r¢rrrÚtest_signature9‹sÿ
 
 
 
zTestUfunc.test_signature9cCsXt ddd¡\}}}}}t|dƒt|dƒt|dƒt||j|jdfƒt|dƒdS)NrSrz ( 3? ) , (3? ,  3?) ,(n )-> ( 9)r¸r¹rrºr½r¢rrrÚtest_signature10”sÿ
 
 
zTestUfunc.test_signature10c    Cs&ttƒt ddd¡W5QRXdS)Nrrz ((i)),(i)->()©rÚ
ValueErrorrŽr r$rrrÚ(test_signature_failure_extra_parenthesiss
z2TestUfunc.test_signature_failure_extra_parenthesisc    Cs&ttƒt ddd¡W5QRXdS)Nrrz (i),)i(->()rÁr$rrrÚ.test_signature_failure_mismatching_parenthesis¡s
z8TestUfunc.test_signature_failure_mismatching_parenthesisc    Cs&ttƒt ddd¡W5QRXdS)Nrrz(i),->()rÁr$rrrÚ2test_signature_failure_signature_missing_input_arg¥s
z<TestUfunc.test_signature_failure_signature_missing_input_argc    Cs&ttƒt ddd¡W5QRXdS)Nrr›rÁr$rrrÚ3test_signature_failure_signature_missing_output_arg©s
z=TestUfunc.test_signature_failure_signature_missing_output_argcCsttjjdƒdS)Nr›)rrŽÚinner1dr(r$rrrÚtest_get_signature­szTestUfunc.test_get_signaturec    Csìdtjddd}tt |d¡dddgƒt t¡$ttj|dddd    d
d
dgƒW5QRXttj|dd dd    d
d
dgƒt t¡$ttj|dd dd    d
d
dgƒW5QRXttj|dd dd    d
d
dgƒtjddd}tj|d|dt|dddgƒd
|dd…<t t¡tj|dd|ddW5QRXt|d
d
dgƒd
|dd…<tj|dd |ddt|d
d
dgƒd
|dd…<t t¡tj|dd |ddW5QRXt|d
d
dgƒd
|dd…<tj|dd |ddt|d
d
dgƒdS)Nçà?rSÚf8r5rçø?ÚiÚunsafe)r'Úcastingrr)Úi4)rÏrÏrÏr¶©Úout)r'rÑrÎ)rr“rr"r{ÚwarnsÚDeprecationWarningÚzeros©r%ÚaÚbrrrÚtest_forced_sig°s> ( ÿ ÿÿ      zTestUfunc.test_forced_sigc    Cs†tjdgdgdd}t dgdg¡}t||ƒtjdgdgdd}t dgdg¡}t||ƒt t¡tjddddW5QRXdS)NrSr])NNN©r'r>©r()rr"rÚmaximumr{Úraisesr!)r%Zres1Zres2rrrÚtest_signature_all_NoneÎs
 
 z!TestUfunc.test_signature_all_NonecCs*tt tj¡ƒ}tjdd||dfddS)NrSr]rÚ)rrrr+rnr")r%Z float_dtyperrrÚtest_signature_dtype_typeÜsz#TestUfunc.test_signature_dtype_typeÚ    get_kwargcCs
ttdS©Nr5©Údictr:©ÚdtrrrrcãrdzTestUfunc.<lambda>cCsttddfdS©NrÚrárãrrrrcärdcCsnt d¡}t t |¡¡}||k    s&t‚tjd||ƒŽj|ks@t‚t dd¡}tj||f|dƒŽjdksjt‚dS)NÚint64rrÚsZm8úm8[s])rr)rr+rr…r†rXr"Ú    timedelta)r%rßræZint64_2ÚtdrrrÚ&test_signature_dtype_instances_allowedâs 
  z0TestUfunc.test_signature_dtype_instances_allowedcCs
t|dSrà©râ©r:rrrrcòrdr+©ÚidcCst|ddfdSrårìrírrrrcórdr(c    Cs–d}tjt|d tjd|t d¡ ¡ƒŽW5QRXtjt|dtjd|t d¡ƒŽW5QRXtjt|dtjd    |dƒŽW5QRXdS)
Nz/The `dtype` and `signature` arguments to ufuncs©ÚmatchrSr‘ræzm8[ns])rSr‘)rSr‘)rSr‘)r{rÜr!rr"r+Ú newbyteorder)r%rßÚmsgrrrrëñs$ rÎrÍZ    same_kindrc    Cs°tjt d¡t d¡dd}|jdks*t‚tjt d¡t d¡dd}|jdksTt‚t t¡tjdt     d¡ddW5QRXt t¡tjdt     d¡ddW5QRXdS)Nçð?rÚdr5)NNrõrÚrS)
rÚldexpÚfloat32Úint_r+rXr{rÜr!Úuint64)r%rÎr[rrrÚtest_partial_signature_mismatchþs   z)TestUfunc.test_partial_signature_mismatchc    Cs€t t¡"tjt d¡t d¡ddW5QRXt t d¡t d¡¡t t¡"tjt d¡t d¡ddW5QRXdS)Nrr)ÚerõNrÙ)r{rÜr!rr"Úfloat16rùrnr$rrrÚ*test_partial_signature_mismatch_with_cache s
 & z4TestUfunc.test_partial_signature_mismatch_with_cachec    Csrtjddtjdd}|dks t‚tjddddtjfdd}|dksFt‚t t¡tjddtjdW5QRXdS)NrËgffffff@rÍ©r+rÎr)r(rÎr5)rÚpowerÚintprXr{rÜr!©r%r[rrrÚ+test_use_output_signature_for_all_argumentss ÿ  z5TestUfunc.test_use_output_signature_for_all_argumentsc    CsìtjtddtjddddW5QRXt t¡tjddddW5QRXt t¡tjddddW5QRXt t¡tjddd    dW5QRXt t¡tjddd
dW5QRXt t¡tjddd dW5QRXdS) Nz1the signature object to ufunc must be a string orrðrSr]gÀ^@rÚz%^->#sii-izii>i)NrÊsÿÿ->i)r{rÜr!rr"rÂÚUnicodeDecodeErrorr$rrrÚtest_signature_errors#sÿ     zTestUfunc.test_signature_errorscCsftjdddgdd}tj||ddtjj|ddtjddd}tj||d    dtj||d    ddS)
Nz
2010-01-02z
1999-03-14z1833-03z>M8[D]r5ÚMr4rèÚm)rrVrÛÚreducer“r")r%rÖrZrrrÚtest_forced_dtype_times8s z!TestUfunc.test_forced_dtype_timesrc    s܇fdd„}tjdddgtjd}| |j ¡¡}||ƒ}||dd}t||ƒt t    ¡||ddW5QRX||d    d}t||ƒt t    ¡||tj
d    d
W5QRX||tj
d d
}|| tj
¡ƒ}t||ƒd S) zBasic test for the safest casts, because ufuncs inner loops can
        indicate a cast-safety as well (which is normally always "no").
        csˆ|fˆj|ŽSr>)Únin)rZÚkwargs©rrrÚ
call_ufuncHsz.TestUfunc.test_cast_safety.<locals>.call_ufuncrôç@ç@r5Úno©rÎÚequivrþrN) rrVr÷rsr+ròrr{rÜr!rn)r%rr rZZarr_bsÚexpectedr[rr rÚtest_cast_safetyCs  
 
 zTestUfunc.test_cast_safetyc CsFt d¡}t d¡}t d¡}dD]º}t |¡}| |¡}| |¡}t || g|| g¡D]|\}}    |dkr‚t|ƒt|    ƒ}nt|ƒt|    ƒ}t ||    ¡}
t    t 
|
¡j dƒ} t |
|| d|dkrØt |
jjd    kƒnt |
jj|jkƒdD]"} t | ¡} tttj||    | d
qîd D]} t | ¡} |dkrFtttj||    | d
nÐt|ƒt|    ƒ}t    t 
| ¡j dƒ} tƒ<}| t¡t t 
| ¡j¡s¢t    t 
| ¡jd ƒ}nd }W5QRXtjd d dtj||    | d
}
W5QRXt |
¡sô| dkrôqt |
|| |dt |
jj| jkƒqdD]¼} t | ¡} t|ƒt|    ƒ}t    t 
| ¡j dƒ} tƒ<}| t¡t t 
| ¡j¡sˆt    t 
| ¡jd ƒ}nd }W5QRXtj||    | d
}
t |
¡s¶qt |
|| |dt |
jj| jkƒqq^q"tjdtjd
}t ||¡}
t |
dkƒt |
jjd    kƒt ||¡}
t |
dkƒt |
jjd    kƒdS)Nr4érÉZbhilqBHILQefdgFDGZFDGgV瞯Ò<)ÚrtolZ
bhilqBHILQrnr5ZefdggwºMhƒ’Úignore)ÚinvalidZoverrû)rÚatolrrôç)rrVr+rsÚ    itertoolsÚproductrWÚfloatÚ true_divideÚmaxÚfinfoÚ
resolutionr
rÚnamerr!r ÚfilterÚ UserWarningÚisnanZtinyrpÚisfiniterHrC)r%rÖr×ÚtgtÚtcräZaaZbbr:r;r[rZtcoutZdtoutÚsuprrrrÚtest_true_dividebst
 
 
 
 
 
 
" 
 
 
 
 
 
 
    zTestUfunc.test_true_dividecCs`tjdtjd}t|d ¡|jdddƒtjdtjd}t|d ¡|jdddƒdS)Néôr5ç$@rr]é )rrHr÷rÚsumÚsizern©r%rÖrrrÚtest_sum_stability¹szTestUfunc.test_sum_stabilityúfp errors don't work in wasm©Úreasonc CsâttjtjtjtjfD]Ä}dD]¼}tjdd¦}t dt    ¡|||ddƒ}t 
|¡ }t t |ƒd|ƒtj d|d|d}tt |¡|ƒt t |ƒd|ƒtt |ddd…¡|ƒt t |ƒd    |ƒW5QRXq tjd
|d}tt |ddd…¡d ƒtt |ddd…¡d ƒtt |ddd    …¡d ƒtt |ddd    …¡d ƒtt |ddd …¡d ƒtt |ddd …¡d ƒtt |ddd…¡d ƒtt |ddd…¡d ƒtjd|d}||7}t|dƒqdS)N© rrrr’ér»ééééé€éiÓT©ÚrecordÚalwaysrrr5ržrSr*g@o@gàd@éþÿÿÿéýÿÿÿ©rr )r#rrür÷rnryÚwarningsÚcatch_warningsÚ simplefilterÚRuntimeWarningr%rÚlenr“rr-rH)r%räÚvÚwr&ZoverflowrõrrrÚtest_sumÀs0  zTestUfunc.test_sumc    Cs¶tjtjtjfD]ž}dD]Ž}|||ddƒ|||dddƒ}tj||d}t d|d¡|_t d|d¡ |_tt     |¡|ƒtt     |ddd…¡|ƒqtj
d|dd}tt     |ddd…¡dƒtt     |ddd…¡dƒtt     |ddd    …¡d
ƒtt     |ddd    …¡d
ƒtt     |ddd …¡dƒtt     |ddd …¡dƒtt     |ddd …¡d
ƒtt     |ddd …¡d
ƒtj
d |dd}||7}t|dƒqdS)Nr4rryð?r5ržr*y@o@@o@rSyàd@àd@r?r@rAy@@) rZ    complex64Z
complex128rzÚemptyr“ÚrealÚimagrr-rH)r%rärGr&rõrrrÚtest_sum_complexãs(,zTestUfunc.test_sum_complexcCsXttjdgdddƒttjdgdddƒttjtjdtjd    d
dd d d d gƒdS) NrSr©Úinitialr‘gš™™™™™É?皙™™™™¹?ç333333Ó?)rrSr‘r5©rr)ÚaxisrOé )rrr-rrHrær$rrrÚtest_sum_initialüs
ÿzTestUfunc.test_sum_initialcCsTttjddgddggddgddƒttjddgddggdd    ddgd
d d    gƒdS) Nrôr rç@TF©Úwhererç@)rSrOrXç"@)rrr-r$rrrÚtest_sum_wheres $ÿÿzTestUfunc.test_sum_wherecCsZt d¡ d¡}tt ||¡tj||ddƒt d¡}tt ||¡t ||¡ƒdS)Nr©rrSrž©rS)rr“ÚreshaperrŽrÇr-r/rrrÚ test_inner1d s 
zTestUfunc.test_inner1dc     Csød}t d¡ d¡}t d¡ d¡}tt ||¡tj||dd|dd}t d¡ d    ¡}tt ||¡tj||dd|dt d
¡ d ¡}t d¡ d ¡}tttj||ƒt d
¡ d ¡}t     d ¡}tttj||ƒt d¡ d¡}t d¡ d¡}tttj||ƒt d¡}t d¡ d    ¡}t 
||¡\}}t |j ddƒ||}t jdd:}t  d¡||7}t t|ƒdƒt|d|dkƒW5QRXt d¡ dd¡}t d¡}t d¡}tttj|||ƒt d¡}    t |||    ¡}
t|
|    kƒdS)NÚ    broadcastr]r¬©rrrržr]©Úerr_msgz"extend & broadcast loop dimensions©rrr5)r]r©r]rr’rr©rS)rSrrrTr<r>rrœrr)rr“r^rrŽrÇr-rrÂrVZbroadcast_arraysrÚstridesrBrCrDrFrrHrJ) r%rórÖr×ÚurGr:rHrÑZout2ÚcrrrÚtest_broadcastsB$$
 
 
 
 
 
zTestUfunc.test_broadcastcCsjt d¡ dd¡}t d¡}tj|||d|t d¡dk ¡sFt‚tj|||d|dk ¡sft‚dS)NrSr)r‘r]rSrÐrr‘)    rr“r^rJr"rJrXrŽrÇ©r%rZrÑrrrÚtest_out_broadcasts>s 
zTestUfunc.test_out_broadcastsrZrÑrr)r]rSrez(1,)->()z
(2,)->(1,)z(4, 3)->(4, 1))Úidsc    Cs\tjtddtj||dW5QRXtjtddtjt d¡||dW5QRXdS)Nznon-broadcastablerðrÐr)r{rÜrÂrÚpositiver"rHrjrrrÚtest_out_broadcast_errorsMsz#TestUfunc.test_out_broadcast_errorscCs€d}tjddd d¡}tt ||¡tj||dd|dd    }t d¡ d¡}|d
}tt ||¡tj||dd|ddS) Nz    type castrÚshortr5r\ržr]rbztype cast on one argumentrP)rr“r^rrŽrÇr-r)r%rórÖr×rrrÚtest_type_cast[sÿÿzTestUfunc.test_type_castcCsPd}tjddd d¡}tt ||¡tj||dd|dd    }tjdd
d d¡}tt ||¡tj||dd|dtjd d d}tjd d d}t||jt d¡ƒt||jt d¡ƒt||jt d¡ƒt||jt d¡ƒtt     |¡jt d¡ƒtt     |¡jt d¡ƒtt 
|¡jt d¡ƒtt 
|¡jt d¡ƒdS)Nz
big endianrz>i4r5r\ržr]rbz little endianz<i4rz>f8z<f8rÊ) rr“r^rrŽrÇr-rr+ÚabsoluteÚnegative)r%rórÖZBaZLarrrÚ test_endianfs(ÿÿzTestUfunc.test_endiancCsød}t d¡ d¡}|dd…ddd…ddd…df}|dd…ddd…ddd…df}d|d<d}t|d    d|d
tt ||¡tj||dd |d
t d ¡ d dd¡}|j}|j}d|d<t|dd|d
tt ||¡tj||dd |d
dS)Nz#incontiguous memory layout of arrayé@)rrrrrrrrržr¦z-make sure it references to the original array)rrrrrrrbr]érrSr])    rr“r^rrrŽrÇr-ÚT)r%rór:rÖr×Zmsg2rrrÚtest_incontiguous_array}s  $z!TestUfunc.test_incontiguous_arraycCs”d}t d¡ d¡}t d¡ d¡d}tjddd    }t |||¡t|tj||d
d |d d
|dd…<tj|||d t|tj||d
d |d d}tjddd    }t |||¡t|tj||d
d |d d
|dd…<tj|||d t|tj||d
d |d d}tjddd    }t |||d¡t|dtj||d
d |d d
|dd…<tj|||dd t|dtj||d
d |d dS)Nzoutput argumentrT©rrSrr]r¬rr\r#r5ržr]rbrÐzoutput argument with type castÚint16z(output argument with incontiguous layout©rrSr]).r)rr“r^rÔrŽrÇrr-)r%rórÖr×rhrrrÚtest_output_arguments.    zTestUfunc.test_output_argumentc Cs,tj}t d¡ d¡}t dd¡ d¡}|||ƒ}t||| d¡ƒ|||dddgd    }t||| d¡ƒ|||dddgd    }t||| d¡ƒ|||dddgd    }t||| d¡ƒ|||ddgd    }t||| d¡ƒ|||t d¡tjdtj    d
gd    }t||| d¡ƒ|||d d gd    }t||| d ¡ƒ|||d d gd    }t|| 
d d d ¡| d¡ƒt t |||dd    t t |||dgd    t t |||ddgd    t t |||ddgd    t t |||dd gd    t t |||dddgd    t t |||dddgd    t t |||dddgd    t t |||d d gd    tj}t d¡ d¡}t d¡ d¡d }|||ƒ}t|t ||¡ƒ|||dddgd    }t|t ||¡ƒ|||dddgd    }t|t ||¡ƒ|||dddgd    }t|t | 
d d d ¡| 
d dd d ¡¡ƒt d¡}||||dddgd}t||kƒt|t ||¡ƒt d¡}||||dddgd}t||kƒt|t ||¡ 
dd d d ¡ƒt t |||d dt t |||d d    t t |||dd    t t |||gd    t t |||dgd    t t |||dddgd    t t |||dddgd    t t |||ddgddgddggd    t t |||ddddggd    t t |||dddgd    t t |||ddd gd    t d!¡}t t |||d ƒt t ||||dd…d fd"t t ||d |d d gd    t t ||||d d d gdt t tjd#d#d gd    t t |||d d gd$d%dS)&Nç;@©rSrSrSr+ç3@©rSrrSržrr)Úaxesr5rrrçð¿)r©r?ržrTrxr5©rrrr©rrr\)rržrS)rrrSr)rÑr€)rrrrS)rSrr])r‚r‚r‚r?)r?r?rdrÐrôT)r€r-)rŽrÇrr“r^rr-Zint8rVÚint32Ú    transposerr!rÂÚmatrix_multiplyÚmatmulrJrrÔr")r%rÇrÖr×rhÚmmrõÚzrrrÚtest_axes_argument¨sš
$
ÿ
 
 ÿ ÿ
zTestUfunc.test_axes_argumentc    Cs>tj}t d¡ d¡}t dd¡ d¡}|||ƒ}t||| d¡ƒ|||dd}t||| d¡ƒt |¡}|||d|d}t||kƒt||ƒ|||d    d}t||| d    ¡ƒt d
¡ d ¡}t d d ¡ d ¡}t dd¡ d ¡}ttj    |||d    dtj|||d    dƒttj
|d    dtj
|d    dƒttj
|ddtj
|ddƒt  |¡}tj
||d    d}t||kƒt|tj
|d    dƒtj
||dd}t||kƒt|tj
|ddƒt t |||d    d    d    gdt t |||d    gdtj}t t |||ddtjd|jd}t ttj
||d    dt t tjddd    ddS)Nr|r}r+r~rržr])rSrÑrrr\r4r7ré©rÑrSr)rSr€©rrrSr5rô)rŽrÇrr“r^rr-Ú
zeros_likerÚinnerwtÚcumsumZ
empty_likerr!r‡rJr+rÂr")    r%rÇrÖr×rhrÑrõrHr‰rrrÚtest_axis_argumentsF
 
 
ÿ
  zTestUfunc.test_axis_argumentcCstj}t d¡ d¡}t dd¡ d¡}|||ƒ}t||| d¡ƒ|||dd}t||| d¡ƒ|||d    d}t|||jdd    dƒt |¡}|||d    |d
}t||kƒt||ƒ|||ddd }t|||jdddƒ|||dd    d }t|||jdd    dƒ|||d dd }t|||jd ddƒ|||d d    d }t|||jd d    dƒ|||d d dgdd}t||| d¡ƒ|||d d d gd    d}t|||jdd    dƒ|||d d gdd}t||| d ¡ƒ|||d d d gd    d}t|||jd d    dƒ|||d dgdd}t||     ddd ¡| d¡ƒ|||d dgd    d}t||     ddd ¡|jdd    dƒ|||d ddgd    d}t||     ddd ¡|jdd    dƒ|||d dd gd    d}t|||     dd d¡jd d    dƒ|||d ddgd    d}t||     dd d¡|     d dd¡jdd    dƒt 
d¡t d¡dd…tj tj f}t   |¡}t j |dd}t||ƒt j |d    d}t||dd…tj tj fƒt 
d¡t d¡dd…tj tj f}t  |¡\}}    t j|dd\}
} t|
|ƒt| |    ƒt j|d    d\}
} t|
|dd…tj tj fƒt| |    dd…tj tj fƒt d¡ d¡}t dd¡ d¡}t dd¡ d¡} ttj||| d    dtj||| dd    d ƒttj||| d d    d tj||| d d    d ƒtt|||ddtj} tt| ||d    dtt| ||ddtttjdddddS)Nr|r}r+r~rržF©ÚkeepdimsT)r”rÑ©rSr”rrr)r€r”rrrSrVrr\r4r7rrŒÚtruerô)rŽrÇrr“r^rr-rrr†ÚeyeÚnewaxisÚumlÚdetZslogdetrrr!r‡r")r%rÇrÖr×rhrÑrõrZ
expected_sZ
expected_lÚcsZclrHr‰rrrÚtest_keepdims_argument;s”
 
 
ÿÿ" ÿ&
 
&
 
ÿÿz TestUfunc.test_keepdims_argumentcCsºt d¡ d¡}t dd¡ d¡}t dd¡ d¡}tt |||¡tj|||ddƒt d    d
¡ d ¡}t d d ¡ d ¡}t dd¡ d ¡}tt |||¡tj|||ddƒdS)Nrr\r4r7rrŒržr]édé|rzéÈéàé,iD)rr“r^rrŽrr-©r%rÖr×rHrrrÚ test_innerwtŠs&zTestUfunc.test_innerwtcCsTtjgdd}tjgdd}tjgdd}tt |||¡tj|||ddƒdS)z/Test generalized ufunc with zero-sized operandsrÊr5ržr]N)rrVrrŽrr-r¢rrrÚtest_innerwt_empty”szTestUfunc.test_innerwt_emptycCsât d¡}tt ||¡t d¡ƒt d¡}t |d||¡}t||kƒt|t t d¡|d|d f¡ƒtt    tjt d¡t d¡ƒtt    tj|t 
d¡ƒtt    tj|t 
d¡t d    ¡ƒtt    tj|t 
d¡t d¡ƒd
S) z Test with fixed-sized signature.rS©rSrSrrrr]rVr)rSr]N) rr—rrŽZcross1drÔrZvstackrrÂr“)r%rÖrÑÚresultrrrÚ test_cross1d›s
 
 &zTestUfunc.test_cross1dcCsRt d¡ d¡}t d¡}|dd…tjf}t d¡ d¡d}t ||¡}t ||¡}t||ƒtt    tj||ƒt ||¡}t|| 
¡ƒt ||¡}t ||¡}t||ƒt d¡}|tjdd…f}t d¡ d    ¡d}    t ||¡}
t ||¡} t| |
ƒtt    tj||ƒt ||¡} t| |
 
¡ƒt |    |¡}
t |    |¡} t| |
ƒ|j }|      d
d ¡}t ||¡} t ||¡}t|| ƒtt    tj||ƒt ||¡}t||  
¡ƒt |    |¡}t |    |¡}t||ƒt  |¡}tj|    ||d }t||ƒd |dd…<tj|    ||d }t||ƒt  | ¡}tt    tj|||ƒt |||¡}t||  
¡ƒdS)NrTrxrr5rƒrrSru)r]rrrrSr?ržrÐr)rr“r^r˜rŽr‡rˆrrrÂÚsqueezervÚswapaxesr)r%ÚmatZ
single_vecZcol_vecZ col_vec_arrayZ
mm_col_vecZmatmul_col_vecZ
matmul_colZrow_vecZ row_vec_arrayZ
mm_row_vecZmatmul_row_vecZ
matmul_rowZmm_row_col_vecZmatmul_row_col_vecZmatmul_row_colZmm_row_col_arrayZmatmul_row_col_arrayrÑrrrÚtest_can_ignore_signatureªs`
 
 
 
 
 
 
 
 
 
 
 
 ÿz#TestUfunc.test_can_ignore_signaturecCs| tj¡| tj¡dSr>)Úcompare_matrix_multiply_resultsrrærxr$rrrÚtest_matrix_multiplyñs zTestUfunc.test_matrix_multiplycCsTt t d¡t d¡¡}t|t d¡ƒt t d¡t d¡¡}t|t d¡ƒdS)N)rr4)r4rrœ)r4r4)rŽr‡rrHrrÔrrrrÚ test_matrix_multiply_umath_emptyõsz*TestUfunc.test_matrix_multiply_umath_emptyc s‚tjtj ddd¡|d}tjtj ddd¡|d}d|jj}‡fdd„‰‡fdd    „‰d
d „}ˆdƒ}ˆdƒtddd ƒfdf}d }|D]â}    |D]Ø}
|D]Î} |D]Ä} | |    ¡| } | |
¡| }|oÐ| jdk    }|oÞ|jdk    }| j    d |j    dkr¤|| j    d|j    dƒr¤t
t   | |¡tj |dtjf dd ¡| dtjdd…fd d|dt| j    ƒt|j    ƒfdq¤qœq”qŒt|d dddS)NrrSr]r5zmatrix multiply on type %scsp|dkrdgfSd}ˆ|dƒ}|D]F}t|ƒD]8}||dg}||||d<|d||<||f7}q0q$|S)Nrrr)rƒ)ÚnÚretÚbaseÚpermrÌÚnew)Ú    permute_nrrr´s   z<TestUfunc.compare_matrix_multiply_results.<locals>.permute_ncsT|dkr dSd}ˆ|dƒ}|D].}||tdƒff7}||tddƒff7}q |S)Nr)rrr)Úslice)r¯r°r±Úsl)Úslice_nrrr· s z:TestUfunc.compare_matrix_multiply_results.<locals>.slice_ncSs||kp|dkp|dkSrAr)Ús1Ús2rrrÚ broadcastablesz@TestUfunc.compare_matrix_multiply_results.<locals>.broadcastableržTr?r.r@r]z %s %srbzreference check)rrVÚrandomZrandr+r!rµr†r±ÚshaperrŽr‡r-r˜r©Ústrr)r%ÚtpÚd1Zd2rórºZ    permute_3Zslice_3ÚrefÚp1Úp2r¸r¹Za1Za2r)r´r·rr¬ûs@ 
ÿ
ÿÿ ÿüz)TestUfunc.compare_matrix_multiply_resultscCsªtjdtd dd¡}tj|jd|jdddf|jd}t ||¡t     tj
|dd…df|ddd    ¡}|tj |jdt d}t ||ƒtttj|ƒdS)
NrTr5r]rSrrrržr])rr“rr^rJr¼r+rŽZeuclidean_pdistÚsqrtr-ZtriÚboolrrrÂ)r%rÖrÑr×rrrÚtest_euclidean_pdist1s* (
zTestUfunc.test_euclidean_pdistcCs&t d¡}t |¡}t|| ¡ƒdS)Nr4)rr“rŽr‘r)r%rÖr¦rrrÚ test_cumsum;s
 
zTestUfunc.test_cumsumcCs–tjddddddgtd}tt |d¡tjdd„|Dƒtdƒtt |d¡tjd    d„|Dƒtdƒtt |d
¡tjd d„|Dƒtdƒtt |d ¡tjd d„|Dƒtdƒtt |d¡tjdd„|Dƒtdƒtt |d¡tjdd„|Dƒtdƒtt |d
¡tjdd„|Dƒtdƒtt |d ¡tjdd„|Dƒtdƒtt |¡tjdd„|Dƒtdƒttj |¡dƒttj |¡dƒdS)NrSTFÚtestÚr5cSsg|] }|pd‘qSr>r©rr:rrrrCsz1TestUfunc.test_object_logical.<locals>.<listcomp>cSsg|] }|pd‘qS©TrrÉrrrrEsrTcSsg|] }|pd‘qS©rTrrÉrrrrGsÚblahcSsg|] }|pd‘qS©rÌrrÉrrrrIscSsg|] }|od‘qSr>rrÉrrrrLscSsg|] }|od‘qSrÊrrÉrrrrNscSsg|] }|od‘qSrËrrÉrrrrPscSsg|] }|od‘qSrÍrrÉrrrrRscSsg|]
}| ‘qSrrrÉrrrrUs)rrVrIrÚ
logical_orÚ logical_andZ logical_notrr/rrrÚtest_object_logical@s< ÿ ÿ ÿ ÿ ÿ ÿ ÿ ÿ
ÿzTestUfunc.test_object_logicalcCsšGdd„dƒ}t |ƒ¡}t||kdƒtt ||¡dƒt |ƒg¡}t||kt dg¡ƒtt ||¡t dg¡ƒttj||tdt dg¡ƒdS)Nc@seZdZdd„ZdS)z8TestUfunc.test_object_comparison.<locals>.HasComparisonscSsdS)Nú==r©r%ÚotherrrrÚ__eq__\sz?TestUfunc.test_object_comparison.<locals>.HasComparisons.__eq__N)r/r0r1rÔrrrrÚHasComparisons[srÕTr5rÑ)rrVrÚequalrI)r%rÕZarr0dZarr1drrrÚtest_object_comparisonZs z TestUfunc.test_object_comparisoncCsPtjdddgtd}tt |¡dƒtt |¡dƒtt |¡dƒtjdddgtd}tt |¡dƒtt |¡d    ƒtt |¡dƒtt     |¡dƒtt |¡dƒtt |¡dƒttjd
ggtd ¡d
ƒttjd
dgggtd d ¡d
dgƒttjd
gtdjd
d dƒttjd
gdd ggtdjd    gddgdd    dd gƒdS)NrÖr×rhr5ÚabcTFrrr©rrrNrS)rOrX)
rrVrIrr-rÚminÚprodÚanyrJr/rrrÚtest_object_array_reductionhs(&ÿÿz%TestUfunc.test_object_array_reductioncCsätjdtd}dd„tdƒDƒ|dd…<tjj||dtjj||dt|tjdd„dDƒtdƒtjdtd}d    d„tdƒDƒ|d
dd…f<tjj||d d tjj||d d t|d
dd…ftjd d„dDƒtdƒdS)Nr]r5cSsg|]
}dg‘qSrAr©rrÌrrrr~szBTestUfunc.test_object_array_accumulate_inplace.<locals>.<listcomp>rÐcSsg|]}dg|‘qSrArrÞrrrrƒs)rrSrr4©rr]cSsg|]
}dg‘qS©rrrÞrrrrˆsrržrcSsg|]}dg|‘qSràrrÞrrrrŒs)rrHrIrƒr"Ú
accumulaterrV)r%rZrrrÚ$test_object_array_accumulate_inplace{sÿÿz.TestUfunc.test_object_array_accumulate_inplacec    Csbtj tjdddgtd¡}t|tjdddgtdƒt t¡tj dddg¡W5QRXdS)Nrrrr5rS)    rr"rárVrIrr{rÜr!rrrrÚ$test_object_array_accumulate_failures z.TestUfunc.test_object_array_accumulate_failurecCs$tjdtd}dd„tdƒDƒ|dd…<tjdtd}dd„tdƒDƒ|dd…<tjj|t d¡|dtjj|t d¡|dt||ƒtjdtd}dd„tdƒDƒ|d    dd…f<tjdtd}d
d„tdƒDƒ|d    dd…f<tjj|t d¡|d d tjj|t d¡|d d t||ƒdS) Nr]r5cSsg|]
}dg‘qSrArrÞrrrršsz@TestUfunc.test_object_array_reduceat_inplace.<locals>.<listcomp>cSsg|]
}dg‘qSrArrÞrrrrœsrÐrßcSsg|]
}dg‘qSràrrÞrrrr£srcSsg|]
}dg‘qSràrrÞrrrr¥sržr)    rrJrIrƒr"r–r“rrHrjrrrÚ"test_object_array_reduceat_inplace—s
z,TestUfunc.test_object_array_reduceat_inplacec    Csltj tjdddgtdddg¡}t|tjddgtdƒt t¡tj dddgddg¡W5QRXdS)Nrrr5r)    rr"r–rVrIrr{rÜr!rrrrÚ"test_object_array_reduceat_failureªs" z,TestUfunc.test_object_array_reduceat_failurecCsxgtjgtdfD]`}tt |¡dƒtt |¡dƒtt |¡dƒtt |¡dƒtt    tj
|ƒtt    tj |ƒqdS)Nr5rrFT) rrVrIrr-rÛrÜrJrrÂrrÚr/rrrÚtest_zerosize_reduction³sz!TestUfunc.test_zerosize_reductioncCs„t ddg¡}ttj|jddt ddg¡}ttj|jddt ddg¡}ttj|jddt ddg¡}ttj|jdddS)NFrr]r?)rrVrZ    AxisErrorrJrÜr/rrrÚtest_axis_out_of_bounds½sz!TestUfunc.test_axis_out_of_boundscCsjttjddddƒttjddddƒttjddddƒttjddddƒttjddddƒttjddddƒttj     d¡dƒt
t tjt  d¡ddƒtj kƒt
t tjt  d¡ddƒtj kƒt
t tjt  d¡ddƒtj kƒt
t tjt  d¡ddƒtj kƒt
t tjdddƒtj kƒGdd    „d    tjƒ}t d
¡ |¡}t
t t |¡ƒ|kƒdS) NrSrr]ç @TFg@c@s eZdZdS)z0TestUfunc.test_scalar_reduction.<locals>.MyArrayN©r/r0r1rrrrÚMyArrayßsrêr)rrr-rÛrÜrJrrÚrÿrrrrr÷rCÚndarrayrVÚview)r%rêrÖrrrÚtest_scalar_reductionÈs""""zTestUfunc.test_scalar_reductioncCs|t dtj¡}t dtj¡}t dtj¡}tj|||dt|dƒt d¡}tjdtjd}tj|d|dt|dƒdS)N)rŸrrÐrir5r)    rrHrærnr"rrÔr÷Úsubtract©r%rÖr×rhrrrÚtest_casting_out_paramäs
 
z TestUfunc.test_casting_out_paramc    CsÎt d¡}t d¡}t d¡}tj||||ddkdt|dddddddgƒt d¡ dd¡d}tj|ddg|ddgddggdt|dd    gd
d ggƒtj|d|d d gdt|dd    gdd ggƒdS)Nr’rr©rÑrXrr]rrSér7r‘TFé)    rr“rHrÔr"rr^rÿrîrïrrrÚtest_where_paramñs
 
 
"zTestUfunc.test_where_paramcCsvt dtj¡}t dtj¡}dt dtj¡}tj|||ddddddddddg
dt|ddddddddddg
ƒdS)Nr4rËrrrñr)rrHrærnr"rrïrrrÚtest_where_param_buffer_outputs
&z(TestUfunc.test_where_param_buffer_outputcCsttjdgtjd}tjdgtd}ttj||ddgƒtjdgtjd}tjdgtd}ttj||ddgƒdS)Nrr5TrW)rrVrærÄrrÃrn©r%rÖrrrrÚtest_where_param_alloc s z TestUfunc.test_where_param_alloccCs‚tj d¡}tj d¡}|dk}t |d¡}tj||||dt ||j¡|}t|||k|| t¡ƒ||     ¡r~t
‚dS)N)éˆr])rørrQr)rXrÑ) rr»Z    full_likeÚlessZ broadcast_tor¼rrsrÄrÜrX)r%rÖr×rXrÑZb_whererrrÚtest_where_with_broadcastings   z&TestUfunc.test_where_with_broadcastingcCs@d|d<d|d<ttjj|dddƒttjj|ddddddgƒttjj|dddddgƒttjj|ddddgƒttjj|ddddddgddddgddddggƒttjj|ddddddgddddggƒttjj|d    ddddgdddggƒttjj|d
d|ƒd|d<d|d <ttjj|dddƒttjj|ddddddgƒttjj|dddddgƒttjj|ddddgƒttjj|ddddddgddddgddddggƒttjj|ddddddgddddggƒttjj|d    ddddgdddggƒttjj|d
d|ƒd|d<d|d <ttjj|dddƒttjj|ddddddgƒttjj|dddddgƒttjj|ddddgƒttjj|ddddddgddddgddddggƒttjj|ddddddgddddggƒttjj|d    ddddgdddggƒttjj|d
d|ƒdS) Nr.r)rrrr]rÙrRr„rr)rrr)rrr)rrÚminimumrr/rrrÚcheck_identityless_reduction"s` ÿÿÿ ÿÿÿ ÿÿÿz&TestUfunc.check_identityless_reductionlcCsjt dd¡}ddg|dd…df<ddg|dd…df<tjj|dd}~|ddksVt‚|ddksft‚dS)    N)rlÚuint8rrSrr]ržr])rrÔrÛrrXrYrrrÚ&test_identityless_reduction_huge_arrayPs z0TestUfunc.test_identityless_reduction_huge_arraycCstjddd}| |¡dS)NrzÚC©Úorder©rrJrür/rrrÚ"test_identityless_reduction_corder[sz,TestUfunc.test_identityless_reduction_cordercCstjddd}| |¡dS)NrzÚFrrr/rrrÚ"test_identityless_reduction_forder_sz,TestUfunc.test_identityless_reduction_fordercCs$tjddd dd¡}| |¡dS)N)rr]rSrÿrrr©rrJr©rür/rrrÚ&test_identityless_reduction_otherordercsz0TestUfunc.test_identityless_reduction_otherordercCs>tjddd dd¡}|dd…dd…dd…f}| |¡dS)N)rSr‘r]rÿrrrrr/rrrÚ%test_identityless_reduction_noncontiggsz/TestUfunc.test_identityless_reduction_noncontigcCsPtjddd}|dd…jdd}d|_|dd…dd…dd…f}| |¡dS)N)iáÚi1r5rrÊ)rSr]r‘)rrJrìr¼rür/rrrÚ/test_identityless_reduction_noncontig_unalignedls
z9TestUfunc.test_identityless_reduction_noncontig_unalignedcCsttjjgdddƒttjjgtjdtjƒttjjgtj dtj ƒttjjdgdddƒttjjdgdddƒttjjdgdddƒttjjdgdddƒtttjjgddtttjjgddttjjgtj    ddƒtj
dgt d}tjj|dd}t|dƒdS)NrrNr‘r]r4r5r6) rrrÛrrûÚinfrrÂr"Z_NoValuerVrI©r%rÖr[rrrÚtest_initial_reductionssz TestUfunc.test_initial_reductionrS)rrNrXFTcCsht d¡ dd¡}| ¡}t |¡}tj|||dtjj|||d}| |¡}t    ||ƒt
||ƒdS)NrZrSrñ©rSrX) rr“r^Úcopyrrmr"rr-rr)r%rSrXrÖÚa_copyÚa_checkr[ÚcheckrrrÚtest_reduction_with_wheres
 
 
z#TestUfunc.test_reduction_with_whererr)NTrOrYc    Cslt d¡ dd¡}| ¡}t |jtj ¡}tj|||dtjj    ||||d}|j
||d}t ||ƒdS)NrZrSrñ)rSrXrOrN) rr“r^rr7r¼r rmrÛrrr)    r%rSrXrOrÖrrr[rrrrÚ%test_reduction_with_where_and_initial¢sz/TestUfunc.test_reduction_with_where_and_initialcCs4t d¡ dd¡}dddg}tttjj||ddS)NrZrSFTrW)rr“r^rrÂrÛrrörrrÚ#test_reduction_where_initial_needed±s
z-TestUfunc.test_reduction_where_initial_neededcCsŠt dddgdddgg¡}tjj|dd}t|dddgƒtjj|d    d}t|ddgƒtjj|d
d}t||ƒtttjj|d ddS) Ng @r rôrÉgÐ?rr]rVrrrÙ)rrVÚdividerrrrÂr rrrÚ*test_identityless_reduction_nonreorderable¶s
z4TestUfunc.test_identityless_reduction_nonreorderablecCsddd„}dd„}dd„}ttjjdƒ||tjjddƒ||tjjddƒ||tjjddƒ||tjjddƒ|tjjgƒtjjt d    ¡d
d ||tjjddƒ||tjjddƒ||tjjddƒ||tjjddƒtj g¡tjjt d    ¡d
d tjtjfD]V}|jt d ¡dd |jt d ¡dd |jt d¡dd |jt d    ¡dd qdS)Nc_s|||ŽdSr>r©r9Úargsr
rrrÚokÒsz+TestUfunc.test_reduce_zero_axis.<locals>.okc_stt|f|ž|ŽdSr>)rrÂrrrrÚerrÕsz,TestUfunc.test_reduce_zero_axis.<locals>.errc
Ssp||t ||f¡dd||t ||f¡dd||t |d|d|f¡dd||t |d||df¡dd||t ||d|df¡dd||t |d||df¡dd||t |d|d|d|d|df¡dd||t d    ||f¡d
d||t d    ||f¡dd||t |d    |f¡dd||t d    ||f¡dd||t d    ||f¡dddS) Nrr]rrr„rRrS)rrrr4rÙ)rrÔ)ÚexpectÚfuncr¯rrrrÚtØs"""""ÿþz*TestUfunc.test_reduce_zero_axis.<locals>.térrœrr])rr)rr)rr)rrrÛÚidentityrrÔr"rá)r%rrrrrrrÚtest_reduce_zero_axisÄs* zTestUfunc.test_reduce_zero_axiscCs€tjdddgtd}tttj|dƒdddgƒtttj|d|d    d
d „}tt||dƒttj|d|d d t|dddgƒdS)NrrrSr5gš™™™™™ñ?gÍÌÌÌÌÌ@gÍÌÌÌÌÌ@gffffff@rÐcSs ||7}dSr>r)rÖr×rrrÚ add_inplacesz0TestUfunc.test_safe_casting.<locals>.add_inplacerÍ©rÑrÎr])rrVr#rr    r"rr!)r%rÖr"rrrÚtest_safe_castingsÿzTestUfunc.test_safe_castingc    CsÈtjdddgdd}tjdddgdd}tjdtjd}t |||¡}tjdddgtjd}t||ƒt ||¡}t||ƒtj|| tj¡|d}t||ƒt    t
ƒt |t d¡¡W5QRXdS)    NrrrÚi8r5rSr]rÐ) rrVrJrˆÚrationalr‰rrsÚuint16rr!)r%rÖr×rhr¦ÚtargetrrrÚtest_ufunc_custom_outs
 
 
 
zTestUfunc.test_ufunc_custom_outc
CsÂtjddd dd¡}tjddd dd¡}t |dd…dd…f|¡t|tjdd    ddgd
dd d
gd dd d gddd dggddƒt d¡}t |d¡t|dƒt |ddg¡t|dƒdS)Nr7Úlr5r]r»rSržrrr’é róérTr,r6r4)rr“r^Ú opflag_testsZ inplace_addrrVrÕrrrÚtest_operand_flags4s
 
ÿÿ
 
zTestUfunc.test_operand_flagscCsdddlmm}tjdgdd}tjdgdd}| ||¡}t|tjdgddƒtt|j    ƒdS)NrrŽzu8,u8,u8r5)rr]r)
Znumpy.core._struct_ufunc_testsr_Z_struct_ufunc_testsrrVZ add_tripletrrÚ RuntimeErrorZ register_fail)r%Z struct_ufuncrÖr×r¦rrrÚtest_struct_ufuncAs  zTestUfunc.test_struct_ufunccCs¢tjt dd¡t dd¡t dd¡gtjd}tjt dd¡t dd¡t dd¡gtjd}t ||¡}tjt d¡t dd¡t dd¡gtjd}t||ƒdS)NrrrSr]r5)rrVrˆr&Ztest_add_rationalsr)r%rÖr×r¦rrrrÚtest_custom_ufuncKs.
 
 
þü
 
 
þü 
 
þüzTestUfunc.test_custom_ufuncc    Cs6ttƒ$tjt d¡dtjtdfdW5QRXdS)NrrÚ)rr!rÚmultiplyrˆr&r#r$rrrÚtest_custom_ufunc_forced_sig_s
 
ÿz&TestUfunc.test_custom_ufunc_forced_sigcsLG‡fdd„dƒ‰t d¡ˆdƒtˆjdkˆjƒtˆjdkˆjƒdS)Ncs@eZdZdZdZdZdd„Zdd„Z‡fdd„Z‡fd    d
„Z    d S) z1TestUfunc.test_custom_array_like.<locals>.MyThingéèrcSs
||_dSr>©r¼)r%r¼rrrÚ__init__msz:TestUfunc.test_custom_array_like.<locals>.MyThing.__init__cSs
|jdS©Nrr5r$rrrÚ__len__psz9TestUfunc.test_custom_array_like.<locals>.MyThing.__len__csJˆjd7_t|tƒs|f}t|ƒ|jkr4tdƒ‚ˆ|jt|ƒd…ƒS)NrZboo)Ú getitem_countrÚtuplerFÚndimÚ
IndexErrorr¼)r%rÌ©ÚMyThingrrÚ __getitem__ss 
z=TestUfunc.test_custom_array_like.<locals>.MyThing.__getitem__csˆjd7_|SrA)Ú
rmul_countrÒr=rrÚ__rmul__|sz:TestUfunc.test_custom_array_like.<locals>.MyThing.__rmul__N)
r/r0r1Z__array_priority__r@r9r6r8r?rArr=rrr>gs     r>r‘r¥rr)rrnrr@r9r$rr=rÚtest_custom_array_likeesz TestUfunc.test_custom_array_likecCsêt d¡}tj |dddgd¡t|dddddddd    d
d g
ƒt d¡}t d d d g¡}tj |dddg|¡t|ddd ddddd    d
d g
ƒt d ¡ dd¡}t d d d gdddgdddgg¡}tj |tdƒdddgf|¡t|dddgdddgdddggƒt d¡ ddd¡}t d ddg¡}tj |tdƒtdƒdddgf|¡t|ddd gdddgdddggd ddgdddgd d!d"ggd#d$d%gd&d'd(gd)d*d+gggƒt d ¡ dd¡}t d d d gdddgdddgg¡}tj |dddgtdƒf|¡t|dddgd,dd-gd.d/dggƒt d¡ ddd¡}t d ddg¡}tj |tdƒdddgtdƒf|¡t|dddgd0dd1gd2d/dggd dd3gd4dd5gd6d7d8ggd#d9d:gd;d'd<gd=d>d?gggƒt d ¡ dd¡}t d ddg¡}tj |ddddgf|¡t|ddd gdddgdd    d
ggƒt d¡ ddd¡}t d ddg¡}tj |dddgdtdƒf|¡t|dddgdddgdd    d
ggd@ddAgddBdCgd dDdEggdFdGdHgd&dIdJgd)dKdLgggƒt d¡ ddd¡}t d ddg¡}tj |tdƒtdƒtdƒf|¡t|d ddMgdNdOdPgd2d/dggdQdRdSgdTdUdVgd6d7d8ggdFdGdHgdWdXdYgd=d>d?gggƒt d¡}tj |dddg¡t|ddddddZdd    d
d g
ƒt d¡}tj |d[d¡t|dƒt    t
tjj|ddƒt    t
tjj|gdƒt d¡}tj  |ddddgd\¡t|t ddd]d^dddd    d
d g
¡ƒt d¡}|ddk}tj  ||ddddd
g¡t|dddddddd    dd g
ƒtjdd_d`}tj  |dddg¡t|ddddddadd    d
d g
ƒt d¡}|dd…dfdd…dd…f}tj |ddgd¡t|t d¡ƒt dddgt db¡ ¡¡}t ddddgt dc¡ ¡¡}tj ||d¡t|dd
ddgƒtjdddgtd`}t    ttjj|ddgdƒt|tjdddgtd`ƒt    ttjjt d¡dgƒt dddg¡}tj |dgd¡tt dddg¡|ƒdS)eNr4rr‘rrr]rSrr’r5r»réÊéirŸr¡éÉéfi”éÍi_i4ròi‘i—éÐišéÓrTiéÖr6i éÙr,i£éÜéi¦éßrui©éâi“i•éÎéÏéËi]éjr+éÔiféséØi=r8réÝioržéáiFéÑicr,rór7éévéÛi@ééérŒi.égéÌi1éméÒi7épéÕi:éyéÞiCéûÿÿÿrrèi>é.Zu4r5lúÿrÌr9rÖ)rr“r"ÚatrrVr^rµrrrr<rÿrÖÚinvertrr+ròrIr!rÂÚmodfrÛ)r%rÖr×ÚindexÚorigÚvaluesrrrÚtest_inplace_fancy_indexing„sø
 
""$þþþøÿ ""$þþþøÿ " þþþøÿ "þþþøÿ
 
 
 
$
 
 z%TestUfunc.test_inplace_fancy_indexingcCs^t d¡}t d¡}tttjj|dg|ƒt ddgddggg¡}tttjjj    j|dgƒdS)Nr®rarrrrSr])
rrHrr!rˆrjrVÚlinalgÚ _umath_linalgršrÕrrrÚtest_at_not_none_signatures
 
 
z$TestUfunc.test_at_not_none_signaturec CsBtjj}tjdtd}tjd|jd}|d}t||ƒ|ƒt||dd|ƒt||dƒ|ƒt||ddd|ƒt||ddd|ƒt||ddƒ|ƒt||ddƒ|ƒt||dddd|ƒt||dd|d|ƒt||dd|ƒ|ƒt||dddƒ|ƒt||dddd    d
|ƒt||dddd ƒ| d |j¡ƒt||dddd    dƒ|ƒt||dddd    dd |ƒt||dddd    dd ƒ|ƒt||dddd    dd d|ƒt||dddd    d|ƒt||dddd    d|ƒt||dddd    d|ƒt||dddd    dd d|ƒt    t
|ƒt    t
||dddd    dd dƒ
t    t
||dƒt    t
||ddt    t
||ddd dt    t
||ddƒt    t
||ddt    t
||dddt    t
||dddƒt    t
||ddt    t
||dddt    t
||dddddt    t
||ddddt    t
||ddt    t
||dd dddt    t
||ddd dddt    t
||ddddddS)N)r‘rr5ràr‘rr]rÌrÐFr“TrArNrW)rSr+rÑr”)r+rÑr”)rÑr”)rÑr”rOrXrr)rSr+r”©r+rÑ©rÑr+)r”r+rÑ)rSr+r©r)r”rrÑ)rSr+r”rÑr)rSr+rÑr) rr"rrHr#r+rr^r¼rr!)r%r9rõÚoÚrrrrÚtest_reduce_argumentsst"ÿÿ
 ÿÿÿÿ ÿzTestUfunc.test_reduce_argumentscCstGdd„dtjƒ}t d¡ dd¡}|jdd ¡}| |¡}tjdd    d    d    gtd}tt     |||d
kk¡dƒdS) Nc@seZdZdd„ZdS)z,TestUfunc.test_structured_equal.<locals>.MyAc_st||ƒdd„|Dƒ|ŽS)Ncss|]}| tj¡VqdSr>)rìrrë)rÚinputrrrÚ    <genexpr>asÿzOTestUfunc.test_structured_equal.<locals>.MyA.__array_ufunc__.<locals>.<genexpr>)r^)r%rÚmethodÚinputsr
rrrÚ__array_ufunc__`s
ÿÿz<TestUfunc.test_structured_equal.<locals>.MyA.__array_ufunc__N)r/r0r1r~rrrrÚMyA_srç(@r]rSzf8,f8,f8r5TFr)
rrër“r^rìr¨rVrÄrrJ)r%rrÖÚraZmrar(rrrÚtest_structured_equal\s 
zTestUfunc.test_structured_equalcCsLt d¡}t d¡}t||kƒt||kƒt||k ƒt||k ƒdS)NrrÖ)rrVrrÕrrrÚtest_scalar_equaljs 
 
  zTestUfunc.test_scalar_equalcCs¶tjtjtjtjtjtjtjtjtj    tj
tj tj tj tjtjtjtjtjtjtjtjtjtjtjtjtjtjg}t d¡}d}t ddg¡}|D] }tt|||ƒtt|||ƒqdS)NÚ1rrôr )rrÿr"rîr2rrZ floor_divideZ bitwise_andZ
bitwise_orZ bitwise_xorZ
left_shiftZ right_shiftZfmaxZfminÚfmodÚhypotZ    logaddexpZ
logaddexp2rÛrûÚmodZgreaterZ greater_equalrùZ
less_equalrÖÚ    not_equalrVrr!)r%Z binary_funcsrÖr×rhr9rrrÚ test_NotImplemented_not_returnedtsDù    
z*TestUfunc.test_NotImplemented_not_returnedNcCs4tjdddgtd}||||d}|jtks0t‚dS)NTFr5rÚ)rrVrIr+rX)r%rr(rÖr[rrrÚ%test_logical_ufuncs_object_signatures‡sz/TestUfunc.test_logical_ufuncs_object_signaturesc    Cs8t dddg¡}t t¡||||dW5QRXdS)NTFrÚ)rrVr{rÜr!)r%rr(rÖrrrÚ+test_logical_ufuncs_mixed_object_signatures‘s z5TestUfunc.test_logical_ufuncs_mixed_object_signaturescCsâtjddd}t ddg¡}t|||ƒ|ddgdƒƒ| |¡dksHt‚tjdtjd}|ddgdƒ |j¡}t||||d|ƒtjd    tjd}|j||ddks¨t‚tjd
gd d}tjd    |jd}|j||dd ksÞt‚dS) Nó1ZV3r5rôr TrrÐrrSrÌr)    rrVrrrXrÔr…rsr+)r%rrÖrhrÑrrrrÚ$test_logical_ufuncs_support_anythingœsz.TestUfunc.test_logical_ufuncs_support_anythingc    CsVtjtdd|dgdgƒW5QRXtjtdd| dddg¡W5QRXdS)a·
        Logical ufuncs are normally well defined by working with the boolean
        equivalent, i.e. casting all inputs to bools should work.
 
        However, casting strings to bools is *currently* weird, because it
        actually uses `bool(int(str))`.  Thus we explicitly reject strings.
        This test should succeed (and can probably just be removed) as soon as
        string to bool casts are well defined in NumPy.
        zcontain a loop with signaturerðr„Ú3Ú2Ú0N)r{rÜr!r)r%rrrrÚ!test_logical_ufuncs_reject_string°s z+TestUfunc.test_logical_ufuncs_reject_stringc    CsJt d¡}t ddg¡}| ¡}t t¡||||ddW5QRXdS)Nr„rôr rr#)rrVrr{rÜr!)r%rrÖrhrÑrrrÚ"test_logical_ufuncs_out_cast_checkÁs
 
 z,TestUfunc.test_logical_ufuncs_out_cast_checkcCsxtjddd}tjddd}tj |¡tj |¡ks8t‚ttj |¡tj |¡ƒttj |dg¡tj |dg¡ƒdS)Nr4z>i8r5z<i8r)rr“r"rrXrrár–)r%Zarr_beZarr_lerrrÚ$test_reducelike_byteorder_resolutionËsÿz.TestUfunc.test_reducelike_byteorder_resolutioncCs²tjdtjd}tjdtjd}tjj||ddks8t‚d|dd…<tjj||ddks\t‚tj    dd    tj
d}tjdtj d}tjdtj d}tjj||tj d
||ks®t‚dS) Nr4r5rrÐrr4r;r‘iÿÿÿru) rrHrýrÔr'r"rrXr2r7rær÷)r%rZrÑr[Z
single_resrrrÚtest_reducelike_out_promotesÖs z&TestUfunc.test_reducelike_out_promotescCsÎtjddd}tjd|j ¡d}tj |¡}tjj||dt||ƒtjd|j ¡d}tj |ddg¡}tjj|ddg|dt||ƒtj|j    |j ¡d}tj 
|¡}tjj
||dt||ƒdS)    NrrÊr5rrÐrrr) rrHrJr+ròr"rrr–r¼rá)r%rZrÑrrrrÚ+test_reducelike_output_needs_identical_castís 
 
 z5TestUfunc.test_reducelike_output_needs_identical_castcCsðtjdtjd ddd¡}|dd…dd    d…dd
…f dd d ¡}tjd tjd dd¡}|ddd …dd…f}| ¡}tjj|| ¡d d}tjj||d d}t||ƒt|ddd…f|ddd…fƒt|ddd…f|ddd…fƒdS)NiØr5r’r,r5r]rrr+r‘rrr7rrS)    rr“ryr^r†rr"rr)r%r:Zy_baser;Z y_base_copyZr0Zr1rrrÚtest_reduce_noncontig_output    s&
"z&TestUfunc.test_reduce_noncontig_outputÚ    with_castc    Cs‚t d¡}t d¡}|r$| tj¡}tjtddtjj|ddg|dW5QRXtjtddtjj    ||dW5QRXdS)Nr‘rSz (shape|size)rðrrÐ)
rr“rsrnr{rÜrÂr"r–rá)r%r—rZrÑrrrÚ/test_reduceat_and_accumulate_out_shape_mismatch    s
 
  z9TestUfunc.test_reduceat_and_accumulate_out_shape_mismatchÚ    out_shaperAr¶©rr)rrSr”Úf_reducec    Csˆt d¡ dd¡}t ||j¡}||d|d}||jkr^ttƒ||d||dW5QRXn&||d||d}t||kƒt    ||ƒdS)Nr€r]rSrr•©rSrÑr”)
rr“r^rJr+r¼rrÂrr)r%r›r”r™rÖrÑZ correct_outrrrrÚ"test_reduce_wrong_dimension_output&    s
 
 z,TestUfunc.test_reduce_wrong_dimension_outputc    Cs²t d¡}t d¡}t d¡}tjj|d|ddtjj|d|dd…dfddttƒtjj|d|ddW5QRXttƒ&tjj|d|dd…dfddW5QRXdS)    N)rr4rš)rSrržTrœrF)rrHrJr"rrrÂ)r%rÖZ out_correctZ out_incorrectrrrÚ+test_reduce_output_does_not_broadcast_input9    s
 
 
 
 
z5TestUfunc.test_reduce_output_does_not_broadcast_inputcCsvGdd„dtjƒ}t d¡}tjjt d¡|d| |¡}tjjt d¡|d|ksZt‚ttj |¡ƒ|ksrt‚dS)Nc@s eZdZdS)z7TestUfunc.test_reduce_output_subclass_ok.<locals>.MyArrNrérrrrÚMyArrG    srŸrr‘rÐ)    rrërJr"rrHrìrXrr)r%rŸrÑrrrÚtest_reduce_output_subclass_okF    s 
 
z(TestUfunc.test_reduce_output_subclass_okcCstdtjjkƒdS)NÚ
)rrŽZinner1d_no_docrvr$rrrÚtest_no_doc_stringP    szTestUfunc.test_no_doc_stringcCs"t ttjd¡}| d¡st‚dS)Nzloop of ufunc does not support)r{rÜr!rrÃrñrX)r%rtrrrÚtest_invalid_argsT    szTestUfunc.test_invalid_argsÚnatcCs,zt |¡rt‚Wntk
r&YnXdSr>)rr%rXr!©r%r¤rrrÚtest_nat_is_not_finiteZ    sz TestUfunc.test_nat_is_not_finitecCs,zt |¡st‚Wntk
r&YnXdSr>)rr$rXr!r¥rrrÚtest_nat_is_nana    szTestUfunc.test_nat_is_nancCs,zt |¡rt‚Wntk
r&YnXdSr>)rÚisinfrXr!r¥rrrÚtest_nat_is_not_infh    szTestUfunc.test_nat_is_not_inf)r/r0r1r‹rrr™ršr¡r²r¥r¨r«r­r±r³r·r¼r¾r¿rÀrÃrÄrÅrÆrÈrØrÝrÞr{r|r}rërrúrýrrrrr"rÃrr)r0Úskipifr rIrMrUr[r_rirkrJrHrnrprsrwr{r‹r’rœr£r¤r§r«r­r®r¬rÅrÆrÐr×rÝrârãrärårærçrírðrôrõr÷rúrürrþrrrrr
r rVrr rrrr!r$r)r.r0r1r3rBrprsryr‚rƒr‰rÏrÎrIrŠrFrÄr‹rr‘r’r“r”r•r–r˜rrûrržr r¢r£Z
datetime64Z timedelta64r¦r§r©rrrrr½sx     T
 
 
    
                     þ
þ
 
 
      
W
" + ýü
     g,O
G6
    
     .
 
  þþ  þÿ
A 
    @
 
ÿÿÿ ÿÿÿ ÿ
ÿ
ÿ
 
ÿ
 """rrcCs(g|] }ttt|ƒtjƒrtt|ƒ‘qSr©rr^rrrÉrrrrp    sÿc    
CsÌ|jD]À}d|ksd|krq| d¡\}}dd„|Dƒ}tjddt d¡||Ž}W5QRXt|tƒr²t|ƒ}t|ƒt|ƒksˆt‚t    ||ƒD]\}}|j
t  
|¡ks’t‚q’q|j
t  
|¡kst‚qd    S)
    Check all ufuncs that the correct type is returned. Avoid
    object and boolean types since many operations are not defined for
    for them.
 
    Choose the shape so even dot and matmul will succeed
    rUú?ú->cSsg|]}t d|¡‘qS)r¥)rrH©rrrrrr    sz$test_ufunc_types.<locals>.<listcomp>Tr<r>N) rÚsplitrBrCÚfilterwarningsrr:rFrXr•r+r)    rÚtypÚinprÑrr[ZoutsrxrrrrÚtest_ufunc_typesp    s
 
 
 
r³cCs(g|] }ttt|ƒtjƒrtt|ƒ‘qSrr«rÉrrrr‹    sÿc
Cs"|jD]}ttdƒt|ƒ@ƒr"q| d¡\}}dd„|Dƒ}dd„|Dƒ}|D]}tddƒ|_qP|D]}tddƒ|_qftjdd     t d
¡||Ž}||Ž}W5QRXt    |ƒdkrÂ|f}|f}t
||ƒD]N\}    }
|    j } t   | t j¡rt  | ¡j} d | } t||| | d qÌt|    |
ƒqÌqd S)zs
    Check that contiguous and non-contiguous calls to ufuncs
    have the same results for values in range(9)
    zO?mMr­cSsg|]}t d|¡‘qS)r©rrJr®rrrr™    sz,test_ufunc_noncontiguous.<locals>.<listcomp>cSs"g|]}t d|¡ddd…‘qS)r,NrSr´r®rrrrš    srr’Tr<r>r)rrN)rrÜÚsetr¯rƒZflatrBrCr°rFr•r+rZ
issubdtypeZfloatingrZepsr
r)rr±r²rÑZargs_cZargs_nrÖZres_cZres_nZc_arZn_arräZres_epsZtolrrrÚtest_ufunc_noncontiguous‹    s0 
  r¶cCs\t dgd¡ d¡}t |¡s"t‚|jdkr6||ƒn"|jdkrP||| ¡ƒntdƒ‚dS)Nl€r%rÊrrzufunc with more than 2 inputs)rrVrìr$rXr    rrÂ)rr×rrrÚtest_ufunc_warn_with_nan³    s
 
 
r·zPython lacks refcountsr2c    Csöd}tj|gttjdƒdg|gtdtjƒtd}tjt|ƒtjd}t     |¡}t
  t ¡tj |||ddW5QRX|t     |¡ks”t‚|ddks¤t‚t
  t ¡tj |||tjdd    W5QRX|t     |¡ksât‚|ddksòt‚dS)
Né{rËÚstringr5rÍr#ržr)rÑr+rÎ)rrVr#ÚBUFSIZErIrHrFrÚsysÚ getrefcountr{rÜrÂr"rX)ÚvaluerZrÑÚcountrrrÚtest_ufunc_out_casterrorsÄ    s$ÿþþ
   r¿Ú
bad_offsetrËc    Cs`d}tj|g|dg|gtdtjƒtd}t t¡tj||tj    ddW5QRXdS)Nr¸r¹rËr5rÍrþ)
rrVr#rºrIr{rÜrÂr"r©rÀr½rZrrrÚtest_ufunc_input_casterrorsä    s ÿþþ rÂr1c
Csvd}t |g|tjg|gtdtjƒ¡}tjdd0t t¡tj    ||tj
ddW5QRXW5QRXdS)Nr¸rËrlrvrÍrþ) rrVÚnanr#rºrpr{rÜÚFloatingPointErrorr"rrÁrrrÚ$test_ufunc_input_floatingpoint_errorï    s ÿþrÅc    Cs6tjtddtjt dd¡dddW5QRXdS)Nzcast ufunc 'add' input 0rðrzi,irSzdd->drÚ)r{rÜr!rr"rVrrrrÚtest_trivial_loop_invalid_castû    sÿrÆÚoffsetrc    Cs¤d}tj|g|dg|gtdtjƒtd}tjdtjd}t |¡}tj    t
ddtj j |tj|dW5QRX|t |¡ksŒt ‚|d    ||ks t ‚dS)
Nr¸r¹rËr5ržzinvalid literalrðrtr)rrVr#rºrIrr»r¼r{rÜrÂr"rrX)rÇr½rZrÑr¾rrrÚtest_reduce_casterrors
s ÿþþ
rÈr|cCstj |dg¡Sr7)rr"r–rírrrrc!
rdrcr–rîcCstj |dg¡S)Nr)rÚlogrjrírrrrc"
rdrjc
Cs t tjdtj g¡}tjdd(tjtdd||ƒW5QRXW5QRXt tjdtj g¡}tjdd$t t¡||ƒW5QRXW5QRXdS)NrÚwarnrmz invalid valuerðrl)    rrVr rpr{rÒrErÜrÄ)r|rZrrrÚtest_ufunc_methods_floaterrors
s rËcCs8|dkr dSt |j¡sdS|jjdkr4t |j¡SdS)NrFrhT)rÚsignbitrKr+ÚkindrL)r½rrrÚ_check_neg_zero0
s   rÎr+ZAllFloatcCslt |¡}|jdkr&| tddƒ¡}n
| d¡}t |¡}t |¡}t||ƒsTt‚||7}t|ƒsht‚dS)Nrhç€)rr+rÍrrrWrVrÎrX)r+Úneg_zerorZZarr2rrrÚtest_addition_negative_zero9
s
 
 
 
 
rÑÚ use_initialTFcCs¼t |¡}|jdkr&| tddƒ¡}n
| d¡}i}|rB||d<n
t d¡tddƒD]`}tj|g||d}tj    |f|Ž}|dksˆ|r–t
|ƒs¶t ‚qVt  |j ¡r¦t ‚t  |j¡rVt ‚qVdS)NrhrÏrOz1-0. propagation in sum currently requires initialré–r5)rr+rÍrrrWr{ZxfailrƒrVr-rÎrXrÌrKrL)r+rÒrÐr
rÌrZr[rrrÚ"test_addition_reduce_negative_zeroJ
s
 
 
 
 
 rÔc
@sÒeZdZdd„Zdd„Zdd„Zej de     
d¡e     
d¡fd    e     
d¡e     
d
¡fe     
d¡d    e     
d
¡fd g¡d d „ƒZ dd„Zdd„Z ejj eedƒ dddd„ƒZej ddddg¡dd„ƒZdd„Zdd„Zd    S) ÚTestLowlevelAPIAccessc    Cs¾t d¡}t d¡}t d¡}tj ||df¡}||||fksBt‚tjj||dfdd}||||fksjt‚tj |tdf¡}||||fksŽt‚t t¡tjj||dfddW5QRXdS)NrÏÚf4rÊ)NNrÖrÚrr)    rr+r"Úresolve_dtypesrXr#r{rÜr!)r%rÏrÖrÊrxrrrÚtest_resolve_dtypes_basicf
s"
 
 
ÿÿ z/TestLowlevelAPIAccess.test_resolve_dtypes_basicc    Csjt d¡}tj ||df¡}|||t t¡fks4t‚t d¡}t t¡tj ||df¡W5QRXdS)NÚS0Z10i)    rr+rÖr×rÄrXr{rÜÚNotImplementedError)r%rÙrxZdtsrrrÚtest_weird_dtypes|
s 
 
 z'TestLowlevelAPIAccess.test_weird_dtypesc    Cs:t d¡}t t¡tjj|||fddW5QRXdS)NrÏT©Z    reduction)rr+r{rÜrÚr"r×)r%rÏrrrÚtest_resolve_dtypes_reductionˆ
s
 z3TestLowlevelAPIAccess.test_resolve_dtypes_reductionÚdtypesrÌNr9)rÏrÏNc    Cs&t t¡tj |¡W5QRXdSr>)r{rÜr!rr"r×)r%rÞrrrÚtest_resolve_dtypes_errors
s z0TestLowlevelAPIAccess.test_resolve_dtypes_errorscCs@t d¡}t d¡}tjjd|dfdd}||||fks<t‚dS)NÚi2ÚlongTrÜ)rr+r"r×rX)r%ràZlong_r[rrrrÝ–
s
 
c    CsXt d¡}t t¡tj d||f¡W5QRXt t¡tj d¡W5QRXdS)Nrà)NNrÏ)rr+r{rÜr!r"r×r()r%ràrrrÚ$test_resolve_dtypes_reduction_errors
s
 
  z:TestLowlevelAPIAccess.test_resolve_dtypes_reduction_errorsÚ    pythonapiz2`ctypes.pythonapi` required for capsule unpacking.r2c
    s4t tjd¡}t tjd¡}t tjd¡}t tjtj|||tj¡‰G‡fdd„dtjƒ}t     d¡}tj
  ||f¡\}}|||fksˆt ‚tj
  |¡tjtjj_tj t |¡t d¡¡}t |t |¡¡j}tjd|d}    | |j||    jj|    jjƒ|    jj||    jjd    |    jjd    ƒ|j¡t|    tjd|d ƒdS)
Nrrcs6eZdZd”fdejfdejfdejfdejfgZdS)z;TestLowlevelAPIAccess.test_loop_access.<locals>.call_info_tÚ strided_loopÚcontextÚauxdataZrequires_pyapiZno_floatingpoint_errorsN)r/r0r1ÚctÚc_void_pÚc_byteÚ_fields_r©Zstrided_loop_trrÚ call_info_t°
s ûrìrÏsnumpy_1.24_ufunc_call_infor4r5r)rçÚARRAYÚc_char_pÚ    c_ssize_tÚ    CFUNCTYPEÚc_intrèÚ    Structurerr+rrÚ_resolve_dtypes_and_contextrXÚ_get_strided_looprãZPyCapsule_GetPointerÚrestypeÚ    py_objectÚcastÚPOINTERÚcontentsr“räråÚctypesÚdatar¼rfrær)
r%Zdata_tZdim_tZ    strides_trìrÏräZ call_info_objÚ    call_inforZrrërÚtest_loop_access¦
s>ÿ    
  þûz&TestLowlevelAPIAccess.test_loop_accessrfrrŽ)rrc    CsLt d¡}tj ||f¡\}}tjtddtjj||dW5QRXdS)NrÏzfixed_strides.*tuple.*or Nonerð)Z fixed_strides)rr+rrrór{rÜr!rô)r%rfrÏrärürrrÚ)test__get_strided_loop_errors_bad_stridesÒ
s
z?TestLowlevelAPIAccess.test__get_strided_loop_errors_bad_stridesc    Csœt d¡}tj ||f¡\}}tjtddtj d¡W5QRXtjtddtj     |¡W5QRXtj |¡t t¡tj |¡W5QRXdS)NrÏZ    PyCapsulerðznot the capsule!z.*incompatible context)
rr+rrrór{rÜrÂrôr!r")r%rÏrärürrrÚ+test__get_strided_loop_errors_bad_call_infoÚ
s
  zATestLowlevelAPIAccess.test__get_strided_loop_errors_bad_call_infocCsPtjdtjd}d|dd<d|dd<t |¡}t|dd|ddƒdS)N)ii•r5rréiž)rrÔrwrŒr)r%rr'rrrÚtest_long_arraysé
s
 
z&TestLowlevelAPIAccess.test_long_arrays)r/r0r1rØrÛrÝr{r|r}rr+rßrârªÚhasattrrçrýrþrÿrrrrrrÕe
s( ü
    ÿ
*
rÕ)IrBrr»rúrçr{rÚnumpyrZnumpy.core._umath_testsr_Z _umath_testsrŽZnumpy.linalg._umath_linalgrqrrr™Znumpy.core._operand_flag_testsZ_operand_flag_testsr-Znumpy.core._rational_testsrˆZ numpy.testingrrrrrrr    r
r r r Znumpy.testing._private.utilsrZ numpy.compatrr`Ú__dict__roZ UNARY_UFUNCSrrr2r€rr|r}Údirr³Z_no_nep50_warningr¶ÚsignrÖr·rªr¿r#rºrÂrÅrÆrÈr"rárrËrÎZ    typecodesrÑrÔrÕrrrrÚ<module>s 4  D
 %
 
 
 
 
ÿ  þÿ